From b3ef6db3e623d42999a7b0017c6054d82f6a3591 Mon Sep 17 00:00:00 2001 From: saltykox Date: Mon, 21 Feb 2022 12:29:04 +0300 Subject: [PATCH 01/15] Added input parameters validation and tests for deep-object-reid --- .../validation_helper.py | 19 + ote_sdk/ote_sdk/utils/argument_checks.py | 349 ++++++++++++++++++ 2 files changed, 368 insertions(+) create mode 100644 ote_sdk/ote_sdk/tests/parameters_validation/validation_helper.py create mode 100644 ote_sdk/ote_sdk/utils/argument_checks.py diff --git a/ote_sdk/ote_sdk/tests/parameters_validation/validation_helper.py b/ote_sdk/ote_sdk/tests/parameters_validation/validation_helper.py new file mode 100644 index 00000000000..97570de287e --- /dev/null +++ b/ote_sdk/ote_sdk/tests/parameters_validation/validation_helper.py @@ -0,0 +1,19 @@ +""" +Common functions for input parameters validation tests +""" + +import pytest + + +def check_value_error_exception_raised( + correct_parameters: dict, unexpected_values: list, class_or_function +) -> None: + """ + Function checks that ValueError exception is raised when unexpected type values are specified as parameters for + methods or functions + """ + for key, value in unexpected_values: + incorrect_parameters_dict = dict(correct_parameters) + incorrect_parameters_dict[key] = value + with pytest.raises(ValueError): + class_or_function(**incorrect_parameters_dict) diff --git a/ote_sdk/ote_sdk/utils/argument_checks.py b/ote_sdk/ote_sdk/utils/argument_checks.py new file mode 100644 index 00000000000..b0c2a139ffd --- /dev/null +++ b/ote_sdk/ote_sdk/utils/argument_checks.py @@ -0,0 +1,349 @@ +""" +Utils for checking functions and methods arguments +""" + +# Copyright (C) 2021-2022 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 +# + +import typing +from abc import ABC, abstractmethod +from os.path import exists + +import yaml +from numpy import floating +from omegaconf import DictConfig + + +def raise_value_error_if_parameter_has_unexpected_type( + parameter, parameter_name, expected_type +): + """Function raises ValueError exception if parameter has unexpected type""" + if expected_type == float: + expected_type = (int, float, floating) + if not isinstance(parameter, expected_type): + parameter_type = type(parameter) + raise ValueError( + f"Unexpected type of '{parameter_name}' parameter, expected: {expected_type}, actual: {parameter_type}" + ) + + +def check_nested_elements_type(iterable, parameter_name, expected_type): + """Function raises ValueError exception if one of elements in collection has unexpected type""" + for element in iterable: + check_parameter_type( + parameter=element, + parameter_name=f"nested {parameter_name}", + expected_type=expected_type, + ) + + +def check_dictionary_keys_values_type( + parameter, parameter_name, expected_key_class, expected_value_class +): + """Function raises ValueError exception if dictionary key or value has unexpected type""" + for key, value in parameter.items(): + check_parameter_type( + parameter=key, + parameter_name=f"key in {parameter_name}", + expected_type=expected_key_class, + ) + check_parameter_type( + parameter=value, + parameter_name=f"value in {parameter_name}", + expected_type=expected_value_class, + ) + + +def check_parameter_type(parameter, parameter_name, expected_type): + """Function extracts nested expected types and raises ValueError exception if parameter has unexpected type""" + # pylint: disable=W0212 + if expected_type == typing.Any: + return + if not isinstance(expected_type, typing._GenericAlias): # type: ignore + raise_value_error_if_parameter_has_unexpected_type( + parameter=parameter, + parameter_name=parameter_name, + expected_type=expected_type, + ) + return + origin_class = expected_type.__dict__.get("__origin__") + # Checking origin class + raise_value_error_if_parameter_has_unexpected_type( + parameter=parameter, + parameter_name=parameter_name, + expected_type=origin_class, + ) + # Checking nested elements + args = expected_type.__dict__.get("__args__") + if issubclass(origin_class, typing.Sequence) and args: + if len(args) != 1: + raise TypeError( + "length of nested expected types for Sequence should be equal to 1" + ) + check_nested_elements_type( + iterable=parameter, + parameter_name=parameter_name, + expected_type=args, + ) + elif origin_class == dict and args: + if len(args) != 2: + raise TypeError( + "length of nested expected types for dictionary should be equal to 2" + ) + key, value = args + check_dictionary_keys_values_type( + parameter=parameter, + parameter_name=parameter_name, + expected_key_class=key, + expected_value_class=value, + ) + + +class BaseInputArgumentChecker(ABC): + """Abstract class to check input arguments""" + + @abstractmethod + def check(self): + """Abstract method to check input arguments""" + raise NotImplementedError("The check is not implemented") + + +def check_input_param_type(*checks: BaseInputArgumentChecker): + """Function to apply methods on checks according to their type""" + for param_check in checks: + if not isinstance(param_check, BaseInputArgumentChecker): + raise TypeError(f"Wrong parameter of check_input_param: {param_check}") + param_check.check() + + +class RequiredParamTypeCheck(BaseInputArgumentChecker): + """Class to check required input parameters""" + + def __init__(self, parameter, parameter_name, expected_type): + self.parameter = parameter + self.parameter_name = parameter_name + self.expected_type = expected_type + + def check(self): + """Method raises ValueError exception if required parameter has unexpected type""" + check_parameter_type( + parameter=self.parameter, + parameter_name=self.parameter_name, + expected_type=self.expected_type, + ) + + +class OptionalParamTypeCheck(RequiredParamTypeCheck): + """Class to check optional input parameters""" + + def check(self): + """Method checks if optional parameter exists and raises ValueError exception if it has unexpected type""" + if self.parameter is not None: + check_parameter_type( + parameter=self.parameter, + parameter_name=self.parameter_name, + expected_type=self.expected_type, + ) + + +def check_file_extension( + file_path: str, file_path_name: str, expected_extensions: list +): + """Function raises ValueError exception if file has unexpected extension""" + file_extension = file_path.split(".")[-1].lower() + if file_extension not in expected_extensions: + raise ValueError( + f"Unexpected extension of {file_path_name} file. expected: {expected_extensions} actual: {file_extension}" + ) + + +def check_that_null_character_absents_in_string(parameter: str, parameter_name: str): + """Function raises ValueError exception if null character: '\0' is specified in path to file""" + if "\0" in parameter: + raise ValueError(f"\\0 is specified in {parameter_name}: {parameter}") + + +def check_that_file_exists(file_path: str, file_path_name: str): + """Function raises ValueError exception if file not exists""" + if not exists(file_path): + raise ValueError( + f"File {file_path} specified in '{file_path_name}' parameter not exists" + ) + + +def check_that_parameter_is_not_empty(parameter, parameter_name): + """Function raises ValueError if parameter is empty""" + if not parameter: + raise ValueError(f"parameter {parameter_name} is empty") + + +def check_that_all_characters_printable(parameter, parameter_name, allow_crlf=False): + """Function raises ValueError if one of string-parameter characters is not printable""" + if not allow_crlf: + all_characters_printable = all(c.isprintable() for c in parameter) + else: + all_characters_printable = all( + (c.isprintable() or c == "\n" or c == "\r") for c in parameter + ) + if not all_characters_printable: + raise ValueError( + fr"parameter {parameter_name} has not printable symbols: {parameter}" + ) + + +class InputConfigCheck(BaseInputArgumentChecker): + """Class to check input config_parameters""" + + def __init__(self, parameter): + self.parameter = parameter + + def check(self): + """Method raises ValueError exception if "input_config" parameter is not equal to expected""" + parameter_name = "input_config" + raise_value_error_if_parameter_has_unexpected_type( + parameter=self.parameter, + parameter_name=parameter_name, + expected_type=(str, DictConfig, dict), + ) + check_that_parameter_is_not_empty( + parameter=self.parameter, parameter_name=parameter_name + ) + if isinstance(self.parameter, str): + check_that_null_character_absents_in_string( + parameter=self.parameter, parameter_name=parameter_name + ) + # yaml-format string is specified + if isinstance(yaml.safe_load(self.parameter), dict): + check_that_all_characters_printable( + parameter=self.parameter, + parameter_name=parameter_name, + allow_crlf=True, + ) + # Path to file is specified + else: + check_file_extension( + file_path=self.parameter, + file_path_name=parameter_name, + expected_extensions=["yaml"], + ) + check_that_all_characters_printable( + parameter=self.parameter, parameter_name=parameter_name + ) + check_that_file_exists( + file_path=self.parameter, file_path_name=parameter_name + ) + + +class FilePathCheck(BaseInputArgumentChecker): + """Class to check file_path-like parameters""" + + def __init__(self, parameter, parameter_name, expected_file_extension): + self.parameter = parameter + self.parameter_name = parameter_name + self.expected_file_extensions = expected_file_extension + + def check(self): + """Method raises ValueError exception if file path parameter is not equal to expected""" + raise_value_error_if_parameter_has_unexpected_type( + parameter=self.parameter, + parameter_name=self.parameter_name, + expected_type=str, + ) + check_that_parameter_is_not_empty( + parameter=self.parameter, parameter_name=self.parameter_name + ) + check_file_extension( + file_path=self.parameter, + file_path_name=self.parameter_name, + expected_extensions=self.expected_file_extensions, + ) + check_that_null_character_absents_in_string( + parameter=self.parameter, parameter_name=self.parameter_name + ) + check_that_all_characters_printable( + parameter=self.parameter, parameter_name=self.parameter_name + ) + check_that_file_exists( + file_path=self.parameter, file_path_name=self.parameter_name + ) + + +def check_is_parameter_like_dataset(parameter, parameter_name): + """Function raises ValueError exception if parameter does not have __len__, __getitem__ and get_subset attributes of + DataSet-type object""" + for expected_attribute in ("__len__", "__getitem__", "get_subset"): + if not hasattr(parameter, expected_attribute): + parameter_type = type(parameter) + raise ValueError( + f"parameter {parameter_name} has type {parameter_type} which does not have expected " + f"'{expected_attribute}' dataset attribute" + ) + + +class DatasetParamTypeCheck(BaseInputArgumentChecker): + """Class to check DataSet-like parameters""" + + def __init__(self, parameter, parameter_name): + self.parameter = parameter + self.parameter_name = parameter_name + + def check(self): + """Method raises ValueError exception if parameter is not equal to DataSet""" + check_is_parameter_like_dataset( + parameter=self.parameter, parameter_name=self.parameter_name + ) + + +class DirectoryPathCheck(BaseInputArgumentChecker): + """Class to check directory_path-like parameters""" + + def __init__(self, parameter, parameter_name): + self.parameter = parameter + self.parameter_name = parameter_name + + def check(self): + """Method raises ValueError exception if file path parameter is not equal to expected""" + raise_value_error_if_parameter_has_unexpected_type( + parameter=self.parameter, + parameter_name=self.parameter_name, + expected_type=str, + ) + check_that_parameter_is_not_empty( + parameter=self.parameter, parameter_name=self.parameter_name + ) + check_that_null_character_absents_in_string( + parameter=self.parameter, parameter_name=self.parameter_name + ) + check_that_all_characters_printable( + parameter=self.parameter, parameter_name=self.parameter_name + ) + + +class OptionalFilePathCheck(BaseInputArgumentChecker): + """Class to check optional file_path-like parameters""" + + def __init__(self, parameter, parameter_name, expected_file_extension): + self.parameter = parameter + self.parameter_name = parameter_name + self.expected_file_extensions = expected_file_extension + + def check(self): + """Method raises ValueError exception if file path parameter is not equal to expected""" + if self.parameter is not None: + FilePathCheck( + self.parameter, self.parameter_name, self.expected_file_extensions + ).check() + + +class OptionalDirectoryPathCheck(BaseInputArgumentChecker): + """Class to check optional directory_path-like parameters""" + + def __init__(self, parameter, parameter_name): + self.parameter = parameter + self.parameter_name = parameter_name + + def check(self): + """Method raises ValueError exception if file path parameter is not equal to expected""" + if self.parameter is not None: + DirectoryPathCheck(self.parameter, self.parameter_name).check() From 91efc23f428dba3613c92885ada76a70a6358c5e Mon Sep 17 00:00:00 2001 From: saltykox Date: Tue, 22 Feb 2022 09:59:58 +0300 Subject: [PATCH 02/15] changed checks of ClassificationDatasetAdapter due to nested directories with files, checking class name for parameters classes --- ote_sdk/ote_sdk/utils/argument_checks.py | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/ote_sdk/ote_sdk/utils/argument_checks.py b/ote_sdk/ote_sdk/utils/argument_checks.py index b0c2a139ffd..7e17a2075e8 100644 --- a/ote_sdk/ote_sdk/utils/argument_checks.py +++ b/ote_sdk/ote_sdk/utils/argument_checks.py @@ -347,3 +347,25 @@ def check(self): """Method raises ValueError exception if file path parameter is not equal to expected""" if self.parameter is not None: DirectoryPathCheck(self.parameter, self.parameter_name).check() + + +class ClassNameCheck(BaseInputArgumentChecker): + """Class to check class name of input parameters""" + + def __init__(self, parameter, parameter_name, expected_type): + self.parameter = parameter + self.parameter_name = parameter_name + self.expected_type = expected_type + + def check(self): + """Method raises ValueError exception if required parameter has unexpected type""" + if self.parameter is not None: + if isinstance(self.parameter, type): + parameter_type = self.parameter.__name__ + else: + parameter_type = type(self.parameter).__name__.split(".")[-1] + if parameter_type != self.expected_type: + raise ValueError( + f"Unexpected type of '{self.parameter_name}' parameter, expected: " + f"{self.expected_type}, actual: {parameter_type}" + ) From 0e8ae697788dbce7b09562dd75abce6041bc450c Mon Sep 17 00:00:00 2001 From: saltykox Date: Mon, 28 Feb 2022 09:47:35 +0300 Subject: [PATCH 03/15] passing initialized parameters classes instances to tests, added check_exists flag to DirectoryPathCheck classes --- ote_sdk/ote_sdk/utils/argument_checks.py | 50 +++++------------------- 1 file changed, 9 insertions(+), 41 deletions(-) diff --git a/ote_sdk/ote_sdk/utils/argument_checks.py b/ote_sdk/ote_sdk/utils/argument_checks.py index 7e17a2075e8..d14e5027923 100644 --- a/ote_sdk/ote_sdk/utils/argument_checks.py +++ b/ote_sdk/ote_sdk/utils/argument_checks.py @@ -298,9 +298,10 @@ def check(self): class DirectoryPathCheck(BaseInputArgumentChecker): """Class to check directory_path-like parameters""" - def __init__(self, parameter, parameter_name): + def __init__(self, parameter, parameter_name, check_exists=False): self.parameter = parameter self.parameter_name = parameter_name + self.check_exists = check_exists def check(self): """Method raises ValueError exception if file path parameter is not equal to expected""" @@ -318,54 +319,21 @@ def check(self): check_that_all_characters_printable( parameter=self.parameter, parameter_name=self.parameter_name ) - - -class OptionalFilePathCheck(BaseInputArgumentChecker): - """Class to check optional file_path-like parameters""" - - def __init__(self, parameter, parameter_name, expected_file_extension): - self.parameter = parameter - self.parameter_name = parameter_name - self.expected_file_extensions = expected_file_extension - - def check(self): - """Method raises ValueError exception if file path parameter is not equal to expected""" - if self.parameter is not None: - FilePathCheck( - self.parameter, self.parameter_name, self.expected_file_extensions - ).check() + if self.check_exists: + check_that_file_exists(self.parameter, self.parameter_name) class OptionalDirectoryPathCheck(BaseInputArgumentChecker): """Class to check optional directory_path-like parameters""" - def __init__(self, parameter, parameter_name): + def __init__(self, parameter, parameter_name, check_exists=False): self.parameter = parameter self.parameter_name = parameter_name + self.check_exists = check_exists def check(self): """Method raises ValueError exception if file path parameter is not equal to expected""" if self.parameter is not None: - DirectoryPathCheck(self.parameter, self.parameter_name).check() - - -class ClassNameCheck(BaseInputArgumentChecker): - """Class to check class name of input parameters""" - - def __init__(self, parameter, parameter_name, expected_type): - self.parameter = parameter - self.parameter_name = parameter_name - self.expected_type = expected_type - - def check(self): - """Method raises ValueError exception if required parameter has unexpected type""" - if self.parameter is not None: - if isinstance(self.parameter, type): - parameter_type = self.parameter.__name__ - else: - parameter_type = type(self.parameter).__name__.split(".")[-1] - if parameter_type != self.expected_type: - raise ValueError( - f"Unexpected type of '{self.parameter_name}' parameter, expected: " - f"{self.expected_type}, actual: {parameter_type}" - ) + DirectoryPathCheck( + self.parameter, self.parameter_name, self.check_exists + ).check() From 6a3c68d548458eef1b1d9d0d56efbaf219fbe56a Mon Sep 17 00:00:00 2001 From: saltykox Date: Tue, 22 Mar 2022 15:31:32 +0300 Subject: [PATCH 04/15] moved tests to training_extensions --- .../sc_input_params_validation/__init__.py | 2 + .../sc_input_params_validation/helpers.py | 71 +++ ..._classification_input_params_validation.py | 173 ++++++ ..._inference_task_input_params_validation.py | 151 ++++++ ...st_ote_monitors_input_params_validation.py | 142 +++++ ...t_ote_nncf_task_input_params_validation.py | 137 +++++ ...e_openvino_task_input_params_validation.py | 356 +++++++++++++ ..._ote_train_task_input_params_validation.py | 101 ++++ .../test_ote_utils_input_params_validation.py | 497 ++++++++++++++++++ 9 files changed, 1630 insertions(+) create mode 100644 external/deep-object-reid/tests/sc_input_params_validation/__init__.py create mode 100644 external/deep-object-reid/tests/sc_input_params_validation/helpers.py create mode 100644 external/deep-object-reid/tests/sc_input_params_validation/test_ote_classification_input_params_validation.py create mode 100644 external/deep-object-reid/tests/sc_input_params_validation/test_ote_inference_task_input_params_validation.py create mode 100644 external/deep-object-reid/tests/sc_input_params_validation/test_ote_monitors_input_params_validation.py create mode 100644 external/deep-object-reid/tests/sc_input_params_validation/test_ote_nncf_task_input_params_validation.py create mode 100644 external/deep-object-reid/tests/sc_input_params_validation/test_ote_openvino_task_input_params_validation.py create mode 100644 external/deep-object-reid/tests/sc_input_params_validation/test_ote_train_task_input_params_validation.py create mode 100644 external/deep-object-reid/tests/sc_input_params_validation/test_ote_utils_input_params_validation.py diff --git a/external/deep-object-reid/tests/sc_input_params_validation/__init__.py b/external/deep-object-reid/tests/sc_input_params_validation/__init__.py new file mode 100644 index 00000000000..a09dff4a5fa --- /dev/null +++ b/external/deep-object-reid/tests/sc_input_params_validation/__init__.py @@ -0,0 +1,2 @@ +""" """ +from .helpers import load_test_dataset diff --git a/external/deep-object-reid/tests/sc_input_params_validation/helpers.py b/external/deep-object-reid/tests/sc_input_params_validation/helpers.py new file mode 100644 index 00000000000..fca3de701ac --- /dev/null +++ b/external/deep-object-reid/tests/sc_input_params_validation/helpers.py @@ -0,0 +1,71 @@ +""" +OTE parameters validation tests helpers +""" + +import numpy as np + +from ote_sdk.entities.annotation import ( + Annotation, + AnnotationSceneEntity, + AnnotationSceneKind, +) +from ote_sdk.entities.dataset_item import DatasetItemEntity +from ote_sdk.entities.datasets import DatasetEntity +from ote_sdk.entities.id import ID +from ote_sdk.entities.image import Image +from ote_sdk.entities.label import Domain, LabelEntity +from ote_sdk.entities.scored_label import ScoredLabel +from ote_sdk.entities.shapes.rectangle import Rectangle +from ote_sdk.entities.subset import Subset + + +def load_test_dataset(): + """Helper to create test dataset""" + def gen_image(resolution, x1, y1, x2, y2): + w, h = resolution + image = np.full([h, w, 3], fill_value=255, dtype=np.uint8) + image[int(y1 * h): int(y2 * h), int(x1 * w): int(x2 * w), :] = np.array( + [0, 128, 128], dtype=np.uint8 + )[None, None, :] + return image, Rectangle(x1=x1, y1=y1, x2=x2, y2=y2) + + images = [ + gen_image((640, 480), 0.0, 0.0, 0.5, 0.5), + gen_image((640, 480), 0.5, 0.0, 1.0, 0.5), + gen_image((640, 480), 0.0, 0.5, 0.5, 1.0), + gen_image((640, 480), 0.5, 0.5, 1.0, 1.0), + ] + labels = [LabelEntity(name="rect", domain=Domain.DETECTION, id=ID("0"))] + + def get_image(i, subset): + image, bbox = images[i] + return DatasetItemEntity( + media=Image(data=image), + annotation_scene=AnnotationSceneEntity( + annotations=[Annotation(bbox, labels=[ScoredLabel(label=labels[0])])], + kind=AnnotationSceneKind.ANNOTATION, + ), + subset=subset, + ) + + items = [ + get_image(0, Subset.TRAINING), + get_image(1, Subset.TRAINING), + get_image(2, Subset.TRAINING), + get_image(3, Subset.TRAINING), + get_image(0, Subset.TRAINING), + get_image(1, Subset.TRAINING), + get_image(2, Subset.TRAINING), + get_image(3, Subset.TRAINING), + get_image(0, Subset.TRAINING), + get_image(1, Subset.TRAINING), + get_image(0, Subset.VALIDATION), + get_image(1, Subset.VALIDATION), + get_image(2, Subset.VALIDATION), + get_image(3, Subset.VALIDATION), + get_image(0, Subset.TESTING), + get_image(1, Subset.TESTING), + get_image(2, Subset.TESTING), + get_image(3, Subset.TESTING), + ] + return DatasetEntity(items), labels diff --git a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_classification_input_params_validation.py b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_classification_input_params_validation.py new file mode 100644 index 00000000000..6a210fc5ddd --- /dev/null +++ b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_classification_input_params_validation.py @@ -0,0 +1,173 @@ +import numpy as np +import pytest +from ote_sdk.test_suite.e2e_test_system import e2e_pytest_unit +from ote_sdk.tests.parameters_validation.validation_helper import ( + check_value_error_exception_raised, +) + +from torchreid.integration.sc.model_wrappers.classification import ( + OteClassification, + sigmoid_numpy, + softmax_numpy, + get_multiclass_predictions, + get_multilabel_predictions, +) + + +class MockClassification(OteClassification): + def __init__(self): + pass + + +class TestClassificationFunctionsParamsValidation: + @e2e_pytest_unit + def test_sigmoid_numpy_params_validation(self): + """ + Description: + Check "sigmoid_numpy" function input parameters validation + + Input data: + "x" non-nd.array parameter + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "sigmoid_numpy" function + """ + with pytest.raises(ValueError): + sigmoid_numpy(x="unexpected string") # type: ignore + + @e2e_pytest_unit + def test_softmax_numpy_params_validation(self): + """ + Description: + Check "softmax_numpy" function input parameters validation + + Input data: + "x" non-nd.array parameter + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "softmax_numpy" function + """ + with pytest.raises(ValueError): + softmax_numpy(x="unexpected string") # type: ignore + + @e2e_pytest_unit + def test_get_multiclass_predictions_params_validation(self): + """ + Description: + Check "get_multiclass_predictions" function input parameters validation + + Input data: + "get_multiclass_predictions" unexpected type parameters + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "get_multiclass_predictions" function + """ + correct_values_dict = { + "logits": np.random.randint(low=0, high=255, size=(10, 16, 3)), + "activate": True, + } + unexpected_str = "unexpected string" + unexpected_values = [ + # Unexpected string is specified as "logits" parameter + ("logits", unexpected_str), + # Unexpected string is specified as "activate" parameter + ("activate", unexpected_str), + ] + + check_value_error_exception_raised( + correct_parameters=correct_values_dict, + unexpected_values=unexpected_values, + class_or_function=get_multiclass_predictions, + ) + + @e2e_pytest_unit + def test_get_multilabel_predictions_params_validation(self): + """ + Description: + Check "get_multilabel_predictions" function input parameters validation + + Input data: + "get_multilabel_predictions" unexpected type parameters + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "get_multilabel_predictions" function + """ + correct_values_dict = { + "logits": np.random.randint(low=0, high=255, size=(10, 16, 3)), + "activate": True, + } + unexpected_str = "unexpected string" + unexpected_values = [ + # Unexpected string is specified as "logits" parameter + ("logits", unexpected_str), + # Unexpected string is specified as "pos_thr" parameter + ("pos_thr", unexpected_str), + # Unexpected string is specified as "activate" parameter + ("activate", unexpected_str), + ] + + check_value_error_exception_raised( + correct_parameters=correct_values_dict, + unexpected_values=unexpected_values, + class_or_function=get_multilabel_predictions, + ) + + +class TestOteClassificationParamsValidation: + @e2e_pytest_unit + def test_ote_classification_preprocess_params_validation(self): + """ + Description: + Check OteClassification object "preprocess" method input parameters validation + + Input data: + OteClassification object. "image" non-ndarray object + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "preprocess" method + """ + classification = MockClassification() + with pytest.raises(ValueError): + classification.preprocess(image="unexpected string") # type: ignore + + @e2e_pytest_unit + def test_ote_classification_postprocess_params_validation(self): + """ + Description: + Check OteClassification object "postprocess" method input parameters validation + + Input data: + OteClassification object. "postprocess" method unexpected type parameters + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "postprocess" method + """ + classification = MockClassification() + correct_values_dict = { + "outputs": {"output_1": np.random.rand(2, 2)}, + "metadata": {"metadata_1": "some_data"}, + } + unexpected_int = 1 + unexpected_values = [ + # Unexpected integer is specified as "outputs" parameter + ("outputs", unexpected_int), + # Unexpected integer is specified as "outputs" dictionary key + ("outputs", {unexpected_int: np.random.rand(2, 2)}), + # Unexpected integer is specified as "outputs" dictionary value + ("outputs", {"output_1": unexpected_int}), + # Unexpected integer is specified as "metadata" parameter + ("metadata", unexpected_int), + # Unexpected integer is specified as "metadata" dictionary key + ("metadata", {unexpected_int: "some_data"}), + ] + check_value_error_exception_raised( + correct_parameters=correct_values_dict, + unexpected_values=unexpected_values, + class_or_function=classification.postprocess, + ) diff --git a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_inference_task_input_params_validation.py b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_inference_task_input_params_validation.py new file mode 100644 index 00000000000..614db7ea27b --- /dev/null +++ b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_inference_task_input_params_validation.py @@ -0,0 +1,151 @@ +import pytest +from ote_sdk.configuration.configurable_parameters import ConfigurableParameters +from ote_sdk.entities.datasets import DatasetEntity +from ote_sdk.entities.inference_parameters import InferenceParameters +from ote_sdk.entities.label_schema import LabelSchemaEntity +from ote_sdk.entities.model import ModelConfiguration, ModelEntity +from ote_sdk.entities.resultset import ResultSetEntity +from ote_sdk.test_suite.e2e_test_system import e2e_pytest_unit +from ote_sdk.tests.parameters_validation.validation_helper import ( + check_value_error_exception_raised, +) +from ote_sdk.usecases.tasks.interfaces.export_interface import ExportType + +from torchreid.integration.sc.inference_task import OTEClassificationInferenceTask + + +class MockClassificationInferenceTask(OTEClassificationInferenceTask): + def __init__(self): + pass + + +class TestOTEClassificationInferenceTaskInputParamsValidation: + @staticmethod + def model(): + model_configuration = ModelConfiguration( + configurable_parameters=ConfigurableParameters( + header="header", description="description" + ), + label_schema=LabelSchemaEntity(), + ) + return ModelEntity( + train_dataset=DatasetEntity(), configuration=model_configuration + ) + + @e2e_pytest_unit + def test_ote_classification_inference_task_init_params_validation(self): + """ + Description: + Check OTEClassificationInferenceTask object initialization parameters validation + + Input data: + OTEClassificationInferenceTask object initialization parameters with unexpected type + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + OTEClassificationInferenceTask initialization parameter + """ + with pytest.raises(ValueError): + OTEClassificationInferenceTask(task_environment="unexpected string") # type: ignore + + @e2e_pytest_unit + def test_ote_classification_inference_task_infer_params_validation(self): + """ + Description: + Check OTEClassificationInferenceTask object "infer" method input parameters validation + + Input data: + OTEClassificationInferenceTask object. "infer" method unexpected-type input parameters + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "infer" method + """ + task = MockClassificationInferenceTask() + correct_values_dict = { + "dataset": DatasetEntity(), + "inference_parameters": InferenceParameters(), + } + unexpected_str = "unexpected string" + unexpected_values = [ + # Unexpected string is specified as "dataset" parameter + ("dataset", unexpected_str), + # Unexpected string is specified as "inference_parameters" parameter + ("inference_parameters", unexpected_str), + ] + + check_value_error_exception_raised( + correct_parameters=correct_values_dict, + unexpected_values=unexpected_values, + class_or_function=task.infer, + ) + + @e2e_pytest_unit + def test_ote_classification_inference_task_evaluate_params_validation(self): + """ + Description: + Check OTEClassificationInferenceTask object "evaluate" method input parameters validation + + Input data: + OTEClassificationInferenceTask object. "evaluate" method unexpected-type input parameters + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "evaluate" method + """ + task = MockClassificationInferenceTask() + model = self.model() + result_set = ResultSetEntity( + model=model, + ground_truth_dataset=DatasetEntity(), + prediction_dataset=DatasetEntity(), + ) + correct_values_dict = { + "output_resultset": result_set, + "evaluation_metric": "metric", + } + unexpected_int = 1 + unexpected_values = [ + # Unexpected integer is specified as "output_resultset" parameter + ("output_resultset", unexpected_int), + # Unexpected integer is specified as "evaluation_metric" parameter + ("evaluation_metric", unexpected_int), + ] + + check_value_error_exception_raised( + correct_parameters=correct_values_dict, + unexpected_values=unexpected_values, + class_or_function=task.evaluate, + ) + + @e2e_pytest_unit + def test_ote_classification_inference_task_export_params_validation(self): + """ + Description: + Check OTEClassificationInferenceTask object "export" method input parameters validation + + Input data: + OTEClassificationInferenceTask object. "export" method unexpected-type input parameters + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "export" method + """ + task = MockClassificationInferenceTask() + model = self.model() + correct_values_dict = { + "export_type": ExportType.OPENVINO, + "output_model": model, + } + unexpected_str = "unexpected string" + unexpected_values = [ + # Unexpected string is specified as "export_type" parameter + ("export_type", unexpected_str), + # Unexpected string is specified as "output_model" parameter + ("output_model", unexpected_str), + ] + check_value_error_exception_raised( + correct_parameters=correct_values_dict, + unexpected_values=unexpected_values, + class_or_function=task.export, + ) diff --git a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_monitors_input_params_validation.py b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_monitors_input_params_validation.py new file mode 100644 index 00000000000..67d59f6921d --- /dev/null +++ b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_monitors_input_params_validation.py @@ -0,0 +1,142 @@ +import pytest +from ote_sdk.test_suite.e2e_test_system import e2e_pytest_unit +from ote_sdk.tests.parameters_validation.validation_helper import ( + check_value_error_exception_raised, +) + +from torchreid.integration.sc.monitors import MetricsMonitor, DefaultMetricsMonitor + + +class TestMetricsMonitorParamsValidation: + @e2e_pytest_unit + def test_metrics_monitor_init_params_validation(self): + """ + Description: + Check MetricsMonitor object initialization parameters validation + + Input data: + "log_dir" unexpected type object + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + MetricsMonitor object initialization parameter + """ + for unexpected_value in [ + # Unexpected integer is specified as "path" parameter + 1, + # Empty string is specified as "path" parameter + "", + # Path Null character is specified in "path" parameter + "./null\0char", + # Path with non-printable character is specified as "path" parameter + "./non\nprintable", + ]: + with pytest.raises(ValueError): + MetricsMonitor(log_dir=unexpected_value) + + @e2e_pytest_unit + def test_metrics_monitor_add_scalar_params_validation(self): + """ + Description: + Check MetricsMonitor object "add_scalar" method input parameters validation + + Input data: + MetricsMonitor object. "add_scalar" method unexpected-type input parameters + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "add_scalar" method + """ + monitor = MetricsMonitor("./") + correct_values_dict = { + "capture": "some capture", + "value": 0.1, + "timestamp": 1, + } + unexpected_dict = {"unexpected": "dictionary"} + unexpected_values = [ + # Unexpected dictionary is specified as "capture" parameter + ("capture", unexpected_dict), + # Unexpected dictionary is specified as "value" parameter + ("value", unexpected_dict), + # Unexpected dictionary is specified as "timestamp" parameter + ("timestamp", unexpected_dict), + ] + + check_value_error_exception_raised( + correct_parameters=correct_values_dict, + unexpected_values=unexpected_values, + class_or_function=monitor.add_scalar, + ) + + +class TestDefaultMetricsMonitorParamsValidation: + @e2e_pytest_unit + def test_default_metrics_monitor_add_scalar_params_validation(self): + """ + Description: + Check DefaultMetricsMonitor object "add_scalar" method input parameters validation + + Input data: + DefaultMetricsMonitor object, "add_scalar" method unexpected-type input parameters + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "add_scalar" method + """ + monitor = DefaultMetricsMonitor() + correct_values_dict = { + "capture": "some capture", + "value": 0.1, + "timestamp": 1, + } + unexpected_dict = {"unexpected": "dictionary"} + unexpected_values = [ + # Unexpected dictionary is specified as "capture" parameter + ("capture", unexpected_dict), + # Unexpected dictionary is specified as "value" parameter + ("value", unexpected_dict), + # Unexpected dictionary is specified as "timestamp" parameter + ("timestamp", unexpected_dict), + ] + + check_value_error_exception_raised( + correct_parameters=correct_values_dict, + unexpected_values=unexpected_values, + class_or_function=monitor.add_scalar, + ) + + @e2e_pytest_unit + def test_default_metrics_monitor_get_metric_values_params_validation(self): + """ + Description: + Check DefaultMetricsMonitor object "get_metric_values" method input parameters validation + + Input data: + DefaultMetricsMonitor object, "capture" unexpected-type value + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "get_metric_values" method + """ + monitor = DefaultMetricsMonitor() + with pytest.raises(ValueError): + monitor.get_metric_values(capture=1) # type: ignore + + @e2e_pytest_unit + def test_default_metrics_monitor_get_metric_timestamps_params_validation(self): + """ + Description: + Check DefaultMetricsMonitor object "get_metric_timestamps" method input parameters + validation + + Input data: + DefaultMetricsMonitor object, "capture" unexpected-type value + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "get_metric_timestamps" method + """ + monitor = DefaultMetricsMonitor() + with pytest.raises(ValueError): + monitor.get_metric_timestamps(capture=1) # type: ignore diff --git a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_nncf_task_input_params_validation.py b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_nncf_task_input_params_validation.py new file mode 100644 index 00000000000..f8e22243726 --- /dev/null +++ b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_nncf_task_input_params_validation.py @@ -0,0 +1,137 @@ +# Copyright (C) 2021-2022 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 +# + +import pytest +from ote_sdk.configuration.configurable_parameters import ConfigurableParameters +from ote_sdk.entities.datasets import DatasetEntity +from ote_sdk.entities.label_schema import LabelSchemaEntity +from ote_sdk.entities.model import ModelConfiguration, ModelEntity +from ote_sdk.test_suite.e2e_test_system import e2e_pytest_unit +from ote_sdk.tests.parameters_validation.validation_helper import ( + check_value_error_exception_raised, +) +from ote_sdk.usecases.tasks.interfaces.export_interface import ExportType +from ote_sdk.usecases.tasks.interfaces.optimization_interface import OptimizationType + +from torchreid.integration.sc.nncf_task import OTEClassificationNNCFTask + + +class MockNNCFTask(OTEClassificationNNCFTask): + def __init__(self): + pass + + +class TestNNCFTaskInputParamsValidation: + @staticmethod + def model(): + model_configuration = ModelConfiguration( + configurable_parameters=ConfigurableParameters( + header="header", description="description" + ), + label_schema=LabelSchemaEntity(), + ) + return ModelEntity( + train_dataset=DatasetEntity(), configuration=model_configuration + ) + + @e2e_pytest_unit + def test_ote_nncf_classification_task_init_params_validation(self): + """ + Description: + Check OTEClassificationNNCFTask object initialization parameters validation + + Input data: + OTEClassificationNNCFTask object initialization parameters with unexpected type + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + OTEClassificationNNCFTask object initialization parameter + """ + with pytest.raises(ValueError): + OTEClassificationNNCFTask(task_environment="unexpected string") # type: ignore + + @e2e_pytest_unit + def test_ote_nncf_classification_task_optimize_params_validation(self): + """ + Description: + Check OTEClassificationNNCFTask object "optimize" method input parameters validation + + Input data: + OTEClassificationNNCFTask object. "optimize" method unexpected-type input parameters + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "optimize" method + """ + task = MockNNCFTask() + correct_values_dict = { + "optimization_type": OptimizationType.NNCF, + "dataset": DatasetEntity(), + "output_model": self.model(), + "optimization_parameters": None, + } + unexpected_str = "unexpected string" + unexpected_values = [ + # Unexpected string is specified as "optimization_type" parameter + ("optimization_type", unexpected_str), + # Unexpected string is specified as "dataset" parameter + ("dataset", unexpected_str), + # Unexpected string is specified as "output_model" parameter + ("output_model", unexpected_str), + # Unexpected string is specified as "optimization_parameters" parameter + ("optimization_parameters", unexpected_str), + ] + check_value_error_exception_raised( + correct_parameters=correct_values_dict, + unexpected_values=unexpected_values, + class_or_function=task.optimize, + ) + + @e2e_pytest_unit + def test_ote_nncf_classification_task_save_model_params_validation(self): + """ + Description: + Check OTEClassificationNNCFTask object "save_model" method input parameters validation + + Input data: + OTEClassificationNNCFTask object, "output_model" non-ModelEntity object + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "save_model" method + """ + task = MockNNCFTask() + with pytest.raises(ValueError): + task.save_model(output_model="unexpected string") # type: ignore + + @e2e_pytest_unit + def test_ote_nncf_classification_task_export_params_validation(self): + """ + Description: + Check OTEClassificationNNCFTask object "export" method input parameters validation + + Input data: + OTEClassificationNNCFTask object. "export" method unexpected-type input parameters + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "export" method + """ + task = MockNNCFTask() + correct_values_dict = { + "export_type": ExportType.OPENVINO, + "output_model": self.model(), + } + unexpected_str = "unexpected string" + unexpected_values = [ + # Unexpected string is specified as "export_type" parameter + ("export_type", unexpected_str), + # Unexpected string is specified as "output_model" parameter + ("output_model", unexpected_str), + ] + check_value_error_exception_raised( + correct_parameters=correct_values_dict, + unexpected_values=unexpected_values, + class_or_function=task.export, + ) diff --git a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_openvino_task_input_params_validation.py b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_openvino_task_input_params_validation.py new file mode 100644 index 00000000000..07eb3bf367f --- /dev/null +++ b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_openvino_task_input_params_validation.py @@ -0,0 +1,356 @@ +# Copyright (C) 2021-2022 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 +# + +import numpy as np +import pytest +from ote_sdk.configuration.configurable_parameters import ConfigurableParameters +from ote_sdk.entities.datasets import DatasetEntity +from ote_sdk.entities.label_schema import LabelSchemaEntity +from ote_sdk.entities.model import ModelConfiguration, ModelEntity +from ote_sdk.entities.resultset import ResultSetEntity +from ote_sdk.test_suite.e2e_test_system import e2e_pytest_unit +from ote_sdk.tests.parameters_validation.validation_helper import ( + check_value_error_exception_raised, +) +from ote_sdk.usecases.tasks.interfaces.optimization_interface import OptimizationType + +from torchreid.integration.sc.openvino_task import ( + OpenVINOClassificationInferencer, + OTEOpenVinoDataLoader, + OpenVINOClassificationTask, +) +from torchreid.integration.sc.parameters import OTEClassificationParameters + + +def model(): + model_configuration = ModelConfiguration( + configurable_parameters=ConfigurableParameters( + header="header", description="description" + ), + label_schema=LabelSchemaEntity(), + ) + return ModelEntity( + train_dataset=DatasetEntity(), configuration=model_configuration + ) + + +class MockOpenVinoTask(OpenVINOClassificationTask): + def __init__(self): + pass + + +class MockOpenVinoInferencer(OpenVINOClassificationInferencer): + def __init__(self): + pass + + +class TestOpenVINODetectionTaskInputParamsValidation: + @e2e_pytest_unit + def test_openvino_task_init_params_validation(self): + """ + Description: + Check OpenVINOClassificationTask object initialization parameters validation + + Input data: + "task_environment" non-TaskEnvironment object + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + OpenVINOClassificationTask object initialization parameter + """ + with pytest.raises(ValueError): + OpenVINOClassificationTask(task_environment="unexpected string") # type: ignore + + @e2e_pytest_unit + def test_openvino_task_infer_params_validation(self): + """ + Description: + Check OpenVINOClassificationTask object "infer" method input parameters validation + + Input data: + OpenVINOClassificationTask object. "infer" method unexpected-type input parameters + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "infer" method + """ + task = MockOpenVinoTask() + correct_values_dict = {"dataset": DatasetEntity()} + unexpected_str = "unexpected string" + unexpected_values = [ + # Unexpected string is specified as "dataset" parameter + ("dataset", unexpected_str), + # Unexpected string is specified as "inference_parameters" parameter + ("inference_parameters", unexpected_str), + ] + check_value_error_exception_raised( + correct_parameters=correct_values_dict, + unexpected_values=unexpected_values, + class_or_function=task.infer, + ) + + @e2e_pytest_unit + def test_openvino_task_evaluate_params_validation(self): + """ + Description: + Check OpenVINOClassificationTask object "evaluate" method input parameters validation + + Input data: + OpenVINOClassificationTask object. "evaluate" method unexpected-type input parameters + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "evaluate" method + """ + result_set = ResultSetEntity( + model=model(), + ground_truth_dataset=DatasetEntity(), + prediction_dataset=DatasetEntity(), + ) + task = MockOpenVinoTask() + correct_values_dict = {"output_result_set": result_set} + unexpected_int = 1 + unexpected_values = [ + # Unexpected integer is specified as "output_result_set" parameter + ("output_result_set", unexpected_int), + # Unexpected integer is specified as "evaluation_metric" parameter + ("evaluation_metric", unexpected_int), + ] + check_value_error_exception_raised( + correct_parameters=correct_values_dict, + unexpected_values=unexpected_values, + class_or_function=task.evaluate, + ) + + @e2e_pytest_unit + def test_openvino_task_deploy_params_validation(self): + """ + Description: + Check OpenVINOClassificationTask object "deploy" method input parameters validation + + Input data: + OpenVINOClassificationTask object. "output_model" non-ModelEntity object + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "deploy" method + """ + task = MockOpenVinoTask() + with pytest.raises(ValueError): + task.deploy(output_model="unexpected string") # type: ignore + + @e2e_pytest_unit + def test_openvino_task_optimize_params_validation(self): + """ + Description: + Check OpenVINOClassificationTask object "optimize" method input parameters validation + + Input data: + OpenVINOClassificationTask object. "optimize" method unexpected-type input parameters + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "optimize" method + """ + task = MockOpenVinoTask() + correct_values_dict = { + "optimization_type": OptimizationType.POT, + "dataset": DatasetEntity(), + "output_model": model(), + "optimization_parameters": None, + } + unexpected_str = "unexpected string" + unexpected_values = [ + # Unexpected string is specified as "optimization_type" parameter + ("optimization_type", unexpected_str), + # Unexpected string is specified as "dataset" parameter + ("dataset", unexpected_str), + # Unexpected string is specified as "output_model" parameter + ("output_model", unexpected_str), + # Unexpected string is specified as "optimization_parameters" parameter + ("optimization_parameters", unexpected_str), + ] + check_value_error_exception_raised( + correct_parameters=correct_values_dict, + unexpected_values=unexpected_values, + class_or_function=task.optimize, + ) + + +class TestOTEOpenVinoDataLoaderInputParamsValidation: + @e2e_pytest_unit + def test_openvino_data_loader_init_params_validation(self): + """ + Description: + Check OTEOpenVinoDataLoader object initialization parameters validation + + Input data: + OTEOpenVinoDataLoader object initialization parameters with unexpected type + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + OTEOpenVinoDataLoader object initialization parameter + """ + classification_inferencer = MockOpenVinoInferencer() + correct_values_dict = { + "dataset": DatasetEntity(), + "inferencer": classification_inferencer, + } + unexpected_str = "unexpected string" + unexpected_values = [ + # Unexpected string is specified as "dataset" parameter + ("dataset", unexpected_str), + # Unexpected string is specified as "inferencer" parameter + ("inferencer", unexpected_str), + ] + + check_value_error_exception_raised( + correct_parameters=correct_values_dict, + unexpected_values=unexpected_values, + class_or_function=OTEOpenVinoDataLoader, + ) + + @e2e_pytest_unit + def test_openvino_data_loader_getitem_input_params_validation(self): + """ + Description: + Check OTEOpenVinoDataLoader object "__getitem__" method input parameters validation + + Input data: + OTEOpenVinoDataLoader object. "__getitem__" method unexpected-type input parameters + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "__getitem__" method + """ + classification_inferencer = MockOpenVinoInferencer() + data_loader = OTEOpenVinoDataLoader( + dataset=DatasetEntity(), inferencer=classification_inferencer + ) + with pytest.raises(ValueError): + data_loader.__getitem__(index="unexpected string") # type: ignore + + +class TestOpenVINOClassificationInferencerInputParamsValidation: + @e2e_pytest_unit + def test_openvino_classification_inferencer_init_params_validation(self): + """ + Description: + Check OpenVINOClassificationInferencer object initialization parameters validation + + Input data: + OpenVINOClassificationInferencer object initialization parameters + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + OpenVINOClassificationInferencer object initialization parameter + """ + correct_values_dict = { + "hparams": OTEClassificationParameters("header"), + "label_schema": LabelSchemaEntity(), + "model_file": "some model data", + } + unexpected_float = 1.1 + unexpected_values = [ + # Unexpected float is specified as "hparams" parameter + ("hparams", unexpected_float), + # Unexpected float is specified as "label_schema" parameter + ("label_schema", unexpected_float), + # Unexpected float is specified as "model_file" parameter + ("model_file", unexpected_float), + # Unexpected float is specified as "weight_file" parameter + ("weight_file", unexpected_float), + # Unexpected float is specified as "device" parameter + ("device", unexpected_float), + # Unexpected float is specified as "num_requests" parameter + ("num_requests", unexpected_float), + ] + check_value_error_exception_raised( + correct_parameters=correct_values_dict, + unexpected_values=unexpected_values, + class_or_function=OpenVINOClassificationInferencer, + ) + + @e2e_pytest_unit + def test_openvino_classification_inferencer_pre_process_params_validation(self): + """ + Description: + Check OpenVINOClassificationInferencer object "pre_process" method input parameters + validation + + Input data: + OpenVINOClassificationInferencer object, "image" non-ndarray object + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "pre_process" method + """ + inferencer = MockOpenVinoInferencer() + with pytest.raises(ValueError): + inferencer.pre_process(image="unexpected string") # type: ignore + + @e2e_pytest_unit + def test_openvino_classification_inferencer_post_process_params_validation(self): + """ + Description: + Check OpenVINOClassificationInferencer object "post_process" method input parameters + validation + + Input data: + OpenVINOClassificationInferencer object, "post_process" method unexpected-type input + parameters + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "post_process" method + """ + inferencer = MockOpenVinoInferencer() + correct_values_dict = { + "prediction": {"prediction_1": np.random.rand(2, 2)}, + "metadata": {"metadata_1": "some_data"}, + } + unexpected_int = 1 + unexpected_values = [ + # Unexpected integer is specified as "prediction" parameter + ("prediction", unexpected_int), + # Unexpected integer is specified as "prediction" dictionary key + ("prediction", {unexpected_int: np.random.rand(2, 2)}), + # Unexpected integer is specified as "prediction" dictionary value + ("prediction", {"prediction_1": unexpected_int}), + # Unexpected integer is specified as "metadata" parameter + ("metadata", unexpected_int), + # Unexpected integer is specified as "metadata" dictionary key + ("metadata", {unexpected_int: "some_data"}), + ] + check_value_error_exception_raised( + correct_parameters=correct_values_dict, + unexpected_values=unexpected_values, + class_or_function=inferencer.post_process, + ) + + @e2e_pytest_unit + def test_openvino_classification_inferencer_forward_params_validation(self): + """ + Description: + Check OpenVINOClassificationInferencer object "forward" method input parameters validation + + Input data: + OpenVINOClassificationInferencer object, "forward" method unexpected-type input parameters + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "forward" method + """ + inferencer = MockOpenVinoInferencer() + unexpected_int = 1 + for unexpected_value in [ + # Unexpected integer is specified as "inputs" parameter + unexpected_int, + # Unexpected integer is specified as "inputs" dictionary key + {unexpected_int: np.random.rand(2, 2)}, + # Unexpected integer is specified as "inputs" dictionary value + {"input_1": unexpected_int}, + ]: + with pytest.raises(ValueError): + inferencer.forward(inputs=unexpected_value) # type: ignore diff --git a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_train_task_input_params_validation.py b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_train_task_input_params_validation.py new file mode 100644 index 00000000000..8360a1a1bb0 --- /dev/null +++ b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_train_task_input_params_validation.py @@ -0,0 +1,101 @@ +# Copyright (C) 2021-2022 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 +# + +import pytest +from ote_sdk.configuration.configurable_parameters import ConfigurableParameters +from ote_sdk.entities.datasets import DatasetEntity +from ote_sdk.entities.label_schema import LabelSchemaEntity +from ote_sdk.entities.model import ModelConfiguration, ModelEntity +from ote_sdk.test_suite.e2e_test_system import e2e_pytest_unit +from ote_sdk.tests.parameters_validation.validation_helper import ( + check_value_error_exception_raised, +) + +from torchreid.integration.sc.train_task import OTEClassificationTrainingTask + + +class MockClassificationTrainingTask(OTEClassificationTrainingTask): + def __init__(self): + pass + + +class TestOTEClassificationTrainingTaskInputParamsValidation: + @staticmethod + def model(): + model_configuration = ModelConfiguration( + configurable_parameters=ConfigurableParameters( + header="header", description="description" + ), + label_schema=LabelSchemaEntity(), + ) + return ModelEntity( + train_dataset=DatasetEntity(), configuration=model_configuration + ) + + @e2e_pytest_unit + def test_ote_classification_train_task_init_params_validation(self): + """ + Description: + Check OTEClassificationTrainingTask object initialization parameters validation + + Input data: + "task_environment" non-TaskEnvironment object + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + OTEClassificationTrainingTask object initialization parameter + """ + with pytest.raises(ValueError): + OTEClassificationTrainingTask(task_environment="unexpected string") # type: ignore + + @e2e_pytest_unit + def test_ote_classification_train_task_save_model_input_params_validation(self): + """ + Description: + Check OTEClassificationTrainingTask object "save_model" method input parameters validation + + Input data: + OTEClassificationTrainingTask object, "model" non-ModelEntity object + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "save_model" method + """ + task = MockClassificationTrainingTask() + with pytest.raises(ValueError): + task.save_model(output_model="unexpected string") # type: ignore + + @e2e_pytest_unit + def test_ote_classification_train_task_input_params_validation(self): + """ + Description: + Check OTEClassificationTrainingTask object "train" method input parameters validation + + Input data: + OTEClassificationTrainingTask object, "train" method unexpected-type input parameters + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "train" method + """ + task = MockClassificationTrainingTask() + correct_values_dict = { + "dataset": DatasetEntity(), + "output_model": self.model(), + } + unexpected_str = "unexpected string" + unexpected_values = [ + # Unexpected string is specified as "dataset" parameter + ("dataset", unexpected_str), + # Unexpected string is specified as "output_model" parameter + ("output_model", unexpected_str), + # Unexpected string is specified as "train_parameters" parameter + ("train_parameters", unexpected_str), + ] + + check_value_error_exception_raised( + correct_parameters=correct_values_dict, + unexpected_values=unexpected_values, + class_or_function=task.train, + ) diff --git a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_utils_input_params_validation.py b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_utils_input_params_validation.py new file mode 100644 index 00000000000..93e74d6d69c --- /dev/null +++ b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_utils_input_params_validation.py @@ -0,0 +1,497 @@ +import numpy as np +import pytest +from ote_sdk.entities.label import LabelEntity, Domain +from ote_sdk.entities.label_schema import LabelSchemaEntity +from ote_sdk.test_suite.e2e_test_system import e2e_pytest_unit +from ote_sdk.tests.parameters_validation.validation_helper import ( + check_value_error_exception_raised, +) + +from torchreid.integration.sc.utils import ( + ClassificationDatasetAdapter, + active_score_from_probs, + OTEClassificationDataset, + generate_label_schema, + get_actmap, + get_multiclass_predictions, + get_task_class, + reload_hyper_parameters, + preprocess_features_for_actmap, + set_values_as_default, + sigmoid_numpy, + softmax_numpy, + get_multilabel_predictions, + force_fp32, + get_multihead_class_info, + get_hierarchical_predictions, +) +from .helpers import load_test_dataset + + +class TestClassificationDatasetAdapterInputParamsValidation: + @e2e_pytest_unit + def test_classification_dataset_adapter_init_params_validation(self): + """ + Description: + Check ClassificationDatasetAdapter object initialization parameters validation + + Input data: + ClassificationDatasetAdapter object initialization parameters with unexpected type + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + ClassificationDatasetAdapter initialization parameter + """ + correct_values_dict = {} + unexpected_int = 1 + unexpected_values = [ + # Unexpected integer is specified as "train_ann_file" parameter + ("train_ann_file", unexpected_int), + # Empty string is specified as "train_ann_file" parameter + ("train_ann_file", ""), + # Path with null character is specified as "train_ann_file" parameter + ("train_ann_file", "./\0fake_data.json"), + # Path with non-printable character is specified as "train_ann_file" parameter + ("train_ann_file", "./\nfake_data.json"), + # Unexpected integer is specified as "train_data_root" parameter + ("train_data_root", unexpected_int), + # Empty string is specified as "train_data_root" parameter + ("train_data_root", ""), + # Path with null character is specified as "train_data_root" parameter + ("train_data_root", "./\0null_char"), + # Path with non-printable character is specified as "train_data_root" parameter + ("train_data_root", "./\non_printable_char"), + # Unexpected integer is specified as "val_ann_file" parameter + ("val_ann_file", unexpected_int), + # Empty string is specified as "val_ann_file" parameter + ("val_ann_file", ""), + # Path with null character is specified as "val_ann_file" parameter + ("val_ann_file", "./\0fake_data.json"), + # Path with non-printable character is specified as "val_ann_file" parameter + ("val_ann_file", "./\nfake_data.json"), + # Unexpected integer is specified as "val_data_root" parameter + ("val_data_root", unexpected_int), + # Empty string is specified as "val_data_root" parameter + ("val_data_root", ""), + # Path with null character is specified as "val_data_root" parameter + ("val_data_root", "./\0null_char"), + # Path with non-printable character is specified as "val_data_root" parameter + ("val_data_root", "./\non_printable_char"), + # Unexpected integer is specified as "test_ann_file" parameter + ("test_ann_file", unexpected_int), + # Empty string is specified as "test_ann_file" parameter + ("test_ann_file", ""), + # Path with null character is specified as "test_ann_file" parameter + ("test_ann_file", "./\0fake_data.json"), + # Path with non-printable character is specified as "test_ann_file" parameter + ("test_ann_file", "./\nfake_data.json"), + # Unexpected integer is specified as "test_data_root" parameter + ("test_data_root", unexpected_int), + # Empty string is specified as "test_data_root" parameter + ("test_data_root", ""), + # Path with null character is specified as "test_data_root" parameter + ("test_data_root", "./\0null_char"), + # Path with non-printable character is specified as "test_data_root" parameter + ("test_data_root", "./\non_printable_char"), + ] + check_value_error_exception_raised( + correct_parameters=correct_values_dict, + unexpected_values=unexpected_values, + class_or_function=ClassificationDatasetAdapter, + ) + + +class TestOTEClassificationDatasetInputParamsValidation: + @e2e_pytest_unit + def test_ote_classification_dataset_init_params_validation(self): + """ + Description: + Check OTEClassificationDataset object initialization parameters validation + + Input data: + OTEClassificationDataset object initialization parameters with unexpected type + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + OTEClassificationDataset initialization parameter + """ + dataset, labels_list = load_test_dataset() + + correct_values_dict = { + "ote_dataset": dataset, + "labels": labels_list, + } + unexpected_str = "unexpected string" + unexpected_values = [ + # Unexpected string is specified as "ote_dataset" parameter + ("ote_dataset", unexpected_str), + # Unexpected string is specified as "labels" parameter + ("labels", unexpected_str), + # Unexpected string is specified as nested label + ("labels", [labels_list[0], unexpected_str]), + # Unexpected string is specified as "multilabel" parameter + ("multilabel", unexpected_str), + # Unexpected string is specified as "hierarchical" parameter + ("hierarchical", unexpected_str), + # Unexpected string is specified as "mixed_cls_heads_info" parameter + ("mixed_cls_heads_info", unexpected_str), + # Unexpected string is specified as "keep_empty_label" parameter + ("keep_empty_label", unexpected_str), + ] + + check_value_error_exception_raised( + correct_parameters=correct_values_dict, + unexpected_values=unexpected_values, + class_or_function=OTEClassificationDataset, + ) + + @e2e_pytest_unit + def test_ote_classification_dataset_getitem_params_validation(self): + """ + Description: + Check OTEClassificationDataset object "__getitem__" method input parameters validation + + Input data: + "idx" non-integer parameter + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "__getitem__" method + """ + dataset, labels_list = load_test_dataset() + ote_classification_dataset = OTEClassificationDataset( + ote_dataset=dataset, + labels=labels_list + ) + with pytest.raises(ValueError): + ote_classification_dataset.__getitem__(idx="unexpected string") # type: ignore + + +class TestUtilsFunctionsParamsValidation: + @e2e_pytest_unit + def test_generate_label_schema_params_validation(self): + """ + Description: + Check "get_multilabel_predictions" function input parameters validation + + Input data: + "get_multilabel_predictions" unexpected type parameters + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "get_multilabel_predictions" function + """ + dataset, labels_list = load_test_dataset() + + correct_values_dict = { + "not_empty_labels": labels_list, + } + unexpected_str = "unexpected string" + unexpected_values = [ + # Unexpected string is specified as "not_empty_labels" parameter + ("not_empty_labels", unexpected_str), + # Unexpected string is specified as nested non_empty_label + ("not_empty_labels", [labels_list[0], unexpected_str]), + # Unexpected string is specified as "multilabel" parameter + ("multilabel", unexpected_str), + ] + + check_value_error_exception_raised( + correct_parameters=correct_values_dict, + unexpected_values=unexpected_values, + class_or_function=generate_label_schema, + ) + + @e2e_pytest_unit + def test_get_multihead_class_info_params_validation(self): + """ + Description: + Check "get_multihead_class_info" function input parameters validation + + Input data: + "label_schema" non-LabelSchemaEntity parameter + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "get_multihead_class_info" function + """ + with pytest.raises(ValueError): + get_multihead_class_info(label_schema=1) # type: ignore + + @e2e_pytest_unit + def test_get_task_class_params_validation(self): + """ + Description: + Check "get_task_class" function input parameters validation + + Input data: + "path" non-string parameter + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "get_task_class" function + """ + with pytest.raises(ValueError): + get_task_class(path=1) # type: ignore + + @e2e_pytest_unit + def test_reload_hyper_parameters_params_validation(self): + """ + Description: + Check "reload_hyper_parameters" function input parameters validation + + Input data: + "model_template" non-ModelTemplate parameter + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "reload_hyper_parameters" function + """ + with pytest.raises(ValueError): + reload_hyper_parameters(model_template="unexpected string") # type: ignore + + @e2e_pytest_unit + def test_set_values_as_default_parameters_params_validation(self): + """ + Description: + Check "set_values_as_default" function input parameters validation + + Input data: + "parameters" non-ModelTemplate parameter + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "set_values_as_default" function + """ + with pytest.raises(ValueError): + set_values_as_default(parameters="unexpected string") # type: ignore + + @e2e_pytest_unit + def test_force_fp32_parameters_params_validation(self): + """ + Description: + Check "force_fp32" function input parameters validation + + Input data: + "model" non-Module parameter + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "force_fp32" function + """ + with pytest.raises(ValueError): + with force_fp32(model="unexpected string"): # type: ignore + pass + + @e2e_pytest_unit + def test_preprocess_features_for_actmap_parameters_params_validation(self): + """ + Description: + Check "preprocess_features_for_actmap" function input parameters validation + + Input data: + "features" non-expected type object + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "preprocess_features_for_actmap" function + """ + with pytest.raises(ValueError): + preprocess_features_for_actmap(features={"unexpected": "dict"}) # type: ignore + + @e2e_pytest_unit + def test_get_actmap_params_validation(self): + """ + Description: + Check "get_actmap" function input parameters validation + + Input data: + "get_actmap" unexpected type parameters + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "get_actmap" function + """ + unexpected_dict = {"unexpected": "dictionary"} + correct_values_dict = { + "features": ["some", "features"], + "output_res": ("iterable", "object") + } + unexpected_values = [ + # Unexpected dictionary is specified as "features" parameter + ("features", unexpected_dict), + # Unexpected dictionary is specified as "output_res" parameter + ("output_res", unexpected_dict), + ] + + check_value_error_exception_raised( + correct_parameters=correct_values_dict, + unexpected_values=unexpected_values, + class_or_function=get_actmap, + ) + + @e2e_pytest_unit + def test_active_score_from_probs_parameters_params_validation(self): + """ + Description: + Check "active_score_from_probs" function input parameters validation + + Input data: + "predictions" non-expected type object + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "active_score_from_probs" function + """ + with pytest.raises(ValueError): + active_score_from_probs(predictions={}) # type: ignore + + @e2e_pytest_unit + def test_sigmoid_numpy_parameters_params_validation(self): + """ + Description: + Check "sigmoid_numpy" function input parameters validation + + Input data: + "x" non-ndarray object + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "sigmoid_numpy" function + """ + with pytest.raises(ValueError): + sigmoid_numpy(x="unexpected str") # type: ignore + + @e2e_pytest_unit + def test_softmax_numpy_parameters_params_validation(self): + """ + Description: + Check "softmax_numpy" function input parameters validation + + Input data: + "x" non-ndarray object + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "softmax_numpy" function + """ + with pytest.raises(ValueError): + softmax_numpy(x="unexpected str") # type: ignore + + @e2e_pytest_unit + def test_get_multiclass_predictions_params_validation(self): + """ + Description: + Check "get_multiclass_predictions" function input parameters validation + + Input data: + "get_multiclass_predictions" unexpected type parameters + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "get_multiclass_predictions" function + """ + label = LabelEntity(name="test label", domain=Domain.DETECTION) + correct_values_dict = { + "logits": np.random.randint(low=0, high=255, size=(10, 16, 3)), + "labels": [label] + } + unexpected_str = "unexpected string" + unexpected_values = [ + # Unexpected string is specified as "features" parameter + ("logits", unexpected_str), + # Unexpected string is specified as "labels" parameter + ("labels", unexpected_str), + # Unexpected string is specified as nested label + ("labels", [label, unexpected_str]), + # Unexpected string is specified as "output_res" parameter + ("activate", unexpected_str), + ] + + check_value_error_exception_raised( + correct_parameters=correct_values_dict, + unexpected_values=unexpected_values, + class_or_function=get_multiclass_predictions, + ) + + @e2e_pytest_unit + def test_get_multilabel_predictions_params_validation(self): + """ + Description: + Check "get_multilabel_predictions" function input parameters validation + + Input data: + "get_multilabel_predictions" unexpected type parameters + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "get_multilabel_predictions" function + """ + label = LabelEntity(name="test label", domain=Domain.DETECTION) + correct_values_dict = { + "logits": np.random.randint(low=0, high=255, size=(10, 16, 3)), + "labels": [label] + } + unexpected_str = "unexpected string" + unexpected_values = [ + # Unexpected string is specified as "features" parameter + ("logits", unexpected_str), + # Unexpected string is specified as "labels" parameter + ("labels", unexpected_str), + # Unexpected string is specified as nested label + ("labels", [label, unexpected_str]), + # Unexpected string is specified as "pos_thr" parameter + ("pos_thr", unexpected_str), + # Unexpected string is specified as "output_res" parameter + ("activate", unexpected_str), + ] + + check_value_error_exception_raised( + correct_parameters=correct_values_dict, + unexpected_values=unexpected_values, + class_or_function=get_multilabel_predictions, + ) + + @e2e_pytest_unit + def test_get_hierarchical_predictions_params_validation(self): + """ + Description: + Check "get_hierarchical_predictions" function input parameters validation + + Input data: + "get_hierarchical_predictions" unexpected type parameters + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "get_hierarchical_predictions" function + """ + label = LabelEntity(name="test label", domain=Domain.DETECTION) + correct_values_dict = { + "logits": np.random.randint(low=0, high=255, size=(10, 16, 3)), + "labels": [label], + "label_schema": LabelSchemaEntity(), + "multihead_class_info": {"class": "info"}, + } + unexpected_str = "unexpected string" + unexpected_values = [ + # Unexpected string is specified as "features" parameter + ("logits", unexpected_str), + # Unexpected string is specified as "labels" parameter + ("labels", unexpected_str), + # Unexpected string is specified as nested label + ("labels", [label, unexpected_str]), + # Unexpected string is specified as "label_schema" parameter + ("label_schema", unexpected_str), + # Unexpected string is specified as "multihead_class_info" parameter + ("multihead_class_info", unexpected_str), + # Unexpected string is specified as "pos_thr" parameter + ("pos_thr", unexpected_str), + # Unexpected string is specified as "output_res" parameter + ("activate", unexpected_str), + ] + + check_value_error_exception_raised( + correct_parameters=correct_values_dict, + unexpected_values=unexpected_values, + class_or_function=get_hierarchical_predictions, + ) From a0e636af43c6cd953927e2cf47ffa4a96c5e764a Mon Sep 17 00:00:00 2001 From: saltykox Date: Tue, 22 Mar 2022 17:05:22 +0300 Subject: [PATCH 05/15] added input parameters validation in functions and methods of external/deep-object-reid/torchreid_tasks/ directory --- ..._classification_input_params_validation.py | 88 +++- ..._inference_task_input_params_validation.py | 2 +- ...st_ote_monitors_input_params_validation.py | 2 +- ...t_ote_nncf_task_input_params_validation.py | 3 +- ...e_openvino_task_input_params_validation.py | 23 +- ..._ote_train_task_input_params_validation.py | 2 +- .../test_ote_utils_input_params_validation.py | 2 +- .../deep-object-reid/tests/test_ote_api.py | 4 +- .../torchreid_tasks/inference_task.py | 8 + .../model_wrappers/classification.py | 19 +- .../torchreid_tasks/monitors.py | 9 + .../torchreid_tasks/nncf_task.py | 10 +- .../torchreid_tasks/openvino_task.py | 22 +- .../torchreid_tasks/train_task.py | 7 + .../deep-object-reid/torchreid_tasks/utils.py | 54 ++- ote_sdk/ote_sdk/utils/argument_checks.py | 390 ++++++++++++------ 16 files changed, 481 insertions(+), 164 deletions(-) diff --git a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_classification_input_params_validation.py b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_classification_input_params_validation.py index 6a210fc5ddd..daf62592b0a 100644 --- a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_classification_input_params_validation.py +++ b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_classification_input_params_validation.py @@ -5,12 +5,14 @@ check_value_error_exception_raised, ) -from torchreid.integration.sc.model_wrappers.classification import ( +from torchreid_tasks.model_wrappers.classification import ( OteClassification, sigmoid_numpy, softmax_numpy, get_multiclass_predictions, get_multilabel_predictions, + preprocess_features_for_actmap, + get_actmap, ) @@ -171,3 +173,87 @@ def test_ote_classification_postprocess_params_validation(self): unexpected_values=unexpected_values, class_or_function=classification.postprocess, ) + + @e2e_pytest_unit + def test_ote_classification_postprocess_aux_outputs_params_validation(self): + """ + Description: + Check OteClassification object "postprocess_aux_outputs" method input parameters validation + + Input data: + OteClassification object. "postprocess_aux_outputs" method unexpected type parameters + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "postprocess_aux_outputs" method + """ + classification = MockClassification() + correct_values_dict = { + "outputs": {"output_1": np.random.rand(2, 2)}, + "metadata": {"metadata_1": "some_data"}, + } + unexpected_int = 1 + unexpected_values = [ + # Unexpected integer is specified as "outputs" parameter + ("outputs", unexpected_int), + # Unexpected integer is specified as "outputs" dictionary key + ("outputs", {unexpected_int: np.random.rand(2, 2)}), + # Unexpected integer is specified as "outputs" dictionary value + ("outputs", {"output_1": unexpected_int}), + # Unexpected integer is specified as "metadata" parameter + ("metadata", unexpected_int), + # Unexpected integer is specified as "metadata" dictionary key + ("metadata", {unexpected_int: "some_data"}), + ] + check_value_error_exception_raised( + correct_parameters=correct_values_dict, + unexpected_values=unexpected_values, + class_or_function=classification.postprocess_aux_outputs, + ) + + @e2e_pytest_unit + def test_preprocess_features_for_actmap_parameters_params_validation(self): + """ + Description: + Check "preprocess_features_for_actmap" function input parameters validation + + Input data: + "features" non-expected type object + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "preprocess_features_for_actmap" function + """ + with pytest.raises(ValueError): + preprocess_features_for_actmap(features={"unexpected": "dict"}) # type: ignore + + @e2e_pytest_unit + def test_get_actmap_params_validation(self): + """ + Description: + Check "get_actmap" function input parameters validation + + Input data: + "get_actmap" unexpected type parameters + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "get_actmap" function + """ + unexpected_dict = {"unexpected": "dictionary"} + correct_values_dict = { + "features": ["some", "features"], + "output_res": ("iterable", "object") + } + unexpected_values = [ + # Unexpected dictionary is specified as "features" parameter + ("features", unexpected_dict), + # Unexpected dictionary is specified as "output_res" parameter + ("output_res", unexpected_dict), + ] + + check_value_error_exception_raised( + correct_parameters=correct_values_dict, + unexpected_values=unexpected_values, + class_or_function=get_actmap, + ) diff --git a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_inference_task_input_params_validation.py b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_inference_task_input_params_validation.py index 614db7ea27b..13a36ae7ad1 100644 --- a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_inference_task_input_params_validation.py +++ b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_inference_task_input_params_validation.py @@ -11,7 +11,7 @@ ) from ote_sdk.usecases.tasks.interfaces.export_interface import ExportType -from torchreid.integration.sc.inference_task import OTEClassificationInferenceTask +from torchreid_tasks.inference_task import OTEClassificationInferenceTask class MockClassificationInferenceTask(OTEClassificationInferenceTask): diff --git a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_monitors_input_params_validation.py b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_monitors_input_params_validation.py index 67d59f6921d..a188322d2bb 100644 --- a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_monitors_input_params_validation.py +++ b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_monitors_input_params_validation.py @@ -4,7 +4,7 @@ check_value_error_exception_raised, ) -from torchreid.integration.sc.monitors import MetricsMonitor, DefaultMetricsMonitor +from torchreid_tasks.monitors import MetricsMonitor, DefaultMetricsMonitor class TestMetricsMonitorParamsValidation: diff --git a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_nncf_task_input_params_validation.py b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_nncf_task_input_params_validation.py index f8e22243726..c3885e8f944 100644 --- a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_nncf_task_input_params_validation.py +++ b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_nncf_task_input_params_validation.py @@ -14,7 +14,7 @@ from ote_sdk.usecases.tasks.interfaces.export_interface import ExportType from ote_sdk.usecases.tasks.interfaces.optimization_interface import OptimizationType -from torchreid.integration.sc.nncf_task import OTEClassificationNNCFTask +from torchreid_tasks.nncf_task import OTEClassificationNNCFTask class MockNNCFTask(OTEClassificationNNCFTask): @@ -69,7 +69,6 @@ def test_ote_nncf_classification_task_optimize_params_validation(self): "optimization_type": OptimizationType.NNCF, "dataset": DatasetEntity(), "output_model": self.model(), - "optimization_parameters": None, } unexpected_str = "unexpected string" unexpected_values = [ diff --git a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_openvino_task_input_params_validation.py b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_openvino_task_input_params_validation.py index 07eb3bf367f..e69a205f318 100644 --- a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_openvino_task_input_params_validation.py +++ b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_openvino_task_input_params_validation.py @@ -15,12 +15,12 @@ ) from ote_sdk.usecases.tasks.interfaces.optimization_interface import OptimizationType -from torchreid.integration.sc.openvino_task import ( +from torchreid_tasks.openvino_task import ( OpenVINOClassificationInferencer, OTEOpenVinoDataLoader, OpenVINOClassificationTask, ) -from torchreid.integration.sc.parameters import OTEClassificationParameters +from torchreid_tasks.parameters import OTEClassificationParameters def model(): @@ -158,7 +158,6 @@ def test_openvino_task_optimize_params_validation(self): "optimization_type": OptimizationType.POT, "dataset": DatasetEntity(), "output_model": model(), - "optimization_parameters": None, } unexpected_str = "unexpected string" unexpected_values = [ @@ -329,6 +328,24 @@ def test_openvino_classification_inferencer_post_process_params_validation(self) class_or_function=inferencer.post_process, ) + @e2e_pytest_unit + def test_openvino_classification_inferencer_predict_params_validation(self): + """ + Description: + Check OpenVINOClassificationInferencer object "predict" method input parameters + validation + + Input data: + OpenVINOClassificationInferencer object, "image" non-ndarray object + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "predict" method + """ + inferencer = MockOpenVinoInferencer() + with pytest.raises(ValueError): + inferencer.predict(image="unexpected string") # type: ignore + @e2e_pytest_unit def test_openvino_classification_inferencer_forward_params_validation(self): """ diff --git a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_train_task_input_params_validation.py b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_train_task_input_params_validation.py index 8360a1a1bb0..5d7e4f6972f 100644 --- a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_train_task_input_params_validation.py +++ b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_train_task_input_params_validation.py @@ -12,7 +12,7 @@ check_value_error_exception_raised, ) -from torchreid.integration.sc.train_task import OTEClassificationTrainingTask +from torchreid_tasks.train_task import OTEClassificationTrainingTask class MockClassificationTrainingTask(OTEClassificationTrainingTask): diff --git a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_utils_input_params_validation.py b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_utils_input_params_validation.py index 93e74d6d69c..d3c781ffec0 100644 --- a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_utils_input_params_validation.py +++ b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_utils_input_params_validation.py @@ -7,7 +7,7 @@ check_value_error_exception_raised, ) -from torchreid.integration.sc.utils import ( +from torchreid_tasks.utils import ( ClassificationDatasetAdapter, active_score_from_probs, OTEClassificationDataset, diff --git a/external/deep-object-reid/tests/test_ote_api.py b/external/deep-object-reid/tests/test_ote_api.py index 9db578f091d..134669d8a1c 100644 --- a/external/deep-object-reid/tests/test_ote_api.py +++ b/external/deep-object-reid/tests/test_ote_api.py @@ -136,7 +136,7 @@ def test_training_progress_tracking(default_task_setup): def progress_callback(progress: float, score: Optional[float] = None): training_progress_curve.append(progress) - train_parameters = TrainParameters + train_parameters = TrainParameters() train_parameters.update_progress = progress_callback output_model = ModelEntity( dataset, @@ -160,7 +160,7 @@ def test_inference_progress_tracking(default_task_setup): def progress_callback(progress: int): inference_progress_curve.append(progress) - inference_parameters = InferenceParameters + inference_parameters = InferenceParameters() inference_parameters.update_progress = progress_callback task.infer(dataset.with_empty_annotations(), inference_parameters) diff --git a/external/deep-object-reid/torchreid_tasks/inference_task.py b/external/deep-object-reid/torchreid_tasks/inference_task.py index acabf96c217..edf81de5d2a 100644 --- a/external/deep-object-reid/torchreid_tasks/inference_task.py +++ b/external/deep-object-reid/torchreid_tasks/inference_task.py @@ -42,6 +42,10 @@ from ote_sdk.usecases.tasks.interfaces.export_interface import ExportType, IExportTask from ote_sdk.usecases.tasks.interfaces.inference_interface import IInferenceTask from ote_sdk.usecases.tasks.interfaces.unload_interface import IUnload +from ote_sdk.utils.argument_checks import ( + DatasetParamTypeCheck, + check_input_parameters_type, +) from ote_sdk.utils.labels_utils import get_empty_label from scripts.default_config import (get_default_config, imagedata_kwargs, merge_from_files_with_base, model_kwargs) @@ -63,6 +67,7 @@ class OTEClassificationInferenceTask(IInferenceTask, IEvaluationTask, IExportTas task_environment: TaskEnvironment + @check_input_parameters_type() def __init__(self, task_environment: TaskEnvironment): logger.info("Loading OTEClassificationTask.") self._scratch_space = tempfile.mkdtemp(prefix="ote-cls-scratch-") @@ -183,6 +188,7 @@ def _patch_config(self, base_dir: str): self._cfg.lr_finder.enable = self._hyperparams.learning_parameters.enable_lr_finder self._cfg.train.early_stopping = self._hyperparams.learning_parameters.enable_early_stopping + @check_input_parameters_type({"dataset": DatasetParamTypeCheck}) def infer(self, dataset: DatasetEntity, inference_parameters: Optional[InferenceParameters] = None) -> DatasetEntity: """ @@ -262,6 +268,7 @@ def infer(self, dataset: DatasetEntity, return dataset + @check_input_parameters_type() def evaluate( self, output_resultset: ResultSetEntity, evaluation_metric: Optional[str] = None ): @@ -269,6 +276,7 @@ def evaluate( logger.info(f"Computes performance of {performance}") output_resultset.performance = performance + @check_input_parameters_type() def export(self, export_type: ExportType, output_model: ModelEntity): assert export_type == ExportType.OPENVINO output_model.model_format = ModelFormat.OPENVINO diff --git a/external/deep-object-reid/torchreid_tasks/model_wrappers/classification.py b/external/deep-object-reid/torchreid_tasks/model_wrappers/classification.py index 15e85df635d..250d92b0282 100644 --- a/external/deep-object-reid/torchreid_tasks/model_wrappers/classification.py +++ b/external/deep-object-reid/torchreid_tasks/model_wrappers/classification.py @@ -14,7 +14,9 @@ import cv2 import numpy as np -from typing import Any, Dict +from typing import Any, Dict, Union +from ote_sdk.utils.argument_checks import check_input_parameters_type + try: from openvino.model_zoo.model_api.models.classification import Classification @@ -59,6 +61,7 @@ def _get_outputs(self): 'labels must match ({} != {})'.format(layer_shape[1], len(self.labels))) return layer_name + @check_input_parameters_type() def preprocess(self, image: np.ndarray): meta = {'original_shape': image.shape} resized_image = self.resize(image, (self.w, self.h)) @@ -71,6 +74,7 @@ def preprocess(self, image: np.ndarray): dict_inputs = {self.image_blob_name: resized_image} return dict_inputs, meta + @check_input_parameters_type() def postprocess(self, outputs: Dict[str, np.ndarray], metadata: Dict[str, Any]): logits = outputs[self.out_layer_name].squeeze() if self.multilabel: @@ -80,6 +84,7 @@ def postprocess(self, outputs: Dict[str, np.ndarray], metadata: Dict[str, Any]): return predictions + @check_input_parameters_type() def postprocess_aux_outputs(self, outputs: Dict[str, np.ndarray], metadata: Dict[str, Any]): features = preprocess_features_for_actmap(outputs['features']) actmap = get_actmap(features[0], (metadata['original_shape'][1], metadata['original_shape'][0])) @@ -95,8 +100,8 @@ def postprocess_aux_outputs(self, outputs: Dict[str, np.ndarray], metadata: Dict return actmap, repr_vector, act_score - -def preprocess_features_for_actmap(features): +@check_input_parameters_type() +def preprocess_features_for_actmap(features: Union[np.ndarray, int, float, str, tuple, list]): features = np.mean(features, axis=1) b, h, w = features.shape features = features.reshape(b, h * w) @@ -106,7 +111,9 @@ def preprocess_features_for_actmap(features): return features -def get_actmap(features, output_res): +@check_input_parameters_type() +def get_actmap(features: Union[np.ndarray, int, float, str, tuple, list], + output_res: Union[tuple, list]): am = cv2.resize(features, output_res) am = 255 * (am - np.min(am)) / (np.max(am) - np.min(am) + 1e-12) am = np.uint8(np.floor(am)) @@ -114,16 +121,19 @@ def get_actmap(features, output_res): return am +@check_input_parameters_type() def sigmoid_numpy(x: np.ndarray): return 1. / (1. + np.exp(-1. * x)) +@check_input_parameters_type() def softmax_numpy(x: np.ndarray): x = np.exp(x) x /= np.sum(x) return x +@check_input_parameters_type() def get_multiclass_predictions(logits: np.ndarray, activate: bool = True): index = np.argmax(logits) @@ -132,6 +142,7 @@ def get_multiclass_predictions(logits: np.ndarray, activate: bool = True): return [(index, logits[index])] +@check_input_parameters_type() def get_multilabel_predictions(logits: np.ndarray, pos_thr: float = 0.5, activate: bool = True): if activate: logits = sigmoid_numpy(logits) diff --git a/external/deep-object-reid/torchreid_tasks/monitors.py b/external/deep-object-reid/torchreid_tasks/monitors.py index 1cadd875f6f..bef363f3fd6 100644 --- a/external/deep-object-reid/torchreid_tasks/monitors.py +++ b/external/deep-object-reid/torchreid_tasks/monitors.py @@ -17,6 +17,10 @@ import abc from torch.utils.tensorboard import SummaryWriter +from ote_sdk.utils.argument_checks import ( + DirectoryPathCheck, + check_input_parameters_type, +) class IMetricsMonitor(metaclass=abc.ABCMeta): @@ -72,10 +76,12 @@ def reset(self): class MetricsMonitor(IMetricsMonitor): + @check_input_parameters_type({"log_dir": DirectoryPathCheck}) def __init__(self, log_dir): self.log_dir = log_dir self.tb = None + @check_input_parameters_type() def add_scalar(self, capture: str, value: float, timestamp: int): if not self.tb: self.tb = SummaryWriter(self.log_dir) @@ -102,6 +108,7 @@ class DefaultMetricsMonitor(IMetricsMonitor): def __init__(self): self.metrics_dict = {} + @check_input_parameters_type() def add_scalar(self, capture: str, value: float, timestamp: int): if capture in self.metrics_dict: self.metrics_dict[capture].append((timestamp, value)) @@ -111,9 +118,11 @@ def add_scalar(self, capture: str, value: float, timestamp: int): def get_metric_keys(self): return self.metrics_dict.keys() + @check_input_parameters_type() def get_metric_values(self, capture: str): return [item[1] for item in self.metrics_dict[capture]] + @check_input_parameters_type() def get_metric_timestamps(self, capture: str): return [item[0] for item in self.metrics_dict[capture]] diff --git a/external/deep-object-reid/torchreid_tasks/nncf_task.py b/external/deep-object-reid/torchreid_tasks/nncf_task.py index cd012e31c39..15d948dd842 100644 --- a/external/deep-object-reid/torchreid_tasks/nncf_task.py +++ b/external/deep-object-reid/torchreid_tasks/nncf_task.py @@ -31,6 +31,10 @@ from ote_sdk.entities.train_parameters import default_progress_callback from ote_sdk.usecases.tasks.interfaces.export_interface import ExportType from ote_sdk.usecases.tasks.interfaces.optimization_interface import IOptimizationTask, OptimizationType +from ote_sdk.utils.argument_checks import ( + DatasetParamTypeCheck, + check_input_parameters_type, +) from scripts.default_config import imagedata_kwargs, lr_scheduler_kwargs, optimizer_kwargs from torchreid.apis.training import run_training from torchreid.integration.nncf.compression import check_nncf_is_enabled, is_nncf_state, wrap_nncf_model @@ -47,6 +51,7 @@ class OTEClassificationNNCFTask(OTEClassificationInferenceTask, IOptimizationTask): + @check_input_parameters_type() def __init__(self, task_environment: TaskEnvironment): """" Task for compressing classification models using NNCF. @@ -153,12 +158,13 @@ def _load_aux_models_data(self, model: ModelEntity): aux_models_data.append(model_data) return aux_models_data + @check_input_parameters_type({"dataset": DatasetParamTypeCheck}) def optimize( self, optimization_type: OptimizationType, dataset: DatasetEntity, output_model: ModelEntity, - optimization_parameters: Optional[OptimizationParameters], + optimization_parameters: Optional[OptimizationParameters] = None, ): """ Optimize a model on a dataset """ if optimization_type is not OptimizationType.NNCF: @@ -243,6 +249,7 @@ def optimize( output_model.optimization_methods = self._optimization_methods output_model.precision = self._precision + @check_input_parameters_type() def save_model(self, output_model: ModelEntity): state_dict = None if self._compression_ctrl is not None: @@ -252,6 +259,7 @@ def save_model(self, output_model: ModelEntity): } self._save_model(output_model, state_dict) + @check_input_parameters_type() def export(self, export_type: ExportType, output_model: ModelEntity): if self._compression_ctrl is None: super().export(export_type, output_model) diff --git a/external/deep-object-reid/torchreid_tasks/openvino_task.py b/external/deep-object-reid/torchreid_tasks/openvino_task.py index 309ae3a07fa..0fe4cd703da 100644 --- a/external/deep-object-reid/torchreid_tasks/openvino_task.py +++ b/external/deep-object-reid/torchreid_tasks/openvino_task.py @@ -55,6 +55,10 @@ IOptimizationTask, OptimizationType, ) +from ote_sdk.utils.argument_checks import ( + DatasetParamTypeCheck, + check_input_parameters_type, +) from compression.api import DataLoader from compression.engines.ie_engine import IEEngine @@ -77,12 +81,13 @@ class OpenVINOClassificationInferencer(BaseInferencer): + @check_input_parameters_type() def __init__( self, hparams: OTEClassificationParameters, label_schema: LabelSchemaEntity, model_file: Union[str, bytes], - weight_file: Union[str, bytes, None] = None, + weight_file: Optional[str, bytes] = None, device: str = "CPU", num_requests: int = 1, ): @@ -107,15 +112,18 @@ def __init__( self.converter = ClassificationToAnnotationConverter(self.label_schema) + @check_input_parameters_type() def pre_process(self, image: np.ndarray) -> Tuple[Dict[str, np.ndarray], Dict[str, Any]]: return self.model.preprocess(image) + @check_input_parameters_type() def post_process(self, prediction: Dict[str, np.ndarray], metadata: Dict[str, Any]) -> Tuple[AnnotationSceneEntity, np.ndarray, np.ndarray]: prediction = self.model.postprocess(prediction, metadata) return self.converter.convert_to_annotation(prediction, metadata) + @check_input_parameters_type() def predict(self, image: np.ndarray) -> Tuple[AnnotationSceneEntity, np.ndarray, np.ndarray]: image, metadata = self.pre_process(image) raw_predictions = self.forward(image) @@ -124,17 +132,20 @@ def predict(self, image: np.ndarray) -> Tuple[AnnotationSceneEntity, np.ndarray, return predictions, features, repr_vectors, act_score + @check_input_parameters_type() def forward(self, inputs: Dict[str, np.ndarray]) -> Dict[str, np.ndarray]: return self.model.infer_sync(inputs) class OTEOpenVinoDataLoader(DataLoader): + @check_input_parameters_type({"dataset": DatasetParamTypeCheck}) def __init__(self, dataset: DatasetEntity, inferencer: BaseInferencer): super().__init__(config=None) self.dataset = dataset self.inferencer = inferencer - def __getitem__(self, index): + @check_input_parameters_type() + def __getitem__(self, index: int): image = self.dataset[index].numpy annotation = self.dataset[index].annotation_scene inputs, metadata = self.inferencer.pre_process(image) @@ -146,6 +157,7 @@ def __len__(self): class OpenVINOClassificationTask(IDeploymentTask, IInferenceTask, IEvaluationTask, IOptimizationTask): + @check_input_parameters_type() def __init__(self, task_environment: TaskEnvironment): self.task_environment = task_environment self.hparams = self.task_environment.get_hyper_parameters(OTEClassificationParameters) @@ -158,6 +170,7 @@ def load_inferencer(self) -> OpenVINOClassificationInferencer: self.model.get_data("openvino.xml"), self.model.get_data("openvino.bin")) + @check_input_parameters_type({"dataset": DatasetParamTypeCheck}) def infer(self, dataset: DatasetEntity, inference_parameters: Optional[InferenceParameters] = None) -> DatasetEntity: update_progress_callback = default_progress_callback @@ -185,6 +198,7 @@ def infer(self, dataset: DatasetEntity, update_progress_callback(int(i / dataset_size * 100)) return dataset + @check_input_parameters_type() def evaluate(self, output_result_set: ResultSetEntity, evaluation_metric: Optional[str] = None): @@ -193,6 +207,7 @@ def evaluate(self, 'but parameter is ignored. Use accuracy instead.') output_result_set.performance = MetricsHelper.compute_accuracy(output_result_set).get_performance() + @check_input_parameters_type() def deploy(self, output_model: ModelEntity) -> None: logger.info('Deploying the model') @@ -233,11 +248,12 @@ def deploy(self, output_model.exportable_code = file.read() logger.info('Deploying completed') + @check_input_parameters_type({"dataset": DatasetParamTypeCheck}) def optimize(self, optimization_type: OptimizationType, dataset: DatasetEntity, output_model: ModelEntity, - optimization_parameters: Optional[OptimizationParameters]): + optimization_parameters: Optional[OptimizationParameters] = None): if optimization_type is not OptimizationType.POT: raise ValueError("POT is the only supported optimization type for OpenVino models") diff --git a/external/deep-object-reid/torchreid_tasks/train_task.py b/external/deep-object-reid/torchreid_tasks/train_task.py index d6ed8b641f3..adeed8cbef1 100644 --- a/external/deep-object-reid/torchreid_tasks/train_task.py +++ b/external/deep-object-reid/torchreid_tasks/train_task.py @@ -35,12 +35,17 @@ from torchreid_tasks.utils import (OTEClassificationDataset, TrainingProgressCallback) from torchreid.ops import DataParallel from torchreid.utils import load_pretrained_weights, set_random_seed +from ote_sdk.utils.argument_checks import ( + DatasetParamTypeCheck, + check_input_parameters_type, +) logger = logging.getLogger(__name__) class OTEClassificationTrainingTask(OTEClassificationInferenceTask, ITrainingTask): + @check_input_parameters_type() def __init__(self, task_environment: TaskEnvironment): super().__init__(task_environment) self._aux_model_snap_paths = {} @@ -55,6 +60,7 @@ def cancel_training(self): logger.info("Cancel training requested.") self.stop_callback.stop() + @check_input_parameters_type() def save_model(self, output_model: ModelEntity): for name, path in self._aux_model_snap_paths.items(): with open(path, 'rb') as read_file: @@ -78,6 +84,7 @@ def _generate_training_metrics_group(self) -> Optional[List[MetricsGroup]]: return output + @check_input_parameters_type({"dataset": DatasetParamTypeCheck}) def train(self, dataset: DatasetEntity, output_model: ModelEntity, train_parameters: Optional[TrainParameters] = None): """ Trains a model on a dataset """ diff --git a/external/deep-object-reid/torchreid_tasks/utils.py b/external/deep-object-reid/torchreid_tasks/utils.py index 6e4e87be492..e3cb8a3ab89 100644 --- a/external/deep-object-reid/torchreid_tasks/utils.py +++ b/external/deep-object-reid/torchreid_tasks/utils.py @@ -24,7 +24,7 @@ import time from os import path as osp from operator import itemgetter -from typing import List +from typing import List, Union import cv2 as cv import numpy as np @@ -38,11 +38,18 @@ from ote_sdk.entities.label import Domain, LabelEntity from ote_sdk.entities.label_schema import (LabelGroup, LabelGroupType, LabelSchemaEntity) +from ote_sdk.entities.model_template import ModelTemplate from ote_sdk.entities.scored_label import ScoredLabel from ote_sdk.entities.shapes.rectangle import Rectangle from ote_sdk.entities.subset import Subset from ote_sdk.entities.train_parameters import UpdateProgressCallback from ote_sdk.usecases.reporting.time_monitor_callback import TimeMonitorCallback +from ote_sdk.utils.argument_checks import ( + DatasetParamTypeCheck, + OptionalDirectoryPathCheck, + check_input_parameters_type, +) +from torch.nn.modules import Module from torchreid.utils import set_model_attr, get_model_attr @@ -53,6 +60,12 @@ class ClassificationType(Enum): class ClassificationDatasetAdapter(DatasetEntity): + @check_input_parameters_type({"train_ann_file": OptionalDirectoryPathCheck, + "train_data_root": OptionalDirectoryPathCheck, + "val_ann_file": OptionalDirectoryPathCheck, + "val_data_root": OptionalDirectoryPathCheck, + "test_ann_file": OptionalDirectoryPathCheck, + "test_data_root": OptionalDirectoryPathCheck}) def __init__(self, train_ann_file=None, train_data_root=None, @@ -202,7 +215,8 @@ def generate_label_schema(self): return label_schema -def generate_label_schema(not_empty_labels, multilabel=False): +@check_input_parameters_type() +def generate_label_schema(not_empty_labels: List[LabelEntity], multilabel: bool = False): assert len(not_empty_labels) > 1 label_schema = LabelSchemaEntity() @@ -218,6 +232,7 @@ def generate_label_schema(not_empty_labels, multilabel=False): return label_schema +@check_input_parameters_type() def get_multihead_class_info(label_schema: LabelSchemaEntity): all_groups = label_schema.get_groups(include_empty=False) all_groups_str = [] @@ -256,8 +271,9 @@ def get_multihead_class_info(label_schema: LabelSchemaEntity): class OTEClassificationDataset: - def __init__(self, ote_dataset: DatasetEntity, labels, multilabel=False, hierarchical=False, - mixed_cls_heads_info={}, keep_empty_label=False): + @check_input_parameters_type({"ote_dataset": DatasetParamTypeCheck}) + def __init__(self, ote_dataset: DatasetEntity, labels: List[LabelEntity], multilabel: bool = False, + hierarchical: bool = False, mixed_cls_heads_info: dict = {}, keep_empty_label: bool = False): super().__init__() self.ote_dataset = ote_dataset self.multilabel = multilabel @@ -309,7 +325,8 @@ def __init__(self, ote_dataset: DatasetEntity, labels, multilabel=False, hierarc else: self.annotation.append({'label': class_indices[0]}) - def __getitem__(self, idx): + @check_input_parameters_type() + def __getitem__(self, idx: int): sample = self.ote_dataset[idx].numpy # This returns 8-bit numpy array of shape (height, width, RGB) label = self.annotation[idx]['label'] return {'img': sample, 'label': label} @@ -324,13 +341,15 @@ def get_classes(self): return self.label_names -def get_task_class(path): +@check_input_parameters_type() +def get_task_class(path: str): module_name, class_name = path.rsplit('.', 1) module = importlib.import_module(module_name) return getattr(module, class_name) -def reload_hyper_parameters(model_template): +@check_input_parameters_type() +def reload_hyper_parameters(model_template: ModelTemplate): """ This function copies template.yaml file and its configuration.yaml dependency to temporal folder. Then it re-loads hyper parameters from copied template.yaml file. This function should not be used in general case, it is assumed that @@ -349,7 +368,8 @@ def reload_hyper_parameters(model_template): assert model_template.hyper_parameters.data -def set_values_as_default(parameters): +@check_input_parameters_type() +def set_values_as_default(parameters: dict): for v in parameters.values(): if isinstance(v, dict) and 'value' not in v: set_values_as_default(v) @@ -359,7 +379,8 @@ def set_values_as_default(parameters): @contextmanager -def force_fp32(model): +@check_input_parameters_type() +def force_fp32(model: Module): mix_precision_status = get_model_attr(model, 'mix_precision') set_model_attr(model, 'mix_precision', False) try: @@ -396,7 +417,8 @@ def on_test_batch_end(self, batch=None, logs=None): self.update_progress_callback(self.get_progress()) -def preprocess_features_for_actmap(features): +@check_input_parameters_type() +def preprocess_features_for_actmap(features: Union[np.ndarray, int, float, str, tuple, list]): features = np.mean(features, axis=1) b, h, w = features.shape features = features.reshape(b, h * w) @@ -406,7 +428,9 @@ def preprocess_features_for_actmap(features): return features -def get_actmap(features, output_res): +@check_input_parameters_type() +def get_actmap(features: Union[np.ndarray, int, float, str, tuple, list], + output_res: Union[tuple, list]): am = cv.resize(features, output_res) am = 255 * (am - np.min(am)) / (np.max(am) - np.min(am) + 1e-12) am = np.uint8(np.floor(am)) @@ -414,22 +438,26 @@ def get_actmap(features, output_res): return am -def active_score_from_probs(predictions): +@check_input_parameters_type() +def active_score_from_probs(predictions: Union[np.ndarray, int, float, str, tuple, list]): top_idxs = np.argpartition(predictions, -2)[-2:] top_probs = predictions[top_idxs] return np.max(top_probs) - np.min(top_probs) +@check_input_parameters_type() def sigmoid_numpy(x: np.ndarray): return 1. / (1. + np.exp(-1. * x)) +@check_input_parameters_type() def softmax_numpy(x: np.ndarray): x = np.exp(x) x /= np.sum(x) return x +@check_input_parameters_type() def get_multiclass_predictions(logits: np.ndarray, labels: List[LabelEntity], activate: bool = True) -> List[ScoredLabel]: i = np.argmax(logits) @@ -438,6 +466,7 @@ def get_multiclass_predictions(logits: np.ndarray, labels: List[LabelEntity], return [ScoredLabel(labels[i], probability=float(logits[i]))] +@check_input_parameters_type() def get_multilabel_predictions(logits: np.ndarray, labels: List[LabelEntity], pos_thr: float = 0.5, activate: bool = True) -> List[ScoredLabel]: if activate: @@ -451,6 +480,7 @@ def get_multilabel_predictions(logits: np.ndarray, labels: List[LabelEntity], return item_labels +@check_input_parameters_type() def get_hierarchical_predictions(logits: np.ndarray, labels: List[LabelEntity], label_schema: LabelSchemaEntity, multihead_class_info: dict, pos_thr: float = 0.5, activate: bool = True) -> List[ScoredLabel]: diff --git a/ote_sdk/ote_sdk/utils/argument_checks.py b/ote_sdk/ote_sdk/utils/argument_checks.py index d14e5027923..30a2b40d70a 100644 --- a/ote_sdk/ote_sdk/utils/argument_checks.py +++ b/ote_sdk/ote_sdk/utils/argument_checks.py @@ -6,8 +6,11 @@ # SPDX-License-Identifier: Apache-2.0 # +import inspect import typing from abc import ABC, abstractmethod +from collections.abc import Sequence +from functools import wraps from os.path import exists import yaml @@ -23,8 +26,14 @@ def raise_value_error_if_parameter_has_unexpected_type( expected_type = (int, float, floating) if not isinstance(parameter, expected_type): parameter_type = type(parameter) + try: + parameter_str = repr(parameter) + # pylint: disable=broad-except + except Exception: + parameter_str = "" raise ValueError( - f"Unexpected type of '{parameter_name}' parameter, expected: {expected_type}, actual: {parameter_type}" + f"Unexpected type of '{parameter_name}' parameter, expected: {expected_type}, actual: {parameter_type}, " + f"actual value: {parameter_str}" ) @@ -42,6 +51,9 @@ def check_dictionary_keys_values_type( parameter, parameter_name, expected_key_class, expected_value_class ): """Function raises ValueError exception if dictionary key or value has unexpected type""" + raise_value_error_if_parameter_has_unexpected_type( + parameter=parameter, parameter_name=parameter_name, expected_type=dict + ) for key, value in parameter.items(): check_parameter_type( parameter=key, @@ -58,7 +70,7 @@ def check_dictionary_keys_values_type( def check_parameter_type(parameter, parameter_name, expected_type): """Function extracts nested expected types and raises ValueError exception if parameter has unexpected type""" # pylint: disable=W0212 - if expected_type == typing.Any: + if expected_type in [typing.Any, inspect._empty]: # type: ignore return if not isinstance(expected_type, typing._GenericAlias): # type: ignore raise_value_error_if_parameter_has_unexpected_type( @@ -67,84 +79,98 @@ def check_parameter_type(parameter, parameter_name, expected_type): expected_type=expected_type, ) return - origin_class = expected_type.__dict__.get("__origin__") - # Checking origin class - raise_value_error_if_parameter_has_unexpected_type( - parameter=parameter, - parameter_name=parameter_name, - expected_type=origin_class, - ) - # Checking nested elements - args = expected_type.__dict__.get("__args__") - if issubclass(origin_class, typing.Sequence) and args: - if len(args) != 1: - raise TypeError( - "length of nested expected types for Sequence should be equal to 1" - ) - check_nested_elements_type( - iterable=parameter, - parameter_name=parameter_name, - expected_type=args, - ) - elif origin_class == dict and args: - if len(args) != 2: + expected_type_dict = expected_type.__dict__ + origin_class = expected_type_dict.get("__origin__") + nested_elements_class = expected_type_dict.get("__args__") + if origin_class == dict: + if len(nested_elements_class) != 2: raise TypeError( "length of nested expected types for dictionary should be equal to 2" ) - key, value = args + key, value = nested_elements_class check_dictionary_keys_values_type( parameter=parameter, parameter_name=parameter_name, expected_key_class=key, expected_value_class=value, ) - - -class BaseInputArgumentChecker(ABC): - """Abstract class to check input arguments""" - - @abstractmethod - def check(self): - """Abstract method to check input arguments""" - raise NotImplementedError("The check is not implemented") - - -def check_input_param_type(*checks: BaseInputArgumentChecker): - """Function to apply methods on checks according to their type""" - for param_check in checks: - if not isinstance(param_check, BaseInputArgumentChecker): - raise TypeError(f"Wrong parameter of check_input_param: {param_check}") - param_check.check() - - -class RequiredParamTypeCheck(BaseInputArgumentChecker): - """Class to check required input parameters""" - - def __init__(self, parameter, parameter_name, expected_type): - self.parameter = parameter - self.parameter_name = parameter_name - self.expected_type = expected_type - - def check(self): - """Method raises ValueError exception if required parameter has unexpected type""" - check_parameter_type( - parameter=self.parameter, - parameter_name=self.parameter_name, - expected_type=self.expected_type, + if origin_class in [list, set, tuple, Sequence]: + raise_value_error_if_parameter_has_unexpected_type( + parameter=parameter, + parameter_name=parameter_name, + expected_type=origin_class, ) + if len(nested_elements_class) != 1: + raise TypeError( + "length of nested expected types for Sequence should be equal to 1" + ) + check_nested_elements_type( + iterable=parameter, + parameter_name=parameter_name, + expected_type=nested_elements_class, + ) + if origin_class == typing.Union: + expected_args = expected_type_dict.get("__args__") + # Union type with nested elements check + checks_counter = 0 + errors_counter = 0 + for expected_arg in expected_args: + try: + checks_counter += 1 + check_parameter_type(parameter, parameter_name, expected_arg) + except ValueError: + errors_counter += 1 + if errors_counter == checks_counter: + actual_type = type(parameter) + raise ValueError( + f"Unexpected type of '{parameter_name}' parameter, expected: {expected_args}, " + f"actual type: {actual_type}, actual value: {parameter}" + ) -class OptionalParamTypeCheck(RequiredParamTypeCheck): - """Class to check optional input parameters""" - - def check(self): - """Method checks if optional parameter exists and raises ValueError exception if it has unexpected type""" - if self.parameter is not None: - check_parameter_type( - parameter=self.parameter, - parameter_name=self.parameter_name, - expected_type=self.expected_type, - ) +def check_input_parameters_type(checks_types: dict = None): + """Decorator to check input parameters type""" + if checks_types is None: + checks_types = {} + + def _check_input_parameters_type(function): + @wraps(function) + def validate(*args, **kwargs): + # Forming expected types dictionary + signature = inspect.signature(function) + expected_types_map = signature.parameters + if len(expected_types_map) < len(args): + raise TypeError("Too many positional arguments") + # Forming input parameters dictionary + input_parameters_values_map = dict(zip(signature.parameters.keys(), args)) + for key, value in kwargs.items(): + if key in input_parameters_values_map: + raise TypeError( + f"Duplication of the parameter {key} -- both in args and kwargs" + ) + input_parameters_values_map[key] = value + # Checking input parameters type + for parameter in expected_types_map: + input_parameter_actual = input_parameters_values_map.get(parameter) + if input_parameter_actual is None: + default_value = expected_types_map.get(parameter).default + # pylint: disable=protected-access + if default_value != inspect._empty: # type: ignore + input_parameter_actual = default_value + custom_check = checks_types.get(parameter) + if custom_check: + custom_check(input_parameter_actual, parameter).check() + else: + check_parameter_type( + parameter=input_parameter_actual, + parameter_name=parameter, + expected_type=expected_types_map.get(parameter).annotation, + ) + return function(**input_parameters_values_map) + + return validate + + return _check_input_parameters_type def check_file_extension( @@ -161,7 +187,7 @@ def check_file_extension( def check_that_null_character_absents_in_string(parameter: str, parameter_name: str): """Function raises ValueError exception if null character: '\0' is specified in path to file""" if "\0" in parameter: - raise ValueError(f"\\0 is specified in {parameter_name}: {parameter}") + raise ValueError(f"null char \\0 is specified in {parameter_name}: {parameter}") def check_that_file_exists(file_path: str, file_path_name: str): @@ -192,46 +218,109 @@ def check_that_all_characters_printable(parameter, parameter_name, allow_crlf=Fa ) +def check_is_parameter_like_dataset(parameter, parameter_name): + """Function raises ValueError exception if parameter does not have __len__, __getitem__ and get_subset attributes of + DataSet-type object""" + for expected_attribute in ("__len__", "__getitem__", "get_subset"): + if not hasattr(parameter, expected_attribute): + parameter_type = type(parameter) + raise ValueError( + f"parameter '{parameter_name}' is not like DatasetEntity, actual type: {parameter_type} which does " + f"not have expected '{expected_attribute}' dataset attribute" + ) + + +def check_file_path(parameter, parameter_name, expected_file_extensions): + """Function to check file path string objects""" + raise_value_error_if_parameter_has_unexpected_type( + parameter=parameter, + parameter_name=parameter_name, + expected_type=str, + ) + check_that_parameter_is_not_empty( + parameter=parameter, parameter_name=parameter_name + ) + check_file_extension( + file_path=parameter, + file_path_name=parameter_name, + expected_extensions=expected_file_extensions, + ) + check_that_null_character_absents_in_string( + parameter=parameter, parameter_name=parameter_name + ) + check_that_all_characters_printable( + parameter=parameter, parameter_name=parameter_name + ) + check_that_file_exists(file_path=parameter, file_path_name=parameter_name) + + +def check_directory_path(parameter, parameter_name): + """Function to check directory path string objects""" + raise_value_error_if_parameter_has_unexpected_type( + parameter=parameter, + parameter_name=parameter_name, + expected_type=str, + ) + check_that_parameter_is_not_empty( + parameter=parameter, parameter_name=parameter_name + ) + check_that_null_character_absents_in_string( + parameter=parameter, parameter_name=parameter_name + ) + check_that_all_characters_printable( + parameter=parameter, parameter_name=parameter_name + ) + + +class BaseInputArgumentChecker(ABC): + """Abstract class to check input arguments""" + + @abstractmethod + def check(self): + """Abstract method to check input arguments""" + raise NotImplementedError("The check is not implemented") + + class InputConfigCheck(BaseInputArgumentChecker): """Class to check input config_parameters""" - def __init__(self, parameter): + def __init__(self, parameter, parameter_name): self.parameter = parameter + self.parameter_name = parameter_name def check(self): """Method raises ValueError exception if "input_config" parameter is not equal to expected""" - parameter_name = "input_config" raise_value_error_if_parameter_has_unexpected_type( parameter=self.parameter, - parameter_name=parameter_name, + parameter_name=self.parameter_name, expected_type=(str, DictConfig, dict), ) check_that_parameter_is_not_empty( - parameter=self.parameter, parameter_name=parameter_name + parameter=self.parameter, parameter_name=self.parameter_name ) if isinstance(self.parameter, str): check_that_null_character_absents_in_string( - parameter=self.parameter, parameter_name=parameter_name + parameter=self.parameter, parameter_name=self.parameter_name ) # yaml-format string is specified if isinstance(yaml.safe_load(self.parameter), dict): check_that_all_characters_printable( parameter=self.parameter, - parameter_name=parameter_name, + parameter_name=self.parameter_name, allow_crlf=True, ) # Path to file is specified else: check_file_extension( file_path=self.parameter, - file_path_name=parameter_name, + file_path_name=self.parameter_name, expected_extensions=["yaml"], ) check_that_all_characters_printable( - parameter=self.parameter, parameter_name=parameter_name + parameter=self.parameter, parameter_name=self.parameter_name ) check_that_file_exists( - file_path=self.parameter, file_path_name=parameter_name + file_path=self.parameter, file_path_name=self.parameter_name ) @@ -245,44 +334,29 @@ def __init__(self, parameter, parameter_name, expected_file_extension): def check(self): """Method raises ValueError exception if file path parameter is not equal to expected""" - raise_value_error_if_parameter_has_unexpected_type( - parameter=self.parameter, - parameter_name=self.parameter_name, - expected_type=str, - ) - check_that_parameter_is_not_empty( - parameter=self.parameter, parameter_name=self.parameter_name - ) - check_file_extension( - file_path=self.parameter, - file_path_name=self.parameter_name, - expected_extensions=self.expected_file_extensions, - ) - check_that_null_character_absents_in_string( - parameter=self.parameter, parameter_name=self.parameter_name - ) - check_that_all_characters_printable( - parameter=self.parameter, parameter_name=self.parameter_name - ) - check_that_file_exists( - file_path=self.parameter, file_path_name=self.parameter_name + check_file_path( + self.parameter, self.parameter_name, self.expected_file_extensions ) -def check_is_parameter_like_dataset(parameter, parameter_name): - """Function raises ValueError exception if parameter does not have __len__, __getitem__ and get_subset attributes of - DataSet-type object""" - for expected_attribute in ("__len__", "__getitem__", "get_subset"): - if not hasattr(parameter, expected_attribute): - parameter_type = type(parameter) - raise ValueError( - f"parameter {parameter_name} has type {parameter_type} which does not have expected " - f"'{expected_attribute}' dataset attribute" +class OptionalFilePathCheck(BaseInputArgumentChecker): + """Class to check optional file_path-like parameters""" + + def __init__(self, parameter, parameter_name, expected_file_extension): + self.parameter = parameter + self.parameter_name = parameter_name + self.expected_file_extensions = expected_file_extension + + def check(self): + """Method raises ValueError exception if file path parameter is not equal to expected""" + if self.parameter is not None: + check_file_path( + self.parameter, self.parameter_name, self.expected_file_extensions ) class DatasetParamTypeCheck(BaseInputArgumentChecker): - """Class to check DataSet-like parameters""" + """Class to check DatasetEntity-type parameters""" def __init__(self, parameter, parameter_name): self.parameter = parameter @@ -295,45 +369,97 @@ def check(self): ) -class DirectoryPathCheck(BaseInputArgumentChecker): - """Class to check directory_path-like parameters""" +class OptionalDatasetParamTypeCheck(DatasetParamTypeCheck): + """Class to check DatasetEntity-type parameters""" - def __init__(self, parameter, parameter_name, check_exists=False): + def check(self): + """Method raises ValueError exception if parameter is not equal to DataSet""" + if self.parameter is not None: + check_is_parameter_like_dataset( + parameter=self.parameter, parameter_name=self.parameter_name + ) + + +class OptionalModelParamTypeCheck(BaseInputArgumentChecker): + """Class to check ModelEntity-type parameters""" + + def __init__(self, parameter, parameter_name): self.parameter = parameter self.parameter_name = parameter_name - self.check_exists = check_exists def check(self): - """Method raises ValueError exception if file path parameter is not equal to expected""" - raise_value_error_if_parameter_has_unexpected_type( - parameter=self.parameter, - parameter_name=self.parameter_name, - expected_type=str, + """Method raises ValueError exception if parameter is not equal to DataSet""" + if self.parameter is not None: + for expected_attribute in ( + "__train_dataset__", + "__previous_trained_revision__", + "__model_format__", + ): + if not hasattr(self.parameter, expected_attribute): + parameter_type = type(self.parameter) + raise ValueError( + f"parameter '{self.parameter_name}' is not like ModelEntity, actual type: {parameter_type} " + f"which does not have expected '{expected_attribute}' Model attribute" + ) + + +class OptionalImageFilePathCheck(OptionalFilePathCheck): + """Class to check optional image file path parameters""" + + def __init__(self, parameter, parameter_name): + super().__init__( + parameter=parameter, + parameter_name=parameter_name, + expected_file_extension=["jpg", "png"], ) - check_that_parameter_is_not_empty( - parameter=self.parameter, parameter_name=self.parameter_name + + +class YamlFilePathCheck(FilePathCheck): + """Class to check optional yaml file path parameters""" + + def __init__(self, parameter, parameter_name): + super().__init__( + parameter=parameter, + parameter_name=parameter_name, + expected_file_extension=["yaml"], ) - check_that_null_character_absents_in_string( - parameter=self.parameter, parameter_name=self.parameter_name + + +class JsonFilePathCheck(FilePathCheck): + """Class to check optional yaml file path parameters""" + + def __init__(self, parameter, parameter_name): + super().__init__( + parameter=parameter, + parameter_name=parameter_name, + expected_file_extension=["json"], ) - check_that_all_characters_printable( + + +class DirectoryPathCheck(BaseInputArgumentChecker): + """Class to check directory path parameters""" + + def __init__(self, parameter, parameter_name): + self.parameter = parameter + self.parameter_name = parameter_name + + def check(self): + """Method raises ValueError exception if directory path parameter is not equal to expected""" + check_directory_path( parameter=self.parameter, parameter_name=self.parameter_name ) - if self.check_exists: - check_that_file_exists(self.parameter, self.parameter_name) class OptionalDirectoryPathCheck(BaseInputArgumentChecker): - """Class to check optional directory_path-like parameters""" + """Class to check optional directory path parameters""" - def __init__(self, parameter, parameter_name, check_exists=False): + def __init__(self, parameter, parameter_name): self.parameter = parameter self.parameter_name = parameter_name - self.check_exists = check_exists def check(self): - """Method raises ValueError exception if file path parameter is not equal to expected""" + """Method raises ValueError exception if directory path parameter is not equal to expected""" if self.parameter is not None: - DirectoryPathCheck( - self.parameter, self.parameter_name, self.check_exists - ).check() + check_directory_path( + parameter=self.parameter, parameter_name=self.parameter_name + ) From 5463ee497abe4fab5be6610ca3a8d1dec1414134 Mon Sep 17 00:00:00 2001 From: saltykox Date: Tue, 22 Mar 2022 17:13:11 +0300 Subject: [PATCH 06/15] fix type for weight_file --- external/deep-object-reid/torchreid_tasks/openvino_task.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/external/deep-object-reid/torchreid_tasks/openvino_task.py b/external/deep-object-reid/torchreid_tasks/openvino_task.py index 0fe4cd703da..0b6b07a0050 100644 --- a/external/deep-object-reid/torchreid_tasks/openvino_task.py +++ b/external/deep-object-reid/torchreid_tasks/openvino_task.py @@ -87,7 +87,7 @@ def __init__( hparams: OTEClassificationParameters, label_schema: LabelSchemaEntity, model_file: Union[str, bytes], - weight_file: Optional[str, bytes] = None, + weight_file: Union[str, bytes, None] = None, device: str = "CPU", num_requests: int = 1, ): From 90df7bcb05b03c79dcbbef3835441a81152ff0e6 Mon Sep 17 00:00:00 2001 From: saltykox Date: Wed, 23 Mar 2022 10:06:09 +0300 Subject: [PATCH 07/15] optimized imports --- .../tests/sc_input_params_validation/__init__.py | 2 -- .../tests/sc_input_params_validation/helpers.py | 1 + .../test_ote_utils_input_params_validation.py | 4 ++-- 3 files changed, 3 insertions(+), 4 deletions(-) delete mode 100644 external/deep-object-reid/tests/sc_input_params_validation/__init__.py diff --git a/external/deep-object-reid/tests/sc_input_params_validation/__init__.py b/external/deep-object-reid/tests/sc_input_params_validation/__init__.py deleted file mode 100644 index a09dff4a5fa..00000000000 --- a/external/deep-object-reid/tests/sc_input_params_validation/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -""" """ -from .helpers import load_test_dataset diff --git a/external/deep-object-reid/tests/sc_input_params_validation/helpers.py b/external/deep-object-reid/tests/sc_input_params_validation/helpers.py index fca3de701ac..36e80d46919 100644 --- a/external/deep-object-reid/tests/sc_input_params_validation/helpers.py +++ b/external/deep-object-reid/tests/sc_input_params_validation/helpers.py @@ -21,6 +21,7 @@ def load_test_dataset(): """Helper to create test dataset""" + def gen_image(resolution, x1, y1, x2, y2): w, h = resolution image = np.full([h, w, 3], fill_value=255, dtype=np.uint8) diff --git a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_utils_input_params_validation.py b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_utils_input_params_validation.py index d3c781ffec0..2387c669ccf 100644 --- a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_utils_input_params_validation.py +++ b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_utils_input_params_validation.py @@ -6,7 +6,6 @@ from ote_sdk.tests.parameters_validation.validation_helper import ( check_value_error_exception_raised, ) - from torchreid_tasks.utils import ( ClassificationDatasetAdapter, active_score_from_probs, @@ -25,7 +24,8 @@ get_multihead_class_info, get_hierarchical_predictions, ) -from .helpers import load_test_dataset + +from helpers import load_test_dataset class TestClassificationDatasetAdapterInputParamsValidation: From a902f5caf40b4eb48b18aaaf67a001979499329a Mon Sep 17 00:00:00 2001 From: saltykox Date: Wed, 23 Mar 2022 11:18:51 +0300 Subject: [PATCH 08/15] updated expected types of features and predictions parameters --- .../test_ote_classification_input_params_validation.py | 7 +++---- .../test_ote_utils_input_params_validation.py | 9 ++++----- .../torchreid_tasks/model_wrappers/classification.py | 6 +++--- external/deep-object-reid/torchreid_tasks/utils.py | 8 ++++---- 4 files changed, 14 insertions(+), 16 deletions(-) diff --git a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_classification_input_params_validation.py b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_classification_input_params_validation.py index daf62592b0a..b1b6b6d3083 100644 --- a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_classification_input_params_validation.py +++ b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_classification_input_params_validation.py @@ -225,7 +225,7 @@ def test_preprocess_features_for_actmap_parameters_params_validation(self): input parameter for "preprocess_features_for_actmap" function """ with pytest.raises(ValueError): - preprocess_features_for_actmap(features={"unexpected": "dict"}) # type: ignore + preprocess_features_for_actmap(features=None) # type: ignore @e2e_pytest_unit def test_get_actmap_params_validation(self): @@ -240,16 +240,15 @@ def test_get_actmap_params_validation(self): Test passes if ValueError exception is raised when unexpected type object is specified as input parameter for "get_actmap" function """ - unexpected_dict = {"unexpected": "dictionary"} correct_values_dict = { "features": ["some", "features"], "output_res": ("iterable", "object") } unexpected_values = [ # Unexpected dictionary is specified as "features" parameter - ("features", unexpected_dict), + ("features", None), # Unexpected dictionary is specified as "output_res" parameter - ("output_res", unexpected_dict), + ("output_res", {"unexpected": "dictionary"}), ] check_value_error_exception_raised( diff --git a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_utils_input_params_validation.py b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_utils_input_params_validation.py index 2387c669ccf..f32c9c07587 100644 --- a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_utils_input_params_validation.py +++ b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_utils_input_params_validation.py @@ -297,7 +297,7 @@ def test_preprocess_features_for_actmap_parameters_params_validation(self): input parameter for "preprocess_features_for_actmap" function """ with pytest.raises(ValueError): - preprocess_features_for_actmap(features={"unexpected": "dict"}) # type: ignore + preprocess_features_for_actmap(features=None) # type: ignore @e2e_pytest_unit def test_get_actmap_params_validation(self): @@ -312,16 +312,15 @@ def test_get_actmap_params_validation(self): Test passes if ValueError exception is raised when unexpected type object is specified as input parameter for "get_actmap" function """ - unexpected_dict = {"unexpected": "dictionary"} correct_values_dict = { "features": ["some", "features"], "output_res": ("iterable", "object") } unexpected_values = [ # Unexpected dictionary is specified as "features" parameter - ("features", unexpected_dict), + ("features", None), # Unexpected dictionary is specified as "output_res" parameter - ("output_res", unexpected_dict), + ("output_res", {"unexpected": "dictionary"}), ] check_value_error_exception_raised( @@ -344,7 +343,7 @@ def test_active_score_from_probs_parameters_params_validation(self): input parameter for "active_score_from_probs" function """ with pytest.raises(ValueError): - active_score_from_probs(predictions={}) # type: ignore + active_score_from_probs(predictions=None) # type: ignore @e2e_pytest_unit def test_sigmoid_numpy_parameters_params_validation(self): diff --git a/external/deep-object-reid/torchreid_tasks/model_wrappers/classification.py b/external/deep-object-reid/torchreid_tasks/model_wrappers/classification.py index 250d92b0282..6272fc31ac7 100644 --- a/external/deep-object-reid/torchreid_tasks/model_wrappers/classification.py +++ b/external/deep-object-reid/torchreid_tasks/model_wrappers/classification.py @@ -14,7 +14,7 @@ import cv2 import numpy as np -from typing import Any, Dict, Union +from typing import Any, Dict, Iterable, Union from ote_sdk.utils.argument_checks import check_input_parameters_type @@ -101,7 +101,7 @@ def postprocess_aux_outputs(self, outputs: Dict[str, np.ndarray], metadata: Dict @check_input_parameters_type() -def preprocess_features_for_actmap(features: Union[np.ndarray, int, float, str, tuple, list]): +def preprocess_features_for_actmap(features: Union[np.ndarray, Iterable, int, float]): features = np.mean(features, axis=1) b, h, w = features.shape features = features.reshape(b, h * w) @@ -112,7 +112,7 @@ def preprocess_features_for_actmap(features: Union[np.ndarray, int, float, str, @check_input_parameters_type() -def get_actmap(features: Union[np.ndarray, int, float, str, tuple, list], +def get_actmap(features: Union[np.ndarray, Iterable, int, float], output_res: Union[tuple, list]): am = cv2.resize(features, output_res) am = 255 * (am - np.min(am)) / (np.max(am) - np.min(am) + 1e-12) diff --git a/external/deep-object-reid/torchreid_tasks/utils.py b/external/deep-object-reid/torchreid_tasks/utils.py index e3cb8a3ab89..efe4ae1e8e4 100644 --- a/external/deep-object-reid/torchreid_tasks/utils.py +++ b/external/deep-object-reid/torchreid_tasks/utils.py @@ -24,7 +24,7 @@ import time from os import path as osp from operator import itemgetter -from typing import List, Union +from typing import Iterable, List, Union import cv2 as cv import numpy as np @@ -418,7 +418,7 @@ def on_test_batch_end(self, batch=None, logs=None): @check_input_parameters_type() -def preprocess_features_for_actmap(features: Union[np.ndarray, int, float, str, tuple, list]): +def preprocess_features_for_actmap(features: Union[np.ndarray, Iterable, int, float]): features = np.mean(features, axis=1) b, h, w = features.shape features = features.reshape(b, h * w) @@ -429,7 +429,7 @@ def preprocess_features_for_actmap(features: Union[np.ndarray, int, float, str, @check_input_parameters_type() -def get_actmap(features: Union[np.ndarray, int, float, str, tuple, list], +def get_actmap(features: Union[np.ndarray, Iterable, int, float], output_res: Union[tuple, list]): am = cv.resize(features, output_res) am = 255 * (am - np.min(am)) / (np.max(am) - np.min(am) + 1e-12) @@ -439,7 +439,7 @@ def get_actmap(features: Union[np.ndarray, int, float, str, tuple, list], @check_input_parameters_type() -def active_score_from_probs(predictions: Union[np.ndarray, int, float, str, tuple, list]): +def active_score_from_probs(predictions: Union[np.ndarray, Iterable, int, float]): top_idxs = np.argpartition(predictions, -2)[-2:] top_probs = predictions[top_idxs] return np.max(top_probs) - np.min(top_probs) From b028fa281abe08e674fc2dd9bd9e2f095e61d161 Mon Sep 17 00:00:00 2001 From: saltykox Date: Wed, 23 Mar 2022 11:35:18 +0300 Subject: [PATCH 09/15] updated check_parameter_type function --- ote_sdk/ote_sdk/utils/argument_checks.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/ote_sdk/ote_sdk/utils/argument_checks.py b/ote_sdk/ote_sdk/utils/argument_checks.py index 30a2b40d70a..e4a300a7d07 100644 --- a/ote_sdk/ote_sdk/utils/argument_checks.py +++ b/ote_sdk/ote_sdk/utils/argument_checks.py @@ -72,7 +72,7 @@ def check_parameter_type(parameter, parameter_name, expected_type): # pylint: disable=W0212 if expected_type in [typing.Any, inspect._empty]: # type: ignore return - if not isinstance(expected_type, typing._GenericAlias): # type: ignore + if (not isinstance(expected_type, typing._GenericAlias)) or (expected_type == typing.Iterable): # type: ignore raise_value_error_if_parameter_has_unexpected_type( parameter=parameter, parameter_name=parameter_name, @@ -126,6 +126,8 @@ def check_parameter_type(parameter, parameter_name, expected_type): f"Unexpected type of '{parameter_name}' parameter, expected: {expected_args}, " f"actual type: {actual_type}, actual value: {parameter}" ) + if origin_class == typing.Iterable: + check_input_parameters_type() def check_input_parameters_type(checks_types: dict = None): From 5147863b78f854840cf75c7cc290b04c17b2c4fc Mon Sep 17 00:00:00 2001 From: saltykox Date: Fri, 25 Mar 2022 16:37:49 +0300 Subject: [PATCH 10/15] updated function in ote_sdk/ote_sdk/utils/argument_checks.py, added test to cover get_hierarchical_predictions parameters validation --- ..._classification_input_params_validation.py | 36 +++ ...e_openvino_task_input_params_validation.py | 2 +- ..._ote_train_task_input_params_validation.py | 2 +- .../model_wrappers/classification.py | 1 + ote_sdk/ote_sdk/utils/argument_checks.py | 213 +++++++++++------- 5 files changed, 169 insertions(+), 85 deletions(-) diff --git a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_classification_input_params_validation.py b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_classification_input_params_validation.py index b1b6b6d3083..6393c051e3b 100644 --- a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_classification_input_params_validation.py +++ b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_classification_input_params_validation.py @@ -9,6 +9,7 @@ OteClassification, sigmoid_numpy, softmax_numpy, + get_hierarchical_predictions, get_multiclass_predictions, get_multilabel_predictions, preprocess_features_for_actmap, @@ -54,6 +55,41 @@ def test_softmax_numpy_params_validation(self): with pytest.raises(ValueError): softmax_numpy(x="unexpected string") # type: ignore + @e2e_pytest_unit + def test_get_hierarchical_predictions_params_validation(self): + """ + Description: + Check "get_hierarchical_predictions" function input parameters validation + + Input data: + "get_hierarchical_predictions" unexpected type parameters + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "get_hierarchical_predictions" function + """ + correct_values_dict = { + "logits": np.random.randint(low=0, high=255, size=(10, 16, 3)), + "multihead_class_info": {"multihead": "dictionary"}, + } + unexpected_str = "unexpected string" + unexpected_values = [ + # Unexpected string is specified as "logits" parameter + ("logits", unexpected_str), + # Unexpected string is specified as "multihead_class_info" parameter + ("multihead_class_info", unexpected_str), + # Unexpected string is specified as "pos_thr" parameter + ("pos_thr", unexpected_str), + # Unexpected string is specified as "activate" parameter + ("activate", unexpected_str), + ] + + check_value_error_exception_raised( + correct_parameters=correct_values_dict, + unexpected_values=unexpected_values, + class_or_function=get_hierarchical_predictions, + ) + @e2e_pytest_unit def test_get_multiclass_predictions_params_validation(self): """ diff --git a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_openvino_task_input_params_validation.py b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_openvino_task_input_params_validation.py index e69a205f318..3774096b013 100644 --- a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_openvino_task_input_params_validation.py +++ b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_openvino_task_input_params_validation.py @@ -45,7 +45,7 @@ def __init__(self): pass -class TestOpenVINODetectionTaskInputParamsValidation: +class TestOpenVINOClassificationTaskInputParamsValidation: @e2e_pytest_unit def test_openvino_task_init_params_validation(self): """ diff --git a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_train_task_input_params_validation.py b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_train_task_input_params_validation.py index 5d7e4f6972f..cef38871153 100644 --- a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_train_task_input_params_validation.py +++ b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_train_task_input_params_validation.py @@ -67,7 +67,7 @@ def test_ote_classification_train_task_save_model_input_params_validation(self): task.save_model(output_model="unexpected string") # type: ignore @e2e_pytest_unit - def test_ote_classification_train_task_input_params_validation(self): + def test_ote_classification_train_task_train_input_params_validation(self): """ Description: Check OTEClassificationTrainingTask object "train" method input parameters validation diff --git a/external/deep-object-reid/torchreid_tasks/model_wrappers/classification.py b/external/deep-object-reid/torchreid_tasks/model_wrappers/classification.py index 5595f620866..e6dca308d93 100644 --- a/external/deep-object-reid/torchreid_tasks/model_wrappers/classification.py +++ b/external/deep-object-reid/torchreid_tasks/model_wrappers/classification.py @@ -164,6 +164,7 @@ def get_hierarchical_predictions(logits: np.ndarray, multihead_class_info: dict, return predicted_labels +@check_input_parameters_type() def get_multiclass_predictions(logits: np.ndarray, activate: bool = True): index = np.argmax(logits) diff --git a/ote_sdk/ote_sdk/utils/argument_checks.py b/ote_sdk/ote_sdk/utils/argument_checks.py index e4a300a7d07..1d383a9e373 100644 --- a/ote_sdk/ote_sdk/utils/argument_checks.py +++ b/ote_sdk/ote_sdk/utils/argument_checks.py @@ -7,30 +7,84 @@ # import inspect +import itertools import typing from abc import ABC, abstractmethod from collections.abc import Sequence from functools import wraps -from os.path import exists +from os.path import exists, splitext import yaml from numpy import floating from omegaconf import DictConfig +IMAGE_FILE_EXTENSIONS = [ + ".bmp", + ".dib", + ".jpeg", + ".jpg", + ".jpe", + ".jp2", + ".png", + ".webp", + ".pbm", + ".pgm", + ".ppm", + ".pxm", + ".pnm", + ".sr", + ".ras", + ".tiff", + ".tif", + ".exr", + ".hdr", + ".pic", +] + + +def get_bases(parameter) -> set: + """Function to get set of all base classes of parameter""" + + def __get_bases(parameter_type): + return [parameter_type.__name__] + list( + itertools.chain.from_iterable( + __get_bases(t1) for t1 in parameter_type.__bases__ + ) + ) + + return set(__get_bases(type(parameter))) + + +def get_parameter_repr(parameter) -> str: + """Function to get parameter representation""" + try: + parameter_str = repr(parameter) + # pylint: disable=broad-except + except Exception: + parameter_str = "" + return parameter_str + def raise_value_error_if_parameter_has_unexpected_type( parameter, parameter_name, expected_type ): """Function raises ValueError exception if parameter has unexpected type""" + if isinstance(expected_type, typing.ForwardRef): + expected_type = expected_type.__forward_arg__ + if isinstance(expected_type, str): + parameter_types = get_bases(parameter) + if not any(t == expected_type for t in parameter_types): + parameter_str = get_parameter_repr(parameter) + raise ValueError( + f"Unexpected type of '{parameter_name}' parameter, expected: {expected_type}, " + f"actual value: {parameter_str}" + ) + return if expected_type == float: expected_type = (int, float, floating) if not isinstance(parameter, expected_type): parameter_type = type(parameter) - try: - parameter_str = repr(parameter) - # pylint: disable=broad-except - except Exception: - parameter_str = "" + parameter_str = get_parameter_repr(parameter) raise ValueError( f"Unexpected type of '{parameter_name}' parameter, expected: {expected_type}, actual: {parameter_type}, " f"actual value: {parameter_str}" @@ -67,21 +121,10 @@ def check_dictionary_keys_values_type( ) -def check_parameter_type(parameter, parameter_name, expected_type): - """Function extracts nested expected types and raises ValueError exception if parameter has unexpected type""" - # pylint: disable=W0212 - if expected_type in [typing.Any, inspect._empty]: # type: ignore - return - if (not isinstance(expected_type, typing._GenericAlias)) or (expected_type == typing.Iterable): # type: ignore - raise_value_error_if_parameter_has_unexpected_type( - parameter=parameter, - parameter_name=parameter_name, - expected_type=expected_type, - ) - return - expected_type_dict = expected_type.__dict__ - origin_class = expected_type_dict.get("__origin__") - nested_elements_class = expected_type_dict.get("__args__") +def check_nested_classes_parameters( + parameter, parameter_name, origin_class, nested_elements_class +): + """Function to check type of parameters with nested elements""" if origin_class == dict: if len(nested_elements_class) != 2: raise TypeError( @@ -100,18 +143,53 @@ def check_parameter_type(parameter, parameter_name, expected_type): parameter_name=parameter_name, expected_type=origin_class, ) - if len(nested_elements_class) != 1: - raise TypeError( - "length of nested expected types for Sequence should be equal to 1" - ) + if origin_class == tuple: + tuple_length = len(nested_elements_class) + if tuple_length > 2: + raise NotImplementedError( + "length of nested expected types for Tuple should not exceed 2" + ) + if tuple_length == 2: + if nested_elements_class[1] != Ellipsis: + raise NotImplementedError("expected homogeneous tuple annotation") + nested_elements_class = nested_elements_class[0] + else: + if len(nested_elements_class) != 1: + raise TypeError( + "length of nested expected types for Sequence should be equal to 1" + ) check_nested_elements_type( iterable=parameter, parameter_name=parameter_name, expected_type=nested_elements_class, ) + + +def check_parameter_type(parameter, parameter_name, expected_type): + """Function extracts nested expected types and raises ValueError exception if parameter has unexpected type""" + # pylint: disable=W0212 + if expected_type in [typing.Any, inspect._empty]: # type: ignore + return + if not isinstance(expected_type, typing._GenericAlias): # type: ignore + raise_value_error_if_parameter_has_unexpected_type( + parameter=parameter, + parameter_name=parameter_name, + expected_type=expected_type, + ) + return + # Checking parameters with nested elements + expected_type_dict = expected_type.__dict__ + origin_class = expected_type_dict.get("__origin__") + nested_elements_class = expected_type_dict.get("__args__") + check_nested_classes_parameters( + parameter=parameter, + parameter_name=parameter_name, + origin_class=origin_class, + nested_elements_class=nested_elements_class, + ) + # Union type with nested elements check if origin_class == typing.Union: expected_args = expected_type_dict.get("__args__") - # Union type with nested elements check checks_counter = 0 errors_counter = 0 for expected_arg in expected_args: @@ -126,14 +204,15 @@ def check_parameter_type(parameter, parameter_name, expected_type): f"Unexpected type of '{parameter_name}' parameter, expected: {expected_args}, " f"actual type: {actual_type}, actual value: {parameter}" ) - if origin_class == typing.Iterable: - check_input_parameters_type() -def check_input_parameters_type(checks_types: dict = None): - """Decorator to check input parameters type""" - if checks_types is None: - checks_types = {} +def check_input_parameters_type(custom_checks: typing.Optional[dict] = None): + """ + Decorator to check input parameters type + :param custom_checks: dictionary where key - name of parameter and value - custom check class + """ + if custom_checks is None: + custom_checks = {} def _check_input_parameters_type(function): @wraps(function) @@ -152,21 +231,23 @@ def validate(*args, **kwargs): ) input_parameters_values_map[key] = value # Checking input parameters type - for parameter in expected_types_map: - input_parameter_actual = input_parameters_values_map.get(parameter) - if input_parameter_actual is None: - default_value = expected_types_map.get(parameter).default + for parameter_name in expected_types_map: + parameter = input_parameters_values_map.get(parameter_name) + if parameter is None: + default_value = expected_types_map.get(parameter_name).default # pylint: disable=protected-access if default_value != inspect._empty: # type: ignore - input_parameter_actual = default_value - custom_check = checks_types.get(parameter) - if custom_check: - custom_check(input_parameter_actual, parameter).check() + parameter = default_value + if parameter_name in custom_checks: + custom_check = custom_checks[parameter_name] + if custom_check is None: + continue + custom_check(parameter, parameter_name).check() else: check_parameter_type( - parameter=input_parameter_actual, - parameter_name=parameter, - expected_type=expected_types_map.get(parameter).annotation, + parameter=parameter, + parameter_name=parameter_name, + expected_type=expected_types_map.get(parameter_name).annotation, ) return function(**input_parameters_values_map) @@ -179,7 +260,7 @@ def check_file_extension( file_path: str, file_path_name: str, expected_extensions: list ): """Function raises ValueError exception if file has unexpected extension""" - file_extension = file_path.split(".")[-1].lower() + file_extension = splitext(file_path)[1].lower() if file_extension not in expected_extensions: raise ValueError( f"Unexpected extension of {file_path_name} file. expected: {expected_extensions} actual: {file_extension}" @@ -316,7 +397,7 @@ def check(self): check_file_extension( file_path=self.parameter, file_path_name=self.parameter_name, - expected_extensions=["yaml"], + expected_extensions=[".yaml"], ) check_that_all_characters_printable( parameter=self.parameter, parameter_name=self.parameter_name @@ -365,46 +446,12 @@ def __init__(self, parameter, parameter_name): self.parameter_name = parameter_name def check(self): - """Method raises ValueError exception if parameter is not equal to DataSet""" + """Method raises ValueError exception if parameter is not equal to Dataset""" check_is_parameter_like_dataset( parameter=self.parameter, parameter_name=self.parameter_name ) -class OptionalDatasetParamTypeCheck(DatasetParamTypeCheck): - """Class to check DatasetEntity-type parameters""" - - def check(self): - """Method raises ValueError exception if parameter is not equal to DataSet""" - if self.parameter is not None: - check_is_parameter_like_dataset( - parameter=self.parameter, parameter_name=self.parameter_name - ) - - -class OptionalModelParamTypeCheck(BaseInputArgumentChecker): - """Class to check ModelEntity-type parameters""" - - def __init__(self, parameter, parameter_name): - self.parameter = parameter - self.parameter_name = parameter_name - - def check(self): - """Method raises ValueError exception if parameter is not equal to DataSet""" - if self.parameter is not None: - for expected_attribute in ( - "__train_dataset__", - "__previous_trained_revision__", - "__model_format__", - ): - if not hasattr(self.parameter, expected_attribute): - parameter_type = type(self.parameter) - raise ValueError( - f"parameter '{self.parameter_name}' is not like ModelEntity, actual type: {parameter_type} " - f"which does not have expected '{expected_attribute}' Model attribute" - ) - - class OptionalImageFilePathCheck(OptionalFilePathCheck): """Class to check optional image file path parameters""" @@ -412,7 +459,7 @@ def __init__(self, parameter, parameter_name): super().__init__( parameter=parameter, parameter_name=parameter_name, - expected_file_extension=["jpg", "png"], + expected_file_extension=IMAGE_FILE_EXTENSIONS, ) @@ -423,7 +470,7 @@ def __init__(self, parameter, parameter_name): super().__init__( parameter=parameter, parameter_name=parameter_name, - expected_file_extension=["yaml"], + expected_file_extension=[".yaml"], ) @@ -434,7 +481,7 @@ def __init__(self, parameter, parameter_name): super().__init__( parameter=parameter, parameter_name=parameter_name, - expected_file_extension=["json"], + expected_file_extension=[".json"], ) From 7d728e48e3bfd272354d76efa685f530a962826e Mon Sep 17 00:00:00 2001 From: saltykox Date: Fri, 25 Mar 2022 17:39:13 +0300 Subject: [PATCH 11/15] fixed test_get_actmap_params_validation tests --- .../test_ote_classification_input_params_validation.py | 2 +- .../test_ote_utils_input_params_validation.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_classification_input_params_validation.py b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_classification_input_params_validation.py index 6393c051e3b..7855979ef47 100644 --- a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_classification_input_params_validation.py +++ b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_classification_input_params_validation.py @@ -284,7 +284,7 @@ def test_get_actmap_params_validation(self): # Unexpected dictionary is specified as "features" parameter ("features", None), # Unexpected dictionary is specified as "output_res" parameter - ("output_res", {"unexpected": "dictionary"}), + ("output_res", None), ] check_value_error_exception_raised( diff --git a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_utils_input_params_validation.py b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_utils_input_params_validation.py index f32c9c07587..82e4795b8fa 100644 --- a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_utils_input_params_validation.py +++ b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_utils_input_params_validation.py @@ -320,7 +320,7 @@ def test_get_actmap_params_validation(self): # Unexpected dictionary is specified as "features" parameter ("features", None), # Unexpected dictionary is specified as "output_res" parameter - ("output_res", {"unexpected": "dictionary"}), + ("output_res", None), ] check_value_error_exception_raised( From 3e6052aa57ddfcb54571f277e3a9029cb3d95d03 Mon Sep 17 00:00:00 2001 From: saltykox Date: Mon, 28 Mar 2022 09:03:24 +0300 Subject: [PATCH 12/15] updated check_parameter_type function --- ote_sdk/ote_sdk/utils/argument_checks.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ote_sdk/ote_sdk/utils/argument_checks.py b/ote_sdk/ote_sdk/utils/argument_checks.py index 1d383a9e373..ade09aef9b4 100644 --- a/ote_sdk/ote_sdk/utils/argument_checks.py +++ b/ote_sdk/ote_sdk/utils/argument_checks.py @@ -170,7 +170,7 @@ def check_parameter_type(parameter, parameter_name, expected_type): # pylint: disable=W0212 if expected_type in [typing.Any, inspect._empty]: # type: ignore return - if not isinstance(expected_type, typing._GenericAlias): # type: ignore + if not isinstance(expected_type, typing._GenericAlias) or expected_type == typing.Iterable: # type: ignore raise_value_error_if_parameter_has_unexpected_type( parameter=parameter, parameter_name=parameter_name, From d8807f4a66b9b7caf7f96db9d3138d15b1df9454 Mon Sep 17 00:00:00 2001 From: saltykox Date: Mon, 28 Mar 2022 09:48:56 +0300 Subject: [PATCH 13/15] refactored nested elements checks --- ote_sdk/ote_sdk/utils/argument_checks.py | 30 +++++++++++------------- 1 file changed, 14 insertions(+), 16 deletions(-) diff --git a/ote_sdk/ote_sdk/utils/argument_checks.py b/ote_sdk/ote_sdk/utils/argument_checks.py index ade09aef9b4..c0db4193b34 100644 --- a/ote_sdk/ote_sdk/utils/argument_checks.py +++ b/ote_sdk/ote_sdk/utils/argument_checks.py @@ -105,9 +105,6 @@ def check_dictionary_keys_values_type( parameter, parameter_name, expected_key_class, expected_value_class ): """Function raises ValueError exception if dictionary key or value has unexpected type""" - raise_value_error_if_parameter_has_unexpected_type( - parameter=parameter, parameter_name=parameter_name, expected_type=dict - ) for key, value in parameter.items(): check_parameter_type( parameter=key, @@ -125,6 +122,11 @@ def check_nested_classes_parameters( parameter, parameter_name, origin_class, nested_elements_class ): """Function to check type of parameters with nested elements""" + # Checking origin class + raise_value_error_if_parameter_has_unexpected_type( + parameter=parameter, parameter_name=parameter_name, expected_type=origin_class + ) + # Checking nested elements if origin_class == dict: if len(nested_elements_class) != 2: raise TypeError( @@ -138,11 +140,6 @@ def check_nested_classes_parameters( expected_value_class=value, ) if origin_class in [list, set, tuple, Sequence]: - raise_value_error_if_parameter_has_unexpected_type( - parameter=parameter, - parameter_name=parameter_name, - expected_type=origin_class, - ) if origin_class == tuple: tuple_length = len(nested_elements_class) if tuple_length > 2: @@ -170,23 +167,16 @@ def check_parameter_type(parameter, parameter_name, expected_type): # pylint: disable=W0212 if expected_type in [typing.Any, inspect._empty]: # type: ignore return - if not isinstance(expected_type, typing._GenericAlias) or expected_type == typing.Iterable: # type: ignore + if not isinstance(expected_type, typing._GenericAlias): # type: ignore raise_value_error_if_parameter_has_unexpected_type( parameter=parameter, parameter_name=parameter_name, expected_type=expected_type, ) return - # Checking parameters with nested elements expected_type_dict = expected_type.__dict__ origin_class = expected_type_dict.get("__origin__") nested_elements_class = expected_type_dict.get("__args__") - check_nested_classes_parameters( - parameter=parameter, - parameter_name=parameter_name, - origin_class=origin_class, - nested_elements_class=nested_elements_class, - ) # Union type with nested elements check if origin_class == typing.Union: expected_args = expected_type_dict.get("__args__") @@ -204,6 +194,14 @@ def check_parameter_type(parameter, parameter_name, expected_type): f"Unexpected type of '{parameter_name}' parameter, expected: {expected_args}, " f"actual type: {actual_type}, actual value: {parameter}" ) + # Checking parameters with nested elements + elif issubclass(origin_class, typing.Iterable): + check_nested_classes_parameters( + parameter=parameter, + parameter_name=parameter_name, + origin_class=origin_class, + nested_elements_class=nested_elements_class, + ) def check_input_parameters_type(custom_checks: typing.Optional[dict] = None): From b57cc1ef12deea29adfb1f87c170f52a0fd93b8c Mon Sep 17 00:00:00 2001 From: saltykox Date: Tue, 5 Apr 2022 15:20:44 +0300 Subject: [PATCH 14/15] updated check_input_parameters_type --- ..._classification_input_params_validation.py | 92 +++++++++---------- ote_sdk/ote_sdk/utils/argument_checks.py | 8 +- 2 files changed, 51 insertions(+), 49 deletions(-) diff --git a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_classification_input_params_validation.py b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_classification_input_params_validation.py index 7855979ef47..b3f637efef2 100644 --- a/external/deep-object-reid/tests/sc_input_params_validation/test_ote_classification_input_params_validation.py +++ b/external/deep-object-reid/tests/sc_input_params_validation/test_ote_classification_input_params_validation.py @@ -23,6 +23,52 @@ def __init__(self): class TestClassificationFunctionsParamsValidation: + @e2e_pytest_unit + def test_preprocess_features_for_actmap_parameters_params_validation(self): + """ + Description: + Check "preprocess_features_for_actmap" function input parameters validation + + Input data: + "features" non-expected type object + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "preprocess_features_for_actmap" function + """ + with pytest.raises(ValueError): + preprocess_features_for_actmap(features=None) # type: ignore + + @e2e_pytest_unit + def test_get_actmap_params_validation(self): + """ + Description: + Check "get_actmap" function input parameters validation + + Input data: + "get_actmap" unexpected type parameters + + Expected results: + Test passes if ValueError exception is raised when unexpected type object is specified as + input parameter for "get_actmap" function + """ + correct_values_dict = { + "features": ["some", "features"], + "output_res": ("iterable", "object") + } + unexpected_values = [ + # Unexpected dictionary is specified as "features" parameter + ("features", None), + # Unexpected dictionary is specified as "output_res" parameter + ("output_res", None), + ] + + check_value_error_exception_raised( + correct_parameters=correct_values_dict, + unexpected_values=unexpected_values, + class_or_function=get_actmap, + ) + @e2e_pytest_unit def test_sigmoid_numpy_params_validation(self): """ @@ -246,49 +292,3 @@ def test_ote_classification_postprocess_aux_outputs_params_validation(self): unexpected_values=unexpected_values, class_or_function=classification.postprocess_aux_outputs, ) - - @e2e_pytest_unit - def test_preprocess_features_for_actmap_parameters_params_validation(self): - """ - Description: - Check "preprocess_features_for_actmap" function input parameters validation - - Input data: - "features" non-expected type object - - Expected results: - Test passes if ValueError exception is raised when unexpected type object is specified as - input parameter for "preprocess_features_for_actmap" function - """ - with pytest.raises(ValueError): - preprocess_features_for_actmap(features=None) # type: ignore - - @e2e_pytest_unit - def test_get_actmap_params_validation(self): - """ - Description: - Check "get_actmap" function input parameters validation - - Input data: - "get_actmap" unexpected type parameters - - Expected results: - Test passes if ValueError exception is raised when unexpected type object is specified as - input parameter for "get_actmap" function - """ - correct_values_dict = { - "features": ["some", "features"], - "output_res": ("iterable", "object") - } - unexpected_values = [ - # Unexpected dictionary is specified as "features" parameter - ("features", None), - # Unexpected dictionary is specified as "output_res" parameter - ("output_res", None), - ] - - check_value_error_exception_raised( - correct_parameters=correct_values_dict, - unexpected_values=unexpected_values, - class_or_function=get_actmap, - ) diff --git a/ote_sdk/ote_sdk/utils/argument_checks.py b/ote_sdk/ote_sdk/utils/argument_checks.py index c0db4193b34..a477f17d351 100644 --- a/ote_sdk/ote_sdk/utils/argument_checks.py +++ b/ote_sdk/ote_sdk/utils/argument_checks.py @@ -231,7 +231,7 @@ def validate(*args, **kwargs): # Checking input parameters type for parameter_name in expected_types_map: parameter = input_parameters_values_map.get(parameter_name) - if parameter is None: + if parameter_name not in input_parameters_values_map: default_value = expected_types_map.get(parameter_name).default # pylint: disable=protected-access if default_value != inspect._empty: # type: ignore @@ -268,7 +268,9 @@ def check_file_extension( def check_that_null_character_absents_in_string(parameter: str, parameter_name: str): """Function raises ValueError exception if null character: '\0' is specified in path to file""" if "\0" in parameter: - raise ValueError(f"null char \\0 is specified in {parameter_name}: {parameter}") + raise ValueError( + rf"null char \\0 is specified in {parameter_name}: {parameter}" + ) def check_that_file_exists(file_path: str, file_path_name: str): @@ -295,7 +297,7 @@ def check_that_all_characters_printable(parameter, parameter_name, allow_crlf=Fa ) if not all_characters_printable: raise ValueError( - fr"parameter {parameter_name} has not printable symbols: {parameter}" + rf"parameter {parameter_name} has not printable symbols: {parameter}" ) From 10b7789530fe4e1c888bca575149a08438bf792b Mon Sep 17 00:00:00 2001 From: Slawomir Strehlke Date: Mon, 16 May 2022 11:19:42 +0200 Subject: [PATCH 15/15] Squashed commit of the following: commit 96913c285b1e7d15d358778bbe4a7193350fa9d0 Merge: c8505d3a 61bb2572 Author: Songki Choi Date: Mon May 16 11:45:27 2022 +0900 Merge pull request #1108 from openvinotoolkit/jeom/enable-mbv3-multilabel Enable multilabel classification in mobilenetV3_small commit 61bb2572d50cb70963f2b93ab507de77f2f62255 Author: JihwanEom Date: Mon May 16 11:29:02 2022 +0900 Enable multilabel cls in mobilenetV3_small commit c8505d3afe7d131570002d1fdc38fa960659a2ed Merge: 0db418e3 be831978 Author: Slawomir Strehlke Date: Fri May 13 09:08:20 2022 +0200 Merge pull request #1085 from openvinotoolkit/ashwin/expose_more_params [Anomaly Task] Expose more params to the UI commit 0db418e3e20f6c64a4ea655e12983759100b7f8e Merge: 1b8c08e5 fa03d14c Author: Songki Choi Date: Thu May 12 15:24:23 2022 +0900 Merge pull request #1102 from openvinotoolkit/releases/v0.2.0-sc1.1 Merge back OTE v0.2.0 release fixes commit 1b8c08e5e638717282af0335701d188c3bf34cc5 Merge: 8ff09d23 5bcd7509 Author: Songki Choi Date: Wed May 11 22:19:11 2022 +0900 Merge pull request #1100 from helena-intel/quickstart-guide-checkout Remove `git checkout` from quick start guide commit 5bcd75096c189153ddf6f7b5cd40e0fa06c05557 Author: Helena Kloosterman Date: Wed May 11 11:51:25 2022 +0200 Remove `git checkout` from quick start guide commit fa03d14c593b8c4a90905c7c52784619d1c9c480 Merge: a1839e27 35285677 Author: Songki Choi Date: Wed May 11 16:20:32 2022 +0900 Merge pull request #1098 from openvinotoolkit/mpa-template-disable Disable MPA model template commit 8ff09d23c3a20ec5859c49563ce1054dc66e0a36 Merge: 8c61268e 61c09e25 Author: Songki Choi Date: Wed May 11 11:06:51 2022 +0900 Merge pull request #1093 from vinnamkim/remove-build-dir Remove build directory commit 8c61268e209f99469eab6fb8dbf197780b0e217b Merge: 20c40bb9 9a59311d Author: Songki Choi Date: Wed May 11 11:03:41 2022 +0900 Merge pull request #1094 from vinnamkim/add-inst-seg-graph-references Add nncf graph references for tests commit 35285677b39fda039f480ff1497e674741a62a7d Author: Chun, Emily Date: Wed May 11 11:02:38 2022 +0900 Rename template file name in api test commit cfaeb5f3bf6022639fc3b23089c8b9b116ec664c Author: harimkan Date: Wed May 11 10:01:44 2022 +0900 Disable MPA model template commit 20c40bb9862363310db138ad2d4c2af9f7f1a1ff Merge: cf3e4cf8 74cda9a4 Author: Slawomir Strehlke Date: Tue May 10 15:03:40 2022 +0200 Merge pull request #1097 from openvinotoolkit/sstrehlk/anomaly_validation_report_fix sstrehlk/Extended conftest configuration for anomaly backend. commit 74cda9a48761e9d295231a4c24ded5046e643f0a Author: Slawomir Strehlke Date: Tue May 10 11:30:17 2022 +0200 Some cleaning. commit c11c3acaf1d1c3ffc119a7551797f4b3c4ac59a8 Author: Slawomir Strehlke Date: Tue May 10 11:07:10 2022 +0200 Disabled importing config. commit a1839e27e6d9e9d2c3a3ee2f1f3894f81c764949 Merge: aadce59e 5236bc6c Author: Songki Choi Date: Tue May 10 17:34:57 2022 +0900 Merge pull request #1096 from openvinotoolkit/eugene/fix_fp16 Fix FP16 issue in Instance Segmentation commit aadce59e1ea04760967eba806db2bbf2c2e2ad84 Author: Songki Choi Date: Tue May 10 23:00:00 2022 +0900 Minor update for mmdet commit Signed-off-by: Songki Choi commit f7b8574116784b2c834d520c42a2c21ba590cec1 Author: Slawomir Strehlke Date: Tue May 10 09:28:20 2022 +0200 Extended conftest configuration for anomaly backend. commit 9a59311d565eaae2b59504071197f628a0b83b48 Author: Kim, Vinnam Date: Mon May 9 13:33:29 2022 +0900 Add nncf graph references for tests - Custom_Counting_Instance_Segmentation_MaskRCNN_EfficientNetB2B - Custom_Counting_Instance_Segmentation_MaskRCNN_ResNet50 Signed-off-by: Kim, Vinnam commit be831978b144c4ebf2dada76599c02bf7a60786e Merge: 95d9233d cf3e4cf8 Author: Ashwin Vaidya Date: Mon May 9 13:36:12 2022 +0200 Merge branch 'develop' into ashwin/expose_more_params commit 5236bc6c1ac07c561ce274607d117de925bf7e3e Author: Eugene Liu Date: Mon May 9 10:46:48 2022 +0100 update ote commit 5ea7a473b215952e6ba0f0c25a03008e218c99ee Author: Eugene Liu Date: Mon May 9 10:17:51 2022 +0100 add fp16 back for efficientnetb2b_maskrcnn and add more tests commit 29c0db9552efd4835a42a3884e69559de6aa43e8 Merge: 3ee619f5 0c74b2c2 Author: Songki Choi Date: Mon May 9 17:13:04 2022 +0900 Merge pull request #1095 from openvinotoolkit/songkich/update-changelog Update change logs for release v0.2.0 commit 0c74b2c291219c8de8cb84c69e9840a90cf7eed9 Author: Songki Choi Date: Tue May 10 00:33:49 2022 +0900 Update change logs for OTE & submodules Signed-off-by: Songki Choi commit 61c09e251e5e75c9010f912d151a54ecfe00fa43 Author: Kim, Vinnam Date: Mon May 9 14:55:30 2022 +0900 Remove external/mmdetection/dist/*.egg Signed-off-by: Kim, Vinnam commit 03eb1161a08c3c30e47da8ac81bdb136d4923241 Author: Kim, Vinnam Date: Mon May 9 14:53:30 2022 +0900 Update .gitignore Signed-off-by: Kim, Vinnam commit 9aab98fb8b1e2bd76cafc360f2a9ef0e22dc6f93 Author: Kim, Vinnam Date: Mon May 9 13:25:18 2022 +0900 Remove build directory Signed-off-by: Kim, Vinnam commit cf3e4cf8d14f536302112c69cb933e1686109871 Merge: 9a781280 9092ebed Author: Songki Choi Date: Fri May 6 18:57:41 2022 +0900 Merge pull request #1090 from openvinotoolkit/jeom/detach_ote Align test file convention commit 3ee619f59074d3fb8898e9d4d45bb21d1649c173 Merge: 607a84f6 8f79ccbb Author: Songki Choi Date: Fri May 6 18:56:47 2022 +0900 Merge pull request #1091 from openvinotoolkit/jeom/align_test_resolution Align test resolution (releases/v0.2.0) commit 8f79ccbb325bf1f33076c1396a9ba35d6073ce5c Author: Harim Kang Date: Fri May 6 17:43:14 2022 +0900 pre-commit fix in mmdet commit 9092ebed2e6906bb0c0418d756505a3401dedcc8 Merge: c6c2d573 83c46463 Author: Harim Kang Date: Fri May 6 17:40:40 2022 +0900 Merge branch 'jeom/detach_ote' of https://github.com/openvinotoolkit/training_extensions into jeom/detach_ote commit c6c2d57347f7b9a5d42278ac576de933570c2a03 Author: Harim Kang Date: Fri May 6 17:40:09 2022 +0900 pre-commit failed fix in mmdetection commit 9333ef762322dbdbc39806778f774651d21b76e3 Author: Jihwan Eom Date: Fri May 6 17:31:54 2022 +0900 Update training_tests_actions.py commit 83c464632d0be3676cc919a92d728569d3cb5c73 Author: Jihwan Eom Date: Fri May 6 17:31:49 2022 +0900 Update training_tests_actions.py commit f8e55b9adbea4a5c267c5ab04bc4d30cac0baeee Author: Jihwan Eom Date: Fri May 6 16:58:57 2022 +0900 Rename test_ote_det_cls_il.py to test_det_cls_il.py commit d39bac0b88c47e88abc9937c166f2b0c64fbd573 Author: Jihwan Eom Date: Fri May 6 16:58:40 2022 +0900 Update and rename test_ote_seg_cls_il.py to test_seg_cls_il.py commit aaf099f878500b9072cec900159ab59ba9ab3034 Author: Jihwan Eom Date: Fri May 6 16:58:15 2022 +0900 Rename test_ote_cls_cls_il.py to test_cls_cls_il.py commit e3efb5e55b048083778ad7d4eb25fee9ac67218f Author: Jihwan Eom Date: Fri May 6 16:58:02 2022 +0900 Update test_ote_cls_cls_il.py commit 385c4d9d76dd02b12f9d959eb22e41dc37485f45 Author: Jihwan Eom Date: Fri May 6 16:48:35 2022 +0900 Update test_seg_cls_il.py commit 8c314fc0e68606afd40c19416d27385eda048715 Author: Jihwan Eom Date: Fri May 6 16:47:56 2022 +0900 Update test_cls_cls_il.py commit a68566c509f7153b7f13eadf221d5c374a8213c6 Author: Jihwan Eom Date: Fri May 6 15:22:09 2022 +0900 Rename test_ote_seg_cls_il.py to test_seg_cls_il.py commit da9e1164d0276379d8a91806ab9201de238b7489 Author: Jihwan Eom Date: Fri May 6 15:21:52 2022 +0900 Rename test_ote_det_cls_il.py to test_det_cls_il.py commit 96d6e7855e4e4e413cfa0354cf90590915f35fe7 Author: Jihwan Eom Date: Fri May 6 15:21:38 2022 +0900 Rename test_ote_cls_cls_il.py to test_cls_cls_il.py commit 9a7812808fc568e22013962569dc8ea66127605e Merge: 4b58c235 52feb1c7 Author: Slawomir Strehlke Date: Thu May 5 12:06:36 2022 +0200 Merge pull request #898 from openvinotoolkit/pf/adding_anomaly_training_tests [Anomaly] Added real-life training tests commit 52feb1c7387f1c2166f04371dd8998b258b8166d Author: Slawomir Strehlke Date: Wed May 4 11:52:11 2022 +0200 Added torchmetrics revision constraint commit 607a84f62d326ff4dd9f1f6e6ee95d2859124e4e Merge: 18efbe59 7930a383 Author: Slawomir Strehlke Date: Wed May 4 10:56:02 2022 +0200 Merge pull request #1087 from openvinotoolkit/vsaltykovx/add_mmsegmentation_params_validation_tests [OTE] Added mmsegmentation input parameters validation and tests commit 18efbe59e10fc6149178119085f1b84badf2e480 Merge: 31d3fdf4 4dc5d3ad Author: Songki Choi Date: Wed May 4 15:51:58 2022 +0900 Merge pull request #1084 from openvinotoolkit/class-incr-learning-validation Add model-preparation-algorithm API & training tests commit 95d9233d8eda8bd078b4b6ed4ac2ab4d3fd4ef6f Author: Ashwin Vaidya Date: Tue May 3 09:52:32 2022 +0200 Add max epochs to stfpm commit fb175feffb10cda9d9b7402cfd122f68e2450313 Author: Ashwin Vaidya Date: Tue May 3 09:38:41 2022 +0200 Refactor configurable parameters commit 14e35c001fa7dcb6e260a8a67e45d2ba145b31ab Author: Ashwin Vaidya Date: Mon May 2 16:36:23 2022 +0200 Expose more parame to the UI commit 31d3fdf4c970fed6db0de551f468f1254f4f9bca Merge: d975d182 4465c36a Author: Songki Choi Date: Fri Apr 29 16:24:06 2022 +0900 Merge pull request #1078 from openvinotoolkit/sstrehlk/add_instance_segmentation_training_tests Add Instance Segmentation (object counting) training tests. commit 4465c36a3d81771769600bc2e3f8334ed64182b0 Author: Slawomir Strehlke Date: Tue Apr 26 13:37:07 2022 +0200 Add Instance Segmentation (object counting) training tests. commit 7988814c2b533edac8a8d4ffd81ab101574d1467 Author: pfinashx Date: Tue Apr 5 10:25:54 2022 +0300 Fix pylint commit 2c968f5aa4618a26f1a6ef50ee02afc0b8349190 Merge: 05f1b664 73ec03ea Author: pfinashx Date: Sun Apr 3 21:28:25 2022 +0300 Merge branch 'develop' into pf/adding_anomaly_training_tests commit 05f1b6642317ac3d4cb08363cc7f61321322bde4 Author: pfinashx Date: Fri Apr 1 19:19:42 2022 +0300 Fixed linters commit e3b8e9e0a6039bbbd86b180346b0a0d5e1cd4e1f Author: pfinashx Date: Thu Mar 31 16:09:20 2022 +0300 Added x-fail ticket commit 8af421d1d5134daf4b0eefa23db4de9b4f6cfd14 Merge: 26ad5d18 2bbc890c Author: pfinashx Date: Thu Mar 31 15:56:49 2022 +0300 Merge branch 'develop' into pf/adding_anomaly_training_tests commit 26ad5d18e1441aaf025fe5e08c51d0572172b79d Author: pfinashx Date: Thu Mar 31 15:12:36 2022 +0300 Added NNCF steps commit a396e8b799d13736939476feda29f831d8137f9f Author: pfinashx Date: Thu Mar 31 11:26:52 2022 +0300 Applying comments v2 commit f5733cc7d8af34bcf21fd4a97f21d1c67ae85180 Merge: ee2ea7cd f0b2d4ee Author: pfinashx Date: Tue Mar 29 17:46:30 2022 +0300 Merge branch 'develop' into pf/adding_anomaly_training_tests commit ee2ea7cd72fd5a9f26bfcb7badaacf382395d1d8 Merge: 80249a4f d79ef8be Author: pfinashx Date: Wed Mar 16 10:39:22 2022 +0300 Merge branch 'develop' into pf/adding_anomaly_training_tests commit 80249a4f0009a683e724bdf0f506f15e2cd948a0 Author: pfinashx Date: Fri Mar 11 19:09:11 2022 +0300 Applying comments v2 commit d13d518a2c6f1b5a4ae7ad770a3c91ffc82c66aa Author: pfinashx Date: Tue Feb 22 18:28:42 2022 +0300 Applying comments v.1 commit 4c1f39ef27f37932d61488122bf0dd7af7aa8776 Author: pfinashx Date: Tue Jan 18 11:03:15 2022 +0300 Added Anomaly real-life training tests commit e2bc5ce1df0cce5a0ba1709bd61a680982b0ef5c Author: aiarkinx Date: Mon Dec 20 01:07:31 2021 +0300 config commit b7e40165785e08a6b18a1afbb4b026b0c0979a6d Author: aiarkinx Date: Mon Dec 20 00:50:40 2021 +0300 versions commit 176b7438db05e30a4bb75e4e845187aa8a8cef1e Author: aiarkinx Date: Mon Dec 20 00:30:25 2021 +0300 openvino version commit b95d1173bceb3f39304653f61152c9e1fef31aad Author: aiarkinx Date: Wed Dec 8 21:13:11 2021 +0300 ci configs --- .gitignore | 2 + CHANGELOG.md | 26 +- QUICK_START_GUIDE.md | 1 - .../configs/padim/configuration.py | 8 +- .../configs/padim/configuration.yaml | 115 +- .../configs/stfpm/configuration.py | 57 +- .../configs/stfpm/configuration.yaml | 198 +- .../configs/padim/configuration.py | 10 +- .../configs/padim/configuration.yaml | 115 +- .../configs/stfpm/configuration.py | 59 +- .../configs/stfpm/configuration.yaml | 198 +- .../configs/padim/configuration.py | 12 +- .../configs/padim/configuration.yaml | 115 +- .../configs/stfpm/configuration.py | 61 +- .../configs/stfpm/configuration.yaml | 198 +- .../ote_anomalib/configs/base}/__init__.py | 10 +- .../configs/{ => base}/configuration.py | 21 +- .../configs/configuration_enums.py | 9 + .../ote_anomalib/configs/padim/__init__.py} | 15 +- .../configs/padim/configuration.py} | 20 +- .../ote_anomalib/configs/stfpm}/__init__.py | 11 +- .../configs/stfpm/configuration.py | 123 ++ external/anomaly/ote_anomalib/nncf_task.py | 3 + external/anomaly/ote_tests_pytest.ini | 2 + external/anomaly/tests/conftest.py | 84 + .../metrics_test_ote_training.yml | 43 + external/anomaly/tests/test_ote_training.py | 400 ++++ .../main_model_multilabel.yaml | 3 - external/deep-object-reid/submodule | 2 +- .../build/lib/detection_tasks/__init__.py | 0 .../lib/detection_tasks/apis/__init__.py | 0 .../apis/detection/__init__.py | 42 - .../apis/detection/config_utils.py | 339 --- .../apis/detection/configuration.py | 173 -- .../apis/detection/inference_task.py | 408 ---- .../apis/detection/nncf_task.py | 283 --- .../apis/detection/openvino_task.py | 367 ---- .../apis/detection/ote_utils.py | 167 -- .../apis/detection/train_task.py | 224 -- .../extension/datasets/data_utils.py | 390 ---- .../extension/datasets/mmdataset.py | 214 -- .../extension/utils/__init__.py | 22 - .../detection_tasks/extension/utils/hooks.py | 503 ----- .../extension/utils/pipelines.py | 120 -- .../detection_tasks/extension/utils/runner.py | 127 -- .../efficientnetb2b_maskrcnn/model.py | 1 + .../dist/detection_tasks-0.0.0-py3.8.egg | Bin 108797 -> 0 bytes external/mmdetection/submodule | 2 +- .../metrics_test_ote_training.yml | 2 +- .../ote_cli/test_instance_segmentation.py | 49 + .../nncf/nncf_quantization.dot | 1822 +++++++++++++++++ .../nncf/nncf_quantization.dot | 1089 ++++++++++ external/mmsegmentation/submodule | 2 +- ...mplate.yaml => template_experimental.yaml} | 0 ...mplate.yaml => template_experimental.yaml} | 0 ...mplate.yaml => template_experimental.yaml} | 0 ...mplate.yaml => template_experimental.yaml} | 0 ...mplate.yaml => template_experimental.yaml} | 0 ...mplate.yaml => template_experimental.yaml} | 0 ...mplate.yaml => template_experimental.yaml} | 0 ...mplate.yaml => template_experimental.yaml} | 0 .../model-preparation-algorithm/submodule | 2 +- ...t_ote_cls_cls_il.py => test_cls_cls_il.py} | 2 +- ...t_ote_det_cls_il.py => test_det_cls_il.py} | 0 ...t_ote_seg_cls_il.py => test_seg_cls_il.py} | 2 +- .../tests/test_ote_api.py | 10 +- .../test_suite/training_tests_actions.py | 2 +- 67 files changed, 4468 insertions(+), 3817 deletions(-) rename external/{mmdetection/build/lib/detection_tasks/apis/detection/model_wrappers => anomaly/ote_anomalib/configs/base}/__init__.py (75%) rename external/anomaly/ote_anomalib/configs/{ => base}/configuration.py (88%) rename external/{mmdetection/build/lib/detection_tasks/apis/detection/configuration_enums.py => anomaly/ote_anomalib/configs/padim/__init__.py} (65%) rename external/{mmdetection/build/lib/detection_tasks/extension/__init__.py => anomaly/ote_anomalib/configs/padim/configuration.py} (58%) rename external/{mmdetection/build/lib/detection_tasks/extension/datasets => anomaly/ote_anomalib/configs/stfpm}/__init__.py (63%) create mode 100644 external/anomaly/ote_anomalib/configs/stfpm/configuration.py create mode 100644 external/anomaly/ote_tests_pytest.ini create mode 100644 external/anomaly/tests/conftest.py create mode 100644 external/anomaly/tests/expected_metrics/metrics_test_ote_training.yml create mode 100644 external/anomaly/tests/test_ote_training.py delete mode 100644 external/mmdetection/build/lib/detection_tasks/__init__.py delete mode 100644 external/mmdetection/build/lib/detection_tasks/apis/__init__.py delete mode 100644 external/mmdetection/build/lib/detection_tasks/apis/detection/__init__.py delete mode 100644 external/mmdetection/build/lib/detection_tasks/apis/detection/config_utils.py delete mode 100644 external/mmdetection/build/lib/detection_tasks/apis/detection/configuration.py delete mode 100644 external/mmdetection/build/lib/detection_tasks/apis/detection/inference_task.py delete mode 100644 external/mmdetection/build/lib/detection_tasks/apis/detection/nncf_task.py delete mode 100644 external/mmdetection/build/lib/detection_tasks/apis/detection/openvino_task.py delete mode 100644 external/mmdetection/build/lib/detection_tasks/apis/detection/ote_utils.py delete mode 100644 external/mmdetection/build/lib/detection_tasks/apis/detection/train_task.py delete mode 100644 external/mmdetection/build/lib/detection_tasks/extension/datasets/data_utils.py delete mode 100644 external/mmdetection/build/lib/detection_tasks/extension/datasets/mmdataset.py delete mode 100644 external/mmdetection/build/lib/detection_tasks/extension/utils/__init__.py delete mode 100644 external/mmdetection/build/lib/detection_tasks/extension/utils/hooks.py delete mode 100644 external/mmdetection/build/lib/detection_tasks/extension/utils/pipelines.py delete mode 100644 external/mmdetection/build/lib/detection_tasks/extension/utils/runner.py delete mode 100644 external/mmdetection/dist/detection_tasks-0.0.0-py3.8.egg create mode 100644 external/mmdetection/tests/reference/Custom_Counting_Instance_Segmentation_MaskRCNN_EfficientNetB2B/nncf/nncf_quantization.dot create mode 100644 external/mmdetection/tests/reference/Custom_Counting_Instance_Segmentation_MaskRCNN_ResNet50/nncf/nncf_quantization.dot rename external/model-preparation-algorithm/configs/classification/efficientnet_b0_cls_incr/{template.yaml => template_experimental.yaml} (100%) rename external/model-preparation-algorithm/configs/classification/efficientnet_v2_s_cls_incr/{template.yaml => template_experimental.yaml} (100%) rename external/model-preparation-algorithm/configs/classification/mobilenet_v3_large_075_cls_incr/{template.yaml => template_experimental.yaml} (100%) rename external/model-preparation-algorithm/configs/classification/mobilenet_v3_large_1_cls_incr/{template.yaml => template_experimental.yaml} (100%) rename external/model-preparation-algorithm/configs/classification/mobilenet_v3_small_cls_incr/{template.yaml => template_experimental.yaml} (100%) rename external/model-preparation-algorithm/configs/detection/mobilenetv2_atss_cls_incr/{template.yaml => template_experimental.yaml} (100%) rename external/model-preparation-algorithm/configs/detection/resnet50_vfnet_cls_incr/{template.yaml => template_experimental.yaml} (100%) rename external/model-preparation-algorithm/configs/segmentation/ocr-lite-hrnet-18-cls-incr/{template.yaml => template_experimental.yaml} (100%) rename external/model-preparation-algorithm/tests/ote_cli/{test_ote_cls_cls_il.py => test_cls_cls_il.py} (99%) rename external/model-preparation-algorithm/tests/ote_cli/{test_ote_det_cls_il.py => test_det_cls_il.py} (100%) rename external/model-preparation-algorithm/tests/ote_cli/{test_ote_seg_cls_il.py => test_seg_cls_il.py} (99%) diff --git a/.gitignore b/.gitignore index 86aae56c004..ac2a9aaae4c 100644 --- a/.gitignore +++ b/.gitignore @@ -11,6 +11,8 @@ env data/* .coverage +build/ +dist/ *egg-info *.pth diff --git a/CHANGELOG.md b/CHANGELOG.md index 25226d40824..cf0ed34f7d6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,10 +2,29 @@ All notable changes to this project will be documented in this file. +## \[v0.2.0\] +### Added +* Model Preparation Algorithm (MPA), a newly introduced OTE Algorithm backend for advanced transfer learning + * Class-Incremental Learning support for OTE models + * Image Classification + * Object Detection + * Semantic Segmentation +* Object counting & Rotated object detection are added to Object Detection backend +* Increased support for NNCF / FP16 / HPO +* Ignored label support +* Stop training on NaN losses + + +### Changed +* Major refactoring + * Tasks & model templates had been moved to OTE repo from each OTE Algorithm backend + + ## \[v0.1.1\] ### Fixed * Some minor issues + ## \[v0.1.0\] ### Added * OTE SDK, defines an interface which can be used by OTE CLI to access OTE Algorithms. @@ -16,10 +35,3 @@ All notable changes to this project will be documented in this file. * Object Detection * Semantic Segmentation -## \[v0.2.0\] -### Added -* Model Preparation Algorithm (MPA), a newly introduced OTE Algorithm backend for advanced transfer learning - * Class-Incremental Learning support for OTE models - * Image Classification - * Object Detection - * Semantic Segmentation diff --git a/QUICK_START_GUIDE.md b/QUICK_START_GUIDE.md index 9bf7ddbdac6..05e72c0c234 100644 --- a/QUICK_START_GUIDE.md +++ b/QUICK_START_GUIDE.md @@ -11,7 +11,6 @@ ``` git clone https://github.com/openvinotoolkit/training_extensions.git cd training_extensions - git checkout -b develop origin/develop git submodule update --init --recursive ``` diff --git a/external/anomaly/anomaly_classification/configs/padim/configuration.py b/external/anomaly/anomaly_classification/configs/padim/configuration.py index 69b1588ab30..33dae9d5bfd 100644 --- a/external/anomaly/anomaly_classification/configs/padim/configuration.py +++ b/external/anomaly/anomaly_classification/configs/padim/configuration.py @@ -17,15 +17,11 @@ # and limitations under the License. from attr import attrs -from ote_anomalib.configs.configuration import BaseAnomalyConfig -from ote_sdk.configuration.elements import string_attribute +from ote_anomalib.configs.padim import PadimAnomalyBaseConfig @attrs -class PadimAnomalyClassificationConfig(BaseAnomalyConfig): +class PadimAnomalyClassificationConfig(PadimAnomalyBaseConfig): """ Configurable parameters for PADIM anomaly classification task. """ - - header = string_attribute("Configuration for Padim") - description = header diff --git a/external/anomaly/anomaly_classification/configs/padim/configuration.yaml b/external/anomaly/anomaly_classification/configs/padim/configuration.yaml index cff368c59e8..690e2560d2f 100644 --- a/external/anomaly/anomaly_classification/configs/padim/configuration.yaml +++ b/external/anomaly/anomaly_classification/configs/padim/configuration.yaml @@ -3,6 +3,8 @@ dataset: header: Dataset Parameters num_workers: affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null default_value: 8 description: Increasing this value might improve training speed however it might @@ -18,10 +20,13 @@ dataset: operator: AND rules: [] type: UI_RULES + value: 8 visible_in_ui: true warning: null train_batch_size: affects_outcome_of: TRAINING + auto_hpo_state: not_possible + auto_hpo_value: null default_value: 32 description: The number of training samples seen in each iteration of training. @@ -37,6 +42,7 @@ dataset: operator: AND rules: [] type: UI_RULES + value: 32 visible_in_ui: true warning: Increasing this value may cause the system to use more memory than available, @@ -45,50 +51,56 @@ dataset: visible_in_ui: true description: Configuration for Padim header: Configuration for Padim -pot_parameters: - description: POT Parameters - header: POT Parameters - preset: +id: "" +model: + backbone: affects_outcome_of: NONE - default_value: Performance - description: Quantization preset that defines quantization scheme + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: resnet18 + description: Pre-trained backbone used for feature extraction editable: true - enum_name: POTQuantizationPreset - header: Preset + enum_name: ModelBackbone + header: Model Backbone options: - MIXED: Mixed - PERFORMANCE: Performance + RESNET18: resnet18 + WIDE_RESNET_50: wide_resnet50_2 type: SELECTABLE ui_rules: action: DISABLE_EDITING operator: AND rules: [] type: UI_RULES + value: resnet18 visible_in_ui: true warning: null - stat_subset_size: + description: Model Parameters + header: Model Parameters + type: PARAMETER_GROUP + visible_in_ui: true +nncf_optimization: + description: Optimization by NNCF + enable_pruning: affects_outcome_of: NONE - default_value: 300 - description: Number of data samples used for post-training optimization + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: false + description: Enable filter pruning algorithm editable: true - header: Number of data samples - max_value: 9223372036854775807 - min_value: 1 - type: INTEGER + header: Enable filter pruning algorithm + type: BOOLEAN ui_rules: action: DISABLE_EDITING operator: AND rules: [] type: UI_RULES + value: false visible_in_ui: true warning: null - type: PARAMETER_GROUP - visible_in_ui: true -nncf_optimization: - description: Optimization by NNCF - header: Optimization by NNCF enable_quantization: - affects_outcome_of: TRAINING + affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null default_value: true description: Enable quantization algorithm editable: true @@ -102,12 +114,15 @@ nncf_optimization: value: true visible_in_ui: true warning: null - enable_pruning: + header: Optimization by NNCF + pruning_supported: affects_outcome_of: TRAINING + auto_hpo_state: not_possible + auto_hpo_value: null default_value: false - description: Enable filter pruning algorithm + description: Whether filter pruning is supported editable: true - header: Enable filter pruning algorithm + header: Whether filter pruning is supported type: BOOLEAN ui_rules: action: DISABLE_EDITING @@ -117,20 +132,50 @@ nncf_optimization: value: false visible_in_ui: true warning: null - pruning_supported: - affects_outcome_of: TRAINING - default_value: false - description: Whether filter pruning is supported - editable: false - header: Whether filter pruning is supported - type: BOOLEAN + type: PARAMETER_GROUP + visible_in_ui: true +pot_parameters: + description: POT Parameters + header: POT Parameters + preset: + affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: Performance + description: Quantization preset that defines quantization scheme + editable: true + enum_name: POTQuantizationPreset + header: Preset + options: + MIXED: Mixed + PERFORMANCE: Performance + type: SELECTABLE ui_rules: action: DISABLE_EDITING operator: AND rules: [] type: UI_RULES - value: false - visible_in_ui: false + value: Performance + visible_in_ui: true + warning: null + stat_subset_size: + affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: 300 + description: Number of data samples used for post-training optimization + editable: true + header: Number of data samples + max_value: 9223372036854775807 + min_value: 1 + type: INTEGER + ui_rules: + action: DISABLE_EDITING + operator: AND + rules: [] + type: UI_RULES + value: 300 + visible_in_ui: true warning: null type: PARAMETER_GROUP visible_in_ui: false diff --git a/external/anomaly/anomaly_classification/configs/stfpm/configuration.py b/external/anomaly/anomaly_classification/configs/stfpm/configuration.py index cc380f2c7f0..06c6017b50b 100644 --- a/external/anomaly/anomaly_classification/configs/stfpm/configuration.py +++ b/external/anomaly/anomaly_classification/configs/stfpm/configuration.py @@ -17,64 +17,11 @@ # and limitations under the License. from attr import attrs -from ote_anomalib.configs.configuration import BaseAnomalyConfig -from ote_anomalib.configs.configuration_enums import EarlyStoppingMetrics -from ote_sdk.configuration.elements import ( - ParameterGroup, - add_parameter_group, - configurable_integer, - selectable, - string_attribute, -) -from ote_sdk.configuration.model_lifecycle import ModelLifecycle +from ote_anomalib.configs.stfpm import STFPMAnomalyBaseConfig @attrs -class STFPMAnomalyClassificationConfig(BaseAnomalyConfig): +class STFPMAnomalyClassificationConfig(STFPMAnomalyBaseConfig): """ Configurable parameters for STFPM anomaly classification task. """ - - header = string_attribute("Configuration for STFPM") - description = header - - @attrs - class ModelParameters(ParameterGroup): - """ - Parameter Group for training model - """ - - header = string_attribute("Model Parameters") - description = header - - @attrs - class EarlyStoppingParameters(ParameterGroup): - """ - Early stopping parameters - """ - - header = string_attribute("Early Stopping Parameters") - description = header - - metric = selectable( - default_value=EarlyStoppingMetrics.IMAGE_F1, - header="Early Stopping Metric", - description="The metric used to determine if the model should stop training", - ) - - patience = configurable_integer( - default_value=10, - min_value=1, - max_value=100, - header="Early Stopping Patience", - description="Number of epochs to wait for an improvement in the monitored metric. If the metric has " - "not improved for this many epochs, the training will stop and the best model will be " - "returned.", - warning="Setting this value too low might lead to underfitting. Setting the value too high will " - "increase the training time and might lead to overfitting.", - affects_outcome_of=ModelLifecycle.TRAINING, - ) - - early_stopping = add_parameter_group(EarlyStoppingParameters) - - model = add_parameter_group(ModelParameters) diff --git a/external/anomaly/anomaly_classification/configs/stfpm/configuration.yaml b/external/anomaly/anomaly_classification/configs/stfpm/configuration.yaml index 9facd1e1d1c..8bcbda3bfa3 100644 --- a/external/anomaly/anomaly_classification/configs/stfpm/configuration.yaml +++ b/external/anomaly/anomaly_classification/configs/stfpm/configuration.yaml @@ -3,6 +3,8 @@ dataset: header: Dataset Parameters num_workers: affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null default_value: 8 description: Increasing this value might improve training speed however it might @@ -18,10 +20,13 @@ dataset: operator: AND rules: [] type: UI_RULES + value: 8 visible_in_ui: true warning: null train_batch_size: affects_outcome_of: TRAINING + auto_hpo_state: not_possible + auto_hpo_value: null default_value: 32 description: The number of training samples seen in each iteration of training. @@ -37,6 +42,7 @@ dataset: operator: AND rules: [] type: UI_RULES + value: 32 visible_in_ui: true warning: Increasing this value may cause the system to use more memory than available, @@ -45,13 +51,37 @@ dataset: visible_in_ui: true description: Configuration for STFPM header: Configuration for STFPM +id: "" model: + backbone: + affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: resnet18 + description: Pre-trained backbone used for feature extraction + editable: true + enum_name: ModelBackbone + header: Model Backbone + options: + RESNET18: resnet18 + WIDE_RESNET_50: wide_resnet50_2 + type: SELECTABLE + ui_rules: + action: DISABLE_EDITING + operator: AND + rules: [] + type: UI_RULES + value: resnet18 + visible_in_ui: true + warning: null description: Model Parameters early_stopping: description: Early Stopping Parameters header: Early Stopping Parameters metric: affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null default_value: image_F1 description: The metric used to determine if the model should stop training editable: true @@ -66,10 +96,13 @@ model: operator: AND rules: [] type: UI_RULES + value: image_F1 visible_in_ui: true warning: null patience: affects_outcome_of: TRAINING + auto_hpo_state: not_possible + auto_hpo_value: null default_value: 10 description: Number of epochs to wait for an improvement in the monitored metric. @@ -85,6 +118,7 @@ model: operator: AND rules: [] type: UI_RULES + value: 10 visible_in_ui: true warning: Setting this value too low might lead to underfitting. Setting the @@ -92,67 +126,71 @@ model: type: PARAMETER_GROUP visible_in_ui: true header: Model Parameters - type: PARAMETER_GROUP - visible_in_ui: true -pot_parameters: - description: POT Parameters - header: POT Parameters - preset: + lr: affects_outcome_of: NONE - default_value: Performance - description: Quantization preset that defines quantization scheme + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: 0.4 + description: Learning rate used for optimizing the Student network. editable: true - enum_name: POTQuantizationPreset - header: Preset - options: - MIXED: Mixed - PERFORMANCE: Performance - type: SELECTABLE + header: Learning Rate + max_value: 1 + min_value: 0.001 + type: FLOAT ui_rules: action: DISABLE_EDITING operator: AND rules: [] type: UI_RULES + value: 0.4 visible_in_ui: true warning: null - stat_subset_size: + momentum: affects_outcome_of: NONE - default_value: 300 - description: Number of data samples used for post-training optimization + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: 0.9 + description: Momentum used for SGD optimizer editable: true - header: Number of data samples - max_value: 9223372036854775807 - min_value: 1 - type: INTEGER + header: Momentum + max_value: 1.0 + min_value: 0.1 + type: FLOAT ui_rules: action: DISABLE_EDITING operator: AND rules: [] type: UI_RULES + value: 0.9 visible_in_ui: true warning: null type: PARAMETER_GROUP visible_in_ui: true -nncf_optimization: - description: Optimization by NNCF - header: Optimization by NNCF - enable_quantization: - affects_outcome_of: TRAINING - default_value: true - description: Enable quantization algorithm + weight_decay: + affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: 0.0001 + description: Decay for SGD optimizer editable: true - header: Enable quantization algorithm - type: BOOLEAN + header: Weight Decay + max_value: 1 + min_value: 1.0e-05 + type: FLOAT ui_rules: action: DISABLE_EDITING operator: AND rules: [] type: UI_RULES - value: true + value: 0.0001 visible_in_ui: true warning: null +nncf_optimization: + description: Optimization by NNCF enable_pruning: - affects_outcome_of: TRAINING + affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null default_value: false description: Enable filter pruning algorithm editable: true @@ -166,11 +204,31 @@ nncf_optimization: value: false visible_in_ui: true warning: null + enable_quantization: + affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: true + description: Enable quantization algorithm + editable: true + header: Enable quantization algorithm + type: BOOLEAN + ui_rules: + action: DISABLE_EDITING + operator: AND + rules: [] + type: UI_RULES + value: true + visible_in_ui: true + warning: null + header: Optimization by NNCF pruning_supported: affects_outcome_of: TRAINING + auto_hpo_state: not_possible + auto_hpo_value: null default_value: false description: Whether filter pruning is supported - editable: false + editable: true header: Whether filter pruning is supported type: BOOLEAN ui_rules: @@ -179,9 +237,81 @@ nncf_optimization: rules: [] type: UI_RULES value: false - visible_in_ui: false + visible_in_ui: true + warning: null + type: PARAMETER_GROUP + visible_in_ui: true +pot_parameters: + description: POT Parameters + header: POT Parameters + preset: + affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: Performance + description: Quantization preset that defines quantization scheme + editable: true + enum_name: POTQuantizationPreset + header: Preset + options: + MIXED: Mixed + PERFORMANCE: Performance + type: SELECTABLE + ui_rules: + action: DISABLE_EDITING + operator: AND + rules: [] + type: UI_RULES + value: Performance + visible_in_ui: true + warning: null + stat_subset_size: + affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: 300 + description: Number of data samples used for post-training optimization + editable: true + header: Number of data samples + max_value: 9223372036854775807 + min_value: 1 + type: INTEGER + ui_rules: + action: DISABLE_EDITING + operator: AND + rules: [] + type: UI_RULES + value: 300 + visible_in_ui: true warning: null type: PARAMETER_GROUP visible_in_ui: false +trainer: + description: Trainer Parameters + header: Trainer Parameters + max_epochs: + affects_outcome_of: TRAINING + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: 100 + description: Maximum number of epochs to train the model for. + editable: true + header: Max Epochs + max_value: 500 + min_value: 1 + type: INTEGER + ui_rules: + action: DISABLE_EDITING + operator: AND + rules: [] + type: UI_RULES + value: 100 + visible_in_ui: true + warning: + Training for very few epochs might lead to poor performance. If Early + Stopping is enabled then increasing the value of max epochs might not lead to + desired result. + type: PARAMETER_GROUP + visible_in_ui: true type: CONFIGURABLE_PARAMETERS visible_in_ui: true diff --git a/external/anomaly/anomaly_detection/configs/padim/configuration.py b/external/anomaly/anomaly_detection/configs/padim/configuration.py index 141a128841b..5592615e54a 100644 --- a/external/anomaly/anomaly_detection/configs/padim/configuration.py +++ b/external/anomaly/anomaly_detection/configs/padim/configuration.py @@ -17,15 +17,11 @@ # and limitations under the License. from attr import attrs -from ote_anomalib.configs.configuration import BaseAnomalyConfig -from ote_sdk.configuration.elements import string_attribute +from ote_anomalib.configs.padim import PadimAnomalyBaseConfig @attrs -class PadimAnomalyDetectionConfig(BaseAnomalyConfig): +class PadimAnomalyDetectionConfig(PadimAnomalyBaseConfig): """ - Configurable parameters for PADIM anomaly classification task. + Configurable parameters for PADIM anomaly detection task. """ - - header = string_attribute("Configuration for Padim") - description = header diff --git a/external/anomaly/anomaly_detection/configs/padim/configuration.yaml b/external/anomaly/anomaly_detection/configs/padim/configuration.yaml index cff368c59e8..690e2560d2f 100644 --- a/external/anomaly/anomaly_detection/configs/padim/configuration.yaml +++ b/external/anomaly/anomaly_detection/configs/padim/configuration.yaml @@ -3,6 +3,8 @@ dataset: header: Dataset Parameters num_workers: affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null default_value: 8 description: Increasing this value might improve training speed however it might @@ -18,10 +20,13 @@ dataset: operator: AND rules: [] type: UI_RULES + value: 8 visible_in_ui: true warning: null train_batch_size: affects_outcome_of: TRAINING + auto_hpo_state: not_possible + auto_hpo_value: null default_value: 32 description: The number of training samples seen in each iteration of training. @@ -37,6 +42,7 @@ dataset: operator: AND rules: [] type: UI_RULES + value: 32 visible_in_ui: true warning: Increasing this value may cause the system to use more memory than available, @@ -45,50 +51,56 @@ dataset: visible_in_ui: true description: Configuration for Padim header: Configuration for Padim -pot_parameters: - description: POT Parameters - header: POT Parameters - preset: +id: "" +model: + backbone: affects_outcome_of: NONE - default_value: Performance - description: Quantization preset that defines quantization scheme + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: resnet18 + description: Pre-trained backbone used for feature extraction editable: true - enum_name: POTQuantizationPreset - header: Preset + enum_name: ModelBackbone + header: Model Backbone options: - MIXED: Mixed - PERFORMANCE: Performance + RESNET18: resnet18 + WIDE_RESNET_50: wide_resnet50_2 type: SELECTABLE ui_rules: action: DISABLE_EDITING operator: AND rules: [] type: UI_RULES + value: resnet18 visible_in_ui: true warning: null - stat_subset_size: + description: Model Parameters + header: Model Parameters + type: PARAMETER_GROUP + visible_in_ui: true +nncf_optimization: + description: Optimization by NNCF + enable_pruning: affects_outcome_of: NONE - default_value: 300 - description: Number of data samples used for post-training optimization + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: false + description: Enable filter pruning algorithm editable: true - header: Number of data samples - max_value: 9223372036854775807 - min_value: 1 - type: INTEGER + header: Enable filter pruning algorithm + type: BOOLEAN ui_rules: action: DISABLE_EDITING operator: AND rules: [] type: UI_RULES + value: false visible_in_ui: true warning: null - type: PARAMETER_GROUP - visible_in_ui: true -nncf_optimization: - description: Optimization by NNCF - header: Optimization by NNCF enable_quantization: - affects_outcome_of: TRAINING + affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null default_value: true description: Enable quantization algorithm editable: true @@ -102,12 +114,15 @@ nncf_optimization: value: true visible_in_ui: true warning: null - enable_pruning: + header: Optimization by NNCF + pruning_supported: affects_outcome_of: TRAINING + auto_hpo_state: not_possible + auto_hpo_value: null default_value: false - description: Enable filter pruning algorithm + description: Whether filter pruning is supported editable: true - header: Enable filter pruning algorithm + header: Whether filter pruning is supported type: BOOLEAN ui_rules: action: DISABLE_EDITING @@ -117,20 +132,50 @@ nncf_optimization: value: false visible_in_ui: true warning: null - pruning_supported: - affects_outcome_of: TRAINING - default_value: false - description: Whether filter pruning is supported - editable: false - header: Whether filter pruning is supported - type: BOOLEAN + type: PARAMETER_GROUP + visible_in_ui: true +pot_parameters: + description: POT Parameters + header: POT Parameters + preset: + affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: Performance + description: Quantization preset that defines quantization scheme + editable: true + enum_name: POTQuantizationPreset + header: Preset + options: + MIXED: Mixed + PERFORMANCE: Performance + type: SELECTABLE ui_rules: action: DISABLE_EDITING operator: AND rules: [] type: UI_RULES - value: false - visible_in_ui: false + value: Performance + visible_in_ui: true + warning: null + stat_subset_size: + affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: 300 + description: Number of data samples used for post-training optimization + editable: true + header: Number of data samples + max_value: 9223372036854775807 + min_value: 1 + type: INTEGER + ui_rules: + action: DISABLE_EDITING + operator: AND + rules: [] + type: UI_RULES + value: 300 + visible_in_ui: true warning: null type: PARAMETER_GROUP visible_in_ui: false diff --git a/external/anomaly/anomaly_detection/configs/stfpm/configuration.py b/external/anomaly/anomaly_detection/configs/stfpm/configuration.py index b8b885461e3..154eb8cf2c6 100644 --- a/external/anomaly/anomaly_detection/configs/stfpm/configuration.py +++ b/external/anomaly/anomaly_detection/configs/stfpm/configuration.py @@ -17,64 +17,11 @@ # and limitations under the License. from attr import attrs -from ote_anomalib.configs.configuration import BaseAnomalyConfig -from ote_anomalib.configs.configuration_enums import EarlyStoppingMetrics -from ote_sdk.configuration.elements import ( - ParameterGroup, - add_parameter_group, - configurable_integer, - selectable, - string_attribute, -) -from ote_sdk.configuration.model_lifecycle import ModelLifecycle +from ote_anomalib.configs.stfpm import STFPMAnomalyBaseConfig @attrs -class STFPMAnomalyDetectionConfig(BaseAnomalyConfig): +class STFPMAnomalyDetectionConfig(STFPMAnomalyBaseConfig): """ - Configurable parameters for STFPM anomaly classification task. + Configurable parameters for STFPM anomaly detection task. """ - - header = string_attribute("Configuration for STFPM") - description = header - - @attrs - class ModelParameters(ParameterGroup): - """ - Parameter Group for training model - """ - - header = string_attribute("Model Parameters") - description = header - - @attrs - class EarlyStoppingParameters(ParameterGroup): - """ - Early stopping parameters - """ - - header = string_attribute("Early Stopping Parameters") - description = header - - metric = selectable( - default_value=EarlyStoppingMetrics.IMAGE_F1, - header="Early Stopping Metric", - description="The metric used to determine if the model should stop training", - ) - - patience = configurable_integer( - default_value=10, - min_value=1, - max_value=100, - header="Early Stopping Patience", - description="Number of epochs to wait for an improvement in the monitored metric. If the metric has " - "not improved for this many epochs, the training will stop and the best model will be " - "returned.", - warning="Setting this value too low might lead to underfitting. Setting the value too high will " - "increase the training time and might lead to overfitting.", - affects_outcome_of=ModelLifecycle.TRAINING, - ) - - early_stopping = add_parameter_group(EarlyStoppingParameters) - - model = add_parameter_group(ModelParameters) diff --git a/external/anomaly/anomaly_detection/configs/stfpm/configuration.yaml b/external/anomaly/anomaly_detection/configs/stfpm/configuration.yaml index 9facd1e1d1c..8bcbda3bfa3 100644 --- a/external/anomaly/anomaly_detection/configs/stfpm/configuration.yaml +++ b/external/anomaly/anomaly_detection/configs/stfpm/configuration.yaml @@ -3,6 +3,8 @@ dataset: header: Dataset Parameters num_workers: affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null default_value: 8 description: Increasing this value might improve training speed however it might @@ -18,10 +20,13 @@ dataset: operator: AND rules: [] type: UI_RULES + value: 8 visible_in_ui: true warning: null train_batch_size: affects_outcome_of: TRAINING + auto_hpo_state: not_possible + auto_hpo_value: null default_value: 32 description: The number of training samples seen in each iteration of training. @@ -37,6 +42,7 @@ dataset: operator: AND rules: [] type: UI_RULES + value: 32 visible_in_ui: true warning: Increasing this value may cause the system to use more memory than available, @@ -45,13 +51,37 @@ dataset: visible_in_ui: true description: Configuration for STFPM header: Configuration for STFPM +id: "" model: + backbone: + affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: resnet18 + description: Pre-trained backbone used for feature extraction + editable: true + enum_name: ModelBackbone + header: Model Backbone + options: + RESNET18: resnet18 + WIDE_RESNET_50: wide_resnet50_2 + type: SELECTABLE + ui_rules: + action: DISABLE_EDITING + operator: AND + rules: [] + type: UI_RULES + value: resnet18 + visible_in_ui: true + warning: null description: Model Parameters early_stopping: description: Early Stopping Parameters header: Early Stopping Parameters metric: affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null default_value: image_F1 description: The metric used to determine if the model should stop training editable: true @@ -66,10 +96,13 @@ model: operator: AND rules: [] type: UI_RULES + value: image_F1 visible_in_ui: true warning: null patience: affects_outcome_of: TRAINING + auto_hpo_state: not_possible + auto_hpo_value: null default_value: 10 description: Number of epochs to wait for an improvement in the monitored metric. @@ -85,6 +118,7 @@ model: operator: AND rules: [] type: UI_RULES + value: 10 visible_in_ui: true warning: Setting this value too low might lead to underfitting. Setting the @@ -92,67 +126,71 @@ model: type: PARAMETER_GROUP visible_in_ui: true header: Model Parameters - type: PARAMETER_GROUP - visible_in_ui: true -pot_parameters: - description: POT Parameters - header: POT Parameters - preset: + lr: affects_outcome_of: NONE - default_value: Performance - description: Quantization preset that defines quantization scheme + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: 0.4 + description: Learning rate used for optimizing the Student network. editable: true - enum_name: POTQuantizationPreset - header: Preset - options: - MIXED: Mixed - PERFORMANCE: Performance - type: SELECTABLE + header: Learning Rate + max_value: 1 + min_value: 0.001 + type: FLOAT ui_rules: action: DISABLE_EDITING operator: AND rules: [] type: UI_RULES + value: 0.4 visible_in_ui: true warning: null - stat_subset_size: + momentum: affects_outcome_of: NONE - default_value: 300 - description: Number of data samples used for post-training optimization + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: 0.9 + description: Momentum used for SGD optimizer editable: true - header: Number of data samples - max_value: 9223372036854775807 - min_value: 1 - type: INTEGER + header: Momentum + max_value: 1.0 + min_value: 0.1 + type: FLOAT ui_rules: action: DISABLE_EDITING operator: AND rules: [] type: UI_RULES + value: 0.9 visible_in_ui: true warning: null type: PARAMETER_GROUP visible_in_ui: true -nncf_optimization: - description: Optimization by NNCF - header: Optimization by NNCF - enable_quantization: - affects_outcome_of: TRAINING - default_value: true - description: Enable quantization algorithm + weight_decay: + affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: 0.0001 + description: Decay for SGD optimizer editable: true - header: Enable quantization algorithm - type: BOOLEAN + header: Weight Decay + max_value: 1 + min_value: 1.0e-05 + type: FLOAT ui_rules: action: DISABLE_EDITING operator: AND rules: [] type: UI_RULES - value: true + value: 0.0001 visible_in_ui: true warning: null +nncf_optimization: + description: Optimization by NNCF enable_pruning: - affects_outcome_of: TRAINING + affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null default_value: false description: Enable filter pruning algorithm editable: true @@ -166,11 +204,31 @@ nncf_optimization: value: false visible_in_ui: true warning: null + enable_quantization: + affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: true + description: Enable quantization algorithm + editable: true + header: Enable quantization algorithm + type: BOOLEAN + ui_rules: + action: DISABLE_EDITING + operator: AND + rules: [] + type: UI_RULES + value: true + visible_in_ui: true + warning: null + header: Optimization by NNCF pruning_supported: affects_outcome_of: TRAINING + auto_hpo_state: not_possible + auto_hpo_value: null default_value: false description: Whether filter pruning is supported - editable: false + editable: true header: Whether filter pruning is supported type: BOOLEAN ui_rules: @@ -179,9 +237,81 @@ nncf_optimization: rules: [] type: UI_RULES value: false - visible_in_ui: false + visible_in_ui: true + warning: null + type: PARAMETER_GROUP + visible_in_ui: true +pot_parameters: + description: POT Parameters + header: POT Parameters + preset: + affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: Performance + description: Quantization preset that defines quantization scheme + editable: true + enum_name: POTQuantizationPreset + header: Preset + options: + MIXED: Mixed + PERFORMANCE: Performance + type: SELECTABLE + ui_rules: + action: DISABLE_EDITING + operator: AND + rules: [] + type: UI_RULES + value: Performance + visible_in_ui: true + warning: null + stat_subset_size: + affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: 300 + description: Number of data samples used for post-training optimization + editable: true + header: Number of data samples + max_value: 9223372036854775807 + min_value: 1 + type: INTEGER + ui_rules: + action: DISABLE_EDITING + operator: AND + rules: [] + type: UI_RULES + value: 300 + visible_in_ui: true warning: null type: PARAMETER_GROUP visible_in_ui: false +trainer: + description: Trainer Parameters + header: Trainer Parameters + max_epochs: + affects_outcome_of: TRAINING + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: 100 + description: Maximum number of epochs to train the model for. + editable: true + header: Max Epochs + max_value: 500 + min_value: 1 + type: INTEGER + ui_rules: + action: DISABLE_EDITING + operator: AND + rules: [] + type: UI_RULES + value: 100 + visible_in_ui: true + warning: + Training for very few epochs might lead to poor performance. If Early + Stopping is enabled then increasing the value of max epochs might not lead to + desired result. + type: PARAMETER_GROUP + visible_in_ui: true type: CONFIGURABLE_PARAMETERS visible_in_ui: true diff --git a/external/anomaly/anomaly_segmentation/configs/padim/configuration.py b/external/anomaly/anomaly_segmentation/configs/padim/configuration.py index 7be758adb1b..0990e374e02 100644 --- a/external/anomaly/anomaly_segmentation/configs/padim/configuration.py +++ b/external/anomaly/anomaly_segmentation/configs/padim/configuration.py @@ -1,5 +1,5 @@ """ -Configurable parameters for Padim anomaly classification task +Configurable parameters for Padim anomaly segmentation task """ # Copyright (C) 2021 Intel Corporation @@ -17,15 +17,11 @@ # and limitations under the License. from attr import attrs -from ote_anomalib.configs.configuration import BaseAnomalyConfig -from ote_sdk.configuration.elements import string_attribute +from ote_anomalib.configs.padim import PadimAnomalyBaseConfig @attrs -class PadimAnomalySegmentationConfig(BaseAnomalyConfig): +class PadimAnomalySegmentationConfig(PadimAnomalyBaseConfig): """ - Configurable parameters for PADIM anomaly classification task. + Configurable parameters for PADIM anomaly segmentation task. """ - - header = string_attribute("Configuration for Padim") - description = header diff --git a/external/anomaly/anomaly_segmentation/configs/padim/configuration.yaml b/external/anomaly/anomaly_segmentation/configs/padim/configuration.yaml index cff368c59e8..690e2560d2f 100644 --- a/external/anomaly/anomaly_segmentation/configs/padim/configuration.yaml +++ b/external/anomaly/anomaly_segmentation/configs/padim/configuration.yaml @@ -3,6 +3,8 @@ dataset: header: Dataset Parameters num_workers: affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null default_value: 8 description: Increasing this value might improve training speed however it might @@ -18,10 +20,13 @@ dataset: operator: AND rules: [] type: UI_RULES + value: 8 visible_in_ui: true warning: null train_batch_size: affects_outcome_of: TRAINING + auto_hpo_state: not_possible + auto_hpo_value: null default_value: 32 description: The number of training samples seen in each iteration of training. @@ -37,6 +42,7 @@ dataset: operator: AND rules: [] type: UI_RULES + value: 32 visible_in_ui: true warning: Increasing this value may cause the system to use more memory than available, @@ -45,50 +51,56 @@ dataset: visible_in_ui: true description: Configuration for Padim header: Configuration for Padim -pot_parameters: - description: POT Parameters - header: POT Parameters - preset: +id: "" +model: + backbone: affects_outcome_of: NONE - default_value: Performance - description: Quantization preset that defines quantization scheme + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: resnet18 + description: Pre-trained backbone used for feature extraction editable: true - enum_name: POTQuantizationPreset - header: Preset + enum_name: ModelBackbone + header: Model Backbone options: - MIXED: Mixed - PERFORMANCE: Performance + RESNET18: resnet18 + WIDE_RESNET_50: wide_resnet50_2 type: SELECTABLE ui_rules: action: DISABLE_EDITING operator: AND rules: [] type: UI_RULES + value: resnet18 visible_in_ui: true warning: null - stat_subset_size: + description: Model Parameters + header: Model Parameters + type: PARAMETER_GROUP + visible_in_ui: true +nncf_optimization: + description: Optimization by NNCF + enable_pruning: affects_outcome_of: NONE - default_value: 300 - description: Number of data samples used for post-training optimization + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: false + description: Enable filter pruning algorithm editable: true - header: Number of data samples - max_value: 9223372036854775807 - min_value: 1 - type: INTEGER + header: Enable filter pruning algorithm + type: BOOLEAN ui_rules: action: DISABLE_EDITING operator: AND rules: [] type: UI_RULES + value: false visible_in_ui: true warning: null - type: PARAMETER_GROUP - visible_in_ui: true -nncf_optimization: - description: Optimization by NNCF - header: Optimization by NNCF enable_quantization: - affects_outcome_of: TRAINING + affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null default_value: true description: Enable quantization algorithm editable: true @@ -102,12 +114,15 @@ nncf_optimization: value: true visible_in_ui: true warning: null - enable_pruning: + header: Optimization by NNCF + pruning_supported: affects_outcome_of: TRAINING + auto_hpo_state: not_possible + auto_hpo_value: null default_value: false - description: Enable filter pruning algorithm + description: Whether filter pruning is supported editable: true - header: Enable filter pruning algorithm + header: Whether filter pruning is supported type: BOOLEAN ui_rules: action: DISABLE_EDITING @@ -117,20 +132,50 @@ nncf_optimization: value: false visible_in_ui: true warning: null - pruning_supported: - affects_outcome_of: TRAINING - default_value: false - description: Whether filter pruning is supported - editable: false - header: Whether filter pruning is supported - type: BOOLEAN + type: PARAMETER_GROUP + visible_in_ui: true +pot_parameters: + description: POT Parameters + header: POT Parameters + preset: + affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: Performance + description: Quantization preset that defines quantization scheme + editable: true + enum_name: POTQuantizationPreset + header: Preset + options: + MIXED: Mixed + PERFORMANCE: Performance + type: SELECTABLE ui_rules: action: DISABLE_EDITING operator: AND rules: [] type: UI_RULES - value: false - visible_in_ui: false + value: Performance + visible_in_ui: true + warning: null + stat_subset_size: + affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: 300 + description: Number of data samples used for post-training optimization + editable: true + header: Number of data samples + max_value: 9223372036854775807 + min_value: 1 + type: INTEGER + ui_rules: + action: DISABLE_EDITING + operator: AND + rules: [] + type: UI_RULES + value: 300 + visible_in_ui: true warning: null type: PARAMETER_GROUP visible_in_ui: false diff --git a/external/anomaly/anomaly_segmentation/configs/stfpm/configuration.py b/external/anomaly/anomaly_segmentation/configs/stfpm/configuration.py index df17aefc323..1cc58e6a554 100644 --- a/external/anomaly/anomaly_segmentation/configs/stfpm/configuration.py +++ b/external/anomaly/anomaly_segmentation/configs/stfpm/configuration.py @@ -1,5 +1,5 @@ """ -Configurable parameters for STFPM anomaly classification task +Configurable parameters for STFPM anomaly segmentation task """ # Copyright (C) 2021 Intel Corporation @@ -17,64 +17,11 @@ # and limitations under the License. from attr import attrs -from ote_anomalib.configs.configuration import BaseAnomalyConfig -from ote_anomalib.configs.configuration_enums import EarlyStoppingMetrics -from ote_sdk.configuration.elements import ( - ParameterGroup, - add_parameter_group, - configurable_integer, - selectable, - string_attribute, -) -from ote_sdk.configuration.model_lifecycle import ModelLifecycle +from ote_anomalib.configs.stfpm import STFPMAnomalyBaseConfig @attrs -class STFPMAnomalySegmentationConfig(BaseAnomalyConfig): +class STFPMAnomalySegmentationConfig(STFPMAnomalyBaseConfig): """ - Configurable parameters for STFPM anomaly classification task. + Configurable parameters for STFPM anomaly segmentation task. """ - - header = string_attribute("Configuration for STFPM") - description = header - - @attrs - class ModelParameters(ParameterGroup): - """ - Parameter Group for training model - """ - - header = string_attribute("Model Parameters") - description = header - - @attrs - class EarlyStoppingParameters(ParameterGroup): - """ - Early stopping parameters - """ - - header = string_attribute("Early Stopping Parameters") - description = header - - metric = selectable( - default_value=EarlyStoppingMetrics.IMAGE_F1, - header="Early Stopping Metric", - description="The metric used to determine if the model should stop training", - ) - - patience = configurable_integer( - default_value=10, - min_value=1, - max_value=100, - header="Early Stopping Patience", - description="Number of epochs to wait for an improvement in the monitored metric. If the metric has " - "not improved for this many epochs, the training will stop and the best model will be " - "returned.", - warning="Setting this value too low might lead to underfitting. Setting the value too high will " - "increase the training time and might lead to overfitting.", - affects_outcome_of=ModelLifecycle.TRAINING, - ) - - early_stopping = add_parameter_group(EarlyStoppingParameters) - - model = add_parameter_group(ModelParameters) diff --git a/external/anomaly/anomaly_segmentation/configs/stfpm/configuration.yaml b/external/anomaly/anomaly_segmentation/configs/stfpm/configuration.yaml index 9facd1e1d1c..8bcbda3bfa3 100644 --- a/external/anomaly/anomaly_segmentation/configs/stfpm/configuration.yaml +++ b/external/anomaly/anomaly_segmentation/configs/stfpm/configuration.yaml @@ -3,6 +3,8 @@ dataset: header: Dataset Parameters num_workers: affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null default_value: 8 description: Increasing this value might improve training speed however it might @@ -18,10 +20,13 @@ dataset: operator: AND rules: [] type: UI_RULES + value: 8 visible_in_ui: true warning: null train_batch_size: affects_outcome_of: TRAINING + auto_hpo_state: not_possible + auto_hpo_value: null default_value: 32 description: The number of training samples seen in each iteration of training. @@ -37,6 +42,7 @@ dataset: operator: AND rules: [] type: UI_RULES + value: 32 visible_in_ui: true warning: Increasing this value may cause the system to use more memory than available, @@ -45,13 +51,37 @@ dataset: visible_in_ui: true description: Configuration for STFPM header: Configuration for STFPM +id: "" model: + backbone: + affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: resnet18 + description: Pre-trained backbone used for feature extraction + editable: true + enum_name: ModelBackbone + header: Model Backbone + options: + RESNET18: resnet18 + WIDE_RESNET_50: wide_resnet50_2 + type: SELECTABLE + ui_rules: + action: DISABLE_EDITING + operator: AND + rules: [] + type: UI_RULES + value: resnet18 + visible_in_ui: true + warning: null description: Model Parameters early_stopping: description: Early Stopping Parameters header: Early Stopping Parameters metric: affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null default_value: image_F1 description: The metric used to determine if the model should stop training editable: true @@ -66,10 +96,13 @@ model: operator: AND rules: [] type: UI_RULES + value: image_F1 visible_in_ui: true warning: null patience: affects_outcome_of: TRAINING + auto_hpo_state: not_possible + auto_hpo_value: null default_value: 10 description: Number of epochs to wait for an improvement in the monitored metric. @@ -85,6 +118,7 @@ model: operator: AND rules: [] type: UI_RULES + value: 10 visible_in_ui: true warning: Setting this value too low might lead to underfitting. Setting the @@ -92,67 +126,71 @@ model: type: PARAMETER_GROUP visible_in_ui: true header: Model Parameters - type: PARAMETER_GROUP - visible_in_ui: true -pot_parameters: - description: POT Parameters - header: POT Parameters - preset: + lr: affects_outcome_of: NONE - default_value: Performance - description: Quantization preset that defines quantization scheme + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: 0.4 + description: Learning rate used for optimizing the Student network. editable: true - enum_name: POTQuantizationPreset - header: Preset - options: - MIXED: Mixed - PERFORMANCE: Performance - type: SELECTABLE + header: Learning Rate + max_value: 1 + min_value: 0.001 + type: FLOAT ui_rules: action: DISABLE_EDITING operator: AND rules: [] type: UI_RULES + value: 0.4 visible_in_ui: true warning: null - stat_subset_size: + momentum: affects_outcome_of: NONE - default_value: 300 - description: Number of data samples used for post-training optimization + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: 0.9 + description: Momentum used for SGD optimizer editable: true - header: Number of data samples - max_value: 9223372036854775807 - min_value: 1 - type: INTEGER + header: Momentum + max_value: 1.0 + min_value: 0.1 + type: FLOAT ui_rules: action: DISABLE_EDITING operator: AND rules: [] type: UI_RULES + value: 0.9 visible_in_ui: true warning: null type: PARAMETER_GROUP visible_in_ui: true -nncf_optimization: - description: Optimization by NNCF - header: Optimization by NNCF - enable_quantization: - affects_outcome_of: TRAINING - default_value: true - description: Enable quantization algorithm + weight_decay: + affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: 0.0001 + description: Decay for SGD optimizer editable: true - header: Enable quantization algorithm - type: BOOLEAN + header: Weight Decay + max_value: 1 + min_value: 1.0e-05 + type: FLOAT ui_rules: action: DISABLE_EDITING operator: AND rules: [] type: UI_RULES - value: true + value: 0.0001 visible_in_ui: true warning: null +nncf_optimization: + description: Optimization by NNCF enable_pruning: - affects_outcome_of: TRAINING + affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null default_value: false description: Enable filter pruning algorithm editable: true @@ -166,11 +204,31 @@ nncf_optimization: value: false visible_in_ui: true warning: null + enable_quantization: + affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: true + description: Enable quantization algorithm + editable: true + header: Enable quantization algorithm + type: BOOLEAN + ui_rules: + action: DISABLE_EDITING + operator: AND + rules: [] + type: UI_RULES + value: true + visible_in_ui: true + warning: null + header: Optimization by NNCF pruning_supported: affects_outcome_of: TRAINING + auto_hpo_state: not_possible + auto_hpo_value: null default_value: false description: Whether filter pruning is supported - editable: false + editable: true header: Whether filter pruning is supported type: BOOLEAN ui_rules: @@ -179,9 +237,81 @@ nncf_optimization: rules: [] type: UI_RULES value: false - visible_in_ui: false + visible_in_ui: true + warning: null + type: PARAMETER_GROUP + visible_in_ui: true +pot_parameters: + description: POT Parameters + header: POT Parameters + preset: + affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: Performance + description: Quantization preset that defines quantization scheme + editable: true + enum_name: POTQuantizationPreset + header: Preset + options: + MIXED: Mixed + PERFORMANCE: Performance + type: SELECTABLE + ui_rules: + action: DISABLE_EDITING + operator: AND + rules: [] + type: UI_RULES + value: Performance + visible_in_ui: true + warning: null + stat_subset_size: + affects_outcome_of: NONE + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: 300 + description: Number of data samples used for post-training optimization + editable: true + header: Number of data samples + max_value: 9223372036854775807 + min_value: 1 + type: INTEGER + ui_rules: + action: DISABLE_EDITING + operator: AND + rules: [] + type: UI_RULES + value: 300 + visible_in_ui: true warning: null type: PARAMETER_GROUP visible_in_ui: false +trainer: + description: Trainer Parameters + header: Trainer Parameters + max_epochs: + affects_outcome_of: TRAINING + auto_hpo_state: not_possible + auto_hpo_value: null + default_value: 100 + description: Maximum number of epochs to train the model for. + editable: true + header: Max Epochs + max_value: 500 + min_value: 1 + type: INTEGER + ui_rules: + action: DISABLE_EDITING + operator: AND + rules: [] + type: UI_RULES + value: 100 + visible_in_ui: true + warning: + Training for very few epochs might lead to poor performance. If Early + Stopping is enabled then increasing the value of max epochs might not lead to + desired result. + type: PARAMETER_GROUP + visible_in_ui: true type: CONFIGURABLE_PARAMETERS visible_in_ui: true diff --git a/external/mmdetection/build/lib/detection_tasks/apis/detection/model_wrappers/__init__.py b/external/anomaly/ote_anomalib/configs/base/__init__.py similarity index 75% rename from external/mmdetection/build/lib/detection_tasks/apis/detection/model_wrappers/__init__.py rename to external/anomaly/ote_anomalib/configs/base/__init__.py index 570552ae1af..398c125beb1 100644 --- a/external/mmdetection/build/lib/detection_tasks/apis/detection/model_wrappers/__init__.py +++ b/external/anomaly/ote_anomalib/configs/base/__init__.py @@ -1,4 +1,8 @@ -# Copyright (C) 2021 Intel Corporation +""" +Base configurable parameter for anomaly tasks +""" + +# Copyright (C) 2022 Intel Corporation # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -12,4 +16,6 @@ # See the License for the specific language governing permissions # and limitations under the License. -__all__ = [] +from .configuration import BaseAnomalyConfig + +__all__ = ["BaseAnomalyConfig"] diff --git a/external/anomaly/ote_anomalib/configs/configuration.py b/external/anomaly/ote_anomalib/configs/base/configuration.py similarity index 88% rename from external/anomaly/ote_anomalib/configs/configuration.py rename to external/anomaly/ote_anomalib/configs/base/configuration.py index 11858df24bb..01c20b5b136 100644 --- a/external/anomaly/ote_anomalib/configs/configuration.py +++ b/external/anomaly/ote_anomalib/configs/base/configuration.py @@ -19,7 +19,10 @@ from sys import maxsize from attr import attrs -from ote_anomalib.configs.configuration_enums import POTQuantizationPreset +from ote_anomalib.configs.configuration_enums import ( + ModelBackbone, + POTQuantizationPreset, +) from ote_sdk.configuration import ConfigurableParameters from ote_sdk.configuration.elements import ( ParameterGroup, @@ -126,6 +129,22 @@ class NNCFOptimization(ParameterGroup): affects_outcome_of=ModelLifecycle.TRAINING, ) + @attrs + class ModelParameters(ParameterGroup): + """ + Parameter Group for tuning the model + """ + + header = string_attribute("Model Parameters") + description = header + + backbone = selectable( + default_value=ModelBackbone.RESNET18, + header="Model Backbone", + description="Pre-trained backbone used for feature extraction", + ) + + model = add_parameter_group(ModelParameters) dataset = add_parameter_group(DatasetParameters) pot_parameters = add_parameter_group(POTParameters) nncf_optimization = add_parameter_group(NNCFOptimization) diff --git a/external/anomaly/ote_anomalib/configs/configuration_enums.py b/external/anomaly/ote_anomalib/configs/configuration_enums.py index b95bb34e479..62e98b67698 100644 --- a/external/anomaly/ote_anomalib/configs/configuration_enums.py +++ b/external/anomaly/ote_anomalib/configs/configuration_enums.py @@ -44,3 +44,12 @@ class ModelName(ConfigurableEnum): STFPM = "stfpm" PADIM = "padim" + + +class ModelBackbone(ConfigurableEnum): + """ + This enum represents the common backbones that can be used with Padim and STFPM + """ + + RESNET18 = "resnet18" + WIDE_RESNET_50 = "wide_resnet50_2" diff --git a/external/mmdetection/build/lib/detection_tasks/apis/detection/configuration_enums.py b/external/anomaly/ote_anomalib/configs/padim/__init__.py similarity index 65% rename from external/mmdetection/build/lib/detection_tasks/apis/detection/configuration_enums.py rename to external/anomaly/ote_anomalib/configs/padim/__init__.py index 067e193a374..b764a82efe0 100644 --- a/external/mmdetection/build/lib/detection_tasks/apis/detection/configuration_enums.py +++ b/external/anomaly/ote_anomalib/configs/padim/__init__.py @@ -1,4 +1,8 @@ -# Copyright (C) 2021 Intel Corporation +""" +Base configuration parameters for Padim +""" + +# Copyright (C) 2022 Intel Corporation # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -12,11 +16,6 @@ # See the License for the specific language governing permissions # and limitations under the License. -from ote_sdk.configuration import ConfigurableEnum +from .configuration import PadimAnomalyBaseConfig -class POTQuantizationPreset(ConfigurableEnum): - """ - This Enum represents the quantization preset for post training optimization - """ - PERFORMANCE = 'Performance' - MIXED = 'Mixed' +__all__ = ["PadimAnomalyBaseConfig"] diff --git a/external/mmdetection/build/lib/detection_tasks/extension/__init__.py b/external/anomaly/ote_anomalib/configs/padim/configuration.py similarity index 58% rename from external/mmdetection/build/lib/detection_tasks/extension/__init__.py rename to external/anomaly/ote_anomalib/configs/padim/configuration.py index 90eb8894330..c9c426864b5 100644 --- a/external/mmdetection/build/lib/detection_tasks/extension/__init__.py +++ b/external/anomaly/ote_anomalib/configs/padim/configuration.py @@ -1,3 +1,7 @@ +""" +Configurable parameters for Padim anomaly task +""" + # Copyright (C) 2021 Intel Corporation # # Licensed under the Apache License, Version 2.0 (the "License"); @@ -12,6 +16,16 @@ # See the License for the specific language governing permissions # and limitations under the License. -from .datasets import OTEDataset, get_annotation_mmdet_format -from .utils import (CancelTrainingHook, FixedMomentumUpdaterHook, LoadImageFromOTEDataset, EpochRunnerWithCancel, - LoadAnnotationFromOTEDataset, OTELoggerHook, OTEProgressHook, EarlyStoppingHook, ReduceLROnPlateauLrUpdaterHook) +from attr import attrs +from ote_anomalib.configs.base import BaseAnomalyConfig +from ote_sdk.configuration.elements import string_attribute + + +@attrs +class PadimAnomalyBaseConfig(BaseAnomalyConfig): + """ + Configurable parameters for PADIM anomaly classification task. + """ + + header = string_attribute("Configuration for Padim") + description = header diff --git a/external/mmdetection/build/lib/detection_tasks/extension/datasets/__init__.py b/external/anomaly/ote_anomalib/configs/stfpm/__init__.py similarity index 63% rename from external/mmdetection/build/lib/detection_tasks/extension/datasets/__init__.py rename to external/anomaly/ote_anomalib/configs/stfpm/__init__.py index e9bc5ab37d1..fb2e6736121 100644 --- a/external/mmdetection/build/lib/detection_tasks/extension/datasets/__init__.py +++ b/external/anomaly/ote_anomalib/configs/stfpm/__init__.py @@ -1,4 +1,8 @@ -# Copyright (C) 2021 Intel Corporation +""" +Base configuration parameters for STFPM +""" + +# Copyright (C) 2022 Intel Corporation # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -12,7 +16,6 @@ # See the License for the specific language governing permissions # and limitations under the License. -from .data_utils import get_anchor_boxes, get_sizes_from_dataset_entity, format_list_to_str -from .mmdataset import OTEDataset, get_annotation_mmdet_format +from .configuration import STFPMAnomalyBaseConfig -__all__ = [OTEDataset, get_annotation_mmdet_format, get_anchor_boxes, get_sizes_from_dataset_entity, format_list_to_str] +__all__ = ["STFPMAnomalyBaseConfig"] diff --git a/external/anomaly/ote_anomalib/configs/stfpm/configuration.py b/external/anomaly/ote_anomalib/configs/stfpm/configuration.py new file mode 100644 index 00000000000..0295db477fe --- /dev/null +++ b/external/anomaly/ote_anomalib/configs/stfpm/configuration.py @@ -0,0 +1,123 @@ +""" +Configurable parameters for STFPM anomaly base task +""" + +# Copyright (C) 2022 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions +# and limitations under the License. + +from attr import attrs +from ote_anomalib.configs.base import BaseAnomalyConfig +from ote_anomalib.configs.configuration_enums import EarlyStoppingMetrics +from ote_sdk.configuration.elements import ( + ParameterGroup, + add_parameter_group, + configurable_float, + configurable_integer, + selectable, + string_attribute, +) +from ote_sdk.configuration.model_lifecycle import ModelLifecycle + + +@attrs +class STFPMAnomalyBaseConfig(BaseAnomalyConfig): + """ + Configurable parameters for STFPM anomaly base task. + """ + + header = string_attribute("Configuration for STFPM") + description = header + + @attrs + class ModelParameters(BaseAnomalyConfig.ModelParameters): + """ + Parameter Group for training model + """ + + lr = configurable_float( + default_value=0.4, + header="Learning Rate", + min_value=1e-3, + max_value=1, + description="Learning rate used for optimizing the Student network.", + ) + + momentum = configurable_float( + default_value=0.9, + header="Momentum", + min_value=0.1, + max_value=1.0, + description="Momentum used for SGD optimizer", + ) + + weight_decay = configurable_float( + default_value=0.0001, + header="Weight Decay", + min_value=1e-5, + max_value=1, + description="Decay for SGD optimizer", + ) + + @attrs + class EarlyStoppingParameters(ParameterGroup): + """ + Early stopping parameters + """ + + header = string_attribute("Early Stopping Parameters") + description = header + + metric = selectable( + default_value=EarlyStoppingMetrics.IMAGE_F1, + header="Early Stopping Metric", + description="The metric used to determine if the model should stop training", + ) + + patience = configurable_integer( + default_value=10, + min_value=1, + max_value=100, + header="Early Stopping Patience", + description="Number of epochs to wait for an improvement in the monitored metric. If the metric has " + "not improved for this many epochs, the training will stop and the best model will be " + "returned.", + warning="Setting this value too low might lead to underfitting. Setting the value too high will " + "increase the training time and might lead to overfitting.", + affects_outcome_of=ModelLifecycle.TRAINING, + ) + + early_stopping = add_parameter_group(EarlyStoppingParameters) + + @attrs + class TrainerParameters(ParameterGroup): + """ + Parameters related to PyTorch Lightning trainer + """ + + header = string_attribute("Trainer Parameters") + description = header + + max_epochs = configurable_integer( + default_value=100, + header="Max Epochs", + min_value=1, + max_value=500, + description="Maximum number of epochs to train the model for.", + warning="Training for very few epochs might lead to poor performance. If Early Stopping is enabled then " + "increasing the value of max epochs might not lead to desired result.", + affects_outcome_of=ModelLifecycle.TRAINING, + ) + + trainer = add_parameter_group(TrainerParameters) + model = add_parameter_group(ModelParameters) diff --git a/external/anomaly/ote_anomalib/nncf_task.py b/external/anomaly/ote_anomalib/nncf_task.py index 2b4cabcc7d3..5b5bd4182ea 100644 --- a/external/anomaly/ote_anomalib/nncf_task.py +++ b/external/anomaly/ote_anomalib/nncf_task.py @@ -36,6 +36,7 @@ from ote_sdk.entities.datasets import DatasetEntity from ote_sdk.entities.model import ( ModelEntity, + ModelFormat, ModelOptimizationType, ModelPrecision, OptimizationMethod, @@ -183,6 +184,8 @@ def optimize( self.trainer = Trainer(**self.config.trainer, logger=False, callbacks=callbacks) self.trainer.fit(model=self.model, datamodule=datamodule) self.compression_ctrl = nncf_callback.nncf_ctrl + output_model.model_format = ModelFormat.BASE_FRAMEWORK + output_model.optimization_type = ModelOptimizationType.NNCF self.save_model(output_model) logger.info("Training completed.") diff --git a/external/anomaly/ote_tests_pytest.ini b/external/anomaly/ote_tests_pytest.ini new file mode 100644 index 00000000000..c2d07cb3f9d --- /dev/null +++ b/external/anomaly/ote_tests_pytest.ini @@ -0,0 +1,2 @@ +[pytest] +python_files = test_ote_api.py test_ote_inference.py test_ote_training.py \ No newline at end of file diff --git a/external/anomaly/tests/conftest.py b/external/anomaly/tests/conftest.py new file mode 100644 index 00000000000..427a5f6ee92 --- /dev/null +++ b/external/anomaly/tests/conftest.py @@ -0,0 +1,84 @@ +# 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. + +try: + import e2e.fixtures + + from e2e.conftest_utils import * # noqa + from e2e.conftest_utils import pytest_addoption as _e2e_pytest_addoption # noqa + from e2e import config # noqa + from e2e.utils import get_plugins_from_packages + pytest_plugins = get_plugins_from_packages([e2e]) +except ImportError: + _e2e_pytest_addoption = None + pass +import pytest +from ote_sdk.test_suite.pytest_insertions import ( + get_pytest_plugins_from_ote, + ote_conftest_insertion, + ote_pytest_generate_tests_insertion, + ote_pytest_addoption_insertion, +) +from ote_sdk.test_suite.training_tests_common import REALLIFE_USECASE_CONSTANT + +pytest_plugins = get_pytest_plugins_from_ote() + +ote_conftest_insertion(default_repository_name="ote/training_extensions/external/anomaly") + + +@pytest.fixture +def ote_test_domain_fx(): + return "custom-anomaly-classification" + + +@pytest.fixture +def ote_test_scenario_fx(current_test_parameters_fx): + assert isinstance(current_test_parameters_fx, dict) + if current_test_parameters_fx.get("usecase") == REALLIFE_USECASE_CONSTANT: + return "performance" + else: + return "integration" + + +@pytest.fixture(scope="session") +def ote_templates_root_dir_fx(): + import os.path as osp + import logging + + logger = logging.getLogger(__name__) + root = osp.dirname(osp.dirname(osp.realpath(__file__))) + root = f"{root}/anomaly_classification/" + logger.debug(f"overloaded ote_templates_root_dir_fx: return {root}") + return root + + +@pytest.fixture(scope="session") +def ote_reference_root_dir_fx(): + import os.path as osp + import logging + + logger = logging.getLogger(__name__) + root = osp.dirname(osp.dirname(osp.realpath(__file__))) + root = f"{root}/tests/reference/" + logger.debug(f"overloaded ote_reference_root_dir_fx: return {root}") + return root + + +# pytest magic +def pytest_generate_tests(metafunc): + ote_pytest_generate_tests_insertion(metafunc) + + +def pytest_addoption(parser): + ote_pytest_addoption_insertion(parser) diff --git a/external/anomaly/tests/expected_metrics/metrics_test_ote_training.yml b/external/anomaly/tests/expected_metrics/metrics_test_ote_training.yml new file mode 100644 index 00000000000..bd74e44d1dc --- /dev/null +++ b/external/anomaly/tests/expected_metrics/metrics_test_ote_training.yml @@ -0,0 +1,43 @@ +? "ACTION-training_evaluation,model-ote_anomaly_classification_padim,dataset-mvtec,patience-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "target_value": 0.73 + "max_diff_if_less_threshold": 0.01 + "max_diff_if_greater_threshold": 0.04 +? "ACTION-export_evaluation,model-ote_anomaly_classification_padim,dataset-mvtec,patience-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.01 +? "ACTION-pot_evaluation,model-ote_anomaly_classification_padim,dataset-mvtec,patience-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "export_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.03 +? "ACTION-nncf_evaluation,model-ote_anomaly_classification_padim,dataset-mvtec,patience-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff_if_less_threshold": 0.01 +? "ACTION-nncf_export_evaluation,model-ote_anomaly_classification_padim,dataset-mvtec,patience-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "nncf_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.01 + +? "ACTION-training_evaluation,model-ote_anomaly_classification_stfpm,dataset-mvtec,patience-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "target_value": 0.74 + "max_diff_if_less_threshold": 0.01 + "max_diff_if_greater_threshold": 0.04 +? "ACTION-export_evaluation,model-ote_anomaly_classification_stfpm,dataset-mvtec,patience-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.01 +? "ACTION-pot_evaluation,model-ote_anomaly_classification_stfpm,dataset-mvtec,patience-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "export_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.03 +? "ACTION-nncf_evaluation,model-ote_anomaly_classification_stfpm,dataset-mvtec,patience-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "training_evaluation.metrics.accuracy.f-measure" + "max_diff_if_less_threshold": 0.01 +? "ACTION-nncf_export_evaluation,model-ote_anomaly_classification_stfpm,dataset-mvtec,patience-CONFIG,batch-CONFIG,usecase-reallife" +: "metrics.accuracy.f-measure": + "base": "nncf_evaluation.metrics.accuracy.f-measure" + "max_diff": 0.01 diff --git a/external/anomaly/tests/test_ote_training.py b/external/anomaly/tests/test_ote_training.py new file mode 100644 index 00000000000..f868eb812e5 --- /dev/null +++ b/external/anomaly/tests/test_ote_training.py @@ -0,0 +1,400 @@ +# 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 os +from collections import namedtuple, OrderedDict +from copy import deepcopy +from pprint import pformat +from typing import Any, Callable, Dict, List, Optional, Type + +import pytest +from ote_sdk.entities.model import ModelEntity +from ote_sdk.entities.datasets import DatasetEntity +from ote_sdk.entities.model_template import parse_model_template +from ote_sdk.entities.label_schema import LabelSchemaEntity +from ote_sdk.entities.subset import Subset +from ote_sdk.entities.train_parameters import TrainParameters + +from ote_anomalib.data.mvtec import OteMvtecDataset +from ote_anomalib.logging import get_logger + +from ote_sdk.configuration.helper import create as ote_sdk_configuration_helper_create +from ote_sdk.test_suite.training_test_case import OTETestCaseInterface, generate_ote_integration_test_case_class +from ote_sdk.test_suite.e2e_test_system import DataCollector, e2e_pytest_performance +from ote_sdk.test_suite.training_tests_common import ( + make_path_be_abs, + make_paths_be_abs, + performance_to_score_name_value, + KEEP_CONFIG_FIELD_VALUE, + REALLIFE_USECASE_CONSTANT, + ROOT_PATH_KEY, +) +from ote_sdk.test_suite.training_tests_helper import ( + OTETestHelper, + DefaultOTETestCreationParametersInterface, + OTETrainingTestInterface, +) +from ote_sdk.test_suite.training_tests_actions import ( + create_environment_and_task, + OTETestTrainingAction, + BaseOTETestAction, + OTETestTrainingEvaluationAction, + OTETestExportAction, + OTETestExportEvaluationAction, + OTETestPotAction, + OTETestPotEvaluationAction, + OTETestNNCFAction, + OTETestNNCFEvaluationAction, + OTETestNNCFExportAction, + OTETestNNCFExportEvaluationAction, + OTETestNNCFGraphAction, +) + +logger = get_logger(__name__) + + +def DATASET_PARAMETERS_FIELDS() -> List[str]: + return deepcopy(["dataset_path"]) + + +DatasetParameters = namedtuple("DatasetParameters", DATASET_PARAMETERS_FIELDS()) # type: ignore + + +def _get_dataset_params_from_dataset_definitions(dataset_definitions, dataset_name): + if dataset_name not in dataset_definitions: + raise ValueError( + f"dataset {dataset_name} is absent in dataset_definitions, " + f"dataset_definitions.keys={list(dataset_definitions.keys())}" + ) + cur_dataset_definition = dataset_definitions[dataset_name] + training_parameters_fields = {k: v for k, v in cur_dataset_definition.items() if k in DATASET_PARAMETERS_FIELDS()} + print(f"training_parameters_fields: {training_parameters_fields}") + make_paths_be_abs(training_parameters_fields, dataset_definitions[ROOT_PATH_KEY]) + print(f"training_parameters_fields after make_paths_be_abs: {training_parameters_fields}") + + assert set(DATASET_PARAMETERS_FIELDS()) == set( + training_parameters_fields.keys() + ), f"ERROR: dataset definitions for name={dataset_name} does not contain all required fields" + assert all( + training_parameters_fields.values() + ), f"ERROR: dataset definitions for name={dataset_name} contains empty values for some required fields" + + params = DatasetParameters(**training_parameters_fields) + return params + + +def _create_anomaly_classification_dataset_and_labels_schema(dataset_params, dataset_name): + logger.debug(f"Path to dataset: {dataset_params.dataset_path}") + category_list = [f.path for f in os.scandir(dataset_params.dataset_path) if f.is_dir()] + items = [] + if "short" in dataset_name: + logger.debug(f"Creating short dataset {dataset_name}") + items.extend(OteMvtecDataset(path=dataset_params.dataset_path, seed=0).generate()) + else: + for category in category_list: + logger.debug(f"Creating dataset for {category}") + items.extend(OteMvtecDataset(path=category, seed=0).generate()) + dataset = DatasetEntity(items=items) + labels = dataset.get_labels() + labels_schema = LabelSchemaEntity.from_labels(labels) + return dataset, labels_schema + + +def get_anomaly_test_action_classes() -> List[Type[BaseOTETestAction]]: + return [ + AnomalyDetectionTestTrainingAction, + OTETestTrainingEvaluationAction, + OTETestExportAction, + OTETestExportEvaluationAction, + OTETestPotAction, + OTETestPotEvaluationAction, + OTETestNNCFAction, + OTETestNNCFEvaluationAction, + OTETestNNCFExportAction, + OTETestNNCFExportEvaluationAction, + OTETestNNCFGraphAction, + ] + + +class AnomalyClassificationTrainingTestParameters(DefaultOTETestCreationParametersInterface): + def test_case_class(self) -> Type[OTETestCaseInterface]: + return generate_ote_integration_test_case_class(get_anomaly_test_action_classes()) + + def test_bunches(self) -> List[Dict[str, Any]]: + test_bunches = [ + dict( + model_name=[ + "ote_anomaly_classification_padim", + "ote_anomaly_classification_stfpm", + ], + dataset_name="mvtec_short", + usecase="precommit", + ), + dict( + model_name=[ + "ote_anomaly_classification_padim", + "ote_anomaly_classification_stfpm", + ], + dataset_name="mvtec", + patience=KEEP_CONFIG_FIELD_VALUE, + batch_size=KEEP_CONFIG_FIELD_VALUE, + usecase=REALLIFE_USECASE_CONSTANT, + ), + ] + return deepcopy(test_bunches) + + def short_test_parameters_names_for_generating_id(self) -> OrderedDict: + DEFAULT_SHORT_TEST_PARAMETERS_NAMES_FOR_GENERATING_ID = OrderedDict( + [ + ("test_stage", "ACTION"), + ("model_name", "model"), + ("dataset_name", "dataset"), + ("patience", "patience"), + ("batch_size", "batch"), + ("usecase", "usecase"), + ] + ) + return deepcopy(DEFAULT_SHORT_TEST_PARAMETERS_NAMES_FOR_GENERATING_ID) + + def test_parameters_defining_test_case_behavior(self) -> List[str]: + DEFAULT_TEST_PARAMETERS_DEFINING_IMPL_BEHAVIOR = [ + "model_name", + "dataset_name", + "patience", + "batch_size", + ] + return deepcopy(DEFAULT_TEST_PARAMETERS_DEFINING_IMPL_BEHAVIOR) + + def default_test_parameters(self) -> Dict[str, Any]: + DEFAULT_TEST_PARAMETERS = { + "patience": 1, + "batch_size": 2, + } + return deepcopy(DEFAULT_TEST_PARAMETERS) + + +# TODO:pfinashx: This function copies with minor change OTETestTrainingAction +# from ote_sdk.test_suite. +# Try to avoid copying of code. +class AnomalyDetectionTestTrainingAction(OTETestTrainingAction): + _name = "training" + + def __init__(self, dataset, labels_schema, template_path, patience, batch_size): + self.dataset = dataset + self.labels_schema = labels_schema + self.template_path = template_path + self.num_training_iters = patience + self.batch_size = batch_size + + def _get_training_performance_as_score_name_value(self): + training_performance = getattr(self.output_model, "performance", None) + if training_performance is None: + raise RuntimeError("Cannot get training performance") + return performance_to_score_name_value(training_performance) + + def _run_ote_training(self, data_collector): + logger.debug(f"self.template_path = {self.template_path}") + + print(f"train dataset: {len(self.dataset.get_subset(Subset.TRAINING))} items") + print(f"validation dataset: " f"{len(self.dataset.get_subset(Subset.VALIDATION))} items") + + logger.debug("Load model template") + self.model_template = parse_model_template(self.template_path) + + logger.debug("Set hyperparameters") + params = ote_sdk_configuration_helper_create(self.model_template.hyper_parameters.data) + if hasattr(params, "model"): + if self.num_training_iters != KEEP_CONFIG_FIELD_VALUE: + params.model.early_stopping.patience = int(self.num_training_iters) + logger.debug(f"Set params.model.early_stopping.patience=" f"{params.model.early_stopping.patience}") + else: + logger.debug(f"Keep params.model.early_stopping.patience=" f"{params.model.early_stopping.patience}") + if self.batch_size != KEEP_CONFIG_FIELD_VALUE: + params.dataset.train_batch_size = int(self.batch_size) + logger.debug(f"Set params.dataset.train_batch_size=" f"{params.dataset.train_batch_size}") + else: + logger.debug(f"Keep params.dataset.train_batch_size=" f"{params.dataset.train_batch_size}") + + logger.debug("Setup environment") + self.environment, self.task = create_environment_and_task(params, self.labels_schema, self.model_template) + + logger.debug("Train model") + self.output_model = ModelEntity( + self.dataset, + self.environment.get_model_configuration(), + ) + + self.copy_hyperparams = deepcopy(self.task.task_environment.get_hyper_parameters()) + + try: + self.task.train(self.dataset, self.output_model, TrainParameters) + except Exception as ex: + raise RuntimeError("Training failed") from ex + + score_name, score_value = self._get_training_performance_as_score_name_value() + logger.info(f"performance={self.output_model.performance}") + data_collector.log_final_metric("metric_name", self.name + "/" + score_name) + data_collector.log_final_metric("metric_value", score_value) + + def __call__(self, data_collector: DataCollector, results_prev_stages: OrderedDict): + self._run_ote_training(data_collector) + results = { + "model_template": self.model_template, + "task": self.task, + "dataset": self.dataset, + "environment": self.environment, + "output_model": self.output_model, + } + return results + + +class TestOTEReallifeAnomalyClassification(OTETrainingTestInterface): + """ + The main class of running test in this file. + """ + + PERFORMANCE_RESULTS = None # it is required for e2e system + helper = OTETestHelper(AnomalyClassificationTrainingTestParameters()) + + @classmethod + def get_list_of_tests(cls, usecase: Optional[str] = None): + """ + This method should be a classmethod. It is called before fixture initialization, during + tests discovering. + """ + return cls.helper.get_list_of_tests(usecase) + + @pytest.fixture + def params_factories_for_test_actions_fx( + self, current_test_parameters_fx, dataset_definitions_fx, ote_current_reference_dir_fx, template_paths_fx + ) -> Dict[str, Callable[[], Dict]]: + logger.debug("params_factories_for_test_actions_fx: begin") + + test_parameters = deepcopy(current_test_parameters_fx) + dataset_definitions = deepcopy(dataset_definitions_fx) + template_paths = deepcopy(template_paths_fx) + + def _training_params_factory() -> Dict: + if dataset_definitions is None: + pytest.skip('The parameter "--dataset-definitions" is not set') + model_name = test_parameters["model_name"] + dataset_name = test_parameters["dataset_name"] + patience = test_parameters["patience"] + batch_size = test_parameters["batch_size"] + dataset_params = _get_dataset_params_from_dataset_definitions(dataset_definitions, dataset_name) + + if model_name not in template_paths: + raise ValueError( + f"Model {model_name} is absent in template_paths, " + f"template_paths.keys={list(template_paths.keys())}" + ) + template_path = make_path_be_abs(template_paths[model_name], template_paths[ROOT_PATH_KEY]) + logger.debug("training params factory: Before creating dataset and labels_schema") + dataset, labels_schema = _create_anomaly_classification_dataset_and_labels_schema( + dataset_params, dataset_name + ) + logger.debug("training params factory: After creating dataset and labels_schema") + return { + "dataset": dataset, + "labels_schema": labels_schema, + "template_path": template_path, + "patience": patience, + "batch_size": batch_size, + } + + def _nncf_graph_params_factory() -> Dict: + if dataset_definitions is None: + pytest.skip('The parameter "--dataset-definitions" is not set') + + model_name = test_parameters["model_name"] + dataset_name = test_parameters["dataset_name"] + + dataset_params = _get_dataset_params_from_dataset_definitions(dataset_definitions, dataset_name) + + if model_name not in template_paths: + raise ValueError( + f"Model {model_name} is absent in template_paths, " + f"template_paths.keys={list(template_paths.keys())}" + ) + template_path = make_path_be_abs(template_paths[model_name], template_paths[ROOT_PATH_KEY]) + + logger.debug("training params factory: Before creating dataset and labels_schema") + dataset, labels_schema = _create_anomaly_classification_dataset_and_labels_schema( + dataset_params, dataset_name + ) + logger.debug("training params factory: After creating dataset and labels_schema") + + return { + "dataset": dataset, + "labels_schema": labels_schema, + "template_path": template_path, + "reference_dir": ote_current_reference_dir_fx, + "fn_get_compressed_model": None, # NNCF not yet implemented in Anomaly + } + + params_factories_for_test_actions = { + "training": _training_params_factory, + "nncf_graph": _nncf_graph_params_factory, + } + logger.debug("params_factories_for_test_actions_fx: end") + return params_factories_for_test_actions + + @pytest.fixture + def test_case_fx(self, current_test_parameters_fx, params_factories_for_test_actions_fx): + """ + This fixture returns the test case class OTEIntegrationTestCase that should be used for the current test. + Note that the cache from the test helper allows to store the instance of the class + between the tests. + If the main parameters used for this test are the same as the main parameters used for the previous test, + the instance of the test case class will be kept and re-used. It is helpful for tests that can + re-use the result of operations (model training, model optimization, etc) made for the previous tests, + if these operations are time-consuming. + If the main parameters used for this test differs w.r.t. the previous test, a new instance of + test case class will be created. + """ + test_case = type(self).helper.get_test_case(current_test_parameters_fx, params_factories_for_test_actions_fx) + return test_case + + # TODO(lbeynens): move to common fixtures + @pytest.fixture + def data_collector_fx(self, request) -> DataCollector: + setup = deepcopy(request.node.callspec.params) + setup["environment_name"] = os.environ.get("TT_ENVIRONMENT_NAME", "no-env") + setup["test_type"] = os.environ.get("TT_TEST_TYPE", "no-test-type") # TODO: get from e2e test type + setup["scenario"] = "api" # TODO(lbeynens): get from a fixture! + setup["test"] = request.node.name + setup["subject"] = "custom-anomaly-classification" + setup["project"] = "ote" + if "test_parameters" in setup: + assert isinstance(setup["test_parameters"], dict) + if "dataset_name" not in setup: + setup["dataset_name"] = setup["test_parameters"].get("dataset_name") + if "model_name" not in setup: + setup["model_name"] = setup["test_parameters"].get("model_name") + if "test_stage" not in setup: + setup["test_stage"] = setup["test_parameters"].get("test_stage") + if "usecase" not in setup: + setup["usecase"] = setup["test_parameters"].get("usecase") + logger.info(f"creating DataCollector: setup=\n{pformat(setup, width=140)}") + data_collector = DataCollector(name="TestOTEIntegration", setup=setup) + with data_collector: + logger.info("data_collector is created") + yield data_collector + logger.info("data_collector is released") + + @e2e_pytest_performance + def test(self, test_parameters, test_case_fx, data_collector_fx, cur_test_expected_metrics_callback_fx): + if "nncf_graph" in test_parameters["test_stage"]: + pytest.xfail("The models has no a reference NNCF graph yet, please see CVS-83365") + test_case_fx.run_stage(test_parameters["test_stage"], data_collector_fx, cur_test_expected_metrics_callback_fx) diff --git a/external/deep-object-reid/configs/ote_custom_classification/mobilenet_v3_small/main_model_multilabel.yaml b/external/deep-object-reid/configs/ote_custom_classification/mobilenet_v3_small/main_model_multilabel.yaml index 9ccd4294104..e7f1745f397 100644 --- a/external/deep-object-reid/configs/ote_custom_classification/mobilenet_v3_small/main_model_multilabel.yaml +++ b/external/deep-object-reid/configs/ote_custom_classification/mobilenet_v3_small/main_model_multilabel.yaml @@ -19,12 +19,9 @@ model: custom_datasets: roots: ['data/coco/train.json', 'data/coco/val.json'] types: ['multilabel_classification', 'multilabel_classification'] - names: ['coco_train', 'coco_val'] data: root: './' - sources: ['coco_train'] - targets: ['coco_val'] height: 224 width: 224 norm_mean: [0.485, 0.456, 0.406] diff --git a/external/deep-object-reid/submodule b/external/deep-object-reid/submodule index 8376d3ec0d3..d7f473ab659 160000 --- a/external/deep-object-reid/submodule +++ b/external/deep-object-reid/submodule @@ -1 +1 @@ -Subproject commit 8376d3ec0d3ceaf540020a070661739cddd9110b +Subproject commit d7f473ab659b3dd394bc36574dcf010882b26cf6 diff --git a/external/mmdetection/build/lib/detection_tasks/__init__.py b/external/mmdetection/build/lib/detection_tasks/__init__.py deleted file mode 100644 index e69de29bb2d..00000000000 diff --git a/external/mmdetection/build/lib/detection_tasks/apis/__init__.py b/external/mmdetection/build/lib/detection_tasks/apis/__init__.py deleted file mode 100644 index e69de29bb2d..00000000000 diff --git a/external/mmdetection/build/lib/detection_tasks/apis/detection/__init__.py b/external/mmdetection/build/lib/detection_tasks/apis/detection/__init__.py deleted file mode 100644 index 03c0dce1f69..00000000000 --- a/external/mmdetection/build/lib/detection_tasks/apis/detection/__init__.py +++ /dev/null @@ -1,42 +0,0 @@ -# Copyright (C) 2021 Intel Corporation -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions -# and limitations under the License. - - -from .config_utils import (config_from_string, config_to_string, patch_config, - prepare_for_testing, prepare_for_training, - save_config_to_file, set_hyperparams) -from .configuration import OTEDetectionConfig -from .inference_task import OTEDetectionInferenceTask -from .nncf_task import OTEDetectionNNCFTask -from .openvino_task import OpenVINODetectionTask -from .ote_utils import generate_label_schema, get_task_class, load_template -from .train_task import OTEDetectionTrainingTask - -__all__ = [ - config_from_string, - config_to_string, - generate_label_schema, - get_task_class, - load_template, - OpenVINODetectionTask, - OTEDetectionConfig, - OTEDetectionInferenceTask, - OTEDetectionNNCFTask, - OTEDetectionTrainingTask, - patch_config, - prepare_for_testing, - prepare_for_training, - save_config_to_file, - set_hyperparams, - ] diff --git a/external/mmdetection/build/lib/detection_tasks/apis/detection/config_utils.py b/external/mmdetection/build/lib/detection_tasks/apis/detection/config_utils.py deleted file mode 100644 index 57eabc94bf2..00000000000 --- a/external/mmdetection/build/lib/detection_tasks/apis/detection/config_utils.py +++ /dev/null @@ -1,339 +0,0 @@ -# Copyright (C) 2021 Intel Corporation -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions -# and limitations under the License. - -import copy -import glob -import math -import os -import tempfile -from collections import defaultdict -from typing import List, Optional - -import torch -from mmcv import Config, ConfigDict -from ote_sdk.entities.datasets import DatasetEntity -from ote_sdk.entities.label import LabelEntity, Domain -from ote_sdk.usecases.reporting.time_monitor_callback import TimeMonitorCallback - -from detection_tasks.extension.datasets.data_utils import get_anchor_boxes, \ - get_sizes_from_dataset_entity, format_list_to_str -from mmdet.models.detectors import BaseDetector -from mmdet.utils.logger import get_root_logger - -from .configuration import OTEDetectionConfig - -try: - from sklearn.cluster import KMeans - kmeans_import = True -except ImportError: - kmeans_import = False - - -logger = get_root_logger() - - -def is_epoch_based_runner(runner_config: ConfigDict): - return 'Epoch' in runner_config.type - - -def patch_config(config: Config, work_dir: str, labels: List[LabelEntity], domain: Domain, random_seed: Optional[int] = None): - # Set runner if not defined. - if 'runner' not in config: - config.runner = {'type': 'EpochBasedRunner'} - - # Check that there is no conflict in specification of number of training epochs. - # Move global definition of epochs inside runner config. - if 'total_epochs' in config: - if is_epoch_based_runner(config.runner): - if config.runner.max_epochs != config.total_epochs: - logger.warning('Conflicting declaration of training epochs number.') - config.runner.max_epochs = config.total_epochs - else: - logger.warning(f'Total number of epochs set for an iteration based runner {config.runner.type}.') - remove_from_config(config, 'total_epochs') - - # Change runner's type. - if is_epoch_based_runner(config.runner): - logger.info(f'Replacing runner from {config.runner.type} to EpochRunnerWithCancel.') - config.runner.type = 'EpochRunnerWithCancel' - else: - logger.info(f'Replacing runner from {config.runner.type} to IterBasedRunnerWithCancel.') - config.runner.type = 'IterBasedRunnerWithCancel' - - # Add training cancelation hook. - if 'custom_hooks' not in config: - config.custom_hooks = [] - if 'CancelTrainingHook' not in {hook.type for hook in config.custom_hooks}: - config.custom_hooks.append({'type': 'CancelTrainingHook'}) - - # Remove high level data pipelines definition leaving them only inside `data` section. - remove_from_config(config, 'train_pipeline') - remove_from_config(config, 'test_pipeline') - - # Patch data pipeline, making it OTE-compatible. - patch_datasets(config, domain) - - # Remove FP16 config if running on CPU device and revert to FP32 - # https://github.com/pytorch/pytorch/issues/23377 - if not torch.cuda.is_available() and 'fp16' in config: - logger.info(f'Revert FP16 to FP32 on CPU device') - remove_from_config(config, 'fp16') - - if 'log_config' not in config: - config.log_config = ConfigDict() - # config.log_config.hooks = [] - - if 'evaluation' not in config: - config.evaluation = ConfigDict() - evaluation_metric = config.evaluation.get('metric') - if evaluation_metric is not None: - config.evaluation.save_best = evaluation_metric - - if 'checkpoint_config' not in config: - config.checkpoint_config = ConfigDict() - config.checkpoint_config.max_keep_ckpts = 5 - config.checkpoint_config.interval = config.evaluation.get('interval', 1) - - set_data_classes(config, labels) - - config.gpu_ids = range(1) - config.work_dir = work_dir - config.seed = random_seed - - -def set_hyperparams(config: Config, hyperparams: OTEDetectionConfig): - config.optimizer.lr = float(hyperparams.learning_parameters.learning_rate) - config.lr_config.warmup_iters = int(hyperparams.learning_parameters.learning_rate_warmup_iters) - if config.lr_config.warmup_iters == 0: - config.lr_config.warmup = None - config.data.samples_per_gpu = int(hyperparams.learning_parameters.batch_size) - config.data.workers_per_gpu = int(hyperparams.learning_parameters.num_workers) - total_iterations = int(hyperparams.learning_parameters.num_iters) - if is_epoch_based_runner(config.runner): - config.runner.max_epochs = total_iterations - else: - config.runner.max_iters = total_iterations - - -def patch_adaptive_repeat_dataset(config: Config, num_samples: int, - decay: float = -0.002, factor: float = 30): - """ Patch the repeat times and training epochs adatively - - Frequent dataloading inits and evaluation slow down training when the - sample size is small. Adjusting epoch and dataset repetition based on - empirical exponential decay improves the training time by applying high - repeat value to small sample size dataset and low repeat value to large - sample. - - :param config: mmcv config - :param num_samples: number of training samples - :param decay: decaying rate - :param factor: base repeat factor - """ - data_train = config.data.train - if data_train.type == 'MultiImageMixDataset': - data_train = data_train.dataset - if data_train.type == 'RepeatDataset' and getattr(data_train, 'adaptive_repeat_times', False): - if is_epoch_based_runner(config.runner): - cur_epoch = config.runner.max_epochs - new_repeat = max(round(math.exp(decay * num_samples) * factor), 1) - new_epoch = math.ceil(cur_epoch / new_repeat) - if new_epoch == 1: - return - config.runner.max_epochs = new_epoch - data_train.times = new_repeat - - -def prepare_for_testing(config: Config, dataset: DatasetEntity) -> Config: - config = copy.deepcopy(config) - # FIXME. Should working directories be modified here? - config.data.test.ote_dataset = dataset - return config - - -def prepare_for_training(config: Config, train_dataset: DatasetEntity, val_dataset: DatasetEntity, - time_monitor: TimeMonitorCallback, learning_curves: defaultdict) -> Config: - config = copy.deepcopy(config) - prepare_work_dir(config) - data_train = get_data_cfg(config) - data_train.ote_dataset = train_dataset - config.data.val.ote_dataset = val_dataset - patch_adaptive_repeat_dataset(config, len(train_dataset)) - config.custom_hooks.append({'type': 'OTEProgressHook', 'time_monitor': time_monitor, 'verbose': True}) - config.log_config.hooks.append({'type': 'OTELoggerHook', 'curves': learning_curves}) - return config - - -def config_to_string(config: Config) -> str: - """ - Convert a full mmdetection config to a string. - - :param config: configuration object to convert - :return str: string representation of the configuration - """ - config_copy = copy.deepcopy(config) - # Clean config up by removing dataset as this causes the pretty text parsing to fail. - config_copy.data.test.ote_dataset = None - config_copy.data.test.labels = None - config_copy.data.val.ote_dataset = None - config_copy.data.val.labels = None - data_train = get_data_cfg(config_copy) - data_train.ote_dataset = None - data_train.labels = None - return Config(config_copy).pretty_text - - -def config_from_string(config_string: str) -> Config: - """ - Generate an mmdetection config dict object from a string. - - :param config_string: string to parse - :return config: configuration object - """ - with tempfile.NamedTemporaryFile('w', suffix='.py') as temp_file: - temp_file.write(config_string) - temp_file.flush() - return Config.fromfile(temp_file.name) - - -def save_config_to_file(config: Config): - """ Dump the full config to a file. Filename is 'config.py', it is saved in the current work_dir. """ - filepath = os.path.join(config.work_dir, 'config.py') - config_string = config_to_string(config) - with open(filepath, 'w') as f: - f.write(config_string) - - -def prepare_work_dir(config: Config) -> str: - base_work_dir = config.work_dir - checkpoint_dirs = glob.glob(os.path.join(base_work_dir, "checkpoints_round_*")) - train_round_checkpoint_dir = os.path.join(base_work_dir, f"checkpoints_round_{len(checkpoint_dirs)}") - os.makedirs(train_round_checkpoint_dir) - logger.info(f"Checkpoints and logs for this training run are stored in {train_round_checkpoint_dir}") - config.work_dir = train_round_checkpoint_dir - if 'meta' not in config.runner: - config.runner.meta = ConfigDict() - config.runner.meta.exp_name = f"train_round_{len(checkpoint_dirs)}" - # Save training config for debugging. It is saved in the checkpoint dir for this training round. - # save_config_to_file(config) - return train_round_checkpoint_dir - - -def set_data_classes(config: Config, labels: List[LabelEntity]): - # Save labels in data configs. - for subset in ('train', 'val', 'test'): - cfg = get_data_cfg(config, subset) - cfg.labels = labels - config.data[subset].labels = labels - - # Set proper number of classes in model's detection heads. - head_names = ('mask_head', 'bbox_head', 'segm_head') - num_classes = len(labels) - if 'roi_head' in config.model: - for head_name in head_names: - if head_name in config.model.roi_head: - if isinstance(config.model.roi_head[head_name], List): - for head in config.model.roi_head[head_name]: - head.num_classes = num_classes - else: - config.model.roi_head[head_name].num_classes = num_classes - else: - for head_name in head_names: - if head_name in config.model: - config.model[head_name].num_classes = num_classes - # FIXME. ? - # self.config.model.CLASSES = label_names - - -def patch_datasets(config: Config, domain): - - def patch_color_conversion(pipeline): - # Default data format for OTE is RGB, while mmdet uses BGR, so negate the color conversion flag. - for pipeline_step in pipeline: - if pipeline_step.type == 'Normalize': - to_rgb = False - if 'to_rgb' in pipeline_step: - to_rgb = pipeline_step.to_rgb - to_rgb = not bool(to_rgb) - pipeline_step.to_rgb = to_rgb - elif pipeline_step.type == 'MultiScaleFlipAug': - patch_color_conversion(pipeline_step.transforms) - - assert 'data' in config - for subset in ('train', 'val', 'test'): - cfg = get_data_cfg(config, subset) - cfg.type = 'OTEDataset' - cfg.domain = domain - cfg.ote_dataset = None - cfg.labels = None - remove_from_config(cfg, 'ann_file') - remove_from_config(cfg, 'img_prefix') - for pipeline_step in cfg.pipeline: - if pipeline_step.type == 'LoadImageFromFile': - pipeline_step.type = 'LoadImageFromOTEDataset' - if pipeline_step.type == 'LoadAnnotations': - pipeline_step.type = 'LoadAnnotationFromOTEDataset' - pipeline_step.domain = domain - pipeline_step.min_size = cfg.pop('min_size', -1) - patch_color_conversion(cfg.pipeline) - - -def remove_from_config(config, key: str): - if key in config: - if isinstance(config, Config): - del config._cfg_dict[key] - elif isinstance(config, ConfigDict): - del config[key] - else: - raise ValueError(f'Unknown config type {type(config)}') - -def cluster_anchors(config: Config, dataset: DatasetEntity, model: BaseDetector): - if not kmeans_import: - raise ImportError('Sklearn package is not installed. To enable anchor boxes clustering, please install ' - 'packages from requirements/optional.txt or just scikit-learn package.') - - logger.info('Collecting statistics from training dataset to cluster anchor boxes...') - [target_wh] = [transforms.img_scale for transforms in config.data.test.pipeline - if transforms.type == 'MultiScaleFlipAug'] - prev_generator = config.model.bbox_head.anchor_generator - group_as = [len(width) for width in prev_generator.widths] - wh_stats = get_sizes_from_dataset_entity(dataset, target_wh) - - if len(wh_stats) < sum(group_as): - logger.warning(f'There are not enough objects to cluster: {len(wh_stats)} were detected, while it should be ' - f'at least {sum(group_as)}. Anchor box clustering was skipped.') - return config, model - - widths, heights = get_anchor_boxes(wh_stats, group_as) - logger.info(f'Anchor boxes widths have been updated from {format_list_to_str(prev_generator.widths)} ' - f'to {format_list_to_str(widths)}') - logger.info(f'Anchor boxes heights have been updated from {format_list_to_str(prev_generator.heights)} ' - f'to {format_list_to_str(heights)}') - config_generator = config.model.bbox_head.anchor_generator - config_generator.widths, config_generator.heights = widths, heights - - model_generator = model.bbox_head.anchor_generator - model_generator.widths, model_generator.heights = widths, heights - model_generator.base_anchors = model_generator.gen_base_anchors() - - config.model.bbox_head.anchor_generator = config_generator - model.bbox_head.anchor_generator = model_generator - return config, model - - -def get_data_cfg(config: Config, subset: str = 'train') -> Config: - data_cfg = config.data[subset] - while 'dataset' in data_cfg: - data_cfg = data_cfg.dataset - return data_cfg diff --git a/external/mmdetection/build/lib/detection_tasks/apis/detection/configuration.py b/external/mmdetection/build/lib/detection_tasks/apis/detection/configuration.py deleted file mode 100644 index de8ba9f8eb5..00000000000 --- a/external/mmdetection/build/lib/detection_tasks/apis/detection/configuration.py +++ /dev/null @@ -1,173 +0,0 @@ -# Copyright (C) 2021 Intel Corporation -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions -# and limitations under the License. - -from attr import attrs -from sys import maxsize - -from ote_sdk.configuration.elements import (ParameterGroup, - add_parameter_group, - boolean_attribute, - configurable_boolean, - configurable_float, - configurable_integer, - selectable, - string_attribute) -from ote_sdk.configuration import ConfigurableParameters -from ote_sdk.configuration.enums import ModelLifecycle, AutoHPOState - -from .configuration_enums import POTQuantizationPreset - - -@attrs -class OTEDetectionConfig(ConfigurableParameters): - header = string_attribute("Configuration for an object detection task") - description = header - - @attrs - class __LearningParameters(ParameterGroup): - header = string_attribute("Learning Parameters") - description = header - - batch_size = configurable_integer( - default_value=5, - min_value=1, - max_value=512, - header="Batch size", - description="The number of training samples seen in each iteration of training. Increasing this value " - "improves training time and may make the training more stable. A larger batch size has higher " - "memory requirements.", - warning="Increasing this value may cause the system to use more memory than available, " - "potentially causing out of memory errors, please update with caution.", - affects_outcome_of=ModelLifecycle.TRAINING, - auto_hpo_state=AutoHPOState.POSSIBLE - ) - - num_iters = configurable_integer( - default_value=1, - min_value=1, - max_value=100000, - header="Number of training iterations", - description="Increasing this value causes the results to be more robust but training time will be longer.", - affects_outcome_of=ModelLifecycle.TRAINING - ) - - learning_rate = configurable_float( - default_value=0.01, - min_value=1e-07, - max_value=1e-01, - header="Learning rate", - description="Increasing this value will speed up training convergence but might make it unstable.", - affects_outcome_of=ModelLifecycle.TRAINING, - auto_hpo_state=AutoHPOState.POSSIBLE - ) - - learning_rate_warmup_iters = configurable_integer( - default_value=100, - min_value=0, - max_value=10000, - header="Number of iterations for learning rate warmup", - description="", - affects_outcome_of=ModelLifecycle.TRAINING - ) - - num_workers = configurable_integer( - default_value=4, - min_value=0, - max_value=36, - header="Number of cpu threads to use during batch generation", - description="Increasing this value might improve training speed however it might cause out of memory " - "errors. If the number of workers is set to zero, data loading will happen in the main " - "training thread.", - affects_outcome_of=ModelLifecycle.NONE - ) - - @attrs - class __Postprocessing(ParameterGroup): - header = string_attribute("Postprocessing") - description = header - - result_based_confidence_threshold = configurable_boolean( - default_value=True, - header="Result based confidence threshold", - description="Confidence threshold is derived from the results", - affects_outcome_of=ModelLifecycle.INFERENCE - ) - - confidence_threshold = configurable_float( - default_value=0.35, - min_value=0, - max_value=1, - header="Confidence threshold", - description="This threshold only takes effect if the threshold is not set based on the result.", - affects_outcome_of=ModelLifecycle.INFERENCE - ) - - @attrs - class __NNCFOptimization(ParameterGroup): - header = string_attribute("Optimization by NNCF") - description = header - visible_in_ui = boolean_attribute(False) - - enable_quantization = configurable_boolean( - default_value=True, - header="Enable quantization algorithm", - description="Enable quantization algorithm", - affects_outcome_of=ModelLifecycle.TRAINING - ) - - enable_pruning = configurable_boolean( - default_value=False, - header="Enable filter pruning algorithm", - description="Enable filter pruning algorithm", - affects_outcome_of=ModelLifecycle.TRAINING - ) - - pruning_supported = configurable_boolean( - default_value=False, - header="Whether filter pruning is supported", - description="Whether filter pruning is supported", - affects_outcome_of=ModelLifecycle.TRAINING - ) - - maximal_accuracy_degradation = configurable_float( - default_value=1.0, - min_value=0.0, - max_value=100.0, - header="Maximum accuracy degradation", - description="The maximal allowed accuracy metric drop", - affects_outcome_of=ModelLifecycle.TRAINING - ) - - @attrs - class __POTParameter(ParameterGroup): - header = string_attribute("POT Parameters") - description = header - visible_in_ui = boolean_attribute(False) - - stat_subset_size = configurable_integer( - header="Number of data samples", - description="Number of data samples used for post-training optimization", - default_value=300, - min_value=1, - max_value=maxsize - ) - - preset = selectable(default_value=POTQuantizationPreset.PERFORMANCE, header="Preset", - description="Quantization preset that defines quantization scheme", - editable=True, visible_in_ui=True) - - learning_parameters = add_parameter_group(__LearningParameters) - postprocessing = add_parameter_group(__Postprocessing) - nncf_optimization = add_parameter_group(__NNCFOptimization) - pot_parameters = add_parameter_group(__POTParameter) diff --git a/external/mmdetection/build/lib/detection_tasks/apis/detection/inference_task.py b/external/mmdetection/build/lib/detection_tasks/apis/detection/inference_task.py deleted file mode 100644 index 667fcca55bb..00000000000 --- a/external/mmdetection/build/lib/detection_tasks/apis/detection/inference_task.py +++ /dev/null @@ -1,408 +0,0 @@ -# Copyright (C) 2021 Intel Corporation -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions -# and limitations under the License. - -import copy -import io -import os -import shutil -import tempfile -import warnings -from subprocess import run # nosec -from typing import List, Optional, Tuple - -import cv2 -import numpy as np -import torch -from mmcv.parallel import MMDataParallel -from mmcv.runner import load_checkpoint, load_state_dict -from mmcv.utils import Config -from ote_sdk.entities.annotation import Annotation -from ote_sdk.entities.datasets import DatasetEntity -from ote_sdk.entities.id import ID -from ote_sdk.entities.inference_parameters import InferenceParameters, default_progress_callback -from ote_sdk.entities.model import ModelEntity, ModelFormat, ModelOptimizationType, ModelPrecision, OptimizationMethod -from ote_sdk.entities.model_template import TaskType, task_type_to_label_domain -from ote_sdk.entities.resultset import ResultSetEntity -from ote_sdk.entities.scored_label import ScoredLabel -from ote_sdk.entities.shapes.polygon import Point, Polygon -from ote_sdk.entities.shapes.rectangle import Rectangle -from ote_sdk.entities.task_environment import TaskEnvironment -from ote_sdk.entities.tensor import TensorEntity -from ote_sdk.usecases.evaluation.metrics_helper import MetricsHelper -from ote_sdk.usecases.tasks.interfaces.evaluate_interface import IEvaluationTask -from ote_sdk.usecases.tasks.interfaces.export_interface import ExportType, IExportTask -from ote_sdk.usecases.tasks.interfaces.inference_interface import IInferenceTask -from ote_sdk.usecases.tasks.interfaces.unload_interface import IUnload -from ote_sdk.serialization.label_mapper import label_schema_to_bytes - -from mmdet.apis import export_model -from detection_tasks.apis.detection.config_utils import patch_config, prepare_for_testing, set_hyperparams -from detection_tasks.apis.detection.configuration import OTEDetectionConfig -from detection_tasks.apis.detection.ote_utils import InferenceProgressCallback -from mmdet.datasets import build_dataloader, build_dataset -from mmdet.models import build_detector -from mmdet.parallel import MMDataCPU -from mmdet.utils.collect_env import collect_env -from mmdet.utils.logger import get_root_logger - -logger = get_root_logger() - - -class OTEDetectionInferenceTask(IInferenceTask, IExportTask, IEvaluationTask, IUnload): - - _task_environment: TaskEnvironment - - def __init__(self, task_environment: TaskEnvironment): - """" - Task for inference object detection models using OTEDetection. - """ - logger.info('Loading OTEDetectionTask') - - print('ENVIRONMENT:') - for name, val in collect_env().items(): - print(f'{name}: {val}') - print('pip list:') - run('pip list', shell=True, check=True) - - self._task_environment = task_environment - self._task_type = task_environment.model_template.task_type - self._scratch_space = tempfile.mkdtemp(prefix="ote-det-scratch-") - logger.info(f'Scratch space created at {self._scratch_space}') - - self._model_name = task_environment.model_template.name - self._labels = task_environment.get_labels(False) - - template_file_path = task_environment.model_template.model_template_path - - # Get and prepare mmdet config. - self._base_dir = os.path.abspath(os.path.dirname(template_file_path)) - config_file_path = os.path.join(self._base_dir, "model.py") - self._config = Config.fromfile(config_file_path) - patch_config(self._config, self._scratch_space, self._labels, task_type_to_label_domain(self._task_type), random_seed=42) - set_hyperparams(self._config, self._hyperparams) - self.confidence_threshold: float = self._hyperparams.postprocessing.confidence_threshold - - # Set default model attributes. - self._optimization_methods = [] - self._precision = [ModelPrecision.FP32] - self._optimization_type = ModelOptimizationType.MO - - # Create and initialize PyTorch model. - logger.info('Loading the model') - self._model = self._load_model(task_environment.model) - - # Extra control variables. - self._training_work_dir = None - self._is_training = False - self._should_stop = False - logger.info('Task initialization completed') - - @property - def _hyperparams(self): - return self._task_environment.get_hyper_parameters(OTEDetectionConfig) - - def _load_model(self, model: ModelEntity): - if model is not None: - # If a model has been trained and saved for the task already, create empty model and load weights here - buffer = io.BytesIO(model.get_data("weights.pth")) - model_data = torch.load(buffer, map_location=torch.device('cpu')) - - self.confidence_threshold = model_data.get('confidence_threshold', self.confidence_threshold) - if model_data.get('anchors'): - anchors = model_data['anchors'] - self._config.model.bbox_head.anchor_generator.heights = anchors['heights'] - self._config.model.bbox_head.anchor_generator.widths = anchors['widths'] - - model = self._create_model(self._config, from_scratch=True) - - try: - load_state_dict(model, model_data['model']) - logger.info(f"Loaded model weights from Task Environment") - logger.info(f"Model architecture: {self._model_name}") - except BaseException as ex: - raise ValueError("Could not load the saved model. The model file structure is invalid.") \ - from ex - else: - # If there is no trained model yet, create model with pretrained weights as defined in the model config - # file. - model = self._create_model(self._config, from_scratch=False) - logger.info(f"No trained model in project yet. Created new model with '{self._model_name}' " - f"architecture and general-purpose pretrained weights.") - return model - - - @staticmethod - def _create_model(config: Config, from_scratch: bool = False): - """ - Creates a model, based on the configuration in config - - :param config: mmdetection configuration from which the model has to be built - :param from_scratch: bool, if True does not load any weights - - :return model: ModelEntity in training mode - """ - model_cfg = copy.deepcopy(config.model) - - init_from = None if from_scratch else config.get('load_from', None) - logger.warning(init_from) - if init_from is not None: - # No need to initialize backbone separately, if all weights are provided. - model_cfg.pretrained = None - logger.warning('build detector') - model = build_detector(model_cfg) - # Load all weights. - logger.warning('load checkpoint') - load_checkpoint(model, init_from, map_location='cpu') - else: - logger.warning('build detector') - model = build_detector(model_cfg) - return model - - - def _add_predictions_to_dataset(self, prediction_results, dataset, confidence_threshold=0.0): - """ Loop over dataset again to assign predictions. Convert from MMDetection format to OTE format. """ - for dataset_item, (all_results, feature_vector) in zip(dataset, prediction_results): - width = dataset_item.width - height = dataset_item.height - - shapes = [] - if self._task_type == TaskType.DETECTION: - for label_idx, detections in enumerate(all_results): - for i in range(detections.shape[0]): - probability = float(detections[i, 4]) - coords = detections[i, :4].astype(float).copy() - coords /= np.array([width, height, width, height], dtype=float) - coords = np.clip(coords, 0, 1) - - if probability < confidence_threshold: - continue - - assigned_label = [ScoredLabel(self._labels[label_idx], - probability=probability)] - if coords[3] - coords[1] <= 0 or coords[2] - coords[0] <= 0: - continue - - shapes.append(Annotation( - Rectangle(x1=coords[0], y1=coords[1], x2=coords[2], y2=coords[3]), - labels=assigned_label)) - elif self._task_type in {TaskType.INSTANCE_SEGMENTATION, TaskType.ROTATED_DETECTION}: - for label_idx, (boxes, masks) in enumerate(zip(*all_results)): - for mask, probability in zip(masks, boxes[:, 4]): - mask = mask.astype(np.uint8) - probability = float(probability) - contours, hierarchies = cv2.findContours(mask, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) - if hierarchies is None: - continue - for contour, hierarchy in zip(contours, hierarchies[0]): - if hierarchy[3] != -1: - continue - if len(contour) <= 2 or probability < confidence_threshold: - continue - if self._task_type == TaskType.INSTANCE_SEGMENTATION: - points = [Point(x=point[0][0] / width, y=point[0][1] / height) for point in contour] - else: - box_points = cv2.boxPoints(cv2.minAreaRect(contour)) - points = [Point(x=point[0] / width, y=point[1] / height) for point in box_points] - labels = [ScoredLabel(self._labels[label_idx], probability=probability)] - polygon = Polygon(points=points) - if polygon.get_area() > 1e-12: - shapes.append(Annotation(polygon, labels=labels, id=ID(f"{label_idx:08}"))) - else: - raise RuntimeError( - f"Detection results assignment not implemented for task: {self._task_type}") - - dataset_item.append_annotations(shapes) - - if feature_vector is not None: - active_score = TensorEntity(name="representation_vector", numpy=feature_vector) - dataset_item.append_metadata_item(active_score, model=self._task_environment.model) - - - def infer(self, dataset: DatasetEntity, inference_parameters: Optional[InferenceParameters] = None) -> DatasetEntity: - """ Analyzes a dataset using the latest inference model. """ - - logger.info('Infer the model on the dataset') - set_hyperparams(self._config, self._hyperparams) - # There is no need to have many workers for a couple of images. - self._config.data.workers_per_gpu = max(min(self._config.data.workers_per_gpu, len(dataset) - 1), 0) - - # If confidence threshold is adaptive then up-to-date value should be stored in the model - # and should not be changed during inference. Otherwise user-specified value should be taken. - if not self._hyperparams.postprocessing.result_based_confidence_threshold: - self.confidence_threshold = self._hyperparams.postprocessing.confidence_threshold - - update_progress_callback = default_progress_callback - if inference_parameters is not None: - update_progress_callback = inference_parameters.update_progress - - time_monitor = InferenceProgressCallback(len(dataset), update_progress_callback) - - def pre_hook(module, input): - time_monitor.on_test_batch_begin(None, None) - - def hook(module, input, output): - time_monitor.on_test_batch_end(None, None) - - logger.info(f'Confidence threshold {self.confidence_threshold}') - model = self._model - with model.register_forward_pre_hook(pre_hook), model.register_forward_hook(hook): - prediction_results, _ = self._infer_detector(model, self._config, dataset, dump_features=True, eval=False) - self._add_predictions_to_dataset(prediction_results, dataset, self.confidence_threshold) - - logger.info('Inference completed') - return dataset - - - @staticmethod - def _infer_detector(model: torch.nn.Module, config: Config, dataset: DatasetEntity, dump_features: bool = False, - eval: Optional[bool] = False, metric_name: Optional[str] = 'mAP') -> Tuple[List, float]: - model.eval() - test_config = prepare_for_testing(config, dataset) - mm_val_dataset = build_dataset(test_config.data.test) - batch_size = 1 - mm_val_dataloader = build_dataloader(mm_val_dataset, - samples_per_gpu=batch_size, - workers_per_gpu=test_config.data.workers_per_gpu, - num_gpus=1, - dist=False, - shuffle=False) - if torch.cuda.is_available(): - eval_model = MMDataParallel(model.cuda(test_config.gpu_ids[0]), - device_ids=test_config.gpu_ids) - else: - eval_model = MMDataCPU(model) - - eval_predictions = [] - feature_vectors = [] - - def dump_features_hook(mod, inp, out): - with torch.no_grad(): - feature_map = out[-1] - feature_vector = torch.nn.functional.adaptive_avg_pool2d(feature_map, (1, 1)) - assert feature_vector.size(0) == 1 - feature_vectors.append(feature_vector.view(-1).detach().cpu().numpy()) - - def dummy_dump_features_hook(mod, inp, out): - feature_vectors.append(None) - - hook = dump_features_hook if dump_features else dummy_dump_features_hook - - # Use a single gpu for testing. Set in both mm_val_dataloader and eval_model - with eval_model.module.backbone.register_forward_hook(hook): - for data in mm_val_dataloader: - with torch.no_grad(): - result = eval_model(return_loss=False, rescale=True, **data) - eval_predictions.extend(result) - - # hard-code way to remove EvalHook args - for key in [ - 'interval', 'tmpdir', 'start', 'gpu_collect', 'save_best', - 'rule', 'dynamic_intervals' - ]: - config.evaluation.pop(key, None) - - metric = None - if eval: - metric = mm_val_dataset.evaluate(eval_predictions, **config.evaluation)[metric_name] - - assert len(eval_predictions) == len(feature_vectors), f'{len(eval_predictions)} != {len(feature_vectors)}' - eval_predictions = zip(eval_predictions, feature_vectors) - return eval_predictions, metric - - - def evaluate(self, - output_result_set: ResultSetEntity, - evaluation_metric: Optional[str] = None): - """ Computes performance on a resultset """ - logger.info('Evaluating the metric') - if evaluation_metric is not None: - logger.warning(f'Requested to use {evaluation_metric} metric, but parameter is ignored. Use F-measure instead.') - metric = MetricsHelper.compute_f_measure(output_result_set) - logger.info(f"F-measure after evaluation: {metric.f_measure.value}") - output_result_set.performance = metric.get_performance() - logger.info('Evaluation completed') - - - @staticmethod - def _is_docker(): - """ - Checks whether the task runs in docker container - - :return bool: True if task runs in docker - """ - path = '/proc/self/cgroup' - is_in_docker = False - if os.path.isfile(path): - with open(path) as f: - is_in_docker = is_in_docker or any('docker' in line for line in f) - is_in_docker = is_in_docker or os.path.exists('/.dockerenv') - return is_in_docker - - def unload(self): - """ - Unload the task - """ - self._delete_scratch_space() - if self._is_docker(): - logger.warning( - "Got unload request. Unloading models. Throwing Segmentation Fault on purpose") - import ctypes - ctypes.string_at(0) - else: - logger.warning("Got unload request, but not on Docker. Only clearing CUDA cache") - torch.cuda.empty_cache() - logger.warning(f"Done unloading. " - f"Torch is still occupying {torch.cuda.memory_allocated()} bytes of GPU memory") - - def export(self, - export_type: ExportType, - output_model: ModelEntity): - logger.info('Exporting the model') - assert export_type == ExportType.OPENVINO - output_model.model_format = ModelFormat.OPENVINO - output_model.optimization_type = self._optimization_type - with tempfile.TemporaryDirectory() as tempdir: - optimized_model_dir = os.path.join(tempdir, 'export') - logger.info(f'Optimized model will be temporarily saved to "{optimized_model_dir}"') - os.makedirs(optimized_model_dir, exist_ok=True) - try: - from torch.jit._trace import TracerWarning - warnings.filterwarnings('ignore', category=TracerWarning) - if torch.cuda.is_available(): - model = self._model.cuda(self._config.gpu_ids[0]) - else: - model = self._model.cpu() - pruning_transformation = OptimizationMethod.FILTER_PRUNING in self._optimization_methods - export_model(model, self._config, tempdir, target='openvino', - pruning_transformation=pruning_transformation) - bin_file = [f for f in os.listdir(tempdir) if f.endswith('.bin')][0] - xml_file = [f for f in os.listdir(tempdir) if f.endswith('.xml')][0] - with open(os.path.join(tempdir, bin_file), "rb") as f: - output_model.set_data('openvino.bin', f.read()) - with open(os.path.join(tempdir, xml_file), "rb") as f: - output_model.set_data('openvino.xml', f.read()) - output_model.set_data('confidence_threshold', np.array([self.confidence_threshold], dtype=np.float32).tobytes()) - output_model.precision = self._precision - output_model.optimization_methods = self._optimization_methods - except Exception as ex: - raise RuntimeError('Optimization was unsuccessful.') from ex - output_model.set_data("label_schema.json", label_schema_to_bytes(self._task_environment.label_schema)) - logger.info('Exporting completed') - - def _delete_scratch_space(self): - """ - Remove model checkpoints and mmdet logs - """ - if os.path.exists(self._scratch_space): - shutil.rmtree(self._scratch_space, ignore_errors=False) diff --git a/external/mmdetection/build/lib/detection_tasks/apis/detection/nncf_task.py b/external/mmdetection/build/lib/detection_tasks/apis/detection/nncf_task.py deleted file mode 100644 index 2d6aa61c8db..00000000000 --- a/external/mmdetection/build/lib/detection_tasks/apis/detection/nncf_task.py +++ /dev/null @@ -1,283 +0,0 @@ -# Copyright (C) 2021 Intel Corporation -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions -# and limitations under the License. - -import io -import json -import os -from collections import defaultdict -from typing import Optional - -import torch -from ote_sdk.configuration import cfg_helper -from ote_sdk.configuration.helper.utils import ids_to_strings -from ote_sdk.entities.datasets import DatasetEntity -from ote_sdk.entities.model import ( - ModelEntity, - ModelFormat, - ModelOptimizationType, - ModelPrecision, - OptimizationMethod, -) -from ote_sdk.entities.optimization_parameters import default_progress_callback, OptimizationParameters -from ote_sdk.entities.subset import Subset -from ote_sdk.entities.task_environment import TaskEnvironment -from ote_sdk.serialization.label_mapper import label_schema_to_bytes -from ote_sdk.usecases.tasks.interfaces.export_interface import ExportType -from ote_sdk.usecases.tasks.interfaces.optimization_interface import IOptimizationTask -from ote_sdk.usecases.tasks.interfaces.optimization_interface import OptimizationType - -from mmdet.apis import train_detector -from mmdet.apis.fake_input import get_fake_input -from detection_tasks.apis.detection.config_utils import prepare_for_training -from detection_tasks.apis.detection.configuration import OTEDetectionConfig -from detection_tasks.apis.detection.inference_task import OTEDetectionInferenceTask -from detection_tasks.apis.detection.ote_utils import OptimizationProgressCallback -from detection_tasks.extension.utils.hooks import OTELoggerHook -from mmdet.apis.train import build_val_dataloader -from mmdet.datasets import build_dataloader, build_dataset -from mmdet.integration.nncf import check_nncf_is_enabled -from mmdet.integration.nncf import is_state_nncf -from mmdet.integration.nncf import wrap_nncf_model -from mmdet.integration.nncf import is_accuracy_aware_training_set -from mmdet.integration.nncf.config import compose_nncf_config -from mmdet.utils.logger import get_root_logger - - -logger = get_root_logger() - - -class OTEDetectionNNCFTask(OTEDetectionInferenceTask, IOptimizationTask): - - def __init__(self, task_environment: TaskEnvironment): - """" - Task for compressing object detection models using NNCF. - """ - self._val_dataloader = None - self._compression_ctrl = None - self._nncf_preset = "nncf_quantization" - check_nncf_is_enabled() - super().__init__(task_environment) - self._optimization_type = ModelOptimizationType.NNCF - - def _set_attributes_by_hyperparams(self): - quantization = self._hyperparams.nncf_optimization.enable_quantization - pruning = self._hyperparams.nncf_optimization.enable_pruning - if quantization and pruning: - self._nncf_preset = "nncf_quantization_pruning" - self._optimization_methods = [OptimizationMethod.QUANTIZATION, OptimizationMethod.FILTER_PRUNING] - self._precision = [ModelPrecision.INT8] - return - if quantization and not pruning: - self._nncf_preset = "nncf_quantization" - self._optimization_methods = [OptimizationMethod.QUANTIZATION] - self._precision = [ModelPrecision.INT8] - return - if not quantization and pruning: - self._nncf_preset = "nncf_pruning" - self._optimization_methods = [OptimizationMethod.FILTER_PRUNING] - self._precision = [ModelPrecision.FP32] - return - raise RuntimeError('Not selected optimization algorithm') - - def _load_model(self, model: ModelEntity): - # NNCF parts - nncf_config_path = os.path.join(self._base_dir, "compression_config.json") - - with open(nncf_config_path) as nncf_config_file: - common_nncf_config = json.load(nncf_config_file) - - self._set_attributes_by_hyperparams() - - optimization_config = compose_nncf_config(common_nncf_config, [self._nncf_preset]) - - max_acc_drop = self._hyperparams.nncf_optimization.maximal_accuracy_degradation / 100 - if "accuracy_aware_training" in optimization_config["nncf_config"]: - # Update maximal_absolute_accuracy_degradation - (optimization_config["nncf_config"]["accuracy_aware_training"] - ["params"]["maximal_absolute_accuracy_degradation"]) = max_acc_drop - # Force evaluation interval - self._config.evaluation.interval = 1 - else: - logger.info("NNCF config has no accuracy_aware_training parameters") - - self._config.update(optimization_config) - - compression_ctrl = None - if model is not None: - # If a model has been trained and saved for the task already, create empty model and load weights here - buffer = io.BytesIO(model.get_data("weights.pth")) - model_data = torch.load(buffer, map_location=torch.device('cpu')) - - self.confidence_threshold = model_data.get('confidence_threshold', - self._hyperparams.postprocessing.confidence_threshold) - if model_data.get('anchors'): - anchors = model_data['anchors'] - self._config.model.bbox_head.anchor_generator.heights = anchors['heights'] - self._config.model.bbox_head.anchor_generator.widths = anchors['widths'] - - model = self._create_model(self._config, from_scratch=True) - try: - if is_state_nncf(model_data): - compression_ctrl, model = wrap_nncf_model( - model, - self._config, - init_state_dict=model_data, - get_fake_input_func=get_fake_input - ) - logger.info("Loaded model weights from Task Environment and wrapped by NNCF") - else: - try: - model.load_state_dict(model_data['model']) - logger.info(f"Loaded model weights from Task Environment") - logger.info(f"Model architecture: {self._model_name}") - except BaseException as ex: - raise ValueError("Could not load the saved model. The model file structure is invalid.") \ - from ex - - logger.info(f"Loaded model weights from Task Environment") - logger.info(f"Model architecture: {self._model_name}") - except BaseException as ex: - raise ValueError("Could not load the saved model. The model file structure is invalid.") \ - from ex - else: - raise ValueError(f"No trained model in project. NNCF require pretrained weights to compress the model") - - self._compression_ctrl = compression_ctrl - return model - - def _create_compressed_model(self, dataset, config): - init_dataloader = build_dataloader( - dataset, - config.data.samples_per_gpu, - config.data.workers_per_gpu, - len(config.gpu_ids), - dist=False, - seed=config.seed) - is_acc_aware_training_set = is_accuracy_aware_training_set(config.get("nncf_config")) - - if is_acc_aware_training_set: - self._val_dataloader = build_val_dataloader(config, False) - - self._compression_ctrl, self._model = wrap_nncf_model( - self._model, - config, - val_dataloader=self._val_dataloader, - dataloader_for_init=init_dataloader, - get_fake_input_func=get_fake_input, - is_accuracy_aware=is_acc_aware_training_set) - - def optimize( - self, - optimization_type: OptimizationType, - dataset: DatasetEntity, - output_model: ModelEntity, - optimization_parameters: Optional[OptimizationParameters], - ): - if optimization_type is not OptimizationType.NNCF: - raise RuntimeError("NNCF is the only supported optimization") - - train_dataset = dataset.get_subset(Subset.TRAINING) - val_dataset = dataset.get_subset(Subset.VALIDATION) - - config = self._config - - if optimization_parameters is not None: - update_progress_callback = optimization_parameters.update_progress - else: - update_progress_callback = default_progress_callback - - time_monitor = OptimizationProgressCallback(update_progress_callback, - loading_stage_progress_percentage=5, - initialization_stage_progress_percentage=5) - learning_curves = defaultdict(OTELoggerHook.Curve) - training_config = prepare_for_training(config, train_dataset, val_dataset, time_monitor, learning_curves) - mm_train_dataset = build_dataset(training_config.data.train) - - if torch.cuda.is_available(): - self._model.cuda(training_config.gpu_ids[0]) - - # Initialize NNCF parts if start from not compressed model - if not self._compression_ctrl: - self._create_compressed_model(mm_train_dataset, training_config) - - time_monitor.on_initialization_end() - - # Run training. - self._training_work_dir = training_config.work_dir - self._is_training = True - self._model.train() - - train_detector(model=self._model, - dataset=mm_train_dataset, - cfg=training_config, - validate=True, - val_dataloader=self._val_dataloader, - compression_ctrl=self._compression_ctrl) - - # Check for stop signal when training has stopped. If should_stop is true, training was cancelled - if self._should_stop: - logger.info('Training cancelled.') - self._should_stop = False - self._is_training = False - return - - self.save_model(output_model) - - output_model.model_format = ModelFormat.BASE_FRAMEWORK - output_model.optimization_type = self._optimization_type - output_model.optimization_methods = self._optimization_methods - output_model.precision = self._precision - - self._is_training = False - - def export(self, export_type: ExportType, output_model: ModelEntity): - if self._compression_ctrl is None: - super().export(export_type, output_model) - else: - self._compression_ctrl.prepare_for_export() - self._model.disable_dynamic_graph_building() - super().export(export_type, output_model) - self._model.enable_dynamic_graph_building() - - def save_model(self, output_model: ModelEntity): - buffer = io.BytesIO() - hyperparams = self._task_environment.get_hyper_parameters(OTEDetectionConfig) - hyperparams_str = ids_to_strings(cfg_helper.convert(hyperparams, dict, enum_to_str=True)) - labels = {label.name: label.color.rgb_tuple for label in self._labels} - # WA for scheduler resetting in NNCF - compression_state = self._compression_ctrl.get_compression_state() - for algo_state in compression_state.get('ctrl_state', {}).values(): - if not algo_state.get('scheduler_state'): - algo_state['scheduler_state'] = {'current_step': 0, 'current_epoch': 0} - modelinfo = { - 'compression_state': compression_state, - 'meta': { - 'config': self._config, - 'nncf_enable_compression': True, - }, - 'model': self._model.state_dict(), - 'config': hyperparams_str, - 'labels': labels, - 'confidence_threshold': self.confidence_threshold, - 'VERSION': 1, - } - - if hasattr(self._config.model, 'bbox_head') and hasattr(self._config.model.bbox_head, 'anchor_generator'): - if getattr(self._config.model.bbox_head.anchor_generator, 'reclustering_anchors', False): - generator = self._model.bbox_head.anchor_generator - modelinfo['anchors'] = {'heights': generator.heights, 'widths': generator.widths} - - torch.save(modelinfo, buffer) - output_model.set_data("weights.pth", buffer.getvalue()) - output_model.set_data("label_schema.json", label_schema_to_bytes(self._task_environment.label_schema)) diff --git a/external/mmdetection/build/lib/detection_tasks/apis/detection/openvino_task.py b/external/mmdetection/build/lib/detection_tasks/apis/detection/openvino_task.py deleted file mode 100644 index 9c84aa40fdf..00000000000 --- a/external/mmdetection/build/lib/detection_tasks/apis/detection/openvino_task.py +++ /dev/null @@ -1,367 +0,0 @@ -# Copyright (C) 2021 Intel Corporation -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions -# and limitations under the License. - -import attr -import copy -import io -import json -import numpy as np -import os -import ote_sdk.usecases.exportable_code.demo as demo -import tempfile -from addict import Dict as ADDict -from compression.api import DataLoader -from compression.engines.ie_engine import IEEngine -from compression.graph import load_model, save_model -from compression.graph.model_utils import compress_model_weights, get_nodes_by_type -from compression.pipeline.initializer import create_pipeline -from openvino.model_zoo.model_api.adapters import OpenvinoAdapter, create_core -from openvino.model_zoo.model_api.models import Model -from ote_sdk.entities.annotation import AnnotationSceneEntity -from ote_sdk.entities.datasets import DatasetEntity -from ote_sdk.entities.inference_parameters import InferenceParameters, default_progress_callback -from ote_sdk.entities.label_schema import LabelSchemaEntity -from ote_sdk.entities.model import ( - ModelEntity, - ModelFormat, - ModelOptimizationType, - ModelPrecision, - OptimizationMethod, -) -from ote_sdk.entities.model_template import TaskType -from ote_sdk.entities.optimization_parameters import OptimizationParameters -from ote_sdk.entities.resultset import ResultSetEntity -from ote_sdk.entities.task_environment import TaskEnvironment -from ote_sdk.serialization.label_mapper import LabelSchemaMapper, label_schema_to_bytes -from ote_sdk.usecases.evaluation.metrics_helper import MetricsHelper -from ote_sdk.usecases.exportable_code.inference import BaseInferencer -from ote_sdk.usecases.exportable_code.prediction_to_annotation_converter import ( - DetectionBoxToAnnotationConverter, - MaskToAnnotationConverter, - RotatedRectToAnnotationConverter, -) -from ote_sdk.usecases.tasks.interfaces.deployment_interface import IDeploymentTask -from ote_sdk.usecases.tasks.interfaces.evaluate_interface import IEvaluationTask -from ote_sdk.usecases.tasks.interfaces.inference_interface import IInferenceTask -from ote_sdk.usecases.tasks.interfaces.optimization_interface import IOptimizationTask, OptimizationType -from typing import Any, Dict, List, Optional, Tuple, Union -from zipfile import ZipFile - -from mmdet.utils.logger import get_root_logger -from .configuration import OTEDetectionConfig - -logger = get_root_logger() - - -class BaseInferencerWithConverter(BaseInferencer): - - def __init__(self, configuration, model, converter) -> None: - self.configuration = configuration - self.model = model - self.converter = converter - - def pre_process(self, image: np.ndarray) -> Tuple[Dict[str, np.ndarray], Dict[str, Any]]: - return self.model.preprocess(image) - - def post_process(self, prediction: Dict[str, np.ndarray], metadata: Dict[str, Any]) -> AnnotationSceneEntity: - detections = self.model.postprocess(prediction, metadata) - - return self.converter.convert_to_annotation(detections, metadata) - - def forward(self, inputs: Dict[str, np.ndarray]) -> Dict[str, np.ndarray]: - return self.model.infer_sync(inputs) - - -class OpenVINODetectionInferencer(BaseInferencerWithConverter): - def __init__( - self, - hparams: OTEDetectionConfig, - label_schema: LabelSchemaEntity, - model_file: Union[str, bytes], - weight_file: Union[str, bytes, None] = None, - device: str = "CPU", - num_requests: int = 1, - ): - """ - Inferencer implementation for OTEDetection using OpenVINO backend. - - :param hparams: Hyper parameters that the model should use. - :param label_schema: LabelSchemaEntity that was used during model training. - :param model_file: Path OpenVINO IR model definition file. - :param weight_file: Path OpenVINO IR model weights file. - :param device: Device to run inference on, such as CPU, GPU or MYRIAD. Defaults to "CPU". - :param num_requests: Maximum number of requests that the inferencer can make. Defaults to 1. - - """ - - model_adapter = OpenvinoAdapter(create_core(), model_file, weight_file, device=device, max_num_requests=num_requests) - configuration = {**attr.asdict(hparams.postprocessing, - filter=lambda attr, value: attr.name not in ['header', 'description', 'type', 'visible_in_ui'])} - model = Model.create_model('ssd', model_adapter, configuration, preload=True) - converter = DetectionBoxToAnnotationConverter(label_schema) - - super().__init__(configuration, model, converter) - - -class OpenVINOMaskInferencer(BaseInferencerWithConverter): - def __init__( - self, - hparams: OTEDetectionConfig, - label_schema: LabelSchemaEntity, - model_file: Union[str, bytes], - weight_file: Union[str, bytes, None] = None, - device: str = "CPU", - num_requests: int = 1, - ): - model_adapter = OpenvinoAdapter( - create_core(), - model_file, - weight_file, - device=device, - max_num_requests=num_requests) - - configuration = { - **attr.asdict( - hparams.postprocessing, - filter=lambda attr, value: attr.name not in [ - 'header', 'description', 'type', 'visible_in_ui'])} - - model = Model.create_model( - 'maskrcnn', - model_adapter, - configuration, - preload=True) - - converter = MaskToAnnotationConverter(label_schema) - - super().__init__(configuration, model, converter) - - -class OpenVINORotatedRectInferencer(BaseInferencerWithConverter): - def __init__( - self, - hparams: OTEDetectionConfig, - label_schema: LabelSchemaEntity, - model_file: Union[str, bytes], - weight_file: Union[str, bytes, None] = None, - device: str = "CPU", - num_requests: int = 1, - ): - model_adapter = OpenvinoAdapter( - create_core(), - model_file, - weight_file, - device=device, - max_num_requests=num_requests) - - configuration = { - **attr.asdict( - hparams.postprocessing, - filter=lambda attr, value: attr.name not in [ - 'header', 'description', 'type', 'visible_in_ui'])} - - model = Model.create_model( - 'maskrcnn', - model_adapter, - configuration, - preload=True) - - converter = RotatedRectToAnnotationConverter(label_schema) - - super().__init__(configuration, model, converter) - - -class OTEOpenVinoDataLoader(DataLoader): - def __init__(self, dataset: DatasetEntity, inferencer: BaseInferencer): - self.dataset = dataset - self.inferencer = inferencer - - def __getitem__(self, index): - image = self.dataset[index].numpy - annotation = self.dataset[index].annotation_scene - inputs, metadata = self.inferencer.pre_process(image) - - return (index, annotation), inputs, metadata - - def __len__(self): - return len(self.dataset) - - -class OpenVINODetectionTask(IDeploymentTask, IInferenceTask, IEvaluationTask, IOptimizationTask): - def __init__(self, task_environment: TaskEnvironment): - logger.info('Loading OpenVINO OTEDetectionTask') - self.task_environment = task_environment - self.model = self.task_environment.model - self.task_type = self.task_environment.model_template.task_type - self.confidence_threshold: float = 0.0 - self.inferencer = self.load_inferencer() - logger.info('OpenVINO task initialization completed') - - @property - def hparams(self): - return self.task_environment.get_hyper_parameters(OTEDetectionConfig) - - def load_inferencer(self) -> Union[OpenVINODetectionInferencer, OpenVINOMaskInferencer] : - _hparams = copy.deepcopy(self.hparams) - self.confidence_threshold = float(np.frombuffer(self.model.get_data("confidence_threshold"), dtype=np.float32)[0]) - _hparams.postprocessing.confidence_threshold = self.confidence_threshold - args = [ - _hparams, - self.task_environment.label_schema, - self.model.get_data("openvino.xml"), - self.model.get_data("openvino.bin"), - ] - if self.task_type == TaskType.DETECTION: - return OpenVINODetectionInferencer(*args) - if self.task_type == TaskType.INSTANCE_SEGMENTATION: - return OpenVINOMaskInferencer(*args) - if self.task_type == TaskType.ROTATED_DETECTION: - return OpenVINORotatedRectInferencer(*args) - raise RuntimeError(f"Unknown OpenVINO Inferencer TaskType: {self.task_type}") - - def infer(self, dataset: DatasetEntity, inference_parameters: Optional[InferenceParameters] = None) -> DatasetEntity: - logger.info('Start OpenVINO inference') - update_progress_callback = default_progress_callback - if inference_parameters is not None: - update_progress_callback = inference_parameters.update_progress - dataset_size = len(dataset) - for i, dataset_item in enumerate(dataset, 1): - predicted_scene = self.inferencer.predict(dataset_item.numpy) - dataset_item.append_annotations(predicted_scene.annotations) - update_progress_callback(int(i / dataset_size * 100)) - logger.info('OpenVINO inference completed') - return dataset - - def evaluate(self, - output_result_set: ResultSetEntity, - evaluation_metric: Optional[str] = None): - logger.info('Start OpenVINO metric evaluation') - if evaluation_metric is not None: - logger.warning(f'Requested to use {evaluation_metric} metric, but parameter is ignored. Use F-measure instead.') - output_result_set.performance = MetricsHelper.compute_f_measure(output_result_set).get_performance() - logger.info('OpenVINO metric evaluation completed') - - def deploy(self, - output_model: ModelEntity) -> None: - logger.info('Deploying the model') - - work_dir = os.path.dirname(demo.__file__) - parameters = {} - parameters['type_of_model'] = self.inferencer.model.__model__ - parameters['converter_type'] = str(self.task_type) - parameters['model_parameters'] = self.inferencer.configuration - parameters['model_parameters']['labels'] = LabelSchemaMapper.forward(self.task_environment.label_schema) - - zip_buffer = io.BytesIO() - with ZipFile(zip_buffer, 'w') as arch: - # model files - arch.writestr(os.path.join("model", "model.xml"), self.model.get_data("openvino.xml")) - arch.writestr(os.path.join("model", "model.bin"), self.model.get_data("openvino.bin")) - arch.writestr( - os.path.join("model", "config.json"), json.dumps(parameters, ensure_ascii=False, indent=4) - ) - # python files - arch.write(os.path.join(work_dir, "requirements.txt"), os.path.join("python", "requirements.txt")) - arch.write(os.path.join(work_dir, "LICENSE"), os.path.join("python", "LICENSE")) - arch.write(os.path.join(work_dir, "README.md"), os.path.join("python", "README.md")) - arch.write(os.path.join(work_dir, "demo.py"), os.path.join("python", "demo.py")) - output_model.exportable_code = zip_buffer.getvalue() - logger.info('Deploying completed') - - def optimize(self, - optimization_type: OptimizationType, - dataset: DatasetEntity, - output_model: ModelEntity, - optimization_parameters: Optional[OptimizationParameters]): - logger.info('Start POT optimization') - - if optimization_type is not OptimizationType.POT: - raise ValueError('POT is the only supported optimization type for OpenVino models') - - data_loader = OTEOpenVinoDataLoader(dataset, self.inferencer) - - with tempfile.TemporaryDirectory() as tempdir: - xml_path = os.path.join(tempdir, "model.xml") - bin_path = os.path.join(tempdir, "model.bin") - with open(xml_path, "wb") as f: - f.write(self.model.get_data("openvino.xml")) - with open(bin_path, "wb") as f: - f.write(self.model.get_data("openvino.bin")) - - model_config = ADDict({ - 'model_name': 'openvino_model', - 'model': xml_path, - 'weights': bin_path - }) - - model = load_model(model_config) - - if get_nodes_by_type(model, ['FakeQuantize']): - raise RuntimeError("Model is already optimized by POT") - - if optimization_parameters is not None: - optimization_parameters.update_progress(10) - - engine_config = ADDict({ - 'device': 'CPU' - }) - - stat_subset_size = self.hparams.pot_parameters.stat_subset_size - preset = self.hparams.pot_parameters.preset.name.lower() - - algorithms = [ - { - 'name': 'DefaultQuantization', - 'params': { - 'target_device': 'ANY', - 'preset': preset, - 'stat_subset_size': min(stat_subset_size, len(data_loader)), - 'shuffle_data': True - } - } - ] - - engine = IEEngine(config=engine_config, data_loader=data_loader, metric=None) - - pipeline = create_pipeline(algorithms, engine) - - compressed_model = pipeline.run(model) - - compress_model_weights(compressed_model) - - if optimization_parameters is not None: - optimization_parameters.update_progress(90) - - with tempfile.TemporaryDirectory() as tempdir: - save_model(compressed_model, tempdir, model_name="model") - with open(os.path.join(tempdir, "model.xml"), "rb") as f: - output_model.set_data("openvino.xml", f.read()) - with open(os.path.join(tempdir, "model.bin"), "rb") as f: - output_model.set_data("openvino.bin", f.read()) - output_model.set_data("confidence_threshold", np.array([self.confidence_threshold], dtype=np.float32).tobytes()) - - output_model.set_data("label_schema.json", label_schema_to_bytes(self.task_environment.label_schema)) - - # set model attributes for quantized model - output_model.model_format = ModelFormat.OPENVINO - output_model.optimization_type = ModelOptimizationType.POT - output_model.optimization_methods = [OptimizationMethod.QUANTIZATION] - output_model.precision = [ModelPrecision.INT8] - - self.model = output_model - self.inferencer = self.load_inferencer() - logger.info('POT optimization completed') - - if optimization_parameters is not None: - optimization_parameters.update_progress(100) diff --git a/external/mmdetection/build/lib/detection_tasks/apis/detection/ote_utils.py b/external/mmdetection/build/lib/detection_tasks/apis/detection/ote_utils.py deleted file mode 100644 index 991efaaa52b..00000000000 --- a/external/mmdetection/build/lib/detection_tasks/apis/detection/ote_utils.py +++ /dev/null @@ -1,167 +0,0 @@ -# Copyright (C) 2021 Intel Corporation -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions -# and limitations under the License. - -import time -import colorsys -import importlib -import random -from typing import Callable, Union - -import numpy as np -import yaml -from ote_sdk.entities.color import Color -from ote_sdk.entities.id import ID -from ote_sdk.entities.label import Domain, LabelEntity -from ote_sdk.entities.label_schema import LabelGroup, LabelGroupType, LabelSchemaEntity -from ote_sdk.entities.train_parameters import UpdateProgressCallback -from ote_sdk.usecases.reporting.time_monitor_callback import TimeMonitorCallback - - -class ColorPalette: - def __init__(self, n, rng=None): - assert n > 0 - - if rng is None: - rng = random.Random(0xACE) - - candidates_num = 100 - hsv_colors = [(1.0, 1.0, 1.0)] - for _ in range(1, n): - colors_candidates = [(rng.random(), rng.uniform(0.8, 1.0), rng.uniform(0.5, 1.0)) - for _ in range(candidates_num)] - min_distances = [self.min_distance(hsv_colors, c) for c in colors_candidates] - arg_max = np.argmax(min_distances) - hsv_colors.append(colors_candidates[arg_max]) - - self.palette = [Color(*self.hsv2rgb(*hsv)) for hsv in hsv_colors] - - @staticmethod - def dist(c1, c2): - dh = min(abs(c1[0] - c2[0]), 1 - abs(c1[0] - c2[0])) * 2 - ds = abs(c1[1] - c2[1]) - dv = abs(c1[2] - c2[2]) - return dh * dh + ds * ds + dv * dv - - @classmethod - def min_distance(cls, colors_set, color_candidate): - distances = [cls.dist(o, color_candidate) for o in colors_set] - return np.min(distances) - - @staticmethod - def hsv2rgb(h, s, v): - return tuple(round(c * 255) for c in colorsys.hsv_to_rgb(h, s, v)) - - def __getitem__(self, n): - return self.palette[n % len(self.palette)] - - def __len__(self): - return len(self.palette) - - -def generate_label_schema(label_names, label_domain=Domain.DETECTION): - colors = ColorPalette(len(label_names)) if len(label_names) > 0 else [] - not_empty_labels = [LabelEntity(name=name, color=colors[i], domain=label_domain, id=ID(f"{i:08}")) for i, name in - enumerate(label_names)] - emptylabel = LabelEntity(name=f"Empty label", color=Color(42, 43, 46), - is_empty=True, domain=label_domain, id=ID(f"{len(not_empty_labels):08}")) - - label_schema = LabelSchemaEntity() - exclusive_group = LabelGroup(name="labels", labels=not_empty_labels, group_type=LabelGroupType.EXCLUSIVE) - empty_group = LabelGroup(name="empty", labels=[emptylabel], group_type=LabelGroupType.EMPTY_LABEL) - label_schema.add_group(exclusive_group) - label_schema.add_group(empty_group) - return label_schema - - -def load_template(path): - with open(path) as f: - template = yaml.safe_load(f) - return template - - -def get_task_class(path): - module_name, class_name = path.rsplit('.', 1) - module = importlib.import_module(module_name) - return getattr(module, class_name) - - -class TrainingProgressCallback(TimeMonitorCallback): - def __init__(self, update_progress_callback: UpdateProgressCallback): - super().__init__(0, 0, 0, 0, update_progress_callback=update_progress_callback) - - def on_train_batch_end(self, batch, logs=None): - super().on_train_batch_end(batch, logs) - self.update_progress_callback(self.get_progress()) - - def on_epoch_end(self, epoch, logs=None): - self.past_epoch_duration.append(time.time() - self.start_epoch_time) - self._calculate_average_epoch() - score = None - if hasattr(self.update_progress_callback, 'metric') and isinstance(logs, dict): - score = logs.get(self.update_progress_callback.metric, None) - score = float(score) if score is not None else None - self.update_progress_callback(self.get_progress(), score=score) - - -class InferenceProgressCallback(TimeMonitorCallback): - def __init__(self, num_test_steps, update_progress_callback: Callable[[int], None]): - super().__init__( - num_epoch=0, - num_train_steps=0, - num_val_steps=0, - num_test_steps=num_test_steps, - update_progress_callback=update_progress_callback) - - def on_test_batch_end(self, batch=None, logs=None): - super().on_test_batch_end(batch, logs) - self.update_progress_callback(int(self.get_progress())) - - -class OptimizationProgressCallback(TrainingProgressCallback): - """ Progress callback used for optimization using NNCF - There are three stages to the progress bar: - - 5 % model is loaded - - 10 % compressed model is initialized - - 10-100 % compressed model is being fine-tuned - """ - def __init__(self, update_progress_callback: UpdateProgressCallback, loading_stage_progress_percentage: int = 5, - initialization_stage_progress_percentage: int = 5): - super().__init__(update_progress_callback=update_progress_callback) - if loading_stage_progress_percentage + initialization_stage_progress_percentage >= 100: - raise RuntimeError('Total optimization progress percentage is more than 100%') - - self.loading_stage_progress_percentage = loading_stage_progress_percentage - self.initialization_stage_progress_percentage = initialization_stage_progress_percentage - - # set loading_stage_progress_percentage from the start as the model is already loaded at this point - self.update_progress_callback(loading_stage_progress_percentage) - - def on_train_begin(self, logs=None): - super().on_train_begin(logs) - # Callback initialization takes place here after OTEProgressHook.before_run() is called - train_percentage = 100 - self.loading_stage_progress_percentage - self.initialization_stage_progress_percentage - loading_stage_steps = self.total_steps * self.loading_stage_progress_percentage / train_percentage - initialization_stage_steps = self.total_steps * self.initialization_stage_progress_percentage / train_percentage - self.total_steps += loading_stage_steps + initialization_stage_steps - - self.current_step = loading_stage_steps + initialization_stage_steps - self.update_progress_callback(self.get_progress()) - - def on_train_end(self, logs=None): - super().on_train_end(logs) - self.update_progress_callback(self.get_progress(), score=logs) - - def on_initialization_end(self): - self.update_progress_callback(self.loading_stage_progress_percentage + - self.initialization_stage_progress_percentage) diff --git a/external/mmdetection/build/lib/detection_tasks/apis/detection/train_task.py b/external/mmdetection/build/lib/detection_tasks/apis/detection/train_task.py deleted file mode 100644 index 9d837cd2f82..00000000000 --- a/external/mmdetection/build/lib/detection_tasks/apis/detection/train_task.py +++ /dev/null @@ -1,224 +0,0 @@ -# Copyright (C) 2021 Intel Corporation -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions -# and limitations under the License. - -import copy -import io -import os -from collections import defaultdict -from glob import glob -from typing import List, Optional - -import numpy as np -import torch -from ote_sdk.configuration import cfg_helper -from ote_sdk.configuration.helper.utils import ids_to_strings -from ote_sdk.entities.datasets import DatasetEntity -from ote_sdk.entities.metrics import (BarChartInfo, BarMetricsGroup, CurveMetric, LineChartInfo, LineMetricsGroup, MetricsGroup, - ScoreMetric, VisualizationType) -from ote_sdk.entities.model import ModelEntity, ModelPrecision -from ote_sdk.entities.resultset import ResultSetEntity -from ote_sdk.entities.subset import Subset -from ote_sdk.entities.train_parameters import TrainParameters, default_progress_callback -from ote_sdk.serialization.label_mapper import label_schema_to_bytes -from ote_sdk.usecases.evaluation.metrics_helper import MetricsHelper -from ote_sdk.usecases.tasks.interfaces.training_interface import ITrainingTask - -from mmdet.apis import train_detector -from detection_tasks.apis.detection.config_utils import cluster_anchors, prepare_for_training, set_hyperparams -from detection_tasks.apis.detection.inference_task import OTEDetectionInferenceTask -from detection_tasks.apis.detection.ote_utils import TrainingProgressCallback -from detection_tasks.extension.utils.hooks import OTELoggerHook -from mmdet.datasets import build_dataset -from mmdet.utils.logger import get_root_logger - -logger = get_root_logger() - - -class OTEDetectionTrainingTask(OTEDetectionInferenceTask, ITrainingTask): - - def _generate_training_metrics(self, learning_curves, map) -> Optional[List[MetricsGroup]]: - """ - Parses the mmdetection logs to get metrics from the latest training run - - :return output List[MetricsGroup] - """ - output: List[MetricsGroup] = [] - - # Learning curves. - for key, curve in learning_curves.items(): - n, m = len(curve.x), len(curve.y) - if n != m: - logger.warning(f"Learning curve {key} has inconsistent number of coordinates ({n} vs {m}.") - n = min(n, m) - curve.x = curve.x[:n] - curve.y = curve.y[:n] - metric_curve = CurveMetric( - xs=np.nan_to_num(curve.x).tolist(), - ys=np.nan_to_num(curve.y).tolist(), - name=key) - visualization_info = LineChartInfo(name=key, x_axis_label="Epoch", y_axis_label=key) - output.append(LineMetricsGroup(metrics=[metric_curve], visualization_info=visualization_info)) - - # Final mAP value on the validation set. - output.append( - BarMetricsGroup( - metrics=[ScoreMetric(value=map, name="mAP")], - visualization_info=BarChartInfo("Validation score", visualization_type=VisualizationType.RADIAL_BAR) - ) - ) - - return output - - - def train(self, dataset: DatasetEntity, output_model: ModelEntity, train_parameters: Optional[TrainParameters] = None): - """ Trains a model on a dataset """ - - logger.info('Training the model') - set_hyperparams(self._config, self._hyperparams) - - train_dataset = dataset.get_subset(Subset.TRAINING) - val_dataset = dataset.get_subset(Subset.VALIDATION) - - # Do clustering for SSD model - if hasattr(self._config.model, 'bbox_head') and hasattr(self._config.model.bbox_head, 'anchor_generator'): - if getattr(self._config.model.bbox_head.anchor_generator, 'reclustering_anchors', False): - self._config, self._model = cluster_anchors(self._config, train_dataset, self._model) - - config = self._config - - # Create a copy of the network. - old_model = copy.deepcopy(self._model) - - # Check for stop signal between pre-eval and training. If training is cancelled at this point, - # old_model should be restored. - if self._should_stop: - logger.info('Training cancelled.') - self._model = old_model - self._should_stop = False - self._is_training = False - self._training_work_dir = None - return - - # Run training. - update_progress_callback = default_progress_callback - if train_parameters is not None: - update_progress_callback = train_parameters.update_progress - time_monitor = TrainingProgressCallback(update_progress_callback) - learning_curves = defaultdict(OTELoggerHook.Curve) - training_config = prepare_for_training(config, train_dataset, val_dataset, time_monitor, learning_curves) - self._training_work_dir = training_config.work_dir - mm_train_dataset = build_dataset(training_config.data.train) - self._is_training = True - self._model.train() - logger.info('Start training') - train_detector(model=self._model, dataset=mm_train_dataset, cfg=training_config, validate=True) - logger.info('Training completed') - - # Check for stop signal when training has stopped. If should_stop is true, training was cancelled and no new - # model should be returned. Old train model is restored. - if self._should_stop: - logger.info('Training cancelled.') - self._model = old_model - self._should_stop = False - self._is_training = False - return - - # Load best weights. - checkpoint_file_path = glob(os.path.join(training_config.work_dir, 'best*pth')) - if len(checkpoint_file_path) == 0: - checkpoint_file_path = os.path.join(training_config.work_dir, 'latest.pth') - elif len(checkpoint_file_path) > 1: - logger.warning(f'Multiple candidates for the best checkpoint found: {checkpoint_file_path}') - checkpoint_file_path = checkpoint_file_path[0] - else: - checkpoint_file_path = checkpoint_file_path[0] - logger.info(f'Use {checkpoint_file_path} for final model weights.') - checkpoint = torch.load(checkpoint_file_path) - self._model.load_state_dict(checkpoint['state_dict']) - - # Get predictions on the validation set. - val_preds, val_map = self._infer_detector( - self._model, - config, - val_dataset, - metric_name=config.evaluation.metric, - dump_features=False, - eval=True - ) - preds_val_dataset = val_dataset.with_empty_annotations() - self._add_predictions_to_dataset(val_preds, preds_val_dataset, 0.0) - resultset = ResultSetEntity( - model=output_model, - ground_truth_dataset=val_dataset, - prediction_dataset=preds_val_dataset, - ) - - # Adjust confidence threshold. - adaptive_threshold = self._hyperparams.postprocessing.result_based_confidence_threshold - if adaptive_threshold: - logger.info('Adjusting the confidence threshold') - metric = MetricsHelper.compute_f_measure(resultset, vary_confidence_threshold=True) - best_confidence_threshold = metric.best_confidence_threshold.value - if best_confidence_threshold is None: - raise ValueError(f"Cannot compute metrics: Invalid confidence threshold!") - logger.info(f"Setting confidence threshold to {best_confidence_threshold} based on results") - self.confidence_threshold = best_confidence_threshold - else: - metric = MetricsHelper.compute_f_measure(resultset, vary_confidence_threshold=False) - - # Compose performance statistics. - # TODO[EUGENE]: ADD MAE CURVE FOR TaskType.COUNTING - performance = metric.get_performance() - performance.dashboard_metrics.extend(self._generate_training_metrics(learning_curves, val_map)) - logger.info(f'Final model performance: {str(performance)}') - - # Save resulting model. - self.save_model(output_model) - output_model.performance = performance - - self._is_training = False - logger.info('Training the model [done]') - - - def save_model(self, output_model: ModelEntity): - buffer = io.BytesIO() - hyperparams_str = ids_to_strings(cfg_helper.convert(self._hyperparams, dict, enum_to_str=True)) - - modelinfo = {'model': self._model.state_dict(), - 'config': hyperparams_str, - 'confidence_threshold': self.confidence_threshold, - 'VERSION': 1} - - if hasattr(self._config.model, 'bbox_head') and hasattr(self._config.model.bbox_head, 'anchor_generator'): - if getattr(self._config.model.bbox_head.anchor_generator, 'reclustering_anchors', False): - generator = self._model.bbox_head.anchor_generator - modelinfo['anchors'] = {'heights': generator.heights, 'widths': generator.widths} - - torch.save(modelinfo, buffer) - output_model.set_data("weights.pth", buffer.getvalue()) - output_model.set_data("label_schema.json", label_schema_to_bytes(self._task_environment.label_schema)) - output_model.precision = [ModelPrecision.FP32] - - - def cancel_training(self): - """ - Sends a cancel training signal to gracefully stop the optimizer. The signal consists of creating a - '.stop_training' file in the current work_dir. The runner checks for this file periodically. - The stopping mechanism allows stopping after each iteration, but validation will still be carried out. Stopping - will therefore take some time. - """ - logger.info("Cancel training requested.") - self._should_stop = True - stop_training_filepath = os.path.join(self._training_work_dir, '.stop_training') - open(stop_training_filepath, 'a').close() diff --git a/external/mmdetection/build/lib/detection_tasks/extension/datasets/data_utils.py b/external/mmdetection/build/lib/detection_tasks/extension/datasets/data_utils.py deleted file mode 100644 index ff38a3243af..00000000000 --- a/external/mmdetection/build/lib/detection_tasks/extension/datasets/data_utils.py +++ /dev/null @@ -1,390 +0,0 @@ -# Copyright (C) 2020-2021 Intel Corporation -# SPDX-License-Identifier: Apache-2.0 -# -import json -import os.path as osp -from typing import List, Optional - -import numpy as np -from ote_sdk.entities.annotation import Annotation, AnnotationSceneEntity, AnnotationSceneKind -from ote_sdk.entities.dataset_item import DatasetItemEntity -from ote_sdk.entities.datasets import DatasetEntity -from ote_sdk.entities.id import ID -from ote_sdk.entities.image import Image -from ote_sdk.entities.label import Domain, LabelEntity -from ote_sdk.entities.scored_label import ScoredLabel -from ote_sdk.entities.shapes.polygon import Polygon, Point -from ote_sdk.entities.shapes.rectangle import Rectangle -from ote_sdk.entities.subset import Subset -from ote_sdk.utils.shape_factory import ShapeFactory -from pycocotools.coco import COCO - -from mmdet.core import BitmapMasks, PolygonMasks - -def get_classes_from_annotation(path): - with open(path) as read_file: - content = json.load(read_file) - categories = [ - v["name"] for v in sorted(content["categories"], key=lambda x: x["id"]) - ] - return categories - - -class LoadAnnotations: - def __init__(self, with_bbox=True, with_label=True, with_mask=False): - self.with_bbox = with_bbox - self.with_label = with_label - self.with_mask = with_mask - - def _load_bboxes(self, results): - ann_info = results["ann_info"] - results["gt_bboxes"] = ann_info["bboxes"].copy() - - gt_bboxes_ignore = ann_info.get("bboxes_ignore", None) - if gt_bboxes_ignore is not None: - results["gt_bboxes_ignore"] = gt_bboxes_ignore.copy() - results["bbox_fields"].append("gt_bboxes_ignore") - results["bbox_fields"].append("gt_bboxes") - return results - - def _load_labels(self, results): - results["gt_labels"] = results["ann_info"]["labels"].copy() - return results - - def _load_masks(self, results): - gt_masks = results['ann_info']['masks'] - results['gt_masks'] = gt_masks - results['mask_fields'].append('gt_masks') - return results - - def __call__(self, results): - if self.with_bbox: - results = self._load_bboxes(results) - if results is None: - return None - if self.with_label: - results = self._load_labels(results) - if self.with_mask: - results = self._load_masks(results) - - return results - - def __repr__(self): - repr_str = self.__class__.__name__ - repr_str += f"(with_bbox={self.with_bbox}, " - repr_str += f"with_label={self.with_label})" - return repr_str - - -class CocoDataset: - def __init__( - self, - ann_file, - classes=None, - data_root=None, - img_prefix="", - test_mode=False, - filter_empty_gt=True, - min_size=None, - with_mask=False, - ): - self.ann_file = ann_file - self.data_root = data_root - self.img_prefix = img_prefix - self.test_mode = test_mode - self.filter_empty_gt = filter_empty_gt - self.classes = self.get_classes(classes) - self.min_size = min_size - self.with_mask = with_mask - - if self.data_root is not None: - # if not osp.isabs(self.ann_file): - # self.ann_file = osp.join(self.data_root, self.ann_file) - if not (self.img_prefix is None or osp.isabs(self.img_prefix)): - self.img_prefix = osp.join(self.data_root, self.img_prefix) - - self.data_infos = self.load_annotations(self.ann_file) - - if not test_mode: - valid_inds = self._filter_imgs() - self.data_infos = [self.data_infos[i] for i in valid_inds] - - def __len__(self): - return len(self.data_infos) - - def pre_pipeline(self, results): - results["img_prefix"] = self.img_prefix - results["bbox_fields"] = [] - results["mask_fields"] = [] - results["seg_fields"] = [] - - def _rand_another(self, idx): - pool = np.where(self.flag == self.flag[idx])[0] - return np.random.choice(pool) - - def __getitem__(self, idx): - return self.prepare_img(idx) - - def __iter__(self): - for i in range(len(self)): - yield self[i] - - def prepare_img(self, idx): - img_info = self.data_infos[idx] - ann_info = self.get_ann_info(idx) - results = dict(img_info=img_info, ann_info=ann_info) - self.pre_pipeline(results) - return LoadAnnotations(with_mask=self.with_mask)(results) - - def get_classes(self, classes=None): - if classes is None: - return get_classes_from_annotation(self.ann_file) - - if isinstance(classes, (tuple, list)): - return classes - - raise ValueError(f"Unsupported type {type(classes)} of classes.") - - def load_annotations(self, ann_file): - self.coco = COCO(ann_file) - self.cat_ids = self.coco.get_cat_ids(cat_names=self.classes) - self.cat2label = {cat_id: i for i, cat_id in enumerate(self.cat_ids)} - self.img_ids = self.coco.get_img_ids() - data_infos = [] - for i in self.img_ids: - info = self.coco.load_imgs([i])[0] - info["filename"] = info["file_name"] - data_infos.append(info) - return data_infos - - def get_ann_info(self, idx): - img_id = self.data_infos[idx]["id"] - ann_ids = self.coco.get_ann_ids(img_ids=[img_id]) - ann_info = self.coco.load_anns(ann_ids) - return self._parse_ann_info(self.data_infos[idx], ann_info) - - def get_cat_ids(self, idx): - img_id = self.data_infos[idx]["id"] - ann_ids = self.coco.get_ann_ids(img_ids=[img_id]) - ann_info = self.coco.load_anns(ann_ids) - return [ann["category_id"] for ann in ann_info] - - def _filter_imgs(self, min_size=32): - """Filter images too small or without ground truths.""" - valid_inds = [] - # obtain images that contain annotation - ids_with_ann = set(_["image_id"] for _ in self.coco.anns.values()) - # obtain images that contain annotations of the required categories - ids_in_cat = set() - for i, class_id in enumerate(self.cat_ids): - ids_in_cat |= set(self.coco.cat_img_map[class_id]) - # merge the image id sets of the two conditions and use the merged set - # to filter out images if self.filter_empty_gt=True - ids_in_cat &= ids_with_ann - - valid_img_ids = [] - for i, img_info in enumerate(self.data_infos): - img_id = self.img_ids[i] - if self.filter_empty_gt and img_id not in ids_in_cat: - continue - if min(img_info["width"], img_info["height"]) >= min_size: - valid_inds.append(i) - valid_img_ids.append(img_id) - self.img_ids = valid_img_ids - return valid_inds - - def _parse_ann_info(self, img_info, ann_info): - gt_bboxes = [] - gt_labels = [] - gt_bboxes_ignore = [] - gt_masks_ann = [] - for ann in ann_info: - if ann.get("ignore", False): - continue - x1, y1, w, h = ann["bbox"] - inter_w = max(0, min(x1 + w, img_info["width"]) - max(x1, 0)) - inter_h = max(0, min(y1 + h, img_info["height"]) - max(y1, 0)) - if inter_w * inter_h == 0: - continue - if ann["area"] <= 0 or w < 1 or h < 1: - continue - if self.min_size is not None: - if w < self.min_size or h < self.min_size: - continue - if ann["category_id"] not in self.cat_ids: - continue - bbox = [x1, y1, x1 + w, y1 + h] - if ann.get("iscrowd", False): - gt_bboxes_ignore.append(bbox) - else: - gt_bboxes.append(bbox) - gt_labels.append(self.cat2label[ann["category_id"]]) - gt_masks_ann.append(ann.get("segmentation", None)) - - if gt_bboxes: - gt_bboxes = np.array(gt_bboxes, dtype=np.float32) - gt_labels = np.array(gt_labels, dtype=np.int64) - else: - gt_bboxes = np.zeros((0, 4), dtype=np.float32) - gt_labels = np.array([], dtype=np.int64) - - if gt_bboxes_ignore: - gt_bboxes_ignore = np.array(gt_bboxes_ignore, dtype=np.float32) - else: - gt_bboxes_ignore = np.zeros((0, 4), dtype=np.float32) - - seg_map = img_info["filename"].replace("jpg", "png") - - ann = dict( - bboxes=gt_bboxes, - labels=gt_labels, - bboxes_ignore=gt_bboxes_ignore, - masks=gt_masks_ann, - seg_map=seg_map, - ) - - return ann - - -def find_label_by_name(labels, name, domain): - matching_labels = [label for label in labels if label.name == name] - if len(matching_labels) == 1: - return matching_labels[0] - elif len(matching_labels) == 0: - label = LabelEntity(name=name, domain=domain, id=ID(len(labels))) - labels.append(label) - return label - else: - raise ValueError("Found multiple matching labels") - - -def load_dataset_items_coco_format( - ann_file_path: str, - data_root_dir: str, - domain: Domain, - subset: Subset = Subset.NONE, - labels_list: Optional[List[LabelEntity]] = None, - with_mask: bool = False, -): - test_mode = subset in {Subset.VALIDATION, Subset.TESTING} - - coco_dataset = CocoDataset( - ann_file=ann_file_path, - data_root=data_root_dir, - classes=None, - test_mode=test_mode, - with_mask=with_mask, - ) - coco_dataset.test_mode = False - for label_name in coco_dataset.classes: - find_label_by_name(labels_list, label_name, domain) - - dataset_items = [] - for item in coco_dataset: - - def create_gt_box(x1, y1, x2, y2, label_name): - return Annotation( - Rectangle(x1=x1, y1=y1, x2=x2, y2=y2), - labels=[ScoredLabel(label=find_label_by_name(labels_list, label_name, domain))], - ) - - def create_gt_polygon(polygon_group, label_name): - if len(polygon_group) != 1: - raise RuntimeError("Complex instance segmentation masks consisting of several polygons are not supported.") - - return Annotation( - Polygon(points=polygon_group[0]), - labels=[ScoredLabel(label=find_label_by_name(labels_list, label_name, domain))], - ) - - img_height = item["img_info"].get("height") - img_width = item["img_info"].get("width") - divisor = np.array( - [img_width, img_height, img_width, img_height], - dtype=item["gt_bboxes"].dtype, - ) - bboxes = item["gt_bboxes"] / divisor - labels = item["gt_labels"] - - assert len(bboxes) == len(labels) - if with_mask: - polygons = item["gt_masks"] - assert len(bboxes) == len(polygons) - normalized_polygons = [] - for polygon_group in polygons: - normalized_polygons.append([]) - for polygon in polygon_group: - normalized_polygon = [p / divisor[i % 2] for i, p in enumerate(polygon)] - points = [Point(normalized_polygon[i], normalized_polygon[i + 1]) for i in range(0, len(polygon), 2)] - normalized_polygons[-1].append(points) - - if item["img_prefix"] is not None: - filename = osp.join(item["img_prefix"], item["img_info"]["filename"]) - else: - filename = item["img_info"]["filename"] - - if with_mask: - shapes = [ - create_gt_polygon(polygon_group, coco_dataset.classes[label_id]) - for polygon_group, label_id in zip(normalized_polygons, labels) - ] - else: - shapes = [ - create_gt_box(x1, y1, x2, y2, coco_dataset.classes[label_id]) - for (x1, y1, x2, y2), label_id in zip(bboxes, labels) - ] - - dataset_item = DatasetItemEntity( - media=Image(file_path=filename), - annotation_scene=AnnotationSceneEntity( - annotations=shapes, kind=AnnotationSceneKind.ANNOTATION - ), - subset=subset, - ) - dataset_items.append(dataset_item) - - return dataset_items - - -def get_sizes_from_dataset_entity(dataset: DatasetEntity, target_wh: list): - """ - Function to get sizes of instances in DatasetEntity and to resize it to the target size. - - :param dataset: DatasetEntity in which to get statistics - :param target_wh: target width and height of the dataset - :return list: tuples with width and height of each instance - """ - wh_stats = [] - for item in dataset: - for ann in item.get_annotations(include_empty=False): - has_detection_labels = any(label.domain == Domain.DETECTION for label in ann.get_labels(include_empty=False)) - if has_detection_labels: - box = ShapeFactory.shape_as_rectangle(ann.shape) - w = box.width * target_wh[0] - h = box.height * target_wh[1] - wh_stats.append((w, h)) - return wh_stats - - -def get_anchor_boxes(wh_stats, group_as): - from sklearn.cluster import KMeans - kmeans = KMeans(init='k-means++', n_clusters=sum(group_as), random_state=0).fit(wh_stats) - centers = kmeans.cluster_centers_ - - areas = np.sqrt(np.prod(centers, axis=1)) - idx = np.argsort(areas) - - widths = centers[idx, 0] - heights = centers[idx, 1] - - group_as = np.cumsum(group_as[:-1]) - widths, heights = np.split(widths, group_as), np.split(heights, group_as) - return widths, heights - - -def format_list_to_str(value_lists): - """ Decrease floating point digits in logs """ - str_value = '' - for value_list in value_lists: - str_value += '[' + ', '.join(f'{value:.2f}' for value in value_list) + '], ' - return f'[{str_value[:-2]}]' diff --git a/external/mmdetection/build/lib/detection_tasks/extension/datasets/mmdataset.py b/external/mmdetection/build/lib/detection_tasks/extension/datasets/mmdataset.py deleted file mode 100644 index ba7ef08c136..00000000000 --- a/external/mmdetection/build/lib/detection_tasks/extension/datasets/mmdataset.py +++ /dev/null @@ -1,214 +0,0 @@ -# Copyright (C) 2021 Intel Corporation -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions -# and limitations under the License. - -from copy import deepcopy -from typing import List - -import numpy as np -from ote_sdk.entities.dataset_item import DatasetItemEntity -from ote_sdk.entities.datasets import DatasetEntity -from ote_sdk.entities.label import Domain, LabelEntity -from ote_sdk.utils.shape_factory import ShapeFactory - -from mmdet.core import PolygonMasks -from mmdet.datasets.builder import DATASETS -from mmdet.datasets.custom import CustomDataset -from mmdet.datasets.pipelines import Compose - - -def get_annotation_mmdet_format( - dataset_item: DatasetItemEntity, - labels: List[LabelEntity], - domain: Domain, - min_size: int = -1, -) -> dict: - """ - Function to convert a OTE annotation to mmdetection format. This is used both in the OTEDataset class defined in - this file as in the custom pipeline element 'LoadAnnotationFromOTEDataset' - - :param dataset_item: DatasetItem for which to get annotations - :param labels: List of labels that are used in the task - :return dict: annotation information dict in mmdet format - """ - width, height = dataset_item.width, dataset_item.height - - # load annotations for item - gt_bboxes = [] - gt_labels = [] - gt_polygons = [] - - label_idx = {label.id: i for i, label in enumerate(labels)} - - for annotation in dataset_item.get_annotations(labels=labels, include_empty=False): - - box = ShapeFactory.shape_as_rectangle(annotation.shape) - - if min(box.width * width, box.height * height) < min_size: - continue - - class_indices = [ - label_idx[label.id] - for label in annotation.get_labels(include_empty=False) - if label.domain == domain - ] - - n = len(class_indices) - gt_bboxes.extend([[box.x1 * width, box.y1 * height, box.x2 * width, box.y2 * height] for _ in range(n)]) - if domain != Domain.DETECTION: - polygon = ShapeFactory.shape_as_polygon(annotation.shape) - polygon = np.array([p for point in polygon.points for p in [point.x * width, point.y * height]]) - gt_polygons.extend([[polygon] for _ in range(n)]) - gt_labels.extend(class_indices) - - if len(gt_bboxes) > 0: - ann_info = dict( - bboxes=np.array(gt_bboxes, dtype=np.float32).reshape(-1, 4), - labels=np.array(gt_labels, dtype=int), - masks=PolygonMasks( - gt_polygons, height=height, width=width) if gt_polygons else []) - else: - ann_info = dict( - bboxes=np.zeros((0, 4), dtype=np.float32), - labels=np.array([], dtype=int), - masks=[]) - return ann_info - - -@DATASETS.register_module() -class OTEDataset(CustomDataset): - """ - Wrapper that allows using a OTE dataset to train mmdetection models. This wrapper is not based on the filesystem, - but instead loads the items here directly from the OTE DatasetEntity object. - - The wrapper overwrites some methods of the CustomDataset class: prepare_train_img, prepare_test_img and prepipeline - Naming of certain attributes might seem a bit peculiar but this is due to the conventions set in CustomDataset. For - instance, CustomDatasets expects the dataset items to be stored in the attribute data_infos, which is why it is - named like that and not dataset_items. - - """ - - class _DataInfoProxy: - """ - This class is intended to be a wrapper to use it in CustomDataset-derived class as `self.data_infos`. - Instead of using list `data_infos` as in CustomDataset, our implementation of dataset OTEDataset - uses this proxy class with overriden __len__ and __getitem__; this proxy class - forwards data access operations to ote_dataset and converts the dataset items to the view - convenient for mmdetection. - """ - def __init__(self, ote_dataset, labels): - self.ote_dataset = ote_dataset - self.labels = labels - - def __len__(self): - return len(self.ote_dataset) - - def __getitem__(self, index): - """ - Prepare a dict 'data_info' that is expected by the mmdet pipeline to handle images and annotations - :return data_info: dictionary that contains the image and image metadata, as well as the labels of the objects - in the image - """ - - dataset = self.ote_dataset - item = dataset[index] - - height, width = item.height, item.width - - data_info = dict(dataset_item=item, width=width, height=height, index=index, - ann_info=dict(label_list=self.labels)) - - return data_info - - def __init__(self, ote_dataset: DatasetEntity, labels: List[LabelEntity], pipeline, domain, test_mode: bool = False): - self.ote_dataset = ote_dataset - self.labels = labels - self.CLASSES = list(label.name for label in labels) - self.domain = domain - self.test_mode = test_mode - - # Instead of using list data_infos as in CustomDataset, this implementation of dataset - # uses a proxy class with overriden __len__ and __getitem__; this proxy class - # forwards data access operations to ote_dataset. - # Note that list `data_infos` cannot be used here, since OTE dataset class does not have interface to - # get only annotation of a data item, so we would load the whole data item (including image) - # even if we need only checking aspect ratio of the image; due to it - # this implementation of dataset does not uses such tricks as skipping images with wrong aspect ratios or - # small image size, since otherwise reading the whole dataset during initialization will be required. - self.data_infos = OTEDataset._DataInfoProxy(ote_dataset, labels) - - self.proposals = None # Attribute expected by mmdet but not used for OTE datasets - - if not test_mode: - self._set_group_flag() - - self.pipeline = Compose(pipeline) - - def _set_group_flag(self): - """Set flag for grouping images. - - Originally, in Custom dataset, images with aspect ratio greater than 1 will be set as group 1, - otherwise group 0. - This implementation will set group 0 for every image. - """ - self.flag = np.zeros(len(self), dtype=np.uint8) - - def _rand_another(self, idx): - return np.random.choice(len(self)) - - # In contrast with CustomDataset this implementation of dataset - # does not filter images w.r.t. the min size - def _filter_imgs(self, min_size=32): - raise NotImplementedError - - def prepare_train_img(self, idx: int) -> dict: - """Get training data and annotations after pipeline. - - :param idx: int, Index of data. - :return dict: Training data and annotation after pipeline with new keys introduced by pipeline. - """ - item = deepcopy(self.data_infos[idx]) - self.pre_pipeline(item) - return self.pipeline(item) - - def prepare_test_img(self, idx: int) -> dict: - """Get testing data after pipeline. - - :param idx: int, Index of data. - :return dict: Testing data after pipeline with new keys introduced by pipeline. - """ - # FIXME. - # item = deepcopy(self.data_infos[idx]) - item = self.data_infos[idx] - self.pre_pipeline(item) - return self.pipeline(item) - - @staticmethod - def pre_pipeline(results: dict): - """Prepare results dict for pipeline. Add expected keys to the dict. """ - results['bbox_fields'] = [] - results['mask_fields'] = [] - results['seg_fields'] = [] - - def get_ann_info(self, idx): - """ - This method is used for evaluation of predictions. The CustomDataset class implements a method - CustomDataset.evaluate, which uses the class method get_ann_info to retrieve annotations. - - :param idx: index of the dataset item for which to get the annotations - :return ann_info: dict that contains the coordinates of the bboxes and their corresponding labels - """ - dataset_item = self.ote_dataset[idx] - labels = self.labels - return get_annotation_mmdet_format(dataset_item, labels, self.domain) - diff --git a/external/mmdetection/build/lib/detection_tasks/extension/utils/__init__.py b/external/mmdetection/build/lib/detection_tasks/extension/utils/__init__.py deleted file mode 100644 index 144196cf57b..00000000000 --- a/external/mmdetection/build/lib/detection_tasks/extension/utils/__init__.py +++ /dev/null @@ -1,22 +0,0 @@ -# Copyright (C) 2021-2022 Intel Corporation -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions -# and limitations under the License. - -from .hooks import CancelTrainingHook, FixedMomentumUpdaterHook, OTELoggerHook, OTEProgressHook -from .hooks import EarlyStoppingHook, ReduceLROnPlateauLrUpdaterHook, StopLossNanTrainingHook -from .pipelines import LoadImageFromOTEDataset, LoadAnnotationFromOTEDataset -from .runner import EpochRunnerWithCancel - -__all__ = [CancelTrainingHook, FixedMomentumUpdaterHook, LoadImageFromOTEDataset, EpochRunnerWithCancel, - LoadAnnotationFromOTEDataset, OTELoggerHook, OTEProgressHook, EarlyStoppingHook, - ReduceLROnPlateauLrUpdaterHook, StopLossNanTrainingHook] diff --git a/external/mmdetection/build/lib/detection_tasks/extension/utils/hooks.py b/external/mmdetection/build/lib/detection_tasks/extension/utils/hooks.py deleted file mode 100644 index dbde2753aa0..00000000000 --- a/external/mmdetection/build/lib/detection_tasks/extension/utils/hooks.py +++ /dev/null @@ -1,503 +0,0 @@ -# Copyright (C) 2021-2022 Intel Corporation -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions -# and limitations under the License. - -import logging -import math -import os -from math import inf, isnan -from collections import defaultdict - -from mmcv.runner.hooks import HOOKS, Hook, LoggerHook, LrUpdaterHook -from mmcv.runner import BaseRunner, EpochBasedRunner -from mmcv.runner.dist_utils import master_only -from mmcv.utils import print_log - -from mmdet.utils.logger import get_root_logger - - -logger = get_root_logger() - - -@HOOKS.register_module() -class CancelTrainingHook(Hook): - def __init__(self, interval: int = 5): - """ - Periodically check whether whether a stop signal is sent to the runner during model training. - Every 'check_interval' iterations, the work_dir for the runner is checked to see if a file '.stop_training' - is present. If it is, training is stopped. - - :param interval: Period for checking for stop signal, given in iterations. - - """ - self.interval = interval - - @staticmethod - def _check_for_stop_signal(runner: BaseRunner): - work_dir = runner.work_dir - stop_filepath = os.path.join(work_dir, '.stop_training') - if os.path.exists(stop_filepath): - if isinstance(runner, EpochBasedRunner): - epoch = runner.epoch - runner._max_epochs = epoch # Force runner to stop by pretending it has reached it's max_epoch - runner.should_stop = True # Set this flag to true to stop the current training epoch - os.remove(stop_filepath) - - def after_train_iter(self, runner: BaseRunner): - if not self.every_n_iters(runner, self.interval): - return - self._check_for_stop_signal(runner) - - -@HOOKS.register_module() -class FixedMomentumUpdaterHook(Hook): - def __init__(self): - """ - This hook does nothing, as the momentum is fixed by default. The hook is here to streamline switching between - different LR schedules. - """ - pass - - def before_run(self, runner): - pass - - -@HOOKS.register_module() -class EnsureCorrectBestCheckpointHook(Hook): - def __init__(self): - """ - This hook makes sure that the 'best_mAP' checkpoint points properly to the best model, even if the best model is - created in the last epoch. - """ - pass - - def after_run(self, runner): - runner.call_hook('after_train_epoch') - - -@HOOKS.register_module() -class OTELoggerHook(LoggerHook): - - class Curve: - def __init__(self): - self.x = [] - self.y = [] - - def __repr__(self): - points = [] - for x, y in zip(self.x, self.y): - points.append(f'({x},{y})') - return 'curve[' + ','.join(points) + ']' - - def __init__(self, - curves=None, - interval=10, - ignore_last=True, - reset_flag=True, - by_epoch=True): - super().__init__(interval, ignore_last, reset_flag, by_epoch) - self.curves = curves if curves is not None else defaultdict(self.Curve) - - @master_only - def log(self, runner): - tags = self.get_loggable_tags(runner, allow_text=False) - if runner.max_epochs is not None: - normalized_iter = self.get_iter(runner) / runner.max_iters * runner.max_epochs - else: - normalized_iter = self.get_iter(runner) - for tag, value in tags.items(): - curve = self.curves[tag] - # Remove duplicates. - if len(curve.x) > 0 and curve.x[-1] == normalized_iter: - curve.x.pop() - curve.y.pop() - curve.x.append(normalized_iter) - curve.y.append(value) - - def after_train_epoch(self, runner): - # Iteration counter is increased right after the last iteration in the epoch, - # temporarily decrease it back. - runner._iter -= 1 - super().after_train_epoch(runner) - runner._iter += 1 - - -@HOOKS.register_module() -class OTEProgressHook(Hook): - def __init__(self, time_monitor, verbose=False): - super().__init__() - self.time_monitor = time_monitor - self.verbose = verbose - self.print_threshold = 1 - - def before_run(self, runner): - total_epochs = runner.max_epochs if runner.max_epochs is not None else 1 - self.time_monitor.total_epochs = total_epochs - self.time_monitor.train_steps = runner.max_iters // total_epochs if total_epochs else 1 - self.time_monitor.steps_per_epoch = self.time_monitor.train_steps + self.time_monitor.val_steps - self.time_monitor.total_steps = max(math.ceil(self.time_monitor.steps_per_epoch * total_epochs), 1) - self.time_monitor.current_step = 0 - self.time_monitor.current_epoch = 0 - self.time_monitor.on_train_begin() - - def before_epoch(self, runner): - self.time_monitor.on_epoch_begin(runner.epoch) - - def after_epoch(self, runner): - self.time_monitor.on_epoch_end(runner.epoch, runner.log_buffer.output) - - def before_iter(self, runner): - self.time_monitor.on_train_batch_begin(1) - - def after_iter(self, runner): - self.time_monitor.on_train_batch_end(1) - if self.verbose: - progress = self.progress - if progress >= self.print_threshold: - logger.warning(f'training progress {progress:.0f}%') - self.print_threshold = (progress + 10) // 10 * 10 - - def before_val_iter(self, runner): - self.time_monitor.on_test_batch_begin(1) - - def after_val_iter(self, runner): - self.time_monitor.on_test_batch_end(1) - - def after_run(self, runner): - self.time_monitor.on_train_end(1) - self.time_monitor.update_progress_callback(int(self.time_monitor.get_progress())) - - @property - def progress(self): - return self.time_monitor.get_progress() - - -@HOOKS.register_module() -class EarlyStoppingHook(Hook): - """ - Cancel training when a metric has stopped improving. - - Early Stopping hook monitors a metric quantity and if no improvement is seen for a ‘patience’ - number of epochs, the training is cancelled. - - :param interval: the number of intervals for checking early stop. The interval number should be - the same as the evaluation interval - the `interval` variable set in - `evaluation` config. - :param metric: the metric name to be monitored - :param rule: greater or less. In `less` mode, training will stop when the metric has stopped - decreasing and in `greater` mode it will stop when the metric has stopped - increasing. - :param patience: Number of epochs with no improvement after which the training will be reduced. - For example, if patience = 2, then we will ignore the first 2 epochs with no - improvement, and will only cancel the training after the 3rd epoch if the - metric still hasn’t improved then - :param iteration_patience: Number of iterations must be trained after the last improvement - before training stops. The same as patience but the training - continues if the number of iteration is lower than iteration_patience - This variable makes sure a model is trained enough for some - iterations after the last improvement before stopping. - :param min_delta: Minimal decay applied to lr. If the difference between new and old lr is - smaller than eps, the update is ignored - """ - rule_map = {'greater': lambda x, y: x > y, 'less': lambda x, y: x < y} - init_value_map = {'greater': -inf, 'less': inf} - greater_keys = [ - 'acc', 'top', 'AR@', 'auc', 'precision', 'mAP', 'mDice', 'mIoU', - 'mAcc', 'aAcc' - ] - less_keys = ['loss'] - - def __init__(self, - interval: int, - metric: str = 'bbox_mAP', - rule: str = None, - patience: int = 5, - iteration_patience: int = 500, - min_delta: float = 0.0): - super().__init__() - self.patience = patience - self.iteration_patience = iteration_patience - self.interval = interval - self.min_delta = min_delta - self._init_rule(rule, metric) - - self.min_delta *= 1 if self.rule == 'greater' else -1 - self.last_iter = 0 - self.wait_count = 0 - self.best_score = self.init_value_map[self.rule] - - def _init_rule(self, rule, key_indicator): - """Initialize rule, key_indicator, comparison_func, and best score. - - Here is the rule to determine which rule is used for key indicator - when the rule is not specific: - 1. If the key indicator is in ``self.greater_keys``, the rule will be - specified as 'greater'. - 2. Or if the key indicator is in ``self.less_keys``, the rule will be - specified as 'less'. - 3. Or if the key indicator is equal to the substring in any one item - in ``self.greater_keys``, the rule will be specified as 'greater'. - 4. Or if the key indicator is equal to the substring in any one item - in ``self.less_keys``, the rule will be specified as 'less'. - - Args: - rule (str | None): Comparison rule for best score. - key_indicator (str | None): Key indicator to determine the - comparison rule. - """ - if rule not in self.rule_map and rule is not None: - raise KeyError(f'rule must be greater, less or None, ' - f'but got {rule}.') - - if rule is None: - if key_indicator in self.greater_keys or any( - key in key_indicator for key in self.greater_keys): - rule = 'greater' - elif key_indicator in self.less_keys or any( - key in key_indicator for key in self.less_keys): - rule = 'less' - else: - raise ValueError(f'Cannot infer the rule for key ' - f'{key_indicator}, thus a specific rule ' - f'must be specified.') - self.rule = rule - self.key_indicator = key_indicator - self.compare_func = self.rule_map[self.rule] - - def before_run(self, runner): - self.by_epoch = False if runner.max_epochs is None else True - for hook in runner.hooks: - if isinstance(hook, LrUpdaterHook): - self.warmup_iters = hook.warmup_iters - break - - def after_train_iter(self, runner): - """Called after every training iter to evaluate the results.""" - if not self.by_epoch: - self._do_check_stopping(runner) - - def after_train_epoch(self, runner): - """Called after every training epoch to evaluate the results.""" - if self.by_epoch: - self._do_check_stopping(runner) - - def _do_check_stopping(self, runner): - if not self._should_check_stopping( - runner) or self.warmup_iters > runner.iter: - return - - if runner.rank == 0: - if self.key_indicator not in runner.log_buffer.output: - raise KeyError( - f'metric {self.key_indicator} does not exist in buffer. Please check ' - f'{self.key_indicator} is cached in evaluation output buffer' - ) - - key_score = runner.log_buffer.output[self.key_indicator] - if self.compare_func(key_score - self.min_delta, self.best_score): - self.best_score = key_score - self.wait_count = 0 - self.last_iter = runner.iter - else: - self.wait_count += 1 - if self.wait_count >= self.patience: - if runner.iter - self.last_iter < self.iteration_patience: - print_log( - f"\nSkip early stopping. Accumulated iteration " - f"{runner.iter - self.last_iter} from the last " - f"improvement must be larger than {self.iteration_patience} to trigger " - f"Early Stopping.", - logger=runner.logger) - return - stop_point = runner.epoch if self.by_epoch else runner.iter - print_log( - f"\nEarly Stopping at :{stop_point} with " - f"best {self.key_indicator}: {self.best_score}", - logger=runner.logger) - runner.should_stop = True - - def _should_check_stopping(self, runner): - check_time = self.every_n_epochs if self.by_epoch else self.every_n_iters - if not check_time(runner, self.interval): - # No evaluation during the interval. - return False - return True - - -@HOOKS.register_module() -class ReduceLROnPlateauLrUpdaterHook(LrUpdaterHook): - """ - Reduce learning rate when a metric has stopped improving. - - Models often benefit from reducing the learning rate by a factor of 2-10 once learning stagnates. - This scheduler reads a metrics quantity and if no improvement is seen for a ‘patience’ - number of epochs, the learning rate is reduced. - - :param min_lr: minimum learning rate. The lower bound of the desired learning rate. - :param interval: the number of intervals for checking the hook. The interval number should be - the same as the evaluation interval - the `interval` variable set in - `evaluation` config. - :param metric: the metric name to be monitored - :param rule: greater or less. In `less` mode, learning rate will be dropped if the metric has - stopped decreasing and in `greater` mode it will be dropped when the metric has - stopped increasing. - :param patience: Number of epochs with no improvement after which learning rate will be reduced. - For example, if patience = 2, then we will ignore the first 2 epochs with no - improvement, and will only drop LR after the 3rd epoch if the metric still - hasn’t improved then - :param iteration_patience: Number of iterations must be trained after the last improvement - before LR drops. The same as patience but the LR remains the same if - the number of iteration is lower than iteration_patience. This - variable makes sure a model is trained enough for some iterations - after the last improvement before dropping the LR. - :param factor: Factor to be multiply with the learning rate. - For example, new_lr = current_lr * factor - """ - rule_map = {'greater': lambda x, y: x > y, 'less': lambda x, y: x < y} - init_value_map = {'greater': -inf, 'less': inf} - greater_keys = [ - 'acc', 'top', 'AR@', 'auc', 'precision', 'mAP', 'mDice', 'mIoU', - 'mAcc', 'aAcc' - ] - less_keys = ['loss'] - - def __init__(self, - min_lr, - interval, - metric='bbox_mAP', - rule=None, - factor=0.1, - patience=3, - iteration_patience=300, - **kwargs): - super().__init__(**kwargs) - self.interval = interval - self.min_lr = min_lr - self.factor = factor - self.patience = patience - self.iteration_patience = iteration_patience - self.metric = metric - self.bad_count = 0 - self.last_iter = 0 - self.current_lr = None - self._init_rule(rule, metric) - self.best_score = self.init_value_map[self.rule] - - def _init_rule(self, rule, key_indicator): - """Initialize rule, key_indicator, comparison_func, and best score. - - Here is the rule to determine which rule is used for key indicator - when the rule is not specific: - 1. If the key indicator is in ``self.greater_keys``, the rule will be - specified as 'greater'. - 2. Or if the key indicator is in ``self.less_keys``, the rule will be - specified as 'less'. - 3. Or if the key indicator is equal to the substring in any one item - in ``self.greater_keys``, the rule will be specified as 'greater'. - 4. Or if the key indicator is equal to the substring in any one item - in ``self.less_keys``, the rule will be specified as 'less'. - - Args: - rule (str | None): Comparison rule for best score. - key_indicator (str | None): Key indicator to determine the - comparison rule. - """ - if rule not in self.rule_map and rule is not None: - raise KeyError(f'rule must be greater, less or None, ' - f'but got {rule}.') - - if rule is None: - if key_indicator in self.greater_keys or any( - key in key_indicator for key in self.greater_keys): - rule = 'greater' - elif key_indicator in self.less_keys or any( - key in key_indicator for key in self.less_keys): - rule = 'less' - else: - raise ValueError(f'Cannot infer the rule for key ' - f'{key_indicator}, thus a specific rule ' - f'must be specified.') - self.rule = rule - self.key_indicator = key_indicator - self.compare_func = self.rule_map[self.rule] - - def _should_check_stopping(self, runner): - check_time = self.every_n_epochs if self.by_epoch else self.every_n_iters - if not check_time(runner, self.interval): - # No evaluation during the interval. - return False - return True - - def get_lr(self, runner, base_lr): - if not self._should_check_stopping( - runner) or self.warmup_iters > runner.iter: - return base_lr - - if self.current_lr is None: - self.current_lr = base_lr - - if hasattr(runner, self.metric): - score = getattr(runner, self.metric, 0.0) - else: - return self.current_lr - - print_log( - f"\nBest Score: {self.best_score}, Current Score: {score}, Patience: {self.patience} " - f"Count: {self.bad_count}", - logger=runner.logger) - if self.compare_func(score, self.best_score): - self.best_score = score - self.bad_count = 0 - self.last_iter = runner.iter - else: - self.bad_count += 1 - - if self.bad_count >= self.patience: - if runner.iter - self.last_iter < self.iteration_patience: - print_log( - f"\nSkip LR dropping. Accumulated iteration " - f"{runner.iter - self.last_iter} from the last " - f"improvement must be larger than {self.iteration_patience} to trigger " - f"LR dropping.", - logger=runner.logger) - return self.current_lr - self.last_iter = runner.iter - self.bad_count = 0 - print_log( - f"\nDrop LR from: {self.current_lr}, to: " - f"{max(self.current_lr * self.factor, self.min_lr)}", - logger=runner.logger) - self.current_lr = max(self.current_lr * self.factor, self.min_lr) - return self.current_lr - - def before_run(self, runner): - # TODO: remove overloaded method after fixing the issue - # https://github.com/open-mmlab/mmdetection/issues/6572 - for group in runner.optimizer.param_groups: - group.setdefault('initial_lr', group['lr']) - self.base_lr = [ - group['lr'] for group in runner.optimizer.param_groups - ] - self.bad_count = 0 - self.last_iter = 0 - self.current_lr = None - self.best_score = self.init_value_map[self.rule] - - -@HOOKS.register_module() -class StopLossNanTrainingHook(Hook): - - def after_train_iter(self, runner): - if isnan(runner.outputs['loss'].item()): - logger.warning(f"Early Stopping since loss is NaN") - runner.should_stop = True diff --git a/external/mmdetection/build/lib/detection_tasks/extension/utils/pipelines.py b/external/mmdetection/build/lib/detection_tasks/extension/utils/pipelines.py deleted file mode 100644 index 82629e49973..00000000000 --- a/external/mmdetection/build/lib/detection_tasks/extension/utils/pipelines.py +++ /dev/null @@ -1,120 +0,0 @@ -# Copyright (C) 2021 Intel Corporation -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions -# and limitations under the License. - -import copy - -import numpy as np - -from mmdet.datasets.builder import PIPELINES - -from ..datasets import get_annotation_mmdet_format - - -@PIPELINES.register_module() -class LoadImageFromOTEDataset: - """ - Pipeline element that loads an image from a OTE Dataset on the fly. Can do conversion to float 32 if needed. - - Expected entries in the 'results' dict that should be passed to this pipeline element are: - results['dataset_item']: dataset_item from which to load the image - results['dataset_id']: id of the dataset to which the item belongs - results['index']: index of the item in the dataset - - :param to_float32: optional bool, True to convert images to fp32. defaults to False - """ - - def __init__(self, to_float32: bool = False): - self.to_float32 = to_float32 - - def __call__(self, results): - dataset_item = results['dataset_item'] - img = dataset_item.numpy - shape = img.shape - - assert img.shape[0] == results['height'], f"{img.shape[0]} != {results['height']}" - assert img.shape[1] == results['width'], f"{img.shape[1]} != {results['width']}" - - filename = f"Dataset item index {results['index']}" - results['filename'] = filename - results['ori_filename'] = filename - results['img'] = img - results['img_shape'] = shape - results['ori_shape'] = shape - # Set initial values for default meta_keys - results['pad_shape'] = shape - num_channels = 1 if len(shape) < 3 else shape[2] - results['img_norm_cfg'] = dict( - mean=np.zeros(num_channels, dtype=np.float32), - std=np.ones(num_channels, dtype=np.float32), - to_rgb=False) - results['img_fields'] = ['img'] - - if self.to_float32: - results['img'] = results['img'].astype(np.float32) - - return results - - -@PIPELINES.register_module() -class LoadAnnotationFromOTEDataset: - """ - Pipeline element that loads an annotation from a OTE Dataset on the fly. - - Expected entries in the 'results' dict that should be passed to this pipeline element are: - results['dataset_item']: dataset_item from which to load the annotation - results['ann_info']['label_list']: list of all labels in the project - - """ - - def __init__(self, min_size : int, with_bbox: bool = True, with_label: bool = True, with_mask: bool = False, with_seg: bool = False, - poly2mask: bool = True, with_text: bool = False, domain=None): - self.with_bbox = with_bbox - self.with_label = with_label - self.with_mask = with_mask - self.with_seg = with_seg - self.poly2mask = poly2mask - self.with_text = with_text - self.domain = domain - self.min_size = min_size - - @staticmethod - def _load_bboxes(results, ann_info): - results['bbox_fields'].append('gt_bboxes') - results['gt_bboxes'] = copy.deepcopy(ann_info['bboxes']) - return results - - @staticmethod - def _load_labels(results, ann_info): - results['gt_labels'] = copy.deepcopy(ann_info['labels']) - return results - - @staticmethod - def _load_masks(results, ann_info): - results['mask_fields'].append('gt_masks') - results['gt_masks'] = copy.deepcopy(ann_info['masks']) - return results - - def __call__(self, results): - dataset_item = results['dataset_item'] - label_list = results['ann_info']['label_list'] - ann_info = get_annotation_mmdet_format(dataset_item, label_list, self.domain, self.min_size) - if self.with_bbox: - results = self._load_bboxes(results, ann_info) - if results is None or len(results['gt_bboxes']) == 0: - return None - if self.with_label: - results = self._load_labels(results, ann_info) - if self.with_mask: - results = self._load_masks(results, ann_info) - return results diff --git a/external/mmdetection/build/lib/detection_tasks/extension/utils/runner.py b/external/mmdetection/build/lib/detection_tasks/extension/utils/runner.py deleted file mode 100644 index 94889b2d1d2..00000000000 --- a/external/mmdetection/build/lib/detection_tasks/extension/utils/runner.py +++ /dev/null @@ -1,127 +0,0 @@ -# Copyright (c) 2018-2021 OpenMMLab -# SPDX-License-Identifier: Apache-2.0 -# -# Copyright (C) 2020-2022 Intel Corporation -# SPDX-License-Identifier: Apache-2.0 -# - -# Is based on -# * https://github.com/open-mmlab/mmcv/blob/master/mmcv/runner/epoch_based_runner.py -# * https://github.com/open-mmlab/mmcv/blob/master/mmcv/runner/iter_based_runner.py - -import time -import warnings - -import mmcv -import torch.distributed as dist -from mmcv.runner.utils import get_host_info -from mmcv.runner import RUNNERS, EpochBasedRunner, IterBasedRunner, IterLoader, get_dist_info - - -@RUNNERS.register_module() -class EpochRunnerWithCancel(EpochBasedRunner): - """ - Simple modification to EpochBasedRunner to allow cancelling the training during an epoch. - A stopping hook should set the runner.should_stop flag to True if stopping is required. - """ - - def __init__(self, *args, **kwargs): - super().__init__(*args, **kwargs) - self.should_stop = False - _, world_size = get_dist_info() - self.distributed = True if world_size > 1 else False - - def stop(self) -> bool: - """ Returning a boolean to break the training loop - This method supports distributed training by broadcasting should_stop to other ranks - :return: a cancellation bool - """ - broadcast_obj = [False] - if self.rank == 0 and self.should_stop: - broadcast_obj = [True] - - if self.distributed: - dist.broadcast_object_list(broadcast_obj, src=0) - if broadcast_obj[0]: - self._max_epochs = self.epoch - return broadcast_obj[0] - - def train(self, data_loader, **kwargs): - self.model.train() - self.mode = 'train' - self.data_loader = data_loader - self._max_iters = self._max_epochs * len(self.data_loader) - self.call_hook('before_train_epoch') - time.sleep(2) # Prevent possible deadlock during epoch transition - for i, data_batch in enumerate(self.data_loader): - self._inner_iter = i - self.call_hook('before_train_iter') - self.run_iter(data_batch, train_mode=True, **kwargs) - self.call_hook('after_train_iter') - if self.stop(): - break - self._iter += 1 - self.call_hook('after_train_epoch') - self.stop() - self._epoch += 1 - - -@RUNNERS.register_module() -class IterBasedRunnerWithCancel(IterBasedRunner): - """ - Simple modification to IterBasedRunner to allow cancelling the training. The cancel training hook - should set the runner.should_stop flag to True if stopping is required. - - # TODO: Implement cancelling of training via keyboard interrupt signal, instead of should_stop - """ - def __init__(self, *args, **kwargs): - super().__init__(*args, **kwargs) - self.should_stop = False - - def main_loop(self, workflow, iter_loaders, **kwargs): - while self.iter < self._max_iters: - for i, flow in enumerate(workflow): - self._inner_iter = 0 - mode, iters = flow - if not isinstance(mode, str) or not hasattr(self, mode): - raise ValueError( - 'runner has no method named "{}" to run a workflow'. - format(mode)) - iter_runner = getattr(self, mode) - for _ in range(iters): - if mode == 'train' and self.iter >= self._max_iters: - break - iter_runner(iter_loaders[i], **kwargs) - if self.should_stop: - return - - def run(self, data_loaders, workflow, max_iters=None, **kwargs): - assert isinstance(data_loaders, list) - assert mmcv.is_list_of(workflow, tuple) - assert len(data_loaders) == len(workflow) - if max_iters is not None: - warnings.warn( - 'setting max_iters in run is deprecated, ' - 'please set max_iters in runner_config', DeprecationWarning) - self._max_iters = max_iters - assert self._max_iters is not None, ( - 'max_iters must be specified during instantiation') - - work_dir = self.work_dir if self.work_dir is not None else 'NONE' - self.logger.info('Start running, host: %s, work_dir: %s', - get_host_info(), work_dir) - self.logger.info('workflow: %s, max: %d iters', workflow, - self._max_iters) - self.call_hook('before_run') - - iter_loaders = [IterLoader(x) for x in data_loaders] - - self.call_hook('before_epoch') - - self.should_stop = False - self.main_loop(workflow, iter_loaders, **kwargs) - self.should_stop = False - - time.sleep(1) # wait for some hooks like loggers to finish - self.call_hook('after_epoch') - self.call_hook('after_run') diff --git a/external/mmdetection/configs/custom-counting-instance-seg/efficientnetb2b_maskrcnn/model.py b/external/mmdetection/configs/custom-counting-instance-seg/efficientnetb2b_maskrcnn/model.py index ccce0aed64e..74051b8e088 100644 --- a/external/mmdetection/configs/custom-counting-instance-seg/efficientnetb2b_maskrcnn/model.py +++ b/external/mmdetection/configs/custom-counting-instance-seg/efficientnetb2b_maskrcnn/model.py @@ -157,3 +157,4 @@ dict(type='EarlyStoppingHook', patience=10, metric='mAP', interval=1, priority=75, iteration_patience=0), ] +fp16 = dict(loss_scale=512.) \ No newline at end of file diff --git a/external/mmdetection/dist/detection_tasks-0.0.0-py3.8.egg b/external/mmdetection/dist/detection_tasks-0.0.0-py3.8.egg deleted file mode 100644 index fb1e0ec450d36430cdcb17413c7cb4035e45386a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 108797 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 diff --git a/external/mmdetection/submodule b/external/mmdetection/submodule index ca19197237a..e490c6ad46d 160000 --- a/external/mmdetection/submodule +++ b/external/mmdetection/submodule @@ -1 +1 @@ -Subproject commit ca19197237ab5ecb7e7a27514bd4f464f6d379a6 +Subproject commit e490c6ad46d2a4e0dffce95017654591e141fe48 diff --git a/external/mmdetection/tests/expected_metrics/metrics_test_ote_training.yml b/external/mmdetection/tests/expected_metrics/metrics_test_ote_training.yml index 0ff86530012..bbf2e1a08e9 100644 --- a/external/mmdetection/tests/expected_metrics/metrics_test_ote_training.yml +++ b/external/mmdetection/tests/expected_metrics/metrics_test_ote_training.yml @@ -391,5 +391,5 @@ "max_diff_if_less_threshold": 0.01 ? "ACTION-nncf_export_evaluation,model-Custom_Counting_Instance_Segmentation_MaskRCNN_EfficientNetB2B,dataset-aeromonas,num_iters-CONFIG,batch-CONFIG,usecase-reallife" : "metrics.accuracy.f-measure": - "base": 'nncf_evaluation.metrics.accuracy.f-measure' + "base": "nncf_evaluation.metrics.accuracy.f-measure" "max_diff": 0.01 diff --git a/external/mmdetection/tests/ote_cli/test_instance_segmentation.py b/external/mmdetection/tests/ote_cli/test_instance_segmentation.py index b5c438986e4..46e6a729b91 100644 --- a/external/mmdetection/tests/ote_cli/test_instance_segmentation.py +++ b/external/mmdetection/tests/ote_cli/test_instance_segmentation.py @@ -34,6 +34,13 @@ ote_eval_testing, ote_train_testing, ote_export_testing, + nncf_optimize_testing, + nncf_export_testing, + nncf_eval_testing, + ote_hpo_testing, + nncf_eval_openvino_testing, + pot_optimize_testing, + pot_eval_testing ) @@ -111,3 +118,45 @@ def test_ote_eval_deployment(self, template): @pytest.mark.parametrize("template", templates, ids=templates_ids) def test_ote_demo_deployment(self, template): ote_demo_deployment_testing(template, root, ote_dir, args) + + @e2e_pytest_component + @pytest.mark.parametrize("template", templates, ids=templates_ids) + def test_nncf_optimize(self, template): + if template.entrypoints.nncf is None: + pytest.skip("nncf entrypoint is none") + + nncf_optimize_testing(template, root, ote_dir, args) + + @e2e_pytest_component + @pytest.mark.parametrize("template", templates, ids=templates_ids) + def test_nncf_export(self, template): + if template.entrypoints.nncf is None: + pytest.skip("nncf entrypoint is none") + + nncf_export_testing(template, root) + + @e2e_pytest_component + @pytest.mark.parametrize("template", templates, ids=templates_ids) + def test_nncf_eval(self, template): + if template.entrypoints.nncf is None: + pytest.skip("nncf entrypoint is none") + + nncf_eval_testing(template, root, ote_dir, args, threshold=0.001) + + @e2e_pytest_component + @pytest.mark.parametrize("template", templates, ids=templates_ids) + def test_nncf_eval_openvino(self, template): + if template.entrypoints.nncf is None: + pytest.skip("nncf entrypoint is none") + + nncf_eval_openvino_testing(template, root, ote_dir, args) + + @e2e_pytest_component + @pytest.mark.parametrize("template", templates, ids=templates_ids) + def test_pot_optimize(self, template): + pot_optimize_testing(template, root, ote_dir, args) + + @e2e_pytest_component + @pytest.mark.parametrize("template", templates, ids=templates_ids) + def test_pot_eval(self, template): + pot_eval_testing(template, root, ote_dir, args) \ No newline at end of file diff --git a/external/mmdetection/tests/reference/Custom_Counting_Instance_Segmentation_MaskRCNN_EfficientNetB2B/nncf/nncf_quantization.dot b/external/mmdetection/tests/reference/Custom_Counting_Instance_Segmentation_MaskRCNN_EfficientNetB2B/nncf/nncf_quantization.dot new file mode 100644 index 00000000000..52c51835a11 --- /dev/null +++ b/external/mmdetection/tests/reference/Custom_Counting_Instance_Segmentation_MaskRCNN_EfficientNetB2B/nncf/nncf_quantization.dot @@ -0,0 +1,1822 @@ +strict digraph { +"0 /nncf_model_input_0" [id=0, type=nncf_model_input]; +"1 SymmetricQuantizer/symmetric_quantize_0" [id=1, type=symmetric_quantize]; +"2 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/EffiInitBlock[init_block]/pad_0" [id=2, type=pad]; +"3 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/EffiInitBlock[init_block]/ConvBlock[conv]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=3, type=symmetric_quantize]; +"4 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/EffiInitBlock[init_block]/ConvBlock[conv]/NNCFConv2d[conv]/conv2d_0" [id=4, type=conv2d]; +"5 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/EffiInitBlock[init_block]/ConvBlock[conv]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=5, type=batch_norm]; +"6 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/EffiInitBlock[init_block]/ConvBlock[conv]/SiLU[activ]/silu_0" [id=6, type=silu]; +"7 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/EffiInitBlock[init_block]/ConvBlock[conv]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=7, type=symmetric_quantize]; +"8 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/pad_0" [id=8, type=pad]; +"9 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/ConvBlock[dw_conv]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=9, type=symmetric_quantize]; +"10 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/ConvBlock[dw_conv]/NNCFConv2d[conv]/conv2d_0" [id=10, type=conv2d]; +"11 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/ConvBlock[dw_conv]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=11, type=batch_norm]; +"12 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/ConvBlock[dw_conv]/SiLU[activ]/silu_0" [id=12, type=silu]; +"13 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/ConvBlock[dw_conv]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=13, type=symmetric_quantize]; +"14 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" [id=14, type=adaptive_avg_pool2d]; +"15 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" [id=15, type=symmetric_quantize]; +"16 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=16, type=symmetric_quantize]; +"17 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" [id=17, type=conv2d]; +"18 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/SiLU[activ]/silu_0" [id=18, type=silu]; +"19 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=19, type=symmetric_quantize]; +"20 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=20, type=symmetric_quantize]; +"21 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" [id=21, type=conv2d]; +"22 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" [id=22, type=sigmoid]; +"23 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" [id=23, type=symmetric_quantize]; +"24 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/__mul___0" [id=24, type=__mul__]; +"25 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" [id=25, type=symmetric_quantize]; +"26 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/ConvBlock[pw_conv]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=26, type=symmetric_quantize]; +"27 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/ConvBlock[pw_conv]/NNCFConv2d[conv]/conv2d_0" [id=27, type=conv2d]; +"28 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/ConvBlock[pw_conv]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=28, type=batch_norm]; +"29 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/ConvBlock[pw_conv]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=29, type=symmetric_quantize]; +"30 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/pad_0" [id=30, type=pad]; +"31 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/ConvBlock[dw_conv]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=31, type=symmetric_quantize]; +"32 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/ConvBlock[dw_conv]/NNCFConv2d[conv]/conv2d_0" [id=32, type=conv2d]; +"33 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/ConvBlock[dw_conv]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=33, type=batch_norm]; +"34 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/ConvBlock[dw_conv]/SiLU[activ]/silu_0" [id=34, type=silu]; +"35 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/ConvBlock[dw_conv]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=35, type=symmetric_quantize]; +"36 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" [id=36, type=adaptive_avg_pool2d]; +"37 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" [id=37, type=symmetric_quantize]; +"38 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=38, type=symmetric_quantize]; +"39 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" [id=39, type=conv2d]; +"40 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/SiLU[activ]/silu_0" [id=40, type=silu]; +"41 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=41, type=symmetric_quantize]; +"42 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=42, type=symmetric_quantize]; +"43 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" [id=43, type=conv2d]; +"44 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" [id=44, type=sigmoid]; +"45 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" [id=45, type=symmetric_quantize]; +"46 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/__mul___0" [id=46, type=__mul__]; +"47 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" [id=47, type=symmetric_quantize]; +"48 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/ConvBlock[pw_conv]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=48, type=symmetric_quantize]; +"49 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/ConvBlock[pw_conv]/NNCFConv2d[conv]/conv2d_0" [id=49, type=conv2d]; +"50 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/ConvBlock[pw_conv]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=50, type=batch_norm]; +"51 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/ConvBlock[pw_conv]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=51, type=symmetric_quantize]; +"52 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/__add___0" [id=52, type=__add__]; +"53 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SymmetricQuantizer/symmetric_quantize_0" [id=53, type=symmetric_quantize]; +"54 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=54, type=symmetric_quantize]; +"55 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=55, type=conv2d]; +"56 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=56, type=batch_norm]; +"57 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv1]/SiLU[activ]/silu_0" [id=57, type=silu]; +"58 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=58, type=symmetric_quantize]; +"59 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/pad_0" [id=59, type=pad]; +"60 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=60, type=symmetric_quantize]; +"61 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=61, type=conv2d]; +"62 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=62, type=batch_norm]; +"63 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv2]/SiLU[activ]/silu_0" [id=63, type=silu]; +"64 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=64, type=symmetric_quantize]; +"65 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" [id=65, type=adaptive_avg_pool2d]; +"66 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" [id=66, type=symmetric_quantize]; +"67 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=67, type=symmetric_quantize]; +"68 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" [id=68, type=conv2d]; +"69 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/SiLU[activ]/silu_0" [id=69, type=silu]; +"70 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=70, type=symmetric_quantize]; +"71 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=71, type=symmetric_quantize]; +"72 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" [id=72, type=conv2d]; +"73 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" [id=73, type=sigmoid]; +"74 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" [id=74, type=symmetric_quantize]; +"75 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/__mul___0" [id=75, type=__mul__]; +"76 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" [id=76, type=symmetric_quantize]; +"77 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=77, type=symmetric_quantize]; +"78 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=78, type=conv2d]; +"79 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=79, type=batch_norm]; +"80 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=80, type=symmetric_quantize]; +"81 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=81, type=symmetric_quantize]; +"82 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=82, type=conv2d]; +"83 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=83, type=batch_norm]; +"84 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv1]/SiLU[activ]/silu_0" [id=84, type=silu]; +"85 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=85, type=symmetric_quantize]; +"86 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/pad_0" [id=86, type=pad]; +"87 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=87, type=symmetric_quantize]; +"88 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=88, type=conv2d]; +"89 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=89, type=batch_norm]; +"90 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv2]/SiLU[activ]/silu_0" [id=90, type=silu]; +"91 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=91, type=symmetric_quantize]; +"92 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" [id=92, type=adaptive_avg_pool2d]; +"93 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" [id=93, type=symmetric_quantize]; +"94 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=94, type=symmetric_quantize]; +"95 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" [id=95, type=conv2d]; +"96 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/SiLU[activ]/silu_0" [id=96, type=silu]; +"97 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=97, type=symmetric_quantize]; +"98 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=98, type=symmetric_quantize]; +"99 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" [id=99, type=conv2d]; +"100 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" [id=100, type=sigmoid]; +"101 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" [id=101, type=symmetric_quantize]; +"102 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/__mul___0" [id=102, type=__mul__]; +"103 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" [id=103, type=symmetric_quantize]; +"104 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=104, type=symmetric_quantize]; +"105 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=105, type=conv2d]; +"106 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=106, type=batch_norm]; +"107 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=107, type=symmetric_quantize]; +"108 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/__add___0" [id=108, type=__add__]; +"109 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SymmetricQuantizer/symmetric_quantize_0" [id=109, type=symmetric_quantize]; +"110 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=110, type=symmetric_quantize]; +"111 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=111, type=conv2d]; +"112 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=112, type=batch_norm]; +"113 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv1]/SiLU[activ]/silu_0" [id=113, type=silu]; +"114 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=114, type=symmetric_quantize]; +"115 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/pad_0" [id=115, type=pad]; +"116 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=116, type=symmetric_quantize]; +"117 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=117, type=conv2d]; +"118 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=118, type=batch_norm]; +"119 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv2]/SiLU[activ]/silu_0" [id=119, type=silu]; +"120 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=120, type=symmetric_quantize]; +"121 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" [id=121, type=adaptive_avg_pool2d]; +"122 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" [id=122, type=symmetric_quantize]; +"123 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=123, type=symmetric_quantize]; +"124 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" [id=124, type=conv2d]; +"125 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/SiLU[activ]/silu_0" [id=125, type=silu]; +"126 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=126, type=symmetric_quantize]; +"127 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=127, type=symmetric_quantize]; +"128 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" [id=128, type=conv2d]; +"129 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" [id=129, type=sigmoid]; +"130 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" [id=130, type=symmetric_quantize]; +"131 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/__mul___0" [id=131, type=__mul__]; +"132 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" [id=132, type=symmetric_quantize]; +"133 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=133, type=symmetric_quantize]; +"134 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=134, type=conv2d]; +"135 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=135, type=batch_norm]; +"136 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=136, type=symmetric_quantize]; +"137 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/__add___0" [id=137, type=__add__]; +"138 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SymmetricQuantizer/symmetric_quantize_0" [id=138, type=symmetric_quantize]; +"139 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=139, type=symmetric_quantize]; +"140 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=140, type=conv2d]; +"141 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=141, type=batch_norm]; +"142 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv1]/SiLU[activ]/silu_0" [id=142, type=silu]; +"143 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=143, type=symmetric_quantize]; +"144 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/pad_0" [id=144, type=pad]; +"145 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=145, type=symmetric_quantize]; +"146 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=146, type=conv2d]; +"147 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=147, type=batch_norm]; +"148 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv2]/SiLU[activ]/silu_0" [id=148, type=silu]; +"149 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=149, type=symmetric_quantize]; +"150 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" [id=150, type=adaptive_avg_pool2d]; +"151 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" [id=151, type=symmetric_quantize]; +"152 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=152, type=symmetric_quantize]; +"153 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" [id=153, type=conv2d]; +"154 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/SiLU[activ]/silu_0" [id=154, type=silu]; +"155 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=155, type=symmetric_quantize]; +"156 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=156, type=symmetric_quantize]; +"157 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" [id=157, type=conv2d]; +"158 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" [id=158, type=sigmoid]; +"159 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" [id=159, type=symmetric_quantize]; +"160 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/__mul___0" [id=160, type=__mul__]; +"161 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" [id=161, type=symmetric_quantize]; +"162 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=162, type=symmetric_quantize]; +"163 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=163, type=conv2d]; +"164 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=164, type=batch_norm]; +"165 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=165, type=symmetric_quantize]; +"166 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=166, type=symmetric_quantize]; +"167 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=167, type=conv2d]; +"168 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=168, type=batch_norm]; +"169 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv1]/SiLU[activ]/silu_0" [id=169, type=silu]; +"170 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=170, type=symmetric_quantize]; +"171 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/pad_0" [id=171, type=pad]; +"172 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=172, type=symmetric_quantize]; +"173 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=173, type=conv2d]; +"174 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=174, type=batch_norm]; +"175 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv2]/SiLU[activ]/silu_0" [id=175, type=silu]; +"176 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=176, type=symmetric_quantize]; +"177 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" [id=177, type=adaptive_avg_pool2d]; +"178 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" [id=178, type=symmetric_quantize]; +"179 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=179, type=symmetric_quantize]; +"180 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" [id=180, type=conv2d]; +"181 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/SiLU[activ]/silu_0" [id=181, type=silu]; +"182 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=182, type=symmetric_quantize]; +"183 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=183, type=symmetric_quantize]; +"184 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" [id=184, type=conv2d]; +"185 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" [id=185, type=sigmoid]; +"186 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" [id=186, type=symmetric_quantize]; +"187 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/__mul___0" [id=187, type=__mul__]; +"188 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" [id=188, type=symmetric_quantize]; +"189 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=189, type=symmetric_quantize]; +"190 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=190, type=conv2d]; +"191 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=191, type=batch_norm]; +"192 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=192, type=symmetric_quantize]; +"193 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/__add___0" [id=193, type=__add__]; +"194 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SymmetricQuantizer/symmetric_quantize_0" [id=194, type=symmetric_quantize]; +"195 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=195, type=symmetric_quantize]; +"196 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=196, type=conv2d]; +"197 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=197, type=batch_norm]; +"198 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv1]/SiLU[activ]/silu_0" [id=198, type=silu]; +"199 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=199, type=symmetric_quantize]; +"200 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/pad_0" [id=200, type=pad]; +"201 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=201, type=symmetric_quantize]; +"202 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=202, type=conv2d]; +"203 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=203, type=batch_norm]; +"204 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv2]/SiLU[activ]/silu_0" [id=204, type=silu]; +"205 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=205, type=symmetric_quantize]; +"206 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" [id=206, type=adaptive_avg_pool2d]; +"207 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" [id=207, type=symmetric_quantize]; +"208 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=208, type=symmetric_quantize]; +"209 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" [id=209, type=conv2d]; +"210 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/SiLU[activ]/silu_0" [id=210, type=silu]; +"211 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=211, type=symmetric_quantize]; +"212 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=212, type=symmetric_quantize]; +"213 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" [id=213, type=conv2d]; +"214 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" [id=214, type=sigmoid]; +"215 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" [id=215, type=symmetric_quantize]; +"216 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/__mul___0" [id=216, type=__mul__]; +"217 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" [id=217, type=symmetric_quantize]; +"218 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=218, type=symmetric_quantize]; +"219 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=219, type=conv2d]; +"220 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=220, type=batch_norm]; +"221 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=221, type=symmetric_quantize]; +"222 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/__add___0" [id=222, type=__add__]; +"223 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SymmetricQuantizer/symmetric_quantize_0" [id=223, type=symmetric_quantize]; +"224 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=224, type=symmetric_quantize]; +"225 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=225, type=conv2d]; +"226 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=226, type=batch_norm]; +"227 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv1]/SiLU[activ]/silu_0" [id=227, type=silu]; +"228 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=228, type=symmetric_quantize]; +"229 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/pad_0" [id=229, type=pad]; +"230 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=230, type=symmetric_quantize]; +"231 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=231, type=conv2d]; +"232 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=232, type=batch_norm]; +"233 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv2]/SiLU[activ]/silu_0" [id=233, type=silu]; +"234 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=234, type=symmetric_quantize]; +"235 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" [id=235, type=adaptive_avg_pool2d]; +"236 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" [id=236, type=symmetric_quantize]; +"237 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=237, type=symmetric_quantize]; +"238 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" [id=238, type=conv2d]; +"239 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/SiLU[activ]/silu_0" [id=239, type=silu]; +"240 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=240, type=symmetric_quantize]; +"241 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=241, type=symmetric_quantize]; +"242 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" [id=242, type=conv2d]; +"243 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" [id=243, type=sigmoid]; +"244 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" [id=244, type=symmetric_quantize]; +"245 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/__mul___0" [id=245, type=__mul__]; +"246 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" [id=246, type=symmetric_quantize]; +"247 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=247, type=symmetric_quantize]; +"248 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=248, type=conv2d]; +"249 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=249, type=batch_norm]; +"250 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=250, type=symmetric_quantize]; +"251 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=251, type=symmetric_quantize]; +"252 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=252, type=conv2d]; +"253 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=253, type=batch_norm]; +"254 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv1]/SiLU[activ]/silu_0" [id=254, type=silu]; +"255 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=255, type=symmetric_quantize]; +"256 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/pad_0" [id=256, type=pad]; +"257 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=257, type=symmetric_quantize]; +"258 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=258, type=conv2d]; +"259 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=259, type=batch_norm]; +"260 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv2]/SiLU[activ]/silu_0" [id=260, type=silu]; +"261 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=261, type=symmetric_quantize]; +"262 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" [id=262, type=adaptive_avg_pool2d]; +"263 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" [id=263, type=symmetric_quantize]; +"264 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=264, type=symmetric_quantize]; +"265 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" [id=265, type=conv2d]; +"266 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/SiLU[activ]/silu_0" [id=266, type=silu]; +"267 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=267, type=symmetric_quantize]; +"268 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=268, type=symmetric_quantize]; +"269 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" [id=269, type=conv2d]; +"270 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" [id=270, type=sigmoid]; +"271 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" [id=271, type=symmetric_quantize]; +"272 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/__mul___0" [id=272, type=__mul__]; +"273 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" [id=273, type=symmetric_quantize]; +"274 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=274, type=symmetric_quantize]; +"275 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=275, type=conv2d]; +"276 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=276, type=batch_norm]; +"277 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=277, type=symmetric_quantize]; +"278 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/__add___0" [id=278, type=__add__]; +"279 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SymmetricQuantizer/symmetric_quantize_0" [id=279, type=symmetric_quantize]; +"280 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=280, type=symmetric_quantize]; +"281 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=281, type=conv2d]; +"282 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=282, type=batch_norm]; +"283 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv1]/SiLU[activ]/silu_0" [id=283, type=silu]; +"284 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=284, type=symmetric_quantize]; +"285 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/pad_0" [id=285, type=pad]; +"286 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=286, type=symmetric_quantize]; +"287 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=287, type=conv2d]; +"288 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=288, type=batch_norm]; +"289 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv2]/SiLU[activ]/silu_0" [id=289, type=silu]; +"290 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=290, type=symmetric_quantize]; +"291 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" [id=291, type=adaptive_avg_pool2d]; +"292 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" [id=292, type=symmetric_quantize]; +"293 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=293, type=symmetric_quantize]; +"294 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" [id=294, type=conv2d]; +"295 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/SiLU[activ]/silu_0" [id=295, type=silu]; +"296 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=296, type=symmetric_quantize]; +"297 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=297, type=symmetric_quantize]; +"298 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" [id=298, type=conv2d]; +"299 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" [id=299, type=sigmoid]; +"300 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" [id=300, type=symmetric_quantize]; +"301 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/__mul___0" [id=301, type=__mul__]; +"302 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" [id=302, type=symmetric_quantize]; +"303 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=303, type=symmetric_quantize]; +"304 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=304, type=conv2d]; +"305 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=305, type=batch_norm]; +"306 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=306, type=symmetric_quantize]; +"307 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/__add___0" [id=307, type=__add__]; +"308 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SymmetricQuantizer/symmetric_quantize_0" [id=308, type=symmetric_quantize]; +"309 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=309, type=symmetric_quantize]; +"310 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=310, type=conv2d]; +"311 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=311, type=batch_norm]; +"312 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv1]/SiLU[activ]/silu_0" [id=312, type=silu]; +"313 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=313, type=symmetric_quantize]; +"314 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/pad_0" [id=314, type=pad]; +"315 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=315, type=symmetric_quantize]; +"316 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=316, type=conv2d]; +"317 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=317, type=batch_norm]; +"318 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv2]/SiLU[activ]/silu_0" [id=318, type=silu]; +"319 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=319, type=symmetric_quantize]; +"320 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" [id=320, type=adaptive_avg_pool2d]; +"321 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" [id=321, type=symmetric_quantize]; +"322 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=322, type=symmetric_quantize]; +"323 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" [id=323, type=conv2d]; +"324 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/SiLU[activ]/silu_0" [id=324, type=silu]; +"325 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=325, type=symmetric_quantize]; +"326 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=326, type=symmetric_quantize]; +"327 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" [id=327, type=conv2d]; +"328 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" [id=328, type=sigmoid]; +"329 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" [id=329, type=symmetric_quantize]; +"330 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/__mul___0" [id=330, type=__mul__]; +"331 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" [id=331, type=symmetric_quantize]; +"332 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=332, type=symmetric_quantize]; +"333 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=333, type=conv2d]; +"334 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=334, type=batch_norm]; +"335 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=335, type=symmetric_quantize]; +"336 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/__add___0" [id=336, type=__add__]; +"337 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SymmetricQuantizer/symmetric_quantize_0" [id=337, type=symmetric_quantize]; +"338 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=338, type=symmetric_quantize]; +"339 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=339, type=conv2d]; +"340 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=340, type=batch_norm]; +"341 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv1]/SiLU[activ]/silu_0" [id=341, type=silu]; +"342 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=342, type=symmetric_quantize]; +"343 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/pad_0" [id=343, type=pad]; +"344 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=344, type=symmetric_quantize]; +"345 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=345, type=conv2d]; +"346 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=346, type=batch_norm]; +"347 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv2]/SiLU[activ]/silu_0" [id=347, type=silu]; +"348 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=348, type=symmetric_quantize]; +"349 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" [id=349, type=adaptive_avg_pool2d]; +"350 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" [id=350, type=symmetric_quantize]; +"351 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=351, type=symmetric_quantize]; +"352 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" [id=352, type=conv2d]; +"353 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/SiLU[activ]/silu_0" [id=353, type=silu]; +"354 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=354, type=symmetric_quantize]; +"355 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=355, type=symmetric_quantize]; +"356 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" [id=356, type=conv2d]; +"357 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" [id=357, type=sigmoid]; +"358 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" [id=358, type=symmetric_quantize]; +"359 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/__mul___0" [id=359, type=__mul__]; +"360 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" [id=360, type=symmetric_quantize]; +"361 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=361, type=symmetric_quantize]; +"362 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=362, type=conv2d]; +"363 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=363, type=batch_norm]; +"364 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=364, type=symmetric_quantize]; +"365 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=365, type=symmetric_quantize]; +"366 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=366, type=conv2d]; +"367 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=367, type=batch_norm]; +"368 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv1]/SiLU[activ]/silu_0" [id=368, type=silu]; +"369 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=369, type=symmetric_quantize]; +"370 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/pad_0" [id=370, type=pad]; +"371 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=371, type=symmetric_quantize]; +"372 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=372, type=conv2d]; +"373 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=373, type=batch_norm]; +"374 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv2]/SiLU[activ]/silu_0" [id=374, type=silu]; +"375 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=375, type=symmetric_quantize]; +"376 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" [id=376, type=adaptive_avg_pool2d]; +"377 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" [id=377, type=symmetric_quantize]; +"378 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=378, type=symmetric_quantize]; +"379 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" [id=379, type=conv2d]; +"380 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/SiLU[activ]/silu_0" [id=380, type=silu]; +"381 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=381, type=symmetric_quantize]; +"382 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=382, type=symmetric_quantize]; +"383 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" [id=383, type=conv2d]; +"384 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" [id=384, type=sigmoid]; +"385 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" [id=385, type=symmetric_quantize]; +"386 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/__mul___0" [id=386, type=__mul__]; +"387 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" [id=387, type=symmetric_quantize]; +"388 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=388, type=symmetric_quantize]; +"389 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=389, type=conv2d]; +"390 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=390, type=batch_norm]; +"391 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=391, type=symmetric_quantize]; +"392 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/__add___0" [id=392, type=__add__]; +"393 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SymmetricQuantizer/symmetric_quantize_0" [id=393, type=symmetric_quantize]; +"394 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=394, type=symmetric_quantize]; +"395 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=395, type=conv2d]; +"396 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=396, type=batch_norm]; +"397 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv1]/SiLU[activ]/silu_0" [id=397, type=silu]; +"398 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=398, type=symmetric_quantize]; +"399 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/pad_0" [id=399, type=pad]; +"400 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=400, type=symmetric_quantize]; +"401 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=401, type=conv2d]; +"402 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=402, type=batch_norm]; +"403 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv2]/SiLU[activ]/silu_0" [id=403, type=silu]; +"404 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=404, type=symmetric_quantize]; +"405 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" [id=405, type=adaptive_avg_pool2d]; +"406 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" [id=406, type=symmetric_quantize]; +"407 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=407, type=symmetric_quantize]; +"408 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" [id=408, type=conv2d]; +"409 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/SiLU[activ]/silu_0" [id=409, type=silu]; +"410 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=410, type=symmetric_quantize]; +"411 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=411, type=symmetric_quantize]; +"412 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" [id=412, type=conv2d]; +"413 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" [id=413, type=sigmoid]; +"414 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" [id=414, type=symmetric_quantize]; +"415 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/__mul___0" [id=415, type=__mul__]; +"416 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" [id=416, type=symmetric_quantize]; +"417 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=417, type=symmetric_quantize]; +"418 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=418, type=conv2d]; +"419 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=419, type=batch_norm]; +"420 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=420, type=symmetric_quantize]; +"421 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/__add___0" [id=421, type=__add__]; +"422 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SymmetricQuantizer/symmetric_quantize_0" [id=422, type=symmetric_quantize]; +"423 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=423, type=symmetric_quantize]; +"424 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=424, type=conv2d]; +"425 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=425, type=batch_norm]; +"426 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv1]/SiLU[activ]/silu_0" [id=426, type=silu]; +"427 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=427, type=symmetric_quantize]; +"428 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/pad_0" [id=428, type=pad]; +"429 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=429, type=symmetric_quantize]; +"430 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=430, type=conv2d]; +"431 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=431, type=batch_norm]; +"432 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv2]/SiLU[activ]/silu_0" [id=432, type=silu]; +"433 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=433, type=symmetric_quantize]; +"434 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" [id=434, type=adaptive_avg_pool2d]; +"435 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" [id=435, type=symmetric_quantize]; +"436 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=436, type=symmetric_quantize]; +"437 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" [id=437, type=conv2d]; +"438 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/SiLU[activ]/silu_0" [id=438, type=silu]; +"439 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=439, type=symmetric_quantize]; +"440 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=440, type=symmetric_quantize]; +"441 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" [id=441, type=conv2d]; +"442 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" [id=442, type=sigmoid]; +"443 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" [id=443, type=symmetric_quantize]; +"444 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/__mul___0" [id=444, type=__mul__]; +"445 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" [id=445, type=symmetric_quantize]; +"446 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=446, type=symmetric_quantize]; +"447 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=447, type=conv2d]; +"448 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=448, type=batch_norm]; +"449 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=449, type=symmetric_quantize]; +"450 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/__add___0" [id=450, type=__add__]; +"451 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SymmetricQuantizer/symmetric_quantize_0" [id=451, type=symmetric_quantize]; +"452 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=452, type=symmetric_quantize]; +"453 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=453, type=conv2d]; +"454 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=454, type=batch_norm]; +"455 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv1]/SiLU[activ]/silu_0" [id=455, type=silu]; +"456 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=456, type=symmetric_quantize]; +"457 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/pad_0" [id=457, type=pad]; +"458 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=458, type=symmetric_quantize]; +"459 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=459, type=conv2d]; +"460 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=460, type=batch_norm]; +"461 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv2]/SiLU[activ]/silu_0" [id=461, type=silu]; +"462 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=462, type=symmetric_quantize]; +"463 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" [id=463, type=adaptive_avg_pool2d]; +"464 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" [id=464, type=symmetric_quantize]; +"465 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=465, type=symmetric_quantize]; +"466 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" [id=466, type=conv2d]; +"467 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/SiLU[activ]/silu_0" [id=467, type=silu]; +"468 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=468, type=symmetric_quantize]; +"469 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=469, type=symmetric_quantize]; +"470 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" [id=470, type=conv2d]; +"471 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" [id=471, type=sigmoid]; +"472 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" [id=472, type=symmetric_quantize]; +"473 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/__mul___0" [id=473, type=__mul__]; +"474 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" [id=474, type=symmetric_quantize]; +"475 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=475, type=symmetric_quantize]; +"476 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=476, type=conv2d]; +"477 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=477, type=batch_norm]; +"478 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=478, type=symmetric_quantize]; +"479 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=479, type=symmetric_quantize]; +"480 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=480, type=conv2d]; +"481 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=481, type=batch_norm]; +"482 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv1]/SiLU[activ]/silu_0" [id=482, type=silu]; +"483 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=483, type=symmetric_quantize]; +"484 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/pad_0" [id=484, type=pad]; +"485 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=485, type=symmetric_quantize]; +"486 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=486, type=conv2d]; +"487 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=487, type=batch_norm]; +"488 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv2]/SiLU[activ]/silu_0" [id=488, type=silu]; +"489 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=489, type=symmetric_quantize]; +"490 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" [id=490, type=adaptive_avg_pool2d]; +"491 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" [id=491, type=symmetric_quantize]; +"492 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=492, type=symmetric_quantize]; +"493 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" [id=493, type=conv2d]; +"494 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/SiLU[activ]/silu_0" [id=494, type=silu]; +"495 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=495, type=symmetric_quantize]; +"496 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=496, type=symmetric_quantize]; +"497 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" [id=497, type=conv2d]; +"498 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" [id=498, type=sigmoid]; +"499 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" [id=499, type=symmetric_quantize]; +"500 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/__mul___0" [id=500, type=__mul__]; +"501 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" [id=501, type=symmetric_quantize]; +"502 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=502, type=symmetric_quantize]; +"503 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=503, type=conv2d]; +"504 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=504, type=batch_norm]; +"505 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=505, type=symmetric_quantize]; +"506 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/__add___0" [id=506, type=__add__]; +"507 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SymmetricQuantizer/symmetric_quantize_0" [id=507, type=symmetric_quantize]; +"508 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=508, type=symmetric_quantize]; +"509 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=509, type=conv2d]; +"510 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=510, type=batch_norm]; +"511 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv1]/SiLU[activ]/silu_0" [id=511, type=silu]; +"512 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=512, type=symmetric_quantize]; +"513 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/pad_0" [id=513, type=pad]; +"514 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=514, type=symmetric_quantize]; +"515 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=515, type=conv2d]; +"516 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=516, type=batch_norm]; +"517 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv2]/SiLU[activ]/silu_0" [id=517, type=silu]; +"518 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=518, type=symmetric_quantize]; +"519 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" [id=519, type=adaptive_avg_pool2d]; +"520 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" [id=520, type=symmetric_quantize]; +"521 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=521, type=symmetric_quantize]; +"522 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" [id=522, type=conv2d]; +"523 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/SiLU[activ]/silu_0" [id=523, type=silu]; +"524 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=524, type=symmetric_quantize]; +"525 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=525, type=symmetric_quantize]; +"526 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" [id=526, type=conv2d]; +"527 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" [id=527, type=sigmoid]; +"528 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" [id=528, type=symmetric_quantize]; +"529 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/__mul___0" [id=529, type=__mul__]; +"530 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" [id=530, type=symmetric_quantize]; +"531 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=531, type=symmetric_quantize]; +"532 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=532, type=conv2d]; +"533 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=533, type=batch_norm]; +"534 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=534, type=symmetric_quantize]; +"535 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/__add___0" [id=535, type=__add__]; +"536 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SymmetricQuantizer/symmetric_quantize_0" [id=536, type=symmetric_quantize]; +"537 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=537, type=symmetric_quantize]; +"538 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=538, type=conv2d]; +"539 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=539, type=batch_norm]; +"540 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv1]/SiLU[activ]/silu_0" [id=540, type=silu]; +"541 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=541, type=symmetric_quantize]; +"542 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/pad_0" [id=542, type=pad]; +"543 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=543, type=symmetric_quantize]; +"544 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=544, type=conv2d]; +"545 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=545, type=batch_norm]; +"546 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv2]/SiLU[activ]/silu_0" [id=546, type=silu]; +"547 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=547, type=symmetric_quantize]; +"548 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" [id=548, type=adaptive_avg_pool2d]; +"549 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" [id=549, type=symmetric_quantize]; +"550 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=550, type=symmetric_quantize]; +"551 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" [id=551, type=conv2d]; +"552 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/SiLU[activ]/silu_0" [id=552, type=silu]; +"553 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=553, type=symmetric_quantize]; +"554 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=554, type=symmetric_quantize]; +"555 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" [id=555, type=conv2d]; +"556 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" [id=556, type=sigmoid]; +"557 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" [id=557, type=symmetric_quantize]; +"558 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/__mul___0" [id=558, type=__mul__]; +"559 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" [id=559, type=symmetric_quantize]; +"560 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=560, type=symmetric_quantize]; +"561 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=561, type=conv2d]; +"562 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=562, type=batch_norm]; +"563 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=563, type=symmetric_quantize]; +"564 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/__add___0" [id=564, type=__add__]; +"565 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SymmetricQuantizer/symmetric_quantize_0" [id=565, type=symmetric_quantize]; +"566 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=566, type=symmetric_quantize]; +"567 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=567, type=conv2d]; +"568 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=568, type=batch_norm]; +"569 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv1]/SiLU[activ]/silu_0" [id=569, type=silu]; +"570 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=570, type=symmetric_quantize]; +"571 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/pad_0" [id=571, type=pad]; +"572 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=572, type=symmetric_quantize]; +"573 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=573, type=conv2d]; +"574 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=574, type=batch_norm]; +"575 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv2]/SiLU[activ]/silu_0" [id=575, type=silu]; +"576 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=576, type=symmetric_quantize]; +"577 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" [id=577, type=adaptive_avg_pool2d]; +"578 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" [id=578, type=symmetric_quantize]; +"579 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=579, type=symmetric_quantize]; +"580 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" [id=580, type=conv2d]; +"581 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/SiLU[activ]/silu_0" [id=581, type=silu]; +"582 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=582, type=symmetric_quantize]; +"583 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=583, type=symmetric_quantize]; +"584 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" [id=584, type=conv2d]; +"585 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" [id=585, type=sigmoid]; +"586 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" [id=586, type=symmetric_quantize]; +"587 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/__mul___0" [id=587, type=__mul__]; +"588 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" [id=588, type=symmetric_quantize]; +"589 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=589, type=symmetric_quantize]; +"590 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=590, type=conv2d]; +"591 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=591, type=batch_norm]; +"592 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=592, type=symmetric_quantize]; +"593 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/__add___0" [id=593, type=__add__]; +"594 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SymmetricQuantizer/symmetric_quantize_0" [id=594, type=symmetric_quantize]; +"595 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=595, type=symmetric_quantize]; +"596 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=596, type=conv2d]; +"597 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=597, type=batch_norm]; +"598 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv1]/SiLU[activ]/silu_0" [id=598, type=silu]; +"599 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=599, type=symmetric_quantize]; +"600 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/pad_0" [id=600, type=pad]; +"601 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=601, type=symmetric_quantize]; +"602 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=602, type=conv2d]; +"603 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=603, type=batch_norm]; +"604 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv2]/SiLU[activ]/silu_0" [id=604, type=silu]; +"605 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=605, type=symmetric_quantize]; +"606 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" [id=606, type=adaptive_avg_pool2d]; +"607 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" [id=607, type=symmetric_quantize]; +"608 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=608, type=symmetric_quantize]; +"609 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" [id=609, type=conv2d]; +"610 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/SiLU[activ]/silu_0" [id=610, type=silu]; +"611 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=611, type=symmetric_quantize]; +"612 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=612, type=symmetric_quantize]; +"613 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" [id=613, type=conv2d]; +"614 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" [id=614, type=sigmoid]; +"615 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" [id=615, type=symmetric_quantize]; +"616 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/__mul___0" [id=616, type=__mul__]; +"617 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" [id=617, type=symmetric_quantize]; +"618 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=618, type=symmetric_quantize]; +"619 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=619, type=conv2d]; +"620 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=620, type=batch_norm]; +"621 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=621, type=symmetric_quantize]; +"622 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=622, type=symmetric_quantize]; +"623 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" [id=623, type=conv2d]; +"624 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=624, type=batch_norm]; +"625 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv1]/SiLU[activ]/silu_0" [id=625, type=silu]; +"626 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=626, type=symmetric_quantize]; +"627 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/pad_0" [id=627, type=pad]; +"628 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=628, type=symmetric_quantize]; +"629 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" [id=629, type=conv2d]; +"630 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=630, type=batch_norm]; +"631 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv2]/SiLU[activ]/silu_0" [id=631, type=silu]; +"632 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=632, type=symmetric_quantize]; +"633 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" [id=633, type=adaptive_avg_pool2d]; +"634 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" [id=634, type=symmetric_quantize]; +"635 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=635, type=symmetric_quantize]; +"636 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" [id=636, type=conv2d]; +"637 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/SiLU[activ]/silu_0" [id=637, type=silu]; +"638 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" [id=638, type=symmetric_quantize]; +"639 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=639, type=symmetric_quantize]; +"640 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" [id=640, type=conv2d]; +"641 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" [id=641, type=sigmoid]; +"642 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" [id=642, type=symmetric_quantize]; +"643 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/__mul___0" [id=643, type=__mul__]; +"644 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" [id=644, type=symmetric_quantize]; +"645 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=645, type=symmetric_quantize]; +"646 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" [id=646, type=conv2d]; +"647 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" [id=647, type=batch_norm]; +"648 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" [id=648, type=symmetric_quantize]; +"649 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/__add___0" [id=649, type=__add__]; +"650 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SymmetricQuantizer/symmetric_quantize_0" [id=650, type=symmetric_quantize]; +"651 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=651, type=symmetric_quantize]; +"652 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" [id=652, type=conv2d]; +"653 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=653, type=symmetric_quantize]; +"654 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=654, type=symmetric_quantize]; +"655 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" [id=655, type=conv2d]; +"656 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=656, type=symmetric_quantize]; +"657 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=657, type=symmetric_quantize]; +"658 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" [id=658, type=conv2d]; +"659 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=659, type=symmetric_quantize]; +"660 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=660, type=symmetric_quantize]; +"661 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" [id=661, type=conv2d]; +"662 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=662, type=symmetric_quantize]; +"663 MaskRCNN/FPN[neck]/interpolate_0" [id=663, type=interpolate]; +"664 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_0" [id=664, type=symmetric_quantize]; +"665 MaskRCNN/FPN[neck]/__iadd___0" [id=665, type=__iadd__]; +"666 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_1" [id=666, type=symmetric_quantize]; +"667 MaskRCNN/FPN[neck]/interpolate_1" [id=667, type=interpolate]; +"668 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_2" [id=668, type=symmetric_quantize]; +"669 MaskRCNN/FPN[neck]/__iadd___1" [id=669, type=__iadd__]; +"670 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_3" [id=670, type=symmetric_quantize]; +"671 MaskRCNN/FPN[neck]/interpolate_2" [id=671, type=interpolate]; +"672 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_4" [id=672, type=symmetric_quantize]; +"673 MaskRCNN/FPN[neck]/__iadd___2" [id=673, type=__iadd__]; +"674 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_5" [id=674, type=symmetric_quantize]; +"675 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=675, type=symmetric_quantize]; +"676 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" [id=676, type=conv2d]; +"677 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=677, type=symmetric_quantize]; +"678 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" [id=678, type=conv2d]; +"679 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=679, type=symmetric_quantize]; +"680 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" [id=680, type=conv2d]; +"681 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=681, type=symmetric_quantize]; +"682 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" [id=682, type=conv2d]; +"683 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_6" [id=683, type=symmetric_quantize]; +"684 MaskRCNN/FPN[neck]/max_pool2d_0" [id=684, type=max_pool2d]; +"685 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=685, type=symmetric_quantize]; +"686 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/SymmetricQuantizer/symmetric_quantize_0" [id=686, type=symmetric_quantize]; +"687 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_0" [id=687, type=conv2d]; +"688 MaskRCNN/RPNHead[rpn_head]/relu__0" [id=688, type=relu_]; +"689 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_0" [id=689, type=symmetric_quantize]; +"690 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=690, type=symmetric_quantize]; +"691 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/conv2d_0" [id=691, type=conv2d]; +"692 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=692, type=symmetric_quantize]; +"693 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/conv2d_0" [id=693, type=conv2d]; +"694 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" [id=694, type=symmetric_quantize]; +"695 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/SymmetricQuantizer/symmetric_quantize_1" [id=695, type=symmetric_quantize]; +"696 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_1" [id=696, type=conv2d]; +"697 MaskRCNN/RPNHead[rpn_head]/relu__1" [id=697, type=relu_]; +"698 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_1" [id=698, type=symmetric_quantize]; +"699 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" [id=699, type=symmetric_quantize]; +"700 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/conv2d_1" [id=700, type=conv2d]; +"701 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" [id=701, type=symmetric_quantize]; +"702 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/conv2d_1" [id=702, type=conv2d]; +"703 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" [id=703, type=symmetric_quantize]; +"704 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/SymmetricQuantizer/symmetric_quantize_2" [id=704, type=symmetric_quantize]; +"705 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_2" [id=705, type=conv2d]; +"706 MaskRCNN/RPNHead[rpn_head]/relu__2" [id=706, type=relu_]; +"707 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_2" [id=707, type=symmetric_quantize]; +"708 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" [id=708, type=symmetric_quantize]; +"709 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/conv2d_2" [id=709, type=conv2d]; +"710 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" [id=710, type=symmetric_quantize]; +"711 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/conv2d_2" [id=711, type=conv2d]; +"712 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" [id=712, type=symmetric_quantize]; +"713 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/SymmetricQuantizer/symmetric_quantize_3" [id=713, type=symmetric_quantize]; +"714 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_3" [id=714, type=conv2d]; +"715 MaskRCNN/RPNHead[rpn_head]/relu__3" [id=715, type=relu_]; +"716 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_3" [id=716, type=symmetric_quantize]; +"717 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" [id=717, type=symmetric_quantize]; +"718 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/conv2d_3" [id=718, type=conv2d]; +"719 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" [id=719, type=symmetric_quantize]; +"720 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/conv2d_3" [id=720, type=conv2d]; +"721 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" [id=721, type=symmetric_quantize]; +"722 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_4" [id=722, type=conv2d]; +"723 MaskRCNN/RPNHead[rpn_head]/relu__4" [id=723, type=relu_]; +"724 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_4" [id=724, type=symmetric_quantize]; +"725 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" [id=725, type=symmetric_quantize]; +"726 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/conv2d_4" [id=726, type=conv2d]; +"727 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" [id=727, type=symmetric_quantize]; +"728 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/conv2d_4" [id=728, type=conv2d]; +"729 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/sqrt_0" [id=729, type=sqrt]; +"730 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_0" [id=730, type=symmetric_quantize]; +"731 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__truediv___0" [id=731, type=__truediv__]; +"732 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_1" [id=732, type=symmetric_quantize]; +"733 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__add___0" [id=733, type=__add__]; +"734 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/log2_0" [id=734, type=log2]; +"735 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/floor_0" [id=735, type=floor]; +"736 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/clamp_0" [id=736, type=clamp]; +"737 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/long_0" [id=737, type=long]; +"738 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__eq___0" [id=738, type=__eq__]; +"739 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/float_0" [id=739, type=float]; +"740 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_2" [id=740, type=symmetric_quantize]; +"741 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/unsqueeze_0" [id=741, type=unsqueeze]; +"742 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/expand_0" [id=742, type=expand]; +"743 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/reshape_0" [id=743, type=reshape]; +"744 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/new_zeros_0" [id=744, type=new_zeros]; +"745 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/SymmetricQuantizer/symmetric_quantize_0" [id=745, type=symmetric_quantize]; +"746 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/new_zeros_1" [id=746, type=new_zeros]; +"747 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/new_zeros_2" [id=747, type=new_zeros]; +"748 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__imul___0" [id=748, type=__imul__]; +"749 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__eq___1" [id=749, type=__eq__]; +"750 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/float_1" [id=750, type=float]; +"751 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_3" [id=751, type=symmetric_quantize]; +"752 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/unsqueeze_1" [id=752, type=unsqueeze]; +"753 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/expand_1" [id=753, type=expand]; +"754 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/reshape_1" [id=754, type=reshape]; +"755 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/new_zeros_0" [id=755, type=new_zeros]; +"756 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/SymmetricQuantizer/symmetric_quantize_0" [id=756, type=symmetric_quantize]; +"757 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/new_zeros_1" [id=757, type=new_zeros]; +"758 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/new_zeros_2" [id=758, type=new_zeros]; +"759 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__imul___1" [id=759, type=__imul__]; +"760 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__eq___2" [id=760, type=__eq__]; +"761 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/float_2" [id=761, type=float]; +"762 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_4" [id=762, type=symmetric_quantize]; +"763 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/unsqueeze_2" [id=763, type=unsqueeze]; +"764 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/expand_2" [id=764, type=expand]; +"765 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/reshape_2" [id=765, type=reshape]; +"766 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/new_zeros_0" [id=766, type=new_zeros]; +"767 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/SymmetricQuantizer/symmetric_quantize_0" [id=767, type=symmetric_quantize]; +"768 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/new_zeros_1" [id=768, type=new_zeros]; +"769 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/new_zeros_2" [id=769, type=new_zeros]; +"770 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__imul___2" [id=770, type=__imul__]; +"771 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__eq___3" [id=771, type=__eq__]; +"772 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/float_3" [id=772, type=float]; +"773 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_5" [id=773, type=symmetric_quantize]; +"774 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/unsqueeze_3" [id=774, type=unsqueeze]; +"775 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/expand_3" [id=775, type=expand]; +"776 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/reshape_3" [id=776, type=reshape]; +"777 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/new_zeros_0" [id=777, type=new_zeros]; +"778 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/SymmetricQuantizer/symmetric_quantize_0" [id=778, type=symmetric_quantize]; +"779 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/new_zeros_1" [id=779, type=new_zeros]; +"780 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/new_zeros_2" [id=780, type=new_zeros]; +"781 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__imul___3" [id=781, type=__imul__]; +"782 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ModuleList[shared_fcs]/NNCFLinear[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=782, type=symmetric_quantize]; +"783 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ModuleList[shared_fcs]/NNCFLinear[0]/linear_0" [id=783, type=linear]; +"784 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ReLU[relu]/relu__0" [id=784, type=relu_]; +"785 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=785, type=symmetric_quantize]; +"786 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ModuleList[shared_fcs]/NNCFLinear[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=786, type=symmetric_quantize]; +"787 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ModuleList[shared_fcs]/NNCFLinear[1]/linear_0" [id=787, type=linear]; +"788 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ReLU[relu]/relu__1" [id=788, type=relu_]; +"789 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=789, type=symmetric_quantize]; +"790 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/NNCFLinear[fc_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=790, type=symmetric_quantize]; +"791 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/NNCFLinear[fc_cls]/linear_0" [id=791, type=linear]; +"792 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/NNCFLinear[fc_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=792, type=symmetric_quantize]; +"793 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/NNCFLinear[fc_reg]/linear_0" [id=793, type=linear]; +"794 MaskRCNN/pad_0" [id=794, type=pad]; +"795 MaskRCNN/SymmetricQuantizer/symmetric_quantize_0" [id=795, type=symmetric_quantize]; +"796 MaskRCNN/cat_0" [id=796, type=cat]; +"797 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__getitem___0" [id=797, type=__getitem__]; +"798 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/clone_0" [id=798, type=clone]; +"799 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__getitem___1" [id=799, type=__getitem__]; +"800 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__getitem___2" [id=800, type=__getitem__]; +"801 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__sub___0" [id=801, type=__sub__]; +"802 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_0" [id=802, type=symmetric_quantize]; +"803 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__getitem___3" [id=803, type=__getitem__]; +"804 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__getitem___4" [id=804, type=__getitem__]; +"805 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__sub___1" [id=805, type=__sub__]; +"806 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_1" [id=806, type=symmetric_quantize]; +"807 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__mul___0" [id=807, type=__mul__]; +"808 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_2" [id=808, type=symmetric_quantize]; +"809 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/sqrt_0" [id=809, type=sqrt]; +"810 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_3" [id=810, type=symmetric_quantize]; +"811 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__truediv___0" [id=811, type=__truediv__]; +"812 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_4" [id=812, type=symmetric_quantize]; +"813 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__add___0" [id=813, type=__add__]; +"814 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/log2_0" [id=814, type=log2]; +"815 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/floor_0" [id=815, type=floor]; +"816 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/clamp_0" [id=816, type=clamp]; +"817 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/long_0" [id=817, type=long]; +"818 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__eq___0" [id=818, type=__eq__]; +"819 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/float_0" [id=819, type=float]; +"820 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_5" [id=820, type=symmetric_quantize]; +"821 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/unsqueeze_0" [id=821, type=unsqueeze]; +"822 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/expand_0" [id=822, type=expand]; +"823 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/reshape_0" [id=823, type=reshape]; +"824 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/new_zeros_0" [id=824, type=new_zeros]; +"825 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/SymmetricQuantizer/symmetric_quantize_0" [id=825, type=symmetric_quantize]; +"826 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/new_zeros_1" [id=826, type=new_zeros]; +"827 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/new_zeros_2" [id=827, type=new_zeros]; +"828 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__imul___0" [id=828, type=__imul__]; +"829 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__eq___1" [id=829, type=__eq__]; +"830 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/float_1" [id=830, type=float]; +"831 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_6" [id=831, type=symmetric_quantize]; +"832 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/unsqueeze_1" [id=832, type=unsqueeze]; +"833 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/expand_1" [id=833, type=expand]; +"834 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/reshape_1" [id=834, type=reshape]; +"835 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/new_zeros_0" [id=835, type=new_zeros]; +"836 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/SymmetricQuantizer/symmetric_quantize_0" [id=836, type=symmetric_quantize]; +"837 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/new_zeros_1" [id=837, type=new_zeros]; +"838 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/new_zeros_2" [id=838, type=new_zeros]; +"839 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__imul___1" [id=839, type=__imul__]; +"840 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__eq___2" [id=840, type=__eq__]; +"841 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/float_2" [id=841, type=float]; +"842 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_7" [id=842, type=symmetric_quantize]; +"843 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/unsqueeze_2" [id=843, type=unsqueeze]; +"844 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/expand_2" [id=844, type=expand]; +"845 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/reshape_2" [id=845, type=reshape]; +"846 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/new_zeros_0" [id=846, type=new_zeros]; +"847 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/SymmetricQuantizer/symmetric_quantize_0" [id=847, type=symmetric_quantize]; +"848 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/new_zeros_1" [id=848, type=new_zeros]; +"849 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/new_zeros_2" [id=849, type=new_zeros]; +"850 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__imul___2" [id=850, type=__imul__]; +"851 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__eq___3" [id=851, type=__eq__]; +"852 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/float_3" [id=852, type=float]; +"853 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_8" [id=853, type=symmetric_quantize]; +"854 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/unsqueeze_3" [id=854, type=unsqueeze]; +"855 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/expand_3" [id=855, type=expand]; +"856 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/reshape_3" [id=856, type=reshape]; +"857 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/new_zeros_0" [id=857, type=new_zeros]; +"858 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/SymmetricQuantizer/symmetric_quantize_0" [id=858, type=symmetric_quantize]; +"859 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/new_zeros_1" [id=859, type=new_zeros]; +"860 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/new_zeros_2" [id=860, type=new_zeros]; +"861 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__imul___3" [id=861, type=__imul__]; +"862 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=862, type=symmetric_quantize]; +"863 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" [id=863, type=conv2d]; +"864 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[0]/ReLU[activate]/relu__0" [id=864, type=relu_]; +"865 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" [id=865, type=symmetric_quantize]; +"866 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=866, type=symmetric_quantize]; +"867 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" [id=867, type=conv2d]; +"868 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[1]/ReLU[activate]/relu__0" [id=868, type=relu_]; +"869 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" [id=869, type=symmetric_quantize]; +"870 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=870, type=symmetric_quantize]; +"871 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" [id=871, type=conv2d]; +"872 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[2]/ReLU[activate]/relu__0" [id=872, type=relu_]; +"873 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" [id=873, type=symmetric_quantize]; +"874 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=874, type=symmetric_quantize]; +"875 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" [id=875, type=conv2d]; +"876 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[3]/ReLU[activate]/relu__0" [id=876, type=relu_]; +"877 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" [id=877, type=symmetric_quantize]; +"878 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/NNCFConvTranspose2d[upsample]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=878, type=symmetric_quantize]; +"879 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/NNCFConvTranspose2d[upsample]/conv_transpose2d_0" [id=879, type=conv_transpose2d]; +"880 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ReLU[relu]/relu__0" [id=880, type=relu_]; +"881 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=881, type=symmetric_quantize]; +"882 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/NNCFConv2d[conv_logits]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=882, type=symmetric_quantize]; +"883 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/NNCFConv2d[conv_logits]/conv2d_0" [id=883, type=conv2d]; +"884 MaskRCNN/__getitem___0" [id=884, type=__getitem__]; +"885 MaskRCNN/sigmoid_0" [id=885, type=sigmoid]; +"0 /nncf_model_input_0" -> "1 SymmetricQuantizer/symmetric_quantize_0"; +"1 SymmetricQuantizer/symmetric_quantize_0" -> "2 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/EffiInitBlock[init_block]/pad_0"; +"2 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/EffiInitBlock[init_block]/pad_0" -> "4 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/EffiInitBlock[init_block]/ConvBlock[conv]/NNCFConv2d[conv]/conv2d_0"; +"3 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/EffiInitBlock[init_block]/ConvBlock[conv]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "4 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/EffiInitBlock[init_block]/ConvBlock[conv]/NNCFConv2d[conv]/conv2d_0"; +"4 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/EffiInitBlock[init_block]/ConvBlock[conv]/NNCFConv2d[conv]/conv2d_0" -> "5 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/EffiInitBlock[init_block]/ConvBlock[conv]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"5 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/EffiInitBlock[init_block]/ConvBlock[conv]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "6 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/EffiInitBlock[init_block]/ConvBlock[conv]/SiLU[activ]/silu_0"; +"6 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/EffiInitBlock[init_block]/ConvBlock[conv]/SiLU[activ]/silu_0" -> "7 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/EffiInitBlock[init_block]/ConvBlock[conv]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"7 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/EffiInitBlock[init_block]/ConvBlock[conv]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "8 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/pad_0"; +"8 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/pad_0" -> "10 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/ConvBlock[dw_conv]/NNCFConv2d[conv]/conv2d_0"; +"9 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/ConvBlock[dw_conv]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "10 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/ConvBlock[dw_conv]/NNCFConv2d[conv]/conv2d_0"; +"10 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/ConvBlock[dw_conv]/NNCFConv2d[conv]/conv2d_0" -> "11 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/ConvBlock[dw_conv]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"11 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/ConvBlock[dw_conv]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "12 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/ConvBlock[dw_conv]/SiLU[activ]/silu_0"; +"12 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/ConvBlock[dw_conv]/SiLU[activ]/silu_0" -> "13 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/ConvBlock[dw_conv]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"13 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/ConvBlock[dw_conv]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "14 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0"; +"13 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/ConvBlock[dw_conv]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "24 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/__mul___0"; +"14 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" -> "15 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0"; +"15 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" -> "17 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"16 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "17 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"17 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" -> "18 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/SiLU[activ]/silu_0"; +"18 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/SiLU[activ]/silu_0" -> "19 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"19 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "21 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"20 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "21 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"21 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" -> "22 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0"; +"22 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" -> "23 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0"; +"23 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" -> "24 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/__mul___0"; +"24 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/__mul___0" -> "25 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0"; +"25 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" -> "27 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/ConvBlock[pw_conv]/NNCFConv2d[conv]/conv2d_0"; +"26 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/ConvBlock[pw_conv]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "27 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/ConvBlock[pw_conv]/NNCFConv2d[conv]/conv2d_0"; +"27 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/ConvBlock[pw_conv]/NNCFConv2d[conv]/conv2d_0" -> "28 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/ConvBlock[pw_conv]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"28 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/ConvBlock[pw_conv]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "29 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/ConvBlock[pw_conv]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"29 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/ConvBlock[pw_conv]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "30 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/pad_0"; +"29 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit1]/ConvBlock[pw_conv]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "52 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/__add___0"; +"30 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/pad_0" -> "32 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/ConvBlock[dw_conv]/NNCFConv2d[conv]/conv2d_0"; +"31 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/ConvBlock[dw_conv]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "32 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/ConvBlock[dw_conv]/NNCFConv2d[conv]/conv2d_0"; +"32 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/ConvBlock[dw_conv]/NNCFConv2d[conv]/conv2d_0" -> "33 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/ConvBlock[dw_conv]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"33 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/ConvBlock[dw_conv]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "34 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/ConvBlock[dw_conv]/SiLU[activ]/silu_0"; +"34 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/ConvBlock[dw_conv]/SiLU[activ]/silu_0" -> "35 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/ConvBlock[dw_conv]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"35 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/ConvBlock[dw_conv]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "36 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0"; +"35 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/ConvBlock[dw_conv]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "46 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/__mul___0"; +"36 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" -> "37 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0"; +"37 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" -> "39 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"38 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "39 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"39 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" -> "40 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/SiLU[activ]/silu_0"; +"40 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/SiLU[activ]/silu_0" -> "41 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"41 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "43 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"42 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "43 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"43 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" -> "44 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0"; +"44 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" -> "45 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0"; +"45 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" -> "46 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/__mul___0"; +"46 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/__mul___0" -> "47 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0"; +"47 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" -> "49 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/ConvBlock[pw_conv]/NNCFConv2d[conv]/conv2d_0"; +"48 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/ConvBlock[pw_conv]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "49 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/ConvBlock[pw_conv]/NNCFConv2d[conv]/conv2d_0"; +"49 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/ConvBlock[pw_conv]/NNCFConv2d[conv]/conv2d_0" -> "50 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/ConvBlock[pw_conv]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"50 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/ConvBlock[pw_conv]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "51 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/ConvBlock[pw_conv]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"51 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/ConvBlock[pw_conv]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "52 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/__add___0"; +"52 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/__add___0" -> "53 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SymmetricQuantizer/symmetric_quantize_0"; +"53 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage1]/EffiDwsConvUnit[unit2]/SymmetricQuantizer/symmetric_quantize_0" -> "55 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"54 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "55 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"55 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "56 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"56 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "57 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv1]/SiLU[activ]/silu_0"; +"57 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv1]/SiLU[activ]/silu_0" -> "58 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"58 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "59 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/pad_0"; +"59 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/pad_0" -> "61 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"60 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "61 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"61 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "62 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"62 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "63 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv2]/SiLU[activ]/silu_0"; +"63 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv2]/SiLU[activ]/silu_0" -> "64 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"64 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "65 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0"; +"64 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "75 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/__mul___0"; +"65 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" -> "66 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0"; +"66 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" -> "68 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"67 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "68 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"68 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" -> "69 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/SiLU[activ]/silu_0"; +"69 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/SiLU[activ]/silu_0" -> "70 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"70 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "72 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"71 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "72 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"72 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" -> "73 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0"; +"73 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" -> "74 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0"; +"74 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" -> "75 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/__mul___0"; +"75 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/__mul___0" -> "76 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0"; +"76 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" -> "78 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"77 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "78 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"78 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "79 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"79 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "80 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"80 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "82 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"80 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "108 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/__add___0"; +"81 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "82 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"82 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "83 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"83 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "84 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv1]/SiLU[activ]/silu_0"; +"84 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv1]/SiLU[activ]/silu_0" -> "85 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"85 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "86 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/pad_0"; +"86 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/pad_0" -> "88 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"87 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "88 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"88 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "89 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"89 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "90 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv2]/SiLU[activ]/silu_0"; +"90 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv2]/SiLU[activ]/silu_0" -> "91 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"91 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "92 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0"; +"91 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "102 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/__mul___0"; +"92 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" -> "93 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0"; +"93 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" -> "95 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"94 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "95 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"95 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" -> "96 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/SiLU[activ]/silu_0"; +"96 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/SiLU[activ]/silu_0" -> "97 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"97 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "99 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"98 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "99 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"99 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" -> "100 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0"; +"100 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" -> "101 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0"; +"101 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" -> "102 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/__mul___0"; +"102 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/__mul___0" -> "103 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0"; +"103 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" -> "105 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"104 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "105 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"105 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "106 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"106 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "107 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"107 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "108 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/__add___0"; +"108 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/__add___0" -> "109 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SymmetricQuantizer/symmetric_quantize_0"; +"109 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SymmetricQuantizer/symmetric_quantize_0" -> "111 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"109 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit2]/SymmetricQuantizer/symmetric_quantize_0" -> "137 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/__add___0"; +"110 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "111 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"111 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "112 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"112 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "113 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv1]/SiLU[activ]/silu_0"; +"113 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv1]/SiLU[activ]/silu_0" -> "114 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"114 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "115 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/pad_0"; +"115 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/pad_0" -> "117 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"116 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "117 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"117 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "118 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"118 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "119 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv2]/SiLU[activ]/silu_0"; +"119 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv2]/SiLU[activ]/silu_0" -> "120 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"120 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "121 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0"; +"120 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "131 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/__mul___0"; +"121 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" -> "122 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0"; +"122 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" -> "124 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"123 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "124 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"124 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" -> "125 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/SiLU[activ]/silu_0"; +"125 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/SiLU[activ]/silu_0" -> "126 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"126 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "128 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"127 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "128 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"128 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" -> "129 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0"; +"129 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" -> "130 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0"; +"130 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" -> "131 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/__mul___0"; +"131 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/__mul___0" -> "132 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0"; +"132 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" -> "134 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"133 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "134 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"134 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "135 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"135 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "136 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"136 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "137 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/__add___0"; +"137 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/__add___0" -> "138 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SymmetricQuantizer/symmetric_quantize_0"; +"138 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SymmetricQuantizer/symmetric_quantize_0" -> "140 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"138 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage2]/EffiInvResUnit[unit3]/SymmetricQuantizer/symmetric_quantize_0" -> "652 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0"; +"139 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "140 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"140 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "141 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"141 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "142 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv1]/SiLU[activ]/silu_0"; +"142 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv1]/SiLU[activ]/silu_0" -> "143 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"143 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "144 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/pad_0"; +"144 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/pad_0" -> "146 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"145 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "146 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"146 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "147 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"147 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "148 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv2]/SiLU[activ]/silu_0"; +"148 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv2]/SiLU[activ]/silu_0" -> "149 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"149 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "150 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0"; +"149 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "160 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/__mul___0"; +"150 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" -> "151 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0"; +"151 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" -> "153 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"152 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "153 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"153 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" -> "154 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/SiLU[activ]/silu_0"; +"154 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/SiLU[activ]/silu_0" -> "155 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"155 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "157 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"156 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "157 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"157 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" -> "158 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0"; +"158 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" -> "159 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0"; +"159 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" -> "160 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/__mul___0"; +"160 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/__mul___0" -> "161 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0"; +"161 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" -> "163 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"162 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "163 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"163 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "164 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"164 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "165 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"165 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "167 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"165 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "193 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/__add___0"; +"166 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "167 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"167 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "168 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"168 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "169 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv1]/SiLU[activ]/silu_0"; +"169 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv1]/SiLU[activ]/silu_0" -> "170 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"170 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "171 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/pad_0"; +"171 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/pad_0" -> "173 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"172 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "173 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"173 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "174 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"174 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "175 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv2]/SiLU[activ]/silu_0"; +"175 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv2]/SiLU[activ]/silu_0" -> "176 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"176 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "177 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0"; +"176 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "187 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/__mul___0"; +"177 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" -> "178 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0"; +"178 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" -> "180 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"179 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "180 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"180 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" -> "181 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/SiLU[activ]/silu_0"; +"181 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/SiLU[activ]/silu_0" -> "182 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"182 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "184 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"183 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "184 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"184 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" -> "185 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0"; +"185 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" -> "186 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0"; +"186 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" -> "187 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/__mul___0"; +"187 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/__mul___0" -> "188 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0"; +"188 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" -> "190 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"189 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "190 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"190 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "191 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"191 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "192 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"192 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "193 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/__add___0"; +"193 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/__add___0" -> "194 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SymmetricQuantizer/symmetric_quantize_0"; +"194 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SymmetricQuantizer/symmetric_quantize_0" -> "196 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"194 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit2]/SymmetricQuantizer/symmetric_quantize_0" -> "222 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/__add___0"; +"195 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "196 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"196 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "197 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"197 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "198 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv1]/SiLU[activ]/silu_0"; +"198 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv1]/SiLU[activ]/silu_0" -> "199 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"199 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "200 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/pad_0"; +"200 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/pad_0" -> "202 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"201 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "202 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"202 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "203 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"203 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "204 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv2]/SiLU[activ]/silu_0"; +"204 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv2]/SiLU[activ]/silu_0" -> "205 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"205 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "206 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0"; +"205 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "216 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/__mul___0"; +"206 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" -> "207 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0"; +"207 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" -> "209 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"208 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "209 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"209 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" -> "210 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/SiLU[activ]/silu_0"; +"210 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/SiLU[activ]/silu_0" -> "211 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"211 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "213 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"212 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "213 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"213 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" -> "214 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0"; +"214 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" -> "215 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0"; +"215 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" -> "216 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/__mul___0"; +"216 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/__mul___0" -> "217 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0"; +"217 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" -> "219 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"218 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "219 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"219 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "220 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"220 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "221 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"221 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "222 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/__add___0"; +"222 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/__add___0" -> "223 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SymmetricQuantizer/symmetric_quantize_0"; +"223 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SymmetricQuantizer/symmetric_quantize_0" -> "225 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"223 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage3]/EffiInvResUnit[unit3]/SymmetricQuantizer/symmetric_quantize_0" -> "655 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0"; +"224 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "225 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"225 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "226 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"226 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "227 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv1]/SiLU[activ]/silu_0"; +"227 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv1]/SiLU[activ]/silu_0" -> "228 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"228 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "229 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/pad_0"; +"229 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/pad_0" -> "231 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"230 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "231 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"231 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "232 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"232 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "233 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv2]/SiLU[activ]/silu_0"; +"233 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv2]/SiLU[activ]/silu_0" -> "234 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"234 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "235 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0"; +"234 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "245 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/__mul___0"; +"235 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" -> "236 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0"; +"236 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" -> "238 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"237 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "238 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"238 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" -> "239 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/SiLU[activ]/silu_0"; +"239 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/SiLU[activ]/silu_0" -> "240 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"240 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "242 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"241 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "242 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"242 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" -> "243 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0"; +"243 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" -> "244 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0"; +"244 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" -> "245 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/__mul___0"; +"245 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/__mul___0" -> "246 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0"; +"246 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" -> "248 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"247 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "248 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"248 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "249 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"249 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "250 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"250 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "252 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"250 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "278 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/__add___0"; +"251 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "252 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"252 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "253 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"253 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "254 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv1]/SiLU[activ]/silu_0"; +"254 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv1]/SiLU[activ]/silu_0" -> "255 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"255 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "256 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/pad_0"; +"256 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/pad_0" -> "258 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"257 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "258 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"258 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "259 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"259 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "260 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv2]/SiLU[activ]/silu_0"; +"260 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv2]/SiLU[activ]/silu_0" -> "261 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"261 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "262 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0"; +"261 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "272 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/__mul___0"; +"262 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" -> "263 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0"; +"263 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" -> "265 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"264 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "265 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"265 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" -> "266 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/SiLU[activ]/silu_0"; +"266 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/SiLU[activ]/silu_0" -> "267 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"267 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "269 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"268 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "269 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"269 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" -> "270 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0"; +"270 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" -> "271 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0"; +"271 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" -> "272 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/__mul___0"; +"272 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/__mul___0" -> "273 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0"; +"273 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" -> "275 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"274 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "275 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"275 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "276 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"276 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "277 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"277 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "278 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/__add___0"; +"278 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/__add___0" -> "279 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SymmetricQuantizer/symmetric_quantize_0"; +"279 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SymmetricQuantizer/symmetric_quantize_0" -> "281 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"279 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit2]/SymmetricQuantizer/symmetric_quantize_0" -> "307 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/__add___0"; +"280 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "281 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"281 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "282 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"282 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "283 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv1]/SiLU[activ]/silu_0"; +"283 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv1]/SiLU[activ]/silu_0" -> "284 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"284 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "285 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/pad_0"; +"285 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/pad_0" -> "287 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"286 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "287 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"287 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "288 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"288 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "289 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv2]/SiLU[activ]/silu_0"; +"289 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv2]/SiLU[activ]/silu_0" -> "290 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"290 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "291 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0"; +"290 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "301 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/__mul___0"; +"291 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" -> "292 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0"; +"292 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" -> "294 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"293 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "294 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"294 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" -> "295 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/SiLU[activ]/silu_0"; +"295 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/SiLU[activ]/silu_0" -> "296 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"296 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "298 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"297 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "298 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"298 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" -> "299 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0"; +"299 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" -> "300 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0"; +"300 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" -> "301 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/__mul___0"; +"301 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/__mul___0" -> "302 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0"; +"302 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" -> "304 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"303 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "304 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"304 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "305 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"305 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "306 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"306 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "307 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/__add___0"; +"307 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/__add___0" -> "308 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SymmetricQuantizer/symmetric_quantize_0"; +"308 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SymmetricQuantizer/symmetric_quantize_0" -> "310 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"308 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit3]/SymmetricQuantizer/symmetric_quantize_0" -> "336 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/__add___0"; +"309 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "310 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"310 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "311 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"311 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "312 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv1]/SiLU[activ]/silu_0"; +"312 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv1]/SiLU[activ]/silu_0" -> "313 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"313 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "314 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/pad_0"; +"314 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/pad_0" -> "316 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"315 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "316 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"316 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "317 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"317 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "318 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv2]/SiLU[activ]/silu_0"; +"318 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv2]/SiLU[activ]/silu_0" -> "319 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"319 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "320 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0"; +"319 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "330 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/__mul___0"; +"320 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" -> "321 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0"; +"321 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" -> "323 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"322 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "323 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"323 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" -> "324 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/SiLU[activ]/silu_0"; +"324 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/SiLU[activ]/silu_0" -> "325 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"325 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "327 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"326 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "327 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"327 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" -> "328 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0"; +"328 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" -> "329 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0"; +"329 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" -> "330 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/__mul___0"; +"330 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/__mul___0" -> "331 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0"; +"331 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" -> "333 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"332 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "333 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"333 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "334 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"334 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "335 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"335 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "336 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/__add___0"; +"336 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/__add___0" -> "337 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SymmetricQuantizer/symmetric_quantize_0"; +"337 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit4]/SymmetricQuantizer/symmetric_quantize_0" -> "339 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"338 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "339 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"339 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "340 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"340 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "341 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv1]/SiLU[activ]/silu_0"; +"341 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv1]/SiLU[activ]/silu_0" -> "342 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"342 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "343 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/pad_0"; +"343 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/pad_0" -> "345 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"344 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "345 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"345 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "346 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"346 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "347 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv2]/SiLU[activ]/silu_0"; +"347 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv2]/SiLU[activ]/silu_0" -> "348 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"348 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "349 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0"; +"348 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "359 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/__mul___0"; +"349 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" -> "350 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0"; +"350 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" -> "352 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"351 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "352 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"352 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" -> "353 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/SiLU[activ]/silu_0"; +"353 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/SiLU[activ]/silu_0" -> "354 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"354 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "356 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"355 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "356 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"356 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" -> "357 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0"; +"357 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" -> "358 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0"; +"358 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" -> "359 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/__mul___0"; +"359 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/__mul___0" -> "360 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0"; +"360 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" -> "362 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"361 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "362 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"362 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "363 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"363 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "364 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"364 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "366 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"364 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit5]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "392 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/__add___0"; +"365 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "366 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"366 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "367 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"367 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "368 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv1]/SiLU[activ]/silu_0"; +"368 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv1]/SiLU[activ]/silu_0" -> "369 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"369 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "370 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/pad_0"; +"370 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/pad_0" -> "372 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"371 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "372 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"372 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "373 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"373 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "374 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv2]/SiLU[activ]/silu_0"; +"374 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv2]/SiLU[activ]/silu_0" -> "375 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"375 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "376 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0"; +"375 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "386 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/__mul___0"; +"376 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" -> "377 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0"; +"377 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" -> "379 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"378 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "379 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"379 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" -> "380 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/SiLU[activ]/silu_0"; +"380 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/SiLU[activ]/silu_0" -> "381 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"381 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "383 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"382 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "383 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"383 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" -> "384 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0"; +"384 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" -> "385 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0"; +"385 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" -> "386 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/__mul___0"; +"386 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/__mul___0" -> "387 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0"; +"387 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" -> "389 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"388 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "389 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"389 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "390 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"390 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "391 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"391 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "392 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/__add___0"; +"392 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/__add___0" -> "393 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SymmetricQuantizer/symmetric_quantize_0"; +"393 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SymmetricQuantizer/symmetric_quantize_0" -> "395 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"393 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit6]/SymmetricQuantizer/symmetric_quantize_0" -> "421 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/__add___0"; +"394 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "395 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"395 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "396 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"396 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "397 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv1]/SiLU[activ]/silu_0"; +"397 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv1]/SiLU[activ]/silu_0" -> "398 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"398 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "399 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/pad_0"; +"399 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/pad_0" -> "401 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"400 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "401 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"401 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "402 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"402 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "403 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv2]/SiLU[activ]/silu_0"; +"403 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv2]/SiLU[activ]/silu_0" -> "404 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"404 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "405 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0"; +"404 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "415 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/__mul___0"; +"405 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" -> "406 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0"; +"406 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" -> "408 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"407 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "408 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"408 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" -> "409 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/SiLU[activ]/silu_0"; +"409 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/SiLU[activ]/silu_0" -> "410 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"410 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "412 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"411 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "412 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"412 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" -> "413 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0"; +"413 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" -> "414 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0"; +"414 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" -> "415 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/__mul___0"; +"415 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/__mul___0" -> "416 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0"; +"416 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" -> "418 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"417 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "418 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"418 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "419 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"419 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "420 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"420 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "421 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/__add___0"; +"421 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/__add___0" -> "422 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SymmetricQuantizer/symmetric_quantize_0"; +"422 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SymmetricQuantizer/symmetric_quantize_0" -> "424 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"422 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit7]/SymmetricQuantizer/symmetric_quantize_0" -> "450 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/__add___0"; +"423 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "424 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"424 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "425 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"425 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "426 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv1]/SiLU[activ]/silu_0"; +"426 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv1]/SiLU[activ]/silu_0" -> "427 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"427 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "428 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/pad_0"; +"428 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/pad_0" -> "430 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"429 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "430 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"430 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "431 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"431 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "432 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv2]/SiLU[activ]/silu_0"; +"432 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv2]/SiLU[activ]/silu_0" -> "433 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"433 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "434 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0"; +"433 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "444 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/__mul___0"; +"434 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" -> "435 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0"; +"435 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" -> "437 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"436 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "437 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"437 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" -> "438 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/SiLU[activ]/silu_0"; +"438 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/SiLU[activ]/silu_0" -> "439 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"439 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "441 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"440 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "441 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"441 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" -> "442 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0"; +"442 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" -> "443 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0"; +"443 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" -> "444 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/__mul___0"; +"444 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/__mul___0" -> "445 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0"; +"445 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" -> "447 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"446 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "447 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"447 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "448 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"448 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "449 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"449 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "450 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/__add___0"; +"450 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/__add___0" -> "451 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SymmetricQuantizer/symmetric_quantize_0"; +"451 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SymmetricQuantizer/symmetric_quantize_0" -> "453 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"451 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage4]/EffiInvResUnit[unit8]/SymmetricQuantizer/symmetric_quantize_0" -> "658 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0"; +"452 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "453 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"453 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "454 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"454 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "455 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv1]/SiLU[activ]/silu_0"; +"455 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv1]/SiLU[activ]/silu_0" -> "456 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"456 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "457 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/pad_0"; +"457 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/pad_0" -> "459 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"458 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "459 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"459 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "460 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"460 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "461 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv2]/SiLU[activ]/silu_0"; +"461 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv2]/SiLU[activ]/silu_0" -> "462 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"462 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "463 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0"; +"462 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "473 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/__mul___0"; +"463 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" -> "464 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0"; +"464 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" -> "466 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"465 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "466 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"466 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" -> "467 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/SiLU[activ]/silu_0"; +"467 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/SiLU[activ]/silu_0" -> "468 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"468 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "470 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"469 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "470 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"470 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" -> "471 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0"; +"471 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" -> "472 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0"; +"472 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" -> "473 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/__mul___0"; +"473 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/__mul___0" -> "474 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0"; +"474 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" -> "476 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"475 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "476 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"476 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "477 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"477 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "478 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"478 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "480 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"478 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit1]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "506 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/__add___0"; +"479 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "480 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"480 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "481 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"481 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "482 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv1]/SiLU[activ]/silu_0"; +"482 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv1]/SiLU[activ]/silu_0" -> "483 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"483 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "484 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/pad_0"; +"484 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/pad_0" -> "486 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"485 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "486 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"486 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "487 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"487 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "488 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv2]/SiLU[activ]/silu_0"; +"488 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv2]/SiLU[activ]/silu_0" -> "489 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"489 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "490 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0"; +"489 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "500 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/__mul___0"; +"490 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" -> "491 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0"; +"491 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" -> "493 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"492 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "493 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"493 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" -> "494 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/SiLU[activ]/silu_0"; +"494 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/SiLU[activ]/silu_0" -> "495 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"495 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "497 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"496 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "497 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"497 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" -> "498 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0"; +"498 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" -> "499 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0"; +"499 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" -> "500 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/__mul___0"; +"500 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/__mul___0" -> "501 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0"; +"501 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" -> "503 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"502 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "503 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"503 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "504 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"504 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "505 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"505 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "506 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/__add___0"; +"506 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/__add___0" -> "507 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SymmetricQuantizer/symmetric_quantize_0"; +"507 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SymmetricQuantizer/symmetric_quantize_0" -> "509 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"507 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit2]/SymmetricQuantizer/symmetric_quantize_0" -> "535 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/__add___0"; +"508 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "509 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"509 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "510 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"510 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "511 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv1]/SiLU[activ]/silu_0"; +"511 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv1]/SiLU[activ]/silu_0" -> "512 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"512 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "513 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/pad_0"; +"513 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/pad_0" -> "515 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"514 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "515 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"515 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "516 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"516 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "517 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv2]/SiLU[activ]/silu_0"; +"517 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv2]/SiLU[activ]/silu_0" -> "518 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"518 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "519 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0"; +"518 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "529 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/__mul___0"; +"519 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" -> "520 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0"; +"520 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" -> "522 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"521 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "522 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"522 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" -> "523 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/SiLU[activ]/silu_0"; +"523 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/SiLU[activ]/silu_0" -> "524 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"524 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "526 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"525 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "526 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"526 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" -> "527 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0"; +"527 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" -> "528 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0"; +"528 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" -> "529 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/__mul___0"; +"529 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/__mul___0" -> "530 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0"; +"530 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" -> "532 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"531 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "532 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"532 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "533 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"533 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "534 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"534 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "535 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/__add___0"; +"535 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/__add___0" -> "536 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SymmetricQuantizer/symmetric_quantize_0"; +"536 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SymmetricQuantizer/symmetric_quantize_0" -> "538 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"536 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit3]/SymmetricQuantizer/symmetric_quantize_0" -> "564 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/__add___0"; +"537 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "538 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"538 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "539 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"539 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "540 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv1]/SiLU[activ]/silu_0"; +"540 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv1]/SiLU[activ]/silu_0" -> "541 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"541 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "542 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/pad_0"; +"542 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/pad_0" -> "544 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"543 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "544 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"544 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "545 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"545 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "546 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv2]/SiLU[activ]/silu_0"; +"546 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv2]/SiLU[activ]/silu_0" -> "547 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"547 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "548 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0"; +"547 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "558 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/__mul___0"; +"548 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" -> "549 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0"; +"549 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" -> "551 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"550 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "551 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"551 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" -> "552 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/SiLU[activ]/silu_0"; +"552 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/SiLU[activ]/silu_0" -> "553 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"553 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "555 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"554 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "555 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"555 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" -> "556 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0"; +"556 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" -> "557 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0"; +"557 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" -> "558 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/__mul___0"; +"558 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/__mul___0" -> "559 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0"; +"559 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" -> "561 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"560 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "561 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"561 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "562 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"562 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "563 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"563 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "564 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/__add___0"; +"564 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/__add___0" -> "565 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SymmetricQuantizer/symmetric_quantize_0"; +"565 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SymmetricQuantizer/symmetric_quantize_0" -> "567 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"565 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit4]/SymmetricQuantizer/symmetric_quantize_0" -> "593 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/__add___0"; +"566 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "567 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"567 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "568 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"568 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "569 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv1]/SiLU[activ]/silu_0"; +"569 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv1]/SiLU[activ]/silu_0" -> "570 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"570 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "571 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/pad_0"; +"571 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/pad_0" -> "573 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"572 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "573 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"573 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "574 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"574 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "575 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv2]/SiLU[activ]/silu_0"; +"575 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv2]/SiLU[activ]/silu_0" -> "576 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"576 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "577 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0"; +"576 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "587 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/__mul___0"; +"577 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" -> "578 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0"; +"578 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" -> "580 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"579 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "580 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"580 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" -> "581 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/SiLU[activ]/silu_0"; +"581 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/SiLU[activ]/silu_0" -> "582 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"582 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "584 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"583 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "584 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"584 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" -> "585 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0"; +"585 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" -> "586 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0"; +"586 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" -> "587 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/__mul___0"; +"587 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/__mul___0" -> "588 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0"; +"588 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" -> "590 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"589 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "590 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"590 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "591 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"591 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "592 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"592 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "593 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/__add___0"; +"593 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/__add___0" -> "594 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SymmetricQuantizer/symmetric_quantize_0"; +"594 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit5]/SymmetricQuantizer/symmetric_quantize_0" -> "596 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"595 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "596 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"596 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "597 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"597 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "598 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv1]/SiLU[activ]/silu_0"; +"598 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv1]/SiLU[activ]/silu_0" -> "599 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"599 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "600 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/pad_0"; +"600 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/pad_0" -> "602 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"601 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "602 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"602 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "603 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"603 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "604 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv2]/SiLU[activ]/silu_0"; +"604 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv2]/SiLU[activ]/silu_0" -> "605 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"605 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "606 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0"; +"605 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "616 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/__mul___0"; +"606 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" -> "607 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0"; +"607 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" -> "609 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"608 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "609 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"609 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" -> "610 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/SiLU[activ]/silu_0"; +"610 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/SiLU[activ]/silu_0" -> "611 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"611 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "613 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"612 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "613 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"613 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" -> "614 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0"; +"614 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" -> "615 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0"; +"615 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" -> "616 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/__mul___0"; +"616 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/__mul___0" -> "617 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0"; +"617 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" -> "619 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"618 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "619 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"619 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "620 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"620 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "621 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"621 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "623 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"621 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit6]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "649 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/__add___0"; +"622 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "623 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0"; +"623 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv1]/NNCFConv2d[conv]/conv2d_0" -> "624 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"624 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv1]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "625 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv1]/SiLU[activ]/silu_0"; +"625 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv1]/SiLU[activ]/silu_0" -> "626 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"626 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv1]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "627 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/pad_0"; +"627 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/pad_0" -> "629 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"628 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "629 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0"; +"629 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv2]/NNCFConv2d[conv]/conv2d_0" -> "630 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"630 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv2]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "631 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv2]/SiLU[activ]/silu_0"; +"631 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv2]/SiLU[activ]/silu_0" -> "632 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"632 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "633 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0"; +"632 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv2]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "643 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/__mul___0"; +"633 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/AdaptiveAvgPool2d[pool]/adaptive_avg_pool2d_0" -> "634 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0"; +"634 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/AdaptiveAvgPool2d[pool]/SymmetricQuantizer/symmetric_quantize_0" -> "636 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"635 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "636 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0"; +"636 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/NNCFConv2d[conv1]/conv2d_0" -> "637 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/SiLU[activ]/silu_0"; +"637 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/SiLU[activ]/silu_0" -> "638 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0"; +"638 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/SiLU[activ]/SymmetricQuantizer/symmetric_quantize_0" -> "640 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"639 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "640 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0"; +"640 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/NNCFConv2d[conv2]/conv2d_0" -> "641 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0"; +"641 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/Sigmoid[sigmoid]/sigmoid_0" -> "642 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0"; +"642 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/Sigmoid[sigmoid]/SymmetricQuantizer/symmetric_quantize_0" -> "643 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/__mul___0"; +"643 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/__mul___0" -> "644 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0"; +"644 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SEBlock[se]/SymmetricQuantizer/symmetric_quantize_0" -> "646 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"645 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "646 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0"; +"646 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv3]/NNCFConv2d[conv]/conv2d_0" -> "647 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0"; +"647 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/batch_norm_0" -> "648 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0"; +"648 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/ConvBlock[conv3]/NNCFBatchNorm2d[bn]/SymmetricQuantizer/symmetric_quantize_0" -> "649 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/__add___0"; +"649 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/__add___0" -> "650 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SymmetricQuantizer/symmetric_quantize_0"; +"650 MaskRCNN/efficientnet_b2b[backbone]/Sequential[features]/Sequential[stage5]/EffiInvResUnit[unit7]/SymmetricQuantizer/symmetric_quantize_0" -> "661 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0"; +"651 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "652 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0"; +"652 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" -> "653 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"653 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "673 MaskRCNN/FPN[neck]/__iadd___2"; +"654 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "655 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0"; +"655 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" -> "656 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"656 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "669 MaskRCNN/FPN[neck]/__iadd___1"; +"657 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "658 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0"; +"658 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" -> "659 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"659 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "665 MaskRCNN/FPN[neck]/__iadd___0"; +"660 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "661 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0"; +"661 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" -> "662 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"662 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "663 MaskRCNN/FPN[neck]/interpolate_0"; +"662 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "682 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0"; +"663 MaskRCNN/FPN[neck]/interpolate_0" -> "664 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_0"; +"664 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_0" -> "665 MaskRCNN/FPN[neck]/__iadd___0"; +"665 MaskRCNN/FPN[neck]/__iadd___0" -> "666 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_1"; +"666 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_1" -> "667 MaskRCNN/FPN[neck]/interpolate_1"; +"666 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_1" -> "680 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0"; +"667 MaskRCNN/FPN[neck]/interpolate_1" -> "668 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_2"; +"668 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_2" -> "669 MaskRCNN/FPN[neck]/__iadd___1"; +"669 MaskRCNN/FPN[neck]/__iadd___1" -> "670 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_3"; +"670 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_3" -> "671 MaskRCNN/FPN[neck]/interpolate_2"; +"670 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_3" -> "678 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0"; +"671 MaskRCNN/FPN[neck]/interpolate_2" -> "672 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_4"; +"672 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_4" -> "673 MaskRCNN/FPN[neck]/__iadd___2"; +"673 MaskRCNN/FPN[neck]/__iadd___2" -> "674 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_5"; +"674 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_5" -> "676 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0"; +"675 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "676 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0"; +"676 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" -> "686 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/SymmetricQuantizer/symmetric_quantize_0"; +"676 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" -> "744 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/new_zeros_0"; +"676 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" -> "746 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/new_zeros_1"; +"676 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" -> "747 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/new_zeros_2"; +"676 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" -> "824 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/new_zeros_0"; +"676 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" -> "826 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/new_zeros_1"; +"676 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" -> "827 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/new_zeros_2"; +"677 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "678 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0"; +"678 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" -> "695 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/SymmetricQuantizer/symmetric_quantize_1"; +"678 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" -> "755 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/new_zeros_0"; +"678 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" -> "757 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/new_zeros_1"; +"678 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" -> "758 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/new_zeros_2"; +"678 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" -> "835 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/new_zeros_0"; +"678 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" -> "837 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/new_zeros_1"; +"678 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" -> "838 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/new_zeros_2"; +"679 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "680 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0"; +"680 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" -> "704 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/SymmetricQuantizer/symmetric_quantize_2"; +"680 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" -> "766 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/new_zeros_0"; +"680 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" -> "768 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/new_zeros_1"; +"680 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" -> "769 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/new_zeros_2"; +"680 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" -> "846 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/new_zeros_0"; +"680 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" -> "848 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/new_zeros_1"; +"680 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" -> "849 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/new_zeros_2"; +"681 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "682 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0"; +"682 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" -> "683 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_6"; +"682 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" -> "713 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/SymmetricQuantizer/symmetric_quantize_3"; +"682 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" -> "777 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/new_zeros_0"; +"682 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" -> "779 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/new_zeros_1"; +"682 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" -> "780 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/new_zeros_2"; +"682 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" -> "857 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/new_zeros_0"; +"682 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" -> "859 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/new_zeros_1"; +"682 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" -> "860 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/new_zeros_2"; +"683 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_6" -> "684 MaskRCNN/FPN[neck]/max_pool2d_0"; +"684 MaskRCNN/FPN[neck]/max_pool2d_0" -> "722 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_4"; +"685 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "687 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_0"; +"686 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/SymmetricQuantizer/symmetric_quantize_0" -> "687 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_0"; +"687 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_0" -> "688 MaskRCNN/RPNHead[rpn_head]/relu__0"; +"688 MaskRCNN/RPNHead[rpn_head]/relu__0" -> "689 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_0"; +"689 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_0" -> "691 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/conv2d_0"; +"689 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_0" -> "693 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/conv2d_0"; +"690 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "691 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/conv2d_0"; +"692 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "693 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/conv2d_0"; +"694 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" -> "696 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_1"; +"695 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/SymmetricQuantizer/symmetric_quantize_1" -> "696 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_1"; +"696 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_1" -> "697 MaskRCNN/RPNHead[rpn_head]/relu__1"; +"697 MaskRCNN/RPNHead[rpn_head]/relu__1" -> "698 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_1"; +"698 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_1" -> "700 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/conv2d_1"; +"698 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_1" -> "702 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/conv2d_1"; +"699 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" -> "700 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/conv2d_1"; +"701 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" -> "702 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/conv2d_1"; +"703 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" -> "705 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_2"; +"704 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/SymmetricQuantizer/symmetric_quantize_2" -> "705 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_2"; +"705 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_2" -> "706 MaskRCNN/RPNHead[rpn_head]/relu__2"; +"706 MaskRCNN/RPNHead[rpn_head]/relu__2" -> "707 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_2"; +"707 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_2" -> "709 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/conv2d_2"; +"707 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_2" -> "711 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/conv2d_2"; +"708 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" -> "709 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/conv2d_2"; +"710 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" -> "711 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/conv2d_2"; +"712 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" -> "714 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_3"; +"713 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/SymmetricQuantizer/symmetric_quantize_3" -> "714 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_3"; +"714 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_3" -> "715 MaskRCNN/RPNHead[rpn_head]/relu__3"; +"715 MaskRCNN/RPNHead[rpn_head]/relu__3" -> "716 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_3"; +"716 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_3" -> "718 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/conv2d_3"; +"716 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_3" -> "720 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/conv2d_3"; +"717 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" -> "718 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/conv2d_3"; +"719 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" -> "720 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/conv2d_3"; +"721 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" -> "722 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_4"; +"722 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_4" -> "723 MaskRCNN/RPNHead[rpn_head]/relu__4"; +"723 MaskRCNN/RPNHead[rpn_head]/relu__4" -> "724 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_4"; +"724 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_4" -> "726 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/conv2d_4"; +"724 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_4" -> "728 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/conv2d_4"; +"725 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" -> "726 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/conv2d_4"; +"727 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" -> "728 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/conv2d_4"; +"729 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/sqrt_0" -> "730 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_0"; +"730 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_0" -> "731 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__truediv___0"; +"731 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__truediv___0" -> "732 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_1"; +"732 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_1" -> "733 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__add___0"; +"733 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__add___0" -> "734 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/log2_0"; +"734 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/log2_0" -> "735 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/floor_0"; +"735 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/floor_0" -> "736 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/clamp_0"; +"736 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/clamp_0" -> "737 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/long_0"; +"737 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/long_0" -> "738 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__eq___0"; +"737 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/long_0" -> "749 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__eq___1"; +"737 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/long_0" -> "760 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__eq___2"; +"737 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/long_0" -> "771 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__eq___3"; +"738 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__eq___0" -> "739 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/float_0"; +"739 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/float_0" -> "740 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_2"; +"740 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_2" -> "741 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/unsqueeze_0"; +"741 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/unsqueeze_0" -> "742 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/expand_0"; +"742 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/expand_0" -> "743 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/reshape_0"; +"743 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/reshape_0" -> "748 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__imul___0"; +"744 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/new_zeros_0" -> "745 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/SymmetricQuantizer/symmetric_quantize_0"; +"745 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/SymmetricQuantizer/symmetric_quantize_0" -> "748 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__imul___0"; +"749 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__eq___1" -> "750 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/float_1"; +"750 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/float_1" -> "751 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_3"; +"751 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_3" -> "752 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/unsqueeze_1"; +"752 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/unsqueeze_1" -> "753 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/expand_1"; +"753 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/expand_1" -> "754 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/reshape_1"; +"754 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/reshape_1" -> "759 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__imul___1"; +"755 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/new_zeros_0" -> "756 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/SymmetricQuantizer/symmetric_quantize_0"; +"756 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/SymmetricQuantizer/symmetric_quantize_0" -> "759 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__imul___1"; +"760 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__eq___2" -> "761 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/float_2"; +"761 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/float_2" -> "762 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_4"; +"762 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_4" -> "763 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/unsqueeze_2"; +"763 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/unsqueeze_2" -> "764 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/expand_2"; +"764 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/expand_2" -> "765 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/reshape_2"; +"765 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/reshape_2" -> "770 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__imul___2"; +"766 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/new_zeros_0" -> "767 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/SymmetricQuantizer/symmetric_quantize_0"; +"767 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/SymmetricQuantizer/symmetric_quantize_0" -> "770 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__imul___2"; +"771 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__eq___3" -> "772 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/float_3"; +"772 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/float_3" -> "773 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_5"; +"773 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_5" -> "774 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/unsqueeze_3"; +"774 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/unsqueeze_3" -> "775 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/expand_3"; +"775 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/expand_3" -> "776 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/reshape_3"; +"776 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/reshape_3" -> "781 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__imul___3"; +"777 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/new_zeros_0" -> "778 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/SymmetricQuantizer/symmetric_quantize_0"; +"778 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/SymmetricQuantizer/symmetric_quantize_0" -> "781 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__imul___3"; +"782 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ModuleList[shared_fcs]/NNCFLinear[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "783 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ModuleList[shared_fcs]/NNCFLinear[0]/linear_0"; +"783 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ModuleList[shared_fcs]/NNCFLinear[0]/linear_0" -> "784 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ReLU[relu]/relu__0"; +"784 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ReLU[relu]/relu__0" -> "785 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"785 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "787 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ModuleList[shared_fcs]/NNCFLinear[1]/linear_0"; +"786 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ModuleList[shared_fcs]/NNCFLinear[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "787 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ModuleList[shared_fcs]/NNCFLinear[1]/linear_0"; +"787 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ModuleList[shared_fcs]/NNCFLinear[1]/linear_0" -> "788 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ReLU[relu]/relu__1"; +"788 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ReLU[relu]/relu__1" -> "789 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"789 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "791 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/NNCFLinear[fc_cls]/linear_0"; +"789 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "793 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/NNCFLinear[fc_reg]/linear_0"; +"790 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/NNCFLinear[fc_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "791 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/NNCFLinear[fc_cls]/linear_0"; +"792 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/NNCFLinear[fc_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "793 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/NNCFLinear[fc_reg]/linear_0"; +"794 MaskRCNN/pad_0" -> "795 MaskRCNN/SymmetricQuantizer/symmetric_quantize_0"; +"795 MaskRCNN/SymmetricQuantizer/symmetric_quantize_0" -> "796 MaskRCNN/cat_0"; +"796 MaskRCNN/cat_0" -> "797 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__getitem___0"; +"796 MaskRCNN/cat_0" -> "799 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__getitem___1"; +"796 MaskRCNN/cat_0" -> "800 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__getitem___2"; +"796 MaskRCNN/cat_0" -> "803 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__getitem___3"; +"796 MaskRCNN/cat_0" -> "804 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__getitem___4"; +"797 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__getitem___0" -> "798 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/clone_0"; +"799 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__getitem___1" -> "801 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__sub___0"; +"800 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__getitem___2" -> "801 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__sub___0"; +"801 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__sub___0" -> "802 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_0"; +"802 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_0" -> "807 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__mul___0"; +"803 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__getitem___3" -> "805 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__sub___1"; +"804 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__getitem___4" -> "805 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__sub___1"; +"805 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__sub___1" -> "806 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_1"; +"806 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_1" -> "807 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__mul___0"; +"807 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__mul___0" -> "808 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_2"; +"808 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_2" -> "809 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/sqrt_0"; +"809 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/sqrt_0" -> "810 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_3"; +"810 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_3" -> "811 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__truediv___0"; +"811 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__truediv___0" -> "812 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_4"; +"812 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_4" -> "813 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__add___0"; +"813 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__add___0" -> "814 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/log2_0"; +"814 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/log2_0" -> "815 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/floor_0"; +"815 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/floor_0" -> "816 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/clamp_0"; +"816 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/clamp_0" -> "817 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/long_0"; +"817 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/long_0" -> "818 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__eq___0"; +"817 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/long_0" -> "829 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__eq___1"; +"817 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/long_0" -> "840 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__eq___2"; +"817 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/long_0" -> "851 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__eq___3"; +"818 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__eq___0" -> "819 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/float_0"; +"819 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/float_0" -> "820 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_5"; +"820 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_5" -> "821 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/unsqueeze_0"; +"821 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/unsqueeze_0" -> "822 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/expand_0"; +"822 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/expand_0" -> "823 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/reshape_0"; +"823 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/reshape_0" -> "828 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__imul___0"; +"824 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/new_zeros_0" -> "825 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/SymmetricQuantizer/symmetric_quantize_0"; +"825 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/SymmetricQuantizer/symmetric_quantize_0" -> "828 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__imul___0"; +"829 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__eq___1" -> "830 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/float_1"; +"830 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/float_1" -> "831 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_6"; +"831 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_6" -> "832 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/unsqueeze_1"; +"832 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/unsqueeze_1" -> "833 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/expand_1"; +"833 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/expand_1" -> "834 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/reshape_1"; +"834 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/reshape_1" -> "839 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__imul___1"; +"835 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/new_zeros_0" -> "836 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/SymmetricQuantizer/symmetric_quantize_0"; +"836 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/SymmetricQuantizer/symmetric_quantize_0" -> "839 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__imul___1"; +"840 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__eq___2" -> "841 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/float_2"; +"841 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/float_2" -> "842 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_7"; +"842 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_7" -> "843 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/unsqueeze_2"; +"843 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/unsqueeze_2" -> "844 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/expand_2"; +"844 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/expand_2" -> "845 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/reshape_2"; +"845 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/reshape_2" -> "850 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__imul___2"; +"846 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/new_zeros_0" -> "847 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/SymmetricQuantizer/symmetric_quantize_0"; +"847 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/SymmetricQuantizer/symmetric_quantize_0" -> "850 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__imul___2"; +"851 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__eq___3" -> "852 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/float_3"; +"852 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/float_3" -> "853 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_8"; +"853 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_8" -> "854 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/unsqueeze_3"; +"854 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/unsqueeze_3" -> "855 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/expand_3"; +"855 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/expand_3" -> "856 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/reshape_3"; +"856 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/reshape_3" -> "861 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__imul___3"; +"857 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/new_zeros_0" -> "858 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/SymmetricQuantizer/symmetric_quantize_0"; +"858 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/SymmetricQuantizer/symmetric_quantize_0" -> "861 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__imul___3"; +"862 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "863 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0"; +"863 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" -> "864 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[0]/ReLU[activate]/relu__0"; +"864 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[0]/ReLU[activate]/relu__0" -> "865 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0"; +"865 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" -> "867 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0"; +"866 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "867 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0"; +"867 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" -> "868 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[1]/ReLU[activate]/relu__0"; +"868 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[1]/ReLU[activate]/relu__0" -> "869 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0"; +"869 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" -> "871 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0"; +"870 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "871 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0"; +"871 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" -> "872 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[2]/ReLU[activate]/relu__0"; +"872 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[2]/ReLU[activate]/relu__0" -> "873 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0"; +"873 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" -> "875 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0"; +"874 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "875 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0"; +"875 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" -> "876 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[3]/ReLU[activate]/relu__0"; +"876 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[3]/ReLU[activate]/relu__0" -> "877 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0"; +"877 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" -> "879 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/NNCFConvTranspose2d[upsample]/conv_transpose2d_0"; +"878 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/NNCFConvTranspose2d[upsample]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "879 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/NNCFConvTranspose2d[upsample]/conv_transpose2d_0"; +"879 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/NNCFConvTranspose2d[upsample]/conv_transpose2d_0" -> "880 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ReLU[relu]/relu__0"; +"880 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ReLU[relu]/relu__0" -> "881 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"881 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "883 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/NNCFConv2d[conv_logits]/conv2d_0"; +"882 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/NNCFConv2d[conv_logits]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "883 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/NNCFConv2d[conv_logits]/conv2d_0"; +"883 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/NNCFConv2d[conv_logits]/conv2d_0" -> "884 MaskRCNN/__getitem___0"; +"884 MaskRCNN/__getitem___0" -> "885 MaskRCNN/sigmoid_0"; +} diff --git a/external/mmdetection/tests/reference/Custom_Counting_Instance_Segmentation_MaskRCNN_ResNet50/nncf/nncf_quantization.dot b/external/mmdetection/tests/reference/Custom_Counting_Instance_Segmentation_MaskRCNN_ResNet50/nncf/nncf_quantization.dot new file mode 100644 index 00000000000..ec613cf263d --- /dev/null +++ b/external/mmdetection/tests/reference/Custom_Counting_Instance_Segmentation_MaskRCNN_ResNet50/nncf/nncf_quantization.dot @@ -0,0 +1,1089 @@ +strict digraph { +"0 /nncf_model_input_0" [id=0, type=nncf_model_input]; +"1 SymmetricQuantizer/symmetric_quantize_0" [id=1, type=symmetric_quantize]; +"2 MaskRCNN/ResNet[backbone]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=2, type=symmetric_quantize]; +"3 MaskRCNN/ResNet[backbone]/NNCFConv2d[conv1]/conv2d_0" [id=3, type=conv2d]; +"4 MaskRCNN/ResNet[backbone]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=4, type=batch_norm]; +"5 MaskRCNN/ResNet[backbone]/ReLU[relu]/relu__0" [id=5, type=relu_]; +"6 MaskRCNN/ResNet[backbone]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=6, type=symmetric_quantize]; +"7 MaskRCNN/ResNet[backbone]/MaxPool2d[maxpool]/max_pool2d_0" [id=7, type=max_pool2d]; +"8 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=8, type=symmetric_quantize]; +"9 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" [id=9, type=conv2d]; +"10 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=10, type=batch_norm]; +"11 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/relu__0" [id=11, type=relu_]; +"12 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=12, type=symmetric_quantize]; +"13 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=13, type=symmetric_quantize]; +"14 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" [id=14, type=conv2d]; +"15 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=15, type=batch_norm]; +"16 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/relu__1" [id=16, type=relu_]; +"17 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=17, type=symmetric_quantize]; +"18 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=18, type=symmetric_quantize]; +"19 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0" [id=19, type=conv2d]; +"20 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=20, type=batch_norm]; +"21 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=21, type=symmetric_quantize]; +"22 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=22, type=symmetric_quantize]; +"23 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0" [id=23, type=conv2d]; +"24 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm2d[1]/batch_norm_0" [id=24, type=batch_norm]; +"25 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=25, type=symmetric_quantize]; +"26 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/__iadd___0" [id=26, type=__iadd__]; +"27 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/relu__2" [id=27, type=relu_]; +"28 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=28, type=symmetric_quantize]; +"29 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=29, type=symmetric_quantize]; +"30 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" [id=30, type=conv2d]; +"31 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=31, type=batch_norm]; +"32 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/relu__0" [id=32, type=relu_]; +"33 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=33, type=symmetric_quantize]; +"34 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=34, type=symmetric_quantize]; +"35 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" [id=35, type=conv2d]; +"36 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=36, type=batch_norm]; +"37 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/relu__1" [id=37, type=relu_]; +"38 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=38, type=symmetric_quantize]; +"39 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=39, type=symmetric_quantize]; +"40 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0" [id=40, type=conv2d]; +"41 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=41, type=batch_norm]; +"42 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=42, type=symmetric_quantize]; +"43 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/__iadd___0" [id=43, type=__iadd__]; +"44 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/relu__2" [id=44, type=relu_]; +"45 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=45, type=symmetric_quantize]; +"46 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=46, type=symmetric_quantize]; +"47 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" [id=47, type=conv2d]; +"48 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=48, type=batch_norm]; +"49 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/relu__0" [id=49, type=relu_]; +"50 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=50, type=symmetric_quantize]; +"51 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=51, type=symmetric_quantize]; +"52 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" [id=52, type=conv2d]; +"53 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=53, type=batch_norm]; +"54 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/relu__1" [id=54, type=relu_]; +"55 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=55, type=symmetric_quantize]; +"56 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=56, type=symmetric_quantize]; +"57 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0" [id=57, type=conv2d]; +"58 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=58, type=batch_norm]; +"59 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=59, type=symmetric_quantize]; +"60 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/__iadd___0" [id=60, type=__iadd__]; +"61 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/relu__2" [id=61, type=relu_]; +"62 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=62, type=symmetric_quantize]; +"63 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=63, type=symmetric_quantize]; +"64 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" [id=64, type=conv2d]; +"65 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=65, type=batch_norm]; +"66 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/relu__0" [id=66, type=relu_]; +"67 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=67, type=symmetric_quantize]; +"68 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=68, type=symmetric_quantize]; +"69 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" [id=69, type=conv2d]; +"70 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=70, type=batch_norm]; +"71 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/relu__1" [id=71, type=relu_]; +"72 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=72, type=symmetric_quantize]; +"73 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=73, type=symmetric_quantize]; +"74 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0" [id=74, type=conv2d]; +"75 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=75, type=batch_norm]; +"76 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=76, type=symmetric_quantize]; +"77 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=77, type=symmetric_quantize]; +"78 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0" [id=78, type=conv2d]; +"79 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm2d[1]/batch_norm_0" [id=79, type=batch_norm]; +"80 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=80, type=symmetric_quantize]; +"81 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/__iadd___0" [id=81, type=__iadd__]; +"82 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/relu__2" [id=82, type=relu_]; +"83 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=83, type=symmetric_quantize]; +"84 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=84, type=symmetric_quantize]; +"85 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" [id=85, type=conv2d]; +"86 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=86, type=batch_norm]; +"87 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/relu__0" [id=87, type=relu_]; +"88 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=88, type=symmetric_quantize]; +"89 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=89, type=symmetric_quantize]; +"90 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" [id=90, type=conv2d]; +"91 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=91, type=batch_norm]; +"92 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/relu__1" [id=92, type=relu_]; +"93 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=93, type=symmetric_quantize]; +"94 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=94, type=symmetric_quantize]; +"95 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0" [id=95, type=conv2d]; +"96 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=96, type=batch_norm]; +"97 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=97, type=symmetric_quantize]; +"98 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/__iadd___0" [id=98, type=__iadd__]; +"99 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/relu__2" [id=99, type=relu_]; +"100 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=100, type=symmetric_quantize]; +"101 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=101, type=symmetric_quantize]; +"102 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" [id=102, type=conv2d]; +"103 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=103, type=batch_norm]; +"104 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/relu__0" [id=104, type=relu_]; +"105 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=105, type=symmetric_quantize]; +"106 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=106, type=symmetric_quantize]; +"107 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" [id=107, type=conv2d]; +"108 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=108, type=batch_norm]; +"109 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/relu__1" [id=109, type=relu_]; +"110 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=110, type=symmetric_quantize]; +"111 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=111, type=symmetric_quantize]; +"112 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0" [id=112, type=conv2d]; +"113 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=113, type=batch_norm]; +"114 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=114, type=symmetric_quantize]; +"115 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/__iadd___0" [id=115, type=__iadd__]; +"116 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/relu__2" [id=116, type=relu_]; +"117 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=117, type=symmetric_quantize]; +"118 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=118, type=symmetric_quantize]; +"119 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0" [id=119, type=conv2d]; +"120 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=120, type=batch_norm]; +"121 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/relu__0" [id=121, type=relu_]; +"122 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=122, type=symmetric_quantize]; +"123 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=123, type=symmetric_quantize]; +"124 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0" [id=124, type=conv2d]; +"125 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=125, type=batch_norm]; +"126 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/relu__1" [id=126, type=relu_]; +"127 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=127, type=symmetric_quantize]; +"128 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=128, type=symmetric_quantize]; +"129 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d_0" [id=129, type=conv2d]; +"130 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=130, type=batch_norm]; +"131 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=131, type=symmetric_quantize]; +"132 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/__iadd___0" [id=132, type=__iadd__]; +"133 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/relu__2" [id=133, type=relu_]; +"134 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=134, type=symmetric_quantize]; +"135 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=135, type=symmetric_quantize]; +"136 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" [id=136, type=conv2d]; +"137 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=137, type=batch_norm]; +"138 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/relu__0" [id=138, type=relu_]; +"139 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=139, type=symmetric_quantize]; +"140 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=140, type=symmetric_quantize]; +"141 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" [id=141, type=conv2d]; +"142 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=142, type=batch_norm]; +"143 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/relu__1" [id=143, type=relu_]; +"144 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=144, type=symmetric_quantize]; +"145 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=145, type=symmetric_quantize]; +"146 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0" [id=146, type=conv2d]; +"147 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=147, type=batch_norm]; +"148 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=148, type=symmetric_quantize]; +"149 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=149, type=symmetric_quantize]; +"150 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0" [id=150, type=conv2d]; +"151 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm2d[1]/batch_norm_0" [id=151, type=batch_norm]; +"152 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=152, type=symmetric_quantize]; +"153 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/__iadd___0" [id=153, type=__iadd__]; +"154 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/relu__2" [id=154, type=relu_]; +"155 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=155, type=symmetric_quantize]; +"156 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=156, type=symmetric_quantize]; +"157 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" [id=157, type=conv2d]; +"158 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=158, type=batch_norm]; +"159 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/relu__0" [id=159, type=relu_]; +"160 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=160, type=symmetric_quantize]; +"161 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=161, type=symmetric_quantize]; +"162 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" [id=162, type=conv2d]; +"163 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=163, type=batch_norm]; +"164 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/relu__1" [id=164, type=relu_]; +"165 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=165, type=symmetric_quantize]; +"166 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=166, type=symmetric_quantize]; +"167 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0" [id=167, type=conv2d]; +"168 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=168, type=batch_norm]; +"169 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=169, type=symmetric_quantize]; +"170 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/__iadd___0" [id=170, type=__iadd__]; +"171 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/relu__2" [id=171, type=relu_]; +"172 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=172, type=symmetric_quantize]; +"173 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=173, type=symmetric_quantize]; +"174 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" [id=174, type=conv2d]; +"175 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=175, type=batch_norm]; +"176 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/relu__0" [id=176, type=relu_]; +"177 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=177, type=symmetric_quantize]; +"178 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=178, type=symmetric_quantize]; +"179 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" [id=179, type=conv2d]; +"180 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=180, type=batch_norm]; +"181 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/relu__1" [id=181, type=relu_]; +"182 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=182, type=symmetric_quantize]; +"183 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=183, type=symmetric_quantize]; +"184 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0" [id=184, type=conv2d]; +"185 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=185, type=batch_norm]; +"186 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=186, type=symmetric_quantize]; +"187 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/__iadd___0" [id=187, type=__iadd__]; +"188 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/relu__2" [id=188, type=relu_]; +"189 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=189, type=symmetric_quantize]; +"190 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=190, type=symmetric_quantize]; +"191 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0" [id=191, type=conv2d]; +"192 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=192, type=batch_norm]; +"193 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/relu__0" [id=193, type=relu_]; +"194 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=194, type=symmetric_quantize]; +"195 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=195, type=symmetric_quantize]; +"196 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0" [id=196, type=conv2d]; +"197 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=197, type=batch_norm]; +"198 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/relu__1" [id=198, type=relu_]; +"199 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=199, type=symmetric_quantize]; +"200 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=200, type=symmetric_quantize]; +"201 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d_0" [id=201, type=conv2d]; +"202 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=202, type=batch_norm]; +"203 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=203, type=symmetric_quantize]; +"204 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/__iadd___0" [id=204, type=__iadd__]; +"205 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/relu__2" [id=205, type=relu_]; +"206 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=206, type=symmetric_quantize]; +"207 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=207, type=symmetric_quantize]; +"208 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d_0" [id=208, type=conv2d]; +"209 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=209, type=batch_norm]; +"210 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/relu__0" [id=210, type=relu_]; +"211 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=211, type=symmetric_quantize]; +"212 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=212, type=symmetric_quantize]; +"213 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d_0" [id=213, type=conv2d]; +"214 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=214, type=batch_norm]; +"215 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/relu__1" [id=215, type=relu_]; +"216 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=216, type=symmetric_quantize]; +"217 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=217, type=symmetric_quantize]; +"218 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d_0" [id=218, type=conv2d]; +"219 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=219, type=batch_norm]; +"220 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=220, type=symmetric_quantize]; +"221 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/__iadd___0" [id=221, type=__iadd__]; +"222 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/relu__2" [id=222, type=relu_]; +"223 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=223, type=symmetric_quantize]; +"224 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=224, type=symmetric_quantize]; +"225 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d_0" [id=225, type=conv2d]; +"226 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=226, type=batch_norm]; +"227 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/relu__0" [id=227, type=relu_]; +"228 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=228, type=symmetric_quantize]; +"229 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=229, type=symmetric_quantize]; +"230 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d_0" [id=230, type=conv2d]; +"231 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=231, type=batch_norm]; +"232 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/relu__1" [id=232, type=relu_]; +"233 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=233, type=symmetric_quantize]; +"234 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=234, type=symmetric_quantize]; +"235 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d_0" [id=235, type=conv2d]; +"236 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=236, type=batch_norm]; +"237 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=237, type=symmetric_quantize]; +"238 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/__iadd___0" [id=238, type=__iadd__]; +"239 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/relu__2" [id=239, type=relu_]; +"240 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=240, type=symmetric_quantize]; +"241 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=241, type=symmetric_quantize]; +"242 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" [id=242, type=conv2d]; +"243 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=243, type=batch_norm]; +"244 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/relu__0" [id=244, type=relu_]; +"245 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=245, type=symmetric_quantize]; +"246 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=246, type=symmetric_quantize]; +"247 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" [id=247, type=conv2d]; +"248 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=248, type=batch_norm]; +"249 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/relu__1" [id=249, type=relu_]; +"250 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=250, type=symmetric_quantize]; +"251 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=251, type=symmetric_quantize]; +"252 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0" [id=252, type=conv2d]; +"253 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=253, type=batch_norm]; +"254 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=254, type=symmetric_quantize]; +"255 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=255, type=symmetric_quantize]; +"256 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0" [id=256, type=conv2d]; +"257 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm2d[1]/batch_norm_0" [id=257, type=batch_norm]; +"258 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" [id=258, type=symmetric_quantize]; +"259 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/__iadd___0" [id=259, type=__iadd__]; +"260 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/relu__2" [id=260, type=relu_]; +"261 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=261, type=symmetric_quantize]; +"262 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=262, type=symmetric_quantize]; +"263 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" [id=263, type=conv2d]; +"264 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=264, type=batch_norm]; +"265 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/relu__0" [id=265, type=relu_]; +"266 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=266, type=symmetric_quantize]; +"267 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=267, type=symmetric_quantize]; +"268 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" [id=268, type=conv2d]; +"269 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=269, type=batch_norm]; +"270 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/relu__1" [id=270, type=relu_]; +"271 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=271, type=symmetric_quantize]; +"272 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=272, type=symmetric_quantize]; +"273 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0" [id=273, type=conv2d]; +"274 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=274, type=batch_norm]; +"275 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=275, type=symmetric_quantize]; +"276 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/__iadd___0" [id=276, type=__iadd__]; +"277 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/relu__2" [id=277, type=relu_]; +"278 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=278, type=symmetric_quantize]; +"279 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=279, type=symmetric_quantize]; +"280 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" [id=280, type=conv2d]; +"281 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0" [id=281, type=batch_norm]; +"282 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/relu__0" [id=282, type=relu_]; +"283 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=283, type=symmetric_quantize]; +"284 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=284, type=symmetric_quantize]; +"285 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" [id=285, type=conv2d]; +"286 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0" [id=286, type=batch_norm]; +"287 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/relu__1" [id=287, type=relu_]; +"288 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=288, type=symmetric_quantize]; +"289 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=289, type=symmetric_quantize]; +"290 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0" [id=290, type=conv2d]; +"291 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/batch_norm_0" [id=291, type=batch_norm]; +"292 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" [id=292, type=symmetric_quantize]; +"293 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/__iadd___0" [id=293, type=__iadd__]; +"294 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/relu__2" [id=294, type=relu_]; +"295 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" [id=295, type=symmetric_quantize]; +"296 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=296, type=symmetric_quantize]; +"297 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" [id=297, type=conv2d]; +"298 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=298, type=symmetric_quantize]; +"299 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=299, type=symmetric_quantize]; +"300 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" [id=300, type=conv2d]; +"301 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=301, type=symmetric_quantize]; +"302 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=302, type=symmetric_quantize]; +"303 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" [id=303, type=conv2d]; +"304 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=304, type=symmetric_quantize]; +"305 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=305, type=symmetric_quantize]; +"306 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" [id=306, type=conv2d]; +"307 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" [id=307, type=symmetric_quantize]; +"308 MaskRCNN/FPN[neck]/interpolate_0" [id=308, type=interpolate]; +"309 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_0" [id=309, type=symmetric_quantize]; +"310 MaskRCNN/FPN[neck]/__iadd___0" [id=310, type=__iadd__]; +"311 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_1" [id=311, type=symmetric_quantize]; +"312 MaskRCNN/FPN[neck]/interpolate_1" [id=312, type=interpolate]; +"313 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_2" [id=313, type=symmetric_quantize]; +"314 MaskRCNN/FPN[neck]/__iadd___1" [id=314, type=__iadd__]; +"315 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_3" [id=315, type=symmetric_quantize]; +"316 MaskRCNN/FPN[neck]/interpolate_2" [id=316, type=interpolate]; +"317 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_4" [id=317, type=symmetric_quantize]; +"318 MaskRCNN/FPN[neck]/__iadd___2" [id=318, type=__iadd__]; +"319 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_5" [id=319, type=symmetric_quantize]; +"320 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=320, type=symmetric_quantize]; +"321 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" [id=321, type=conv2d]; +"322 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=322, type=symmetric_quantize]; +"323 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" [id=323, type=conv2d]; +"324 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=324, type=symmetric_quantize]; +"325 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" [id=325, type=conv2d]; +"326 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=326, type=symmetric_quantize]; +"327 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" [id=327, type=conv2d]; +"328 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_6" [id=328, type=symmetric_quantize]; +"329 MaskRCNN/FPN[neck]/max_pool2d_0" [id=329, type=max_pool2d]; +"330 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=330, type=symmetric_quantize]; +"331 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/SymmetricQuantizer/symmetric_quantize_0" [id=331, type=symmetric_quantize]; +"332 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_0" [id=332, type=conv2d]; +"333 MaskRCNN/RPNHead[rpn_head]/relu__0" [id=333, type=relu_]; +"334 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_0" [id=334, type=symmetric_quantize]; +"335 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=335, type=symmetric_quantize]; +"336 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/conv2d_0" [id=336, type=conv2d]; +"337 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=337, type=symmetric_quantize]; +"338 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/conv2d_0" [id=338, type=conv2d]; +"339 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" [id=339, type=symmetric_quantize]; +"340 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/SymmetricQuantizer/symmetric_quantize_1" [id=340, type=symmetric_quantize]; +"341 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_1" [id=341, type=conv2d]; +"342 MaskRCNN/RPNHead[rpn_head]/relu__1" [id=342, type=relu_]; +"343 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_1" [id=343, type=symmetric_quantize]; +"344 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" [id=344, type=symmetric_quantize]; +"345 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/conv2d_1" [id=345, type=conv2d]; +"346 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" [id=346, type=symmetric_quantize]; +"347 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/conv2d_1" [id=347, type=conv2d]; +"348 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" [id=348, type=symmetric_quantize]; +"349 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/SymmetricQuantizer/symmetric_quantize_2" [id=349, type=symmetric_quantize]; +"350 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_2" [id=350, type=conv2d]; +"351 MaskRCNN/RPNHead[rpn_head]/relu__2" [id=351, type=relu_]; +"352 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_2" [id=352, type=symmetric_quantize]; +"353 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" [id=353, type=symmetric_quantize]; +"354 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/conv2d_2" [id=354, type=conv2d]; +"355 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" [id=355, type=symmetric_quantize]; +"356 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/conv2d_2" [id=356, type=conv2d]; +"357 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" [id=357, type=symmetric_quantize]; +"358 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/SymmetricQuantizer/symmetric_quantize_3" [id=358, type=symmetric_quantize]; +"359 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_3" [id=359, type=conv2d]; +"360 MaskRCNN/RPNHead[rpn_head]/relu__3" [id=360, type=relu_]; +"361 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_3" [id=361, type=symmetric_quantize]; +"362 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" [id=362, type=symmetric_quantize]; +"363 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/conv2d_3" [id=363, type=conv2d]; +"364 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" [id=364, type=symmetric_quantize]; +"365 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/conv2d_3" [id=365, type=conv2d]; +"366 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" [id=366, type=symmetric_quantize]; +"367 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_4" [id=367, type=conv2d]; +"368 MaskRCNN/RPNHead[rpn_head]/relu__4" [id=368, type=relu_]; +"369 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_4" [id=369, type=symmetric_quantize]; +"370 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" [id=370, type=symmetric_quantize]; +"371 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/conv2d_4" [id=371, type=conv2d]; +"372 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" [id=372, type=symmetric_quantize]; +"373 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/conv2d_4" [id=373, type=conv2d]; +"374 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/sqrt_0" [id=374, type=sqrt]; +"375 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_0" [id=375, type=symmetric_quantize]; +"376 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__truediv___0" [id=376, type=__truediv__]; +"377 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_1" [id=377, type=symmetric_quantize]; +"378 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__add___0" [id=378, type=__add__]; +"379 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/log2_0" [id=379, type=log2]; +"380 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/floor_0" [id=380, type=floor]; +"381 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/clamp_0" [id=381, type=clamp]; +"382 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/long_0" [id=382, type=long]; +"383 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__eq___0" [id=383, type=__eq__]; +"384 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/float_0" [id=384, type=float]; +"385 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_2" [id=385, type=symmetric_quantize]; +"386 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/unsqueeze_0" [id=386, type=unsqueeze]; +"387 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/expand_0" [id=387, type=expand]; +"388 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/reshape_0" [id=388, type=reshape]; +"389 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/new_zeros_0" [id=389, type=new_zeros]; +"390 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/SymmetricQuantizer/symmetric_quantize_0" [id=390, type=symmetric_quantize]; +"391 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/new_zeros_1" [id=391, type=new_zeros]; +"392 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/new_zeros_2" [id=392, type=new_zeros]; +"393 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__imul___0" [id=393, type=__imul__]; +"394 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__eq___1" [id=394, type=__eq__]; +"395 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/float_1" [id=395, type=float]; +"396 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_3" [id=396, type=symmetric_quantize]; +"397 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/unsqueeze_1" [id=397, type=unsqueeze]; +"398 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/expand_1" [id=398, type=expand]; +"399 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/reshape_1" [id=399, type=reshape]; +"400 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/new_zeros_0" [id=400, type=new_zeros]; +"401 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/SymmetricQuantizer/symmetric_quantize_0" [id=401, type=symmetric_quantize]; +"402 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/new_zeros_1" [id=402, type=new_zeros]; +"403 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/new_zeros_2" [id=403, type=new_zeros]; +"404 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__imul___1" [id=404, type=__imul__]; +"405 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__eq___2" [id=405, type=__eq__]; +"406 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/float_2" [id=406, type=float]; +"407 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_4" [id=407, type=symmetric_quantize]; +"408 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/unsqueeze_2" [id=408, type=unsqueeze]; +"409 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/expand_2" [id=409, type=expand]; +"410 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/reshape_2" [id=410, type=reshape]; +"411 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/new_zeros_0" [id=411, type=new_zeros]; +"412 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/SymmetricQuantizer/symmetric_quantize_0" [id=412, type=symmetric_quantize]; +"413 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/new_zeros_1" [id=413, type=new_zeros]; +"414 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/new_zeros_2" [id=414, type=new_zeros]; +"415 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__imul___2" [id=415, type=__imul__]; +"416 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__eq___3" [id=416, type=__eq__]; +"417 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/float_3" [id=417, type=float]; +"418 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_5" [id=418, type=symmetric_quantize]; +"419 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/unsqueeze_3" [id=419, type=unsqueeze]; +"420 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/expand_3" [id=420, type=expand]; +"421 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/reshape_3" [id=421, type=reshape]; +"422 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/new_zeros_0" [id=422, type=new_zeros]; +"423 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/SymmetricQuantizer/symmetric_quantize_0" [id=423, type=symmetric_quantize]; +"424 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/new_zeros_1" [id=424, type=new_zeros]; +"425 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/new_zeros_2" [id=425, type=new_zeros]; +"426 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__imul___3" [id=426, type=__imul__]; +"427 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ModuleList[shared_fcs]/NNCFLinear[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=427, type=symmetric_quantize]; +"428 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ModuleList[shared_fcs]/NNCFLinear[0]/linear_0" [id=428, type=linear]; +"429 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ReLU[relu]/relu__0" [id=429, type=relu_]; +"430 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=430, type=symmetric_quantize]; +"431 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ModuleList[shared_fcs]/NNCFLinear[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=431, type=symmetric_quantize]; +"432 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ModuleList[shared_fcs]/NNCFLinear[1]/linear_0" [id=432, type=linear]; +"433 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ReLU[relu]/relu__1" [id=433, type=relu_]; +"434 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" [id=434, type=symmetric_quantize]; +"435 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/NNCFLinear[fc_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=435, type=symmetric_quantize]; +"436 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/NNCFLinear[fc_cls]/linear_0" [id=436, type=linear]; +"437 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/NNCFLinear[fc_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=437, type=symmetric_quantize]; +"438 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/NNCFLinear[fc_reg]/linear_0" [id=438, type=linear]; +"439 MaskRCNN/pad_0" [id=439, type=pad]; +"440 MaskRCNN/SymmetricQuantizer/symmetric_quantize_0" [id=440, type=symmetric_quantize]; +"441 MaskRCNN/cat_0" [id=441, type=cat]; +"442 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__getitem___0" [id=442, type=__getitem__]; +"443 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/clone_0" [id=443, type=clone]; +"444 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__getitem___1" [id=444, type=__getitem__]; +"445 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__getitem___2" [id=445, type=__getitem__]; +"446 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__sub___0" [id=446, type=__sub__]; +"447 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_0" [id=447, type=symmetric_quantize]; +"448 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__getitem___3" [id=448, type=__getitem__]; +"449 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__getitem___4" [id=449, type=__getitem__]; +"450 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__sub___1" [id=450, type=__sub__]; +"451 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_1" [id=451, type=symmetric_quantize]; +"452 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__mul___0" [id=452, type=__mul__]; +"453 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_2" [id=453, type=symmetric_quantize]; +"454 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/sqrt_0" [id=454, type=sqrt]; +"455 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_3" [id=455, type=symmetric_quantize]; +"456 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__truediv___0" [id=456, type=__truediv__]; +"457 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_4" [id=457, type=symmetric_quantize]; +"458 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__add___0" [id=458, type=__add__]; +"459 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/log2_0" [id=459, type=log2]; +"460 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/floor_0" [id=460, type=floor]; +"461 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/clamp_0" [id=461, type=clamp]; +"462 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/long_0" [id=462, type=long]; +"463 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__eq___0" [id=463, type=__eq__]; +"464 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/float_0" [id=464, type=float]; +"465 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_5" [id=465, type=symmetric_quantize]; +"466 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/unsqueeze_0" [id=466, type=unsqueeze]; +"467 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/expand_0" [id=467, type=expand]; +"468 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/reshape_0" [id=468, type=reshape]; +"469 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/new_zeros_0" [id=469, type=new_zeros]; +"470 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/SymmetricQuantizer/symmetric_quantize_0" [id=470, type=symmetric_quantize]; +"471 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/new_zeros_1" [id=471, type=new_zeros]; +"472 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/new_zeros_2" [id=472, type=new_zeros]; +"473 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__imul___0" [id=473, type=__imul__]; +"474 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__eq___1" [id=474, type=__eq__]; +"475 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/float_1" [id=475, type=float]; +"476 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_6" [id=476, type=symmetric_quantize]; +"477 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/unsqueeze_1" [id=477, type=unsqueeze]; +"478 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/expand_1" [id=478, type=expand]; +"479 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/reshape_1" [id=479, type=reshape]; +"480 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/new_zeros_0" [id=480, type=new_zeros]; +"481 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/SymmetricQuantizer/symmetric_quantize_0" [id=481, type=symmetric_quantize]; +"482 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/new_zeros_1" [id=482, type=new_zeros]; +"483 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/new_zeros_2" [id=483, type=new_zeros]; +"484 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__imul___1" [id=484, type=__imul__]; +"485 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__eq___2" [id=485, type=__eq__]; +"486 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/float_2" [id=486, type=float]; +"487 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_7" [id=487, type=symmetric_quantize]; +"488 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/unsqueeze_2" [id=488, type=unsqueeze]; +"489 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/expand_2" [id=489, type=expand]; +"490 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/reshape_2" [id=490, type=reshape]; +"491 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/new_zeros_0" [id=491, type=new_zeros]; +"492 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/SymmetricQuantizer/symmetric_quantize_0" [id=492, type=symmetric_quantize]; +"493 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/new_zeros_1" [id=493, type=new_zeros]; +"494 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/new_zeros_2" [id=494, type=new_zeros]; +"495 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__imul___2" [id=495, type=__imul__]; +"496 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__eq___3" [id=496, type=__eq__]; +"497 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/float_3" [id=497, type=float]; +"498 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_8" [id=498, type=symmetric_quantize]; +"499 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/unsqueeze_3" [id=499, type=unsqueeze]; +"500 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/expand_3" [id=500, type=expand]; +"501 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/reshape_3" [id=501, type=reshape]; +"502 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/new_zeros_0" [id=502, type=new_zeros]; +"503 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/SymmetricQuantizer/symmetric_quantize_0" [id=503, type=symmetric_quantize]; +"504 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/new_zeros_1" [id=504, type=new_zeros]; +"505 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/new_zeros_2" [id=505, type=new_zeros]; +"506 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__imul___3" [id=506, type=__imul__]; +"507 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=507, type=symmetric_quantize]; +"508 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" [id=508, type=conv2d]; +"509 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[0]/ReLU[activate]/relu__0" [id=509, type=relu_]; +"510 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" [id=510, type=symmetric_quantize]; +"511 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=511, type=symmetric_quantize]; +"512 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" [id=512, type=conv2d]; +"513 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[1]/ReLU[activate]/relu__0" [id=513, type=relu_]; +"514 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" [id=514, type=symmetric_quantize]; +"515 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=515, type=symmetric_quantize]; +"516 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" [id=516, type=conv2d]; +"517 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[2]/ReLU[activate]/relu__0" [id=517, type=relu_]; +"518 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" [id=518, type=symmetric_quantize]; +"519 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=519, type=symmetric_quantize]; +"520 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" [id=520, type=conv2d]; +"521 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[3]/ReLU[activate]/relu__0" [id=521, type=relu_]; +"522 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" [id=522, type=symmetric_quantize]; +"523 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/NNCFConvTranspose2d[upsample]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=523, type=symmetric_quantize]; +"524 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/NNCFConvTranspose2d[upsample]/conv_transpose2d_0" [id=524, type=conv_transpose2d]; +"525 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ReLU[relu]/relu__0" [id=525, type=relu_]; +"526 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" [id=526, type=symmetric_quantize]; +"527 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/NNCFConv2d[conv_logits]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" [id=527, type=symmetric_quantize]; +"528 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/NNCFConv2d[conv_logits]/conv2d_0" [id=528, type=conv2d]; +"529 MaskRCNN/__getitem___0" [id=529, type=__getitem__]; +"530 MaskRCNN/sigmoid_0" [id=530, type=sigmoid]; +"0 /nncf_model_input_0" -> "1 SymmetricQuantizer/symmetric_quantize_0"; +"1 SymmetricQuantizer/symmetric_quantize_0" -> "3 MaskRCNN/ResNet[backbone]/NNCFConv2d[conv1]/conv2d_0"; +"2 MaskRCNN/ResNet[backbone]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "3 MaskRCNN/ResNet[backbone]/NNCFConv2d[conv1]/conv2d_0"; +"3 MaskRCNN/ResNet[backbone]/NNCFConv2d[conv1]/conv2d_0" -> "4 MaskRCNN/ResNet[backbone]/NNCFBatchNorm2d[bn1]/batch_norm_0"; +"4 MaskRCNN/ResNet[backbone]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "5 MaskRCNN/ResNet[backbone]/ReLU[relu]/relu__0"; +"5 MaskRCNN/ResNet[backbone]/ReLU[relu]/relu__0" -> "6 MaskRCNN/ResNet[backbone]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"6 MaskRCNN/ResNet[backbone]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "7 MaskRCNN/ResNet[backbone]/MaxPool2d[maxpool]/max_pool2d_0"; +"7 MaskRCNN/ResNet[backbone]/MaxPool2d[maxpool]/max_pool2d_0" -> "9 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; +"7 MaskRCNN/ResNet[backbone]/MaxPool2d[maxpool]/max_pool2d_0" -> "23 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0"; +"8 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "9 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; +"9 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" -> "10 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0"; +"10 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "11 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/relu__0"; +"11 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/relu__0" -> "12 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"12 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "14 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; +"13 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "14 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; +"14 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" -> "15 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0"; +"15 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "16 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/relu__1"; +"16 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/relu__1" -> "17 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"17 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "19 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0"; +"18 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "19 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0"; +"19 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0" -> "20 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/batch_norm_0"; +"20 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "21 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"21 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "26 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/__iadd___0"; +"22 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "23 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0"; +"23 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0" -> "24 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm2d[1]/batch_norm_0"; +"24 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm2d[1]/batch_norm_0" -> "25 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"25 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "26 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/__iadd___0"; +"26 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/__iadd___0" -> "27 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/relu__2"; +"27 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/relu__2" -> "28 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"28 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "30 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; +"28 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "43 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/__iadd___0"; +"29 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "30 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; +"30 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" -> "31 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0"; +"31 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "32 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/relu__0"; +"32 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/relu__0" -> "33 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"33 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "35 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; +"34 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "35 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; +"35 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" -> "36 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0"; +"36 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "37 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/relu__1"; +"37 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/relu__1" -> "38 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"38 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "40 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0"; +"39 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "40 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0"; +"40 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0" -> "41 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/batch_norm_0"; +"41 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "42 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"42 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "43 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/__iadd___0"; +"43 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/__iadd___0" -> "44 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/relu__2"; +"44 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/relu__2" -> "45 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"45 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "47 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; +"45 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "60 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/__iadd___0"; +"46 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "47 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; +"47 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" -> "48 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0"; +"48 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "49 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/relu__0"; +"49 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/relu__0" -> "50 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"50 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "52 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; +"51 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "52 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; +"52 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" -> "53 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0"; +"53 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "54 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/relu__1"; +"54 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/relu__1" -> "55 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"55 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "57 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0"; +"56 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "57 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0"; +"57 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0" -> "58 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/batch_norm_0"; +"58 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "59 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"59 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "60 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/__iadd___0"; +"60 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/__iadd___0" -> "61 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/relu__2"; +"61 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/relu__2" -> "62 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"62 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "64 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; +"62 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "78 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0"; +"62 MaskRCNN/ResNet[backbone]/ResLayer[layer1]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "297 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0"; +"63 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "64 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; +"64 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" -> "65 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0"; +"65 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "66 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/relu__0"; +"66 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/relu__0" -> "67 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"67 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "69 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; +"68 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "69 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; +"69 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" -> "70 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0"; +"70 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "71 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/relu__1"; +"71 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/relu__1" -> "72 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"72 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "74 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0"; +"73 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "74 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0"; +"74 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0" -> "75 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/batch_norm_0"; +"75 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "76 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"76 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "81 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/__iadd___0"; +"77 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "78 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0"; +"78 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0" -> "79 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm2d[1]/batch_norm_0"; +"79 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm2d[1]/batch_norm_0" -> "80 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"80 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "81 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/__iadd___0"; +"81 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/__iadd___0" -> "82 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/relu__2"; +"82 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/relu__2" -> "83 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"83 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "85 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; +"83 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "98 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/__iadd___0"; +"84 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "85 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; +"85 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" -> "86 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0"; +"86 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "87 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/relu__0"; +"87 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/relu__0" -> "88 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"88 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "90 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; +"89 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "90 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; +"90 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" -> "91 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0"; +"91 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "92 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/relu__1"; +"92 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/relu__1" -> "93 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"93 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "95 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0"; +"94 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "95 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0"; +"95 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0" -> "96 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/batch_norm_0"; +"96 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "97 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"97 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "98 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/__iadd___0"; +"98 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/__iadd___0" -> "99 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/relu__2"; +"99 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/relu__2" -> "100 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"100 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "102 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; +"100 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "115 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/__iadd___0"; +"101 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "102 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; +"102 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" -> "103 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0"; +"103 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "104 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/relu__0"; +"104 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/relu__0" -> "105 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"105 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "107 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; +"106 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "107 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; +"107 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" -> "108 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0"; +"108 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "109 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/relu__1"; +"109 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/relu__1" -> "110 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"110 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "112 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0"; +"111 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "112 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0"; +"112 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0" -> "113 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/batch_norm_0"; +"113 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "114 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"114 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "115 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/__iadd___0"; +"115 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/__iadd___0" -> "116 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/relu__2"; +"116 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/relu__2" -> "117 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"117 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "119 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0"; +"117 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "132 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/__iadd___0"; +"118 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "119 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0"; +"119 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0" -> "120 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFBatchNorm2d[bn1]/batch_norm_0"; +"120 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "121 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/relu__0"; +"121 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/relu__0" -> "122 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"122 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "124 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0"; +"123 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "124 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0"; +"124 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0" -> "125 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFBatchNorm2d[bn2]/batch_norm_0"; +"125 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "126 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/relu__1"; +"126 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/relu__1" -> "127 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"127 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "129 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d_0"; +"128 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "129 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d_0"; +"129 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d_0" -> "130 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFBatchNorm2d[bn3]/batch_norm_0"; +"130 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "131 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"131 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "132 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/__iadd___0"; +"132 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/__iadd___0" -> "133 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/relu__2"; +"133 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/relu__2" -> "134 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"134 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "136 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; +"134 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "150 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0"; +"134 MaskRCNN/ResNet[backbone]/ResLayer[layer2]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "300 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0"; +"135 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "136 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; +"136 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" -> "137 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0"; +"137 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "138 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/relu__0"; +"138 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/relu__0" -> "139 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"139 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "141 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; +"140 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "141 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; +"141 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" -> "142 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0"; +"142 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "143 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/relu__1"; +"143 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/relu__1" -> "144 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"144 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "146 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0"; +"145 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "146 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0"; +"146 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0" -> "147 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/batch_norm_0"; +"147 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "148 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"148 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "153 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/__iadd___0"; +"149 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "150 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0"; +"150 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0" -> "151 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm2d[1]/batch_norm_0"; +"151 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm2d[1]/batch_norm_0" -> "152 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"152 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "153 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/__iadd___0"; +"153 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/__iadd___0" -> "154 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/relu__2"; +"154 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/relu__2" -> "155 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"155 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "157 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; +"155 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "170 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/__iadd___0"; +"156 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "157 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; +"157 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" -> "158 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0"; +"158 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "159 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/relu__0"; +"159 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/relu__0" -> "160 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"160 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "162 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; +"161 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "162 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; +"162 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" -> "163 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0"; +"163 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "164 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/relu__1"; +"164 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/relu__1" -> "165 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"165 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "167 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0"; +"166 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "167 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0"; +"167 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0" -> "168 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/batch_norm_0"; +"168 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "169 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"169 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "170 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/__iadd___0"; +"170 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/__iadd___0" -> "171 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/relu__2"; +"171 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/relu__2" -> "172 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"172 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "174 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; +"172 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "187 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/__iadd___0"; +"173 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "174 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; +"174 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" -> "175 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0"; +"175 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "176 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/relu__0"; +"176 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/relu__0" -> "177 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"177 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "179 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; +"178 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "179 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; +"179 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" -> "180 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0"; +"180 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "181 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/relu__1"; +"181 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/relu__1" -> "182 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"182 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "184 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0"; +"183 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "184 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0"; +"184 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0" -> "185 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/batch_norm_0"; +"185 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "186 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"186 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "187 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/__iadd___0"; +"187 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/__iadd___0" -> "188 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/relu__2"; +"188 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/relu__2" -> "189 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"189 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "191 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0"; +"189 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "204 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/__iadd___0"; +"190 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "191 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0"; +"191 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv1]/conv2d_0" -> "192 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFBatchNorm2d[bn1]/batch_norm_0"; +"192 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "193 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/relu__0"; +"193 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/relu__0" -> "194 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"194 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "196 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0"; +"195 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "196 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0"; +"196 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv2]/conv2d_0" -> "197 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFBatchNorm2d[bn2]/batch_norm_0"; +"197 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "198 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/relu__1"; +"198 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/relu__1" -> "199 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"199 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "201 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d_0"; +"200 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "201 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d_0"; +"201 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFConv2d[conv3]/conv2d_0" -> "202 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFBatchNorm2d[bn3]/batch_norm_0"; +"202 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "203 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"203 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "204 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/__iadd___0"; +"204 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/__iadd___0" -> "205 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/relu__2"; +"205 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/relu__2" -> "206 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"206 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "208 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d_0"; +"206 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[3]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "221 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/__iadd___0"; +"207 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "208 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d_0"; +"208 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv1]/conv2d_0" -> "209 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFBatchNorm2d[bn1]/batch_norm_0"; +"209 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "210 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/relu__0"; +"210 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/relu__0" -> "211 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"211 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "213 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d_0"; +"212 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "213 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d_0"; +"213 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv2]/conv2d_0" -> "214 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFBatchNorm2d[bn2]/batch_norm_0"; +"214 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "215 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/relu__1"; +"215 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/relu__1" -> "216 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"216 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "218 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d_0"; +"217 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "218 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d_0"; +"218 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFConv2d[conv3]/conv2d_0" -> "219 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFBatchNorm2d[bn3]/batch_norm_0"; +"219 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "220 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"220 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "221 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/__iadd___0"; +"221 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/__iadd___0" -> "222 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/relu__2"; +"222 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/relu__2" -> "223 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"223 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "225 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d_0"; +"223 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[4]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "238 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/__iadd___0"; +"224 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "225 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d_0"; +"225 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv1]/conv2d_0" -> "226 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFBatchNorm2d[bn1]/batch_norm_0"; +"226 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "227 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/relu__0"; +"227 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/relu__0" -> "228 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"228 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "230 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d_0"; +"229 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "230 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d_0"; +"230 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv2]/conv2d_0" -> "231 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFBatchNorm2d[bn2]/batch_norm_0"; +"231 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "232 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/relu__1"; +"232 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/relu__1" -> "233 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"233 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "235 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d_0"; +"234 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "235 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d_0"; +"235 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFConv2d[conv3]/conv2d_0" -> "236 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFBatchNorm2d[bn3]/batch_norm_0"; +"236 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "237 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"237 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "238 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/__iadd___0"; +"238 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/__iadd___0" -> "239 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/relu__2"; +"239 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/relu__2" -> "240 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"240 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "242 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; +"240 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "256 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0"; +"240 MaskRCNN/ResNet[backbone]/ResLayer[layer3]/Bottleneck[5]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "303 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0"; +"241 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "242 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0"; +"242 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv1]/conv2d_0" -> "243 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0"; +"243 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "244 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/relu__0"; +"244 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/relu__0" -> "245 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"245 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "247 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; +"246 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "247 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0"; +"247 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv2]/conv2d_0" -> "248 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0"; +"248 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "249 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/relu__1"; +"249 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/relu__1" -> "250 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"250 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "252 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0"; +"251 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "252 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0"; +"252 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFConv2d[conv3]/conv2d_0" -> "253 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/batch_norm_0"; +"253 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "254 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"254 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "259 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/__iadd___0"; +"255 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "256 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0"; +"256 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFConv2d[0]/conv2d_0" -> "257 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm2d[1]/batch_norm_0"; +"257 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm2d[1]/batch_norm_0" -> "258 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0"; +"258 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/Sequential[downsample]/NNCFBatchNorm2d[1]/SymmetricQuantizer/symmetric_quantize_0" -> "259 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/__iadd___0"; +"259 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/__iadd___0" -> "260 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/relu__2"; +"260 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/relu__2" -> "261 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"261 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "263 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; +"261 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[0]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "276 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/__iadd___0"; +"262 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "263 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0"; +"263 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv1]/conv2d_0" -> "264 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0"; +"264 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "265 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/relu__0"; +"265 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/relu__0" -> "266 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"266 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "268 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; +"267 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "268 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0"; +"268 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv2]/conv2d_0" -> "269 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0"; +"269 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "270 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/relu__1"; +"270 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/relu__1" -> "271 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"271 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "273 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0"; +"272 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "273 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0"; +"273 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFConv2d[conv3]/conv2d_0" -> "274 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/batch_norm_0"; +"274 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "275 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"275 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "276 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/__iadd___0"; +"276 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/__iadd___0" -> "277 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/relu__2"; +"277 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/relu__2" -> "278 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"278 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "280 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; +"278 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[1]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "293 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/__iadd___0"; +"279 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "280 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0"; +"280 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv1]/conv2d_0" -> "281 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0"; +"281 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFBatchNorm2d[bn1]/batch_norm_0" -> "282 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/relu__0"; +"282 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/relu__0" -> "283 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"283 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "285 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; +"284 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "285 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0"; +"285 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv2]/conv2d_0" -> "286 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0"; +"286 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFBatchNorm2d[bn2]/batch_norm_0" -> "287 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/relu__1"; +"287 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/relu__1" -> "288 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"288 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "290 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0"; +"289 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "290 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0"; +"290 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFConv2d[conv3]/conv2d_0" -> "291 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/batch_norm_0"; +"291 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/batch_norm_0" -> "292 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0"; +"292 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/NNCFBatchNorm2d[bn3]/SymmetricQuantizer/symmetric_quantize_0" -> "293 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/__iadd___0"; +"293 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/__iadd___0" -> "294 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/relu__2"; +"294 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/relu__2" -> "295 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2"; +"295 MaskRCNN/ResNet[backbone]/ResLayer[layer4]/Bottleneck[2]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_2" -> "306 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0"; +"296 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "297 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0"; +"297 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" -> "298 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"298 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[0]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "318 MaskRCNN/FPN[neck]/__iadd___2"; +"299 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "300 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0"; +"300 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" -> "301 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"301 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[1]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "314 MaskRCNN/FPN[neck]/__iadd___1"; +"302 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "303 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0"; +"303 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" -> "304 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"304 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[2]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "310 MaskRCNN/FPN[neck]/__iadd___0"; +"305 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "306 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0"; +"306 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" -> "307 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0"; +"307 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "308 MaskRCNN/FPN[neck]/interpolate_0"; +"307 MaskRCNN/FPN[neck]/ModuleList[lateral_convs]/ConvModule[3]/NNCFConv2d[conv]/SymmetricQuantizer/symmetric_quantize_0" -> "327 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0"; +"308 MaskRCNN/FPN[neck]/interpolate_0" -> "309 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_0"; +"309 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_0" -> "310 MaskRCNN/FPN[neck]/__iadd___0"; +"310 MaskRCNN/FPN[neck]/__iadd___0" -> "311 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_1"; +"311 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_1" -> "312 MaskRCNN/FPN[neck]/interpolate_1"; +"311 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_1" -> "325 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0"; +"312 MaskRCNN/FPN[neck]/interpolate_1" -> "313 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_2"; +"313 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_2" -> "314 MaskRCNN/FPN[neck]/__iadd___1"; +"314 MaskRCNN/FPN[neck]/__iadd___1" -> "315 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_3"; +"315 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_3" -> "316 MaskRCNN/FPN[neck]/interpolate_2"; +"315 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_3" -> "323 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0"; +"316 MaskRCNN/FPN[neck]/interpolate_2" -> "317 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_4"; +"317 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_4" -> "318 MaskRCNN/FPN[neck]/__iadd___2"; +"318 MaskRCNN/FPN[neck]/__iadd___2" -> "319 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_5"; +"319 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_5" -> "321 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0"; +"320 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "321 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0"; +"321 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" -> "331 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/SymmetricQuantizer/symmetric_quantize_0"; +"321 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" -> "389 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/new_zeros_0"; +"321 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" -> "391 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/new_zeros_1"; +"321 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" -> "392 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/new_zeros_2"; +"321 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" -> "469 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/new_zeros_0"; +"321 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" -> "471 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/new_zeros_1"; +"321 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" -> "472 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/new_zeros_2"; +"322 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "323 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0"; +"323 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" -> "340 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/SymmetricQuantizer/symmetric_quantize_1"; +"323 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" -> "400 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/new_zeros_0"; +"323 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" -> "402 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/new_zeros_1"; +"323 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" -> "403 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/new_zeros_2"; +"323 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" -> "480 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/new_zeros_0"; +"323 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" -> "482 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/new_zeros_1"; +"323 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" -> "483 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/new_zeros_2"; +"324 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "325 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0"; +"325 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" -> "349 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/SymmetricQuantizer/symmetric_quantize_2"; +"325 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" -> "411 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/new_zeros_0"; +"325 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" -> "413 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/new_zeros_1"; +"325 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" -> "414 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/new_zeros_2"; +"325 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" -> "491 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/new_zeros_0"; +"325 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" -> "493 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/new_zeros_1"; +"325 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" -> "494 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/new_zeros_2"; +"326 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "327 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0"; +"327 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" -> "328 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_6"; +"327 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" -> "358 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/SymmetricQuantizer/symmetric_quantize_3"; +"327 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" -> "422 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/new_zeros_0"; +"327 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" -> "424 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/new_zeros_1"; +"327 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" -> "425 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/new_zeros_2"; +"327 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" -> "502 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/new_zeros_0"; +"327 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" -> "504 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/new_zeros_1"; +"327 MaskRCNN/FPN[neck]/ModuleList[fpn_convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" -> "505 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/new_zeros_2"; +"328 MaskRCNN/FPN[neck]/SymmetricQuantizer/symmetric_quantize_6" -> "329 MaskRCNN/FPN[neck]/max_pool2d_0"; +"329 MaskRCNN/FPN[neck]/max_pool2d_0" -> "367 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_4"; +"330 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "332 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_0"; +"331 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/SymmetricQuantizer/symmetric_quantize_0" -> "332 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_0"; +"332 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_0" -> "333 MaskRCNN/RPNHead[rpn_head]/relu__0"; +"333 MaskRCNN/RPNHead[rpn_head]/relu__0" -> "334 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_0"; +"334 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_0" -> "336 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/conv2d_0"; +"334 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_0" -> "338 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/conv2d_0"; +"335 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "336 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/conv2d_0"; +"337 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "338 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/conv2d_0"; +"339 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" -> "341 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_1"; +"340 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/SymmetricQuantizer/symmetric_quantize_1" -> "341 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_1"; +"341 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_1" -> "342 MaskRCNN/RPNHead[rpn_head]/relu__1"; +"342 MaskRCNN/RPNHead[rpn_head]/relu__1" -> "343 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_1"; +"343 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_1" -> "345 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/conv2d_1"; +"343 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_1" -> "347 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/conv2d_1"; +"344 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" -> "345 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/conv2d_1"; +"346 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_1" -> "347 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/conv2d_1"; +"348 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" -> "350 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_2"; +"349 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/SymmetricQuantizer/symmetric_quantize_2" -> "350 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_2"; +"350 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_2" -> "351 MaskRCNN/RPNHead[rpn_head]/relu__2"; +"351 MaskRCNN/RPNHead[rpn_head]/relu__2" -> "352 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_2"; +"352 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_2" -> "354 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/conv2d_2"; +"352 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_2" -> "356 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/conv2d_2"; +"353 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" -> "354 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/conv2d_2"; +"355 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_2" -> "356 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/conv2d_2"; +"357 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" -> "359 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_3"; +"358 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/SymmetricQuantizer/symmetric_quantize_3" -> "359 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_3"; +"359 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_3" -> "360 MaskRCNN/RPNHead[rpn_head]/relu__3"; +"360 MaskRCNN/RPNHead[rpn_head]/relu__3" -> "361 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_3"; +"361 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_3" -> "363 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/conv2d_3"; +"361 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_3" -> "365 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/conv2d_3"; +"362 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" -> "363 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/conv2d_3"; +"364 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_3" -> "365 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/conv2d_3"; +"366 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" -> "367 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_4"; +"367 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_conv]/conv2d_4" -> "368 MaskRCNN/RPNHead[rpn_head]/relu__4"; +"368 MaskRCNN/RPNHead[rpn_head]/relu__4" -> "369 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_4"; +"369 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_4" -> "371 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/conv2d_4"; +"369 MaskRCNN/RPNHead[rpn_head]/SymmetricQuantizer/symmetric_quantize_4" -> "373 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/conv2d_4"; +"370 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" -> "371 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_cls]/conv2d_4"; +"372 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_4" -> "373 MaskRCNN/RPNHead[rpn_head]/NNCFConv2d[rpn_reg]/conv2d_4"; +"374 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/sqrt_0" -> "375 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_0"; +"375 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_0" -> "376 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__truediv___0"; +"376 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__truediv___0" -> "377 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_1"; +"377 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_1" -> "378 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__add___0"; +"378 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__add___0" -> "379 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/log2_0"; +"379 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/log2_0" -> "380 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/floor_0"; +"380 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/floor_0" -> "381 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/clamp_0"; +"381 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/clamp_0" -> "382 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/long_0"; +"382 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/long_0" -> "383 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__eq___0"; +"382 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/long_0" -> "394 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__eq___1"; +"382 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/long_0" -> "405 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__eq___2"; +"382 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/long_0" -> "416 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__eq___3"; +"383 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__eq___0" -> "384 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/float_0"; +"384 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/float_0" -> "385 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_2"; +"385 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_2" -> "386 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/unsqueeze_0"; +"386 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/unsqueeze_0" -> "387 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/expand_0"; +"387 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/expand_0" -> "388 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/reshape_0"; +"388 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/reshape_0" -> "393 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__imul___0"; +"389 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/new_zeros_0" -> "390 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/SymmetricQuantizer/symmetric_quantize_0"; +"390 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/SymmetricQuantizer/symmetric_quantize_0" -> "393 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__imul___0"; +"394 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__eq___1" -> "395 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/float_1"; +"395 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/float_1" -> "396 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_3"; +"396 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_3" -> "397 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/unsqueeze_1"; +"397 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/unsqueeze_1" -> "398 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/expand_1"; +"398 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/expand_1" -> "399 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/reshape_1"; +"399 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/reshape_1" -> "404 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__imul___1"; +"400 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/new_zeros_0" -> "401 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/SymmetricQuantizer/symmetric_quantize_0"; +"401 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/SymmetricQuantizer/symmetric_quantize_0" -> "404 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__imul___1"; +"405 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__eq___2" -> "406 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/float_2"; +"406 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/float_2" -> "407 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_4"; +"407 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_4" -> "408 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/unsqueeze_2"; +"408 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/unsqueeze_2" -> "409 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/expand_2"; +"409 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/expand_2" -> "410 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/reshape_2"; +"410 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/reshape_2" -> "415 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__imul___2"; +"411 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/new_zeros_0" -> "412 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/SymmetricQuantizer/symmetric_quantize_0"; +"412 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/SymmetricQuantizer/symmetric_quantize_0" -> "415 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__imul___2"; +"416 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__eq___3" -> "417 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/float_3"; +"417 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/float_3" -> "418 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_5"; +"418 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/SymmetricQuantizer/symmetric_quantize_5" -> "419 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/unsqueeze_3"; +"419 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/unsqueeze_3" -> "420 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/expand_3"; +"420 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/expand_3" -> "421 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/reshape_3"; +"421 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/reshape_3" -> "426 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__imul___3"; +"422 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/new_zeros_0" -> "423 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/SymmetricQuantizer/symmetric_quantize_0"; +"423 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/SymmetricQuantizer/symmetric_quantize_0" -> "426 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[bbox_roi_extractor]/__imul___3"; +"427 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ModuleList[shared_fcs]/NNCFLinear[0]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "428 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ModuleList[shared_fcs]/NNCFLinear[0]/linear_0"; +"428 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ModuleList[shared_fcs]/NNCFLinear[0]/linear_0" -> "429 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ReLU[relu]/relu__0"; +"429 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ReLU[relu]/relu__0" -> "430 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"430 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "432 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ModuleList[shared_fcs]/NNCFLinear[1]/linear_0"; +"431 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ModuleList[shared_fcs]/NNCFLinear[1]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "432 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ModuleList[shared_fcs]/NNCFLinear[1]/linear_0"; +"432 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ModuleList[shared_fcs]/NNCFLinear[1]/linear_0" -> "433 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ReLU[relu]/relu__1"; +"433 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ReLU[relu]/relu__1" -> "434 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1"; +"434 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "436 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/NNCFLinear[fc_cls]/linear_0"; +"434 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_1" -> "438 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/NNCFLinear[fc_reg]/linear_0"; +"435 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/NNCFLinear[fc_cls]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "436 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/NNCFLinear[fc_cls]/linear_0"; +"437 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/NNCFLinear[fc_reg]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "438 MaskRCNN/StandardRoIHead[roi_head]/Shared2FCBBoxHead[bbox_head]/NNCFLinear[fc_reg]/linear_0"; +"439 MaskRCNN/pad_0" -> "440 MaskRCNN/SymmetricQuantizer/symmetric_quantize_0"; +"440 MaskRCNN/SymmetricQuantizer/symmetric_quantize_0" -> "441 MaskRCNN/cat_0"; +"441 MaskRCNN/cat_0" -> "442 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__getitem___0"; +"441 MaskRCNN/cat_0" -> "444 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__getitem___1"; +"441 MaskRCNN/cat_0" -> "445 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__getitem___2"; +"441 MaskRCNN/cat_0" -> "448 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__getitem___3"; +"441 MaskRCNN/cat_0" -> "449 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__getitem___4"; +"442 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__getitem___0" -> "443 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/clone_0"; +"444 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__getitem___1" -> "446 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__sub___0"; +"445 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__getitem___2" -> "446 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__sub___0"; +"446 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__sub___0" -> "447 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_0"; +"447 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_0" -> "452 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__mul___0"; +"448 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__getitem___3" -> "450 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__sub___1"; +"449 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__getitem___4" -> "450 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__sub___1"; +"450 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__sub___1" -> "451 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_1"; +"451 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_1" -> "452 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__mul___0"; +"452 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__mul___0" -> "453 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_2"; +"453 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_2" -> "454 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/sqrt_0"; +"454 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/sqrt_0" -> "455 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_3"; +"455 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_3" -> "456 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__truediv___0"; +"456 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__truediv___0" -> "457 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_4"; +"457 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_4" -> "458 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__add___0"; +"458 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__add___0" -> "459 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/log2_0"; +"459 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/log2_0" -> "460 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/floor_0"; +"460 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/floor_0" -> "461 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/clamp_0"; +"461 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/clamp_0" -> "462 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/long_0"; +"462 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/long_0" -> "463 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__eq___0"; +"462 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/long_0" -> "474 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__eq___1"; +"462 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/long_0" -> "485 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__eq___2"; +"462 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/long_0" -> "496 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__eq___3"; +"463 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__eq___0" -> "464 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/float_0"; +"464 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/float_0" -> "465 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_5"; +"465 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_5" -> "466 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/unsqueeze_0"; +"466 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/unsqueeze_0" -> "467 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/expand_0"; +"467 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/expand_0" -> "468 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/reshape_0"; +"468 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/reshape_0" -> "473 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__imul___0"; +"469 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/new_zeros_0" -> "470 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/SymmetricQuantizer/symmetric_quantize_0"; +"470 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[0]/SymmetricQuantizer/symmetric_quantize_0" -> "473 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__imul___0"; +"474 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__eq___1" -> "475 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/float_1"; +"475 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/float_1" -> "476 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_6"; +"476 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_6" -> "477 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/unsqueeze_1"; +"477 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/unsqueeze_1" -> "478 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/expand_1"; +"478 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/expand_1" -> "479 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/reshape_1"; +"479 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/reshape_1" -> "484 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__imul___1"; +"480 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/new_zeros_0" -> "481 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/SymmetricQuantizer/symmetric_quantize_0"; +"481 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[1]/SymmetricQuantizer/symmetric_quantize_0" -> "484 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__imul___1"; +"485 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__eq___2" -> "486 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/float_2"; +"486 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/float_2" -> "487 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_7"; +"487 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_7" -> "488 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/unsqueeze_2"; +"488 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/unsqueeze_2" -> "489 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/expand_2"; +"489 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/expand_2" -> "490 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/reshape_2"; +"490 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/reshape_2" -> "495 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__imul___2"; +"491 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/new_zeros_0" -> "492 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/SymmetricQuantizer/symmetric_quantize_0"; +"492 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[2]/SymmetricQuantizer/symmetric_quantize_0" -> "495 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__imul___2"; +"496 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__eq___3" -> "497 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/float_3"; +"497 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/float_3" -> "498 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_8"; +"498 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/SymmetricQuantizer/symmetric_quantize_8" -> "499 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/unsqueeze_3"; +"499 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/unsqueeze_3" -> "500 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/expand_3"; +"500 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/expand_3" -> "501 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/reshape_3"; +"501 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/reshape_3" -> "506 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__imul___3"; +"502 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/new_zeros_0" -> "503 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/SymmetricQuantizer/symmetric_quantize_0"; +"503 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/ModuleList[roi_layers]/RoIAlign[3]/SymmetricQuantizer/symmetric_quantize_0" -> "506 MaskRCNN/StandardRoIHead[roi_head]/SingleRoIExtractor[mask_roi_extractor]/__imul___3"; +"507 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[0]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "508 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0"; +"508 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[0]/NNCFConv2d[conv]/conv2d_0" -> "509 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[0]/ReLU[activate]/relu__0"; +"509 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[0]/ReLU[activate]/relu__0" -> "510 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0"; +"510 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[0]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" -> "512 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0"; +"511 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[1]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "512 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0"; +"512 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[1]/NNCFConv2d[conv]/conv2d_0" -> "513 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[1]/ReLU[activate]/relu__0"; +"513 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[1]/ReLU[activate]/relu__0" -> "514 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0"; +"514 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[1]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" -> "516 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0"; +"515 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[2]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "516 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0"; +"516 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[2]/NNCFConv2d[conv]/conv2d_0" -> "517 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[2]/ReLU[activate]/relu__0"; +"517 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[2]/ReLU[activate]/relu__0" -> "518 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0"; +"518 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[2]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" -> "520 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0"; +"519 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[3]/NNCFConv2d[conv]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "520 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0"; +"520 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[3]/NNCFConv2d[conv]/conv2d_0" -> "521 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[3]/ReLU[activate]/relu__0"; +"521 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[3]/ReLU[activate]/relu__0" -> "522 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0"; +"522 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ModuleList[convs]/ConvModule[3]/ReLU[activate]/SymmetricQuantizer/symmetric_quantize_0" -> "524 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/NNCFConvTranspose2d[upsample]/conv_transpose2d_0"; +"523 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/NNCFConvTranspose2d[upsample]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "524 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/NNCFConvTranspose2d[upsample]/conv_transpose2d_0"; +"524 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/NNCFConvTranspose2d[upsample]/conv_transpose2d_0" -> "525 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ReLU[relu]/relu__0"; +"525 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ReLU[relu]/relu__0" -> "526 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0"; +"526 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/ReLU[relu]/SymmetricQuantizer/symmetric_quantize_0" -> "528 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/NNCFConv2d[conv_logits]/conv2d_0"; +"527 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/NNCFConv2d[conv_logits]/ModuleDict[pre_ops]/UpdateWeight[0]/SymmetricQuantizer[op]/symmetric_quantize_0" -> "528 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/NNCFConv2d[conv_logits]/conv2d_0"; +"528 MaskRCNN/StandardRoIHead[roi_head]/FCNMaskHead[mask_head]/NNCFConv2d[conv_logits]/conv2d_0" -> "529 MaskRCNN/__getitem___0"; +"529 MaskRCNN/__getitem___0" -> "530 MaskRCNN/sigmoid_0"; +} diff --git a/external/mmsegmentation/submodule b/external/mmsegmentation/submodule index 571a0d38069..d5dddde6513 160000 --- a/external/mmsegmentation/submodule +++ b/external/mmsegmentation/submodule @@ -1 +1 @@ -Subproject commit 571a0d38069588787916c682d94888614352972b +Subproject commit d5dddde65131ab259a97a67294e5e184c082b657 diff --git a/external/model-preparation-algorithm/configs/classification/efficientnet_b0_cls_incr/template.yaml b/external/model-preparation-algorithm/configs/classification/efficientnet_b0_cls_incr/template_experimental.yaml similarity index 100% rename from external/model-preparation-algorithm/configs/classification/efficientnet_b0_cls_incr/template.yaml rename to external/model-preparation-algorithm/configs/classification/efficientnet_b0_cls_incr/template_experimental.yaml diff --git a/external/model-preparation-algorithm/configs/classification/efficientnet_v2_s_cls_incr/template.yaml b/external/model-preparation-algorithm/configs/classification/efficientnet_v2_s_cls_incr/template_experimental.yaml similarity index 100% rename from external/model-preparation-algorithm/configs/classification/efficientnet_v2_s_cls_incr/template.yaml rename to external/model-preparation-algorithm/configs/classification/efficientnet_v2_s_cls_incr/template_experimental.yaml diff --git a/external/model-preparation-algorithm/configs/classification/mobilenet_v3_large_075_cls_incr/template.yaml b/external/model-preparation-algorithm/configs/classification/mobilenet_v3_large_075_cls_incr/template_experimental.yaml similarity index 100% rename from external/model-preparation-algorithm/configs/classification/mobilenet_v3_large_075_cls_incr/template.yaml rename to external/model-preparation-algorithm/configs/classification/mobilenet_v3_large_075_cls_incr/template_experimental.yaml diff --git a/external/model-preparation-algorithm/configs/classification/mobilenet_v3_large_1_cls_incr/template.yaml b/external/model-preparation-algorithm/configs/classification/mobilenet_v3_large_1_cls_incr/template_experimental.yaml similarity index 100% rename from external/model-preparation-algorithm/configs/classification/mobilenet_v3_large_1_cls_incr/template.yaml rename to external/model-preparation-algorithm/configs/classification/mobilenet_v3_large_1_cls_incr/template_experimental.yaml diff --git a/external/model-preparation-algorithm/configs/classification/mobilenet_v3_small_cls_incr/template.yaml b/external/model-preparation-algorithm/configs/classification/mobilenet_v3_small_cls_incr/template_experimental.yaml similarity index 100% rename from external/model-preparation-algorithm/configs/classification/mobilenet_v3_small_cls_incr/template.yaml rename to external/model-preparation-algorithm/configs/classification/mobilenet_v3_small_cls_incr/template_experimental.yaml diff --git a/external/model-preparation-algorithm/configs/detection/mobilenetv2_atss_cls_incr/template.yaml b/external/model-preparation-algorithm/configs/detection/mobilenetv2_atss_cls_incr/template_experimental.yaml similarity index 100% rename from external/model-preparation-algorithm/configs/detection/mobilenetv2_atss_cls_incr/template.yaml rename to external/model-preparation-algorithm/configs/detection/mobilenetv2_atss_cls_incr/template_experimental.yaml diff --git a/external/model-preparation-algorithm/configs/detection/resnet50_vfnet_cls_incr/template.yaml b/external/model-preparation-algorithm/configs/detection/resnet50_vfnet_cls_incr/template_experimental.yaml similarity index 100% rename from external/model-preparation-algorithm/configs/detection/resnet50_vfnet_cls_incr/template.yaml rename to external/model-preparation-algorithm/configs/detection/resnet50_vfnet_cls_incr/template_experimental.yaml diff --git a/external/model-preparation-algorithm/configs/segmentation/ocr-lite-hrnet-18-cls-incr/template.yaml b/external/model-preparation-algorithm/configs/segmentation/ocr-lite-hrnet-18-cls-incr/template_experimental.yaml similarity index 100% rename from external/model-preparation-algorithm/configs/segmentation/ocr-lite-hrnet-18-cls-incr/template.yaml rename to external/model-preparation-algorithm/configs/segmentation/ocr-lite-hrnet-18-cls-incr/template_experimental.yaml diff --git a/external/model-preparation-algorithm/submodule b/external/model-preparation-algorithm/submodule index 8d36bf59448..895aa0350ad 160000 --- a/external/model-preparation-algorithm/submodule +++ b/external/model-preparation-algorithm/submodule @@ -1 +1 @@ -Subproject commit 8d36bf5944837b7a3d22fc2c3a4cb93423619fc2 +Subproject commit 895aa0350ad44866a7b0f77cdfcaecdc5a5d7420 diff --git a/external/model-preparation-algorithm/tests/ote_cli/test_ote_cls_cls_il.py b/external/model-preparation-algorithm/tests/ote_cli/test_cls_cls_il.py similarity index 99% rename from external/model-preparation-algorithm/tests/ote_cli/test_ote_cls_cls_il.py rename to external/model-preparation-algorithm/tests/ote_cli/test_cls_cls_il.py index f95ac868d48..1d01a0c8199 100644 --- a/external/model-preparation-algorithm/tests/ote_cli/test_ote_cls_cls_il.py +++ b/external/model-preparation-algorithm/tests/ote_cli/test_cls_cls_il.py @@ -56,7 +56,7 @@ templates_ids = [template.model_template_id for template in templates] -class TestToolsClassification: +class TestToolsClsClsIncr: @e2e_pytest_component def test_create_venv(self): work_dir, _, algo_backend_dir = get_some_vars(templates[0], root) diff --git a/external/model-preparation-algorithm/tests/ote_cli/test_ote_det_cls_il.py b/external/model-preparation-algorithm/tests/ote_cli/test_det_cls_il.py similarity index 100% rename from external/model-preparation-algorithm/tests/ote_cli/test_ote_det_cls_il.py rename to external/model-preparation-algorithm/tests/ote_cli/test_det_cls_il.py diff --git a/external/model-preparation-algorithm/tests/ote_cli/test_ote_seg_cls_il.py b/external/model-preparation-algorithm/tests/ote_cli/test_seg_cls_il.py similarity index 99% rename from external/model-preparation-algorithm/tests/ote_cli/test_ote_seg_cls_il.py rename to external/model-preparation-algorithm/tests/ote_cli/test_seg_cls_il.py index 7c14e88334e..f77c4940591 100644 --- a/external/model-preparation-algorithm/tests/ote_cli/test_ote_seg_cls_il.py +++ b/external/model-preparation-algorithm/tests/ote_cli/test_seg_cls_il.py @@ -61,7 +61,7 @@ templates_ids = [template.model_template_id for template in templates] -class TestToolsSegmentation: +class TestToolsSegClsIncr: @e2e_pytest_component def test_create_venv(self): work_dir, _, algo_backend_dir = get_some_vars(templates[0], root) diff --git a/external/model-preparation-algorithm/tests/test_ote_api.py b/external/model-preparation-algorithm/tests/test_ote_api.py index 50dd09e38cc..b0611d4ac78 100644 --- a/external/model-preparation-algorithm/tests/test_ote_api.py +++ b/external/model-preparation-algorithm/tests/test_ote_api.py @@ -83,7 +83,7 @@ def test_reading_classification_cls_incr_model_template(self): 'mobilenet_v3_large_1_cls_incr', 'mobilenet_v3_large_075_cls_incr', 'mobilenet_v3_small_cls_incr'] for model_template in classification_template: - parse_model_template(osp.join('configs', 'classification', model_template, 'template.yaml')) + parse_model_template(osp.join('configs', 'classification', model_template, 'template_experimental.yaml')) @staticmethod def generate_label_schema(not_empty_labels, multilabel=False): @@ -103,7 +103,7 @@ def generate_label_schema(not_empty_labels, multilabel=False): @staticmethod def setup_configurable_parameters(template_dir, num_iters=10): - model_template = parse_model_template(osp.join(template_dir, 'template.yaml')) + model_template = parse_model_template(osp.join(template_dir, 'template_experimental.yaml')) hyper_parameters = create(model_template.hyper_parameters.data) hyper_parameters.learning_parameters.num_iters = num_iters return hyper_parameters, model_template @@ -240,7 +240,7 @@ class MPADetAPI(unittest.TestCase): def test_reading_detection_cls_incr_model_template(self): detection_template = ['mobilenetv2_atss_cls_incr', 'resnet50_vfnet_cls_incr'] for model_template in detection_template: - parse_model_template(osp.join('configs', 'detection', model_template, 'template.yaml')) + parse_model_template(osp.join('configs', 'detection', model_template, 'template_experimental.yaml')) def init_environment( self, @@ -455,7 +455,7 @@ class MPASegAPI(unittest.TestCase): def test_reading_segmentation_cls_incr_model_template(self): segmentation_template = ['ocr-lite-hrnet-18-cls-incr'] for model_template in segmentation_template: - parse_model_template(osp.join('configs', 'segmentation', model_template, 'template.yaml')) + parse_model_template(osp.join('configs', 'segmentation', model_template, 'template_experimental.yaml')) @staticmethod def generate_label_schema(label_names): @@ -537,7 +537,7 @@ def init_environment(self, params, model_template, number_of_images=10): @staticmethod def setup_configurable_parameters(template_dir, num_iters=10): - model_template = parse_model_template(osp.join(template_dir, 'template.yaml')) + model_template = parse_model_template(osp.join(template_dir, 'template_experimental.yaml')) hyper_parameters = create(model_template.hyper_parameters.data) hyper_parameters.learning_parameters.learning_rate_fixed_iters = 0 diff --git a/ote_sdk/ote_sdk/test_suite/training_tests_actions.py b/ote_sdk/ote_sdk/test_suite/training_tests_actions.py index 8e5fc0b380b..76e276c7395 100644 --- a/ote_sdk/ote_sdk/test_suite/training_tests_actions.py +++ b/ote_sdk/ote_sdk/test_suite/training_tests_actions.py @@ -79,7 +79,7 @@ def __call__(self, data_collector: DataCollector, results_prev_stages: OrderedDi def create_environment_and_task( - params, labels_schema, model_template, dataset, model_adapters=None + params, labels_schema, model_template, dataset=None, model_adapters=None ): environment = TaskEnvironment(