From 4ffe53113d1a1a2eb00bf30acca375d8b4fee188 Mon Sep 17 00:00:00 2001 From: dlyakhov Date: Fri, 29 Nov 2024 11:30:16 +0100 Subject: [PATCH] WIP OpenVINOQuantizer --- .../quantizer/openvino_quantizer/backend.py | 323 + .../openvino_quantizer/openvino_quantizer.py | 593 ++ .../openvino_quantizer/torch_fx_backend.py | 366 + .../algorithms/min_max/quantizer/backend.py | 323 + .../min_max/quantizer/torch_fx_backend.py | 366 + .../OpenVINOQuantizer/mobilenet_v3_small.dot | 1042 +++ .../OpenVINOQuantizer/resnet18.dot | 457 ++ .../OpenVINOQuantizer/swin_v2_s.dot | 6310 +++++++++++++++++ .../synthetic_transformer.dot | 45 + .../experimental/OpenVINOQuantizer/unet.dot | 469 ++ .../OpenVINOQuantizer/vit_b_16.dot | 1913 +++++ .../OpenVINOQuantizer/yolo11n_sdpa_block.dot | 61 + 12 files changed, 12268 insertions(+) create mode 100644 nncf/experimental/common/quantization/algorithms/quantizer/openvino_quantizer/backend.py create mode 100644 nncf/experimental/common/quantization/algorithms/quantizer/openvino_quantizer/openvino_quantizer.py create mode 100644 nncf/experimental/common/quantization/algorithms/quantizer/openvino_quantizer/torch_fx_backend.py create mode 100644 nncf/quantization/algorithms/min_max/quantizer/backend.py create mode 100644 nncf/quantization/algorithms/min_max/quantizer/torch_fx_backend.py create mode 100644 tests/torch/data/reference_graphs/fx/experimental/OpenVINOQuantizer/mobilenet_v3_small.dot create mode 100644 tests/torch/data/reference_graphs/fx/experimental/OpenVINOQuantizer/resnet18.dot create mode 100644 tests/torch/data/reference_graphs/fx/experimental/OpenVINOQuantizer/swin_v2_s.dot create mode 100644 tests/torch/data/reference_graphs/fx/experimental/OpenVINOQuantizer/synthetic_transformer.dot create mode 100644 tests/torch/data/reference_graphs/fx/experimental/OpenVINOQuantizer/unet.dot create mode 100644 tests/torch/data/reference_graphs/fx/experimental/OpenVINOQuantizer/vit_b_16.dot create mode 100644 tests/torch/data/reference_graphs/fx/experimental/OpenVINOQuantizer/yolo11n_sdpa_block.dot diff --git a/nncf/experimental/common/quantization/algorithms/quantizer/openvino_quantizer/backend.py b/nncf/experimental/common/quantization/algorithms/quantizer/openvino_quantizer/backend.py new file mode 100644 index 00000000000..9f7ea5441e1 --- /dev/null +++ b/nncf/experimental/common/quantization/algorithms/quantizer/openvino_quantizer/backend.py @@ -0,0 +1,323 @@ +# Copyright (c) 2024 Intel Corporation +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# http://www.apache.org/licenses/LICENSE-2.0 +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from abc import ABC +from abc import abstractmethod +from typing import Dict, List, Optional, Set, Tuple, TypeVar + +from nncf.common.graph.graph import NNCFGraph +from nncf.common.graph.graph import NNCFNode +from nncf.common.graph.operator_metatypes import OperatorMetatype +from nncf.common.graph.transformations.commands import TargetPoint +from nncf.common.graph.transformations.commands import TargetType +from nncf.common.graph.transformations.commands import TransformationCommand +from nncf.common.hardware.config import HWConfig +from nncf.common.quantization.structs import QuantizerConfig +from nncf.common.tensor_statistics.collectors import TensorStatisticCollectorBase +from nncf.parameters import ModelType +from nncf.parameters import TargetDevice +from nncf.quantization.fake_quantize import FakeConvertParameters +from nncf.quantization.fake_quantize import FakeQuantizeParameters +from nncf.quantization.range_estimator import RangeEstimatorParameters + +TModel = TypeVar("TModel") + + +class OpenVINOQuantizerBackend(ABC): + @property + @abstractmethod + def preserved_metatypes(self) -> List[OperatorMetatype]: + """ + Property for backend-specific metatypes that require preserving float subgraphs + when removing the ShapeOf subgraph. + """ + + @property + @abstractmethod + def mat_mul_metatypes(self) -> List[OperatorMetatype]: + """ + Property for the backend-specific MatMul metatypes. + """ + + @property + @abstractmethod + def post_processing_metatypes(self) -> List[OperatorMetatype]: + """ + Property for the backend-specific post-processing metatypes (NonMaximumSupression, TopK, etc.). + """ + + @property + @abstractmethod + def conv_metatypes(self) -> List[OperatorMetatype]: + """ + Property for the backend-specific Convolution metatypes. + """ + + @property + @abstractmethod + def shapeof_metatypes(self) -> List[OperatorMetatype]: + """ + Property for the backend-specific ShapeOf metatypes. + """ + + @property + @abstractmethod + def dropout_metatypes(self) -> List[OperatorMetatype]: + """ + Property for the backend-specific Dropout metatypes. + """ + + @property + @abstractmethod + def elementwise_metatypes(self) -> List[OperatorMetatype]: + """ + Property for the backend-specific Elementwises metatypes. + """ + + @property + @abstractmethod + def overflow_fix_metatypes(self) -> List[OperatorMetatype]: + """ + Property for the backend-specific metatypes for which overflow_fix is applicable. + """ + + @property + @abstractmethod + def add_metatypes(self) -> List[OperatorMetatype]: + """ + Property for the backend-specific metatypes that also can be interpreted as Add layer. + """ + + @property + @abstractmethod + def group_conv_metatypes(self) -> List[OperatorMetatype]: + """ + Property for the backend-specific Grouped Convolution metatypes. + """ + + @property + @abstractmethod + def scaled_dot_product_attention_metatypes(self) -> List[OperatorMetatype]: + """ + Property for the backend-specific Scaled Dot Product Attention metatypes. + """ + + @property + @abstractmethod + def scales_unification_map(self) -> Dict[OperatorMetatype, OperatorMetatype]: + """ + Property for the backend-specific metatypes that produces quantizers that might be unified. + """ + + @property + @abstractmethod + def hw_config(self) -> HWConfig: + """ + Property for the hardware backend-specific configuration. + """ + + @property + @abstractmethod + def quant_trait_op_dict(self) -> Dict[int, OperatorMetatype]: + """ + Property for the backend-specific dictionary that contains QuantizationTrait-specific metatypes. + """ + + @staticmethod + @abstractmethod + def target_point(target_type: TargetType, target_node_name: str, port_id: int) -> TargetPoint: + """ + Returns backend-specific target point. + + :param target_type: Type of the location that should be modified. + :param target_node_name: Name of the located node. + :param port_id: Port ID of the tensor for the statistics distribution. + :return: Backend-specific TargetPoint. + """ + + @staticmethod + @abstractmethod + def create_quantizer_insertion_command( + nncf_graph: NNCFGraph, + target_point: TargetPoint, + quantizer_config: QuantizerConfig, + parameters: FakeQuantizeParameters, + ) -> TransformationCommand: + """ + Returns backend-specific quantizer insertion command. + + :param nncf_graph: NNCFGraph to get input/output shapes for the target point. + :param target_point: Target location for the quantizer insertion. + :param quantizer_config: QuantizerConfig instance for the current layer. + :param parameters: FakeQuantizeParameters to calculate activation quantization parameters. + :return: Backend-specific TransformationCommand for the quantizer insertion operation. + """ + + @staticmethod + @abstractmethod + def create_unified_scales_quantizers_insertion_commands( + nncf_graph: NNCFGraph, + target_points: List[TargetPoint], + quantizer_config: QuantizerConfig, + parameters: FakeQuantizeParameters, + ) -> List[TransformationCommand]: + """ + Returns backend-specific unified scales quantizers insertion commands. + + :param nncf_graph: NNCFGraph to get input/output shapes for the target point. + :param target_points: List of target locations for the quantizers insertion. + :param quantizer_config: QuantizerConfig instance for the current layer. + :param parameters: FakeQuantizeParameters to calculate activation quantization parameters. + :return: List of backend-specific TransformationCommands + for the quantizers with unified scales insertion operations. + """ + + @staticmethod + @abstractmethod + def create_convert_insertion_command( + target_point: TargetPoint, + parameters: FakeConvertParameters, + ) -> TransformationCommand: + """ + Returns backend-specific convert insertion command. + + :param target_point: Target location for the correction. + :param parameters: FakeConvertParameters to calculate activation quantization parameters. + :return: Backend-specific TransformationCommand for the quantizer insertion operation. + """ + + @staticmethod + @abstractmethod + def get_start_nodes_for_activation_path_tracing(nncf_graph: NNCFGraph) -> List[NNCFNode]: + """ + Returns a list of NNCFNodes to use as start nodes for activation path tracing. + + :param nncf_graph: NNCFGraph to get the start nodes. + :return: List of NNCFNodes to use as start nodes for activation path tracing. + + """ + + @staticmethod + @abstractmethod + def get_target_point_shape(nncf_graph: NNCFGraph, node: NNCFNode, target_point: TargetPoint) -> Tuple[int, ...]: + """ + Returns shape of a target point tensor. + + :param nncf_graph: NNCFGraph instance. + :param node: NNCFNode. + :param target_point: Target point of which tensor shape is seeked. + :return: Shape of target point tensor. + """ + + @staticmethod + @abstractmethod + def get_weight_quantization_axes(node: NNCFNode, target_point: TargetPoint, ndims: int) -> Tuple[int, ...]: + """ + Returns axes for per-channel quantization of weights of the node placed on a input port_id. + + :param node: Quantized node with the weight. + :param target_point: Corresponding target point. + :param ndims: Number of dimensions of weight. + :return: Axes for per-channel quantization of weights. + """ + + @staticmethod + @abstractmethod + def get_statistic_collector( + range_estimator_params: RangeEstimatorParameters, + use_abs_max: bool, + reduction_axes: Optional[Tuple[int, ...]], + aggregation_axes: Optional[Tuple[int, ...]], + inplace: bool, + num_samples: Optional[int] = None, + ) -> TensorStatisticCollectorBase: + """ + Returns backend-specific statistic collector. + + :param range_estimator_params: Parameters that specify estimators types. + :param use_abs_max: Wheather reduce absolute values of input tensors or not. + :param reduction_axes: Axes for reducer. + :param aggregation_axes: Axes for aggregator. + :param inplace: Whether to calculate statistic inplace or not. + :param num_samples: Maximum number of samples to collect. + :return: Backend-specific TensorStatisticCollectorBase for the statistics calculation. + """ + + @staticmethod + @abstractmethod + def get_weight_tensor_port_ids(node: NNCFNode, graph: NNCFGraph) -> List[Optional[int]]: + """ + Returns node's input port indices with weight tensors. + + :param node: NNCFNode to find its weight input port indices. + :param graph: NNCFGraph instance. + :return: Weights input port indices. + """ + + @staticmethod + def get_weight_name(nncf_graph: NNCFGraph, target_point: TargetPoint) -> str: + """ + Returns node's weight name corresponding to port ID. + + :param nncf_graph: NNCFGraph instance. + :param target_point: The TargetPoint instance that contains layer's information. + :return: Weight name. + """ + + @staticmethod + def should_quantize_weight(weight_name: str, quantized_weight_names: Set[str]) -> bool: + """ + Return True if weight should be quantized. + + :param weight_name: Weight name. + :param quantized_weight_names: Set containing already quantized weight names. + :return: A boolean value specifying whether a weight should be quantized. + """ + + @staticmethod + @abstractmethod + def get_ignored_metatypes(model_type: ModelType, device: TargetDevice) -> List[OperatorMetatype]: + """ + Returns ignored metatypes based on a model type and device parameters. + + :param model_type: Model type parameter. + :param device: Target device. + :return: List of ignored metatypes. + """ + + @staticmethod + @abstractmethod + def get_ignored_names_by_layer_attributes(nncf_graph: NNCFGraph) -> Set[str]: + """ + Returns names of ignored nodes based on layer_attributes. + + :param nncf_graph: NNCFGraph instance. + :return: List of ignored names. + """ + + @abstractmethod + def get_weight_nodes(self, nncf_graph: NNCFGraph) -> List[NNCFNode]: + """ + Returns nodes that have weights. + + :param nncf_graph: Instance of NNCFGraph. + :return: All nodes with weights. + """ + + @abstractmethod + def is_matmul_with_constant(self, node: NNCFNode, nncf_graph: NNCFGraph) -> bool: + """ + Returns true if given nncf matmul node is a matmul with a constant, False otherwise. + + :param Node: Instance of NNCFNode. + :param nncf_graph: Instance of NNCFGraph. + :return: True if given nncf matmul node is a matmul with a constant, False otherwise. + """ diff --git a/nncf/experimental/common/quantization/algorithms/quantizer/openvino_quantizer/openvino_quantizer.py b/nncf/experimental/common/quantization/algorithms/quantizer/openvino_quantizer/openvino_quantizer.py new file mode 100644 index 00000000000..11ce83637c2 --- /dev/null +++ b/nncf/experimental/common/quantization/algorithms/quantizer/openvino_quantizer/openvino_quantizer.py @@ -0,0 +1,593 @@ +# Copyright (c) 2024 Intel Corporation +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# http://www.apache.org/licenses/LICENSE-2.0 +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import dataclasses +from copy import deepcopy +from typing import Dict, List, Optional, Set, TypeVar, Union + +import numpy as np + +import nncf +from nncf.common.graph.graph import NNCFGraph +from nncf.common.graph.patterns import GraphPattern +from nncf.common.graph.patterns.manager import PatternsManager +from nncf.common.hardware.config import get_hw_config_type +from nncf.common.insertion_point_graph import InsertionPointGraph +from nncf.common.logging import nncf_logger +from nncf.common.quantization.config_assignment import assign_qconfig_lists_to_modules +from nncf.common.quantization.quantizer_propagation.solver import QuantizerPropagationRule +from nncf.common.quantization.quantizer_propagation.solver import QuantizerPropagationSolver +from nncf.common.quantization.quantizer_propagation.structs import IgnoreReason +from nncf.common.quantization.quantizer_setup import SingleConfigQuantizerSetup +from nncf.common.quantization.structs import QuantizableWeightedLayerNode +from nncf.common.quantization.structs import QuantizationConstraints +from nncf.common.quantization.structs import QuantizationPreset +from nncf.common.quantization.structs import QuantizationScheme +from nncf.common.quantization.structs import QuantizerConfig +from nncf.common.quantization.structs import QuantizerGroup +from nncf.common.utils.backend import BackendType +from nncf.common.utils.backend import get_backend +from nncf.parameters import ModelType +from nncf.parameters import QuantizationMode +from nncf.parameters import TargetDevice +from nncf.quantization.advanced_parameters import FP8QuantizationParameters +from nncf.quantization.advanced_parameters import FP8Type +from nncf.quantization.advanced_parameters import OverflowFix +from nncf.quantization.advanced_parameters import QuantizationParameters +from nncf.experimental.common.quantization.algorithms.quantizer.quantizer import NNCFQuantizer +from nncf.quantization.passes import transform_to_inference_graph +from nncf.scopes import IgnoredScope +from nncf.scopes import get_ignored_node_names_from_ignored_scope + +TModel = TypeVar("TModel") + +DEFAULT_QCONFIG = QuantizerConfig( + num_bits=8, mode=QuantizationScheme.SYMMETRIC, signedness_to_force=None, per_channel=False +) + + +@dataclasses.dataclass +class ModeBasedDefaults: + """ + Contains default values that should be set in case of abscense. + """ + + overflow_fix: OverflowFix = OverflowFix.FIRST_LAYER + activations_quantization_params: Union[QuantizationParameters, FP8QuantizationParameters] = dataclasses.field( + default_factory=QuantizationParameters + ) + weights_quantization_params: Union[QuantizationParameters, FP8QuantizationParameters] = dataclasses.field( + default_factory=QuantizationParameters + ) + + +MODE_BASED_DEFAULTS = { + None: ModeBasedDefaults(), + QuantizationMode.FP8_E4M3: ModeBasedDefaults( + overflow_fix=OverflowFix.DISABLE, + activations_quantization_params=FP8QuantizationParameters(FP8Type.E4M3), + weights_quantization_params=FP8QuantizationParameters(FP8Type.E4M3), + ), + QuantizationMode.FP8_E5M2: ModeBasedDefaults( + overflow_fix=OverflowFix.DISABLE, + activations_quantization_params=FP8QuantizationParameters(FP8Type.E5M2), + weights_quantization_params=FP8QuantizationParameters(FP8Type.E5M2), + ), +} + + +class NNCFOVQuantizer(NNCFQuantizer): + def __init__( + self, + mode: Optional[QuantizationMode] = None, + preset: Optional[QuantizationPreset] = None, + target_device: TargetDevice = TargetDevice.ANY, + model_type: Optional[ModelType] = None, + ignored_scope: Optional[IgnoredScope] = None, + overflow_fix: Optional[OverflowFix] = None, + quantize_outputs: bool = False, + activations_quantization_params: Union[QuantizationParameters, FP8QuantizationParameters] = None, + weights_quantization_params: Union[QuantizationParameters, FP8QuantizationParameters] = None, + quantizer_propagation_rule: Optional[QuantizerPropagationRule] = None, + ): + """ + :param mode: Defines optimization mode for the algorithm. None by default. + :param preset: A preset controls the quantization mode (symmetric and asymmetric). + It can take the following values: + - `performance`: Symmetric quantization of weights and activations. + - `mixed`: Symmetric quantization of weights and asymmetric quantization of activations. + Default value is None. In this case, `mixed` preset is used for `transformer` + model type otherwise `performance`. + :param target_device: A target device the specificity of which will be taken + into account while compressing in order to obtain the best performance + for this type of device, defaults to TargetDevice.ANY. + :param model_type: Model type is needed to specify additional patterns + in the model. Supported only `transformer` now. + :param ignored_scope: An ignored scope that defined the list of model control + flow graph nodes to be ignored during quantization. + :param overflow_fix: This option controls whether to apply the overflow issue + fix for the 8-bit quantization. + :param quantize_outputs: Whether to insert additional quantizers right before + each of the model outputs. + :param activations_quantization_params: Quantization parameters for model + activations. + :param weights_quantization_params: Quantization parameters for model weights. + :param quantizer_propagation_rule: The strategy to be used while propagating and merging quantizers. + """ + self._target_device = target_device + self._mode = mode + self._model_type = model_type + self._overflow_fix = overflow_fix + self._quantize_outputs = quantize_outputs + self._activations_quantization_params = activations_quantization_params + self._weights_quantization_params = weights_quantization_params + self._preset = preset + self._ignored_scope = IgnoredScope() if ignored_scope is None else ignored_scope + self.quantizer_propagation_rule = quantizer_propagation_rule + + # preset definition + if self._preset is None: + if model_type == ModelType.TRANSFORMER: + self._preset = QuantizationPreset.MIXED + else: + self._preset = QuantizationPreset.PERFORMANCE + + self._override_device() + self._set_mode_based_defaults() + self._review_mode_based_defaults() + + self._quantization_params = { + QuantizerGroup.WEIGHTS: self._weights_quantization_params, + QuantizerGroup.ACTIVATIONS: self._activations_quantization_params, + } + + # Calculates global quantizer constraints + self._global_quantizer_constraints = {} + for quantizer_group in QuantizerGroup: + self._global_quantizer_constraints[quantizer_group] = self._get_quantizer_constraints( + quantizer_group, self._preset, self._quantization_params[quantizer_group] + ) + + self._algorithm_key = f"MMQ_{hash(self)}" + + def _override_device(self) -> None: + """ + Overrides NPU device to use CPU quantization scheme. + """ + if self._target_device == TargetDevice.NPU: + act_bits, weight_bits = 8, 8 + if self._activations_quantization_params and self._activations_quantization_params.num_bits: + act_bits = self._activations_quantization_params.num_bits + if self._weights_quantization_params and self._weights_quantization_params.num_bits: + weight_bits = self._weights_quantization_params.num_bits + + if act_bits == 8 and weight_bits == 8: + self._target_device == TargetDevice.CPU + nncf_logger.debug("Target device NPU was changed to CPU!") + + def _set_mode_based_defaults(self) -> None: + """ + Sets defaults for the algorithms based on the provided mode. + """ + mode_based_defaults = MODE_BASED_DEFAULTS[self._mode] + for field in dataclasses.fields(mode_based_defaults): + self_name = "_" + field.name + default_value = getattr(mode_based_defaults, field.name) + if getattr(self, self_name) is None: + setattr(self, self_name, default_value) + + def _review_mode_based_defaults(self): + """ + Reviews default values because mode option doesn't support them. + """ + if self._mode in (QuantizationMode.FP8_E4M3, QuantizationMode.FP8_E5M2): + nncf_logger.warning(f"You're using experimental option mode with {self._mode} value.") + + if self._preset != QuantizationPreset.PERFORMANCE: + raise nncf.ParameterNotSupportedError( + f"preset option with {self._preset} value is not supported with the mode option!" + ) + + if self._target_device not in [TargetDevice.CPU, TargetDevice.ANY]: + raise nncf.ParameterNotSupportedError( + f"target_device option with {self._target_device} value is not supported with the mode option!" + ) + + if self._overflow_fix != OverflowFix.DISABLE: + raise nncf.ParameterNotSupportedError( + f"overflow_fix option with {self._overflow_fix} value is not supported with the mode option!" + ) + + if self._quantize_outputs: + raise nncf.ParameterNotSupportedError("quantize_outputs option is not supported with the mode option!") + + if isinstance(self._weights_quantization_params, QuantizationParameters): + raise nncf.ParameterNotSupportedError( + "quantization_params option for weights with " + f"{self._weights_quantization_params} " + "value is not supported with the mode option!" + ) + + if isinstance(self._activations_quantization_params, QuantizationParameters): + raise nncf.ParameterNotSupportedError( + "quantization_params option for activations with " + f"{self._activations_quantization_params} " + "value is not supported with the mode option!" + ) + elif self._mode is None: + if isinstance(self._weights_quantization_params, FP8QuantizationParameters): + raise nncf.ParameterNotSupportedError( + "quantization_params option for weights with " + f"{self._weights_quantization_params} " + "value is not supported with the mode: None option!" + ) + + if isinstance(self._activations_quantization_params, FP8QuantizationParameters): + raise nncf.ParameterNotSupportedError( + "quantization_params option for activations with " + f"{self._activations_quantization_params} " + "value is not supported with the mode: None option!" + ) + + @property + def available_backends(self) -> List[BackendType]: + return [BackendType.ONNX, BackendType.OPENVINO, BackendType.TORCH, BackendType.TORCH_FX] + + def _get_quantizer_constraints( + self, + group: QuantizerGroup, + preset: QuantizationPreset, + quantization_params: Union[QuantizationParameters, FP8QuantizationParameters], + ) -> QuantizationConstraints: + """ + Returns QuantizationConstraints for the provided quantizer group. + + :param group: Quantizer group. + :param preset: Quantization preset. + :param quantization_params: Quantization parameters. + :return: QuantizationConstraints. + """ + constraints = {"mode": preset.get_params_configured_by_preset(group)["mode"]} + if quantization_params is None: + return QuantizationConstraints(**constraints) + + if isinstance(quantization_params, FP8QuantizationParameters): + if self._mode is None: + raise nncf.InternalError( + f"FP8QuantizationParameters for {group.value} can not be used without QuantizationMode option!" + ) + return QuantizationConstraints(**constraints) + + if quantization_params.mode is not None: + constraints["mode"] = quantization_params.mode + if quantization_params.num_bits is not None: + constraints["num_bits"] = quantization_params.num_bits + if quantization_params.per_channel is not None: + constraints["per_channel"] = quantization_params.per_channel + if quantization_params.signedness_to_force is not None: + constraints["signedness_to_force"] = quantization_params.signedness_to_force + + return QuantizationConstraints(**constraints) + + def _set_backend_entity(self, model: TModel) -> None: + """ + Creates a helper class with a backed-specific logic of the algorithm + + :param model: backend-specific input model + """ + model_backend = get_backend(model) + if model_backend == BackendType.TORCH_FX: + from nncf.experimental.common.quantization.algorithms.quantizer.openvino_quantizer.torch_fx_backend import OpenVINOQuantizerBackend + + self._backend_entity = OpenVINOQuantizerBackend() + else: + raise nncf.UnsupportedBackendError( + "Cannot return backend-specific entity because {} is not supported!".format(model_backend.value) + ) + + def _get_default_qconfig(self, constraints: QuantizationConstraints = None) -> QuantizerConfig: + """ + Returns default quantizer configuration, based on the provided constraints. + + :param constraints: Quantization constraints. + :return: Quantizer config. + """ + qconfig = deepcopy(DEFAULT_QCONFIG) + if constraints is not None: + qconfig = constraints.apply_constraints_to(qconfig) + return qconfig + + def _get_ignored_names( + self, nncf_graph: NNCFGraph, inference_nncf_graph: NNCFGraph, ignored_patterns: GraphPattern + ) -> Dict[str, IgnoreReason]: + """ + Returns all node names that are ignored for quantization: + Firstly, the ignored names are obtained from user-defined ignored the scope. + Secondly, the ignored names are updated from model_type parameter. + Lastly, the ignored names are updated from ignored_patterns. + + :param nncf_graph: NNCFGraph instance. + :param inference_nncf_graph: Inference graph without constant flows. + :param ignored_patterns: Ignored patterns. + :return: Ignored node names and ignore reason for quantization. + """ + user_ignored_names = get_ignored_node_names_from_ignored_scope( + self._ignored_scope, nncf_graph, strict=self._ignored_scope.validate + ) + autogenerated_ignored_names = self._get_ignored_names_by_ignored_patterns( + inference_nncf_graph, ignored_patterns + ) + autogenerated_ignored_names |= self._backend_entity.get_ignored_names_by_layer_attributes(inference_nncf_graph) + autogenerated_ignored_names |= self._get_ignored_names_by_algorithm(inference_nncf_graph) + ignored_names = {name: IgnoreReason.AUTOGENERATED for name in autogenerated_ignored_names} + # User ignored scope has higher priority + ignored_names.update({name: IgnoreReason.USER_REQUESTED for name in user_ignored_names}) + return ignored_names + + def _get_ignored_names_by_ignored_patterns( + self, inference_nncf_graph: NNCFGraph, ignored_patterns: GraphPattern + ) -> Set[str]: + """ + Returns node names matched ignored_patterns. + + :param nncf_graph: Inference graph without constant flows. + :param ignored_patterns: Ignored patterns. + :return: IgnoredScope with all node names matched ignored_patterns. + """ + nncf_node_names = set() + for subgraph in inference_nncf_graph.find_matching_subgraphs(ignored_patterns, strict=False): + for nncf_node in subgraph: + nncf_node_names.add(nncf_node.node_name) + return nncf_node_names + + def _get_ignored_names_by_algorithm(self, inference_nncf_graph: NNCFGraph) -> Set[str]: + """ + Returns node names for ignored_algorithms matched `quantization`. + + :param inference_nncf_graph: Inference NNCFGraph instance. + :return: IgnoredScope with corresponded nodes. + """ + nncf_node_names = set() + for nncf_node in inference_nncf_graph.get_all_nodes(): + if "ptq_quantization" in nncf_node.ignored_algorithms: + nncf_node_names.add(nncf_node.node_name) + return nncf_node_names + + def _get_scope_overrides(self, inference_nncf_graph: NNCFGraph) -> Dict: + """ + Returns a dictionary of quantization configuration overrides for inputs to matching operation nodes. + + :param inference_nncf_graph: Inference NNCFGraph instance. + :return: A dictionary of quantization configuration overrides for inputs to matching operation nodes. + """ + scaled_dot_product_attention_node_names = [ + node.node_name + for node in inference_nncf_graph.get_nodes_by_metatypes( + self._backend_entity.scaled_dot_product_attention_metatypes + ) + ] + + scope_overrides_activations = {} + for node_name in scaled_dot_product_attention_node_names: + scope_overrides_activations[node_name] = {"mode": "symmetric"} + return {"activations": scope_overrides_activations} + + def _get_quantizer_setup( + self, + nncf_graph: NNCFGraph, + inference_nncf_graph: NNCFGraph, + hw_patterns: GraphPattern, + ignored_patterns: GraphPattern, + ) -> SingleConfigQuantizerSetup: + """ + Returns SingleConfigQuantizerSetup instance based on the input NNCFGraph. + + :param nncf_graph: NNCFGraph instance. + :param hw_patterns: Hardware patterns. + :param ignored_patterns: Ignored patterns. + :return: SingleConfigQuantizerSetup for the current NNCFGraph entity. + """ + hw_config_type = get_hw_config_type(self._target_device.value) + hw_config_path = self._backend_entity.hw_config.get_path_to_hw_config(hw_config_type) + hw_config = self._backend_entity.hw_config.from_json(hw_config_path) + + ignored_names = self._get_ignored_names(nncf_graph, inference_nncf_graph, ignored_patterns) + weight_nodes = self._backend_entity.get_weight_nodes(nncf_graph) + + default_weight_qconfig = self._get_default_qconfig(self._global_quantizer_constraints[QuantizerGroup.WEIGHTS]) + weighted_node_and_qconf_lists = assign_qconfig_lists_to_modules( + nodes_with_weights=weight_nodes, + default_weight_qconfig=default_weight_qconfig, + global_weight_constraints=self._global_quantizer_constraints[QuantizerGroup.WEIGHTS], + scope_overrides_dict=None, + hw_config=hw_config, + ) + quantizable_layer_nodes = [ + QuantizableWeightedLayerNode(node, qconf_list) for node, qconf_list in weighted_node_and_qconf_lists.items() + ] + + scope_overrides = self._get_scope_overrides(inference_nncf_graph) + + ip_graph = InsertionPointGraph(inference_nncf_graph) + ip_graph = ip_graph.get_ip_graph_with_merged_hw_optimized_operations(hw_patterns) + post_processing_types = self._backend_entity.post_processing_metatypes + metatypes_to_ignore = self._backend_entity.get_ignored_metatypes(self._model_type, self._target_device) + solver = QuantizerPropagationSolver( + activation_ignored_scopes=ignored_names, + weight_ignored_scopes=list(ignored_names.keys()), + hw_config=hw_config, + default_trait_to_metatype_map=self._backend_entity.quant_trait_op_dict, + propagation_strategy=self.quantizer_propagation_rule, + default_qconfig_list=[ + self._get_default_qconfig(self._global_quantizer_constraints[QuantizerGroup.ACTIVATIONS]) + ], + quantizable_layer_nodes=quantizable_layer_nodes, + quantize_outputs=self._quantize_outputs, + global_constraints=self._global_quantizer_constraints, + post_processing_marker_metatypes=post_processing_types, + metatypes_to_ignore=metatypes_to_ignore, + scales_unification_map=self._backend_entity.scales_unification_map, + scope_overrides=scope_overrides, + ) + + quantization_proposal = solver.run_on_ip_graph(ip_graph, self._backend_entity.elementwise_metatypes) + multi_config_setup = quantization_proposal.quantizer_setup + single_config_setup = multi_config_setup.select_first_qconfig_for_each_point() + finalized_proposal = quantization_proposal.finalize(single_config_setup) + final_setup = solver.get_final_quantizer_setup(finalized_proposal) + return final_setup + + def get_quantization_setup(self, model: TModel, nncf_graph: NNCFGraph) -> SingleConfigQuantizerSetup: + """ + Initializes a cache, finds quantization target points and them puts in the cache. + + :param model: Backend-specific model, for which Quantization Target Points are being seek. + :param nncf_graph: NNCFGraph instance. + :return: Mapping of quantization target points with associated quantization configuration, + along with target points for scale unification. + """ + self._set_backend_entity(model) + backend = get_backend(model) + device = self._target_device + model_type = self._model_type + ignored_patterns = PatternsManager.get_full_ignored_pattern_graph( + backend=backend, device=device, model_type=model_type + ) + hw_patterns = PatternsManager.get_full_hw_pattern_graph(backend=backend, device=device, model_type=model_type) + + inference_nncf_graph = transform_to_inference_graph( + deepcopy(nncf_graph), + self._backend_entity.get_start_nodes_for_activation_path_tracing(nncf_graph), + self._backend_entity.shapeof_metatypes, + self._backend_entity.dropout_metatypes, + self._backend_entity.preserved_metatypes, + ) + + quantizer_setup = self._get_quantizer_setup(nncf_graph, inference_nncf_graph, hw_patterns, ignored_patterns) + self._apply_model_type_pass(self._model_type, quantizer_setup, nncf_graph) + self._apply_device_pass(self._target_device, quantizer_setup, inference_nncf_graph) + return quantizer_setup + + def _apply_model_type_pass( + self, model_type: Optional[ModelType], quantizer_setup: SingleConfigQuantizerSetup, nncf_graph: NNCFGraph + ) -> None: + """ + Applies changes in-place into quantizer setup based on model_type and device parameters. + + :param model_type: Model type parameter. + :param quantizer_setup: Quantizer setup which considered to update. + :param nncf_graph: Instance of NNCFGraph. + :return: None + """ + if model_type == ModelType.TRANSFORMER: + for quantization_point in quantizer_setup.quantization_points.values(): + if quantization_point.is_activation_quantization_point(): + for node_name in quantization_point.directly_quantized_operator_node_names: + node = nncf_graph.get_node_by_name(node_name) + if node.metatype not in self._backend_entity.mat_mul_metatypes: + continue + if ( + quantization_point.qconfig.mode != QuantizationScheme.SYMMETRIC + and not self._backend_entity.is_matmul_with_constant(node, nncf_graph) + ): + quantization_point.qconfig.mode = QuantizationScheme.SYMMETRIC + nncf_logger.debug( + f"Update quantization mode for the node {node_name}" + f" to the symmetric due to ModelType parameter." + ) + + def _apply_device_pass( + self, target_device: TargetDevice, quantizer_setup: SingleConfigQuantizerSetup, nncf_graph: NNCFGraph + ) -> None: + """ + This method applies model post-processing device passes to SingleConfigQuantizerSetup in-place. + + :param target_device: TargetDevice instance. + :param quantizer_setup: SingleConfigQuantizerSetup instance to update. + :param nncf_graph: NNCFGraph. + :return: None. + """ + + passes_map = {TargetDevice.CPU_SPR: self._apply_spr_pass} + + if target_device not in passes_map: + return + + passes_map[target_device](quantizer_setup, nncf_graph) + + def _apply_spr_pass( + self, quantizer_setup: SingleConfigQuantizerSetup, nncf_graph: NNCFGraph + ) -> SingleConfigQuantizerSetup: + """ + Applies CPU_SPR-related pass. + The main action is to remove one of the quantizers before elementwise layer (e.g. Add). + This action allows to get performance boost on SPR devices. + + :param quantizer_setup: SingleConfigQuantizerSetup instance to update. + :param nncf_graph: NNCFGraph instance to update. + :return: Modified SingleConfigQuantizerSetup. + """ + + def _is_node_after_producers(node): + input_node = node + while True: + input_node = nncf_graph.get_previous_nodes(input_node) + if len(input_node) > 1: + return False + input_node = input_node[0] + if input_node.metatype in producer_metatypes: + return True + + producer_metatypes = ( + self._backend_entity.conv_metatypes + + self._backend_entity.mat_mul_metatypes + + self._backend_entity.group_conv_metatypes + ) + + quantizer_setup_map = { + p.insertion_point.target_node_name: q_key for q_key, p in quantizer_setup.quantization_points.items() + } + + # Walking through all Add layers. + for add_node in nncf_graph.get_nodes_by_metatypes(self._backend_entity.add_metatypes): + add_inputs = nncf_graph.get_previous_nodes(add_node) + + # Filtering Add based on it's input. + # Need to find Add layer only with two activations as input. + if len(add_inputs) == 2 and all(n.node_name in quantizer_setup_map for n in add_inputs): + # Sorting of the inputs based on length of input's consumer in descending order. + add_inputs.sort(key=lambda n: len(nncf_graph.get_next_nodes(n)), reverse=True) + fq_1_producer, fq_2_producer = add_inputs + fq_1_q_key = quantizer_setup_map[fq_1_producer.node_name] + fq_2_q_key = quantizer_setup_map[fq_2_producer.node_name] + + # In the case of the two quantizers where one of them produces data into branching, + # it needs to remove the quantizer without branching after it. + if ( + len(nncf_graph.get_next_nodes(fq_1_producer)) > 1 + and len(nncf_graph.get_next_nodes(fq_2_producer)) == 1 + ): + quantizer_setup.discard(fq_2_q_key, True) + continue + + # In the case of the two quantizers without the branching after them, + # it needs to check that all quantizers follows after producer nodes. + if _is_node_after_producers(fq_1_producer) and _is_node_after_producers(fq_2_producer): + fq_1_prod_shape = np.prod(nncf_graph.get_output_edges_by_port_id(fq_1_producer, 0)[0].tensor_shape) + fq_2_prod_shape = np.prod(nncf_graph.get_output_edges_by_port_id(fq_2_producer, 0)[0].tensor_shape) + + # Then it needs to remove quantizer with the smallest shape. + if fq_1_prod_shape >= fq_2_prod_shape: + quantizer_setup.discard(fq_1_q_key, True) + else: + quantizer_setup.discard(fq_2_q_key, True) + + return quantizer_setup diff --git a/nncf/experimental/common/quantization/algorithms/quantizer/openvino_quantizer/torch_fx_backend.py b/nncf/experimental/common/quantization/algorithms/quantizer/openvino_quantizer/torch_fx_backend.py new file mode 100644 index 00000000000..4115bec611e --- /dev/null +++ b/nncf/experimental/common/quantization/algorithms/quantizer/openvino_quantizer/torch_fx_backend.py @@ -0,0 +1,366 @@ +# Copyright (c) 2024 Intel Corporation +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# http://www.apache.org/licenses/LICENSE-2.0 +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, List, Optional, Set, Tuple + +import torch +from torch.quantization.fake_quantize import FakeQuantize + +import nncf +import nncf.torch.graph.operator_metatypes as om +from nncf.common.graph.graph import NNCFGraph +from nncf.common.graph.graph import NNCFNode +from nncf.common.graph.operator_metatypes import OperatorMetatype +from nncf.common.graph.transformations.commands import TargetType +from nncf.common.graph.transformations.commands import TransformationCommand +from nncf.common.hardware.config import HWConfig +from nncf.common.quantization.structs import QuantizationScheme as QuantizationMode +from nncf.common.quantization.structs import QuantizerConfig +from nncf.experimental.common.tensor_statistics.collectors import AGGREGATORS_MAP +from nncf.experimental.common.tensor_statistics.collectors import TensorCollector +from nncf.experimental.common.tensor_statistics.statistics import MinMaxTensorStatistic +from nncf.experimental.torch.fx.commands import FXApplyTransformationCommand +from nncf.experimental.torch.fx.model_utils import get_target_point +from nncf.experimental.torch.fx.transformations import qdq_insertion_transformation_builder +from nncf.parameters import ModelType +from nncf.parameters import TargetDevice +from nncf.quantization.advanced_parameters import StatisticsType +from nncf.experimental.common.quantization.algorithms.quantizer.openvino_quantizer.backend import OpenVINOQuantizerBackend +from nncf.quantization.fake_quantize import FakeConvertParameters +from nncf.quantization.fake_quantize import FakeQuantizeParameters +from nncf.quantization.range_estimator import AggregatorType +from nncf.quantization.range_estimator import RangeEstimatorParameters +from nncf.torch.graph.graph import PTNNCFGraph +from nncf.torch.graph.graph import PTTargetPoint +from nncf.torch.graph.operator_metatypes import ELEMENTWISE_OPERATIONS +from nncf.torch.graph.transformations.commands import PTSharedFnInsertionCommand +from nncf.torch.hardware.config import PTHWConfig +from nncf.torch.model_graph_manager import get_weight_tensor_port_ids +from nncf.torch.nncf_network import NNCFNetwork +from nncf.torch.quantization.default_quantization import DEFAULT_PT_QUANT_TRAIT_TO_OP_DICT +from nncf.torch.quantization.layers import QUANTIZATION_MODULES +from nncf.torch.quantization.layers import AsymmetricQuantizer +from nncf.torch.quantization.layers import BaseQuantizer +from nncf.torch.quantization.layers import PTQuantizerSpec +from nncf.torch.quantization.layers import get_scale_shape +from nncf.torch.quantization.strip import convert_to_torch_fakequantizer +from nncf.torch.tensor_statistics.collectors import PT_REDUCERS_MAP + +FXMinMaxAlgoBackend = None + + +class FXNNCFQuantizerBackend(OpenVINOQuantizerBackend): + + @property + def preserved_metatypes(self) -> List[OperatorMetatype]: + return [] + + @property + def mat_mul_metatypes(self) -> List[OperatorMetatype]: + return [om.PTLinearMetatype, om.PTMatMulMetatype] + + @property + def post_processing_metatypes(self) -> List[OperatorMetatype]: + return [] + + @property + def shapeof_metatypes(self) -> List[OperatorMetatype]: + return [] + + @property + def dropout_metatypes(self) -> List[OperatorMetatype]: + return [om.PTDropoutMetatype] + + @property + def read_variable_metatypes(self) -> List[OperatorMetatype]: + return [] + + @property + def conv_metatypes(self) -> List[OperatorMetatype]: + return [om.PTConv1dMetatype, om.PTConv2dMetatype, om.PTConv3dMetatype] + + @property + def elementwise_metatypes(self) -> List[OperatorMetatype]: + return ELEMENTWISE_OPERATIONS + + @property + def overflow_fix_metatypes(self) -> List[OperatorMetatype]: + return [ + om.PTConv1dMetatype, + om.PTConv2dMetatype, + om.PTConv3dMetatype, + om.PTLinearMetatype, + om.PTConvTranspose1dMetatype, + om.PTConvTranspose2dMetatype, + om.PTConvTranspose3dMetatype, + ] + + @property + def add_metatypes(self) -> List[OperatorMetatype]: + return [om.PTAddMetatype] + + @property + def group_conv_metatypes(self) -> List[OperatorMetatype]: + return self.conv_metatypes + + @property + def scaled_dot_product_attention_metatypes(self) -> List[OperatorMetatype]: + return [om.PTScaledDotProductAttentionMetatype] + + @property + def scales_unification_map(self) -> Dict[OperatorMetatype, OperatorMetatype]: + return {om.PTCatMetatype: self.overflow_fix_metatypes} + + @property + def hw_config(self) -> HWConfig: + return PTHWConfig + + @property + def quant_trait_op_dict(self) -> Dict[int, OperatorMetatype]: + return DEFAULT_PT_QUANT_TRAIT_TO_OP_DICT + + @staticmethod + def get_start_nodes_for_activation_path_tracing(nncf_graph: PTNNCFGraph) -> List[NNCFNode]: + return nncf_graph.get_input_nodes() + + @staticmethod + def target_point(target_type: TargetType, target_node_name: str, port_id: int) -> PTTargetPoint: + return get_target_point(target_type, target_node_name, port_id) + + @staticmethod + def create_convert_insertion_command( + target_point: PTTargetPoint, + parameters: FakeConvertParameters, + ) -> TransformationCommand: + raise nncf.InternalError("FakeConvert insertion not implemented in PyTorch backend!") + + @staticmethod + def get_target_point_shape(nncf_graph: PTNNCFGraph, node: NNCFNode, target_point: PTTargetPoint) -> Tuple[int, ...]: + return nncf_graph.get_input_shape_for_insertion_point(target_point) + + @staticmethod + def get_weight_quantization_axes(node: NNCFNode, target_point: PTTargetPoint, ndims: int) -> Tuple[int]: + # TODO(dlyakhov): support transpose conv and other cases + return (0,) + + @staticmethod + def get_statistic_collector( + range_estimator_params: RangeEstimatorParameters, + use_abs_max: bool, + reduction_axes: Optional[Tuple[int, ...]], + aggregation_axes: Optional[Tuple[int, ...]], + inplace: bool, + num_samples: Optional[int] = None, + ) -> TensorCollector: + collector = TensorCollector(MinMaxTensorStatistic) + for params, container_key in zip( + [range_estimator_params.min, range_estimator_params.max], + [MinMaxTensorStatistic.MIN_STAT, MinMaxTensorStatistic.MAX_STAT], + ): + if params.statistics_type not in PT_REDUCERS_MAP: + raise nncf.InternalError( + f"Statistic type: {params.statistics_type} is not supported for Torch PTQ backend yet." + ) + + if params.aggregator_type not in AGGREGATORS_MAP: + raise nncf.InternalError( + f"Aggregator type: {params.aggregator_type} is not supported for Torch PTQ backend yet." + ) + + statistic_type = params.statistics_type + if statistic_type in [StatisticsType.QUANTILE, StatisticsType.ABS_QUANTILE]: + # TODO(dlyakhov): merge two quantile aggregators in one + if container_key == MinMaxTensorStatistic.MIN_STAT: + quantile = params.quantile_outlier_prob + else: + quantile = 1 - params.quantile_outlier_prob + reducer = PT_REDUCERS_MAP[statistic_type](reduction_axes=reduction_axes, quantile=[quantile]) + else: + if use_abs_max and statistic_type == StatisticsType.MAX: + statistic_type = StatisticsType.ABS_MAX + reducer = PT_REDUCERS_MAP[statistic_type](reduction_axes=reduction_axes) + + kwargs = { + "num_samples": num_samples, + "aggregation_axes": aggregation_axes, + } + if params.aggregator_type in [AggregatorType.MEAN_NO_OUTLIERS, AggregatorType.MEDIAN_NO_OUTLIERS]: + kwargs.update({"quantile": params.quantile_outlier_prob}) + aggregator = AGGREGATORS_MAP[params.aggregator_type](**kwargs) + + collector.register_statistic_branch(container_key, reducer, aggregator) + return collector + + @staticmethod + def get_weight_tensor_port_ids(node: NNCFNode, graph: NNCFGraph) -> List[Optional[int]]: + return get_weight_tensor_port_ids(node, graph) + + @staticmethod + def get_weight_name(nncf_graph: NNCFGraph, target_point: PTTargetPoint) -> str: + weighted_node = nncf_graph.get_node_by_name(target_point.target_node_name) + weight_edge = nncf_graph.get_input_edge_by_port_id(weighted_node, target_point.input_port_id) + weight = weight_edge.from_node + return weight.node_name + + @staticmethod + def should_quantize_weight(weight_name: str, quantized_weight_names: Set[str]) -> bool: + # If the nodes share one weight tensor, we should have only one quantizer on that + return weight_name not in quantized_weight_names + + @staticmethod + def get_weight_config(config: QuantizerConfig, model: NNCFNetwork) -> QuantizerConfig: + return config + + @staticmethod + def _get_input_scale_shape( + nncf_graph: NNCFGraph, target_point: PTTargetPoint, per_channel: bool + ) -> Tuple[Tuple[int, ...], Tuple[int, ...], int]: + is_weights = target_point.is_weight_target_point() + if is_weights: + # TODO(dlyakhov): support transpose conv/ make channel_idx common + channel_idx = 0 + else: + channel_idx = 1 # channel dim for activations + + input_shape = nncf_graph.get_input_shape_for_insertion_point(target_point) + scale_shape = tuple( + get_scale_shape(input_shape, is_weights=is_weights, per_channel=per_channel, channel_idx=channel_idx) + ) + + return input_shape, scale_shape, channel_idx + + @staticmethod + def _create_quantizer( + quantizer_config: QuantizerConfig, + scale_shape: Tuple, + parameters: FakeQuantizeParameters, + target_type: TargetType, + ) -> FakeQuantize: + mode = quantizer_config.mode + quantizer_cls = QUANTIZATION_MODULES.get(mode) + narrow_range = target_type == TargetType.OPERATION_WITH_WEIGHTS and mode == QuantizationMode.SYMMETRIC + quantizer_spec = PTQuantizerSpec.from_config( + quantizer_config, + narrow_range=narrow_range, + scale_shape=scale_shape, + half_range=False, + logarithm_scale=False, + is_quantized_on_export=False, + compression_lr_multiplier=None, + ) + quantizer = quantizer_cls(quantizer_spec) + + # Fill it with minmax + # TODO(dlyakhov) Prevent creation of intermediate objects like nncf quantizer. + FXMinMaxAlgoBackend._fill_quantizer_parameters(quantizer, parameters, quantizer_spec.scale_shape) + # Convert to the torch fake quantizer + torch_fq = convert_to_torch_fakequantizer(quantizer) + return torch_fq + + @staticmethod + def _fill_quantizer_parameters(quantizer: BaseQuantizer, parameters: FakeQuantizeParameters, scale_shape) -> None: + if isinstance(quantizer, AsymmetricQuantizer): + quantizer.input_low = torch.nn.Parameter(parameters.input_low.data.reshape(scale_shape)) + input_range = parameters.input_high - parameters.input_low + # Subtract eps from the input_range to make quantizer parameters equal to + # original parameters on the forward call. + quantizer.input_range = torch.nn.Parameter((input_range.data - quantizer.eps).reshape(scale_shape)) + else: + quantizer.signed = bool(torch.any(parameters.input_low.data < 0)) + # Subtract eps from the scale to make quantizer parameters equal to + # original parameters on the forward call. + quantizer.scale = torch.nn.Parameter((parameters.input_high.data - quantizer.eps).reshape(scale_shape)) + + @staticmethod + def create_quantizer_insertion_command( + nncf_graph: NNCFGraph, + target_point: PTTargetPoint, + quantizer_config: QuantizerConfig, + parameters: FakeQuantizeParameters, + ) -> FXApplyTransformationCommand: + _, scale_shape, _ = FXMinMaxAlgoBackend._get_input_scale_shape( + nncf_graph, target_point, quantizer_config.per_channel + ) + + quantizer = FXMinMaxAlgoBackend._create_quantizer( + quantizer_config, scale_shape, parameters, target_point.target_type + ) + transformation = qdq_insertion_transformation_builder(quantizer, [target_point]) + return FXApplyTransformationCommand(transformation) + + @staticmethod + def create_unified_scales_quantizers_insertion_commands( + nncf_graph: NNCFGraph, + target_points: List[PTTargetPoint], + quantizer_config: QuantizerConfig, + parameters: FakeQuantizeParameters, + ) -> List[PTSharedFnInsertionCommand]: + _, scale_shape, _ = FXMinMaxAlgoBackend._get_input_scale_shape( + nncf_graph, target_points[0], quantizer_config.per_channel + ) + + quantizer = FXMinMaxAlgoBackend._create_quantizer( + quantizer_config, scale_shape, parameters, target_points[0].target_type + ) + + transformations = [] + for tp in target_points: + transformation = qdq_insertion_transformation_builder(quantizer, [tp]) + transformations.append(FXApplyTransformationCommand(transformation)) + return transformations + + @staticmethod + def get_ignored_metatypes(model_type: ModelType, device: TargetDevice) -> List[OperatorMetatype]: + types = [] + if model_type == ModelType.TRANSFORMER: + types = [ + om.PTAddMetatype, + om.PTPowerMetatype, + om.PTSubMetatype, + om.PTAvgPool2dMetatype, + om.PTAvgPool3dMetatype, + om.PTMeanMetatype, + om.PTSumMetatype, + om.PTReduceL2, + om.PTDivMetatype, + om.PTMaxMetatype, + om.PTSqueezeMetatype, + om.PTLayerNormMetatype, + om.PTModuleLayerNormMetatype, + om.PTGroupNormMetatype, + om.PTModuleGroupNormMetatype, + # Batchnorm + om.PTBatchNormMetatype, + om.PTModuleBatchNormMetatype, + ] + if device != TargetDevice.CPU_SPR: + types.append(om.PTMulMetatype) + return types + + @staticmethod + def get_ignored_names_by_layer_attributes(nncf_graph: NNCFGraph) -> Set[str]: + return set() + + def get_weight_nodes(self, nncf_graph: NNCFGraph) -> List[NNCFNode]: + weight_nodes_candidates = [ + node + for node in nncf_graph.get_all_nodes() + if issubclass(node.metatype, om.PTOperatorMetatype) and node.metatype.weight_port_ids + ] + weight_nodes = [] + for node in weight_nodes_candidates: + if node.metatype in self.mat_mul_metatypes and not self.is_matmul_with_constant(node, nncf_graph): + continue + weight_nodes.append(node) + return weight_nodes + + def is_matmul_with_constant(self, node: NNCFNode, nncf_graph: NNCFGraph) -> bool: + return node.metatype in self.mat_mul_metatypes and len(get_weight_tensor_port_ids(node, nncf_graph)) > 0 diff --git a/nncf/quantization/algorithms/min_max/quantizer/backend.py b/nncf/quantization/algorithms/min_max/quantizer/backend.py new file mode 100644 index 00000000000..821d57a82ea --- /dev/null +++ b/nncf/quantization/algorithms/min_max/quantizer/backend.py @@ -0,0 +1,323 @@ +# Copyright (c) 2024 Intel Corporation +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# http://www.apache.org/licenses/LICENSE-2.0 +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from abc import ABC +from abc import abstractmethod +from typing import Dict, List, Optional, Set, Tuple, TypeVar + +from nncf.common.graph.graph import NNCFGraph +from nncf.common.graph.graph import NNCFNode +from nncf.common.graph.operator_metatypes import OperatorMetatype +from nncf.common.graph.transformations.commands import TargetPoint +from nncf.common.graph.transformations.commands import TargetType +from nncf.common.graph.transformations.commands import TransformationCommand +from nncf.common.hardware.config import HWConfig +from nncf.common.quantization.structs import QuantizerConfig +from nncf.common.tensor_statistics.collectors import TensorStatisticCollectorBase +from nncf.parameters import ModelType +from nncf.parameters import TargetDevice +from nncf.quantization.fake_quantize import FakeConvertParameters +from nncf.quantization.fake_quantize import FakeQuantizeParameters +from nncf.quantization.range_estimator import RangeEstimatorParameters + +TModel = TypeVar("TModel") + + +class NNCFQuantizerBackend(ABC): + @property + @abstractmethod + def preserved_metatypes(self) -> List[OperatorMetatype]: + """ + Property for backend-specific metatypes that require preserving float subgraphs + when removing the ShapeOf subgraph. + """ + + @property + @abstractmethod + def mat_mul_metatypes(self) -> List[OperatorMetatype]: + """ + Property for the backend-specific MatMul metatypes. + """ + + @property + @abstractmethod + def post_processing_metatypes(self) -> List[OperatorMetatype]: + """ + Property for the backend-specific post-processing metatypes (NonMaximumSupression, TopK, etc.). + """ + + @property + @abstractmethod + def conv_metatypes(self) -> List[OperatorMetatype]: + """ + Property for the backend-specific Convolution metatypes. + """ + + @property + @abstractmethod + def shapeof_metatypes(self) -> List[OperatorMetatype]: + """ + Property for the backend-specific ShapeOf metatypes. + """ + + @property + @abstractmethod + def dropout_metatypes(self) -> List[OperatorMetatype]: + """ + Property for the backend-specific Dropout metatypes. + """ + + @property + @abstractmethod + def elementwise_metatypes(self) -> List[OperatorMetatype]: + """ + Property for the backend-specific Elementwises metatypes. + """ + + @property + @abstractmethod + def overflow_fix_metatypes(self) -> List[OperatorMetatype]: + """ + Property for the backend-specific metatypes for which overflow_fix is applicable. + """ + + @property + @abstractmethod + def add_metatypes(self) -> List[OperatorMetatype]: + """ + Property for the backend-specific metatypes that also can be interpreted as Add layer. + """ + + @property + @abstractmethod + def group_conv_metatypes(self) -> List[OperatorMetatype]: + """ + Property for the backend-specific Grouped Convolution metatypes. + """ + + @property + @abstractmethod + def scaled_dot_product_attention_metatypes(self) -> List[OperatorMetatype]: + """ + Property for the backend-specific Scaled Dot Product Attention metatypes. + """ + + @property + @abstractmethod + def scales_unification_map(self) -> Dict[OperatorMetatype, OperatorMetatype]: + """ + Property for the backend-specific metatypes that produces quantizers that might be unified. + """ + + @property + @abstractmethod + def hw_config(self) -> HWConfig: + """ + Property for the hardware backend-specific configuration. + """ + + @property + @abstractmethod + def quant_trait_op_dict(self) -> Dict[int, OperatorMetatype]: + """ + Property for the backend-specific dictionary that contains QuantizationTrait-specific metatypes. + """ + + @staticmethod + @abstractmethod + def target_point(target_type: TargetType, target_node_name: str, port_id: int) -> TargetPoint: + """ + Returns backend-specific target point. + + :param target_type: Type of the location that should be modified. + :param target_node_name: Name of the located node. + :param port_id: Port ID of the tensor for the statistics distribution. + :return: Backend-specific TargetPoint. + """ + + @staticmethod + @abstractmethod + def create_quantizer_insertion_command( + nncf_graph: NNCFGraph, + target_point: TargetPoint, + quantizer_config: QuantizerConfig, + parameters: FakeQuantizeParameters, + ) -> TransformationCommand: + """ + Returns backend-specific quantizer insertion command. + + :param nncf_graph: NNCFGraph to get input/output shapes for the target point. + :param target_point: Target location for the quantizer insertion. + :param quantizer_config: QuantizerConfig instance for the current layer. + :param parameters: FakeQuantizeParameters to calculate activation quantization parameters. + :return: Backend-specific TransformationCommand for the quantizer insertion operation. + """ + + @staticmethod + @abstractmethod + def create_unified_scales_quantizers_insertion_commands( + nncf_graph: NNCFGraph, + target_points: List[TargetPoint], + quantizer_config: QuantizerConfig, + parameters: FakeQuantizeParameters, + ) -> List[TransformationCommand]: + """ + Returns backend-specific unified scales quantizers insertion commands. + + :param nncf_graph: NNCFGraph to get input/output shapes for the target point. + :param target_points: List of target locations for the quantizers insertion. + :param quantizer_config: QuantizerConfig instance for the current layer. + :param parameters: FakeQuantizeParameters to calculate activation quantization parameters. + :return: List of backend-specific TransformationCommands + for the quantizers with unified scales insertion operations. + """ + + @staticmethod + @abstractmethod + def create_convert_insertion_command( + target_point: TargetPoint, + parameters: FakeConvertParameters, + ) -> TransformationCommand: + """ + Returns backend-specific convert insertion command. + + :param target_point: Target location for the correction. + :param parameters: FakeConvertParameters to calculate activation quantization parameters. + :return: Backend-specific TransformationCommand for the quantizer insertion operation. + """ + + @staticmethod + @abstractmethod + def get_start_nodes_for_activation_path_tracing(nncf_graph: NNCFGraph) -> List[NNCFNode]: + """ + Returns a list of NNCFNodes to use as start nodes for activation path tracing. + + :param nncf_graph: NNCFGraph to get the start nodes. + :return: List of NNCFNodes to use as start nodes for activation path tracing. + + """ + + @staticmethod + @abstractmethod + def get_target_point_shape(nncf_graph: NNCFGraph, node: NNCFNode, target_point: TargetPoint) -> Tuple[int, ...]: + """ + Returns shape of a target point tensor. + + :param nncf_graph: NNCFGraph instance. + :param node: NNCFNode. + :param target_point: Target point of which tensor shape is seeked. + :return: Shape of target point tensor. + """ + + @staticmethod + @abstractmethod + def get_weight_quantization_axes(node: NNCFNode, target_point: TargetPoint, ndims: int) -> Tuple[int, ...]: + """ + Returns axes for per-channel quantization of weights of the node placed on a input port_id. + + :param node: Quantized node with the weight. + :param target_point: Corresponding target point. + :param ndims: Number of dimensions of weight. + :return: Axes for per-channel quantization of weights. + """ + + @staticmethod + @abstractmethod + def get_statistic_collector( + range_estimator_params: RangeEstimatorParameters, + use_abs_max: bool, + reduction_axes: Optional[Tuple[int, ...]], + aggregation_axes: Optional[Tuple[int, ...]], + inplace: bool, + num_samples: Optional[int] = None, + ) -> TensorStatisticCollectorBase: + """ + Returns backend-specific statistic collector. + + :param range_estimator_params: Parameters that specify estimators types. + :param use_abs_max: Wheather reduce absolute values of input tensors or not. + :param reduction_axes: Axes for reducer. + :param aggregation_axes: Axes for aggregator. + :param inplace: Whether to calculate statistic inplace or not. + :param num_samples: Maximum number of samples to collect. + :return: Backend-specific TensorStatisticCollectorBase for the statistics calculation. + """ + + @staticmethod + @abstractmethod + def get_weight_tensor_port_ids(node: NNCFNode, graph: NNCFGraph) -> List[Optional[int]]: + """ + Returns node's input port indices with weight tensors. + + :param node: NNCFNode to find its weight input port indices. + :param graph: NNCFGraph instance. + :return: Weights input port indices. + """ + + @staticmethod + def get_weight_name(nncf_graph: NNCFGraph, target_point: TargetPoint) -> str: + """ + Returns node's weight name corresponding to port ID. + + :param nncf_graph: NNCFGraph instance. + :param target_point: The TargetPoint instance that contains layer's information. + :return: Weight name. + """ + + @staticmethod + def should_quantize_weight(weight_name: str, quantized_weight_names: Set[str]) -> bool: + """ + Return True if weight should be quantized. + + :param weight_name: Weight name. + :param quantized_weight_names: Set containing already quantized weight names. + :return: A boolean value specifying whether a weight should be quantized. + """ + + @staticmethod + @abstractmethod + def get_ignored_metatypes(model_type: ModelType, device: TargetDevice) -> List[OperatorMetatype]: + """ + Returns ignored metatypes based on a model type and device parameters. + + :param model_type: Model type parameter. + :param device: Target device. + :return: List of ignored metatypes. + """ + + @staticmethod + @abstractmethod + def get_ignored_names_by_layer_attributes(nncf_graph: NNCFGraph) -> Set[str]: + """ + Returns names of ignored nodes based on layer_attributes. + + :param nncf_graph: NNCFGraph instance. + :return: List of ignored names. + """ + + @abstractmethod + def get_weight_nodes(self, nncf_graph: NNCFGraph) -> List[NNCFNode]: + """ + Returns nodes that have weights. + + :param nncf_graph: Instance of NNCFGraph. + :return: All nodes with weights. + """ + + @abstractmethod + def is_matmul_with_constant(self, node: NNCFNode, nncf_graph: NNCFGraph) -> bool: + """ + Returns true if given nncf matmul node is a matmul with a constant, False otherwise. + + :param Node: Instance of NNCFNode. + :param nncf_graph: Instance of NNCFGraph. + :return: True if given nncf matmul node is a matmul with a constant, False otherwise. + """ diff --git a/nncf/quantization/algorithms/min_max/quantizer/torch_fx_backend.py b/nncf/quantization/algorithms/min_max/quantizer/torch_fx_backend.py new file mode 100644 index 00000000000..9ed869b543c --- /dev/null +++ b/nncf/quantization/algorithms/min_max/quantizer/torch_fx_backend.py @@ -0,0 +1,366 @@ +# Copyright (c) 2024 Intel Corporation +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# http://www.apache.org/licenses/LICENSE-2.0 +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, List, Optional, Set, Tuple + +import torch +from torch.quantization.fake_quantize import FakeQuantize + +import nncf +import nncf.torch.graph.operator_metatypes as om +from nncf.common.graph.graph import NNCFGraph +from nncf.common.graph.graph import NNCFNode +from nncf.common.graph.operator_metatypes import OperatorMetatype +from nncf.common.graph.transformations.commands import TargetType +from nncf.common.graph.transformations.commands import TransformationCommand +from nncf.common.hardware.config import HWConfig +from nncf.common.quantization.structs import QuantizationScheme as QuantizationMode +from nncf.common.quantization.structs import QuantizerConfig +from nncf.experimental.common.tensor_statistics.collectors import AGGREGATORS_MAP +from nncf.experimental.common.tensor_statistics.collectors import TensorCollector +from nncf.experimental.common.tensor_statistics.statistics import MinMaxTensorStatistic +from nncf.experimental.torch.fx.commands import FXApplyTransformationCommand +from nncf.experimental.torch.fx.model_utils import get_target_point +from nncf.experimental.torch.fx.transformations import qdq_insertion_transformation_builder +from nncf.parameters import ModelType +from nncf.parameters import TargetDevice +from nncf.quantization.advanced_parameters import StatisticsType +from nncf.quantization.algorithms.min_max.quantizer.backend import NNCFQuantizerBackend +from nncf.quantization.fake_quantize import FakeConvertParameters +from nncf.quantization.fake_quantize import FakeQuantizeParameters +from nncf.quantization.range_estimator import AggregatorType +from nncf.quantization.range_estimator import RangeEstimatorParameters +from nncf.torch.graph.graph import PTNNCFGraph +from nncf.torch.graph.graph import PTTargetPoint +from nncf.torch.graph.operator_metatypes import ELEMENTWISE_OPERATIONS +from nncf.torch.graph.transformations.commands import PTSharedFnInsertionCommand +from nncf.torch.hardware.config import PTHWConfig +from nncf.torch.model_graph_manager import get_weight_tensor_port_ids +from nncf.torch.nncf_network import NNCFNetwork +from nncf.torch.quantization.default_quantization import DEFAULT_PT_QUANT_TRAIT_TO_OP_DICT +from nncf.torch.quantization.layers import QUANTIZATION_MODULES +from nncf.torch.quantization.layers import AsymmetricQuantizer +from nncf.torch.quantization.layers import BaseQuantizer +from nncf.torch.quantization.layers import PTQuantizerSpec +from nncf.torch.quantization.layers import get_scale_shape +from nncf.torch.quantization.strip import convert_to_torch_fakequantizer +from nncf.torch.tensor_statistics.collectors import PT_REDUCERS_MAP + +FXMinMaxAlgoBackend = None + + +class FXNNCFQuantizerBackend(NNCFQuantizerBackend): + + @property + def preserved_metatypes(self) -> List[OperatorMetatype]: + return [] + + @property + def mat_mul_metatypes(self) -> List[OperatorMetatype]: + return [om.PTLinearMetatype, om.PTMatMulMetatype] + + @property + def post_processing_metatypes(self) -> List[OperatorMetatype]: + return [] + + @property + def shapeof_metatypes(self) -> List[OperatorMetatype]: + return [] + + @property + def dropout_metatypes(self) -> List[OperatorMetatype]: + return [om.PTDropoutMetatype] + + @property + def read_variable_metatypes(self) -> List[OperatorMetatype]: + return [] + + @property + def conv_metatypes(self) -> List[OperatorMetatype]: + return [om.PTConv1dMetatype, om.PTConv2dMetatype, om.PTConv3dMetatype] + + @property + def elementwise_metatypes(self) -> List[OperatorMetatype]: + return ELEMENTWISE_OPERATIONS + + @property + def overflow_fix_metatypes(self) -> List[OperatorMetatype]: + return [ + om.PTConv1dMetatype, + om.PTConv2dMetatype, + om.PTConv3dMetatype, + om.PTLinearMetatype, + om.PTConvTranspose1dMetatype, + om.PTConvTranspose2dMetatype, + om.PTConvTranspose3dMetatype, + ] + + @property + def add_metatypes(self) -> List[OperatorMetatype]: + return [om.PTAddMetatype] + + @property + def group_conv_metatypes(self) -> List[OperatorMetatype]: + return self.conv_metatypes + + @property + def scaled_dot_product_attention_metatypes(self) -> List[OperatorMetatype]: + return [om.PTScaledDotProductAttentionMetatype] + + @property + def scales_unification_map(self) -> Dict[OperatorMetatype, OperatorMetatype]: + return {om.PTCatMetatype: self.overflow_fix_metatypes} + + @property + def hw_config(self) -> HWConfig: + return PTHWConfig + + @property + def quant_trait_op_dict(self) -> Dict[int, OperatorMetatype]: + return DEFAULT_PT_QUANT_TRAIT_TO_OP_DICT + + @staticmethod + def get_start_nodes_for_activation_path_tracing(nncf_graph: PTNNCFGraph) -> List[NNCFNode]: + return nncf_graph.get_input_nodes() + + @staticmethod + def target_point(target_type: TargetType, target_node_name: str, port_id: int) -> PTTargetPoint: + return get_target_point(target_type, target_node_name, port_id) + + @staticmethod + def create_convert_insertion_command( + target_point: PTTargetPoint, + parameters: FakeConvertParameters, + ) -> TransformationCommand: + raise nncf.InternalError("FakeConvert insertion not implemented in PyTorch backend!") + + @staticmethod + def get_target_point_shape(nncf_graph: PTNNCFGraph, node: NNCFNode, target_point: PTTargetPoint) -> Tuple[int, ...]: + return nncf_graph.get_input_shape_for_insertion_point(target_point) + + @staticmethod + def get_weight_quantization_axes(node: NNCFNode, target_point: PTTargetPoint, ndims: int) -> Tuple[int]: + # TODO(dlyakhov): support transpose conv and other cases + return (0,) + + @staticmethod + def get_statistic_collector( + range_estimator_params: RangeEstimatorParameters, + use_abs_max: bool, + reduction_axes: Optional[Tuple[int, ...]], + aggregation_axes: Optional[Tuple[int, ...]], + inplace: bool, + num_samples: Optional[int] = None, + ) -> TensorCollector: + collector = TensorCollector(MinMaxTensorStatistic) + for params, container_key in zip( + [range_estimator_params.min, range_estimator_params.max], + [MinMaxTensorStatistic.MIN_STAT, MinMaxTensorStatistic.MAX_STAT], + ): + if params.statistics_type not in PT_REDUCERS_MAP: + raise nncf.InternalError( + f"Statistic type: {params.statistics_type} is not supported for Torch PTQ backend yet." + ) + + if params.aggregator_type not in AGGREGATORS_MAP: + raise nncf.InternalError( + f"Aggregator type: {params.aggregator_type} is not supported for Torch PTQ backend yet." + ) + + statistic_type = params.statistics_type + if statistic_type in [StatisticsType.QUANTILE, StatisticsType.ABS_QUANTILE]: + # TODO(dlyakhov): merge two quantile aggregators in one + if container_key == MinMaxTensorStatistic.MIN_STAT: + quantile = params.quantile_outlier_prob + else: + quantile = 1 - params.quantile_outlier_prob + reducer = PT_REDUCERS_MAP[statistic_type](reduction_axes=reduction_axes, quantile=[quantile]) + else: + if use_abs_max and statistic_type == StatisticsType.MAX: + statistic_type = StatisticsType.ABS_MAX + reducer = PT_REDUCERS_MAP[statistic_type](reduction_axes=reduction_axes) + + kwargs = { + "num_samples": num_samples, + "aggregation_axes": aggregation_axes, + } + if params.aggregator_type in [AggregatorType.MEAN_NO_OUTLIERS, AggregatorType.MEDIAN_NO_OUTLIERS]: + kwargs.update({"quantile": params.quantile_outlier_prob}) + aggregator = AGGREGATORS_MAP[params.aggregator_type](**kwargs) + + collector.register_statistic_branch(container_key, reducer, aggregator) + return collector + + @staticmethod + def get_weight_tensor_port_ids(node: NNCFNode, graph: NNCFGraph) -> List[Optional[int]]: + return get_weight_tensor_port_ids(node, graph) + + @staticmethod + def get_weight_name(nncf_graph: NNCFGraph, target_point: PTTargetPoint) -> str: + weighted_node = nncf_graph.get_node_by_name(target_point.target_node_name) + weight_edge = nncf_graph.get_input_edge_by_port_id(weighted_node, target_point.input_port_id) + weight = weight_edge.from_node + return weight.node_name + + @staticmethod + def should_quantize_weight(weight_name: str, quantized_weight_names: Set[str]) -> bool: + # If the nodes share one weight tensor, we should have only one quantizer on that + return weight_name not in quantized_weight_names + + @staticmethod + def get_weight_config(config: QuantizerConfig, model: NNCFNetwork) -> QuantizerConfig: + return config + + @staticmethod + def _get_input_scale_shape( + nncf_graph: NNCFGraph, target_point: PTTargetPoint, per_channel: bool + ) -> Tuple[Tuple[int, ...], Tuple[int, ...], int]: + is_weights = target_point.is_weight_target_point() + if is_weights: + # TODO(dlyakhov): support transpose conv/ make channel_idx common + channel_idx = 0 + else: + channel_idx = 1 # channel dim for activations + + input_shape = nncf_graph.get_input_shape_for_insertion_point(target_point) + scale_shape = tuple( + get_scale_shape(input_shape, is_weights=is_weights, per_channel=per_channel, channel_idx=channel_idx) + ) + + return input_shape, scale_shape, channel_idx + + @staticmethod + def _create_quantizer( + quantizer_config: QuantizerConfig, + scale_shape: Tuple, + parameters: FakeQuantizeParameters, + target_type: TargetType, + ) -> FakeQuantize: + mode = quantizer_config.mode + quantizer_cls = QUANTIZATION_MODULES.get(mode) + narrow_range = target_type == TargetType.OPERATION_WITH_WEIGHTS and mode == QuantizationMode.SYMMETRIC + quantizer_spec = PTQuantizerSpec.from_config( + quantizer_config, + narrow_range=narrow_range, + scale_shape=scale_shape, + half_range=False, + logarithm_scale=False, + is_quantized_on_export=False, + compression_lr_multiplier=None, + ) + quantizer = quantizer_cls(quantizer_spec) + + # Fill it with minmax + # TODO(dlyakhov) Prevent creation of intermediate objects like nncf quantizer. + FXMinMaxAlgoBackend._fill_quantizer_parameters(quantizer, parameters, quantizer_spec.scale_shape) + # Convert to the torch fake quantizer + torch_fq = convert_to_torch_fakequantizer(quantizer) + return torch_fq + + @staticmethod + def _fill_quantizer_parameters(quantizer: BaseQuantizer, parameters: FakeQuantizeParameters, scale_shape) -> None: + if isinstance(quantizer, AsymmetricQuantizer): + quantizer.input_low = torch.nn.Parameter(parameters.input_low.data.reshape(scale_shape)) + input_range = parameters.input_high - parameters.input_low + # Subtract eps from the input_range to make quantizer parameters equal to + # original parameters on the forward call. + quantizer.input_range = torch.nn.Parameter((input_range.data - quantizer.eps).reshape(scale_shape)) + else: + quantizer.signed = bool(torch.any(parameters.input_low.data < 0)) + # Subtract eps from the scale to make quantizer parameters equal to + # original parameters on the forward call. + quantizer.scale = torch.nn.Parameter((parameters.input_high.data - quantizer.eps).reshape(scale_shape)) + + @staticmethod + def create_quantizer_insertion_command( + nncf_graph: NNCFGraph, + target_point: PTTargetPoint, + quantizer_config: QuantizerConfig, + parameters: FakeQuantizeParameters, + ) -> FXApplyTransformationCommand: + _, scale_shape, _ = FXMinMaxAlgoBackend._get_input_scale_shape( + nncf_graph, target_point, quantizer_config.per_channel + ) + + quantizer = FXMinMaxAlgoBackend._create_quantizer( + quantizer_config, scale_shape, parameters, target_point.target_type + ) + transformation = qdq_insertion_transformation_builder(quantizer, [target_point]) + return FXApplyTransformationCommand(transformation) + + @staticmethod + def create_unified_scales_quantizers_insertion_commands( + nncf_graph: NNCFGraph, + target_points: List[PTTargetPoint], + quantizer_config: QuantizerConfig, + parameters: FakeQuantizeParameters, + ) -> List[PTSharedFnInsertionCommand]: + _, scale_shape, _ = FXMinMaxAlgoBackend._get_input_scale_shape( + nncf_graph, target_points[0], quantizer_config.per_channel + ) + + quantizer = FXMinMaxAlgoBackend._create_quantizer( + quantizer_config, scale_shape, parameters, target_points[0].target_type + ) + + transformations = [] + for tp in target_points: + transformation = qdq_insertion_transformation_builder(quantizer, [tp]) + transformations.append(FXApplyTransformationCommand(transformation)) + return transformations + + @staticmethod + def get_ignored_metatypes(model_type: ModelType, device: TargetDevice) -> List[OperatorMetatype]: + types = [] + if model_type == ModelType.TRANSFORMER: + types = [ + om.PTAddMetatype, + om.PTPowerMetatype, + om.PTSubMetatype, + om.PTAvgPool2dMetatype, + om.PTAvgPool3dMetatype, + om.PTMeanMetatype, + om.PTSumMetatype, + om.PTReduceL2, + om.PTDivMetatype, + om.PTMaxMetatype, + om.PTSqueezeMetatype, + om.PTLayerNormMetatype, + om.PTModuleLayerNormMetatype, + om.PTGroupNormMetatype, + om.PTModuleGroupNormMetatype, + # Batchnorm + om.PTBatchNormMetatype, + om.PTModuleBatchNormMetatype, + ] + if device != TargetDevice.CPU_SPR: + types.append(om.PTMulMetatype) + return types + + @staticmethod + def get_ignored_names_by_layer_attributes(nncf_graph: NNCFGraph) -> Set[str]: + return set() + + def get_weight_nodes(self, nncf_graph: NNCFGraph) -> List[NNCFNode]: + weight_nodes_candidates = [ + node + for node in nncf_graph.get_all_nodes() + if issubclass(node.metatype, om.PTOperatorMetatype) and node.metatype.weight_port_ids + ] + weight_nodes = [] + for node in weight_nodes_candidates: + if node.metatype in self.mat_mul_metatypes and not self.is_matmul_with_constant(node, nncf_graph): + continue + weight_nodes.append(node) + return weight_nodes + + def is_matmul_with_constant(self, node: NNCFNode, nncf_graph: NNCFGraph) -> bool: + return node.metatype in self.mat_mul_metatypes and len(get_weight_tensor_port_ids(node, nncf_graph)) > 0 diff --git a/tests/torch/data/reference_graphs/fx/experimental/OpenVINOQuantizer/mobilenet_v3_small.dot b/tests/torch/data/reference_graphs/fx/experimental/OpenVINOQuantizer/mobilenet_v3_small.dot new file mode 100644 index 00000000000..ca81831bd41 --- /dev/null +++ b/tests/torch/data/reference_graphs/fx/experimental/OpenVINOQuantizer/mobilenet_v3_small.dot @@ -0,0 +1,1042 @@ +strict digraph { +"0 features_1_block_1_fc1_weight" [id=0, type=get_attr]; +"1 features_1_block_1_fc1_bias" [id=1, type=get_attr]; +"2 features_1_block_1_fc2_weight" [id=2, type=get_attr]; +"3 features_1_block_1_fc2_bias" [id=3, type=get_attr]; +"4 features_4_block_2_fc1_weight" [id=4, type=get_attr]; +"5 features_4_block_2_fc1_bias" [id=5, type=get_attr]; +"6 features_4_block_2_fc2_weight" [id=6, type=get_attr]; +"7 features_4_block_2_fc2_bias" [id=7, type=get_attr]; +"8 features_5_block_2_fc1_weight" [id=8, type=get_attr]; +"9 features_5_block_2_fc1_bias" [id=9, type=get_attr]; +"10 features_5_block_2_fc2_weight" [id=10, type=get_attr]; +"11 features_5_block_2_fc2_bias" [id=11, type=get_attr]; +"12 features_6_block_2_fc1_weight" [id=12, type=get_attr]; +"13 features_6_block_2_fc1_bias" [id=13, type=get_attr]; +"14 features_6_block_2_fc2_weight" [id=14, type=get_attr]; +"15 features_6_block_2_fc2_bias" [id=15, type=get_attr]; +"16 features_7_block_2_fc1_weight" [id=16, type=get_attr]; +"17 features_7_block_2_fc1_bias" [id=17, type=get_attr]; +"18 features_7_block_2_fc2_weight" [id=18, type=get_attr]; +"19 features_7_block_2_fc2_bias" [id=19, type=get_attr]; +"20 features_8_block_2_fc1_weight" [id=20, type=get_attr]; +"21 features_8_block_2_fc1_bias" [id=21, type=get_attr]; +"22 features_8_block_2_fc2_weight" [id=22, type=get_attr]; +"23 features_8_block_2_fc2_bias" [id=23, type=get_attr]; +"24 features_9_block_2_fc1_weight" [id=24, type=get_attr]; +"25 features_9_block_2_fc1_bias" [id=25, type=get_attr]; +"26 features_9_block_2_fc2_weight" [id=26, type=get_attr]; +"27 features_9_block_2_fc2_bias" [id=27, type=get_attr]; +"28 features_10_block_2_fc1_weight" [id=28, type=get_attr]; +"29 features_10_block_2_fc1_bias" [id=29, type=get_attr]; +"30 features_10_block_2_fc2_weight" [id=30, type=get_attr]; +"31 features_10_block_2_fc2_bias" [id=31, type=get_attr]; +"32 features_11_block_2_fc1_weight" [id=32, type=get_attr]; +"33 features_11_block_2_fc1_bias" [id=33, type=get_attr]; +"34 features_11_block_2_fc2_weight" [id=34, type=get_attr]; +"35 features_11_block_2_fc2_bias" [id=35, type=get_attr]; +"36 classifier_0_bias" [id=36, type=get_attr]; +"37 classifier_3_bias" [id=37, type=get_attr]; +"38 x" [id=38, type=input]; +"39 quantize_per_tensor_default" [id=39, type=quantize_per_tensor]; +"40 dequantize_per_tensor_default" [id=40, type=dequantize_per_tensor]; +"41 features_0_0_weight_bias" [id=41, type=get_attr]; +"42 conv2d_scale_0" [id=42, type=get_attr]; +"43 conv2d_zero_point_0" [id=43, type=get_attr]; +"44 _frozen_param0" [id=44, type=get_attr]; +"45 dequantize_per_channel_default" [id=45, type=dequantize_per_channel]; +"46 conv2d" [id=46, type=conv2d]; +"47 hardswish__scale_0" [id=47, type=get_attr]; +"48 hardswish__zero_point_0" [id=48, type=get_attr]; +"49 hardswish_" [id=49, type=hardswish_]; +"50 quantize_per_channel_default_1" [id=50, type=quantize_per_channel]; +"51 dequantize_per_channel_default_1" [id=51, type=dequantize_per_channel]; +"52 features_1_block_0_0_weight_bias" [id=52, type=get_attr]; +"53 conv2d_1_scale_0" [id=53, type=get_attr]; +"54 conv2d_1_zero_point_0" [id=54, type=get_attr]; +"55 _frozen_param1" [id=55, type=get_attr]; +"56 dequantize_per_channel_default_2" [id=56, type=dequantize_per_channel]; +"57 conv2d_1" [id=57, type=conv2d]; +"58 relu_" [id=58, type=relu_]; +"59 quantize_per_tensor_default_1" [id=59, type=quantize_per_tensor]; +"60 dequantize_per_tensor_default_2" [id=60, type=dequantize_per_tensor]; +"61 dequantize_per_tensor_default_1" [id=61, type=dequantize_per_tensor]; +"62 adaptive_avg_pool2d" [id=62, type=adaptive_avg_pool2d]; +"63 conv2d_2" [id=63, type=conv2d]; +"64 relu" [id=64, type=relu]; +"65 conv2d_3" [id=65, type=conv2d]; +"66 hardsigmoid" [id=66, type=hardsigmoid]; +"67 quantize_per_tensor_default_2" [id=67, type=quantize_per_tensor]; +"68 dequantize_per_tensor_default_3" [id=68, type=dequantize_per_tensor]; +"69 mul" [id=69, type=mul]; +"70 quantize_per_tensor_default_3" [id=70, type=quantize_per_tensor]; +"71 dequantize_per_tensor_default_4" [id=71, type=dequantize_per_tensor]; +"72 features_1_block_2_0_weight_bias" [id=72, type=get_attr]; +"73 conv2d_4_scale_0" [id=73, type=get_attr]; +"74 conv2d_4_zero_point_0" [id=74, type=get_attr]; +"75 _frozen_param2" [id=75, type=get_attr]; +"76 dequantize_per_channel_default_3" [id=76, type=dequantize_per_channel]; +"77 conv2d_4" [id=77, type=conv2d]; +"78 quantize_per_tensor_default_4" [id=78, type=quantize_per_tensor]; +"79 dequantize_per_tensor_default_5" [id=79, type=dequantize_per_tensor]; +"80 features_2_block_0_0_weight_bias" [id=80, type=get_attr]; +"81 conv2d_5_scale_0" [id=81, type=get_attr]; +"82 conv2d_5_zero_point_0" [id=82, type=get_attr]; +"83 _frozen_param3" [id=83, type=get_attr]; +"84 dequantize_per_channel_default_4" [id=84, type=dequantize_per_channel]; +"85 conv2d_5" [id=85, type=conv2d]; +"86 relu__1_scale_0" [id=86, type=get_attr]; +"87 relu__1_zero_point_0" [id=87, type=get_attr]; +"88 relu__1" [id=88, type=relu_]; +"89 quantize_per_channel_default_5" [id=89, type=quantize_per_channel]; +"90 dequantize_per_channel_default_5" [id=90, type=dequantize_per_channel]; +"91 features_2_block_1_0_weight_bias" [id=91, type=get_attr]; +"92 conv2d_6_scale_0" [id=92, type=get_attr]; +"93 conv2d_6_zero_point_0" [id=93, type=get_attr]; +"94 _frozen_param4" [id=94, type=get_attr]; +"95 dequantize_per_channel_default_6" [id=95, type=dequantize_per_channel]; +"96 conv2d_6" [id=96, type=conv2d]; +"97 relu__2" [id=97, type=relu_]; +"98 quantize_per_tensor_default_5" [id=98, type=quantize_per_tensor]; +"99 dequantize_per_tensor_default_6" [id=99, type=dequantize_per_tensor]; +"100 features_2_block_2_0_weight_bias" [id=100, type=get_attr]; +"101 conv2d_7_scale_0" [id=101, type=get_attr]; +"102 conv2d_7_zero_point_0" [id=102, type=get_attr]; +"103 _frozen_param5" [id=103, type=get_attr]; +"104 dequantize_per_channel_default_7" [id=104, type=dequantize_per_channel]; +"105 conv2d_7" [id=105, type=conv2d]; +"106 quantize_per_tensor_default_6" [id=106, type=quantize_per_tensor]; +"107 dequantize_per_tensor_default_8" [id=107, type=dequantize_per_tensor]; +"108 dequantize_per_tensor_default_7" [id=108, type=dequantize_per_tensor]; +"109 features_3_block_0_0_weight_bias" [id=109, type=get_attr]; +"110 conv2d_8_scale_0" [id=110, type=get_attr]; +"111 conv2d_8_zero_point_0" [id=111, type=get_attr]; +"112 _frozen_param6" [id=112, type=get_attr]; +"113 dequantize_per_channel_default_8" [id=113, type=dequantize_per_channel]; +"114 conv2d_8" [id=114, type=conv2d]; +"115 relu__3_scale_0" [id=115, type=get_attr]; +"116 relu__3_zero_point_0" [id=116, type=get_attr]; +"117 relu__3" [id=117, type=relu_]; +"118 quantize_per_channel_default_9" [id=118, type=quantize_per_channel]; +"119 dequantize_per_channel_default_9" [id=119, type=dequantize_per_channel]; +"120 features_3_block_1_0_weight_bias" [id=120, type=get_attr]; +"121 conv2d_9_scale_0" [id=121, type=get_attr]; +"122 conv2d_9_zero_point_0" [id=122, type=get_attr]; +"123 _frozen_param7" [id=123, type=get_attr]; +"124 dequantize_per_channel_default_10" [id=124, type=dequantize_per_channel]; +"125 conv2d_9" [id=125, type=conv2d]; +"126 relu__4" [id=126, type=relu_]; +"127 quantize_per_tensor_default_7" [id=127, type=quantize_per_tensor]; +"128 dequantize_per_tensor_default_9" [id=128, type=dequantize_per_tensor]; +"129 features_3_block_2_0_weight_bias" [id=129, type=get_attr]; +"130 conv2d_10_scale_0" [id=130, type=get_attr]; +"131 conv2d_10_zero_point_0" [id=131, type=get_attr]; +"132 _frozen_param8" [id=132, type=get_attr]; +"133 dequantize_per_channel_default_11" [id=133, type=dequantize_per_channel]; +"134 conv2d_10" [id=134, type=conv2d]; +"135 quantize_per_tensor_default_8" [id=135, type=quantize_per_tensor]; +"136 dequantize_per_tensor_default_10" [id=136, type=dequantize_per_tensor]; +"137 add_" [id=137, type=add_]; +"138 quantize_per_tensor_default_9" [id=138, type=quantize_per_tensor]; +"139 dequantize_per_tensor_default_11" [id=139, type=dequantize_per_tensor]; +"140 features_4_block_0_0_weight_bias" [id=140, type=get_attr]; +"141 conv2d_11_scale_0" [id=141, type=get_attr]; +"142 conv2d_11_zero_point_0" [id=142, type=get_attr]; +"143 _frozen_param9" [id=143, type=get_attr]; +"144 dequantize_per_channel_default_12" [id=144, type=dequantize_per_channel]; +"145 conv2d_11" [id=145, type=conv2d]; +"146 hardswish__1_scale_0" [id=146, type=get_attr]; +"147 hardswish__1_zero_point_0" [id=147, type=get_attr]; +"148 hardswish__1" [id=148, type=hardswish_]; +"149 quantize_per_channel_default_13" [id=149, type=quantize_per_channel]; +"150 dequantize_per_channel_default_13" [id=150, type=dequantize_per_channel]; +"151 features_4_block_1_0_weight_bias" [id=151, type=get_attr]; +"152 conv2d_12_scale_0" [id=152, type=get_attr]; +"153 conv2d_12_zero_point_0" [id=153, type=get_attr]; +"154 _frozen_param10" [id=154, type=get_attr]; +"155 dequantize_per_channel_default_14" [id=155, type=dequantize_per_channel]; +"156 conv2d_12" [id=156, type=conv2d]; +"157 hardswish__2" [id=157, type=hardswish_]; +"158 quantize_per_tensor_default_10" [id=158, type=quantize_per_tensor]; +"159 dequantize_per_tensor_default_13" [id=159, type=dequantize_per_tensor]; +"160 dequantize_per_tensor_default_12" [id=160, type=dequantize_per_tensor]; +"161 adaptive_avg_pool2d_1" [id=161, type=adaptive_avg_pool2d]; +"162 conv2d_13" [id=162, type=conv2d]; +"163 relu_1" [id=163, type=relu]; +"164 conv2d_14" [id=164, type=conv2d]; +"165 hardsigmoid_1" [id=165, type=hardsigmoid]; +"166 quantize_per_tensor_default_11" [id=166, type=quantize_per_tensor]; +"167 dequantize_per_tensor_default_14" [id=167, type=dequantize_per_tensor]; +"168 mul_1" [id=168, type=mul]; +"169 quantize_per_tensor_default_12" [id=169, type=quantize_per_tensor]; +"170 dequantize_per_tensor_default_15" [id=170, type=dequantize_per_tensor]; +"171 features_4_block_3_0_weight_bias" [id=171, type=get_attr]; +"172 conv2d_15_scale_0" [id=172, type=get_attr]; +"173 conv2d_15_zero_point_0" [id=173, type=get_attr]; +"174 _frozen_param11" [id=174, type=get_attr]; +"175 dequantize_per_channel_default_15" [id=175, type=dequantize_per_channel]; +"176 conv2d_15" [id=176, type=conv2d]; +"177 quantize_per_tensor_default_13" [id=177, type=quantize_per_tensor]; +"178 dequantize_per_tensor_default_17" [id=178, type=dequantize_per_tensor]; +"179 dequantize_per_tensor_default_16" [id=179, type=dequantize_per_tensor]; +"180 features_5_block_0_0_weight_bias" [id=180, type=get_attr]; +"181 conv2d_16_scale_0" [id=181, type=get_attr]; +"182 conv2d_16_zero_point_0" [id=182, type=get_attr]; +"183 _frozen_param12" [id=183, type=get_attr]; +"184 dequantize_per_channel_default_16" [id=184, type=dequantize_per_channel]; +"185 conv2d_16" [id=185, type=conv2d]; +"186 hardswish__3_scale_0" [id=186, type=get_attr]; +"187 hardswish__3_zero_point_0" [id=187, type=get_attr]; +"188 hardswish__3" [id=188, type=hardswish_]; +"189 quantize_per_channel_default_17" [id=189, type=quantize_per_channel]; +"190 dequantize_per_channel_default_17" [id=190, type=dequantize_per_channel]; +"191 features_5_block_1_0_weight_bias" [id=191, type=get_attr]; +"192 conv2d_17_scale_0" [id=192, type=get_attr]; +"193 conv2d_17_zero_point_0" [id=193, type=get_attr]; +"194 _frozen_param13" [id=194, type=get_attr]; +"195 dequantize_per_channel_default_18" [id=195, type=dequantize_per_channel]; +"196 conv2d_17" [id=196, type=conv2d]; +"197 hardswish__4" [id=197, type=hardswish_]; +"198 quantize_per_tensor_default_14" [id=198, type=quantize_per_tensor]; +"199 dequantize_per_tensor_default_19" [id=199, type=dequantize_per_tensor]; +"200 dequantize_per_tensor_default_18" [id=200, type=dequantize_per_tensor]; +"201 adaptive_avg_pool2d_2" [id=201, type=adaptive_avg_pool2d]; +"202 conv2d_18" [id=202, type=conv2d]; +"203 relu_2" [id=203, type=relu]; +"204 conv2d_19" [id=204, type=conv2d]; +"205 hardsigmoid_2" [id=205, type=hardsigmoid]; +"206 quantize_per_tensor_default_15" [id=206, type=quantize_per_tensor]; +"207 dequantize_per_tensor_default_20" [id=207, type=dequantize_per_tensor]; +"208 mul_2" [id=208, type=mul]; +"209 quantize_per_tensor_default_16" [id=209, type=quantize_per_tensor]; +"210 dequantize_per_tensor_default_21" [id=210, type=dequantize_per_tensor]; +"211 features_5_block_3_0_weight_bias" [id=211, type=get_attr]; +"212 conv2d_20_scale_0" [id=212, type=get_attr]; +"213 conv2d_20_zero_point_0" [id=213, type=get_attr]; +"214 _frozen_param14" [id=214, type=get_attr]; +"215 dequantize_per_channel_default_19" [id=215, type=dequantize_per_channel]; +"216 conv2d_20" [id=216, type=conv2d]; +"217 quantize_per_tensor_default_17" [id=217, type=quantize_per_tensor]; +"218 dequantize_per_tensor_default_22" [id=218, type=dequantize_per_tensor]; +"219 add__1" [id=219, type=add_]; +"220 quantize_per_tensor_default_18" [id=220, type=quantize_per_tensor]; +"221 dequantize_per_tensor_default_24" [id=221, type=dequantize_per_tensor]; +"222 dequantize_per_tensor_default_23" [id=222, type=dequantize_per_tensor]; +"223 features_6_block_0_0_weight_bias" [id=223, type=get_attr]; +"224 conv2d_21_scale_0" [id=224, type=get_attr]; +"225 conv2d_21_zero_point_0" [id=225, type=get_attr]; +"226 _frozen_param15" [id=226, type=get_attr]; +"227 dequantize_per_channel_default_20" [id=227, type=dequantize_per_channel]; +"228 conv2d_21" [id=228, type=conv2d]; +"229 hardswish__5_scale_0" [id=229, type=get_attr]; +"230 hardswish__5_zero_point_0" [id=230, type=get_attr]; +"231 hardswish__5" [id=231, type=hardswish_]; +"232 quantize_per_channel_default_21" [id=232, type=quantize_per_channel]; +"233 dequantize_per_channel_default_21" [id=233, type=dequantize_per_channel]; +"234 features_6_block_1_0_weight_bias" [id=234, type=get_attr]; +"235 conv2d_22_scale_0" [id=235, type=get_attr]; +"236 conv2d_22_zero_point_0" [id=236, type=get_attr]; +"237 _frozen_param16" [id=237, type=get_attr]; +"238 dequantize_per_channel_default_22" [id=238, type=dequantize_per_channel]; +"239 conv2d_22" [id=239, type=conv2d]; +"240 hardswish__6" [id=240, type=hardswish_]; +"241 quantize_per_tensor_default_19" [id=241, type=quantize_per_tensor]; +"242 dequantize_per_tensor_default_26" [id=242, type=dequantize_per_tensor]; +"243 dequantize_per_tensor_default_25" [id=243, type=dequantize_per_tensor]; +"244 adaptive_avg_pool2d_3" [id=244, type=adaptive_avg_pool2d]; +"245 conv2d_23" [id=245, type=conv2d]; +"246 relu_3" [id=246, type=relu]; +"247 conv2d_24" [id=247, type=conv2d]; +"248 hardsigmoid_3" [id=248, type=hardsigmoid]; +"249 quantize_per_tensor_default_20" [id=249, type=quantize_per_tensor]; +"250 dequantize_per_tensor_default_27" [id=250, type=dequantize_per_tensor]; +"251 mul_3" [id=251, type=mul]; +"252 quantize_per_tensor_default_21" [id=252, type=quantize_per_tensor]; +"253 dequantize_per_tensor_default_28" [id=253, type=dequantize_per_tensor]; +"254 features_6_block_3_0_weight_bias" [id=254, type=get_attr]; +"255 conv2d_25_scale_0" [id=255, type=get_attr]; +"256 conv2d_25_zero_point_0" [id=256, type=get_attr]; +"257 _frozen_param17" [id=257, type=get_attr]; +"258 dequantize_per_channel_default_23" [id=258, type=dequantize_per_channel]; +"259 conv2d_25" [id=259, type=conv2d]; +"260 quantize_per_tensor_default_22" [id=260, type=quantize_per_tensor]; +"261 dequantize_per_tensor_default_29" [id=261, type=dequantize_per_tensor]; +"262 add__2" [id=262, type=add_]; +"263 quantize_per_tensor_default_23" [id=263, type=quantize_per_tensor]; +"264 dequantize_per_tensor_default_30" [id=264, type=dequantize_per_tensor]; +"265 features_7_block_0_0_weight_bias" [id=265, type=get_attr]; +"266 conv2d_26_scale_0" [id=266, type=get_attr]; +"267 conv2d_26_zero_point_0" [id=267, type=get_attr]; +"268 _frozen_param18" [id=268, type=get_attr]; +"269 dequantize_per_channel_default_24" [id=269, type=dequantize_per_channel]; +"270 conv2d_26" [id=270, type=conv2d]; +"271 hardswish__7_scale_0" [id=271, type=get_attr]; +"272 hardswish__7_zero_point_0" [id=272, type=get_attr]; +"273 hardswish__7" [id=273, type=hardswish_]; +"274 quantize_per_channel_default_25" [id=274, type=quantize_per_channel]; +"275 dequantize_per_channel_default_25" [id=275, type=dequantize_per_channel]; +"276 features_7_block_1_0_weight_bias" [id=276, type=get_attr]; +"277 conv2d_27_scale_0" [id=277, type=get_attr]; +"278 conv2d_27_zero_point_0" [id=278, type=get_attr]; +"279 _frozen_param19" [id=279, type=get_attr]; +"280 dequantize_per_channel_default_26" [id=280, type=dequantize_per_channel]; +"281 conv2d_27" [id=281, type=conv2d]; +"282 hardswish__8" [id=282, type=hardswish_]; +"283 quantize_per_tensor_default_24" [id=283, type=quantize_per_tensor]; +"284 dequantize_per_tensor_default_32" [id=284, type=dequantize_per_tensor]; +"285 dequantize_per_tensor_default_31" [id=285, type=dequantize_per_tensor]; +"286 adaptive_avg_pool2d_4" [id=286, type=adaptive_avg_pool2d]; +"287 conv2d_28" [id=287, type=conv2d]; +"288 relu_4" [id=288, type=relu]; +"289 conv2d_29" [id=289, type=conv2d]; +"290 hardsigmoid_4" [id=290, type=hardsigmoid]; +"291 quantize_per_tensor_default_25" [id=291, type=quantize_per_tensor]; +"292 dequantize_per_tensor_default_33" [id=292, type=dequantize_per_tensor]; +"293 mul_4" [id=293, type=mul]; +"294 quantize_per_tensor_default_26" [id=294, type=quantize_per_tensor]; +"295 dequantize_per_tensor_default_34" [id=295, type=dequantize_per_tensor]; +"296 features_7_block_3_0_weight_bias" [id=296, type=get_attr]; +"297 conv2d_30_scale_0" [id=297, type=get_attr]; +"298 conv2d_30_zero_point_0" [id=298, type=get_attr]; +"299 _frozen_param20" [id=299, type=get_attr]; +"300 dequantize_per_channel_default_27" [id=300, type=dequantize_per_channel]; +"301 conv2d_30" [id=301, type=conv2d]; +"302 quantize_per_tensor_default_27" [id=302, type=quantize_per_tensor]; +"303 dequantize_per_tensor_default_36" [id=303, type=dequantize_per_tensor]; +"304 dequantize_per_tensor_default_35" [id=304, type=dequantize_per_tensor]; +"305 features_8_block_0_0_weight_bias" [id=305, type=get_attr]; +"306 conv2d_31_scale_0" [id=306, type=get_attr]; +"307 conv2d_31_zero_point_0" [id=307, type=get_attr]; +"308 _frozen_param21" [id=308, type=get_attr]; +"309 dequantize_per_channel_default_28" [id=309, type=dequantize_per_channel]; +"310 conv2d_31" [id=310, type=conv2d]; +"311 hardswish__9_scale_0" [id=311, type=get_attr]; +"312 hardswish__9_zero_point_0" [id=312, type=get_attr]; +"313 hardswish__9" [id=313, type=hardswish_]; +"314 quantize_per_channel_default_29" [id=314, type=quantize_per_channel]; +"315 dequantize_per_channel_default_29" [id=315, type=dequantize_per_channel]; +"316 features_8_block_1_0_weight_bias" [id=316, type=get_attr]; +"317 conv2d_32_scale_0" [id=317, type=get_attr]; +"318 conv2d_32_zero_point_0" [id=318, type=get_attr]; +"319 _frozen_param22" [id=319, type=get_attr]; +"320 dequantize_per_channel_default_30" [id=320, type=dequantize_per_channel]; +"321 conv2d_32" [id=321, type=conv2d]; +"322 hardswish__10" [id=322, type=hardswish_]; +"323 quantize_per_tensor_default_28" [id=323, type=quantize_per_tensor]; +"324 dequantize_per_tensor_default_38" [id=324, type=dequantize_per_tensor]; +"325 dequantize_per_tensor_default_37" [id=325, type=dequantize_per_tensor]; +"326 adaptive_avg_pool2d_5" [id=326, type=adaptive_avg_pool2d]; +"327 conv2d_33" [id=327, type=conv2d]; +"328 relu_5" [id=328, type=relu]; +"329 conv2d_34" [id=329, type=conv2d]; +"330 hardsigmoid_5" [id=330, type=hardsigmoid]; +"331 quantize_per_tensor_default_29" [id=331, type=quantize_per_tensor]; +"332 dequantize_per_tensor_default_39" [id=332, type=dequantize_per_tensor]; +"333 mul_5" [id=333, type=mul]; +"334 quantize_per_tensor_default_30" [id=334, type=quantize_per_tensor]; +"335 dequantize_per_tensor_default_40" [id=335, type=dequantize_per_tensor]; +"336 features_8_block_3_0_weight_bias" [id=336, type=get_attr]; +"337 conv2d_35_scale_0" [id=337, type=get_attr]; +"338 conv2d_35_zero_point_0" [id=338, type=get_attr]; +"339 _frozen_param23" [id=339, type=get_attr]; +"340 dequantize_per_channel_default_31" [id=340, type=dequantize_per_channel]; +"341 conv2d_35" [id=341, type=conv2d]; +"342 quantize_per_tensor_default_31" [id=342, type=quantize_per_tensor]; +"343 dequantize_per_tensor_default_41" [id=343, type=dequantize_per_tensor]; +"344 add__3" [id=344, type=add_]; +"345 quantize_per_tensor_default_32" [id=345, type=quantize_per_tensor]; +"346 dequantize_per_tensor_default_42" [id=346, type=dequantize_per_tensor]; +"347 features_9_block_0_0_weight_bias" [id=347, type=get_attr]; +"348 conv2d_36_scale_0" [id=348, type=get_attr]; +"349 conv2d_36_zero_point_0" [id=349, type=get_attr]; +"350 _frozen_param24" [id=350, type=get_attr]; +"351 dequantize_per_channel_default_32" [id=351, type=dequantize_per_channel]; +"352 conv2d_36" [id=352, type=conv2d]; +"353 hardswish__11_scale_0" [id=353, type=get_attr]; +"354 hardswish__11_zero_point_0" [id=354, type=get_attr]; +"355 hardswish__11" [id=355, type=hardswish_]; +"356 quantize_per_channel_default_33" [id=356, type=quantize_per_channel]; +"357 dequantize_per_channel_default_33" [id=357, type=dequantize_per_channel]; +"358 features_9_block_1_0_weight_bias" [id=358, type=get_attr]; +"359 conv2d_37_scale_0" [id=359, type=get_attr]; +"360 conv2d_37_zero_point_0" [id=360, type=get_attr]; +"361 _frozen_param25" [id=361, type=get_attr]; +"362 dequantize_per_channel_default_34" [id=362, type=dequantize_per_channel]; +"363 conv2d_37" [id=363, type=conv2d]; +"364 hardswish__12" [id=364, type=hardswish_]; +"365 quantize_per_tensor_default_33" [id=365, type=quantize_per_tensor]; +"366 dequantize_per_tensor_default_44" [id=366, type=dequantize_per_tensor]; +"367 dequantize_per_tensor_default_43" [id=367, type=dequantize_per_tensor]; +"368 adaptive_avg_pool2d_6" [id=368, type=adaptive_avg_pool2d]; +"369 conv2d_38" [id=369, type=conv2d]; +"370 relu_6" [id=370, type=relu]; +"371 conv2d_39" [id=371, type=conv2d]; +"372 hardsigmoid_6" [id=372, type=hardsigmoid]; +"373 quantize_per_tensor_default_34" [id=373, type=quantize_per_tensor]; +"374 dequantize_per_tensor_default_45" [id=374, type=dequantize_per_tensor]; +"375 mul_6" [id=375, type=mul]; +"376 quantize_per_tensor_default_35" [id=376, type=quantize_per_tensor]; +"377 dequantize_per_tensor_default_46" [id=377, type=dequantize_per_tensor]; +"378 features_9_block_3_0_weight_bias" [id=378, type=get_attr]; +"379 conv2d_40_scale_0" [id=379, type=get_attr]; +"380 conv2d_40_zero_point_0" [id=380, type=get_attr]; +"381 _frozen_param26" [id=381, type=get_attr]; +"382 dequantize_per_channel_default_35" [id=382, type=dequantize_per_channel]; +"383 conv2d_40" [id=383, type=conv2d]; +"384 quantize_per_tensor_default_36" [id=384, type=quantize_per_tensor]; +"385 dequantize_per_tensor_default_48" [id=385, type=dequantize_per_tensor]; +"386 dequantize_per_tensor_default_47" [id=386, type=dequantize_per_tensor]; +"387 features_10_block_0_0_weight_bias" [id=387, type=get_attr]; +"388 conv2d_41_scale_0" [id=388, type=get_attr]; +"389 conv2d_41_zero_point_0" [id=389, type=get_attr]; +"390 _frozen_param27" [id=390, type=get_attr]; +"391 dequantize_per_channel_default_36" [id=391, type=dequantize_per_channel]; +"392 conv2d_41" [id=392, type=conv2d]; +"393 hardswish__13_scale_0" [id=393, type=get_attr]; +"394 hardswish__13_zero_point_0" [id=394, type=get_attr]; +"395 hardswish__13" [id=395, type=hardswish_]; +"396 quantize_per_channel_default_37" [id=396, type=quantize_per_channel]; +"397 dequantize_per_channel_default_37" [id=397, type=dequantize_per_channel]; +"398 features_10_block_1_0_weight_bias" [id=398, type=get_attr]; +"399 conv2d_42_scale_0" [id=399, type=get_attr]; +"400 conv2d_42_zero_point_0" [id=400, type=get_attr]; +"401 _frozen_param28" [id=401, type=get_attr]; +"402 dequantize_per_channel_default_38" [id=402, type=dequantize_per_channel]; +"403 conv2d_42" [id=403, type=conv2d]; +"404 hardswish__14" [id=404, type=hardswish_]; +"405 quantize_per_tensor_default_37" [id=405, type=quantize_per_tensor]; +"406 dequantize_per_tensor_default_50" [id=406, type=dequantize_per_tensor]; +"407 dequantize_per_tensor_default_49" [id=407, type=dequantize_per_tensor]; +"408 adaptive_avg_pool2d_7" [id=408, type=adaptive_avg_pool2d]; +"409 conv2d_43" [id=409, type=conv2d]; +"410 relu_7" [id=410, type=relu]; +"411 conv2d_44" [id=411, type=conv2d]; +"412 hardsigmoid_7" [id=412, type=hardsigmoid]; +"413 quantize_per_tensor_default_38" [id=413, type=quantize_per_tensor]; +"414 dequantize_per_tensor_default_51" [id=414, type=dequantize_per_tensor]; +"415 mul_7" [id=415, type=mul]; +"416 quantize_per_tensor_default_39" [id=416, type=quantize_per_tensor]; +"417 dequantize_per_tensor_default_52" [id=417, type=dequantize_per_tensor]; +"418 features_10_block_3_0_weight_bias" [id=418, type=get_attr]; +"419 conv2d_45_scale_0" [id=419, type=get_attr]; +"420 conv2d_45_zero_point_0" [id=420, type=get_attr]; +"421 _frozen_param29" [id=421, type=get_attr]; +"422 dequantize_per_channel_default_39" [id=422, type=dequantize_per_channel]; +"423 conv2d_45" [id=423, type=conv2d]; +"424 quantize_per_tensor_default_40" [id=424, type=quantize_per_tensor]; +"425 dequantize_per_tensor_default_53" [id=425, type=dequantize_per_tensor]; +"426 add__4" [id=426, type=add_]; +"427 quantize_per_tensor_default_41" [id=427, type=quantize_per_tensor]; +"428 dequantize_per_tensor_default_55" [id=428, type=dequantize_per_tensor]; +"429 dequantize_per_tensor_default_54" [id=429, type=dequantize_per_tensor]; +"430 features_11_block_0_0_weight_bias" [id=430, type=get_attr]; +"431 conv2d_46_scale_0" [id=431, type=get_attr]; +"432 conv2d_46_zero_point_0" [id=432, type=get_attr]; +"433 _frozen_param30" [id=433, type=get_attr]; +"434 dequantize_per_channel_default_40" [id=434, type=dequantize_per_channel]; +"435 conv2d_46" [id=435, type=conv2d]; +"436 hardswish__15_scale_0" [id=436, type=get_attr]; +"437 hardswish__15_zero_point_0" [id=437, type=get_attr]; +"438 hardswish__15" [id=438, type=hardswish_]; +"439 quantize_per_channel_default_41" [id=439, type=quantize_per_channel]; +"440 dequantize_per_channel_default_41" [id=440, type=dequantize_per_channel]; +"441 features_11_block_1_0_weight_bias" [id=441, type=get_attr]; +"442 conv2d_47_scale_0" [id=442, type=get_attr]; +"443 conv2d_47_zero_point_0" [id=443, type=get_attr]; +"444 _frozen_param31" [id=444, type=get_attr]; +"445 dequantize_per_channel_default_42" [id=445, type=dequantize_per_channel]; +"446 conv2d_47" [id=446, type=conv2d]; +"447 hardswish__16" [id=447, type=hardswish_]; +"448 quantize_per_tensor_default_42" [id=448, type=quantize_per_tensor]; +"449 dequantize_per_tensor_default_57" [id=449, type=dequantize_per_tensor]; +"450 dequantize_per_tensor_default_56" [id=450, type=dequantize_per_tensor]; +"451 adaptive_avg_pool2d_8" [id=451, type=adaptive_avg_pool2d]; +"452 conv2d_48" [id=452, type=conv2d]; +"453 relu_8" [id=453, type=relu]; +"454 conv2d_49" [id=454, type=conv2d]; +"455 hardsigmoid_8" [id=455, type=hardsigmoid]; +"456 quantize_per_tensor_default_43" [id=456, type=quantize_per_tensor]; +"457 dequantize_per_tensor_default_58" [id=457, type=dequantize_per_tensor]; +"458 mul_8" [id=458, type=mul]; +"459 quantize_per_tensor_default_44" [id=459, type=quantize_per_tensor]; +"460 dequantize_per_tensor_default_59" [id=460, type=dequantize_per_tensor]; +"461 features_11_block_3_0_weight_bias" [id=461, type=get_attr]; +"462 conv2d_50_scale_0" [id=462, type=get_attr]; +"463 conv2d_50_zero_point_0" [id=463, type=get_attr]; +"464 _frozen_param32" [id=464, type=get_attr]; +"465 dequantize_per_channel_default_43" [id=465, type=dequantize_per_channel]; +"466 conv2d_50" [id=466, type=conv2d]; +"467 quantize_per_tensor_default_45" [id=467, type=quantize_per_tensor]; +"468 dequantize_per_tensor_default_60" [id=468, type=dequantize_per_tensor]; +"469 add__5" [id=469, type=add_]; +"470 quantize_per_tensor_default_46" [id=470, type=quantize_per_tensor]; +"471 dequantize_per_tensor_default_61" [id=471, type=dequantize_per_tensor]; +"472 features_12_0_weight_bias" [id=472, type=get_attr]; +"473 conv2d_51_scale_0" [id=473, type=get_attr]; +"474 conv2d_51_zero_point_0" [id=474, type=get_attr]; +"475 _frozen_param33" [id=475, type=get_attr]; +"476 dequantize_per_channel_default_44" [id=476, type=dequantize_per_channel]; +"477 conv2d_51" [id=477, type=conv2d]; +"478 hardswish__17" [id=478, type=hardswish_]; +"479 quantize_per_tensor_default_47" [id=479, type=quantize_per_tensor]; +"480 dequantize_per_tensor_default_62" [id=480, type=dequantize_per_tensor]; +"481 adaptive_avg_pool2d_9" [id=481, type=adaptive_avg_pool2d]; +"482 flatten" [id=482, type=flatten]; +"483 flatten_0_0_nncf_smooth_quant_0" [id=483, type=call_module]; +"484 quantize_per_tensor_default_48" [id=484, type=quantize_per_tensor]; +"485 dequantize_per_tensor_default_63" [id=485, type=dequantize_per_tensor]; +"486 linear_scale_0" [id=486, type=get_attr]; +"487 linear_zero_point_0" [id=487, type=get_attr]; +"488 _frozen_param34" [id=488, type=get_attr]; +"489 dequantize_per_channel_default_45" [id=489, type=dequantize_per_channel]; +"490 linear" [id=490, type=linear]; +"491 hardswish__18" [id=491, type=hardswish_]; +"492 dropout_" [id=492, type=dropout_]; +"493 dropout__0_0_nncf_smooth_quant_0" [id=493, type=call_module]; +"494 quantize_per_tensor_default_49" [id=494, type=quantize_per_tensor]; +"495 dequantize_per_tensor_default_64" [id=495, type=dequantize_per_tensor]; +"496 linear_1_scale_0" [id=496, type=get_attr]; +"497 linear_1_zero_point_0" [id=497, type=get_attr]; +"498 _frozen_param35" [id=498, type=get_attr]; +"499 dequantize_per_channel_default_46" [id=499, type=dequantize_per_channel]; +"500 linear_1" [id=500, type=linear]; +"501 output" [id=501, type=output]; +"0 features_1_block_1_fc1_weight" -> "63 conv2d_2" [label="(8, 16, 1, 1)", style=solid]; +"1 features_1_block_1_fc1_bias" -> "63 conv2d_2" [label="(8,)", style=solid]; +"2 features_1_block_1_fc2_weight" -> "65 conv2d_3" [label="(16, 8, 1, 1)", style=solid]; +"3 features_1_block_1_fc2_bias" -> "65 conv2d_3" [label="(16,)", style=solid]; +"4 features_4_block_2_fc1_weight" -> "162 conv2d_13" [label="(24, 96, 1, 1)", style=solid]; +"5 features_4_block_2_fc1_bias" -> "162 conv2d_13" [label="(24,)", style=solid]; +"6 features_4_block_2_fc2_weight" -> "164 conv2d_14" [label="(96, 24, 1, 1)", style=solid]; +"7 features_4_block_2_fc2_bias" -> "164 conv2d_14" [label="(96,)", style=solid]; +"8 features_5_block_2_fc1_weight" -> "202 conv2d_18" [label="(64, 240, 1, 1)", style=solid]; +"9 features_5_block_2_fc1_bias" -> "202 conv2d_18" [label="(64,)", style=solid]; +"10 features_5_block_2_fc2_weight" -> "204 conv2d_19" [label="(240, 64, 1, 1)", style=solid]; +"11 features_5_block_2_fc2_bias" -> "204 conv2d_19" [label="(240,)", style=solid]; +"12 features_6_block_2_fc1_weight" -> "245 conv2d_23" [label="(64, 240, 1, 1)", style=solid]; +"13 features_6_block_2_fc1_bias" -> "245 conv2d_23" [label="(64,)", style=solid]; +"14 features_6_block_2_fc2_weight" -> "247 conv2d_24" [label="(240, 64, 1, 1)", style=solid]; +"15 features_6_block_2_fc2_bias" -> "247 conv2d_24" [label="(240,)", style=solid]; +"16 features_7_block_2_fc1_weight" -> "287 conv2d_28" [label="(32, 120, 1, 1)", style=solid]; +"17 features_7_block_2_fc1_bias" -> "287 conv2d_28" [label="(32,)", style=solid]; +"18 features_7_block_2_fc2_weight" -> "289 conv2d_29" [label="(120, 32, 1, 1)", style=solid]; +"19 features_7_block_2_fc2_bias" -> "289 conv2d_29" [label="(120,)", style=solid]; +"20 features_8_block_2_fc1_weight" -> "327 conv2d_33" [label="(40, 144, 1, 1)", style=solid]; +"21 features_8_block_2_fc1_bias" -> "327 conv2d_33" [label="(40,)", style=solid]; +"22 features_8_block_2_fc2_weight" -> "329 conv2d_34" [label="(144, 40, 1, 1)", style=solid]; +"23 features_8_block_2_fc2_bias" -> "329 conv2d_34" [label="(144,)", style=solid]; +"24 features_9_block_2_fc1_weight" -> "369 conv2d_38" [label="(72, 288, 1, 1)", style=solid]; +"25 features_9_block_2_fc1_bias" -> "369 conv2d_38" [label="(72,)", style=solid]; +"26 features_9_block_2_fc2_weight" -> "371 conv2d_39" [label="(288, 72, 1, 1)", style=solid]; +"27 features_9_block_2_fc2_bias" -> "371 conv2d_39" [label="(288,)", style=solid]; +"28 features_10_block_2_fc1_weight" -> "409 conv2d_43" [label="(144, 576, 1, 1)", style=solid]; +"29 features_10_block_2_fc1_bias" -> "409 conv2d_43" [label="(144,)", style=solid]; +"30 features_10_block_2_fc2_weight" -> "411 conv2d_44" [label="(576, 144, 1, 1)", style=solid]; +"31 features_10_block_2_fc2_bias" -> "411 conv2d_44" [label="(576,)", style=solid]; +"32 features_11_block_2_fc1_weight" -> "452 conv2d_48" [label="(144, 576, 1, 1)", style=solid]; +"33 features_11_block_2_fc1_bias" -> "452 conv2d_48" [label="(144,)", style=solid]; +"34 features_11_block_2_fc2_weight" -> "454 conv2d_49" [label="(576, 144, 1, 1)", style=solid]; +"35 features_11_block_2_fc2_bias" -> "454 conv2d_49" [label="(576,)", style=solid]; +"36 classifier_0_bias" -> "490 linear" [label="(1024,)", style=solid]; +"37 classifier_3_bias" -> "500 linear_1" [label="(1000,)", style=solid]; +"38 x" -> "39 quantize_per_tensor_default" [label="(1, 3, 224, 224)", style=solid]; +"39 quantize_per_tensor_default" -> "40 dequantize_per_tensor_default" [label="(1, 3, 224, 224)", style=solid]; +"40 dequantize_per_tensor_default" -> "46 conv2d" [label="(1, 3, 224, 224)", style=solid]; +"41 features_0_0_weight_bias" -> "46 conv2d" [label="(16,)", style=solid]; +"42 conv2d_scale_0" -> "45 dequantize_per_channel_default" [label="(16,)", style=solid]; +"43 conv2d_zero_point_0" -> "45 dequantize_per_channel_default" [label="(16,)", style=solid]; +"44 _frozen_param0" -> "45 dequantize_per_channel_default" [label="(16, 3, 3, 3)", style=solid]; +"45 dequantize_per_channel_default" -> "46 conv2d" [label="(16, 3, 3, 3)", style=solid]; +"46 conv2d" -> "49 hardswish_" [label="(1, 16, 112, 112)", style=solid]; +"47 hardswish__scale_0" -> "50 quantize_per_channel_default_1" [label="(16,)", style=solid]; +"47 hardswish__scale_0" -> "51 dequantize_per_channel_default_1" [label="(16,)", style=solid]; +"48 hardswish__zero_point_0" -> "50 quantize_per_channel_default_1" [label="(16,)", style=solid]; +"48 hardswish__zero_point_0" -> "51 dequantize_per_channel_default_1" [label="(16,)", style=solid]; +"49 hardswish_" -> "50 quantize_per_channel_default_1" [label="(1, 16, 112, 112)", style=solid]; +"50 quantize_per_channel_default_1" -> "51 dequantize_per_channel_default_1" [label="(1, 16, 112, 112)", style=solid]; +"51 dequantize_per_channel_default_1" -> "57 conv2d_1" [label="(1, 16, 112, 112)", style=solid]; +"52 features_1_block_0_0_weight_bias" -> "57 conv2d_1" [label="(16,)", style=solid]; +"53 conv2d_1_scale_0" -> "56 dequantize_per_channel_default_2" [label="(16,)", style=solid]; +"54 conv2d_1_zero_point_0" -> "56 dequantize_per_channel_default_2" [label="(16,)", style=solid]; +"55 _frozen_param1" -> "56 dequantize_per_channel_default_2" [label="(16, 1, 3, 3)", style=solid]; +"56 dequantize_per_channel_default_2" -> "57 conv2d_1" [label="(16, 1, 3, 3)", style=solid]; +"57 conv2d_1" -> "58 relu_" [label="(1, 16, 56, 56)", style=solid]; +"58 relu_" -> "59 quantize_per_tensor_default_1" [label="(1, 16, 56, 56)", style=solid]; +"59 quantize_per_tensor_default_1" -> "60 dequantize_per_tensor_default_2" [label="(1, 16, 56, 56)", style=solid]; +"59 quantize_per_tensor_default_1" -> "61 dequantize_per_tensor_default_1" [label="(1, 16, 56, 56)", style=solid]; +"60 dequantize_per_tensor_default_2" -> "69 mul" [label="(1, 16, 56, 56)", style=solid]; +"61 dequantize_per_tensor_default_1" -> "62 adaptive_avg_pool2d" [label="(1, 16, 56, 56)", style=solid]; +"62 adaptive_avg_pool2d" -> "63 conv2d_2" [label="(1, 16, 1, 1)", style=solid]; +"63 conv2d_2" -> "64 relu" [label="(1, 8, 1, 1)", style=solid]; +"64 relu" -> "65 conv2d_3" [label="(1, 8, 1, 1)", style=solid]; +"65 conv2d_3" -> "66 hardsigmoid" [label="(1, 16, 1, 1)", style=solid]; +"66 hardsigmoid" -> "67 quantize_per_tensor_default_2" [label="(1, 16, 1, 1)", style=solid]; +"67 quantize_per_tensor_default_2" -> "68 dequantize_per_tensor_default_3" [label="(1, 16, 1, 1)", style=solid]; +"68 dequantize_per_tensor_default_3" -> "69 mul" [label="(1, 16, 1, 1)", style=solid]; +"69 mul" -> "70 quantize_per_tensor_default_3" [label="(1, 16, 56, 56)", style=solid]; +"70 quantize_per_tensor_default_3" -> "71 dequantize_per_tensor_default_4" [label="(1, 16, 56, 56)", style=solid]; +"71 dequantize_per_tensor_default_4" -> "77 conv2d_4" [label="(1, 16, 56, 56)", style=solid]; +"72 features_1_block_2_0_weight_bias" -> "77 conv2d_4" [label="(16,)", style=solid]; +"73 conv2d_4_scale_0" -> "76 dequantize_per_channel_default_3" [label="(16,)", style=solid]; +"74 conv2d_4_zero_point_0" -> "76 dequantize_per_channel_default_3" [label="(16,)", style=solid]; +"75 _frozen_param2" -> "76 dequantize_per_channel_default_3" [label="(16, 16, 1, 1)", style=solid]; +"76 dequantize_per_channel_default_3" -> "77 conv2d_4" [label="(16, 16, 1, 1)", style=solid]; +"77 conv2d_4" -> "78 quantize_per_tensor_default_4" [label="(1, 16, 56, 56)", style=solid]; +"78 quantize_per_tensor_default_4" -> "79 dequantize_per_tensor_default_5" [label="(1, 16, 56, 56)", style=solid]; +"79 dequantize_per_tensor_default_5" -> "85 conv2d_5" [label="(1, 16, 56, 56)", style=solid]; +"80 features_2_block_0_0_weight_bias" -> "85 conv2d_5" [label="(72,)", style=solid]; +"81 conv2d_5_scale_0" -> "84 dequantize_per_channel_default_4" [label="(72,)", style=solid]; +"82 conv2d_5_zero_point_0" -> "84 dequantize_per_channel_default_4" [label="(72,)", style=solid]; +"83 _frozen_param3" -> "84 dequantize_per_channel_default_4" [label="(72, 16, 1, 1)", style=solid]; +"84 dequantize_per_channel_default_4" -> "85 conv2d_5" [label="(72, 16, 1, 1)", style=solid]; +"85 conv2d_5" -> "88 relu__1" [label="(1, 72, 56, 56)", style=solid]; +"86 relu__1_scale_0" -> "89 quantize_per_channel_default_5" [label="(72,)", style=solid]; +"86 relu__1_scale_0" -> "90 dequantize_per_channel_default_5" [label="(72,)", style=solid]; +"87 relu__1_zero_point_0" -> "89 quantize_per_channel_default_5" [label="(72,)", style=solid]; +"87 relu__1_zero_point_0" -> "90 dequantize_per_channel_default_5" [label="(72,)", style=solid]; +"88 relu__1" -> "89 quantize_per_channel_default_5" [label="(1, 72, 56, 56)", style=solid]; +"89 quantize_per_channel_default_5" -> "90 dequantize_per_channel_default_5" [label="(1, 72, 56, 56)", style=solid]; +"90 dequantize_per_channel_default_5" -> "96 conv2d_6" [label="(1, 72, 56, 56)", style=solid]; +"91 features_2_block_1_0_weight_bias" -> "96 conv2d_6" [label="(72,)", style=solid]; +"92 conv2d_6_scale_0" -> "95 dequantize_per_channel_default_6" [label="(72,)", style=solid]; +"93 conv2d_6_zero_point_0" -> "95 dequantize_per_channel_default_6" [label="(72,)", style=solid]; +"94 _frozen_param4" -> "95 dequantize_per_channel_default_6" [label="(72, 1, 3, 3)", style=solid]; +"95 dequantize_per_channel_default_6" -> "96 conv2d_6" [label="(72, 1, 3, 3)", style=solid]; +"96 conv2d_6" -> "97 relu__2" [label="(1, 72, 28, 28)", style=solid]; +"97 relu__2" -> "98 quantize_per_tensor_default_5" [label="(1, 72, 28, 28)", style=solid]; +"98 quantize_per_tensor_default_5" -> "99 dequantize_per_tensor_default_6" [label="(1, 72, 28, 28)", style=solid]; +"99 dequantize_per_tensor_default_6" -> "105 conv2d_7" [label="(1, 72, 28, 28)", style=solid]; +"100 features_2_block_2_0_weight_bias" -> "105 conv2d_7" [label="(24,)", style=solid]; +"101 conv2d_7_scale_0" -> "104 dequantize_per_channel_default_7" [label="(24,)", style=solid]; +"102 conv2d_7_zero_point_0" -> "104 dequantize_per_channel_default_7" [label="(24,)", style=solid]; +"103 _frozen_param5" -> "104 dequantize_per_channel_default_7" [label="(24, 72, 1, 1)", style=solid]; +"104 dequantize_per_channel_default_7" -> "105 conv2d_7" [label="(24, 72, 1, 1)", style=solid]; +"105 conv2d_7" -> "106 quantize_per_tensor_default_6" [label="(1, 24, 28, 28)", style=solid]; +"106 quantize_per_tensor_default_6" -> "107 dequantize_per_tensor_default_8" [label="(1, 24, 28, 28)", style=solid]; +"106 quantize_per_tensor_default_6" -> "108 dequantize_per_tensor_default_7" [label="(1, 24, 28, 28)", style=solid]; +"107 dequantize_per_tensor_default_8" -> "137 add_" [label="(1, 24, 28, 28)", style=solid]; +"108 dequantize_per_tensor_default_7" -> "114 conv2d_8" [label="(1, 24, 28, 28)", style=solid]; +"109 features_3_block_0_0_weight_bias" -> "114 conv2d_8" [label="(88,)", style=solid]; +"110 conv2d_8_scale_0" -> "113 dequantize_per_channel_default_8" [label="(88,)", style=solid]; +"111 conv2d_8_zero_point_0" -> "113 dequantize_per_channel_default_8" [label="(88,)", style=solid]; +"112 _frozen_param6" -> "113 dequantize_per_channel_default_8" [label="(88, 24, 1, 1)", style=solid]; +"113 dequantize_per_channel_default_8" -> "114 conv2d_8" [label="(88, 24, 1, 1)", style=solid]; +"114 conv2d_8" -> "117 relu__3" [label="(1, 88, 28, 28)", style=solid]; +"115 relu__3_scale_0" -> "118 quantize_per_channel_default_9" [label="(88,)", style=solid]; +"115 relu__3_scale_0" -> "119 dequantize_per_channel_default_9" [label="(88,)", style=solid]; +"116 relu__3_zero_point_0" -> "118 quantize_per_channel_default_9" [label="(88,)", style=solid]; +"116 relu__3_zero_point_0" -> "119 dequantize_per_channel_default_9" [label="(88,)", style=solid]; +"117 relu__3" -> "118 quantize_per_channel_default_9" [label="(1, 88, 28, 28)", style=solid]; +"118 quantize_per_channel_default_9" -> "119 dequantize_per_channel_default_9" [label="(1, 88, 28, 28)", style=solid]; +"119 dequantize_per_channel_default_9" -> "125 conv2d_9" [label="(1, 88, 28, 28)", style=solid]; +"120 features_3_block_1_0_weight_bias" -> "125 conv2d_9" [label="(88,)", style=solid]; +"121 conv2d_9_scale_0" -> "124 dequantize_per_channel_default_10" [label="(88,)", style=solid]; +"122 conv2d_9_zero_point_0" -> "124 dequantize_per_channel_default_10" [label="(88,)", style=solid]; +"123 _frozen_param7" -> "124 dequantize_per_channel_default_10" [label="(88, 1, 3, 3)", style=solid]; +"124 dequantize_per_channel_default_10" -> "125 conv2d_9" [label="(88, 1, 3, 3)", style=solid]; +"125 conv2d_9" -> "126 relu__4" [label="(1, 88, 28, 28)", style=solid]; +"126 relu__4" -> "127 quantize_per_tensor_default_7" [label="(1, 88, 28, 28)", style=solid]; +"127 quantize_per_tensor_default_7" -> "128 dequantize_per_tensor_default_9" [label="(1, 88, 28, 28)", style=solid]; +"128 dequantize_per_tensor_default_9" -> "134 conv2d_10" [label="(1, 88, 28, 28)", style=solid]; +"129 features_3_block_2_0_weight_bias" -> "134 conv2d_10" [label="(24,)", style=solid]; +"130 conv2d_10_scale_0" -> "133 dequantize_per_channel_default_11" [label="(24,)", style=solid]; +"131 conv2d_10_zero_point_0" -> "133 dequantize_per_channel_default_11" [label="(24,)", style=solid]; +"132 _frozen_param8" -> "133 dequantize_per_channel_default_11" [label="(24, 88, 1, 1)", style=solid]; +"133 dequantize_per_channel_default_11" -> "134 conv2d_10" [label="(24, 88, 1, 1)", style=solid]; +"134 conv2d_10" -> "135 quantize_per_tensor_default_8" [label="(1, 24, 28, 28)", style=solid]; +"135 quantize_per_tensor_default_8" -> "136 dequantize_per_tensor_default_10" [label="(1, 24, 28, 28)", style=solid]; +"136 dequantize_per_tensor_default_10" -> "137 add_" [label="(1, 24, 28, 28)", style=solid]; +"137 add_" -> "138 quantize_per_tensor_default_9" [label="(1, 24, 28, 28)", style=solid]; +"138 quantize_per_tensor_default_9" -> "139 dequantize_per_tensor_default_11" [label="(1, 24, 28, 28)", style=solid]; +"139 dequantize_per_tensor_default_11" -> "145 conv2d_11" [label="(1, 24, 28, 28)", style=solid]; +"140 features_4_block_0_0_weight_bias" -> "145 conv2d_11" [label="(96,)", style=solid]; +"141 conv2d_11_scale_0" -> "144 dequantize_per_channel_default_12" [label="(96,)", style=solid]; +"142 conv2d_11_zero_point_0" -> "144 dequantize_per_channel_default_12" [label="(96,)", style=solid]; +"143 _frozen_param9" -> "144 dequantize_per_channel_default_12" [label="(96, 24, 1, 1)", style=solid]; +"144 dequantize_per_channel_default_12" -> "145 conv2d_11" [label="(96, 24, 1, 1)", style=solid]; +"145 conv2d_11" -> "148 hardswish__1" [label="(1, 96, 28, 28)", style=solid]; +"146 hardswish__1_scale_0" -> "149 quantize_per_channel_default_13" [label="(96,)", style=solid]; +"146 hardswish__1_scale_0" -> "150 dequantize_per_channel_default_13" [label="(96,)", style=solid]; +"147 hardswish__1_zero_point_0" -> "149 quantize_per_channel_default_13" [label="(96,)", style=solid]; +"147 hardswish__1_zero_point_0" -> "150 dequantize_per_channel_default_13" [label="(96,)", style=solid]; +"148 hardswish__1" -> "149 quantize_per_channel_default_13" [label="(1, 96, 28, 28)", style=solid]; +"149 quantize_per_channel_default_13" -> "150 dequantize_per_channel_default_13" [label="(1, 96, 28, 28)", style=solid]; +"150 dequantize_per_channel_default_13" -> "156 conv2d_12" [label="(1, 96, 28, 28)", style=solid]; +"151 features_4_block_1_0_weight_bias" -> "156 conv2d_12" [label="(96,)", style=solid]; +"152 conv2d_12_scale_0" -> "155 dequantize_per_channel_default_14" [label="(96,)", style=solid]; +"153 conv2d_12_zero_point_0" -> "155 dequantize_per_channel_default_14" [label="(96,)", style=solid]; +"154 _frozen_param10" -> "155 dequantize_per_channel_default_14" [label="(96, 1, 5, 5)", style=solid]; +"155 dequantize_per_channel_default_14" -> "156 conv2d_12" [label="(96, 1, 5, 5)", style=solid]; +"156 conv2d_12" -> "157 hardswish__2" [label="(1, 96, 14, 14)", style=solid]; +"157 hardswish__2" -> "158 quantize_per_tensor_default_10" [label="(1, 96, 14, 14)", style=solid]; +"158 quantize_per_tensor_default_10" -> "159 dequantize_per_tensor_default_13" [label="(1, 96, 14, 14)", style=solid]; +"158 quantize_per_tensor_default_10" -> "160 dequantize_per_tensor_default_12" [label="(1, 96, 14, 14)", style=solid]; +"159 dequantize_per_tensor_default_13" -> "168 mul_1" [label="(1, 96, 14, 14)", style=solid]; +"160 dequantize_per_tensor_default_12" -> "161 adaptive_avg_pool2d_1" [label="(1, 96, 14, 14)", style=solid]; +"161 adaptive_avg_pool2d_1" -> "162 conv2d_13" [label="(1, 96, 1, 1)", style=solid]; +"162 conv2d_13" -> "163 relu_1" [label="(1, 24, 1, 1)", style=solid]; +"163 relu_1" -> "164 conv2d_14" [label="(1, 24, 1, 1)", style=solid]; +"164 conv2d_14" -> "165 hardsigmoid_1" [label="(1, 96, 1, 1)", style=solid]; +"165 hardsigmoid_1" -> "166 quantize_per_tensor_default_11" [label="(1, 96, 1, 1)", style=solid]; +"166 quantize_per_tensor_default_11" -> "167 dequantize_per_tensor_default_14" [label="(1, 96, 1, 1)", style=solid]; +"167 dequantize_per_tensor_default_14" -> "168 mul_1" [label="(1, 96, 1, 1)", style=solid]; +"168 mul_1" -> "169 quantize_per_tensor_default_12" [label="(1, 96, 14, 14)", style=solid]; +"169 quantize_per_tensor_default_12" -> "170 dequantize_per_tensor_default_15" [label="(1, 96, 14, 14)", style=solid]; +"170 dequantize_per_tensor_default_15" -> "176 conv2d_15" [label="(1, 96, 14, 14)", style=solid]; +"171 features_4_block_3_0_weight_bias" -> "176 conv2d_15" [label="(40,)", style=solid]; +"172 conv2d_15_scale_0" -> "175 dequantize_per_channel_default_15" [label="(40,)", style=solid]; +"173 conv2d_15_zero_point_0" -> "175 dequantize_per_channel_default_15" [label="(40,)", style=solid]; +"174 _frozen_param11" -> "175 dequantize_per_channel_default_15" [label="(40, 96, 1, 1)", style=solid]; +"175 dequantize_per_channel_default_15" -> "176 conv2d_15" [label="(40, 96, 1, 1)", style=solid]; +"176 conv2d_15" -> "177 quantize_per_tensor_default_13" [label="(1, 40, 14, 14)", style=solid]; +"177 quantize_per_tensor_default_13" -> "178 dequantize_per_tensor_default_17" [label="(1, 40, 14, 14)", style=solid]; +"177 quantize_per_tensor_default_13" -> "179 dequantize_per_tensor_default_16" [label="(1, 40, 14, 14)", style=solid]; +"178 dequantize_per_tensor_default_17" -> "219 add__1" [label="(1, 40, 14, 14)", style=solid]; +"179 dequantize_per_tensor_default_16" -> "185 conv2d_16" [label="(1, 40, 14, 14)", style=solid]; +"180 features_5_block_0_0_weight_bias" -> "185 conv2d_16" [label="(240,)", style=solid]; +"181 conv2d_16_scale_0" -> "184 dequantize_per_channel_default_16" [label="(240,)", style=solid]; +"182 conv2d_16_zero_point_0" -> "184 dequantize_per_channel_default_16" [label="(240,)", style=solid]; +"183 _frozen_param12" -> "184 dequantize_per_channel_default_16" [label="(240, 40, 1, 1)", style=solid]; +"184 dequantize_per_channel_default_16" -> "185 conv2d_16" [label="(240, 40, 1, 1)", style=solid]; +"185 conv2d_16" -> "188 hardswish__3" [label="(1, 240, 14, 14)", style=solid]; +"186 hardswish__3_scale_0" -> "189 quantize_per_channel_default_17" [label="(240,)", style=solid]; +"186 hardswish__3_scale_0" -> "190 dequantize_per_channel_default_17" [label="(240,)", style=solid]; +"187 hardswish__3_zero_point_0" -> "189 quantize_per_channel_default_17" [label="(240,)", style=solid]; +"187 hardswish__3_zero_point_0" -> "190 dequantize_per_channel_default_17" [label="(240,)", style=solid]; +"188 hardswish__3" -> "189 quantize_per_channel_default_17" [label="(1, 240, 14, 14)", style=solid]; +"189 quantize_per_channel_default_17" -> "190 dequantize_per_channel_default_17" [label="(1, 240, 14, 14)", style=solid]; +"190 dequantize_per_channel_default_17" -> "196 conv2d_17" [label="(1, 240, 14, 14)", style=solid]; +"191 features_5_block_1_0_weight_bias" -> "196 conv2d_17" [label="(240,)", style=solid]; +"192 conv2d_17_scale_0" -> "195 dequantize_per_channel_default_18" [label="(240,)", style=solid]; +"193 conv2d_17_zero_point_0" -> "195 dequantize_per_channel_default_18" [label="(240,)", style=solid]; +"194 _frozen_param13" -> "195 dequantize_per_channel_default_18" [label="(240, 1, 5, 5)", style=solid]; +"195 dequantize_per_channel_default_18" -> "196 conv2d_17" [label="(240, 1, 5, 5)", style=solid]; +"196 conv2d_17" -> "197 hardswish__4" [label="(1, 240, 14, 14)", style=solid]; +"197 hardswish__4" -> "198 quantize_per_tensor_default_14" [label="(1, 240, 14, 14)", style=solid]; +"198 quantize_per_tensor_default_14" -> "199 dequantize_per_tensor_default_19" [label="(1, 240, 14, 14)", style=solid]; +"198 quantize_per_tensor_default_14" -> "200 dequantize_per_tensor_default_18" [label="(1, 240, 14, 14)", style=solid]; +"199 dequantize_per_tensor_default_19" -> "208 mul_2" [label="(1, 240, 14, 14)", style=solid]; +"200 dequantize_per_tensor_default_18" -> "201 adaptive_avg_pool2d_2" [label="(1, 240, 14, 14)", style=solid]; +"201 adaptive_avg_pool2d_2" -> "202 conv2d_18" [label="(1, 240, 1, 1)", style=solid]; +"202 conv2d_18" -> "203 relu_2" [label="(1, 64, 1, 1)", style=solid]; +"203 relu_2" -> "204 conv2d_19" [label="(1, 64, 1, 1)", style=solid]; +"204 conv2d_19" -> "205 hardsigmoid_2" [label="(1, 240, 1, 1)", style=solid]; +"205 hardsigmoid_2" -> "206 quantize_per_tensor_default_15" [label="(1, 240, 1, 1)", style=solid]; +"206 quantize_per_tensor_default_15" -> "207 dequantize_per_tensor_default_20" [label="(1, 240, 1, 1)", style=solid]; +"207 dequantize_per_tensor_default_20" -> "208 mul_2" [label="(1, 240, 1, 1)", style=solid]; +"208 mul_2" -> "209 quantize_per_tensor_default_16" [label="(1, 240, 14, 14)", style=solid]; +"209 quantize_per_tensor_default_16" -> "210 dequantize_per_tensor_default_21" [label="(1, 240, 14, 14)", style=solid]; +"210 dequantize_per_tensor_default_21" -> "216 conv2d_20" [label="(1, 240, 14, 14)", style=solid]; +"211 features_5_block_3_0_weight_bias" -> "216 conv2d_20" [label="(40,)", style=solid]; +"212 conv2d_20_scale_0" -> "215 dequantize_per_channel_default_19" [label="(40,)", style=solid]; +"213 conv2d_20_zero_point_0" -> "215 dequantize_per_channel_default_19" [label="(40,)", style=solid]; +"214 _frozen_param14" -> "215 dequantize_per_channel_default_19" [label="(40, 240, 1, 1)", style=solid]; +"215 dequantize_per_channel_default_19" -> "216 conv2d_20" [label="(40, 240, 1, 1)", style=solid]; +"216 conv2d_20" -> "217 quantize_per_tensor_default_17" [label="(1, 40, 14, 14)", style=solid]; +"217 quantize_per_tensor_default_17" -> "218 dequantize_per_tensor_default_22" [label="(1, 40, 14, 14)", style=solid]; +"218 dequantize_per_tensor_default_22" -> "219 add__1" [label="(1, 40, 14, 14)", style=solid]; +"219 add__1" -> "220 quantize_per_tensor_default_18" [label="(1, 40, 14, 14)", style=solid]; +"220 quantize_per_tensor_default_18" -> "221 dequantize_per_tensor_default_24" [label="(1, 40, 14, 14)", style=solid]; +"220 quantize_per_tensor_default_18" -> "222 dequantize_per_tensor_default_23" [label="(1, 40, 14, 14)", style=solid]; +"221 dequantize_per_tensor_default_24" -> "262 add__2" [label="(1, 40, 14, 14)", style=solid]; +"222 dequantize_per_tensor_default_23" -> "228 conv2d_21" [label="(1, 40, 14, 14)", style=solid]; +"223 features_6_block_0_0_weight_bias" -> "228 conv2d_21" [label="(240,)", style=solid]; +"224 conv2d_21_scale_0" -> "227 dequantize_per_channel_default_20" [label="(240,)", style=solid]; +"225 conv2d_21_zero_point_0" -> "227 dequantize_per_channel_default_20" [label="(240,)", style=solid]; +"226 _frozen_param15" -> "227 dequantize_per_channel_default_20" [label="(240, 40, 1, 1)", style=solid]; +"227 dequantize_per_channel_default_20" -> "228 conv2d_21" [label="(240, 40, 1, 1)", style=solid]; +"228 conv2d_21" -> "231 hardswish__5" [label="(1, 240, 14, 14)", style=solid]; +"229 hardswish__5_scale_0" -> "232 quantize_per_channel_default_21" [label="(240,)", style=solid]; +"229 hardswish__5_scale_0" -> "233 dequantize_per_channel_default_21" [label="(240,)", style=solid]; +"230 hardswish__5_zero_point_0" -> "232 quantize_per_channel_default_21" [label="(240,)", style=solid]; +"230 hardswish__5_zero_point_0" -> "233 dequantize_per_channel_default_21" [label="(240,)", style=solid]; +"231 hardswish__5" -> "232 quantize_per_channel_default_21" [label="(1, 240, 14, 14)", style=solid]; +"232 quantize_per_channel_default_21" -> "233 dequantize_per_channel_default_21" [label="(1, 240, 14, 14)", style=solid]; +"233 dequantize_per_channel_default_21" -> "239 conv2d_22" [label="(1, 240, 14, 14)", style=solid]; +"234 features_6_block_1_0_weight_bias" -> "239 conv2d_22" [label="(240,)", style=solid]; +"235 conv2d_22_scale_0" -> "238 dequantize_per_channel_default_22" [label="(240,)", style=solid]; +"236 conv2d_22_zero_point_0" -> "238 dequantize_per_channel_default_22" [label="(240,)", style=solid]; +"237 _frozen_param16" -> "238 dequantize_per_channel_default_22" [label="(240, 1, 5, 5)", style=solid]; +"238 dequantize_per_channel_default_22" -> "239 conv2d_22" [label="(240, 1, 5, 5)", style=solid]; +"239 conv2d_22" -> "240 hardswish__6" [label="(1, 240, 14, 14)", style=solid]; +"240 hardswish__6" -> "241 quantize_per_tensor_default_19" [label="(1, 240, 14, 14)", style=solid]; +"241 quantize_per_tensor_default_19" -> "242 dequantize_per_tensor_default_26" [label="(1, 240, 14, 14)", style=solid]; +"241 quantize_per_tensor_default_19" -> "243 dequantize_per_tensor_default_25" [label="(1, 240, 14, 14)", style=solid]; +"242 dequantize_per_tensor_default_26" -> "251 mul_3" [label="(1, 240, 14, 14)", style=solid]; +"243 dequantize_per_tensor_default_25" -> "244 adaptive_avg_pool2d_3" [label="(1, 240, 14, 14)", style=solid]; +"244 adaptive_avg_pool2d_3" -> "245 conv2d_23" [label="(1, 240, 1, 1)", style=solid]; +"245 conv2d_23" -> "246 relu_3" [label="(1, 64, 1, 1)", style=solid]; +"246 relu_3" -> "247 conv2d_24" [label="(1, 64, 1, 1)", style=solid]; +"247 conv2d_24" -> "248 hardsigmoid_3" [label="(1, 240, 1, 1)", style=solid]; +"248 hardsigmoid_3" -> "249 quantize_per_tensor_default_20" [label="(1, 240, 1, 1)", style=solid]; +"249 quantize_per_tensor_default_20" -> "250 dequantize_per_tensor_default_27" [label="(1, 240, 1, 1)", style=solid]; +"250 dequantize_per_tensor_default_27" -> "251 mul_3" [label="(1, 240, 1, 1)", style=solid]; +"251 mul_3" -> "252 quantize_per_tensor_default_21" [label="(1, 240, 14, 14)", style=solid]; +"252 quantize_per_tensor_default_21" -> "253 dequantize_per_tensor_default_28" [label="(1, 240, 14, 14)", style=solid]; +"253 dequantize_per_tensor_default_28" -> "259 conv2d_25" [label="(1, 240, 14, 14)", style=solid]; +"254 features_6_block_3_0_weight_bias" -> "259 conv2d_25" [label="(40,)", style=solid]; +"255 conv2d_25_scale_0" -> "258 dequantize_per_channel_default_23" [label="(40,)", style=solid]; +"256 conv2d_25_zero_point_0" -> "258 dequantize_per_channel_default_23" [label="(40,)", style=solid]; +"257 _frozen_param17" -> "258 dequantize_per_channel_default_23" [label="(40, 240, 1, 1)", style=solid]; +"258 dequantize_per_channel_default_23" -> "259 conv2d_25" [label="(40, 240, 1, 1)", style=solid]; +"259 conv2d_25" -> "260 quantize_per_tensor_default_22" [label="(1, 40, 14, 14)", style=solid]; +"260 quantize_per_tensor_default_22" -> "261 dequantize_per_tensor_default_29" [label="(1, 40, 14, 14)", style=solid]; +"261 dequantize_per_tensor_default_29" -> "262 add__2" [label="(1, 40, 14, 14)", style=solid]; +"262 add__2" -> "263 quantize_per_tensor_default_23" [label="(1, 40, 14, 14)", style=solid]; +"263 quantize_per_tensor_default_23" -> "264 dequantize_per_tensor_default_30" [label="(1, 40, 14, 14)", style=solid]; +"264 dequantize_per_tensor_default_30" -> "270 conv2d_26" [label="(1, 40, 14, 14)", style=solid]; +"265 features_7_block_0_0_weight_bias" -> "270 conv2d_26" [label="(120,)", style=solid]; +"266 conv2d_26_scale_0" -> "269 dequantize_per_channel_default_24" [label="(120,)", style=solid]; +"267 conv2d_26_zero_point_0" -> "269 dequantize_per_channel_default_24" [label="(120,)", style=solid]; +"268 _frozen_param18" -> "269 dequantize_per_channel_default_24" [label="(120, 40, 1, 1)", style=solid]; +"269 dequantize_per_channel_default_24" -> "270 conv2d_26" [label="(120, 40, 1, 1)", style=solid]; +"270 conv2d_26" -> "273 hardswish__7" [label="(1, 120, 14, 14)", style=solid]; +"271 hardswish__7_scale_0" -> "274 quantize_per_channel_default_25" [label="(120,)", style=solid]; +"271 hardswish__7_scale_0" -> "275 dequantize_per_channel_default_25" [label="(120,)", style=solid]; +"272 hardswish__7_zero_point_0" -> "274 quantize_per_channel_default_25" [label="(120,)", style=solid]; +"272 hardswish__7_zero_point_0" -> "275 dequantize_per_channel_default_25" [label="(120,)", style=solid]; +"273 hardswish__7" -> "274 quantize_per_channel_default_25" [label="(1, 120, 14, 14)", style=solid]; +"274 quantize_per_channel_default_25" -> "275 dequantize_per_channel_default_25" [label="(1, 120, 14, 14)", style=solid]; +"275 dequantize_per_channel_default_25" -> "281 conv2d_27" [label="(1, 120, 14, 14)", style=solid]; +"276 features_7_block_1_0_weight_bias" -> "281 conv2d_27" [label="(120,)", style=solid]; +"277 conv2d_27_scale_0" -> "280 dequantize_per_channel_default_26" [label="(120,)", style=solid]; +"278 conv2d_27_zero_point_0" -> "280 dequantize_per_channel_default_26" [label="(120,)", style=solid]; +"279 _frozen_param19" -> "280 dequantize_per_channel_default_26" [label="(120, 1, 5, 5)", style=solid]; +"280 dequantize_per_channel_default_26" -> "281 conv2d_27" [label="(120, 1, 5, 5)", style=solid]; +"281 conv2d_27" -> "282 hardswish__8" [label="(1, 120, 14, 14)", style=solid]; +"282 hardswish__8" -> "283 quantize_per_tensor_default_24" [label="(1, 120, 14, 14)", style=solid]; +"283 quantize_per_tensor_default_24" -> "284 dequantize_per_tensor_default_32" [label="(1, 120, 14, 14)", style=solid]; +"283 quantize_per_tensor_default_24" -> "285 dequantize_per_tensor_default_31" [label="(1, 120, 14, 14)", style=solid]; +"284 dequantize_per_tensor_default_32" -> "293 mul_4" [label="(1, 120, 14, 14)", style=solid]; +"285 dequantize_per_tensor_default_31" -> "286 adaptive_avg_pool2d_4" [label="(1, 120, 14, 14)", style=solid]; +"286 adaptive_avg_pool2d_4" -> "287 conv2d_28" [label="(1, 120, 1, 1)", style=solid]; +"287 conv2d_28" -> "288 relu_4" [label="(1, 32, 1, 1)", style=solid]; +"288 relu_4" -> "289 conv2d_29" [label="(1, 32, 1, 1)", style=solid]; +"289 conv2d_29" -> "290 hardsigmoid_4" [label="(1, 120, 1, 1)", style=solid]; +"290 hardsigmoid_4" -> "291 quantize_per_tensor_default_25" [label="(1, 120, 1, 1)", style=solid]; +"291 quantize_per_tensor_default_25" -> "292 dequantize_per_tensor_default_33" [label="(1, 120, 1, 1)", style=solid]; +"292 dequantize_per_tensor_default_33" -> "293 mul_4" [label="(1, 120, 1, 1)", style=solid]; +"293 mul_4" -> "294 quantize_per_tensor_default_26" [label="(1, 120, 14, 14)", style=solid]; +"294 quantize_per_tensor_default_26" -> "295 dequantize_per_tensor_default_34" [label="(1, 120, 14, 14)", style=solid]; +"295 dequantize_per_tensor_default_34" -> "301 conv2d_30" [label="(1, 120, 14, 14)", style=solid]; +"296 features_7_block_3_0_weight_bias" -> "301 conv2d_30" [label="(48,)", style=solid]; +"297 conv2d_30_scale_0" -> "300 dequantize_per_channel_default_27" [label="(48,)", style=solid]; +"298 conv2d_30_zero_point_0" -> "300 dequantize_per_channel_default_27" [label="(48,)", style=solid]; +"299 _frozen_param20" -> "300 dequantize_per_channel_default_27" [label="(48, 120, 1, 1)", style=solid]; +"300 dequantize_per_channel_default_27" -> "301 conv2d_30" [label="(48, 120, 1, 1)", style=solid]; +"301 conv2d_30" -> "302 quantize_per_tensor_default_27" [label="(1, 48, 14, 14)", style=solid]; +"302 quantize_per_tensor_default_27" -> "303 dequantize_per_tensor_default_36" [label="(1, 48, 14, 14)", style=solid]; +"302 quantize_per_tensor_default_27" -> "304 dequantize_per_tensor_default_35" [label="(1, 48, 14, 14)", style=solid]; +"303 dequantize_per_tensor_default_36" -> "344 add__3" [label="(1, 48, 14, 14)", style=solid]; +"304 dequantize_per_tensor_default_35" -> "310 conv2d_31" [label="(1, 48, 14, 14)", style=solid]; +"305 features_8_block_0_0_weight_bias" -> "310 conv2d_31" [label="(144,)", style=solid]; +"306 conv2d_31_scale_0" -> "309 dequantize_per_channel_default_28" [label="(144,)", style=solid]; +"307 conv2d_31_zero_point_0" -> "309 dequantize_per_channel_default_28" [label="(144,)", style=solid]; +"308 _frozen_param21" -> "309 dequantize_per_channel_default_28" [label="(144, 48, 1, 1)", style=solid]; +"309 dequantize_per_channel_default_28" -> "310 conv2d_31" [label="(144, 48, 1, 1)", style=solid]; +"310 conv2d_31" -> "313 hardswish__9" [label="(1, 144, 14, 14)", style=solid]; +"311 hardswish__9_scale_0" -> "314 quantize_per_channel_default_29" [label="(144,)", style=solid]; +"311 hardswish__9_scale_0" -> "315 dequantize_per_channel_default_29" [label="(144,)", style=solid]; +"312 hardswish__9_zero_point_0" -> "314 quantize_per_channel_default_29" [label="(144,)", style=solid]; +"312 hardswish__9_zero_point_0" -> "315 dequantize_per_channel_default_29" [label="(144,)", style=solid]; +"313 hardswish__9" -> "314 quantize_per_channel_default_29" [label="(1, 144, 14, 14)", style=solid]; +"314 quantize_per_channel_default_29" -> "315 dequantize_per_channel_default_29" [label="(1, 144, 14, 14)", style=solid]; +"315 dequantize_per_channel_default_29" -> "321 conv2d_32" [label="(1, 144, 14, 14)", style=solid]; +"316 features_8_block_1_0_weight_bias" -> "321 conv2d_32" [label="(144,)", style=solid]; +"317 conv2d_32_scale_0" -> "320 dequantize_per_channel_default_30" [label="(144,)", style=solid]; +"318 conv2d_32_zero_point_0" -> "320 dequantize_per_channel_default_30" [label="(144,)", style=solid]; +"319 _frozen_param22" -> "320 dequantize_per_channel_default_30" [label="(144, 1, 5, 5)", style=solid]; +"320 dequantize_per_channel_default_30" -> "321 conv2d_32" [label="(144, 1, 5, 5)", style=solid]; +"321 conv2d_32" -> "322 hardswish__10" [label="(1, 144, 14, 14)", style=solid]; +"322 hardswish__10" -> "323 quantize_per_tensor_default_28" [label="(1, 144, 14, 14)", style=solid]; +"323 quantize_per_tensor_default_28" -> "324 dequantize_per_tensor_default_38" [label="(1, 144, 14, 14)", style=solid]; +"323 quantize_per_tensor_default_28" -> "325 dequantize_per_tensor_default_37" [label="(1, 144, 14, 14)", style=solid]; +"324 dequantize_per_tensor_default_38" -> "333 mul_5" [label="(1, 144, 14, 14)", style=solid]; +"325 dequantize_per_tensor_default_37" -> "326 adaptive_avg_pool2d_5" [label="(1, 144, 14, 14)", style=solid]; +"326 adaptive_avg_pool2d_5" -> "327 conv2d_33" [label="(1, 144, 1, 1)", style=solid]; +"327 conv2d_33" -> "328 relu_5" [label="(1, 40, 1, 1)", style=solid]; +"328 relu_5" -> "329 conv2d_34" [label="(1, 40, 1, 1)", style=solid]; +"329 conv2d_34" -> "330 hardsigmoid_5" [label="(1, 144, 1, 1)", style=solid]; +"330 hardsigmoid_5" -> "331 quantize_per_tensor_default_29" [label="(1, 144, 1, 1)", style=solid]; +"331 quantize_per_tensor_default_29" -> "332 dequantize_per_tensor_default_39" [label="(1, 144, 1, 1)", style=solid]; +"332 dequantize_per_tensor_default_39" -> "333 mul_5" [label="(1, 144, 1, 1)", style=solid]; +"333 mul_5" -> "334 quantize_per_tensor_default_30" [label="(1, 144, 14, 14)", style=solid]; +"334 quantize_per_tensor_default_30" -> "335 dequantize_per_tensor_default_40" [label="(1, 144, 14, 14)", style=solid]; +"335 dequantize_per_tensor_default_40" -> "341 conv2d_35" [label="(1, 144, 14, 14)", style=solid]; +"336 features_8_block_3_0_weight_bias" -> "341 conv2d_35" [label="(48,)", style=solid]; +"337 conv2d_35_scale_0" -> "340 dequantize_per_channel_default_31" [label="(48,)", style=solid]; +"338 conv2d_35_zero_point_0" -> "340 dequantize_per_channel_default_31" [label="(48,)", style=solid]; +"339 _frozen_param23" -> "340 dequantize_per_channel_default_31" [label="(48, 144, 1, 1)", style=solid]; +"340 dequantize_per_channel_default_31" -> "341 conv2d_35" [label="(48, 144, 1, 1)", style=solid]; +"341 conv2d_35" -> "342 quantize_per_tensor_default_31" [label="(1, 48, 14, 14)", style=solid]; +"342 quantize_per_tensor_default_31" -> "343 dequantize_per_tensor_default_41" [label="(1, 48, 14, 14)", style=solid]; +"343 dequantize_per_tensor_default_41" -> "344 add__3" [label="(1, 48, 14, 14)", style=solid]; +"344 add__3" -> "345 quantize_per_tensor_default_32" [label="(1, 48, 14, 14)", style=solid]; +"345 quantize_per_tensor_default_32" -> "346 dequantize_per_tensor_default_42" [label="(1, 48, 14, 14)", style=solid]; +"346 dequantize_per_tensor_default_42" -> "352 conv2d_36" [label="(1, 48, 14, 14)", style=solid]; +"347 features_9_block_0_0_weight_bias" -> "352 conv2d_36" [label="(288,)", style=solid]; +"348 conv2d_36_scale_0" -> "351 dequantize_per_channel_default_32" [label="(288,)", style=solid]; +"349 conv2d_36_zero_point_0" -> "351 dequantize_per_channel_default_32" [label="(288,)", style=solid]; +"350 _frozen_param24" -> "351 dequantize_per_channel_default_32" [label="(288, 48, 1, 1)", style=solid]; +"351 dequantize_per_channel_default_32" -> "352 conv2d_36" [label="(288, 48, 1, 1)", style=solid]; +"352 conv2d_36" -> "355 hardswish__11" [label="(1, 288, 14, 14)", style=solid]; +"353 hardswish__11_scale_0" -> "356 quantize_per_channel_default_33" [label="(288,)", style=solid]; +"353 hardswish__11_scale_0" -> "357 dequantize_per_channel_default_33" [label="(288,)", style=solid]; +"354 hardswish__11_zero_point_0" -> "356 quantize_per_channel_default_33" [label="(288,)", style=solid]; +"354 hardswish__11_zero_point_0" -> "357 dequantize_per_channel_default_33" [label="(288,)", style=solid]; +"355 hardswish__11" -> "356 quantize_per_channel_default_33" [label="(1, 288, 14, 14)", style=solid]; +"356 quantize_per_channel_default_33" -> "357 dequantize_per_channel_default_33" [label="(1, 288, 14, 14)", style=solid]; +"357 dequantize_per_channel_default_33" -> "363 conv2d_37" [label="(1, 288, 14, 14)", style=solid]; +"358 features_9_block_1_0_weight_bias" -> "363 conv2d_37" [label="(288,)", style=solid]; +"359 conv2d_37_scale_0" -> "362 dequantize_per_channel_default_34" [label="(288,)", style=solid]; +"360 conv2d_37_zero_point_0" -> "362 dequantize_per_channel_default_34" [label="(288,)", style=solid]; +"361 _frozen_param25" -> "362 dequantize_per_channel_default_34" [label="(288, 1, 5, 5)", style=solid]; +"362 dequantize_per_channel_default_34" -> "363 conv2d_37" [label="(288, 1, 5, 5)", style=solid]; +"363 conv2d_37" -> "364 hardswish__12" [label="(1, 288, 7, 7)", style=solid]; +"364 hardswish__12" -> "365 quantize_per_tensor_default_33" [label="(1, 288, 7, 7)", style=solid]; +"365 quantize_per_tensor_default_33" -> "366 dequantize_per_tensor_default_44" [label="(1, 288, 7, 7)", style=solid]; +"365 quantize_per_tensor_default_33" -> "367 dequantize_per_tensor_default_43" [label="(1, 288, 7, 7)", style=solid]; +"366 dequantize_per_tensor_default_44" -> "375 mul_6" [label="(1, 288, 7, 7)", style=solid]; +"367 dequantize_per_tensor_default_43" -> "368 adaptive_avg_pool2d_6" [label="(1, 288, 7, 7)", style=solid]; +"368 adaptive_avg_pool2d_6" -> "369 conv2d_38" [label="(1, 288, 1, 1)", style=solid]; +"369 conv2d_38" -> "370 relu_6" [label="(1, 72, 1, 1)", style=solid]; +"370 relu_6" -> "371 conv2d_39" [label="(1, 72, 1, 1)", style=solid]; +"371 conv2d_39" -> "372 hardsigmoid_6" [label="(1, 288, 1, 1)", style=solid]; +"372 hardsigmoid_6" -> "373 quantize_per_tensor_default_34" [label="(1, 288, 1, 1)", style=solid]; +"373 quantize_per_tensor_default_34" -> "374 dequantize_per_tensor_default_45" [label="(1, 288, 1, 1)", style=solid]; +"374 dequantize_per_tensor_default_45" -> "375 mul_6" [label="(1, 288, 1, 1)", style=solid]; +"375 mul_6" -> "376 quantize_per_tensor_default_35" [label="(1, 288, 7, 7)", style=solid]; +"376 quantize_per_tensor_default_35" -> "377 dequantize_per_tensor_default_46" [label="(1, 288, 7, 7)", style=solid]; +"377 dequantize_per_tensor_default_46" -> "383 conv2d_40" [label="(1, 288, 7, 7)", style=solid]; +"378 features_9_block_3_0_weight_bias" -> "383 conv2d_40" [label="(96,)", style=solid]; +"379 conv2d_40_scale_0" -> "382 dequantize_per_channel_default_35" [label="(96,)", style=solid]; +"380 conv2d_40_zero_point_0" -> "382 dequantize_per_channel_default_35" [label="(96,)", style=solid]; +"381 _frozen_param26" -> "382 dequantize_per_channel_default_35" [label="(96, 288, 1, 1)", style=solid]; +"382 dequantize_per_channel_default_35" -> "383 conv2d_40" [label="(96, 288, 1, 1)", style=solid]; +"383 conv2d_40" -> "384 quantize_per_tensor_default_36" [label="(1, 96, 7, 7)", style=solid]; +"384 quantize_per_tensor_default_36" -> "385 dequantize_per_tensor_default_48" [label="(1, 96, 7, 7)", style=solid]; +"384 quantize_per_tensor_default_36" -> "386 dequantize_per_tensor_default_47" [label="(1, 96, 7, 7)", style=solid]; +"385 dequantize_per_tensor_default_48" -> "426 add__4" [label="(1, 96, 7, 7)", style=solid]; +"386 dequantize_per_tensor_default_47" -> "392 conv2d_41" [label="(1, 96, 7, 7)", style=solid]; +"387 features_10_block_0_0_weight_bias" -> "392 conv2d_41" [label="(576,)", style=solid]; +"388 conv2d_41_scale_0" -> "391 dequantize_per_channel_default_36" [label="(576,)", style=solid]; +"389 conv2d_41_zero_point_0" -> "391 dequantize_per_channel_default_36" [label="(576,)", style=solid]; +"390 _frozen_param27" -> "391 dequantize_per_channel_default_36" [label="(576, 96, 1, 1)", style=solid]; +"391 dequantize_per_channel_default_36" -> "392 conv2d_41" [label="(576, 96, 1, 1)", style=solid]; +"392 conv2d_41" -> "395 hardswish__13" [label="(1, 576, 7, 7)", style=solid]; +"393 hardswish__13_scale_0" -> "396 quantize_per_channel_default_37" [label="(576,)", style=solid]; +"393 hardswish__13_scale_0" -> "397 dequantize_per_channel_default_37" [label="(576,)", style=solid]; +"394 hardswish__13_zero_point_0" -> "396 quantize_per_channel_default_37" [label="(576,)", style=solid]; +"394 hardswish__13_zero_point_0" -> "397 dequantize_per_channel_default_37" [label="(576,)", style=solid]; +"395 hardswish__13" -> "396 quantize_per_channel_default_37" [label="(1, 576, 7, 7)", style=solid]; +"396 quantize_per_channel_default_37" -> "397 dequantize_per_channel_default_37" [label="(1, 576, 7, 7)", style=solid]; +"397 dequantize_per_channel_default_37" -> "403 conv2d_42" [label="(1, 576, 7, 7)", style=solid]; +"398 features_10_block_1_0_weight_bias" -> "403 conv2d_42" [label="(576,)", style=solid]; +"399 conv2d_42_scale_0" -> "402 dequantize_per_channel_default_38" [label="(576,)", style=solid]; +"400 conv2d_42_zero_point_0" -> "402 dequantize_per_channel_default_38" [label="(576,)", style=solid]; +"401 _frozen_param28" -> "402 dequantize_per_channel_default_38" [label="(576, 1, 5, 5)", style=solid]; +"402 dequantize_per_channel_default_38" -> "403 conv2d_42" [label="(576, 1, 5, 5)", style=solid]; +"403 conv2d_42" -> "404 hardswish__14" [label="(1, 576, 7, 7)", style=solid]; +"404 hardswish__14" -> "405 quantize_per_tensor_default_37" [label="(1, 576, 7, 7)", style=solid]; +"405 quantize_per_tensor_default_37" -> "406 dequantize_per_tensor_default_50" [label="(1, 576, 7, 7)", style=solid]; +"405 quantize_per_tensor_default_37" -> "407 dequantize_per_tensor_default_49" [label="(1, 576, 7, 7)", style=solid]; +"406 dequantize_per_tensor_default_50" -> "415 mul_7" [label="(1, 576, 7, 7)", style=solid]; +"407 dequantize_per_tensor_default_49" -> "408 adaptive_avg_pool2d_7" [label="(1, 576, 7, 7)", style=solid]; +"408 adaptive_avg_pool2d_7" -> "409 conv2d_43" [label="(1, 576, 1, 1)", style=solid]; +"409 conv2d_43" -> "410 relu_7" [label="(1, 144, 1, 1)", style=solid]; +"410 relu_7" -> "411 conv2d_44" [label="(1, 144, 1, 1)", style=solid]; +"411 conv2d_44" -> "412 hardsigmoid_7" [label="(1, 576, 1, 1)", style=solid]; +"412 hardsigmoid_7" -> "413 quantize_per_tensor_default_38" [label="(1, 576, 1, 1)", style=solid]; +"413 quantize_per_tensor_default_38" -> "414 dequantize_per_tensor_default_51" [label="(1, 576, 1, 1)", style=solid]; +"414 dequantize_per_tensor_default_51" -> "415 mul_7" [label="(1, 576, 1, 1)", style=solid]; +"415 mul_7" -> "416 quantize_per_tensor_default_39" [label="(1, 576, 7, 7)", style=solid]; +"416 quantize_per_tensor_default_39" -> "417 dequantize_per_tensor_default_52" [label="(1, 576, 7, 7)", style=solid]; +"417 dequantize_per_tensor_default_52" -> "423 conv2d_45" [label="(1, 576, 7, 7)", style=solid]; +"418 features_10_block_3_0_weight_bias" -> "423 conv2d_45" [label="(96,)", style=solid]; +"419 conv2d_45_scale_0" -> "422 dequantize_per_channel_default_39" [label="(96,)", style=solid]; +"420 conv2d_45_zero_point_0" -> "422 dequantize_per_channel_default_39" [label="(96,)", style=solid]; +"421 _frozen_param29" -> "422 dequantize_per_channel_default_39" [label="(96, 576, 1, 1)", style=solid]; +"422 dequantize_per_channel_default_39" -> "423 conv2d_45" [label="(96, 576, 1, 1)", style=solid]; +"423 conv2d_45" -> "424 quantize_per_tensor_default_40" [label="(1, 96, 7, 7)", style=solid]; +"424 quantize_per_tensor_default_40" -> "425 dequantize_per_tensor_default_53" [label="(1, 96, 7, 7)", style=solid]; +"425 dequantize_per_tensor_default_53" -> "426 add__4" [label="(1, 96, 7, 7)", style=solid]; +"426 add__4" -> "427 quantize_per_tensor_default_41" [label="(1, 96, 7, 7)", style=solid]; +"427 quantize_per_tensor_default_41" -> "428 dequantize_per_tensor_default_55" [label="(1, 96, 7, 7)", style=solid]; +"427 quantize_per_tensor_default_41" -> "429 dequantize_per_tensor_default_54" [label="(1, 96, 7, 7)", style=solid]; +"428 dequantize_per_tensor_default_55" -> "469 add__5" [label="(1, 96, 7, 7)", style=solid]; +"429 dequantize_per_tensor_default_54" -> "435 conv2d_46" [label="(1, 96, 7, 7)", style=solid]; +"430 features_11_block_0_0_weight_bias" -> "435 conv2d_46" [label="(576,)", style=solid]; +"431 conv2d_46_scale_0" -> "434 dequantize_per_channel_default_40" [label="(576,)", style=solid]; +"432 conv2d_46_zero_point_0" -> "434 dequantize_per_channel_default_40" [label="(576,)", style=solid]; +"433 _frozen_param30" -> "434 dequantize_per_channel_default_40" [label="(576, 96, 1, 1)", style=solid]; +"434 dequantize_per_channel_default_40" -> "435 conv2d_46" [label="(576, 96, 1, 1)", style=solid]; +"435 conv2d_46" -> "438 hardswish__15" [label="(1, 576, 7, 7)", style=solid]; +"436 hardswish__15_scale_0" -> "439 quantize_per_channel_default_41" [label="(576,)", style=solid]; +"436 hardswish__15_scale_0" -> "440 dequantize_per_channel_default_41" [label="(576,)", style=solid]; +"437 hardswish__15_zero_point_0" -> "439 quantize_per_channel_default_41" [label="(576,)", style=solid]; +"437 hardswish__15_zero_point_0" -> "440 dequantize_per_channel_default_41" [label="(576,)", style=solid]; +"438 hardswish__15" -> "439 quantize_per_channel_default_41" [label="(1, 576, 7, 7)", style=solid]; +"439 quantize_per_channel_default_41" -> "440 dequantize_per_channel_default_41" [label="(1, 576, 7, 7)", style=solid]; +"440 dequantize_per_channel_default_41" -> "446 conv2d_47" [label="(1, 576, 7, 7)", style=solid]; +"441 features_11_block_1_0_weight_bias" -> "446 conv2d_47" [label="(576,)", style=solid]; +"442 conv2d_47_scale_0" -> "445 dequantize_per_channel_default_42" [label="(576,)", style=solid]; +"443 conv2d_47_zero_point_0" -> "445 dequantize_per_channel_default_42" [label="(576,)", style=solid]; +"444 _frozen_param31" -> "445 dequantize_per_channel_default_42" [label="(576, 1, 5, 5)", style=solid]; +"445 dequantize_per_channel_default_42" -> "446 conv2d_47" [label="(576, 1, 5, 5)", style=solid]; +"446 conv2d_47" -> "447 hardswish__16" [label="(1, 576, 7, 7)", style=solid]; +"447 hardswish__16" -> "448 quantize_per_tensor_default_42" [label="(1, 576, 7, 7)", style=solid]; +"448 quantize_per_tensor_default_42" -> "449 dequantize_per_tensor_default_57" [label="(1, 576, 7, 7)", style=solid]; +"448 quantize_per_tensor_default_42" -> "450 dequantize_per_tensor_default_56" [label="(1, 576, 7, 7)", style=solid]; +"449 dequantize_per_tensor_default_57" -> "458 mul_8" [label="(1, 576, 7, 7)", style=solid]; +"450 dequantize_per_tensor_default_56" -> "451 adaptive_avg_pool2d_8" [label="(1, 576, 7, 7)", style=solid]; +"451 adaptive_avg_pool2d_8" -> "452 conv2d_48" [label="(1, 576, 1, 1)", style=solid]; +"452 conv2d_48" -> "453 relu_8" [label="(1, 144, 1, 1)", style=solid]; +"453 relu_8" -> "454 conv2d_49" [label="(1, 144, 1, 1)", style=solid]; +"454 conv2d_49" -> "455 hardsigmoid_8" [label="(1, 576, 1, 1)", style=solid]; +"455 hardsigmoid_8" -> "456 quantize_per_tensor_default_43" [label="(1, 576, 1, 1)", style=solid]; +"456 quantize_per_tensor_default_43" -> "457 dequantize_per_tensor_default_58" [label="(1, 576, 1, 1)", style=solid]; +"457 dequantize_per_tensor_default_58" -> "458 mul_8" [label="(1, 576, 1, 1)", style=solid]; +"458 mul_8" -> "459 quantize_per_tensor_default_44" [label="(1, 576, 7, 7)", style=solid]; +"459 quantize_per_tensor_default_44" -> "460 dequantize_per_tensor_default_59" [label="(1, 576, 7, 7)", style=solid]; +"460 dequantize_per_tensor_default_59" -> "466 conv2d_50" [label="(1, 576, 7, 7)", style=solid]; +"461 features_11_block_3_0_weight_bias" -> "466 conv2d_50" [label="(96,)", style=solid]; +"462 conv2d_50_scale_0" -> "465 dequantize_per_channel_default_43" [label="(96,)", style=solid]; +"463 conv2d_50_zero_point_0" -> "465 dequantize_per_channel_default_43" [label="(96,)", style=solid]; +"464 _frozen_param32" -> "465 dequantize_per_channel_default_43" [label="(96, 576, 1, 1)", style=solid]; +"465 dequantize_per_channel_default_43" -> "466 conv2d_50" [label="(96, 576, 1, 1)", style=solid]; +"466 conv2d_50" -> "467 quantize_per_tensor_default_45" [label="(1, 96, 7, 7)", style=solid]; +"467 quantize_per_tensor_default_45" -> "468 dequantize_per_tensor_default_60" [label="(1, 96, 7, 7)", style=solid]; +"468 dequantize_per_tensor_default_60" -> "469 add__5" [label="(1, 96, 7, 7)", style=solid]; +"469 add__5" -> "470 quantize_per_tensor_default_46" [label="(1, 96, 7, 7)", style=solid]; +"470 quantize_per_tensor_default_46" -> "471 dequantize_per_tensor_default_61" [label="(1, 96, 7, 7)", style=solid]; +"471 dequantize_per_tensor_default_61" -> "477 conv2d_51" [label="(1, 96, 7, 7)", style=solid]; +"472 features_12_0_weight_bias" -> "477 conv2d_51" [label="(576,)", style=solid]; +"473 conv2d_51_scale_0" -> "476 dequantize_per_channel_default_44" [label="(576,)", style=solid]; +"474 conv2d_51_zero_point_0" -> "476 dequantize_per_channel_default_44" [label="(576,)", style=solid]; +"475 _frozen_param33" -> "476 dequantize_per_channel_default_44" [label="(576, 96, 1, 1)", style=solid]; +"476 dequantize_per_channel_default_44" -> "477 conv2d_51" [label="(576, 96, 1, 1)", style=solid]; +"477 conv2d_51" -> "478 hardswish__17" [label="(1, 576, 7, 7)", style=solid]; +"478 hardswish__17" -> "479 quantize_per_tensor_default_47" [label="(1, 576, 7, 7)", style=solid]; +"479 quantize_per_tensor_default_47" -> "480 dequantize_per_tensor_default_62" [label="(1, 576, 7, 7)", style=solid]; +"480 dequantize_per_tensor_default_62" -> "481 adaptive_avg_pool2d_9" [label="(1, 576, 7, 7)", style=solid]; +"481 adaptive_avg_pool2d_9" -> "482 flatten" [label="(1, 576, 1, 1)", style=solid]; +"482 flatten" -> "483 flatten_0_0_nncf_smooth_quant_0" [label="(1, 576)", style=solid]; +"483 flatten_0_0_nncf_smooth_quant_0" -> "484 quantize_per_tensor_default_48" [label="(1, 576)", style=solid]; +"484 quantize_per_tensor_default_48" -> "485 dequantize_per_tensor_default_63" [label="(1, 576)", style=solid]; +"485 dequantize_per_tensor_default_63" -> "490 linear" [label="(1, 576)", style=solid]; +"486 linear_scale_0" -> "489 dequantize_per_channel_default_45" [label="(1024,)", style=solid]; +"487 linear_zero_point_0" -> "489 dequantize_per_channel_default_45" [label="(1024,)", style=solid]; +"488 _frozen_param34" -> "489 dequantize_per_channel_default_45" [label="(1024, 576)", style=solid]; +"489 dequantize_per_channel_default_45" -> "490 linear" [label="(1024, 576)", style=solid]; +"490 linear" -> "491 hardswish__18" [label="(1, 1024)", style=solid]; +"491 hardswish__18" -> "492 dropout_" [label="(1, 1024)", style=solid]; +"492 dropout_" -> "493 dropout__0_0_nncf_smooth_quant_0" [label="(1, 1024)", style=solid]; +"493 dropout__0_0_nncf_smooth_quant_0" -> "494 quantize_per_tensor_default_49" [label="(1, 1024)", style=solid]; +"494 quantize_per_tensor_default_49" -> "495 dequantize_per_tensor_default_64" [label="(1, 1024)", style=solid]; +"495 dequantize_per_tensor_default_64" -> "500 linear_1" [label="(1, 1024)", style=solid]; +"496 linear_1_scale_0" -> "499 dequantize_per_channel_default_46" [label="(1000,)", style=solid]; +"497 linear_1_zero_point_0" -> "499 dequantize_per_channel_default_46" [label="(1000,)", style=solid]; +"498 _frozen_param35" -> "499 dequantize_per_channel_default_46" [label="(1000, 1024)", style=solid]; +"499 dequantize_per_channel_default_46" -> "500 linear_1" [label="(1000, 1024)", style=solid]; +"500 linear_1" -> "501 output" [label="(1, 1000)", style=solid]; +} diff --git a/tests/torch/data/reference_graphs/fx/experimental/OpenVINOQuantizer/resnet18.dot b/tests/torch/data/reference_graphs/fx/experimental/OpenVINOQuantizer/resnet18.dot new file mode 100644 index 00000000000..ec542cff909 --- /dev/null +++ b/tests/torch/data/reference_graphs/fx/experimental/OpenVINOQuantizer/resnet18.dot @@ -0,0 +1,457 @@ +strict digraph { +"0 fc_bias" [id=0, type=get_attr]; +"1 x" [id=1, type=input]; +"2 quantize_per_tensor_default" [id=2, type=quantize_per_tensor]; +"3 dequantize_per_tensor_default" [id=3, type=dequantize_per_tensor]; +"4 conv1_weight_bias" [id=4, type=get_attr]; +"5 conv2d_scale_0" [id=5, type=get_attr]; +"6 conv2d_zero_point_0" [id=6, type=get_attr]; +"7 _frozen_param0" [id=7, type=get_attr]; +"8 dequantize_per_channel_default" [id=8, type=dequantize_per_channel]; +"9 conv2d" [id=9, type=conv2d]; +"10 relu_" [id=10, type=relu_]; +"11 quantize_per_tensor_default_1" [id=11, type=quantize_per_tensor]; +"12 dequantize_per_tensor_default_1" [id=12, type=dequantize_per_tensor]; +"13 max_pool2d" [id=13, type=max_pool2d]; +"14 layer1_0_conv1_weight_bias" [id=14, type=get_attr]; +"15 conv2d_1_scale_0" [id=15, type=get_attr]; +"16 conv2d_1_zero_point_0" [id=16, type=get_attr]; +"17 _frozen_param1" [id=17, type=get_attr]; +"18 dequantize_per_channel_default_1" [id=18, type=dequantize_per_channel]; +"19 conv2d_1" [id=19, type=conv2d]; +"20 relu__1" [id=20, type=relu_]; +"21 quantize_per_tensor_default_2" [id=21, type=quantize_per_tensor]; +"22 dequantize_per_tensor_default_2" [id=22, type=dequantize_per_tensor]; +"23 layer1_0_conv2_weight_bias" [id=23, type=get_attr]; +"24 conv2d_2_scale_0" [id=24, type=get_attr]; +"25 conv2d_2_zero_point_0" [id=25, type=get_attr]; +"26 _frozen_param2" [id=26, type=get_attr]; +"27 dequantize_per_channel_default_2" [id=27, type=dequantize_per_channel]; +"28 conv2d_2" [id=28, type=conv2d]; +"29 quantize_per_tensor_default_3" [id=29, type=quantize_per_tensor]; +"30 dequantize_per_tensor_default_3" [id=30, type=dequantize_per_tensor]; +"31 add_" [id=31, type=add_]; +"32 relu__2" [id=32, type=relu_]; +"33 quantize_per_tensor_default_4" [id=33, type=quantize_per_tensor]; +"34 dequantize_per_tensor_default_5" [id=34, type=dequantize_per_tensor]; +"35 dequantize_per_tensor_default_4" [id=35, type=dequantize_per_tensor]; +"36 layer1_1_conv1_weight_bias" [id=36, type=get_attr]; +"37 conv2d_3_scale_0" [id=37, type=get_attr]; +"38 conv2d_3_zero_point_0" [id=38, type=get_attr]; +"39 _frozen_param3" [id=39, type=get_attr]; +"40 dequantize_per_channel_default_3" [id=40, type=dequantize_per_channel]; +"41 conv2d_3" [id=41, type=conv2d]; +"42 relu__3" [id=42, type=relu_]; +"43 quantize_per_tensor_default_5" [id=43, type=quantize_per_tensor]; +"44 dequantize_per_tensor_default_6" [id=44, type=dequantize_per_tensor]; +"45 layer1_1_conv2_weight_bias" [id=45, type=get_attr]; +"46 conv2d_4_scale_0" [id=46, type=get_attr]; +"47 conv2d_4_zero_point_0" [id=47, type=get_attr]; +"48 _frozen_param4" [id=48, type=get_attr]; +"49 dequantize_per_channel_default_4" [id=49, type=dequantize_per_channel]; +"50 conv2d_4" [id=50, type=conv2d]; +"51 quantize_per_tensor_default_6" [id=51, type=quantize_per_tensor]; +"52 dequantize_per_tensor_default_7" [id=52, type=dequantize_per_tensor]; +"53 add__1" [id=53, type=add_]; +"54 relu__4" [id=54, type=relu_]; +"55 quantize_per_tensor_default_7" [id=55, type=quantize_per_tensor]; +"56 dequantize_per_tensor_default_9" [id=56, type=dequantize_per_tensor]; +"57 dequantize_per_tensor_default_8" [id=57, type=dequantize_per_tensor]; +"58 layer2_0_conv1_weight_bias" [id=58, type=get_attr]; +"59 conv2d_5_scale_0" [id=59, type=get_attr]; +"60 conv2d_5_zero_point_0" [id=60, type=get_attr]; +"61 _frozen_param5" [id=61, type=get_attr]; +"62 dequantize_per_channel_default_5" [id=62, type=dequantize_per_channel]; +"63 conv2d_5" [id=63, type=conv2d]; +"64 relu__5" [id=64, type=relu_]; +"65 quantize_per_tensor_default_8" [id=65, type=quantize_per_tensor]; +"66 dequantize_per_tensor_default_10" [id=66, type=dequantize_per_tensor]; +"67 layer2_0_conv2_weight_bias" [id=67, type=get_attr]; +"68 conv2d_6_scale_0" [id=68, type=get_attr]; +"69 conv2d_6_zero_point_0" [id=69, type=get_attr]; +"70 _frozen_param6" [id=70, type=get_attr]; +"71 dequantize_per_channel_default_6" [id=71, type=dequantize_per_channel]; +"72 conv2d_6" [id=72, type=conv2d]; +"73 quantize_per_tensor_default_9" [id=73, type=quantize_per_tensor]; +"74 dequantize_per_tensor_default_11" [id=74, type=dequantize_per_tensor]; +"75 layer2_0_downsample_0_weight_bias" [id=75, type=get_attr]; +"76 conv2d_7_scale_0" [id=76, type=get_attr]; +"77 conv2d_7_zero_point_0" [id=77, type=get_attr]; +"78 _frozen_param7" [id=78, type=get_attr]; +"79 dequantize_per_channel_default_7" [id=79, type=dequantize_per_channel]; +"80 conv2d_7" [id=80, type=conv2d]; +"81 quantize_per_tensor_default_10" [id=81, type=quantize_per_tensor]; +"82 dequantize_per_tensor_default_12" [id=82, type=dequantize_per_tensor]; +"83 add__2" [id=83, type=add_]; +"84 relu__6" [id=84, type=relu_]; +"85 quantize_per_tensor_default_11" [id=85, type=quantize_per_tensor]; +"86 dequantize_per_tensor_default_14" [id=86, type=dequantize_per_tensor]; +"87 dequantize_per_tensor_default_13" [id=87, type=dequantize_per_tensor]; +"88 layer2_1_conv1_weight_bias" [id=88, type=get_attr]; +"89 conv2d_8_scale_0" [id=89, type=get_attr]; +"90 conv2d_8_zero_point_0" [id=90, type=get_attr]; +"91 _frozen_param8" [id=91, type=get_attr]; +"92 dequantize_per_channel_default_8" [id=92, type=dequantize_per_channel]; +"93 conv2d_8" [id=93, type=conv2d]; +"94 relu__7" [id=94, type=relu_]; +"95 quantize_per_tensor_default_12" [id=95, type=quantize_per_tensor]; +"96 dequantize_per_tensor_default_15" [id=96, type=dequantize_per_tensor]; +"97 layer2_1_conv2_weight_bias" [id=97, type=get_attr]; +"98 conv2d_9_scale_0" [id=98, type=get_attr]; +"99 conv2d_9_zero_point_0" [id=99, type=get_attr]; +"100 _frozen_param9" [id=100, type=get_attr]; +"101 dequantize_per_channel_default_9" [id=101, type=dequantize_per_channel]; +"102 conv2d_9" [id=102, type=conv2d]; +"103 quantize_per_tensor_default_13" [id=103, type=quantize_per_tensor]; +"104 dequantize_per_tensor_default_16" [id=104, type=dequantize_per_tensor]; +"105 add__3" [id=105, type=add_]; +"106 relu__8" [id=106, type=relu_]; +"107 quantize_per_tensor_default_14" [id=107, type=quantize_per_tensor]; +"108 dequantize_per_tensor_default_18" [id=108, type=dequantize_per_tensor]; +"109 dequantize_per_tensor_default_17" [id=109, type=dequantize_per_tensor]; +"110 layer3_0_conv1_weight_bias" [id=110, type=get_attr]; +"111 conv2d_10_scale_0" [id=111, type=get_attr]; +"112 conv2d_10_zero_point_0" [id=112, type=get_attr]; +"113 _frozen_param10" [id=113, type=get_attr]; +"114 dequantize_per_channel_default_10" [id=114, type=dequantize_per_channel]; +"115 conv2d_10" [id=115, type=conv2d]; +"116 relu__9" [id=116, type=relu_]; +"117 quantize_per_tensor_default_15" [id=117, type=quantize_per_tensor]; +"118 dequantize_per_tensor_default_19" [id=118, type=dequantize_per_tensor]; +"119 layer3_0_conv2_weight_bias" [id=119, type=get_attr]; +"120 conv2d_11_scale_0" [id=120, type=get_attr]; +"121 conv2d_11_zero_point_0" [id=121, type=get_attr]; +"122 _frozen_param11" [id=122, type=get_attr]; +"123 dequantize_per_channel_default_11" [id=123, type=dequantize_per_channel]; +"124 conv2d_11" [id=124, type=conv2d]; +"125 quantize_per_tensor_default_16" [id=125, type=quantize_per_tensor]; +"126 dequantize_per_tensor_default_20" [id=126, type=dequantize_per_tensor]; +"127 layer3_0_downsample_0_weight_bias" [id=127, type=get_attr]; +"128 conv2d_12_scale_0" [id=128, type=get_attr]; +"129 conv2d_12_zero_point_0" [id=129, type=get_attr]; +"130 _frozen_param12" [id=130, type=get_attr]; +"131 dequantize_per_channel_default_12" [id=131, type=dequantize_per_channel]; +"132 conv2d_12" [id=132, type=conv2d]; +"133 quantize_per_tensor_default_17" [id=133, type=quantize_per_tensor]; +"134 dequantize_per_tensor_default_21" [id=134, type=dequantize_per_tensor]; +"135 add__4" [id=135, type=add_]; +"136 relu__10" [id=136, type=relu_]; +"137 quantize_per_tensor_default_18" [id=137, type=quantize_per_tensor]; +"138 dequantize_per_tensor_default_23" [id=138, type=dequantize_per_tensor]; +"139 dequantize_per_tensor_default_22" [id=139, type=dequantize_per_tensor]; +"140 layer3_1_conv1_weight_bias" [id=140, type=get_attr]; +"141 conv2d_13_scale_0" [id=141, type=get_attr]; +"142 conv2d_13_zero_point_0" [id=142, type=get_attr]; +"143 _frozen_param13" [id=143, type=get_attr]; +"144 dequantize_per_channel_default_13" [id=144, type=dequantize_per_channel]; +"145 conv2d_13" [id=145, type=conv2d]; +"146 relu__11" [id=146, type=relu_]; +"147 quantize_per_tensor_default_19" [id=147, type=quantize_per_tensor]; +"148 dequantize_per_tensor_default_24" [id=148, type=dequantize_per_tensor]; +"149 layer3_1_conv2_weight_bias" [id=149, type=get_attr]; +"150 conv2d_14_scale_0" [id=150, type=get_attr]; +"151 conv2d_14_zero_point_0" [id=151, type=get_attr]; +"152 _frozen_param14" [id=152, type=get_attr]; +"153 dequantize_per_channel_default_14" [id=153, type=dequantize_per_channel]; +"154 conv2d_14" [id=154, type=conv2d]; +"155 quantize_per_tensor_default_20" [id=155, type=quantize_per_tensor]; +"156 dequantize_per_tensor_default_25" [id=156, type=dequantize_per_tensor]; +"157 add__5" [id=157, type=add_]; +"158 relu__12" [id=158, type=relu_]; +"159 quantize_per_tensor_default_21" [id=159, type=quantize_per_tensor]; +"160 dequantize_per_tensor_default_27" [id=160, type=dequantize_per_tensor]; +"161 dequantize_per_tensor_default_26" [id=161, type=dequantize_per_tensor]; +"162 layer4_0_conv1_weight_bias" [id=162, type=get_attr]; +"163 conv2d_15_scale_0" [id=163, type=get_attr]; +"164 conv2d_15_zero_point_0" [id=164, type=get_attr]; +"165 _frozen_param15" [id=165, type=get_attr]; +"166 dequantize_per_channel_default_15" [id=166, type=dequantize_per_channel]; +"167 conv2d_15" [id=167, type=conv2d]; +"168 relu__13" [id=168, type=relu_]; +"169 quantize_per_tensor_default_22" [id=169, type=quantize_per_tensor]; +"170 dequantize_per_tensor_default_28" [id=170, type=dequantize_per_tensor]; +"171 layer4_0_conv2_weight_bias" [id=171, type=get_attr]; +"172 conv2d_16_scale_0" [id=172, type=get_attr]; +"173 conv2d_16_zero_point_0" [id=173, type=get_attr]; +"174 _frozen_param16" [id=174, type=get_attr]; +"175 dequantize_per_channel_default_16" [id=175, type=dequantize_per_channel]; +"176 conv2d_16" [id=176, type=conv2d]; +"177 quantize_per_tensor_default_23" [id=177, type=quantize_per_tensor]; +"178 dequantize_per_tensor_default_29" [id=178, type=dequantize_per_tensor]; +"179 layer4_0_downsample_0_weight_bias" [id=179, type=get_attr]; +"180 conv2d_17_scale_0" [id=180, type=get_attr]; +"181 conv2d_17_zero_point_0" [id=181, type=get_attr]; +"182 _frozen_param17" [id=182, type=get_attr]; +"183 dequantize_per_channel_default_17" [id=183, type=dequantize_per_channel]; +"184 conv2d_17" [id=184, type=conv2d]; +"185 quantize_per_tensor_default_24" [id=185, type=quantize_per_tensor]; +"186 dequantize_per_tensor_default_30" [id=186, type=dequantize_per_tensor]; +"187 add__6" [id=187, type=add_]; +"188 relu__14" [id=188, type=relu_]; +"189 quantize_per_tensor_default_25" [id=189, type=quantize_per_tensor]; +"190 dequantize_per_tensor_default_32" [id=190, type=dequantize_per_tensor]; +"191 dequantize_per_tensor_default_31" [id=191, type=dequantize_per_tensor]; +"192 layer4_1_conv1_weight_bias" [id=192, type=get_attr]; +"193 conv2d_18_scale_0" [id=193, type=get_attr]; +"194 conv2d_18_zero_point_0" [id=194, type=get_attr]; +"195 _frozen_param18" [id=195, type=get_attr]; +"196 dequantize_per_channel_default_18" [id=196, type=dequantize_per_channel]; +"197 conv2d_18" [id=197, type=conv2d]; +"198 relu__15" [id=198, type=relu_]; +"199 quantize_per_tensor_default_26" [id=199, type=quantize_per_tensor]; +"200 dequantize_per_tensor_default_33" [id=200, type=dequantize_per_tensor]; +"201 layer4_1_conv2_weight_bias" [id=201, type=get_attr]; +"202 conv2d_19_scale_0" [id=202, type=get_attr]; +"203 conv2d_19_zero_point_0" [id=203, type=get_attr]; +"204 _frozen_param19" [id=204, type=get_attr]; +"205 dequantize_per_channel_default_19" [id=205, type=dequantize_per_channel]; +"206 conv2d_19" [id=206, type=conv2d]; +"207 quantize_per_tensor_default_27" [id=207, type=quantize_per_tensor]; +"208 dequantize_per_tensor_default_34" [id=208, type=dequantize_per_tensor]; +"209 add__7" [id=209, type=add_]; +"210 relu__16" [id=210, type=relu_]; +"211 quantize_per_tensor_default_28" [id=211, type=quantize_per_tensor]; +"212 dequantize_per_tensor_default_35" [id=212, type=dequantize_per_tensor]; +"213 adaptive_avg_pool2d" [id=213, type=adaptive_avg_pool2d]; +"214 flatten" [id=214, type=flatten]; +"215 flatten_0_0_nncf_smooth_quant_0" [id=215, type=call_module]; +"216 quantize_per_tensor_default_29" [id=216, type=quantize_per_tensor]; +"217 dequantize_per_tensor_default_36" [id=217, type=dequantize_per_tensor]; +"218 linear_scale_0" [id=218, type=get_attr]; +"219 linear_zero_point_0" [id=219, type=get_attr]; +"220 _frozen_param20" [id=220, type=get_attr]; +"221 dequantize_per_channel_default_20" [id=221, type=dequantize_per_channel]; +"222 linear" [id=222, type=linear]; +"223 output" [id=223, type=output]; +"0 fc_bias" -> "222 linear" [label="(1000,)", style=solid]; +"1 x" -> "2 quantize_per_tensor_default" [label="(1, 3, 224, 224)", style=solid]; +"2 quantize_per_tensor_default" -> "3 dequantize_per_tensor_default" [label="(1, 3, 224, 224)", style=solid]; +"3 dequantize_per_tensor_default" -> "9 conv2d" [label="(1, 3, 224, 224)", style=solid]; +"4 conv1_weight_bias" -> "9 conv2d" [label="(64,)", style=solid]; +"5 conv2d_scale_0" -> "8 dequantize_per_channel_default" [label="(64,)", style=solid]; +"6 conv2d_zero_point_0" -> "8 dequantize_per_channel_default" [label="(64,)", style=solid]; +"7 _frozen_param0" -> "8 dequantize_per_channel_default" [label="(64, 3, 7, 7)", style=solid]; +"8 dequantize_per_channel_default" -> "9 conv2d" [label="(64, 3, 7, 7)", style=solid]; +"9 conv2d" -> "10 relu_" [label="(1, 64, 112, 112)", style=solid]; +"10 relu_" -> "11 quantize_per_tensor_default_1" [label="(1, 64, 112, 112)", style=solid]; +"11 quantize_per_tensor_default_1" -> "12 dequantize_per_tensor_default_1" [label="(1, 64, 112, 112)", style=solid]; +"12 dequantize_per_tensor_default_1" -> "13 max_pool2d" [label="(1, 64, 112, 112)", style=solid]; +"13 max_pool2d" -> "19 conv2d_1" [label="(1, 64, 56, 56)", style=solid]; +"13 max_pool2d" -> "31 add_" [label="(1, 64, 56, 56)", style=solid]; +"14 layer1_0_conv1_weight_bias" -> "19 conv2d_1" [label="(64,)", style=solid]; +"15 conv2d_1_scale_0" -> "18 dequantize_per_channel_default_1" [label="(64,)", style=solid]; +"16 conv2d_1_zero_point_0" -> "18 dequantize_per_channel_default_1" [label="(64,)", style=solid]; +"17 _frozen_param1" -> "18 dequantize_per_channel_default_1" [label="(64, 64, 3, 3)", style=solid]; +"18 dequantize_per_channel_default_1" -> "19 conv2d_1" [label="(64, 64, 3, 3)", style=solid]; +"19 conv2d_1" -> "20 relu__1" [label="(1, 64, 56, 56)", style=solid]; +"20 relu__1" -> "21 quantize_per_tensor_default_2" [label="(1, 64, 56, 56)", style=solid]; +"21 quantize_per_tensor_default_2" -> "22 dequantize_per_tensor_default_2" [label="(1, 64, 56, 56)", style=solid]; +"22 dequantize_per_tensor_default_2" -> "28 conv2d_2" [label="(1, 64, 56, 56)", style=solid]; +"23 layer1_0_conv2_weight_bias" -> "28 conv2d_2" [label="(64,)", style=solid]; +"24 conv2d_2_scale_0" -> "27 dequantize_per_channel_default_2" [label="(64,)", style=solid]; +"25 conv2d_2_zero_point_0" -> "27 dequantize_per_channel_default_2" [label="(64,)", style=solid]; +"26 _frozen_param2" -> "27 dequantize_per_channel_default_2" [label="(64, 64, 3, 3)", style=solid]; +"27 dequantize_per_channel_default_2" -> "28 conv2d_2" [label="(64, 64, 3, 3)", style=solid]; +"28 conv2d_2" -> "29 quantize_per_tensor_default_3" [label="(1, 64, 56, 56)", style=solid]; +"29 quantize_per_tensor_default_3" -> "30 dequantize_per_tensor_default_3" [label="(1, 64, 56, 56)", style=solid]; +"30 dequantize_per_tensor_default_3" -> "31 add_" [label="(1, 64, 56, 56)", style=solid]; +"31 add_" -> "32 relu__2" [label="(1, 64, 56, 56)", style=solid]; +"32 relu__2" -> "33 quantize_per_tensor_default_4" [label="(1, 64, 56, 56)", style=solid]; +"33 quantize_per_tensor_default_4" -> "34 dequantize_per_tensor_default_5" [label="(1, 64, 56, 56)", style=solid]; +"33 quantize_per_tensor_default_4" -> "35 dequantize_per_tensor_default_4" [label="(1, 64, 56, 56)", style=solid]; +"34 dequantize_per_tensor_default_5" -> "53 add__1" [label="(1, 64, 56, 56)", style=solid]; +"35 dequantize_per_tensor_default_4" -> "41 conv2d_3" [label="(1, 64, 56, 56)", style=solid]; +"36 layer1_1_conv1_weight_bias" -> "41 conv2d_3" [label="(64,)", style=solid]; +"37 conv2d_3_scale_0" -> "40 dequantize_per_channel_default_3" [label="(64,)", style=solid]; +"38 conv2d_3_zero_point_0" -> "40 dequantize_per_channel_default_3" [label="(64,)", style=solid]; +"39 _frozen_param3" -> "40 dequantize_per_channel_default_3" [label="(64, 64, 3, 3)", style=solid]; +"40 dequantize_per_channel_default_3" -> "41 conv2d_3" [label="(64, 64, 3, 3)", style=solid]; +"41 conv2d_3" -> "42 relu__3" [label="(1, 64, 56, 56)", style=solid]; +"42 relu__3" -> "43 quantize_per_tensor_default_5" [label="(1, 64, 56, 56)", style=solid]; +"43 quantize_per_tensor_default_5" -> "44 dequantize_per_tensor_default_6" [label="(1, 64, 56, 56)", style=solid]; +"44 dequantize_per_tensor_default_6" -> "50 conv2d_4" [label="(1, 64, 56, 56)", style=solid]; +"45 layer1_1_conv2_weight_bias" -> "50 conv2d_4" [label="(64,)", style=solid]; +"46 conv2d_4_scale_0" -> "49 dequantize_per_channel_default_4" [label="(64,)", style=solid]; +"47 conv2d_4_zero_point_0" -> "49 dequantize_per_channel_default_4" [label="(64,)", style=solid]; +"48 _frozen_param4" -> "49 dequantize_per_channel_default_4" [label="(64, 64, 3, 3)", style=solid]; +"49 dequantize_per_channel_default_4" -> "50 conv2d_4" [label="(64, 64, 3, 3)", style=solid]; +"50 conv2d_4" -> "51 quantize_per_tensor_default_6" [label="(1, 64, 56, 56)", style=solid]; +"51 quantize_per_tensor_default_6" -> "52 dequantize_per_tensor_default_7" [label="(1, 64, 56, 56)", style=solid]; +"52 dequantize_per_tensor_default_7" -> "53 add__1" [label="(1, 64, 56, 56)", style=solid]; +"53 add__1" -> "54 relu__4" [label="(1, 64, 56, 56)", style=solid]; +"54 relu__4" -> "55 quantize_per_tensor_default_7" [label="(1, 64, 56, 56)", style=solid]; +"55 quantize_per_tensor_default_7" -> "56 dequantize_per_tensor_default_9" [label="(1, 64, 56, 56)", style=solid]; +"55 quantize_per_tensor_default_7" -> "57 dequantize_per_tensor_default_8" [label="(1, 64, 56, 56)", style=solid]; +"56 dequantize_per_tensor_default_9" -> "80 conv2d_7" [label="(1, 64, 56, 56)", style=solid]; +"57 dequantize_per_tensor_default_8" -> "63 conv2d_5" [label="(1, 64, 56, 56)", style=solid]; +"58 layer2_0_conv1_weight_bias" -> "63 conv2d_5" [label="(128,)", style=solid]; +"59 conv2d_5_scale_0" -> "62 dequantize_per_channel_default_5" [label="(128,)", style=solid]; +"60 conv2d_5_zero_point_0" -> "62 dequantize_per_channel_default_5" [label="(128,)", style=solid]; +"61 _frozen_param5" -> "62 dequantize_per_channel_default_5" [label="(128, 64, 3, 3)", style=solid]; +"62 dequantize_per_channel_default_5" -> "63 conv2d_5" [label="(128, 64, 3, 3)", style=solid]; +"63 conv2d_5" -> "64 relu__5" [label="(1, 128, 28, 28)", style=solid]; +"64 relu__5" -> "65 quantize_per_tensor_default_8" [label="(1, 128, 28, 28)", style=solid]; +"65 quantize_per_tensor_default_8" -> "66 dequantize_per_tensor_default_10" [label="(1, 128, 28, 28)", style=solid]; +"66 dequantize_per_tensor_default_10" -> "72 conv2d_6" [label="(1, 128, 28, 28)", style=solid]; +"67 layer2_0_conv2_weight_bias" -> "72 conv2d_6" [label="(128,)", style=solid]; +"68 conv2d_6_scale_0" -> "71 dequantize_per_channel_default_6" [label="(128,)", style=solid]; +"69 conv2d_6_zero_point_0" -> "71 dequantize_per_channel_default_6" [label="(128,)", style=solid]; +"70 _frozen_param6" -> "71 dequantize_per_channel_default_6" [label="(128, 128, 3, 3)", style=solid]; +"71 dequantize_per_channel_default_6" -> "72 conv2d_6" [label="(128, 128, 3, 3)", style=solid]; +"72 conv2d_6" -> "73 quantize_per_tensor_default_9" [label="(1, 128, 28, 28)", style=solid]; +"73 quantize_per_tensor_default_9" -> "74 dequantize_per_tensor_default_11" [label="(1, 128, 28, 28)", style=solid]; +"74 dequantize_per_tensor_default_11" -> "83 add__2" [label="(1, 128, 28, 28)", style=solid]; +"75 layer2_0_downsample_0_weight_bias" -> "80 conv2d_7" [label="(128,)", style=solid]; +"76 conv2d_7_scale_0" -> "79 dequantize_per_channel_default_7" [label="(128,)", style=solid]; +"77 conv2d_7_zero_point_0" -> "79 dequantize_per_channel_default_7" [label="(128,)", style=solid]; +"78 _frozen_param7" -> "79 dequantize_per_channel_default_7" [label="(128, 64, 1, 1)", style=solid]; +"79 dequantize_per_channel_default_7" -> "80 conv2d_7" [label="(128, 64, 1, 1)", style=solid]; +"80 conv2d_7" -> "81 quantize_per_tensor_default_10" [label="(1, 128, 28, 28)", style=solid]; +"81 quantize_per_tensor_default_10" -> "82 dequantize_per_tensor_default_12" [label="(1, 128, 28, 28)", style=solid]; +"82 dequantize_per_tensor_default_12" -> "83 add__2" [label="(1, 128, 28, 28)", style=solid]; +"83 add__2" -> "84 relu__6" [label="(1, 128, 28, 28)", style=solid]; +"84 relu__6" -> "85 quantize_per_tensor_default_11" [label="(1, 128, 28, 28)", style=solid]; +"85 quantize_per_tensor_default_11" -> "86 dequantize_per_tensor_default_14" [label="(1, 128, 28, 28)", style=solid]; +"85 quantize_per_tensor_default_11" -> "87 dequantize_per_tensor_default_13" [label="(1, 128, 28, 28)", style=solid]; +"86 dequantize_per_tensor_default_14" -> "105 add__3" [label="(1, 128, 28, 28)", style=solid]; +"87 dequantize_per_tensor_default_13" -> "93 conv2d_8" [label="(1, 128, 28, 28)", style=solid]; +"88 layer2_1_conv1_weight_bias" -> "93 conv2d_8" [label="(128,)", style=solid]; +"89 conv2d_8_scale_0" -> "92 dequantize_per_channel_default_8" [label="(128,)", style=solid]; +"90 conv2d_8_zero_point_0" -> "92 dequantize_per_channel_default_8" [label="(128,)", style=solid]; +"91 _frozen_param8" -> "92 dequantize_per_channel_default_8" [label="(128, 128, 3, 3)", style=solid]; +"92 dequantize_per_channel_default_8" -> "93 conv2d_8" [label="(128, 128, 3, 3)", style=solid]; +"93 conv2d_8" -> "94 relu__7" [label="(1, 128, 28, 28)", style=solid]; +"94 relu__7" -> "95 quantize_per_tensor_default_12" [label="(1, 128, 28, 28)", style=solid]; +"95 quantize_per_tensor_default_12" -> "96 dequantize_per_tensor_default_15" [label="(1, 128, 28, 28)", style=solid]; +"96 dequantize_per_tensor_default_15" -> "102 conv2d_9" [label="(1, 128, 28, 28)", style=solid]; +"97 layer2_1_conv2_weight_bias" -> "102 conv2d_9" [label="(128,)", style=solid]; +"98 conv2d_9_scale_0" -> "101 dequantize_per_channel_default_9" [label="(128,)", style=solid]; +"99 conv2d_9_zero_point_0" -> "101 dequantize_per_channel_default_9" [label="(128,)", style=solid]; +"100 _frozen_param9" -> "101 dequantize_per_channel_default_9" [label="(128, 128, 3, 3)", style=solid]; +"101 dequantize_per_channel_default_9" -> "102 conv2d_9" [label="(128, 128, 3, 3)", style=solid]; +"102 conv2d_9" -> "103 quantize_per_tensor_default_13" [label="(1, 128, 28, 28)", style=solid]; +"103 quantize_per_tensor_default_13" -> "104 dequantize_per_tensor_default_16" [label="(1, 128, 28, 28)", style=solid]; +"104 dequantize_per_tensor_default_16" -> "105 add__3" [label="(1, 128, 28, 28)", style=solid]; +"105 add__3" -> "106 relu__8" [label="(1, 128, 28, 28)", style=solid]; +"106 relu__8" -> "107 quantize_per_tensor_default_14" [label="(1, 128, 28, 28)", style=solid]; +"107 quantize_per_tensor_default_14" -> "108 dequantize_per_tensor_default_18" [label="(1, 128, 28, 28)", style=solid]; +"107 quantize_per_tensor_default_14" -> "109 dequantize_per_tensor_default_17" [label="(1, 128, 28, 28)", style=solid]; +"108 dequantize_per_tensor_default_18" -> "132 conv2d_12" [label="(1, 128, 28, 28)", style=solid]; +"109 dequantize_per_tensor_default_17" -> "115 conv2d_10" [label="(1, 128, 28, 28)", style=solid]; +"110 layer3_0_conv1_weight_bias" -> "115 conv2d_10" [label="(256,)", style=solid]; +"111 conv2d_10_scale_0" -> "114 dequantize_per_channel_default_10" [label="(256,)", style=solid]; +"112 conv2d_10_zero_point_0" -> "114 dequantize_per_channel_default_10" [label="(256,)", style=solid]; +"113 _frozen_param10" -> "114 dequantize_per_channel_default_10" [label="(256, 128, 3, 3)", style=solid]; +"114 dequantize_per_channel_default_10" -> "115 conv2d_10" [label="(256, 128, 3, 3)", style=solid]; +"115 conv2d_10" -> "116 relu__9" [label="(1, 256, 14, 14)", style=solid]; +"116 relu__9" -> "117 quantize_per_tensor_default_15" [label="(1, 256, 14, 14)", style=solid]; +"117 quantize_per_tensor_default_15" -> "118 dequantize_per_tensor_default_19" [label="(1, 256, 14, 14)", style=solid]; +"118 dequantize_per_tensor_default_19" -> "124 conv2d_11" [label="(1, 256, 14, 14)", style=solid]; +"119 layer3_0_conv2_weight_bias" -> "124 conv2d_11" [label="(256,)", style=solid]; +"120 conv2d_11_scale_0" -> "123 dequantize_per_channel_default_11" [label="(256,)", style=solid]; +"121 conv2d_11_zero_point_0" -> "123 dequantize_per_channel_default_11" [label="(256,)", style=solid]; +"122 _frozen_param11" -> "123 dequantize_per_channel_default_11" [label="(256, 256, 3, 3)", style=solid]; +"123 dequantize_per_channel_default_11" -> "124 conv2d_11" [label="(256, 256, 3, 3)", style=solid]; +"124 conv2d_11" -> "125 quantize_per_tensor_default_16" [label="(1, 256, 14, 14)", style=solid]; +"125 quantize_per_tensor_default_16" -> "126 dequantize_per_tensor_default_20" [label="(1, 256, 14, 14)", style=solid]; +"126 dequantize_per_tensor_default_20" -> "135 add__4" [label="(1, 256, 14, 14)", style=solid]; +"127 layer3_0_downsample_0_weight_bias" -> "132 conv2d_12" [label="(256,)", style=solid]; +"128 conv2d_12_scale_0" -> "131 dequantize_per_channel_default_12" [label="(256,)", style=solid]; +"129 conv2d_12_zero_point_0" -> "131 dequantize_per_channel_default_12" [label="(256,)", style=solid]; +"130 _frozen_param12" -> "131 dequantize_per_channel_default_12" [label="(256, 128, 1, 1)", style=solid]; +"131 dequantize_per_channel_default_12" -> "132 conv2d_12" [label="(256, 128, 1, 1)", style=solid]; +"132 conv2d_12" -> "133 quantize_per_tensor_default_17" [label="(1, 256, 14, 14)", style=solid]; +"133 quantize_per_tensor_default_17" -> "134 dequantize_per_tensor_default_21" [label="(1, 256, 14, 14)", style=solid]; +"134 dequantize_per_tensor_default_21" -> "135 add__4" [label="(1, 256, 14, 14)", style=solid]; +"135 add__4" -> "136 relu__10" [label="(1, 256, 14, 14)", style=solid]; +"136 relu__10" -> "137 quantize_per_tensor_default_18" [label="(1, 256, 14, 14)", style=solid]; +"137 quantize_per_tensor_default_18" -> "138 dequantize_per_tensor_default_23" [label="(1, 256, 14, 14)", style=solid]; +"137 quantize_per_tensor_default_18" -> "139 dequantize_per_tensor_default_22" [label="(1, 256, 14, 14)", style=solid]; +"138 dequantize_per_tensor_default_23" -> "157 add__5" [label="(1, 256, 14, 14)", style=solid]; +"139 dequantize_per_tensor_default_22" -> "145 conv2d_13" [label="(1, 256, 14, 14)", style=solid]; +"140 layer3_1_conv1_weight_bias" -> "145 conv2d_13" [label="(256,)", style=solid]; +"141 conv2d_13_scale_0" -> "144 dequantize_per_channel_default_13" [label="(256,)", style=solid]; +"142 conv2d_13_zero_point_0" -> "144 dequantize_per_channel_default_13" [label="(256,)", style=solid]; +"143 _frozen_param13" -> "144 dequantize_per_channel_default_13" [label="(256, 256, 3, 3)", style=solid]; +"144 dequantize_per_channel_default_13" -> "145 conv2d_13" [label="(256, 256, 3, 3)", style=solid]; +"145 conv2d_13" -> "146 relu__11" [label="(1, 256, 14, 14)", style=solid]; +"146 relu__11" -> "147 quantize_per_tensor_default_19" [label="(1, 256, 14, 14)", style=solid]; +"147 quantize_per_tensor_default_19" -> "148 dequantize_per_tensor_default_24" [label="(1, 256, 14, 14)", style=solid]; +"148 dequantize_per_tensor_default_24" -> "154 conv2d_14" [label="(1, 256, 14, 14)", style=solid]; +"149 layer3_1_conv2_weight_bias" -> "154 conv2d_14" [label="(256,)", style=solid]; +"150 conv2d_14_scale_0" -> "153 dequantize_per_channel_default_14" [label="(256,)", style=solid]; +"151 conv2d_14_zero_point_0" -> "153 dequantize_per_channel_default_14" [label="(256,)", style=solid]; +"152 _frozen_param14" -> "153 dequantize_per_channel_default_14" [label="(256, 256, 3, 3)", style=solid]; +"153 dequantize_per_channel_default_14" -> "154 conv2d_14" [label="(256, 256, 3, 3)", style=solid]; +"154 conv2d_14" -> "155 quantize_per_tensor_default_20" [label="(1, 256, 14, 14)", style=solid]; +"155 quantize_per_tensor_default_20" -> "156 dequantize_per_tensor_default_25" [label="(1, 256, 14, 14)", style=solid]; +"156 dequantize_per_tensor_default_25" -> "157 add__5" [label="(1, 256, 14, 14)", style=solid]; +"157 add__5" -> "158 relu__12" [label="(1, 256, 14, 14)", style=solid]; +"158 relu__12" -> "159 quantize_per_tensor_default_21" [label="(1, 256, 14, 14)", style=solid]; +"159 quantize_per_tensor_default_21" -> "160 dequantize_per_tensor_default_27" [label="(1, 256, 14, 14)", style=solid]; +"159 quantize_per_tensor_default_21" -> "161 dequantize_per_tensor_default_26" [label="(1, 256, 14, 14)", style=solid]; +"160 dequantize_per_tensor_default_27" -> "184 conv2d_17" [label="(1, 256, 14, 14)", style=solid]; +"161 dequantize_per_tensor_default_26" -> "167 conv2d_15" [label="(1, 256, 14, 14)", style=solid]; +"162 layer4_0_conv1_weight_bias" -> "167 conv2d_15" [label="(512,)", style=solid]; +"163 conv2d_15_scale_0" -> "166 dequantize_per_channel_default_15" [label="(512,)", style=solid]; +"164 conv2d_15_zero_point_0" -> "166 dequantize_per_channel_default_15" [label="(512,)", style=solid]; +"165 _frozen_param15" -> "166 dequantize_per_channel_default_15" [label="(512, 256, 3, 3)", style=solid]; +"166 dequantize_per_channel_default_15" -> "167 conv2d_15" [label="(512, 256, 3, 3)", style=solid]; +"167 conv2d_15" -> "168 relu__13" [label="(1, 512, 7, 7)", style=solid]; +"168 relu__13" -> "169 quantize_per_tensor_default_22" [label="(1, 512, 7, 7)", style=solid]; +"169 quantize_per_tensor_default_22" -> "170 dequantize_per_tensor_default_28" [label="(1, 512, 7, 7)", style=solid]; +"170 dequantize_per_tensor_default_28" -> "176 conv2d_16" [label="(1, 512, 7, 7)", style=solid]; +"171 layer4_0_conv2_weight_bias" -> "176 conv2d_16" [label="(512,)", style=solid]; +"172 conv2d_16_scale_0" -> "175 dequantize_per_channel_default_16" [label="(512,)", style=solid]; +"173 conv2d_16_zero_point_0" -> "175 dequantize_per_channel_default_16" [label="(512,)", style=solid]; +"174 _frozen_param16" -> "175 dequantize_per_channel_default_16" [label="(512, 512, 3, 3)", style=solid]; +"175 dequantize_per_channel_default_16" -> "176 conv2d_16" [label="(512, 512, 3, 3)", style=solid]; +"176 conv2d_16" -> "177 quantize_per_tensor_default_23" [label="(1, 512, 7, 7)", style=solid]; +"177 quantize_per_tensor_default_23" -> "178 dequantize_per_tensor_default_29" [label="(1, 512, 7, 7)", style=solid]; +"178 dequantize_per_tensor_default_29" -> "187 add__6" [label="(1, 512, 7, 7)", style=solid]; +"179 layer4_0_downsample_0_weight_bias" -> "184 conv2d_17" [label="(512,)", style=solid]; +"180 conv2d_17_scale_0" -> "183 dequantize_per_channel_default_17" [label="(512,)", style=solid]; +"181 conv2d_17_zero_point_0" -> "183 dequantize_per_channel_default_17" [label="(512,)", style=solid]; +"182 _frozen_param17" -> "183 dequantize_per_channel_default_17" [label="(512, 256, 1, 1)", style=solid]; +"183 dequantize_per_channel_default_17" -> "184 conv2d_17" [label="(512, 256, 1, 1)", style=solid]; +"184 conv2d_17" -> "185 quantize_per_tensor_default_24" [label="(1, 512, 7, 7)", style=solid]; +"185 quantize_per_tensor_default_24" -> "186 dequantize_per_tensor_default_30" [label="(1, 512, 7, 7)", style=solid]; +"186 dequantize_per_tensor_default_30" -> "187 add__6" [label="(1, 512, 7, 7)", style=solid]; +"187 add__6" -> "188 relu__14" [label="(1, 512, 7, 7)", style=solid]; +"188 relu__14" -> "189 quantize_per_tensor_default_25" [label="(1, 512, 7, 7)", style=solid]; +"189 quantize_per_tensor_default_25" -> "190 dequantize_per_tensor_default_32" [label="(1, 512, 7, 7)", style=solid]; +"189 quantize_per_tensor_default_25" -> "191 dequantize_per_tensor_default_31" [label="(1, 512, 7, 7)", style=solid]; +"190 dequantize_per_tensor_default_32" -> "209 add__7" [label="(1, 512, 7, 7)", style=solid]; +"191 dequantize_per_tensor_default_31" -> "197 conv2d_18" [label="(1, 512, 7, 7)", style=solid]; +"192 layer4_1_conv1_weight_bias" -> "197 conv2d_18" [label="(512,)", style=solid]; +"193 conv2d_18_scale_0" -> "196 dequantize_per_channel_default_18" [label="(512,)", style=solid]; +"194 conv2d_18_zero_point_0" -> "196 dequantize_per_channel_default_18" [label="(512,)", style=solid]; +"195 _frozen_param18" -> "196 dequantize_per_channel_default_18" [label="(512, 512, 3, 3)", style=solid]; +"196 dequantize_per_channel_default_18" -> "197 conv2d_18" [label="(512, 512, 3, 3)", style=solid]; +"197 conv2d_18" -> "198 relu__15" [label="(1, 512, 7, 7)", style=solid]; +"198 relu__15" -> "199 quantize_per_tensor_default_26" [label="(1, 512, 7, 7)", style=solid]; +"199 quantize_per_tensor_default_26" -> "200 dequantize_per_tensor_default_33" [label="(1, 512, 7, 7)", style=solid]; +"200 dequantize_per_tensor_default_33" -> "206 conv2d_19" [label="(1, 512, 7, 7)", style=solid]; +"201 layer4_1_conv2_weight_bias" -> "206 conv2d_19" [label="(512,)", style=solid]; +"202 conv2d_19_scale_0" -> "205 dequantize_per_channel_default_19" [label="(512,)", style=solid]; +"203 conv2d_19_zero_point_0" -> "205 dequantize_per_channel_default_19" [label="(512,)", style=solid]; +"204 _frozen_param19" -> "205 dequantize_per_channel_default_19" [label="(512, 512, 3, 3)", style=solid]; +"205 dequantize_per_channel_default_19" -> "206 conv2d_19" [label="(512, 512, 3, 3)", style=solid]; +"206 conv2d_19" -> "207 quantize_per_tensor_default_27" [label="(1, 512, 7, 7)", style=solid]; +"207 quantize_per_tensor_default_27" -> "208 dequantize_per_tensor_default_34" [label="(1, 512, 7, 7)", style=solid]; +"208 dequantize_per_tensor_default_34" -> "209 add__7" [label="(1, 512, 7, 7)", style=solid]; +"209 add__7" -> "210 relu__16" [label="(1, 512, 7, 7)", style=solid]; +"210 relu__16" -> "211 quantize_per_tensor_default_28" [label="(1, 512, 7, 7)", style=solid]; +"211 quantize_per_tensor_default_28" -> "212 dequantize_per_tensor_default_35" [label="(1, 512, 7, 7)", style=solid]; +"212 dequantize_per_tensor_default_35" -> "213 adaptive_avg_pool2d" [label="(1, 512, 7, 7)", style=solid]; +"213 adaptive_avg_pool2d" -> "214 flatten" [label="(1, 512, 1, 1)", style=solid]; +"214 flatten" -> "215 flatten_0_0_nncf_smooth_quant_0" [label="(1, 512)", style=solid]; +"215 flatten_0_0_nncf_smooth_quant_0" -> "216 quantize_per_tensor_default_29" [label="(1, 512)", style=solid]; +"216 quantize_per_tensor_default_29" -> "217 dequantize_per_tensor_default_36" [label="(1, 512)", style=solid]; +"217 dequantize_per_tensor_default_36" -> "222 linear" [label="(1, 512)", style=solid]; +"218 linear_scale_0" -> "221 dequantize_per_channel_default_20" [label="(1000,)", style=solid]; +"219 linear_zero_point_0" -> "221 dequantize_per_channel_default_20" [label="(1000,)", style=solid]; +"220 _frozen_param20" -> "221 dequantize_per_channel_default_20" [label="(1000, 512)", style=solid]; +"221 dequantize_per_channel_default_20" -> "222 linear" [label="(1000, 512)", style=solid]; +"222 linear" -> "223 output" [label="(1, 1000)", style=solid]; +} diff --git a/tests/torch/data/reference_graphs/fx/experimental/OpenVINOQuantizer/swin_v2_s.dot b/tests/torch/data/reference_graphs/fx/experimental/OpenVINOQuantizer/swin_v2_s.dot new file mode 100644 index 00000000000..0e655b8fce3 --- /dev/null +++ b/tests/torch/data/reference_graphs/fx/experimental/OpenVINOQuantizer/swin_v2_s.dot @@ -0,0 +1,6310 @@ +strict digraph { +"0 features_1_0_attn_qkv_bias" [id=0, type=get_attr]; +"1 features_1_0_attn_proj_bias" [id=1, type=get_attr]; +"2 features_1_0_attn_logit_scale" [id=2, type=get_attr]; +"3 features_1_1_attn_qkv_bias" [id=3, type=get_attr]; +"4 features_1_1_attn_proj_bias" [id=4, type=get_attr]; +"5 features_1_1_attn_logit_scale" [id=5, type=get_attr]; +"6 features_3_0_attn_qkv_bias" [id=6, type=get_attr]; +"7 features_3_0_attn_proj_bias" [id=7, type=get_attr]; +"8 features_3_0_attn_logit_scale" [id=8, type=get_attr]; +"9 features_3_1_attn_qkv_bias" [id=9, type=get_attr]; +"10 features_3_1_attn_proj_bias" [id=10, type=get_attr]; +"11 features_3_1_attn_logit_scale" [id=11, type=get_attr]; +"12 features_5_0_attn_qkv_bias" [id=12, type=get_attr]; +"13 features_5_0_attn_proj_bias" [id=13, type=get_attr]; +"14 features_5_0_attn_logit_scale" [id=14, type=get_attr]; +"15 features_5_1_attn_qkv_bias" [id=15, type=get_attr]; +"16 features_5_1_attn_proj_bias" [id=16, type=get_attr]; +"17 features_5_1_attn_logit_scale" [id=17, type=get_attr]; +"18 features_5_2_attn_qkv_bias" [id=18, type=get_attr]; +"19 features_5_2_attn_proj_bias" [id=19, type=get_attr]; +"20 features_5_2_attn_logit_scale" [id=20, type=get_attr]; +"21 features_5_3_attn_qkv_bias" [id=21, type=get_attr]; +"22 features_5_3_attn_proj_bias" [id=22, type=get_attr]; +"23 features_5_3_attn_logit_scale" [id=23, type=get_attr]; +"24 features_5_4_attn_qkv_bias" [id=24, type=get_attr]; +"25 features_5_4_attn_proj_bias" [id=25, type=get_attr]; +"26 features_5_4_attn_logit_scale" [id=26, type=get_attr]; +"27 features_5_5_attn_qkv_bias" [id=27, type=get_attr]; +"28 features_5_5_attn_proj_bias" [id=28, type=get_attr]; +"29 features_5_5_attn_logit_scale" [id=29, type=get_attr]; +"30 features_5_6_attn_qkv_bias" [id=30, type=get_attr]; +"31 features_5_6_attn_proj_bias" [id=31, type=get_attr]; +"32 features_5_6_attn_logit_scale" [id=32, type=get_attr]; +"33 features_5_7_attn_qkv_bias" [id=33, type=get_attr]; +"34 features_5_7_attn_proj_bias" [id=34, type=get_attr]; +"35 features_5_7_attn_logit_scale" [id=35, type=get_attr]; +"36 features_5_8_attn_qkv_bias" [id=36, type=get_attr]; +"37 features_5_8_attn_proj_bias" [id=37, type=get_attr]; +"38 features_5_8_attn_logit_scale" [id=38, type=get_attr]; +"39 features_5_9_attn_qkv_bias" [id=39, type=get_attr]; +"40 features_5_9_attn_proj_bias" [id=40, type=get_attr]; +"41 features_5_9_attn_logit_scale" [id=41, type=get_attr]; +"42 features_5_10_attn_qkv_bias" [id=42, type=get_attr]; +"43 features_5_10_attn_proj_bias" [id=43, type=get_attr]; +"44 features_5_10_attn_logit_scale" [id=44, type=get_attr]; +"45 features_5_11_attn_qkv_bias" [id=45, type=get_attr]; +"46 features_5_11_attn_proj_bias" [id=46, type=get_attr]; +"47 features_5_11_attn_logit_scale" [id=47, type=get_attr]; +"48 features_5_12_attn_qkv_bias" [id=48, type=get_attr]; +"49 features_5_12_attn_proj_bias" [id=49, type=get_attr]; +"50 features_5_12_attn_logit_scale" [id=50, type=get_attr]; +"51 features_5_13_attn_qkv_bias" [id=51, type=get_attr]; +"52 features_5_13_attn_proj_bias" [id=52, type=get_attr]; +"53 features_5_13_attn_logit_scale" [id=53, type=get_attr]; +"54 features_5_14_attn_qkv_bias" [id=54, type=get_attr]; +"55 features_5_14_attn_proj_bias" [id=55, type=get_attr]; +"56 features_5_14_attn_logit_scale" [id=56, type=get_attr]; +"57 features_5_15_attn_qkv_bias" [id=57, type=get_attr]; +"58 features_5_15_attn_proj_bias" [id=58, type=get_attr]; +"59 features_5_15_attn_logit_scale" [id=59, type=get_attr]; +"60 features_5_16_attn_qkv_bias" [id=60, type=get_attr]; +"61 features_5_16_attn_proj_bias" [id=61, type=get_attr]; +"62 features_5_16_attn_logit_scale" [id=62, type=get_attr]; +"63 features_5_17_attn_qkv_bias" [id=63, type=get_attr]; +"64 features_5_17_attn_proj_bias" [id=64, type=get_attr]; +"65 features_5_17_attn_logit_scale" [id=65, type=get_attr]; +"66 features_7_0_attn_qkv_bias" [id=66, type=get_attr]; +"67 features_7_0_attn_proj_bias" [id=67, type=get_attr]; +"68 features_7_0_attn_logit_scale" [id=68, type=get_attr]; +"69 features_7_1_attn_qkv_bias" [id=69, type=get_attr]; +"70 features_7_1_attn_proj_bias" [id=70, type=get_attr]; +"71 features_7_1_attn_logit_scale" [id=71, type=get_attr]; +"72 features_0_0_bias" [id=72, type=get_attr]; +"73 features_0_2_weight" [id=73, type=get_attr]; +"74 features_0_2_bias" [id=74, type=get_attr]; +"75 features_1_0_attn_cpb_mlp_0_bias" [id=75, type=get_attr]; +"76 features_1_0_norm1_weight" [id=76, type=get_attr]; +"77 features_1_0_norm1_bias" [id=77, type=get_attr]; +"78 features_1_0_mlp_0_bias" [id=78, type=get_attr]; +"79 features_1_0_mlp_3_bias" [id=79, type=get_attr]; +"80 features_1_0_norm2_weight" [id=80, type=get_attr]; +"81 features_1_0_norm2_bias" [id=81, type=get_attr]; +"82 features_1_1_attn_cpb_mlp_0_bias" [id=82, type=get_attr]; +"83 features_1_1_norm1_weight" [id=83, type=get_attr]; +"84 features_1_1_norm1_bias" [id=84, type=get_attr]; +"85 features_1_1_mlp_0_bias" [id=85, type=get_attr]; +"86 features_1_1_mlp_3_bias" [id=86, type=get_attr]; +"87 features_1_1_norm2_weight" [id=87, type=get_attr]; +"88 features_1_1_norm2_bias" [id=88, type=get_attr]; +"89 features_2_norm_weight" [id=89, type=get_attr]; +"90 features_2_norm_bias" [id=90, type=get_attr]; +"91 features_3_0_attn_cpb_mlp_0_bias" [id=91, type=get_attr]; +"92 features_3_0_norm1_weight" [id=92, type=get_attr]; +"93 features_3_0_norm1_bias" [id=93, type=get_attr]; +"94 features_3_0_mlp_0_bias" [id=94, type=get_attr]; +"95 features_3_0_mlp_3_bias" [id=95, type=get_attr]; +"96 features_3_0_norm2_weight" [id=96, type=get_attr]; +"97 features_3_0_norm2_bias" [id=97, type=get_attr]; +"98 features_3_1_attn_cpb_mlp_0_bias" [id=98, type=get_attr]; +"99 features_3_1_norm1_weight" [id=99, type=get_attr]; +"100 features_3_1_norm1_bias" [id=100, type=get_attr]; +"101 features_3_1_mlp_0_bias" [id=101, type=get_attr]; +"102 features_3_1_mlp_3_bias" [id=102, type=get_attr]; +"103 features_3_1_norm2_weight" [id=103, type=get_attr]; +"104 features_3_1_norm2_bias" [id=104, type=get_attr]; +"105 features_4_norm_weight" [id=105, type=get_attr]; +"106 features_4_norm_bias" [id=106, type=get_attr]; +"107 features_5_0_attn_cpb_mlp_0_bias" [id=107, type=get_attr]; +"108 features_5_0_norm1_weight" [id=108, type=get_attr]; +"109 features_5_0_norm1_bias" [id=109, type=get_attr]; +"110 features_5_0_mlp_0_bias" [id=110, type=get_attr]; +"111 features_5_0_mlp_3_bias" [id=111, type=get_attr]; +"112 features_5_0_norm2_weight" [id=112, type=get_attr]; +"113 features_5_0_norm2_bias" [id=113, type=get_attr]; +"114 features_5_1_attn_cpb_mlp_0_bias" [id=114, type=get_attr]; +"115 features_5_1_norm1_weight" [id=115, type=get_attr]; +"116 features_5_1_norm1_bias" [id=116, type=get_attr]; +"117 features_5_1_mlp_0_bias" [id=117, type=get_attr]; +"118 features_5_1_mlp_3_bias" [id=118, type=get_attr]; +"119 features_5_1_norm2_weight" [id=119, type=get_attr]; +"120 features_5_1_norm2_bias" [id=120, type=get_attr]; +"121 features_5_2_attn_cpb_mlp_0_bias" [id=121, type=get_attr]; +"122 features_5_2_norm1_weight" [id=122, type=get_attr]; +"123 features_5_2_norm1_bias" [id=123, type=get_attr]; +"124 features_5_2_mlp_0_bias" [id=124, type=get_attr]; +"125 features_5_2_mlp_3_bias" [id=125, type=get_attr]; +"126 features_5_2_norm2_weight" [id=126, type=get_attr]; +"127 features_5_2_norm2_bias" [id=127, type=get_attr]; +"128 features_5_3_attn_cpb_mlp_0_bias" [id=128, type=get_attr]; +"129 features_5_3_norm1_weight" [id=129, type=get_attr]; +"130 features_5_3_norm1_bias" [id=130, type=get_attr]; +"131 features_5_3_mlp_0_bias" [id=131, type=get_attr]; +"132 features_5_3_mlp_3_bias" [id=132, type=get_attr]; +"133 features_5_3_norm2_weight" [id=133, type=get_attr]; +"134 features_5_3_norm2_bias" [id=134, type=get_attr]; +"135 features_5_4_attn_cpb_mlp_0_bias" [id=135, type=get_attr]; +"136 features_5_4_norm1_weight" [id=136, type=get_attr]; +"137 features_5_4_norm1_bias" [id=137, type=get_attr]; +"138 features_5_4_mlp_0_bias" [id=138, type=get_attr]; +"139 features_5_4_mlp_3_bias" [id=139, type=get_attr]; +"140 features_5_4_norm2_weight" [id=140, type=get_attr]; +"141 features_5_4_norm2_bias" [id=141, type=get_attr]; +"142 features_5_5_attn_cpb_mlp_0_bias" [id=142, type=get_attr]; +"143 features_5_5_norm1_weight" [id=143, type=get_attr]; +"144 features_5_5_norm1_bias" [id=144, type=get_attr]; +"145 features_5_5_mlp_0_bias" [id=145, type=get_attr]; +"146 features_5_5_mlp_3_bias" [id=146, type=get_attr]; +"147 features_5_5_norm2_weight" [id=147, type=get_attr]; +"148 features_5_5_norm2_bias" [id=148, type=get_attr]; +"149 features_5_6_attn_cpb_mlp_0_bias" [id=149, type=get_attr]; +"150 features_5_6_norm1_weight" [id=150, type=get_attr]; +"151 features_5_6_norm1_bias" [id=151, type=get_attr]; +"152 features_5_6_mlp_0_bias" [id=152, type=get_attr]; +"153 features_5_6_mlp_3_bias" [id=153, type=get_attr]; +"154 features_5_6_norm2_weight" [id=154, type=get_attr]; +"155 features_5_6_norm2_bias" [id=155, type=get_attr]; +"156 features_5_7_attn_cpb_mlp_0_bias" [id=156, type=get_attr]; +"157 features_5_7_norm1_weight" [id=157, type=get_attr]; +"158 features_5_7_norm1_bias" [id=158, type=get_attr]; +"159 features_5_7_mlp_0_bias" [id=159, type=get_attr]; +"160 features_5_7_mlp_3_bias" [id=160, type=get_attr]; +"161 features_5_7_norm2_weight" [id=161, type=get_attr]; +"162 features_5_7_norm2_bias" [id=162, type=get_attr]; +"163 features_5_8_attn_cpb_mlp_0_bias" [id=163, type=get_attr]; +"164 features_5_8_norm1_weight" [id=164, type=get_attr]; +"165 features_5_8_norm1_bias" [id=165, type=get_attr]; +"166 features_5_8_mlp_0_bias" [id=166, type=get_attr]; +"167 features_5_8_mlp_3_bias" [id=167, type=get_attr]; +"168 features_5_8_norm2_weight" [id=168, type=get_attr]; +"169 features_5_8_norm2_bias" [id=169, type=get_attr]; +"170 features_5_9_attn_cpb_mlp_0_bias" [id=170, type=get_attr]; +"171 features_5_9_norm1_weight" [id=171, type=get_attr]; +"172 features_5_9_norm1_bias" [id=172, type=get_attr]; +"173 features_5_9_mlp_0_bias" [id=173, type=get_attr]; +"174 features_5_9_mlp_3_bias" [id=174, type=get_attr]; +"175 features_5_9_norm2_weight" [id=175, type=get_attr]; +"176 features_5_9_norm2_bias" [id=176, type=get_attr]; +"177 features_5_10_attn_cpb_mlp_0_bias" [id=177, type=get_attr]; +"178 features_5_10_norm1_weight" [id=178, type=get_attr]; +"179 features_5_10_norm1_bias" [id=179, type=get_attr]; +"180 features_5_10_mlp_0_bias" [id=180, type=get_attr]; +"181 features_5_10_mlp_3_bias" [id=181, type=get_attr]; +"182 features_5_10_norm2_weight" [id=182, type=get_attr]; +"183 features_5_10_norm2_bias" [id=183, type=get_attr]; +"184 features_5_11_attn_cpb_mlp_0_bias" [id=184, type=get_attr]; +"185 features_5_11_norm1_weight" [id=185, type=get_attr]; +"186 features_5_11_norm1_bias" [id=186, type=get_attr]; +"187 features_5_11_mlp_0_bias" [id=187, type=get_attr]; +"188 features_5_11_mlp_3_bias" [id=188, type=get_attr]; +"189 features_5_11_norm2_weight" [id=189, type=get_attr]; +"190 features_5_11_norm2_bias" [id=190, type=get_attr]; +"191 features_5_12_attn_cpb_mlp_0_bias" [id=191, type=get_attr]; +"192 features_5_12_norm1_weight" [id=192, type=get_attr]; +"193 features_5_12_norm1_bias" [id=193, type=get_attr]; +"194 features_5_12_mlp_0_bias" [id=194, type=get_attr]; +"195 features_5_12_mlp_3_bias" [id=195, type=get_attr]; +"196 features_5_12_norm2_weight" [id=196, type=get_attr]; +"197 features_5_12_norm2_bias" [id=197, type=get_attr]; +"198 features_5_13_attn_cpb_mlp_0_bias" [id=198, type=get_attr]; +"199 features_5_13_norm1_weight" [id=199, type=get_attr]; +"200 features_5_13_norm1_bias" [id=200, type=get_attr]; +"201 features_5_13_mlp_0_bias" [id=201, type=get_attr]; +"202 features_5_13_mlp_3_bias" [id=202, type=get_attr]; +"203 features_5_13_norm2_weight" [id=203, type=get_attr]; +"204 features_5_13_norm2_bias" [id=204, type=get_attr]; +"205 features_5_14_attn_cpb_mlp_0_bias" [id=205, type=get_attr]; +"206 features_5_14_norm1_weight" [id=206, type=get_attr]; +"207 features_5_14_norm1_bias" [id=207, type=get_attr]; +"208 features_5_14_mlp_0_bias" [id=208, type=get_attr]; +"209 features_5_14_mlp_3_bias" [id=209, type=get_attr]; +"210 features_5_14_norm2_weight" [id=210, type=get_attr]; +"211 features_5_14_norm2_bias" [id=211, type=get_attr]; +"212 features_5_15_attn_cpb_mlp_0_bias" [id=212, type=get_attr]; +"213 features_5_15_norm1_weight" [id=213, type=get_attr]; +"214 features_5_15_norm1_bias" [id=214, type=get_attr]; +"215 features_5_15_mlp_0_bias" [id=215, type=get_attr]; +"216 features_5_15_mlp_3_bias" [id=216, type=get_attr]; +"217 features_5_15_norm2_weight" [id=217, type=get_attr]; +"218 features_5_15_norm2_bias" [id=218, type=get_attr]; +"219 features_5_16_attn_cpb_mlp_0_bias" [id=219, type=get_attr]; +"220 features_5_16_norm1_weight" [id=220, type=get_attr]; +"221 features_5_16_norm1_bias" [id=221, type=get_attr]; +"222 features_5_16_mlp_0_bias" [id=222, type=get_attr]; +"223 features_5_16_mlp_3_bias" [id=223, type=get_attr]; +"224 features_5_16_norm2_weight" [id=224, type=get_attr]; +"225 features_5_16_norm2_bias" [id=225, type=get_attr]; +"226 features_5_17_attn_cpb_mlp_0_bias" [id=226, type=get_attr]; +"227 features_5_17_norm1_weight" [id=227, type=get_attr]; +"228 features_5_17_norm1_bias" [id=228, type=get_attr]; +"229 features_5_17_mlp_0_bias" [id=229, type=get_attr]; +"230 features_5_17_mlp_3_bias" [id=230, type=get_attr]; +"231 features_5_17_norm2_weight" [id=231, type=get_attr]; +"232 features_5_17_norm2_bias" [id=232, type=get_attr]; +"233 features_6_norm_weight" [id=233, type=get_attr]; +"234 features_6_norm_bias" [id=234, type=get_attr]; +"235 features_7_0_attn_cpb_mlp_0_bias" [id=235, type=get_attr]; +"236 features_7_0_norm1_weight" [id=236, type=get_attr]; +"237 features_7_0_norm1_bias" [id=237, type=get_attr]; +"238 features_7_0_mlp_0_bias" [id=238, type=get_attr]; +"239 features_7_0_mlp_3_bias" [id=239, type=get_attr]; +"240 features_7_0_norm2_weight" [id=240, type=get_attr]; +"241 features_7_0_norm2_bias" [id=241, type=get_attr]; +"242 features_7_1_attn_cpb_mlp_0_bias" [id=242, type=get_attr]; +"243 features_7_1_norm1_weight" [id=243, type=get_attr]; +"244 features_7_1_norm1_bias" [id=244, type=get_attr]; +"245 features_7_1_mlp_0_bias" [id=245, type=get_attr]; +"246 features_7_1_mlp_3_bias" [id=246, type=get_attr]; +"247 features_7_1_norm2_weight" [id=247, type=get_attr]; +"248 features_7_1_norm2_bias" [id=248, type=get_attr]; +"249 norm_weight" [id=249, type=get_attr]; +"250 norm_bias" [id=250, type=get_attr]; +"251 head_bias" [id=251, type=get_attr]; +"252 features_1_0_attn_relative_coords_table" [id=252, type=get_attr]; +"253 features_1_0_attn_relative_position_index" [id=253, type=get_attr]; +"254 features_1_1_attn_relative_coords_table" [id=254, type=get_attr]; +"255 features_1_1_attn_relative_position_index" [id=255, type=get_attr]; +"256 features_3_0_attn_relative_coords_table" [id=256, type=get_attr]; +"257 features_3_0_attn_relative_position_index" [id=257, type=get_attr]; +"258 features_3_1_attn_relative_coords_table" [id=258, type=get_attr]; +"259 features_3_1_attn_relative_position_index" [id=259, type=get_attr]; +"260 features_5_0_attn_relative_coords_table" [id=260, type=get_attr]; +"261 features_5_0_attn_relative_position_index" [id=261, type=get_attr]; +"262 features_5_1_attn_relative_coords_table" [id=262, type=get_attr]; +"263 features_5_1_attn_relative_position_index" [id=263, type=get_attr]; +"264 features_5_2_attn_relative_coords_table" [id=264, type=get_attr]; +"265 features_5_2_attn_relative_position_index" [id=265, type=get_attr]; +"266 features_5_3_attn_relative_coords_table" [id=266, type=get_attr]; +"267 features_5_3_attn_relative_position_index" [id=267, type=get_attr]; +"268 features_5_4_attn_relative_coords_table" [id=268, type=get_attr]; +"269 features_5_4_attn_relative_position_index" [id=269, type=get_attr]; +"270 features_5_5_attn_relative_coords_table" [id=270, type=get_attr]; +"271 features_5_5_attn_relative_position_index" [id=271, type=get_attr]; +"272 features_5_6_attn_relative_coords_table" [id=272, type=get_attr]; +"273 features_5_6_attn_relative_position_index" [id=273, type=get_attr]; +"274 features_5_7_attn_relative_coords_table" [id=274, type=get_attr]; +"275 features_5_7_attn_relative_position_index" [id=275, type=get_attr]; +"276 features_5_8_attn_relative_coords_table" [id=276, type=get_attr]; +"277 features_5_8_attn_relative_position_index" [id=277, type=get_attr]; +"278 features_5_9_attn_relative_coords_table" [id=278, type=get_attr]; +"279 features_5_9_attn_relative_position_index" [id=279, type=get_attr]; +"280 features_5_10_attn_relative_coords_table" [id=280, type=get_attr]; +"281 features_5_10_attn_relative_position_index" [id=281, type=get_attr]; +"282 features_5_11_attn_relative_coords_table" [id=282, type=get_attr]; +"283 features_5_11_attn_relative_position_index" [id=283, type=get_attr]; +"284 features_5_12_attn_relative_coords_table" [id=284, type=get_attr]; +"285 features_5_12_attn_relative_position_index" [id=285, type=get_attr]; +"286 features_5_13_attn_relative_coords_table" [id=286, type=get_attr]; +"287 features_5_13_attn_relative_position_index" [id=287, type=get_attr]; +"288 features_5_14_attn_relative_coords_table" [id=288, type=get_attr]; +"289 features_5_14_attn_relative_position_index" [id=289, type=get_attr]; +"290 features_5_15_attn_relative_coords_table" [id=290, type=get_attr]; +"291 features_5_15_attn_relative_position_index" [id=291, type=get_attr]; +"292 features_5_16_attn_relative_coords_table" [id=292, type=get_attr]; +"293 features_5_16_attn_relative_position_index" [id=293, type=get_attr]; +"294 features_5_17_attn_relative_coords_table" [id=294, type=get_attr]; +"295 features_5_17_attn_relative_position_index" [id=295, type=get_attr]; +"296 features_7_0_attn_relative_coords_table" [id=296, type=get_attr]; +"297 features_7_0_attn_relative_position_index" [id=297, type=get_attr]; +"298 features_7_1_attn_relative_coords_table" [id=298, type=get_attr]; +"299 features_7_1_attn_relative_position_index" [id=299, type=get_attr]; +"300 x" [id=300, type=input]; +"301 quantize_per_tensor_default" [id=301, type=quantize_per_tensor]; +"302 dequantize_per_tensor_default" [id=302, type=dequantize_per_tensor]; +"303 conv2d_scale_0" [id=303, type=get_attr]; +"304 conv2d_zero_point_0" [id=304, type=get_attr]; +"305 _frozen_param0" [id=305, type=get_attr]; +"306 dequantize_per_channel_default" [id=306, type=dequantize_per_channel]; +"307 conv2d" [id=307, type=conv2d]; +"308 permute" [id=308, type=permute]; +"309 layer_norm" [id=309, type=layer_norm]; +"310 features_1_0_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [id=310, type=call_module]; +"311 linear_scale_0" [id=311, type=get_attr]; +"312 linear_zero_point_0" [id=312, type=get_attr]; +"313 _frozen_param1" [id=313, type=get_attr]; +"314 dequantize_per_channel_default_1" [id=314, type=dequantize_per_channel]; +"315 linear" [id=315, type=linear]; +"316 relu_" [id=316, type=relu_]; +"317 relu__0_0_nncf_smooth_quant_0" [id=317, type=call_module]; +"318 linear_1_scale_0" [id=318, type=get_attr]; +"319 linear_1_zero_point_0" [id=319, type=get_attr]; +"320 _frozen_param2" [id=320, type=get_attr]; +"321 dequantize_per_channel_default_2" [id=321, type=dequantize_per_channel]; +"322 linear_1" [id=322, type=linear]; +"323 view" [id=323, type=view]; +"324 index" [id=324, type=index]; +"325 view_1" [id=325, type=view]; +"326 permute_1" [id=326, type=permute]; +"327 contiguous" [id=327, type=contiguous]; +"328 unsqueeze" [id=328, type=unsqueeze]; +"329 sigmoid" [id=329, type=sigmoid]; +"330 mul" [id=330, type=mul]; +"331 pad" [id=331, type=pad]; +"332 view_2" [id=332, type=view]; +"333 permute_2" [id=333, type=permute]; +"334 reshape" [id=334, type=reshape]; +"335 clone" [id=335, type=clone]; +"336 reshape_0_0_nncf_smooth_quant_0" [id=336, type=call_module]; +"337 quantize_per_tensor_default_1" [id=337, type=quantize_per_tensor]; +"338 dequantize_per_tensor_default_1" [id=338, type=dequantize_per_tensor]; +"339 linear_2_scale_0" [id=339, type=get_attr]; +"340 linear_2_zero_point_0" [id=340, type=get_attr]; +"341 _frozen_param3" [id=341, type=get_attr]; +"342 dequantize_per_channel_default_3" [id=342, type=dequantize_per_channel]; +"343 linear_2" [id=343, type=linear]; +"344 reshape_1" [id=344, type=reshape]; +"345 permute_3" [id=345, type=permute]; +"346 select" [id=346, type=select]; +"347 select_1" [id=347, type=select]; +"348 select_2" [id=348, type=select]; +"349 linalg_vector_norm" [id=349, type=linalg_vector_norm]; +"350 clamp_min" [id=350, type=clamp_min]; +"351 expand_as" [id=351, type=expand_as]; +"352 div" [id=352, type=div]; +"353 quantize_per_tensor_default_2" [id=353, type=quantize_per_tensor]; +"354 dequantize_per_tensor_default_2" [id=354, type=dequantize_per_tensor]; +"355 linalg_vector_norm_1" [id=355, type=linalg_vector_norm]; +"356 clamp_min_1" [id=356, type=clamp_min]; +"357 expand_as_1" [id=357, type=expand_as]; +"358 div_1" [id=358, type=div]; +"359 quantize_per_tensor_default_3" [id=359, type=quantize_per_tensor]; +"360 dequantize_per_tensor_default_3" [id=360, type=dequantize_per_tensor]; +"361 transpose" [id=361, type=transpose]; +"362 matmul" [id=362, type=matmul]; +"363 clamp" [id=363, type=clamp]; +"364 exp" [id=364, type=exp]; +"365 mul_1" [id=365, type=mul]; +"366 add" [id=366, type=add]; +"367 softmax" [id=367, type=softmax]; +"368 dropout" [id=368, type=dropout]; +"369 matmul_1" [id=369, type=matmul]; +"370 transpose_1" [id=370, type=transpose]; +"371 reshape_2" [id=371, type=reshape]; +"372 reshape_2_0_0_nncf_smooth_quant_0" [id=372, type=call_module]; +"373 quantize_per_tensor_default_4" [id=373, type=quantize_per_tensor]; +"374 dequantize_per_tensor_default_4" [id=374, type=dequantize_per_tensor]; +"375 linear_3_scale_0" [id=375, type=get_attr]; +"376 linear_3_zero_point_0" [id=376, type=get_attr]; +"377 _frozen_param4" [id=377, type=get_attr]; +"378 dequantize_per_channel_default_4" [id=378, type=dequantize_per_channel]; +"379 linear_3" [id=379, type=linear]; +"380 dropout_1" [id=380, type=dropout]; +"381 view_3" [id=381, type=view]; +"382 permute_4" [id=382, type=permute]; +"383 reshape_3" [id=383, type=reshape]; +"384 slice_2" [id=384, type=slice]; +"385 slice_3" [id=385, type=slice]; +"386 layer_norm_1" [id=386, type=layer_norm]; +"387 add_1" [id=387, type=add]; +"388 add_1_0_0_nncf_smooth_quant_0" [id=388, type=call_module]; +"389 quantize_per_tensor_default_5" [id=389, type=quantize_per_tensor]; +"390 dequantize_per_tensor_default_5" [id=390, type=dequantize_per_tensor]; +"391 linear_4_scale_0" [id=391, type=get_attr]; +"392 linear_4_zero_point_0" [id=392, type=get_attr]; +"393 _frozen_param5" [id=393, type=get_attr]; +"394 dequantize_per_channel_default_5" [id=394, type=dequantize_per_channel]; +"395 linear_4" [id=395, type=linear]; +"396 gelu" [id=396, type=gelu]; +"397 dropout_2" [id=397, type=dropout]; +"398 dropout_2_0_0_nncf_smooth_quant_0" [id=398, type=call_module]; +"399 quantize_per_tensor_default_6" [id=399, type=quantize_per_tensor]; +"400 dequantize_per_tensor_default_6" [id=400, type=dequantize_per_tensor]; +"401 linear_5_scale_0" [id=401, type=get_attr]; +"402 linear_5_zero_point_0" [id=402, type=get_attr]; +"403 _frozen_param6" [id=403, type=get_attr]; +"404 dequantize_per_channel_default_6" [id=404, type=dequantize_per_channel]; +"405 linear_5" [id=405, type=linear]; +"406 dropout_3" [id=406, type=dropout]; +"407 layer_norm_2" [id=407, type=layer_norm]; +"408 add_2" [id=408, type=add]; +"409 features_1_1_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [id=409, type=call_module]; +"410 linear_6_scale_0" [id=410, type=get_attr]; +"411 linear_6_zero_point_0" [id=411, type=get_attr]; +"412 _frozen_param7" [id=412, type=get_attr]; +"413 dequantize_per_channel_default_7" [id=413, type=dequantize_per_channel]; +"414 linear_6" [id=414, type=linear]; +"415 relu__1" [id=415, type=relu_]; +"416 relu__1_0_0_nncf_smooth_quant_0" [id=416, type=call_module]; +"417 linear_7_scale_0" [id=417, type=get_attr]; +"418 linear_7_zero_point_0" [id=418, type=get_attr]; +"419 _frozen_param8" [id=419, type=get_attr]; +"420 dequantize_per_channel_default_8" [id=420, type=dequantize_per_channel]; +"421 linear_7" [id=421, type=linear]; +"422 view_4" [id=422, type=view]; +"423 index_1" [id=423, type=index]; +"424 view_5" [id=424, type=view]; +"425 permute_5" [id=425, type=permute]; +"426 contiguous_1" [id=426, type=contiguous]; +"427 unsqueeze_1" [id=427, type=unsqueeze]; +"428 sigmoid_1" [id=428, type=sigmoid]; +"429 mul_2" [id=429, type=mul]; +"430 pad_1" [id=430, type=pad]; +"431 roll" [id=431, type=roll]; +"432 view_6" [id=432, type=view]; +"433 permute_6" [id=433, type=permute]; +"434 reshape_4" [id=434, type=reshape]; +"435 clone_1" [id=435, type=clone]; +"436 reshape_4_0_0_nncf_smooth_quant_0" [id=436, type=call_module]; +"437 quantize_per_tensor_default_7" [id=437, type=quantize_per_tensor]; +"438 dequantize_per_tensor_default_7" [id=438, type=dequantize_per_tensor]; +"439 linear_8_scale_0" [id=439, type=get_attr]; +"440 linear_8_zero_point_0" [id=440, type=get_attr]; +"441 _frozen_param9" [id=441, type=get_attr]; +"442 dequantize_per_channel_default_9" [id=442, type=dequantize_per_channel]; +"443 linear_8" [id=443, type=linear]; +"444 reshape_5" [id=444, type=reshape]; +"445 permute_7" [id=445, type=permute]; +"446 select_3" [id=446, type=select]; +"447 select_4" [id=447, type=select]; +"448 select_5" [id=448, type=select]; +"449 linalg_vector_norm_2" [id=449, type=linalg_vector_norm]; +"450 clamp_min_2" [id=450, type=clamp_min]; +"451 expand_as_2" [id=451, type=expand_as]; +"452 div_2" [id=452, type=div]; +"453 quantize_per_tensor_default_8" [id=453, type=quantize_per_tensor]; +"454 dequantize_per_tensor_default_8" [id=454, type=dequantize_per_tensor]; +"455 linalg_vector_norm_3" [id=455, type=linalg_vector_norm]; +"456 clamp_min_3" [id=456, type=clamp_min]; +"457 expand_as_3" [id=457, type=expand_as]; +"458 div_3" [id=458, type=div]; +"459 quantize_per_tensor_default_9" [id=459, type=quantize_per_tensor]; +"460 dequantize_per_tensor_default_9" [id=460, type=dequantize_per_tensor]; +"461 transpose_2" [id=461, type=transpose]; +"462 matmul_2" [id=462, type=matmul]; +"463 clamp_1" [id=463, type=clamp]; +"464 exp_1" [id=464, type=exp]; +"465 mul_3" [id=465, type=mul]; +"466 add_3" [id=466, type=add]; +"467 new_zeros" [id=467, type=new_zeros]; +"468 view_7" [id=468, type=view]; +"469 permute_8" [id=469, type=permute]; +"470 reshape_6" [id=470, type=reshape]; +"471 unsqueeze_2" [id=471, type=unsqueeze]; +"472 unsqueeze_3" [id=472, type=unsqueeze]; +"473 sub" [id=473, type=sub]; +"474 ne" [id=474, type=ne]; +"475 masked_fill" [id=475, type=masked_fill]; +"476 eq" [id=476, type=eq]; +"477 masked_fill_1" [id=477, type=masked_fill]; +"478 view_8" [id=478, type=view]; +"479 unsqueeze_4" [id=479, type=unsqueeze]; +"480 unsqueeze_5" [id=480, type=unsqueeze]; +"481 add_4" [id=481, type=add]; +"482 view_9" [id=482, type=view]; +"483 softmax_1" [id=483, type=softmax]; +"484 dropout_4" [id=484, type=dropout]; +"485 matmul_3" [id=485, type=matmul]; +"486 transpose_3" [id=486, type=transpose]; +"487 reshape_7" [id=487, type=reshape]; +"488 reshape_7_0_0_nncf_smooth_quant_0" [id=488, type=call_module]; +"489 quantize_per_tensor_default_10" [id=489, type=quantize_per_tensor]; +"490 dequantize_per_tensor_default_10" [id=490, type=dequantize_per_tensor]; +"491 linear_9_scale_0" [id=491, type=get_attr]; +"492 linear_9_zero_point_0" [id=492, type=get_attr]; +"493 _frozen_param10" [id=493, type=get_attr]; +"494 dequantize_per_channel_default_10" [id=494, type=dequantize_per_channel]; +"495 linear_9" [id=495, type=linear]; +"496 dropout_5" [id=496, type=dropout]; +"497 view_10" [id=497, type=view]; +"498 permute_9" [id=498, type=permute]; +"499 reshape_8" [id=499, type=reshape]; +"500 roll_1" [id=500, type=roll]; +"501 slice_23" [id=501, type=slice]; +"502 slice_24" [id=502, type=slice]; +"503 layer_norm_3" [id=503, type=layer_norm]; +"504 add_5" [id=504, type=add]; +"505 add_5_0_0_nncf_smooth_quant_0" [id=505, type=call_module]; +"506 quantize_per_tensor_default_11" [id=506, type=quantize_per_tensor]; +"507 dequantize_per_tensor_default_11" [id=507, type=dequantize_per_tensor]; +"508 linear_10_scale_0" [id=508, type=get_attr]; +"509 linear_10_zero_point_0" [id=509, type=get_attr]; +"510 _frozen_param11" [id=510, type=get_attr]; +"511 dequantize_per_channel_default_11" [id=511, type=dequantize_per_channel]; +"512 linear_10" [id=512, type=linear]; +"513 gelu_1" [id=513, type=gelu]; +"514 dropout_6" [id=514, type=dropout]; +"515 dropout_6_0_0_nncf_smooth_quant_0" [id=515, type=call_module]; +"516 quantize_per_tensor_default_12" [id=516, type=quantize_per_tensor]; +"517 dequantize_per_tensor_default_12" [id=517, type=dequantize_per_tensor]; +"518 linear_11_scale_0" [id=518, type=get_attr]; +"519 linear_11_zero_point_0" [id=519, type=get_attr]; +"520 _frozen_param12" [id=520, type=get_attr]; +"521 dequantize_per_channel_default_12" [id=521, type=dequantize_per_channel]; +"522 linear_11" [id=522, type=linear]; +"523 dropout_7" [id=523, type=dropout]; +"524 layer_norm_4" [id=524, type=layer_norm]; +"525 add_6" [id=525, type=add]; +"526 pad_2" [id=526, type=pad]; +"527 slice_25" [id=527, type=slice]; +"528 slice_26" [id=528, type=slice]; +"529 slice_27" [id=529, type=slice]; +"530 slice_28" [id=530, type=slice]; +"531 slice_29" [id=531, type=slice]; +"532 slice_30" [id=532, type=slice]; +"533 slice_31" [id=533, type=slice]; +"534 slice_32" [id=534, type=slice]; +"535 slice_33" [id=535, type=slice]; +"536 slice_34" [id=536, type=slice]; +"537 slice_35" [id=537, type=slice]; +"538 slice_36" [id=538, type=slice]; +"539 cat" [id=539, type=cat]; +"540 cat_0_0_nncf_smooth_quant_0" [id=540, type=call_module]; +"541 quantize_per_tensor_default_13" [id=541, type=quantize_per_tensor]; +"542 dequantize_per_tensor_default_13" [id=542, type=dequantize_per_tensor]; +"543 linear_12_scale_0" [id=543, type=get_attr]; +"544 linear_12_zero_point_0" [id=544, type=get_attr]; +"545 _frozen_param13" [id=545, type=get_attr]; +"546 dequantize_per_channel_default_13" [id=546, type=dequantize_per_channel]; +"547 linear_12" [id=547, type=linear]; +"548 layer_norm_5" [id=548, type=layer_norm]; +"549 features_3_0_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [id=549, type=call_module]; +"550 linear_13_scale_0" [id=550, type=get_attr]; +"551 linear_13_zero_point_0" [id=551, type=get_attr]; +"552 _frozen_param14" [id=552, type=get_attr]; +"553 dequantize_per_channel_default_14" [id=553, type=dequantize_per_channel]; +"554 linear_13" [id=554, type=linear]; +"555 relu__2" [id=555, type=relu_]; +"556 relu__2_0_0_nncf_smooth_quant_0" [id=556, type=call_module]; +"557 linear_14_scale_0" [id=557, type=get_attr]; +"558 linear_14_zero_point_0" [id=558, type=get_attr]; +"559 _frozen_param15" [id=559, type=get_attr]; +"560 dequantize_per_channel_default_15" [id=560, type=dequantize_per_channel]; +"561 linear_14" [id=561, type=linear]; +"562 view_11" [id=562, type=view]; +"563 index_2" [id=563, type=index]; +"564 view_12" [id=564, type=view]; +"565 permute_10" [id=565, type=permute]; +"566 contiguous_2" [id=566, type=contiguous]; +"567 unsqueeze_6" [id=567, type=unsqueeze]; +"568 sigmoid_2" [id=568, type=sigmoid]; +"569 mul_4" [id=569, type=mul]; +"570 pad_3" [id=570, type=pad]; +"571 view_13" [id=571, type=view]; +"572 permute_11" [id=572, type=permute]; +"573 reshape_9" [id=573, type=reshape]; +"574 clone_2" [id=574, type=clone]; +"575 reshape_9_0_0_nncf_smooth_quant_0" [id=575, type=call_module]; +"576 quantize_per_tensor_default_14" [id=576, type=quantize_per_tensor]; +"577 dequantize_per_tensor_default_14" [id=577, type=dequantize_per_tensor]; +"578 linear_15_scale_0" [id=578, type=get_attr]; +"579 linear_15_zero_point_0" [id=579, type=get_attr]; +"580 _frozen_param16" [id=580, type=get_attr]; +"581 dequantize_per_channel_default_16" [id=581, type=dequantize_per_channel]; +"582 linear_15" [id=582, type=linear]; +"583 reshape_10" [id=583, type=reshape]; +"584 permute_12" [id=584, type=permute]; +"585 select_6" [id=585, type=select]; +"586 select_7" [id=586, type=select]; +"587 select_8" [id=587, type=select]; +"588 linalg_vector_norm_4" [id=588, type=linalg_vector_norm]; +"589 clamp_min_4" [id=589, type=clamp_min]; +"590 expand_as_4" [id=590, type=expand_as]; +"591 div_4" [id=591, type=div]; +"592 quantize_per_tensor_default_15" [id=592, type=quantize_per_tensor]; +"593 dequantize_per_tensor_default_15" [id=593, type=dequantize_per_tensor]; +"594 linalg_vector_norm_5" [id=594, type=linalg_vector_norm]; +"595 clamp_min_5" [id=595, type=clamp_min]; +"596 expand_as_5" [id=596, type=expand_as]; +"597 div_5" [id=597, type=div]; +"598 quantize_per_tensor_default_16" [id=598, type=quantize_per_tensor]; +"599 dequantize_per_tensor_default_16" [id=599, type=dequantize_per_tensor]; +"600 transpose_4" [id=600, type=transpose]; +"601 matmul_4" [id=601, type=matmul]; +"602 clamp_2" [id=602, type=clamp]; +"603 exp_2" [id=603, type=exp]; +"604 mul_5" [id=604, type=mul]; +"605 add_7" [id=605, type=add]; +"606 softmax_2" [id=606, type=softmax]; +"607 dropout_8" [id=607, type=dropout]; +"608 matmul_5" [id=608, type=matmul]; +"609 transpose_5" [id=609, type=transpose]; +"610 reshape_11" [id=610, type=reshape]; +"611 reshape_11_0_0_nncf_smooth_quant_0" [id=611, type=call_module]; +"612 quantize_per_tensor_default_17" [id=612, type=quantize_per_tensor]; +"613 dequantize_per_tensor_default_17" [id=613, type=dequantize_per_tensor]; +"614 linear_16_scale_0" [id=614, type=get_attr]; +"615 linear_16_zero_point_0" [id=615, type=get_attr]; +"616 _frozen_param17" [id=616, type=get_attr]; +"617 dequantize_per_channel_default_17" [id=617, type=dequantize_per_channel]; +"618 linear_16" [id=618, type=linear]; +"619 dropout_9" [id=619, type=dropout]; +"620 view_14" [id=620, type=view]; +"621 permute_13" [id=621, type=permute]; +"622 reshape_12" [id=622, type=reshape]; +"623 slice_38" [id=623, type=slice]; +"624 slice_39" [id=624, type=slice]; +"625 slice_40" [id=625, type=slice]; +"626 slice_41" [id=626, type=slice]; +"627 contiguous_3" [id=627, type=contiguous]; +"628 layer_norm_6" [id=628, type=layer_norm]; +"629 add_8" [id=629, type=add]; +"630 add_8_0_0_nncf_smooth_quant_0" [id=630, type=call_module]; +"631 quantize_per_tensor_default_18" [id=631, type=quantize_per_tensor]; +"632 dequantize_per_tensor_default_18" [id=632, type=dequantize_per_tensor]; +"633 linear_17_scale_0" [id=633, type=get_attr]; +"634 linear_17_zero_point_0" [id=634, type=get_attr]; +"635 _frozen_param18" [id=635, type=get_attr]; +"636 dequantize_per_channel_default_18" [id=636, type=dequantize_per_channel]; +"637 linear_17" [id=637, type=linear]; +"638 gelu_2" [id=638, type=gelu]; +"639 dropout_10" [id=639, type=dropout]; +"640 dropout_10_0_0_nncf_smooth_quant_0" [id=640, type=call_module]; +"641 quantize_per_tensor_default_19" [id=641, type=quantize_per_tensor]; +"642 dequantize_per_tensor_default_19" [id=642, type=dequantize_per_tensor]; +"643 linear_18_scale_0" [id=643, type=get_attr]; +"644 linear_18_zero_point_0" [id=644, type=get_attr]; +"645 _frozen_param19" [id=645, type=get_attr]; +"646 dequantize_per_channel_default_19" [id=646, type=dequantize_per_channel]; +"647 linear_18" [id=647, type=linear]; +"648 dropout_11" [id=648, type=dropout]; +"649 layer_norm_7" [id=649, type=layer_norm]; +"650 add_9" [id=650, type=add]; +"651 features_3_1_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [id=651, type=call_module]; +"652 linear_19_scale_0" [id=652, type=get_attr]; +"653 linear_19_zero_point_0" [id=653, type=get_attr]; +"654 _frozen_param20" [id=654, type=get_attr]; +"655 dequantize_per_channel_default_20" [id=655, type=dequantize_per_channel]; +"656 linear_19" [id=656, type=linear]; +"657 relu__3" [id=657, type=relu_]; +"658 relu__3_0_0_nncf_smooth_quant_0" [id=658, type=call_module]; +"659 linear_20_scale_0" [id=659, type=get_attr]; +"660 linear_20_zero_point_0" [id=660, type=get_attr]; +"661 _frozen_param21" [id=661, type=get_attr]; +"662 dequantize_per_channel_default_21" [id=662, type=dequantize_per_channel]; +"663 linear_20" [id=663, type=linear]; +"664 view_15" [id=664, type=view]; +"665 index_3" [id=665, type=index]; +"666 view_16" [id=666, type=view]; +"667 permute_14" [id=667, type=permute]; +"668 contiguous_4" [id=668, type=contiguous]; +"669 unsqueeze_7" [id=669, type=unsqueeze]; +"670 sigmoid_3" [id=670, type=sigmoid]; +"671 mul_6" [id=671, type=mul]; +"672 pad_4" [id=672, type=pad]; +"673 roll_2" [id=673, type=roll]; +"674 view_17" [id=674, type=view]; +"675 permute_15" [id=675, type=permute]; +"676 reshape_13" [id=676, type=reshape]; +"677 clone_3" [id=677, type=clone]; +"678 reshape_13_0_0_nncf_smooth_quant_0" [id=678, type=call_module]; +"679 quantize_per_tensor_default_20" [id=679, type=quantize_per_tensor]; +"680 dequantize_per_tensor_default_20" [id=680, type=dequantize_per_tensor]; +"681 linear_21_scale_0" [id=681, type=get_attr]; +"682 linear_21_zero_point_0" [id=682, type=get_attr]; +"683 _frozen_param22" [id=683, type=get_attr]; +"684 dequantize_per_channel_default_22" [id=684, type=dequantize_per_channel]; +"685 linear_21" [id=685, type=linear]; +"686 reshape_14" [id=686, type=reshape]; +"687 permute_16" [id=687, type=permute]; +"688 select_9" [id=688, type=select]; +"689 select_10" [id=689, type=select]; +"690 select_11" [id=690, type=select]; +"691 linalg_vector_norm_6" [id=691, type=linalg_vector_norm]; +"692 clamp_min_6" [id=692, type=clamp_min]; +"693 expand_as_6" [id=693, type=expand_as]; +"694 div_6" [id=694, type=div]; +"695 quantize_per_tensor_default_21" [id=695, type=quantize_per_tensor]; +"696 dequantize_per_tensor_default_21" [id=696, type=dequantize_per_tensor]; +"697 linalg_vector_norm_7" [id=697, type=linalg_vector_norm]; +"698 clamp_min_7" [id=698, type=clamp_min]; +"699 expand_as_7" [id=699, type=expand_as]; +"700 div_7" [id=700, type=div]; +"701 quantize_per_tensor_default_22" [id=701, type=quantize_per_tensor]; +"702 dequantize_per_tensor_default_22" [id=702, type=dequantize_per_tensor]; +"703 transpose_6" [id=703, type=transpose]; +"704 matmul_6" [id=704, type=matmul]; +"705 clamp_3" [id=705, type=clamp]; +"706 exp_3" [id=706, type=exp]; +"707 mul_7" [id=707, type=mul]; +"708 add_10" [id=708, type=add]; +"709 new_zeros_1" [id=709, type=new_zeros]; +"710 view_18" [id=710, type=view]; +"711 permute_17" [id=711, type=permute]; +"712 reshape_15" [id=712, type=reshape]; +"713 unsqueeze_8" [id=713, type=unsqueeze]; +"714 unsqueeze_9" [id=714, type=unsqueeze]; +"715 sub_1" [id=715, type=sub]; +"716 ne_1" [id=716, type=ne]; +"717 masked_fill_2" [id=717, type=masked_fill]; +"718 eq_1" [id=718, type=eq]; +"719 masked_fill_3" [id=719, type=masked_fill]; +"720 view_19" [id=720, type=view]; +"721 unsqueeze_10" [id=721, type=unsqueeze]; +"722 unsqueeze_11" [id=722, type=unsqueeze]; +"723 add_11" [id=723, type=add]; +"724 view_20" [id=724, type=view]; +"725 softmax_3" [id=725, type=softmax]; +"726 dropout_12" [id=726, type=dropout]; +"727 matmul_7" [id=727, type=matmul]; +"728 transpose_7" [id=728, type=transpose]; +"729 reshape_16" [id=729, type=reshape]; +"730 reshape_16_0_0_nncf_smooth_quant_0" [id=730, type=call_module]; +"731 quantize_per_tensor_default_23" [id=731, type=quantize_per_tensor]; +"732 dequantize_per_tensor_default_23" [id=732, type=dequantize_per_tensor]; +"733 linear_22_scale_0" [id=733, type=get_attr]; +"734 linear_22_zero_point_0" [id=734, type=get_attr]; +"735 _frozen_param23" [id=735, type=get_attr]; +"736 dequantize_per_channel_default_23" [id=736, type=dequantize_per_channel]; +"737 linear_22" [id=737, type=linear]; +"738 dropout_13" [id=738, type=dropout]; +"739 view_21" [id=739, type=view]; +"740 permute_18" [id=740, type=permute]; +"741 reshape_17" [id=741, type=reshape]; +"742 roll_3" [id=742, type=roll]; +"743 slice_61" [id=743, type=slice]; +"744 slice_62" [id=744, type=slice]; +"745 slice_63" [id=745, type=slice]; +"746 slice_64" [id=746, type=slice]; +"747 contiguous_5" [id=747, type=contiguous]; +"748 layer_norm_8" [id=748, type=layer_norm]; +"749 add_12" [id=749, type=add]; +"750 add_12_0_0_nncf_smooth_quant_0" [id=750, type=call_module]; +"751 quantize_per_tensor_default_24" [id=751, type=quantize_per_tensor]; +"752 dequantize_per_tensor_default_24" [id=752, type=dequantize_per_tensor]; +"753 linear_23_scale_0" [id=753, type=get_attr]; +"754 linear_23_zero_point_0" [id=754, type=get_attr]; +"755 _frozen_param24" [id=755, type=get_attr]; +"756 dequantize_per_channel_default_24" [id=756, type=dequantize_per_channel]; +"757 linear_23" [id=757, type=linear]; +"758 gelu_3" [id=758, type=gelu]; +"759 dropout_14" [id=759, type=dropout]; +"760 dropout_14_0_0_nncf_smooth_quant_0" [id=760, type=call_module]; +"761 quantize_per_tensor_default_25" [id=761, type=quantize_per_tensor]; +"762 dequantize_per_tensor_default_25" [id=762, type=dequantize_per_tensor]; +"763 linear_24_scale_0" [id=763, type=get_attr]; +"764 linear_24_zero_point_0" [id=764, type=get_attr]; +"765 _frozen_param25" [id=765, type=get_attr]; +"766 dequantize_per_channel_default_25" [id=766, type=dequantize_per_channel]; +"767 linear_24" [id=767, type=linear]; +"768 dropout_15" [id=768, type=dropout]; +"769 layer_norm_9" [id=769, type=layer_norm]; +"770 add_13" [id=770, type=add]; +"771 pad_5" [id=771, type=pad]; +"772 slice_65" [id=772, type=slice]; +"773 slice_66" [id=773, type=slice]; +"774 slice_67" [id=774, type=slice]; +"775 slice_68" [id=775, type=slice]; +"776 slice_69" [id=776, type=slice]; +"777 slice_70" [id=777, type=slice]; +"778 slice_71" [id=778, type=slice]; +"779 slice_72" [id=779, type=slice]; +"780 slice_73" [id=780, type=slice]; +"781 slice_74" [id=781, type=slice]; +"782 slice_75" [id=782, type=slice]; +"783 slice_76" [id=783, type=slice]; +"784 cat_1" [id=784, type=cat]; +"785 cat_1_0_0_nncf_smooth_quant_0" [id=785, type=call_module]; +"786 quantize_per_tensor_default_26" [id=786, type=quantize_per_tensor]; +"787 dequantize_per_tensor_default_26" [id=787, type=dequantize_per_tensor]; +"788 linear_25_scale_0" [id=788, type=get_attr]; +"789 linear_25_zero_point_0" [id=789, type=get_attr]; +"790 _frozen_param26" [id=790, type=get_attr]; +"791 dequantize_per_channel_default_26" [id=791, type=dequantize_per_channel]; +"792 linear_25" [id=792, type=linear]; +"793 layer_norm_10" [id=793, type=layer_norm]; +"794 features_5_0_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [id=794, type=call_module]; +"795 linear_26_scale_0" [id=795, type=get_attr]; +"796 linear_26_zero_point_0" [id=796, type=get_attr]; +"797 _frozen_param27" [id=797, type=get_attr]; +"798 dequantize_per_channel_default_27" [id=798, type=dequantize_per_channel]; +"799 linear_26" [id=799, type=linear]; +"800 relu__4" [id=800, type=relu_]; +"801 relu__4_0_0_nncf_smooth_quant_0" [id=801, type=call_module]; +"802 linear_27_scale_0" [id=802, type=get_attr]; +"803 linear_27_zero_point_0" [id=803, type=get_attr]; +"804 _frozen_param28" [id=804, type=get_attr]; +"805 dequantize_per_channel_default_28" [id=805, type=dequantize_per_channel]; +"806 linear_27" [id=806, type=linear]; +"807 view_22" [id=807, type=view]; +"808 index_4" [id=808, type=index]; +"809 view_23" [id=809, type=view]; +"810 permute_19" [id=810, type=permute]; +"811 contiguous_6" [id=811, type=contiguous]; +"812 unsqueeze_12" [id=812, type=unsqueeze]; +"813 sigmoid_4" [id=813, type=sigmoid]; +"814 mul_8" [id=814, type=mul]; +"815 pad_6" [id=815, type=pad]; +"816 view_24" [id=816, type=view]; +"817 permute_20" [id=817, type=permute]; +"818 reshape_18" [id=818, type=reshape]; +"819 clone_4" [id=819, type=clone]; +"820 reshape_18_0_0_nncf_smooth_quant_0" [id=820, type=call_module]; +"821 quantize_per_tensor_default_27" [id=821, type=quantize_per_tensor]; +"822 dequantize_per_tensor_default_27" [id=822, type=dequantize_per_tensor]; +"823 linear_28_scale_0" [id=823, type=get_attr]; +"824 linear_28_zero_point_0" [id=824, type=get_attr]; +"825 _frozen_param29" [id=825, type=get_attr]; +"826 dequantize_per_channel_default_29" [id=826, type=dequantize_per_channel]; +"827 linear_28" [id=827, type=linear]; +"828 reshape_19" [id=828, type=reshape]; +"829 permute_21" [id=829, type=permute]; +"830 select_12" [id=830, type=select]; +"831 select_13" [id=831, type=select]; +"832 select_14" [id=832, type=select]; +"833 linalg_vector_norm_8" [id=833, type=linalg_vector_norm]; +"834 clamp_min_8" [id=834, type=clamp_min]; +"835 expand_as_8" [id=835, type=expand_as]; +"836 div_8" [id=836, type=div]; +"837 quantize_per_tensor_default_28" [id=837, type=quantize_per_tensor]; +"838 dequantize_per_tensor_default_28" [id=838, type=dequantize_per_tensor]; +"839 linalg_vector_norm_9" [id=839, type=linalg_vector_norm]; +"840 clamp_min_9" [id=840, type=clamp_min]; +"841 expand_as_9" [id=841, type=expand_as]; +"842 div_9" [id=842, type=div]; +"843 quantize_per_tensor_default_29" [id=843, type=quantize_per_tensor]; +"844 dequantize_per_tensor_default_29" [id=844, type=dequantize_per_tensor]; +"845 transpose_8" [id=845, type=transpose]; +"846 matmul_8" [id=846, type=matmul]; +"847 clamp_4" [id=847, type=clamp]; +"848 exp_4" [id=848, type=exp]; +"849 mul_9" [id=849, type=mul]; +"850 add_14" [id=850, type=add]; +"851 softmax_4" [id=851, type=softmax]; +"852 dropout_16" [id=852, type=dropout]; +"853 matmul_9" [id=853, type=matmul]; +"854 transpose_9" [id=854, type=transpose]; +"855 reshape_20" [id=855, type=reshape]; +"856 reshape_20_0_0_nncf_smooth_quant_0" [id=856, type=call_module]; +"857 quantize_per_tensor_default_30" [id=857, type=quantize_per_tensor]; +"858 dequantize_per_tensor_default_30" [id=858, type=dequantize_per_tensor]; +"859 linear_29_scale_0" [id=859, type=get_attr]; +"860 linear_29_zero_point_0" [id=860, type=get_attr]; +"861 _frozen_param30" [id=861, type=get_attr]; +"862 dequantize_per_channel_default_30" [id=862, type=dequantize_per_channel]; +"863 linear_29" [id=863, type=linear]; +"864 dropout_17" [id=864, type=dropout]; +"865 view_25" [id=865, type=view]; +"866 permute_22" [id=866, type=permute]; +"867 reshape_21" [id=867, type=reshape]; +"868 slice_78" [id=868, type=slice]; +"869 slice_79" [id=869, type=slice]; +"870 slice_80" [id=870, type=slice]; +"871 slice_81" [id=871, type=slice]; +"872 contiguous_7" [id=872, type=contiguous]; +"873 layer_norm_11" [id=873, type=layer_norm]; +"874 add_15" [id=874, type=add]; +"875 add_15_0_0_nncf_smooth_quant_0" [id=875, type=call_module]; +"876 quantize_per_tensor_default_31" [id=876, type=quantize_per_tensor]; +"877 dequantize_per_tensor_default_31" [id=877, type=dequantize_per_tensor]; +"878 linear_30_scale_0" [id=878, type=get_attr]; +"879 linear_30_zero_point_0" [id=879, type=get_attr]; +"880 _frozen_param31" [id=880, type=get_attr]; +"881 dequantize_per_channel_default_31" [id=881, type=dequantize_per_channel]; +"882 linear_30" [id=882, type=linear]; +"883 gelu_4" [id=883, type=gelu]; +"884 dropout_18" [id=884, type=dropout]; +"885 dropout_18_0_0_nncf_smooth_quant_0" [id=885, type=call_module]; +"886 quantize_per_tensor_default_32" [id=886, type=quantize_per_tensor]; +"887 dequantize_per_tensor_default_32" [id=887, type=dequantize_per_tensor]; +"888 linear_31_scale_0" [id=888, type=get_attr]; +"889 linear_31_zero_point_0" [id=889, type=get_attr]; +"890 _frozen_param32" [id=890, type=get_attr]; +"891 dequantize_per_channel_default_32" [id=891, type=dequantize_per_channel]; +"892 linear_31" [id=892, type=linear]; +"893 dropout_19" [id=893, type=dropout]; +"894 layer_norm_12" [id=894, type=layer_norm]; +"895 add_16" [id=895, type=add]; +"896 features_5_1_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [id=896, type=call_module]; +"897 linear_32_scale_0" [id=897, type=get_attr]; +"898 linear_32_zero_point_0" [id=898, type=get_attr]; +"899 _frozen_param33" [id=899, type=get_attr]; +"900 dequantize_per_channel_default_33" [id=900, type=dequantize_per_channel]; +"901 linear_32" [id=901, type=linear]; +"902 relu__5" [id=902, type=relu_]; +"903 relu__5_0_0_nncf_smooth_quant_0" [id=903, type=call_module]; +"904 linear_33_scale_0" [id=904, type=get_attr]; +"905 linear_33_zero_point_0" [id=905, type=get_attr]; +"906 _frozen_param34" [id=906, type=get_attr]; +"907 dequantize_per_channel_default_34" [id=907, type=dequantize_per_channel]; +"908 linear_33" [id=908, type=linear]; +"909 view_26" [id=909, type=view]; +"910 index_5" [id=910, type=index]; +"911 view_27" [id=911, type=view]; +"912 permute_23" [id=912, type=permute]; +"913 contiguous_8" [id=913, type=contiguous]; +"914 unsqueeze_13" [id=914, type=unsqueeze]; +"915 sigmoid_5" [id=915, type=sigmoid]; +"916 mul_10" [id=916, type=mul]; +"917 pad_7" [id=917, type=pad]; +"918 roll_4" [id=918, type=roll]; +"919 view_28" [id=919, type=view]; +"920 permute_24" [id=920, type=permute]; +"921 reshape_22" [id=921, type=reshape]; +"922 clone_5" [id=922, type=clone]; +"923 reshape_22_0_0_nncf_smooth_quant_0" [id=923, type=call_module]; +"924 quantize_per_tensor_default_33" [id=924, type=quantize_per_tensor]; +"925 dequantize_per_tensor_default_33" [id=925, type=dequantize_per_tensor]; +"926 linear_34_scale_0" [id=926, type=get_attr]; +"927 linear_34_zero_point_0" [id=927, type=get_attr]; +"928 _frozen_param35" [id=928, type=get_attr]; +"929 dequantize_per_channel_default_35" [id=929, type=dequantize_per_channel]; +"930 linear_34" [id=930, type=linear]; +"931 reshape_23" [id=931, type=reshape]; +"932 permute_25" [id=932, type=permute]; +"933 select_15" [id=933, type=select]; +"934 select_16" [id=934, type=select]; +"935 select_17" [id=935, type=select]; +"936 linalg_vector_norm_10" [id=936, type=linalg_vector_norm]; +"937 clamp_min_10" [id=937, type=clamp_min]; +"938 expand_as_10" [id=938, type=expand_as]; +"939 div_10" [id=939, type=div]; +"940 quantize_per_tensor_default_34" [id=940, type=quantize_per_tensor]; +"941 dequantize_per_tensor_default_34" [id=941, type=dequantize_per_tensor]; +"942 linalg_vector_norm_11" [id=942, type=linalg_vector_norm]; +"943 clamp_min_11" [id=943, type=clamp_min]; +"944 expand_as_11" [id=944, type=expand_as]; +"945 div_11" [id=945, type=div]; +"946 quantize_per_tensor_default_35" [id=946, type=quantize_per_tensor]; +"947 dequantize_per_tensor_default_35" [id=947, type=dequantize_per_tensor]; +"948 transpose_10" [id=948, type=transpose]; +"949 matmul_10" [id=949, type=matmul]; +"950 clamp_5" [id=950, type=clamp]; +"951 exp_5" [id=951, type=exp]; +"952 mul_11" [id=952, type=mul]; +"953 add_17" [id=953, type=add]; +"954 new_zeros_2" [id=954, type=new_zeros]; +"955 view_29" [id=955, type=view]; +"956 permute_26" [id=956, type=permute]; +"957 reshape_24" [id=957, type=reshape]; +"958 unsqueeze_14" [id=958, type=unsqueeze]; +"959 unsqueeze_15" [id=959, type=unsqueeze]; +"960 sub_2" [id=960, type=sub]; +"961 ne_2" [id=961, type=ne]; +"962 masked_fill_4" [id=962, type=masked_fill]; +"963 eq_2" [id=963, type=eq]; +"964 masked_fill_5" [id=964, type=masked_fill]; +"965 view_30" [id=965, type=view]; +"966 unsqueeze_16" [id=966, type=unsqueeze]; +"967 unsqueeze_17" [id=967, type=unsqueeze]; +"968 add_18" [id=968, type=add]; +"969 view_31" [id=969, type=view]; +"970 softmax_5" [id=970, type=softmax]; +"971 dropout_20" [id=971, type=dropout]; +"972 matmul_11" [id=972, type=matmul]; +"973 transpose_11" [id=973, type=transpose]; +"974 reshape_25" [id=974, type=reshape]; +"975 reshape_25_0_0_nncf_smooth_quant_0" [id=975, type=call_module]; +"976 quantize_per_tensor_default_36" [id=976, type=quantize_per_tensor]; +"977 dequantize_per_tensor_default_36" [id=977, type=dequantize_per_tensor]; +"978 linear_35_scale_0" [id=978, type=get_attr]; +"979 linear_35_zero_point_0" [id=979, type=get_attr]; +"980 _frozen_param36" [id=980, type=get_attr]; +"981 dequantize_per_channel_default_36" [id=981, type=dequantize_per_channel]; +"982 linear_35" [id=982, type=linear]; +"983 dropout_21" [id=983, type=dropout]; +"984 view_32" [id=984, type=view]; +"985 permute_27" [id=985, type=permute]; +"986 reshape_26" [id=986, type=reshape]; +"987 roll_5" [id=987, type=roll]; +"988 slice_101" [id=988, type=slice]; +"989 slice_102" [id=989, type=slice]; +"990 slice_103" [id=990, type=slice]; +"991 slice_104" [id=991, type=slice]; +"992 contiguous_9" [id=992, type=contiguous]; +"993 layer_norm_13" [id=993, type=layer_norm]; +"994 add_19" [id=994, type=add]; +"995 add_19_0_0_nncf_smooth_quant_0" [id=995, type=call_module]; +"996 quantize_per_tensor_default_37" [id=996, type=quantize_per_tensor]; +"997 dequantize_per_tensor_default_37" [id=997, type=dequantize_per_tensor]; +"998 linear_36_scale_0" [id=998, type=get_attr]; +"999 linear_36_zero_point_0" [id=999, type=get_attr]; +"1000 _frozen_param37" [id=1000, type=get_attr]; +"1001 dequantize_per_channel_default_37" [id=1001, type=dequantize_per_channel]; +"1002 linear_36" [id=1002, type=linear]; +"1003 gelu_5" [id=1003, type=gelu]; +"1004 dropout_22" [id=1004, type=dropout]; +"1005 dropout_22_0_0_nncf_smooth_quant_0" [id=1005, type=call_module]; +"1006 quantize_per_tensor_default_38" [id=1006, type=quantize_per_tensor]; +"1007 dequantize_per_tensor_default_38" [id=1007, type=dequantize_per_tensor]; +"1008 linear_37_scale_0" [id=1008, type=get_attr]; +"1009 linear_37_zero_point_0" [id=1009, type=get_attr]; +"1010 _frozen_param38" [id=1010, type=get_attr]; +"1011 dequantize_per_channel_default_38" [id=1011, type=dequantize_per_channel]; +"1012 linear_37" [id=1012, type=linear]; +"1013 dropout_23" [id=1013, type=dropout]; +"1014 layer_norm_14" [id=1014, type=layer_norm]; +"1015 add_20" [id=1015, type=add]; +"1016 features_5_2_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [id=1016, type=call_module]; +"1017 linear_38_scale_0" [id=1017, type=get_attr]; +"1018 linear_38_zero_point_0" [id=1018, type=get_attr]; +"1019 _frozen_param39" [id=1019, type=get_attr]; +"1020 dequantize_per_channel_default_39" [id=1020, type=dequantize_per_channel]; +"1021 linear_38" [id=1021, type=linear]; +"1022 relu__6" [id=1022, type=relu_]; +"1023 relu__6_0_0_nncf_smooth_quant_0" [id=1023, type=call_module]; +"1024 linear_39_scale_0" [id=1024, type=get_attr]; +"1025 linear_39_zero_point_0" [id=1025, type=get_attr]; +"1026 _frozen_param40" [id=1026, type=get_attr]; +"1027 dequantize_per_channel_default_40" [id=1027, type=dequantize_per_channel]; +"1028 linear_39" [id=1028, type=linear]; +"1029 view_33" [id=1029, type=view]; +"1030 index_6" [id=1030, type=index]; +"1031 view_34" [id=1031, type=view]; +"1032 permute_28" [id=1032, type=permute]; +"1033 contiguous_10" [id=1033, type=contiguous]; +"1034 unsqueeze_18" [id=1034, type=unsqueeze]; +"1035 sigmoid_6" [id=1035, type=sigmoid]; +"1036 mul_12" [id=1036, type=mul]; +"1037 pad_8" [id=1037, type=pad]; +"1038 view_35" [id=1038, type=view]; +"1039 permute_29" [id=1039, type=permute]; +"1040 reshape_27" [id=1040, type=reshape]; +"1041 clone_6" [id=1041, type=clone]; +"1042 reshape_27_0_0_nncf_smooth_quant_0" [id=1042, type=call_module]; +"1043 quantize_per_tensor_default_39" [id=1043, type=quantize_per_tensor]; +"1044 dequantize_per_tensor_default_39" [id=1044, type=dequantize_per_tensor]; +"1045 linear_40_scale_0" [id=1045, type=get_attr]; +"1046 linear_40_zero_point_0" [id=1046, type=get_attr]; +"1047 _frozen_param41" [id=1047, type=get_attr]; +"1048 dequantize_per_channel_default_41" [id=1048, type=dequantize_per_channel]; +"1049 linear_40" [id=1049, type=linear]; +"1050 reshape_28" [id=1050, type=reshape]; +"1051 permute_30" [id=1051, type=permute]; +"1052 select_18" [id=1052, type=select]; +"1053 select_19" [id=1053, type=select]; +"1054 select_20" [id=1054, type=select]; +"1055 linalg_vector_norm_12" [id=1055, type=linalg_vector_norm]; +"1056 clamp_min_12" [id=1056, type=clamp_min]; +"1057 expand_as_12" [id=1057, type=expand_as]; +"1058 div_12" [id=1058, type=div]; +"1059 quantize_per_tensor_default_40" [id=1059, type=quantize_per_tensor]; +"1060 dequantize_per_tensor_default_40" [id=1060, type=dequantize_per_tensor]; +"1061 linalg_vector_norm_13" [id=1061, type=linalg_vector_norm]; +"1062 clamp_min_13" [id=1062, type=clamp_min]; +"1063 expand_as_13" [id=1063, type=expand_as]; +"1064 div_13" [id=1064, type=div]; +"1065 quantize_per_tensor_default_41" [id=1065, type=quantize_per_tensor]; +"1066 dequantize_per_tensor_default_41" [id=1066, type=dequantize_per_tensor]; +"1067 transpose_12" [id=1067, type=transpose]; +"1068 matmul_12" [id=1068, type=matmul]; +"1069 clamp_6" [id=1069, type=clamp]; +"1070 exp_6" [id=1070, type=exp]; +"1071 mul_13" [id=1071, type=mul]; +"1072 add_21" [id=1072, type=add]; +"1073 softmax_6" [id=1073, type=softmax]; +"1074 dropout_24" [id=1074, type=dropout]; +"1075 matmul_13" [id=1075, type=matmul]; +"1076 transpose_13" [id=1076, type=transpose]; +"1077 reshape_29" [id=1077, type=reshape]; +"1078 reshape_29_0_0_nncf_smooth_quant_0" [id=1078, type=call_module]; +"1079 quantize_per_tensor_default_42" [id=1079, type=quantize_per_tensor]; +"1080 dequantize_per_tensor_default_42" [id=1080, type=dequantize_per_tensor]; +"1081 linear_41_scale_0" [id=1081, type=get_attr]; +"1082 linear_41_zero_point_0" [id=1082, type=get_attr]; +"1083 _frozen_param42" [id=1083, type=get_attr]; +"1084 dequantize_per_channel_default_42" [id=1084, type=dequantize_per_channel]; +"1085 linear_41" [id=1085, type=linear]; +"1086 dropout_25" [id=1086, type=dropout]; +"1087 view_36" [id=1087, type=view]; +"1088 permute_31" [id=1088, type=permute]; +"1089 reshape_30" [id=1089, type=reshape]; +"1090 slice_106" [id=1090, type=slice]; +"1091 slice_107" [id=1091, type=slice]; +"1092 slice_108" [id=1092, type=slice]; +"1093 slice_109" [id=1093, type=slice]; +"1094 contiguous_11" [id=1094, type=contiguous]; +"1095 layer_norm_15" [id=1095, type=layer_norm]; +"1096 add_22" [id=1096, type=add]; +"1097 add_22_0_0_nncf_smooth_quant_0" [id=1097, type=call_module]; +"1098 quantize_per_tensor_default_43" [id=1098, type=quantize_per_tensor]; +"1099 dequantize_per_tensor_default_43" [id=1099, type=dequantize_per_tensor]; +"1100 linear_42_scale_0" [id=1100, type=get_attr]; +"1101 linear_42_zero_point_0" [id=1101, type=get_attr]; +"1102 _frozen_param43" [id=1102, type=get_attr]; +"1103 dequantize_per_channel_default_43" [id=1103, type=dequantize_per_channel]; +"1104 linear_42" [id=1104, type=linear]; +"1105 gelu_6" [id=1105, type=gelu]; +"1106 dropout_26" [id=1106, type=dropout]; +"1107 dropout_26_0_0_nncf_smooth_quant_0" [id=1107, type=call_module]; +"1108 quantize_per_tensor_default_44" [id=1108, type=quantize_per_tensor]; +"1109 dequantize_per_tensor_default_44" [id=1109, type=dequantize_per_tensor]; +"1110 linear_43_scale_0" [id=1110, type=get_attr]; +"1111 linear_43_zero_point_0" [id=1111, type=get_attr]; +"1112 _frozen_param44" [id=1112, type=get_attr]; +"1113 dequantize_per_channel_default_44" [id=1113, type=dequantize_per_channel]; +"1114 linear_43" [id=1114, type=linear]; +"1115 dropout_27" [id=1115, type=dropout]; +"1116 layer_norm_16" [id=1116, type=layer_norm]; +"1117 add_23" [id=1117, type=add]; +"1118 features_5_3_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [id=1118, type=call_module]; +"1119 linear_44_scale_0" [id=1119, type=get_attr]; +"1120 linear_44_zero_point_0" [id=1120, type=get_attr]; +"1121 _frozen_param45" [id=1121, type=get_attr]; +"1122 dequantize_per_channel_default_45" [id=1122, type=dequantize_per_channel]; +"1123 linear_44" [id=1123, type=linear]; +"1124 relu__7" [id=1124, type=relu_]; +"1125 relu__7_0_0_nncf_smooth_quant_0" [id=1125, type=call_module]; +"1126 linear_45_scale_0" [id=1126, type=get_attr]; +"1127 linear_45_zero_point_0" [id=1127, type=get_attr]; +"1128 _frozen_param46" [id=1128, type=get_attr]; +"1129 dequantize_per_channel_default_46" [id=1129, type=dequantize_per_channel]; +"1130 linear_45" [id=1130, type=linear]; +"1131 view_37" [id=1131, type=view]; +"1132 index_7" [id=1132, type=index]; +"1133 view_38" [id=1133, type=view]; +"1134 permute_32" [id=1134, type=permute]; +"1135 contiguous_12" [id=1135, type=contiguous]; +"1136 unsqueeze_19" [id=1136, type=unsqueeze]; +"1137 sigmoid_7" [id=1137, type=sigmoid]; +"1138 mul_14" [id=1138, type=mul]; +"1139 pad_9" [id=1139, type=pad]; +"1140 roll_6" [id=1140, type=roll]; +"1141 view_39" [id=1141, type=view]; +"1142 permute_33" [id=1142, type=permute]; +"1143 reshape_31" [id=1143, type=reshape]; +"1144 clone_7" [id=1144, type=clone]; +"1145 reshape_31_0_0_nncf_smooth_quant_0" [id=1145, type=call_module]; +"1146 quantize_per_tensor_default_45" [id=1146, type=quantize_per_tensor]; +"1147 dequantize_per_tensor_default_45" [id=1147, type=dequantize_per_tensor]; +"1148 linear_46_scale_0" [id=1148, type=get_attr]; +"1149 linear_46_zero_point_0" [id=1149, type=get_attr]; +"1150 _frozen_param47" [id=1150, type=get_attr]; +"1151 dequantize_per_channel_default_47" [id=1151, type=dequantize_per_channel]; +"1152 linear_46" [id=1152, type=linear]; +"1153 reshape_32" [id=1153, type=reshape]; +"1154 permute_34" [id=1154, type=permute]; +"1155 select_21" [id=1155, type=select]; +"1156 select_22" [id=1156, type=select]; +"1157 select_23" [id=1157, type=select]; +"1158 linalg_vector_norm_14" [id=1158, type=linalg_vector_norm]; +"1159 clamp_min_14" [id=1159, type=clamp_min]; +"1160 expand_as_14" [id=1160, type=expand_as]; +"1161 div_14" [id=1161, type=div]; +"1162 quantize_per_tensor_default_46" [id=1162, type=quantize_per_tensor]; +"1163 dequantize_per_tensor_default_46" [id=1163, type=dequantize_per_tensor]; +"1164 linalg_vector_norm_15" [id=1164, type=linalg_vector_norm]; +"1165 clamp_min_15" [id=1165, type=clamp_min]; +"1166 expand_as_15" [id=1166, type=expand_as]; +"1167 div_15" [id=1167, type=div]; +"1168 quantize_per_tensor_default_47" [id=1168, type=quantize_per_tensor]; +"1169 dequantize_per_tensor_default_47" [id=1169, type=dequantize_per_tensor]; +"1170 transpose_14" [id=1170, type=transpose]; +"1171 matmul_14" [id=1171, type=matmul]; +"1172 clamp_7" [id=1172, type=clamp]; +"1173 exp_7" [id=1173, type=exp]; +"1174 mul_15" [id=1174, type=mul]; +"1175 add_24" [id=1175, type=add]; +"1176 new_zeros_3" [id=1176, type=new_zeros]; +"1177 view_40" [id=1177, type=view]; +"1178 permute_35" [id=1178, type=permute]; +"1179 reshape_33" [id=1179, type=reshape]; +"1180 unsqueeze_20" [id=1180, type=unsqueeze]; +"1181 unsqueeze_21" [id=1181, type=unsqueeze]; +"1182 sub_3" [id=1182, type=sub]; +"1183 ne_3" [id=1183, type=ne]; +"1184 masked_fill_6" [id=1184, type=masked_fill]; +"1185 eq_3" [id=1185, type=eq]; +"1186 masked_fill_7" [id=1186, type=masked_fill]; +"1187 view_41" [id=1187, type=view]; +"1188 unsqueeze_22" [id=1188, type=unsqueeze]; +"1189 unsqueeze_23" [id=1189, type=unsqueeze]; +"1190 add_25" [id=1190, type=add]; +"1191 view_42" [id=1191, type=view]; +"1192 softmax_7" [id=1192, type=softmax]; +"1193 dropout_28" [id=1193, type=dropout]; +"1194 matmul_15" [id=1194, type=matmul]; +"1195 transpose_15" [id=1195, type=transpose]; +"1196 reshape_34" [id=1196, type=reshape]; +"1197 reshape_34_0_0_nncf_smooth_quant_0" [id=1197, type=call_module]; +"1198 quantize_per_tensor_default_48" [id=1198, type=quantize_per_tensor]; +"1199 dequantize_per_tensor_default_48" [id=1199, type=dequantize_per_tensor]; +"1200 linear_47_scale_0" [id=1200, type=get_attr]; +"1201 linear_47_zero_point_0" [id=1201, type=get_attr]; +"1202 _frozen_param48" [id=1202, type=get_attr]; +"1203 dequantize_per_channel_default_48" [id=1203, type=dequantize_per_channel]; +"1204 linear_47" [id=1204, type=linear]; +"1205 dropout_29" [id=1205, type=dropout]; +"1206 view_43" [id=1206, type=view]; +"1207 permute_36" [id=1207, type=permute]; +"1208 reshape_35" [id=1208, type=reshape]; +"1209 roll_7" [id=1209, type=roll]; +"1210 slice_129" [id=1210, type=slice]; +"1211 slice_130" [id=1211, type=slice]; +"1212 slice_131" [id=1212, type=slice]; +"1213 slice_132" [id=1213, type=slice]; +"1214 contiguous_13" [id=1214, type=contiguous]; +"1215 layer_norm_17" [id=1215, type=layer_norm]; +"1216 add_26" [id=1216, type=add]; +"1217 add_26_0_0_nncf_smooth_quant_0" [id=1217, type=call_module]; +"1218 quantize_per_tensor_default_49" [id=1218, type=quantize_per_tensor]; +"1219 dequantize_per_tensor_default_49" [id=1219, type=dequantize_per_tensor]; +"1220 linear_48_scale_0" [id=1220, type=get_attr]; +"1221 linear_48_zero_point_0" [id=1221, type=get_attr]; +"1222 _frozen_param49" [id=1222, type=get_attr]; +"1223 dequantize_per_channel_default_49" [id=1223, type=dequantize_per_channel]; +"1224 linear_48" [id=1224, type=linear]; +"1225 gelu_7" [id=1225, type=gelu]; +"1226 dropout_30" [id=1226, type=dropout]; +"1227 dropout_30_0_0_nncf_smooth_quant_0" [id=1227, type=call_module]; +"1228 quantize_per_tensor_default_50" [id=1228, type=quantize_per_tensor]; +"1229 dequantize_per_tensor_default_50" [id=1229, type=dequantize_per_tensor]; +"1230 linear_49_scale_0" [id=1230, type=get_attr]; +"1231 linear_49_zero_point_0" [id=1231, type=get_attr]; +"1232 _frozen_param50" [id=1232, type=get_attr]; +"1233 dequantize_per_channel_default_50" [id=1233, type=dequantize_per_channel]; +"1234 linear_49" [id=1234, type=linear]; +"1235 dropout_31" [id=1235, type=dropout]; +"1236 layer_norm_18" [id=1236, type=layer_norm]; +"1237 add_27" [id=1237, type=add]; +"1238 features_5_4_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [id=1238, type=call_module]; +"1239 linear_50_scale_0" [id=1239, type=get_attr]; +"1240 linear_50_zero_point_0" [id=1240, type=get_attr]; +"1241 _frozen_param51" [id=1241, type=get_attr]; +"1242 dequantize_per_channel_default_51" [id=1242, type=dequantize_per_channel]; +"1243 linear_50" [id=1243, type=linear]; +"1244 relu__8" [id=1244, type=relu_]; +"1245 relu__8_0_0_nncf_smooth_quant_0" [id=1245, type=call_module]; +"1246 linear_51_scale_0" [id=1246, type=get_attr]; +"1247 linear_51_zero_point_0" [id=1247, type=get_attr]; +"1248 _frozen_param52" [id=1248, type=get_attr]; +"1249 dequantize_per_channel_default_52" [id=1249, type=dequantize_per_channel]; +"1250 linear_51" [id=1250, type=linear]; +"1251 view_44" [id=1251, type=view]; +"1252 index_8" [id=1252, type=index]; +"1253 view_45" [id=1253, type=view]; +"1254 permute_37" [id=1254, type=permute]; +"1255 contiguous_14" [id=1255, type=contiguous]; +"1256 unsqueeze_24" [id=1256, type=unsqueeze]; +"1257 sigmoid_8" [id=1257, type=sigmoid]; +"1258 mul_16" [id=1258, type=mul]; +"1259 pad_10" [id=1259, type=pad]; +"1260 view_46" [id=1260, type=view]; +"1261 permute_38" [id=1261, type=permute]; +"1262 reshape_36" [id=1262, type=reshape]; +"1263 clone_8" [id=1263, type=clone]; +"1264 reshape_36_0_0_nncf_smooth_quant_0" [id=1264, type=call_module]; +"1265 quantize_per_tensor_default_51" [id=1265, type=quantize_per_tensor]; +"1266 dequantize_per_tensor_default_51" [id=1266, type=dequantize_per_tensor]; +"1267 linear_52_scale_0" [id=1267, type=get_attr]; +"1268 linear_52_zero_point_0" [id=1268, type=get_attr]; +"1269 _frozen_param53" [id=1269, type=get_attr]; +"1270 dequantize_per_channel_default_53" [id=1270, type=dequantize_per_channel]; +"1271 linear_52" [id=1271, type=linear]; +"1272 reshape_37" [id=1272, type=reshape]; +"1273 permute_39" [id=1273, type=permute]; +"1274 select_24" [id=1274, type=select]; +"1275 select_25" [id=1275, type=select]; +"1276 select_26" [id=1276, type=select]; +"1277 linalg_vector_norm_16" [id=1277, type=linalg_vector_norm]; +"1278 clamp_min_16" [id=1278, type=clamp_min]; +"1279 expand_as_16" [id=1279, type=expand_as]; +"1280 div_16" [id=1280, type=div]; +"1281 quantize_per_tensor_default_52" [id=1281, type=quantize_per_tensor]; +"1282 dequantize_per_tensor_default_52" [id=1282, type=dequantize_per_tensor]; +"1283 linalg_vector_norm_17" [id=1283, type=linalg_vector_norm]; +"1284 clamp_min_17" [id=1284, type=clamp_min]; +"1285 expand_as_17" [id=1285, type=expand_as]; +"1286 div_17" [id=1286, type=div]; +"1287 quantize_per_tensor_default_53" [id=1287, type=quantize_per_tensor]; +"1288 dequantize_per_tensor_default_53" [id=1288, type=dequantize_per_tensor]; +"1289 transpose_16" [id=1289, type=transpose]; +"1290 matmul_16" [id=1290, type=matmul]; +"1291 clamp_8" [id=1291, type=clamp]; +"1292 exp_8" [id=1292, type=exp]; +"1293 mul_17" [id=1293, type=mul]; +"1294 add_28" [id=1294, type=add]; +"1295 softmax_8" [id=1295, type=softmax]; +"1296 dropout_32" [id=1296, type=dropout]; +"1297 matmul_17" [id=1297, type=matmul]; +"1298 transpose_17" [id=1298, type=transpose]; +"1299 reshape_38" [id=1299, type=reshape]; +"1300 reshape_38_0_0_nncf_smooth_quant_0" [id=1300, type=call_module]; +"1301 quantize_per_tensor_default_54" [id=1301, type=quantize_per_tensor]; +"1302 dequantize_per_tensor_default_54" [id=1302, type=dequantize_per_tensor]; +"1303 linear_53_scale_0" [id=1303, type=get_attr]; +"1304 linear_53_zero_point_0" [id=1304, type=get_attr]; +"1305 _frozen_param54" [id=1305, type=get_attr]; +"1306 dequantize_per_channel_default_54" [id=1306, type=dequantize_per_channel]; +"1307 linear_53" [id=1307, type=linear]; +"1308 dropout_33" [id=1308, type=dropout]; +"1309 view_47" [id=1309, type=view]; +"1310 permute_40" [id=1310, type=permute]; +"1311 reshape_39" [id=1311, type=reshape]; +"1312 slice_134" [id=1312, type=slice]; +"1313 slice_135" [id=1313, type=slice]; +"1314 slice_136" [id=1314, type=slice]; +"1315 slice_137" [id=1315, type=slice]; +"1316 contiguous_15" [id=1316, type=contiguous]; +"1317 layer_norm_19" [id=1317, type=layer_norm]; +"1318 add_29" [id=1318, type=add]; +"1319 add_29_0_0_nncf_smooth_quant_0" [id=1319, type=call_module]; +"1320 quantize_per_tensor_default_55" [id=1320, type=quantize_per_tensor]; +"1321 dequantize_per_tensor_default_55" [id=1321, type=dequantize_per_tensor]; +"1322 linear_54_scale_0" [id=1322, type=get_attr]; +"1323 linear_54_zero_point_0" [id=1323, type=get_attr]; +"1324 _frozen_param55" [id=1324, type=get_attr]; +"1325 dequantize_per_channel_default_55" [id=1325, type=dequantize_per_channel]; +"1326 linear_54" [id=1326, type=linear]; +"1327 gelu_8" [id=1327, type=gelu]; +"1328 dropout_34" [id=1328, type=dropout]; +"1329 dropout_34_0_0_nncf_smooth_quant_0" [id=1329, type=call_module]; +"1330 quantize_per_tensor_default_56" [id=1330, type=quantize_per_tensor]; +"1331 dequantize_per_tensor_default_56" [id=1331, type=dequantize_per_tensor]; +"1332 linear_55_scale_0" [id=1332, type=get_attr]; +"1333 linear_55_zero_point_0" [id=1333, type=get_attr]; +"1334 _frozen_param56" [id=1334, type=get_attr]; +"1335 dequantize_per_channel_default_56" [id=1335, type=dequantize_per_channel]; +"1336 linear_55" [id=1336, type=linear]; +"1337 dropout_35" [id=1337, type=dropout]; +"1338 layer_norm_20" [id=1338, type=layer_norm]; +"1339 add_30" [id=1339, type=add]; +"1340 features_5_5_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [id=1340, type=call_module]; +"1341 linear_56_scale_0" [id=1341, type=get_attr]; +"1342 linear_56_zero_point_0" [id=1342, type=get_attr]; +"1343 _frozen_param57" [id=1343, type=get_attr]; +"1344 dequantize_per_channel_default_57" [id=1344, type=dequantize_per_channel]; +"1345 linear_56" [id=1345, type=linear]; +"1346 relu__9" [id=1346, type=relu_]; +"1347 relu__9_0_0_nncf_smooth_quant_0" [id=1347, type=call_module]; +"1348 linear_57_scale_0" [id=1348, type=get_attr]; +"1349 linear_57_zero_point_0" [id=1349, type=get_attr]; +"1350 _frozen_param58" [id=1350, type=get_attr]; +"1351 dequantize_per_channel_default_58" [id=1351, type=dequantize_per_channel]; +"1352 linear_57" [id=1352, type=linear]; +"1353 view_48" [id=1353, type=view]; +"1354 index_9" [id=1354, type=index]; +"1355 view_49" [id=1355, type=view]; +"1356 permute_41" [id=1356, type=permute]; +"1357 contiguous_16" [id=1357, type=contiguous]; +"1358 unsqueeze_25" [id=1358, type=unsqueeze]; +"1359 sigmoid_9" [id=1359, type=sigmoid]; +"1360 mul_18" [id=1360, type=mul]; +"1361 pad_11" [id=1361, type=pad]; +"1362 roll_8" [id=1362, type=roll]; +"1363 view_50" [id=1363, type=view]; +"1364 permute_42" [id=1364, type=permute]; +"1365 reshape_40" [id=1365, type=reshape]; +"1366 clone_9" [id=1366, type=clone]; +"1367 reshape_40_0_0_nncf_smooth_quant_0" [id=1367, type=call_module]; +"1368 quantize_per_tensor_default_57" [id=1368, type=quantize_per_tensor]; +"1369 dequantize_per_tensor_default_57" [id=1369, type=dequantize_per_tensor]; +"1370 linear_58_scale_0" [id=1370, type=get_attr]; +"1371 linear_58_zero_point_0" [id=1371, type=get_attr]; +"1372 _frozen_param59" [id=1372, type=get_attr]; +"1373 dequantize_per_channel_default_59" [id=1373, type=dequantize_per_channel]; +"1374 linear_58" [id=1374, type=linear]; +"1375 reshape_41" [id=1375, type=reshape]; +"1376 permute_43" [id=1376, type=permute]; +"1377 select_27" [id=1377, type=select]; +"1378 select_28" [id=1378, type=select]; +"1379 select_29" [id=1379, type=select]; +"1380 linalg_vector_norm_18" [id=1380, type=linalg_vector_norm]; +"1381 clamp_min_18" [id=1381, type=clamp_min]; +"1382 expand_as_18" [id=1382, type=expand_as]; +"1383 div_18" [id=1383, type=div]; +"1384 quantize_per_tensor_default_58" [id=1384, type=quantize_per_tensor]; +"1385 dequantize_per_tensor_default_58" [id=1385, type=dequantize_per_tensor]; +"1386 linalg_vector_norm_19" [id=1386, type=linalg_vector_norm]; +"1387 clamp_min_19" [id=1387, type=clamp_min]; +"1388 expand_as_19" [id=1388, type=expand_as]; +"1389 div_19" [id=1389, type=div]; +"1390 quantize_per_tensor_default_59" [id=1390, type=quantize_per_tensor]; +"1391 dequantize_per_tensor_default_59" [id=1391, type=dequantize_per_tensor]; +"1392 transpose_18" [id=1392, type=transpose]; +"1393 matmul_18" [id=1393, type=matmul]; +"1394 clamp_9" [id=1394, type=clamp]; +"1395 exp_9" [id=1395, type=exp]; +"1396 mul_19" [id=1396, type=mul]; +"1397 add_31" [id=1397, type=add]; +"1398 new_zeros_4" [id=1398, type=new_zeros]; +"1399 view_51" [id=1399, type=view]; +"1400 permute_44" [id=1400, type=permute]; +"1401 reshape_42" [id=1401, type=reshape]; +"1402 unsqueeze_26" [id=1402, type=unsqueeze]; +"1403 unsqueeze_27" [id=1403, type=unsqueeze]; +"1404 sub_4" [id=1404, type=sub]; +"1405 ne_4" [id=1405, type=ne]; +"1406 masked_fill_8" [id=1406, type=masked_fill]; +"1407 eq_4" [id=1407, type=eq]; +"1408 masked_fill_9" [id=1408, type=masked_fill]; +"1409 view_52" [id=1409, type=view]; +"1410 unsqueeze_28" [id=1410, type=unsqueeze]; +"1411 unsqueeze_29" [id=1411, type=unsqueeze]; +"1412 add_32" [id=1412, type=add]; +"1413 view_53" [id=1413, type=view]; +"1414 softmax_9" [id=1414, type=softmax]; +"1415 dropout_36" [id=1415, type=dropout]; +"1416 matmul_19" [id=1416, type=matmul]; +"1417 transpose_19" [id=1417, type=transpose]; +"1418 reshape_43" [id=1418, type=reshape]; +"1419 reshape_43_0_0_nncf_smooth_quant_0" [id=1419, type=call_module]; +"1420 quantize_per_tensor_default_60" [id=1420, type=quantize_per_tensor]; +"1421 dequantize_per_tensor_default_60" [id=1421, type=dequantize_per_tensor]; +"1422 linear_59_scale_0" [id=1422, type=get_attr]; +"1423 linear_59_zero_point_0" [id=1423, type=get_attr]; +"1424 _frozen_param60" [id=1424, type=get_attr]; +"1425 dequantize_per_channel_default_60" [id=1425, type=dequantize_per_channel]; +"1426 linear_59" [id=1426, type=linear]; +"1427 dropout_37" [id=1427, type=dropout]; +"1428 view_54" [id=1428, type=view]; +"1429 permute_45" [id=1429, type=permute]; +"1430 reshape_44" [id=1430, type=reshape]; +"1431 roll_9" [id=1431, type=roll]; +"1432 slice_157" [id=1432, type=slice]; +"1433 slice_158" [id=1433, type=slice]; +"1434 slice_159" [id=1434, type=slice]; +"1435 slice_160" [id=1435, type=slice]; +"1436 contiguous_17" [id=1436, type=contiguous]; +"1437 layer_norm_21" [id=1437, type=layer_norm]; +"1438 add_33" [id=1438, type=add]; +"1439 add_33_0_0_nncf_smooth_quant_0" [id=1439, type=call_module]; +"1440 quantize_per_tensor_default_61" [id=1440, type=quantize_per_tensor]; +"1441 dequantize_per_tensor_default_61" [id=1441, type=dequantize_per_tensor]; +"1442 linear_60_scale_0" [id=1442, type=get_attr]; +"1443 linear_60_zero_point_0" [id=1443, type=get_attr]; +"1444 _frozen_param61" [id=1444, type=get_attr]; +"1445 dequantize_per_channel_default_61" [id=1445, type=dequantize_per_channel]; +"1446 linear_60" [id=1446, type=linear]; +"1447 gelu_9" [id=1447, type=gelu]; +"1448 dropout_38" [id=1448, type=dropout]; +"1449 dropout_38_0_0_nncf_smooth_quant_0" [id=1449, type=call_module]; +"1450 quantize_per_tensor_default_62" [id=1450, type=quantize_per_tensor]; +"1451 dequantize_per_tensor_default_62" [id=1451, type=dequantize_per_tensor]; +"1452 linear_61_scale_0" [id=1452, type=get_attr]; +"1453 linear_61_zero_point_0" [id=1453, type=get_attr]; +"1454 _frozen_param62" [id=1454, type=get_attr]; +"1455 dequantize_per_channel_default_62" [id=1455, type=dequantize_per_channel]; +"1456 linear_61" [id=1456, type=linear]; +"1457 dropout_39" [id=1457, type=dropout]; +"1458 layer_norm_22" [id=1458, type=layer_norm]; +"1459 add_34" [id=1459, type=add]; +"1460 features_5_6_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [id=1460, type=call_module]; +"1461 linear_62_scale_0" [id=1461, type=get_attr]; +"1462 linear_62_zero_point_0" [id=1462, type=get_attr]; +"1463 _frozen_param63" [id=1463, type=get_attr]; +"1464 dequantize_per_channel_default_63" [id=1464, type=dequantize_per_channel]; +"1465 linear_62" [id=1465, type=linear]; +"1466 relu__10" [id=1466, type=relu_]; +"1467 relu__10_0_0_nncf_smooth_quant_0" [id=1467, type=call_module]; +"1468 linear_63_scale_0" [id=1468, type=get_attr]; +"1469 linear_63_zero_point_0" [id=1469, type=get_attr]; +"1470 _frozen_param64" [id=1470, type=get_attr]; +"1471 dequantize_per_channel_default_64" [id=1471, type=dequantize_per_channel]; +"1472 linear_63" [id=1472, type=linear]; +"1473 view_55" [id=1473, type=view]; +"1474 index_10" [id=1474, type=index]; +"1475 view_56" [id=1475, type=view]; +"1476 permute_46" [id=1476, type=permute]; +"1477 contiguous_18" [id=1477, type=contiguous]; +"1478 unsqueeze_30" [id=1478, type=unsqueeze]; +"1479 sigmoid_10" [id=1479, type=sigmoid]; +"1480 mul_20" [id=1480, type=mul]; +"1481 pad_12" [id=1481, type=pad]; +"1482 view_57" [id=1482, type=view]; +"1483 permute_47" [id=1483, type=permute]; +"1484 reshape_45" [id=1484, type=reshape]; +"1485 clone_10" [id=1485, type=clone]; +"1486 reshape_45_0_0_nncf_smooth_quant_0" [id=1486, type=call_module]; +"1487 quantize_per_tensor_default_63" [id=1487, type=quantize_per_tensor]; +"1488 dequantize_per_tensor_default_63" [id=1488, type=dequantize_per_tensor]; +"1489 linear_64_scale_0" [id=1489, type=get_attr]; +"1490 linear_64_zero_point_0" [id=1490, type=get_attr]; +"1491 _frozen_param65" [id=1491, type=get_attr]; +"1492 dequantize_per_channel_default_65" [id=1492, type=dequantize_per_channel]; +"1493 linear_64" [id=1493, type=linear]; +"1494 reshape_46" [id=1494, type=reshape]; +"1495 permute_48" [id=1495, type=permute]; +"1496 select_30" [id=1496, type=select]; +"1497 select_31" [id=1497, type=select]; +"1498 select_32" [id=1498, type=select]; +"1499 linalg_vector_norm_20" [id=1499, type=linalg_vector_norm]; +"1500 clamp_min_20" [id=1500, type=clamp_min]; +"1501 expand_as_20" [id=1501, type=expand_as]; +"1502 div_20" [id=1502, type=div]; +"1503 quantize_per_tensor_default_64" [id=1503, type=quantize_per_tensor]; +"1504 dequantize_per_tensor_default_64" [id=1504, type=dequantize_per_tensor]; +"1505 linalg_vector_norm_21" [id=1505, type=linalg_vector_norm]; +"1506 clamp_min_21" [id=1506, type=clamp_min]; +"1507 expand_as_21" [id=1507, type=expand_as]; +"1508 div_21" [id=1508, type=div]; +"1509 quantize_per_tensor_default_65" [id=1509, type=quantize_per_tensor]; +"1510 dequantize_per_tensor_default_65" [id=1510, type=dequantize_per_tensor]; +"1511 transpose_20" [id=1511, type=transpose]; +"1512 matmul_20" [id=1512, type=matmul]; +"1513 clamp_10" [id=1513, type=clamp]; +"1514 exp_10" [id=1514, type=exp]; +"1515 mul_21" [id=1515, type=mul]; +"1516 add_35" [id=1516, type=add]; +"1517 softmax_10" [id=1517, type=softmax]; +"1518 dropout_40" [id=1518, type=dropout]; +"1519 matmul_21" [id=1519, type=matmul]; +"1520 transpose_21" [id=1520, type=transpose]; +"1521 reshape_47" [id=1521, type=reshape]; +"1522 reshape_47_0_0_nncf_smooth_quant_0" [id=1522, type=call_module]; +"1523 quantize_per_tensor_default_66" [id=1523, type=quantize_per_tensor]; +"1524 dequantize_per_tensor_default_66" [id=1524, type=dequantize_per_tensor]; +"1525 linear_65_scale_0" [id=1525, type=get_attr]; +"1526 linear_65_zero_point_0" [id=1526, type=get_attr]; +"1527 _frozen_param66" [id=1527, type=get_attr]; +"1528 dequantize_per_channel_default_66" [id=1528, type=dequantize_per_channel]; +"1529 linear_65" [id=1529, type=linear]; +"1530 dropout_41" [id=1530, type=dropout]; +"1531 view_58" [id=1531, type=view]; +"1532 permute_49" [id=1532, type=permute]; +"1533 reshape_48" [id=1533, type=reshape]; +"1534 slice_162" [id=1534, type=slice]; +"1535 slice_163" [id=1535, type=slice]; +"1536 slice_164" [id=1536, type=slice]; +"1537 slice_165" [id=1537, type=slice]; +"1538 contiguous_19" [id=1538, type=contiguous]; +"1539 layer_norm_23" [id=1539, type=layer_norm]; +"1540 add_36" [id=1540, type=add]; +"1541 add_36_0_0_nncf_smooth_quant_0" [id=1541, type=call_module]; +"1542 quantize_per_tensor_default_67" [id=1542, type=quantize_per_tensor]; +"1543 dequantize_per_tensor_default_67" [id=1543, type=dequantize_per_tensor]; +"1544 linear_66_scale_0" [id=1544, type=get_attr]; +"1545 linear_66_zero_point_0" [id=1545, type=get_attr]; +"1546 _frozen_param67" [id=1546, type=get_attr]; +"1547 dequantize_per_channel_default_67" [id=1547, type=dequantize_per_channel]; +"1548 linear_66" [id=1548, type=linear]; +"1549 gelu_10" [id=1549, type=gelu]; +"1550 dropout_42" [id=1550, type=dropout]; +"1551 dropout_42_0_0_nncf_smooth_quant_0" [id=1551, type=call_module]; +"1552 quantize_per_tensor_default_68" [id=1552, type=quantize_per_tensor]; +"1553 dequantize_per_tensor_default_68" [id=1553, type=dequantize_per_tensor]; +"1554 linear_67_scale_0" [id=1554, type=get_attr]; +"1555 linear_67_zero_point_0" [id=1555, type=get_attr]; +"1556 _frozen_param68" [id=1556, type=get_attr]; +"1557 dequantize_per_channel_default_68" [id=1557, type=dequantize_per_channel]; +"1558 linear_67" [id=1558, type=linear]; +"1559 dropout_43" [id=1559, type=dropout]; +"1560 layer_norm_24" [id=1560, type=layer_norm]; +"1561 add_37" [id=1561, type=add]; +"1562 features_5_7_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [id=1562, type=call_module]; +"1563 linear_68_scale_0" [id=1563, type=get_attr]; +"1564 linear_68_zero_point_0" [id=1564, type=get_attr]; +"1565 _frozen_param69" [id=1565, type=get_attr]; +"1566 dequantize_per_channel_default_69" [id=1566, type=dequantize_per_channel]; +"1567 linear_68" [id=1567, type=linear]; +"1568 relu__11" [id=1568, type=relu_]; +"1569 relu__11_0_0_nncf_smooth_quant_0" [id=1569, type=call_module]; +"1570 linear_69_scale_0" [id=1570, type=get_attr]; +"1571 linear_69_zero_point_0" [id=1571, type=get_attr]; +"1572 _frozen_param70" [id=1572, type=get_attr]; +"1573 dequantize_per_channel_default_70" [id=1573, type=dequantize_per_channel]; +"1574 linear_69" [id=1574, type=linear]; +"1575 view_59" [id=1575, type=view]; +"1576 index_11" [id=1576, type=index]; +"1577 view_60" [id=1577, type=view]; +"1578 permute_50" [id=1578, type=permute]; +"1579 contiguous_20" [id=1579, type=contiguous]; +"1580 unsqueeze_31" [id=1580, type=unsqueeze]; +"1581 sigmoid_11" [id=1581, type=sigmoid]; +"1582 mul_22" [id=1582, type=mul]; +"1583 pad_13" [id=1583, type=pad]; +"1584 roll_10" [id=1584, type=roll]; +"1585 view_61" [id=1585, type=view]; +"1586 permute_51" [id=1586, type=permute]; +"1587 reshape_49" [id=1587, type=reshape]; +"1588 clone_11" [id=1588, type=clone]; +"1589 reshape_49_0_0_nncf_smooth_quant_0" [id=1589, type=call_module]; +"1590 quantize_per_tensor_default_69" [id=1590, type=quantize_per_tensor]; +"1591 dequantize_per_tensor_default_69" [id=1591, type=dequantize_per_tensor]; +"1592 linear_70_scale_0" [id=1592, type=get_attr]; +"1593 linear_70_zero_point_0" [id=1593, type=get_attr]; +"1594 _frozen_param71" [id=1594, type=get_attr]; +"1595 dequantize_per_channel_default_71" [id=1595, type=dequantize_per_channel]; +"1596 linear_70" [id=1596, type=linear]; +"1597 reshape_50" [id=1597, type=reshape]; +"1598 permute_52" [id=1598, type=permute]; +"1599 select_33" [id=1599, type=select]; +"1600 select_34" [id=1600, type=select]; +"1601 select_35" [id=1601, type=select]; +"1602 linalg_vector_norm_22" [id=1602, type=linalg_vector_norm]; +"1603 clamp_min_22" [id=1603, type=clamp_min]; +"1604 expand_as_22" [id=1604, type=expand_as]; +"1605 div_22" [id=1605, type=div]; +"1606 quantize_per_tensor_default_70" [id=1606, type=quantize_per_tensor]; +"1607 dequantize_per_tensor_default_70" [id=1607, type=dequantize_per_tensor]; +"1608 linalg_vector_norm_23" [id=1608, type=linalg_vector_norm]; +"1609 clamp_min_23" [id=1609, type=clamp_min]; +"1610 expand_as_23" [id=1610, type=expand_as]; +"1611 div_23" [id=1611, type=div]; +"1612 quantize_per_tensor_default_71" [id=1612, type=quantize_per_tensor]; +"1613 dequantize_per_tensor_default_71" [id=1613, type=dequantize_per_tensor]; +"1614 transpose_22" [id=1614, type=transpose]; +"1615 matmul_22" [id=1615, type=matmul]; +"1616 clamp_11" [id=1616, type=clamp]; +"1617 exp_11" [id=1617, type=exp]; +"1618 mul_23" [id=1618, type=mul]; +"1619 add_38" [id=1619, type=add]; +"1620 new_zeros_5" [id=1620, type=new_zeros]; +"1621 view_62" [id=1621, type=view]; +"1622 permute_53" [id=1622, type=permute]; +"1623 reshape_51" [id=1623, type=reshape]; +"1624 unsqueeze_32" [id=1624, type=unsqueeze]; +"1625 unsqueeze_33" [id=1625, type=unsqueeze]; +"1626 sub_5" [id=1626, type=sub]; +"1627 ne_5" [id=1627, type=ne]; +"1628 masked_fill_10" [id=1628, type=masked_fill]; +"1629 eq_5" [id=1629, type=eq]; +"1630 masked_fill_11" [id=1630, type=masked_fill]; +"1631 view_63" [id=1631, type=view]; +"1632 unsqueeze_34" [id=1632, type=unsqueeze]; +"1633 unsqueeze_35" [id=1633, type=unsqueeze]; +"1634 add_39" [id=1634, type=add]; +"1635 view_64" [id=1635, type=view]; +"1636 softmax_11" [id=1636, type=softmax]; +"1637 dropout_44" [id=1637, type=dropout]; +"1638 matmul_23" [id=1638, type=matmul]; +"1639 transpose_23" [id=1639, type=transpose]; +"1640 reshape_52" [id=1640, type=reshape]; +"1641 reshape_52_0_0_nncf_smooth_quant_0" [id=1641, type=call_module]; +"1642 quantize_per_tensor_default_72" [id=1642, type=quantize_per_tensor]; +"1643 dequantize_per_tensor_default_72" [id=1643, type=dequantize_per_tensor]; +"1644 linear_71_scale_0" [id=1644, type=get_attr]; +"1645 linear_71_zero_point_0" [id=1645, type=get_attr]; +"1646 _frozen_param72" [id=1646, type=get_attr]; +"1647 dequantize_per_channel_default_72" [id=1647, type=dequantize_per_channel]; +"1648 linear_71" [id=1648, type=linear]; +"1649 dropout_45" [id=1649, type=dropout]; +"1650 view_65" [id=1650, type=view]; +"1651 permute_54" [id=1651, type=permute]; +"1652 reshape_53" [id=1652, type=reshape]; +"1653 roll_11" [id=1653, type=roll]; +"1654 slice_185" [id=1654, type=slice]; +"1655 slice_186" [id=1655, type=slice]; +"1656 slice_187" [id=1656, type=slice]; +"1657 slice_188" [id=1657, type=slice]; +"1658 contiguous_21" [id=1658, type=contiguous]; +"1659 layer_norm_25" [id=1659, type=layer_norm]; +"1660 add_40" [id=1660, type=add]; +"1661 add_40_0_0_nncf_smooth_quant_0" [id=1661, type=call_module]; +"1662 quantize_per_tensor_default_73" [id=1662, type=quantize_per_tensor]; +"1663 dequantize_per_tensor_default_73" [id=1663, type=dequantize_per_tensor]; +"1664 linear_72_scale_0" [id=1664, type=get_attr]; +"1665 linear_72_zero_point_0" [id=1665, type=get_attr]; +"1666 _frozen_param73" [id=1666, type=get_attr]; +"1667 dequantize_per_channel_default_73" [id=1667, type=dequantize_per_channel]; +"1668 linear_72" [id=1668, type=linear]; +"1669 gelu_11" [id=1669, type=gelu]; +"1670 dropout_46" [id=1670, type=dropout]; +"1671 dropout_46_0_0_nncf_smooth_quant_0" [id=1671, type=call_module]; +"1672 quantize_per_tensor_default_74" [id=1672, type=quantize_per_tensor]; +"1673 dequantize_per_tensor_default_74" [id=1673, type=dequantize_per_tensor]; +"1674 linear_73_scale_0" [id=1674, type=get_attr]; +"1675 linear_73_zero_point_0" [id=1675, type=get_attr]; +"1676 _frozen_param74" [id=1676, type=get_attr]; +"1677 dequantize_per_channel_default_74" [id=1677, type=dequantize_per_channel]; +"1678 linear_73" [id=1678, type=linear]; +"1679 dropout_47" [id=1679, type=dropout]; +"1680 layer_norm_26" [id=1680, type=layer_norm]; +"1681 add_41" [id=1681, type=add]; +"1682 features_5_8_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [id=1682, type=call_module]; +"1683 linear_74_scale_0" [id=1683, type=get_attr]; +"1684 linear_74_zero_point_0" [id=1684, type=get_attr]; +"1685 _frozen_param75" [id=1685, type=get_attr]; +"1686 dequantize_per_channel_default_75" [id=1686, type=dequantize_per_channel]; +"1687 linear_74" [id=1687, type=linear]; +"1688 relu__12" [id=1688, type=relu_]; +"1689 relu__12_0_0_nncf_smooth_quant_0" [id=1689, type=call_module]; +"1690 linear_75_scale_0" [id=1690, type=get_attr]; +"1691 linear_75_zero_point_0" [id=1691, type=get_attr]; +"1692 _frozen_param76" [id=1692, type=get_attr]; +"1693 dequantize_per_channel_default_76" [id=1693, type=dequantize_per_channel]; +"1694 linear_75" [id=1694, type=linear]; +"1695 view_66" [id=1695, type=view]; +"1696 index_12" [id=1696, type=index]; +"1697 view_67" [id=1697, type=view]; +"1698 permute_55" [id=1698, type=permute]; +"1699 contiguous_22" [id=1699, type=contiguous]; +"1700 unsqueeze_36" [id=1700, type=unsqueeze]; +"1701 sigmoid_12" [id=1701, type=sigmoid]; +"1702 mul_24" [id=1702, type=mul]; +"1703 pad_14" [id=1703, type=pad]; +"1704 view_68" [id=1704, type=view]; +"1705 permute_56" [id=1705, type=permute]; +"1706 reshape_54" [id=1706, type=reshape]; +"1707 clone_12" [id=1707, type=clone]; +"1708 reshape_54_0_0_nncf_smooth_quant_0" [id=1708, type=call_module]; +"1709 quantize_per_tensor_default_75" [id=1709, type=quantize_per_tensor]; +"1710 dequantize_per_tensor_default_75" [id=1710, type=dequantize_per_tensor]; +"1711 linear_76_scale_0" [id=1711, type=get_attr]; +"1712 linear_76_zero_point_0" [id=1712, type=get_attr]; +"1713 _frozen_param77" [id=1713, type=get_attr]; +"1714 dequantize_per_channel_default_77" [id=1714, type=dequantize_per_channel]; +"1715 linear_76" [id=1715, type=linear]; +"1716 reshape_55" [id=1716, type=reshape]; +"1717 permute_57" [id=1717, type=permute]; +"1718 select_36" [id=1718, type=select]; +"1719 select_37" [id=1719, type=select]; +"1720 select_38" [id=1720, type=select]; +"1721 linalg_vector_norm_24" [id=1721, type=linalg_vector_norm]; +"1722 clamp_min_24" [id=1722, type=clamp_min]; +"1723 expand_as_24" [id=1723, type=expand_as]; +"1724 div_24" [id=1724, type=div]; +"1725 quantize_per_tensor_default_76" [id=1725, type=quantize_per_tensor]; +"1726 dequantize_per_tensor_default_76" [id=1726, type=dequantize_per_tensor]; +"1727 linalg_vector_norm_25" [id=1727, type=linalg_vector_norm]; +"1728 clamp_min_25" [id=1728, type=clamp_min]; +"1729 expand_as_25" [id=1729, type=expand_as]; +"1730 div_25" [id=1730, type=div]; +"1731 quantize_per_tensor_default_77" [id=1731, type=quantize_per_tensor]; +"1732 dequantize_per_tensor_default_77" [id=1732, type=dequantize_per_tensor]; +"1733 transpose_24" [id=1733, type=transpose]; +"1734 matmul_24" [id=1734, type=matmul]; +"1735 clamp_12" [id=1735, type=clamp]; +"1736 exp_12" [id=1736, type=exp]; +"1737 mul_25" [id=1737, type=mul]; +"1738 add_42" [id=1738, type=add]; +"1739 softmax_12" [id=1739, type=softmax]; +"1740 dropout_48" [id=1740, type=dropout]; +"1741 matmul_25" [id=1741, type=matmul]; +"1742 transpose_25" [id=1742, type=transpose]; +"1743 reshape_56" [id=1743, type=reshape]; +"1744 reshape_56_0_0_nncf_smooth_quant_0" [id=1744, type=call_module]; +"1745 quantize_per_tensor_default_78" [id=1745, type=quantize_per_tensor]; +"1746 dequantize_per_tensor_default_78" [id=1746, type=dequantize_per_tensor]; +"1747 linear_77_scale_0" [id=1747, type=get_attr]; +"1748 linear_77_zero_point_0" [id=1748, type=get_attr]; +"1749 _frozen_param78" [id=1749, type=get_attr]; +"1750 dequantize_per_channel_default_78" [id=1750, type=dequantize_per_channel]; +"1751 linear_77" [id=1751, type=linear]; +"1752 dropout_49" [id=1752, type=dropout]; +"1753 view_69" [id=1753, type=view]; +"1754 permute_58" [id=1754, type=permute]; +"1755 reshape_57" [id=1755, type=reshape]; +"1756 slice_190" [id=1756, type=slice]; +"1757 slice_191" [id=1757, type=slice]; +"1758 slice_192" [id=1758, type=slice]; +"1759 slice_193" [id=1759, type=slice]; +"1760 contiguous_23" [id=1760, type=contiguous]; +"1761 layer_norm_27" [id=1761, type=layer_norm]; +"1762 add_43" [id=1762, type=add]; +"1763 add_43_0_0_nncf_smooth_quant_0" [id=1763, type=call_module]; +"1764 quantize_per_tensor_default_79" [id=1764, type=quantize_per_tensor]; +"1765 dequantize_per_tensor_default_79" [id=1765, type=dequantize_per_tensor]; +"1766 linear_78_scale_0" [id=1766, type=get_attr]; +"1767 linear_78_zero_point_0" [id=1767, type=get_attr]; +"1768 _frozen_param79" [id=1768, type=get_attr]; +"1769 dequantize_per_channel_default_79" [id=1769, type=dequantize_per_channel]; +"1770 linear_78" [id=1770, type=linear]; +"1771 gelu_12" [id=1771, type=gelu]; +"1772 dropout_50" [id=1772, type=dropout]; +"1773 dropout_50_0_0_nncf_smooth_quant_0" [id=1773, type=call_module]; +"1774 quantize_per_tensor_default_80" [id=1774, type=quantize_per_tensor]; +"1775 dequantize_per_tensor_default_80" [id=1775, type=dequantize_per_tensor]; +"1776 linear_79_scale_0" [id=1776, type=get_attr]; +"1777 linear_79_zero_point_0" [id=1777, type=get_attr]; +"1778 _frozen_param80" [id=1778, type=get_attr]; +"1779 dequantize_per_channel_default_80" [id=1779, type=dequantize_per_channel]; +"1780 linear_79" [id=1780, type=linear]; +"1781 dropout_51" [id=1781, type=dropout]; +"1782 layer_norm_28" [id=1782, type=layer_norm]; +"1783 add_44" [id=1783, type=add]; +"1784 features_5_9_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [id=1784, type=call_module]; +"1785 linear_80_scale_0" [id=1785, type=get_attr]; +"1786 linear_80_zero_point_0" [id=1786, type=get_attr]; +"1787 _frozen_param81" [id=1787, type=get_attr]; +"1788 dequantize_per_channel_default_81" [id=1788, type=dequantize_per_channel]; +"1789 linear_80" [id=1789, type=linear]; +"1790 relu__13" [id=1790, type=relu_]; +"1791 relu__13_0_0_nncf_smooth_quant_0" [id=1791, type=call_module]; +"1792 linear_81_scale_0" [id=1792, type=get_attr]; +"1793 linear_81_zero_point_0" [id=1793, type=get_attr]; +"1794 _frozen_param82" [id=1794, type=get_attr]; +"1795 dequantize_per_channel_default_82" [id=1795, type=dequantize_per_channel]; +"1796 linear_81" [id=1796, type=linear]; +"1797 view_70" [id=1797, type=view]; +"1798 index_13" [id=1798, type=index]; +"1799 view_71" [id=1799, type=view]; +"1800 permute_59" [id=1800, type=permute]; +"1801 contiguous_24" [id=1801, type=contiguous]; +"1802 unsqueeze_37" [id=1802, type=unsqueeze]; +"1803 sigmoid_13" [id=1803, type=sigmoid]; +"1804 mul_26" [id=1804, type=mul]; +"1805 pad_15" [id=1805, type=pad]; +"1806 roll_12" [id=1806, type=roll]; +"1807 view_72" [id=1807, type=view]; +"1808 permute_60" [id=1808, type=permute]; +"1809 reshape_58" [id=1809, type=reshape]; +"1810 clone_13" [id=1810, type=clone]; +"1811 reshape_58_0_0_nncf_smooth_quant_0" [id=1811, type=call_module]; +"1812 quantize_per_tensor_default_81" [id=1812, type=quantize_per_tensor]; +"1813 dequantize_per_tensor_default_81" [id=1813, type=dequantize_per_tensor]; +"1814 linear_82_scale_0" [id=1814, type=get_attr]; +"1815 linear_82_zero_point_0" [id=1815, type=get_attr]; +"1816 _frozen_param83" [id=1816, type=get_attr]; +"1817 dequantize_per_channel_default_83" [id=1817, type=dequantize_per_channel]; +"1818 linear_82" [id=1818, type=linear]; +"1819 reshape_59" [id=1819, type=reshape]; +"1820 permute_61" [id=1820, type=permute]; +"1821 select_39" [id=1821, type=select]; +"1822 select_40" [id=1822, type=select]; +"1823 select_41" [id=1823, type=select]; +"1824 linalg_vector_norm_26" [id=1824, type=linalg_vector_norm]; +"1825 clamp_min_26" [id=1825, type=clamp_min]; +"1826 expand_as_26" [id=1826, type=expand_as]; +"1827 div_26" [id=1827, type=div]; +"1828 quantize_per_tensor_default_82" [id=1828, type=quantize_per_tensor]; +"1829 dequantize_per_tensor_default_82" [id=1829, type=dequantize_per_tensor]; +"1830 linalg_vector_norm_27" [id=1830, type=linalg_vector_norm]; +"1831 clamp_min_27" [id=1831, type=clamp_min]; +"1832 expand_as_27" [id=1832, type=expand_as]; +"1833 div_27" [id=1833, type=div]; +"1834 quantize_per_tensor_default_83" [id=1834, type=quantize_per_tensor]; +"1835 dequantize_per_tensor_default_83" [id=1835, type=dequantize_per_tensor]; +"1836 transpose_26" [id=1836, type=transpose]; +"1837 matmul_26" [id=1837, type=matmul]; +"1838 clamp_13" [id=1838, type=clamp]; +"1839 exp_13" [id=1839, type=exp]; +"1840 mul_27" [id=1840, type=mul]; +"1841 add_45" [id=1841, type=add]; +"1842 new_zeros_6" [id=1842, type=new_zeros]; +"1843 view_73" [id=1843, type=view]; +"1844 permute_62" [id=1844, type=permute]; +"1845 reshape_60" [id=1845, type=reshape]; +"1846 unsqueeze_38" [id=1846, type=unsqueeze]; +"1847 unsqueeze_39" [id=1847, type=unsqueeze]; +"1848 sub_6" [id=1848, type=sub]; +"1849 ne_6" [id=1849, type=ne]; +"1850 masked_fill_12" [id=1850, type=masked_fill]; +"1851 eq_6" [id=1851, type=eq]; +"1852 masked_fill_13" [id=1852, type=masked_fill]; +"1853 view_74" [id=1853, type=view]; +"1854 unsqueeze_40" [id=1854, type=unsqueeze]; +"1855 unsqueeze_41" [id=1855, type=unsqueeze]; +"1856 add_46" [id=1856, type=add]; +"1857 view_75" [id=1857, type=view]; +"1858 softmax_13" [id=1858, type=softmax]; +"1859 dropout_52" [id=1859, type=dropout]; +"1860 matmul_27" [id=1860, type=matmul]; +"1861 transpose_27" [id=1861, type=transpose]; +"1862 reshape_61" [id=1862, type=reshape]; +"1863 reshape_61_0_0_nncf_smooth_quant_0" [id=1863, type=call_module]; +"1864 quantize_per_tensor_default_84" [id=1864, type=quantize_per_tensor]; +"1865 dequantize_per_tensor_default_84" [id=1865, type=dequantize_per_tensor]; +"1866 linear_83_scale_0" [id=1866, type=get_attr]; +"1867 linear_83_zero_point_0" [id=1867, type=get_attr]; +"1868 _frozen_param84" [id=1868, type=get_attr]; +"1869 dequantize_per_channel_default_84" [id=1869, type=dequantize_per_channel]; +"1870 linear_83" [id=1870, type=linear]; +"1871 dropout_53" [id=1871, type=dropout]; +"1872 view_76" [id=1872, type=view]; +"1873 permute_63" [id=1873, type=permute]; +"1874 reshape_62" [id=1874, type=reshape]; +"1875 roll_13" [id=1875, type=roll]; +"1876 slice_213" [id=1876, type=slice]; +"1877 slice_214" [id=1877, type=slice]; +"1878 slice_215" [id=1878, type=slice]; +"1879 slice_216" [id=1879, type=slice]; +"1880 contiguous_25" [id=1880, type=contiguous]; +"1881 layer_norm_29" [id=1881, type=layer_norm]; +"1882 add_47" [id=1882, type=add]; +"1883 add_47_0_0_nncf_smooth_quant_0" [id=1883, type=call_module]; +"1884 quantize_per_tensor_default_85" [id=1884, type=quantize_per_tensor]; +"1885 dequantize_per_tensor_default_85" [id=1885, type=dequantize_per_tensor]; +"1886 linear_84_scale_0" [id=1886, type=get_attr]; +"1887 linear_84_zero_point_0" [id=1887, type=get_attr]; +"1888 _frozen_param85" [id=1888, type=get_attr]; +"1889 dequantize_per_channel_default_85" [id=1889, type=dequantize_per_channel]; +"1890 linear_84" [id=1890, type=linear]; +"1891 gelu_13" [id=1891, type=gelu]; +"1892 dropout_54" [id=1892, type=dropout]; +"1893 dropout_54_0_0_nncf_smooth_quant_0" [id=1893, type=call_module]; +"1894 quantize_per_tensor_default_86" [id=1894, type=quantize_per_tensor]; +"1895 dequantize_per_tensor_default_86" [id=1895, type=dequantize_per_tensor]; +"1896 linear_85_scale_0" [id=1896, type=get_attr]; +"1897 linear_85_zero_point_0" [id=1897, type=get_attr]; +"1898 _frozen_param86" [id=1898, type=get_attr]; +"1899 dequantize_per_channel_default_86" [id=1899, type=dequantize_per_channel]; +"1900 linear_85" [id=1900, type=linear]; +"1901 dropout_55" [id=1901, type=dropout]; +"1902 layer_norm_30" [id=1902, type=layer_norm]; +"1903 add_48" [id=1903, type=add]; +"1904 features_5_10_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [id=1904, type=call_module]; +"1905 linear_86_scale_0" [id=1905, type=get_attr]; +"1906 linear_86_zero_point_0" [id=1906, type=get_attr]; +"1907 _frozen_param87" [id=1907, type=get_attr]; +"1908 dequantize_per_channel_default_87" [id=1908, type=dequantize_per_channel]; +"1909 linear_86" [id=1909, type=linear]; +"1910 relu__14" [id=1910, type=relu_]; +"1911 relu__14_0_0_nncf_smooth_quant_0" [id=1911, type=call_module]; +"1912 linear_87_scale_0" [id=1912, type=get_attr]; +"1913 linear_87_zero_point_0" [id=1913, type=get_attr]; +"1914 _frozen_param88" [id=1914, type=get_attr]; +"1915 dequantize_per_channel_default_88" [id=1915, type=dequantize_per_channel]; +"1916 linear_87" [id=1916, type=linear]; +"1917 view_77" [id=1917, type=view]; +"1918 index_14" [id=1918, type=index]; +"1919 view_78" [id=1919, type=view]; +"1920 permute_64" [id=1920, type=permute]; +"1921 contiguous_26" [id=1921, type=contiguous]; +"1922 unsqueeze_42" [id=1922, type=unsqueeze]; +"1923 sigmoid_14" [id=1923, type=sigmoid]; +"1924 mul_28" [id=1924, type=mul]; +"1925 pad_16" [id=1925, type=pad]; +"1926 view_79" [id=1926, type=view]; +"1927 permute_65" [id=1927, type=permute]; +"1928 reshape_63" [id=1928, type=reshape]; +"1929 clone_14" [id=1929, type=clone]; +"1930 reshape_63_0_0_nncf_smooth_quant_0" [id=1930, type=call_module]; +"1931 quantize_per_tensor_default_87" [id=1931, type=quantize_per_tensor]; +"1932 dequantize_per_tensor_default_87" [id=1932, type=dequantize_per_tensor]; +"1933 linear_88_scale_0" [id=1933, type=get_attr]; +"1934 linear_88_zero_point_0" [id=1934, type=get_attr]; +"1935 _frozen_param89" [id=1935, type=get_attr]; +"1936 dequantize_per_channel_default_89" [id=1936, type=dequantize_per_channel]; +"1937 linear_88" [id=1937, type=linear]; +"1938 reshape_64" [id=1938, type=reshape]; +"1939 permute_66" [id=1939, type=permute]; +"1940 select_42" [id=1940, type=select]; +"1941 select_43" [id=1941, type=select]; +"1942 select_44" [id=1942, type=select]; +"1943 linalg_vector_norm_28" [id=1943, type=linalg_vector_norm]; +"1944 clamp_min_28" [id=1944, type=clamp_min]; +"1945 expand_as_28" [id=1945, type=expand_as]; +"1946 div_28" [id=1946, type=div]; +"1947 quantize_per_tensor_default_88" [id=1947, type=quantize_per_tensor]; +"1948 dequantize_per_tensor_default_88" [id=1948, type=dequantize_per_tensor]; +"1949 linalg_vector_norm_29" [id=1949, type=linalg_vector_norm]; +"1950 clamp_min_29" [id=1950, type=clamp_min]; +"1951 expand_as_29" [id=1951, type=expand_as]; +"1952 div_29" [id=1952, type=div]; +"1953 quantize_per_tensor_default_89" [id=1953, type=quantize_per_tensor]; +"1954 dequantize_per_tensor_default_89" [id=1954, type=dequantize_per_tensor]; +"1955 transpose_28" [id=1955, type=transpose]; +"1956 matmul_28" [id=1956, type=matmul]; +"1957 clamp_14" [id=1957, type=clamp]; +"1958 exp_14" [id=1958, type=exp]; +"1959 mul_29" [id=1959, type=mul]; +"1960 add_49" [id=1960, type=add]; +"1961 softmax_14" [id=1961, type=softmax]; +"1962 dropout_56" [id=1962, type=dropout]; +"1963 matmul_29" [id=1963, type=matmul]; +"1964 transpose_29" [id=1964, type=transpose]; +"1965 reshape_65" [id=1965, type=reshape]; +"1966 reshape_65_0_0_nncf_smooth_quant_0" [id=1966, type=call_module]; +"1967 quantize_per_tensor_default_90" [id=1967, type=quantize_per_tensor]; +"1968 dequantize_per_tensor_default_90" [id=1968, type=dequantize_per_tensor]; +"1969 linear_89_scale_0" [id=1969, type=get_attr]; +"1970 linear_89_zero_point_0" [id=1970, type=get_attr]; +"1971 _frozen_param90" [id=1971, type=get_attr]; +"1972 dequantize_per_channel_default_90" [id=1972, type=dequantize_per_channel]; +"1973 linear_89" [id=1973, type=linear]; +"1974 dropout_57" [id=1974, type=dropout]; +"1975 view_80" [id=1975, type=view]; +"1976 permute_67" [id=1976, type=permute]; +"1977 reshape_66" [id=1977, type=reshape]; +"1978 slice_218" [id=1978, type=slice]; +"1979 slice_219" [id=1979, type=slice]; +"1980 slice_220" [id=1980, type=slice]; +"1981 slice_221" [id=1981, type=slice]; +"1982 contiguous_27" [id=1982, type=contiguous]; +"1983 layer_norm_31" [id=1983, type=layer_norm]; +"1984 add_50" [id=1984, type=add]; +"1985 add_50_0_0_nncf_smooth_quant_0" [id=1985, type=call_module]; +"1986 quantize_per_tensor_default_91" [id=1986, type=quantize_per_tensor]; +"1987 dequantize_per_tensor_default_91" [id=1987, type=dequantize_per_tensor]; +"1988 linear_90_scale_0" [id=1988, type=get_attr]; +"1989 linear_90_zero_point_0" [id=1989, type=get_attr]; +"1990 _frozen_param91" [id=1990, type=get_attr]; +"1991 dequantize_per_channel_default_91" [id=1991, type=dequantize_per_channel]; +"1992 linear_90" [id=1992, type=linear]; +"1993 gelu_14" [id=1993, type=gelu]; +"1994 dropout_58" [id=1994, type=dropout]; +"1995 dropout_58_0_0_nncf_smooth_quant_0" [id=1995, type=call_module]; +"1996 quantize_per_tensor_default_92" [id=1996, type=quantize_per_tensor]; +"1997 dequantize_per_tensor_default_92" [id=1997, type=dequantize_per_tensor]; +"1998 linear_91_scale_0" [id=1998, type=get_attr]; +"1999 linear_91_zero_point_0" [id=1999, type=get_attr]; +"2000 _frozen_param92" [id=2000, type=get_attr]; +"2001 dequantize_per_channel_default_92" [id=2001, type=dequantize_per_channel]; +"2002 linear_91" [id=2002, type=linear]; +"2003 dropout_59" [id=2003, type=dropout]; +"2004 layer_norm_32" [id=2004, type=layer_norm]; +"2005 add_51" [id=2005, type=add]; +"2006 features_5_11_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [id=2006, type=call_module]; +"2007 linear_92_scale_0" [id=2007, type=get_attr]; +"2008 linear_92_zero_point_0" [id=2008, type=get_attr]; +"2009 _frozen_param93" [id=2009, type=get_attr]; +"2010 dequantize_per_channel_default_93" [id=2010, type=dequantize_per_channel]; +"2011 linear_92" [id=2011, type=linear]; +"2012 relu__15" [id=2012, type=relu_]; +"2013 relu__15_0_0_nncf_smooth_quant_0" [id=2013, type=call_module]; +"2014 linear_93_scale_0" [id=2014, type=get_attr]; +"2015 linear_93_zero_point_0" [id=2015, type=get_attr]; +"2016 _frozen_param94" [id=2016, type=get_attr]; +"2017 dequantize_per_channel_default_94" [id=2017, type=dequantize_per_channel]; +"2018 linear_93" [id=2018, type=linear]; +"2019 view_81" [id=2019, type=view]; +"2020 index_15" [id=2020, type=index]; +"2021 view_82" [id=2021, type=view]; +"2022 permute_68" [id=2022, type=permute]; +"2023 contiguous_28" [id=2023, type=contiguous]; +"2024 unsqueeze_43" [id=2024, type=unsqueeze]; +"2025 sigmoid_15" [id=2025, type=sigmoid]; +"2026 mul_30" [id=2026, type=mul]; +"2027 pad_17" [id=2027, type=pad]; +"2028 roll_14" [id=2028, type=roll]; +"2029 view_83" [id=2029, type=view]; +"2030 permute_69" [id=2030, type=permute]; +"2031 reshape_67" [id=2031, type=reshape]; +"2032 clone_15" [id=2032, type=clone]; +"2033 reshape_67_0_0_nncf_smooth_quant_0" [id=2033, type=call_module]; +"2034 quantize_per_tensor_default_93" [id=2034, type=quantize_per_tensor]; +"2035 dequantize_per_tensor_default_93" [id=2035, type=dequantize_per_tensor]; +"2036 linear_94_scale_0" [id=2036, type=get_attr]; +"2037 linear_94_zero_point_0" [id=2037, type=get_attr]; +"2038 _frozen_param95" [id=2038, type=get_attr]; +"2039 dequantize_per_channel_default_95" [id=2039, type=dequantize_per_channel]; +"2040 linear_94" [id=2040, type=linear]; +"2041 reshape_68" [id=2041, type=reshape]; +"2042 permute_70" [id=2042, type=permute]; +"2043 select_45" [id=2043, type=select]; +"2044 select_46" [id=2044, type=select]; +"2045 select_47" [id=2045, type=select]; +"2046 linalg_vector_norm_30" [id=2046, type=linalg_vector_norm]; +"2047 clamp_min_30" [id=2047, type=clamp_min]; +"2048 expand_as_30" [id=2048, type=expand_as]; +"2049 div_30" [id=2049, type=div]; +"2050 quantize_per_tensor_default_94" [id=2050, type=quantize_per_tensor]; +"2051 dequantize_per_tensor_default_94" [id=2051, type=dequantize_per_tensor]; +"2052 linalg_vector_norm_31" [id=2052, type=linalg_vector_norm]; +"2053 clamp_min_31" [id=2053, type=clamp_min]; +"2054 expand_as_31" [id=2054, type=expand_as]; +"2055 div_31" [id=2055, type=div]; +"2056 quantize_per_tensor_default_95" [id=2056, type=quantize_per_tensor]; +"2057 dequantize_per_tensor_default_95" [id=2057, type=dequantize_per_tensor]; +"2058 transpose_30" [id=2058, type=transpose]; +"2059 matmul_30" [id=2059, type=matmul]; +"2060 clamp_15" [id=2060, type=clamp]; +"2061 exp_15" [id=2061, type=exp]; +"2062 mul_31" [id=2062, type=mul]; +"2063 add_52" [id=2063, type=add]; +"2064 new_zeros_7" [id=2064, type=new_zeros]; +"2065 view_84" [id=2065, type=view]; +"2066 permute_71" [id=2066, type=permute]; +"2067 reshape_69" [id=2067, type=reshape]; +"2068 unsqueeze_44" [id=2068, type=unsqueeze]; +"2069 unsqueeze_45" [id=2069, type=unsqueeze]; +"2070 sub_7" [id=2070, type=sub]; +"2071 ne_7" [id=2071, type=ne]; +"2072 masked_fill_14" [id=2072, type=masked_fill]; +"2073 eq_7" [id=2073, type=eq]; +"2074 masked_fill_15" [id=2074, type=masked_fill]; +"2075 view_85" [id=2075, type=view]; +"2076 unsqueeze_46" [id=2076, type=unsqueeze]; +"2077 unsqueeze_47" [id=2077, type=unsqueeze]; +"2078 add_53" [id=2078, type=add]; +"2079 view_86" [id=2079, type=view]; +"2080 softmax_15" [id=2080, type=softmax]; +"2081 dropout_60" [id=2081, type=dropout]; +"2082 matmul_31" [id=2082, type=matmul]; +"2083 transpose_31" [id=2083, type=transpose]; +"2084 reshape_70" [id=2084, type=reshape]; +"2085 reshape_70_0_0_nncf_smooth_quant_0" [id=2085, type=call_module]; +"2086 quantize_per_tensor_default_96" [id=2086, type=quantize_per_tensor]; +"2087 dequantize_per_tensor_default_96" [id=2087, type=dequantize_per_tensor]; +"2088 linear_95_scale_0" [id=2088, type=get_attr]; +"2089 linear_95_zero_point_0" [id=2089, type=get_attr]; +"2090 _frozen_param96" [id=2090, type=get_attr]; +"2091 dequantize_per_channel_default_96" [id=2091, type=dequantize_per_channel]; +"2092 linear_95" [id=2092, type=linear]; +"2093 dropout_61" [id=2093, type=dropout]; +"2094 view_87" [id=2094, type=view]; +"2095 permute_72" [id=2095, type=permute]; +"2096 reshape_71" [id=2096, type=reshape]; +"2097 roll_15" [id=2097, type=roll]; +"2098 slice_241" [id=2098, type=slice]; +"2099 slice_242" [id=2099, type=slice]; +"2100 slice_243" [id=2100, type=slice]; +"2101 slice_244" [id=2101, type=slice]; +"2102 contiguous_29" [id=2102, type=contiguous]; +"2103 layer_norm_33" [id=2103, type=layer_norm]; +"2104 add_54" [id=2104, type=add]; +"2105 add_54_0_0_nncf_smooth_quant_0" [id=2105, type=call_module]; +"2106 quantize_per_tensor_default_97" [id=2106, type=quantize_per_tensor]; +"2107 dequantize_per_tensor_default_97" [id=2107, type=dequantize_per_tensor]; +"2108 linear_96_scale_0" [id=2108, type=get_attr]; +"2109 linear_96_zero_point_0" [id=2109, type=get_attr]; +"2110 _frozen_param97" [id=2110, type=get_attr]; +"2111 dequantize_per_channel_default_97" [id=2111, type=dequantize_per_channel]; +"2112 linear_96" [id=2112, type=linear]; +"2113 gelu_15" [id=2113, type=gelu]; +"2114 dropout_62" [id=2114, type=dropout]; +"2115 dropout_62_0_0_nncf_smooth_quant_0" [id=2115, type=call_module]; +"2116 quantize_per_tensor_default_98" [id=2116, type=quantize_per_tensor]; +"2117 dequantize_per_tensor_default_98" [id=2117, type=dequantize_per_tensor]; +"2118 linear_97_scale_0" [id=2118, type=get_attr]; +"2119 linear_97_zero_point_0" [id=2119, type=get_attr]; +"2120 _frozen_param98" [id=2120, type=get_attr]; +"2121 dequantize_per_channel_default_98" [id=2121, type=dequantize_per_channel]; +"2122 linear_97" [id=2122, type=linear]; +"2123 dropout_63" [id=2123, type=dropout]; +"2124 layer_norm_34" [id=2124, type=layer_norm]; +"2125 add_55" [id=2125, type=add]; +"2126 features_5_12_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [id=2126, type=call_module]; +"2127 linear_98_scale_0" [id=2127, type=get_attr]; +"2128 linear_98_zero_point_0" [id=2128, type=get_attr]; +"2129 _frozen_param99" [id=2129, type=get_attr]; +"2130 dequantize_per_channel_default_99" [id=2130, type=dequantize_per_channel]; +"2131 linear_98" [id=2131, type=linear]; +"2132 relu__16" [id=2132, type=relu_]; +"2133 relu__16_0_0_nncf_smooth_quant_0" [id=2133, type=call_module]; +"2134 linear_99_scale_0" [id=2134, type=get_attr]; +"2135 linear_99_zero_point_0" [id=2135, type=get_attr]; +"2136 _frozen_param100" [id=2136, type=get_attr]; +"2137 dequantize_per_channel_default_100" [id=2137, type=dequantize_per_channel]; +"2138 linear_99" [id=2138, type=linear]; +"2139 view_88" [id=2139, type=view]; +"2140 index_16" [id=2140, type=index]; +"2141 view_89" [id=2141, type=view]; +"2142 permute_73" [id=2142, type=permute]; +"2143 contiguous_30" [id=2143, type=contiguous]; +"2144 unsqueeze_48" [id=2144, type=unsqueeze]; +"2145 sigmoid_16" [id=2145, type=sigmoid]; +"2146 mul_32" [id=2146, type=mul]; +"2147 pad_18" [id=2147, type=pad]; +"2148 view_90" [id=2148, type=view]; +"2149 permute_74" [id=2149, type=permute]; +"2150 reshape_72" [id=2150, type=reshape]; +"2151 clone_16" [id=2151, type=clone]; +"2152 reshape_72_0_0_nncf_smooth_quant_0" [id=2152, type=call_module]; +"2153 quantize_per_tensor_default_99" [id=2153, type=quantize_per_tensor]; +"2154 dequantize_per_tensor_default_99" [id=2154, type=dequantize_per_tensor]; +"2155 linear_100_scale_0" [id=2155, type=get_attr]; +"2156 linear_100_zero_point_0" [id=2156, type=get_attr]; +"2157 _frozen_param101" [id=2157, type=get_attr]; +"2158 dequantize_per_channel_default_101" [id=2158, type=dequantize_per_channel]; +"2159 linear_100" [id=2159, type=linear]; +"2160 reshape_73" [id=2160, type=reshape]; +"2161 permute_75" [id=2161, type=permute]; +"2162 select_48" [id=2162, type=select]; +"2163 select_49" [id=2163, type=select]; +"2164 select_50" [id=2164, type=select]; +"2165 linalg_vector_norm_32" [id=2165, type=linalg_vector_norm]; +"2166 clamp_min_32" [id=2166, type=clamp_min]; +"2167 expand_as_32" [id=2167, type=expand_as]; +"2168 div_32" [id=2168, type=div]; +"2169 quantize_per_tensor_default_100" [id=2169, type=quantize_per_tensor]; +"2170 dequantize_per_tensor_default_100" [id=2170, type=dequantize_per_tensor]; +"2171 linalg_vector_norm_33" [id=2171, type=linalg_vector_norm]; +"2172 clamp_min_33" [id=2172, type=clamp_min]; +"2173 expand_as_33" [id=2173, type=expand_as]; +"2174 div_33" [id=2174, type=div]; +"2175 quantize_per_tensor_default_101" [id=2175, type=quantize_per_tensor]; +"2176 dequantize_per_tensor_default_101" [id=2176, type=dequantize_per_tensor]; +"2177 transpose_32" [id=2177, type=transpose]; +"2178 matmul_32" [id=2178, type=matmul]; +"2179 clamp_16" [id=2179, type=clamp]; +"2180 exp_16" [id=2180, type=exp]; +"2181 mul_33" [id=2181, type=mul]; +"2182 add_56" [id=2182, type=add]; +"2183 softmax_16" [id=2183, type=softmax]; +"2184 dropout_64" [id=2184, type=dropout]; +"2185 matmul_33" [id=2185, type=matmul]; +"2186 transpose_33" [id=2186, type=transpose]; +"2187 reshape_74" [id=2187, type=reshape]; +"2188 reshape_74_0_0_nncf_smooth_quant_0" [id=2188, type=call_module]; +"2189 quantize_per_tensor_default_102" [id=2189, type=quantize_per_tensor]; +"2190 dequantize_per_tensor_default_102" [id=2190, type=dequantize_per_tensor]; +"2191 linear_101_scale_0" [id=2191, type=get_attr]; +"2192 linear_101_zero_point_0" [id=2192, type=get_attr]; +"2193 _frozen_param102" [id=2193, type=get_attr]; +"2194 dequantize_per_channel_default_102" [id=2194, type=dequantize_per_channel]; +"2195 linear_101" [id=2195, type=linear]; +"2196 dropout_65" [id=2196, type=dropout]; +"2197 view_91" [id=2197, type=view]; +"2198 permute_76" [id=2198, type=permute]; +"2199 reshape_75" [id=2199, type=reshape]; +"2200 slice_246" [id=2200, type=slice]; +"2201 slice_247" [id=2201, type=slice]; +"2202 slice_248" [id=2202, type=slice]; +"2203 slice_249" [id=2203, type=slice]; +"2204 contiguous_31" [id=2204, type=contiguous]; +"2205 layer_norm_35" [id=2205, type=layer_norm]; +"2206 add_57" [id=2206, type=add]; +"2207 add_57_0_0_nncf_smooth_quant_0" [id=2207, type=call_module]; +"2208 quantize_per_tensor_default_103" [id=2208, type=quantize_per_tensor]; +"2209 dequantize_per_tensor_default_103" [id=2209, type=dequantize_per_tensor]; +"2210 linear_102_scale_0" [id=2210, type=get_attr]; +"2211 linear_102_zero_point_0" [id=2211, type=get_attr]; +"2212 _frozen_param103" [id=2212, type=get_attr]; +"2213 dequantize_per_channel_default_103" [id=2213, type=dequantize_per_channel]; +"2214 linear_102" [id=2214, type=linear]; +"2215 gelu_16" [id=2215, type=gelu]; +"2216 dropout_66" [id=2216, type=dropout]; +"2217 dropout_66_0_0_nncf_smooth_quant_0" [id=2217, type=call_module]; +"2218 quantize_per_tensor_default_104" [id=2218, type=quantize_per_tensor]; +"2219 dequantize_per_tensor_default_104" [id=2219, type=dequantize_per_tensor]; +"2220 linear_103_scale_0" [id=2220, type=get_attr]; +"2221 linear_103_zero_point_0" [id=2221, type=get_attr]; +"2222 _frozen_param104" [id=2222, type=get_attr]; +"2223 dequantize_per_channel_default_104" [id=2223, type=dequantize_per_channel]; +"2224 linear_103" [id=2224, type=linear]; +"2225 dropout_67" [id=2225, type=dropout]; +"2226 layer_norm_36" [id=2226, type=layer_norm]; +"2227 add_58" [id=2227, type=add]; +"2228 features_5_13_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [id=2228, type=call_module]; +"2229 linear_104_scale_0" [id=2229, type=get_attr]; +"2230 linear_104_zero_point_0" [id=2230, type=get_attr]; +"2231 _frozen_param105" [id=2231, type=get_attr]; +"2232 dequantize_per_channel_default_105" [id=2232, type=dequantize_per_channel]; +"2233 linear_104" [id=2233, type=linear]; +"2234 relu__17" [id=2234, type=relu_]; +"2235 relu__17_0_0_nncf_smooth_quant_0" [id=2235, type=call_module]; +"2236 linear_105_scale_0" [id=2236, type=get_attr]; +"2237 linear_105_zero_point_0" [id=2237, type=get_attr]; +"2238 _frozen_param106" [id=2238, type=get_attr]; +"2239 dequantize_per_channel_default_106" [id=2239, type=dequantize_per_channel]; +"2240 linear_105" [id=2240, type=linear]; +"2241 view_92" [id=2241, type=view]; +"2242 index_17" [id=2242, type=index]; +"2243 view_93" [id=2243, type=view]; +"2244 permute_77" [id=2244, type=permute]; +"2245 contiguous_32" [id=2245, type=contiguous]; +"2246 unsqueeze_49" [id=2246, type=unsqueeze]; +"2247 sigmoid_17" [id=2247, type=sigmoid]; +"2248 mul_34" [id=2248, type=mul]; +"2249 pad_19" [id=2249, type=pad]; +"2250 roll_16" [id=2250, type=roll]; +"2251 view_94" [id=2251, type=view]; +"2252 permute_78" [id=2252, type=permute]; +"2253 reshape_76" [id=2253, type=reshape]; +"2254 clone_17" [id=2254, type=clone]; +"2255 reshape_76_0_0_nncf_smooth_quant_0" [id=2255, type=call_module]; +"2256 quantize_per_tensor_default_105" [id=2256, type=quantize_per_tensor]; +"2257 dequantize_per_tensor_default_105" [id=2257, type=dequantize_per_tensor]; +"2258 linear_106_scale_0" [id=2258, type=get_attr]; +"2259 linear_106_zero_point_0" [id=2259, type=get_attr]; +"2260 _frozen_param107" [id=2260, type=get_attr]; +"2261 dequantize_per_channel_default_107" [id=2261, type=dequantize_per_channel]; +"2262 linear_106" [id=2262, type=linear]; +"2263 reshape_77" [id=2263, type=reshape]; +"2264 permute_79" [id=2264, type=permute]; +"2265 select_51" [id=2265, type=select]; +"2266 select_52" [id=2266, type=select]; +"2267 select_53" [id=2267, type=select]; +"2268 linalg_vector_norm_34" [id=2268, type=linalg_vector_norm]; +"2269 clamp_min_34" [id=2269, type=clamp_min]; +"2270 expand_as_34" [id=2270, type=expand_as]; +"2271 div_34" [id=2271, type=div]; +"2272 quantize_per_tensor_default_106" [id=2272, type=quantize_per_tensor]; +"2273 dequantize_per_tensor_default_106" [id=2273, type=dequantize_per_tensor]; +"2274 linalg_vector_norm_35" [id=2274, type=linalg_vector_norm]; +"2275 clamp_min_35" [id=2275, type=clamp_min]; +"2276 expand_as_35" [id=2276, type=expand_as]; +"2277 div_35" [id=2277, type=div]; +"2278 quantize_per_tensor_default_107" [id=2278, type=quantize_per_tensor]; +"2279 dequantize_per_tensor_default_107" [id=2279, type=dequantize_per_tensor]; +"2280 transpose_34" [id=2280, type=transpose]; +"2281 matmul_34" [id=2281, type=matmul]; +"2282 clamp_17" [id=2282, type=clamp]; +"2283 exp_17" [id=2283, type=exp]; +"2284 mul_35" [id=2284, type=mul]; +"2285 add_59" [id=2285, type=add]; +"2286 new_zeros_8" [id=2286, type=new_zeros]; +"2287 view_95" [id=2287, type=view]; +"2288 permute_80" [id=2288, type=permute]; +"2289 reshape_78" [id=2289, type=reshape]; +"2290 unsqueeze_50" [id=2290, type=unsqueeze]; +"2291 unsqueeze_51" [id=2291, type=unsqueeze]; +"2292 sub_8" [id=2292, type=sub]; +"2293 ne_8" [id=2293, type=ne]; +"2294 masked_fill_16" [id=2294, type=masked_fill]; +"2295 eq_8" [id=2295, type=eq]; +"2296 masked_fill_17" [id=2296, type=masked_fill]; +"2297 view_96" [id=2297, type=view]; +"2298 unsqueeze_52" [id=2298, type=unsqueeze]; +"2299 unsqueeze_53" [id=2299, type=unsqueeze]; +"2300 add_60" [id=2300, type=add]; +"2301 view_97" [id=2301, type=view]; +"2302 softmax_17" [id=2302, type=softmax]; +"2303 dropout_68" [id=2303, type=dropout]; +"2304 matmul_35" [id=2304, type=matmul]; +"2305 transpose_35" [id=2305, type=transpose]; +"2306 reshape_79" [id=2306, type=reshape]; +"2307 reshape_79_0_0_nncf_smooth_quant_0" [id=2307, type=call_module]; +"2308 quantize_per_tensor_default_108" [id=2308, type=quantize_per_tensor]; +"2309 dequantize_per_tensor_default_108" [id=2309, type=dequantize_per_tensor]; +"2310 linear_107_scale_0" [id=2310, type=get_attr]; +"2311 linear_107_zero_point_0" [id=2311, type=get_attr]; +"2312 _frozen_param108" [id=2312, type=get_attr]; +"2313 dequantize_per_channel_default_108" [id=2313, type=dequantize_per_channel]; +"2314 linear_107" [id=2314, type=linear]; +"2315 dropout_69" [id=2315, type=dropout]; +"2316 view_98" [id=2316, type=view]; +"2317 permute_81" [id=2317, type=permute]; +"2318 reshape_80" [id=2318, type=reshape]; +"2319 roll_17" [id=2319, type=roll]; +"2320 slice_269" [id=2320, type=slice]; +"2321 slice_270" [id=2321, type=slice]; +"2322 slice_271" [id=2322, type=slice]; +"2323 slice_272" [id=2323, type=slice]; +"2324 contiguous_33" [id=2324, type=contiguous]; +"2325 layer_norm_37" [id=2325, type=layer_norm]; +"2326 add_61" [id=2326, type=add]; +"2327 add_61_0_0_nncf_smooth_quant_0" [id=2327, type=call_module]; +"2328 quantize_per_tensor_default_109" [id=2328, type=quantize_per_tensor]; +"2329 dequantize_per_tensor_default_109" [id=2329, type=dequantize_per_tensor]; +"2330 linear_108_scale_0" [id=2330, type=get_attr]; +"2331 linear_108_zero_point_0" [id=2331, type=get_attr]; +"2332 _frozen_param109" [id=2332, type=get_attr]; +"2333 dequantize_per_channel_default_109" [id=2333, type=dequantize_per_channel]; +"2334 linear_108" [id=2334, type=linear]; +"2335 gelu_17" [id=2335, type=gelu]; +"2336 dropout_70" [id=2336, type=dropout]; +"2337 dropout_70_0_0_nncf_smooth_quant_0" [id=2337, type=call_module]; +"2338 quantize_per_tensor_default_110" [id=2338, type=quantize_per_tensor]; +"2339 dequantize_per_tensor_default_110" [id=2339, type=dequantize_per_tensor]; +"2340 linear_109_scale_0" [id=2340, type=get_attr]; +"2341 linear_109_zero_point_0" [id=2341, type=get_attr]; +"2342 _frozen_param110" [id=2342, type=get_attr]; +"2343 dequantize_per_channel_default_110" [id=2343, type=dequantize_per_channel]; +"2344 linear_109" [id=2344, type=linear]; +"2345 dropout_71" [id=2345, type=dropout]; +"2346 layer_norm_38" [id=2346, type=layer_norm]; +"2347 add_62" [id=2347, type=add]; +"2348 features_5_14_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [id=2348, type=call_module]; +"2349 linear_110_scale_0" [id=2349, type=get_attr]; +"2350 linear_110_zero_point_0" [id=2350, type=get_attr]; +"2351 _frozen_param111" [id=2351, type=get_attr]; +"2352 dequantize_per_channel_default_111" [id=2352, type=dequantize_per_channel]; +"2353 linear_110" [id=2353, type=linear]; +"2354 relu__18" [id=2354, type=relu_]; +"2355 relu__18_0_0_nncf_smooth_quant_0" [id=2355, type=call_module]; +"2356 linear_111_scale_0" [id=2356, type=get_attr]; +"2357 linear_111_zero_point_0" [id=2357, type=get_attr]; +"2358 _frozen_param112" [id=2358, type=get_attr]; +"2359 dequantize_per_channel_default_112" [id=2359, type=dequantize_per_channel]; +"2360 linear_111" [id=2360, type=linear]; +"2361 view_99" [id=2361, type=view]; +"2362 index_18" [id=2362, type=index]; +"2363 view_100" [id=2363, type=view]; +"2364 permute_82" [id=2364, type=permute]; +"2365 contiguous_34" [id=2365, type=contiguous]; +"2366 unsqueeze_54" [id=2366, type=unsqueeze]; +"2367 sigmoid_18" [id=2367, type=sigmoid]; +"2368 mul_36" [id=2368, type=mul]; +"2369 pad_20" [id=2369, type=pad]; +"2370 view_101" [id=2370, type=view]; +"2371 permute_83" [id=2371, type=permute]; +"2372 reshape_81" [id=2372, type=reshape]; +"2373 clone_18" [id=2373, type=clone]; +"2374 reshape_81_0_0_nncf_smooth_quant_0" [id=2374, type=call_module]; +"2375 quantize_per_tensor_default_111" [id=2375, type=quantize_per_tensor]; +"2376 dequantize_per_tensor_default_111" [id=2376, type=dequantize_per_tensor]; +"2377 linear_112_scale_0" [id=2377, type=get_attr]; +"2378 linear_112_zero_point_0" [id=2378, type=get_attr]; +"2379 _frozen_param113" [id=2379, type=get_attr]; +"2380 dequantize_per_channel_default_113" [id=2380, type=dequantize_per_channel]; +"2381 linear_112" [id=2381, type=linear]; +"2382 reshape_82" [id=2382, type=reshape]; +"2383 permute_84" [id=2383, type=permute]; +"2384 select_54" [id=2384, type=select]; +"2385 select_55" [id=2385, type=select]; +"2386 select_56" [id=2386, type=select]; +"2387 linalg_vector_norm_36" [id=2387, type=linalg_vector_norm]; +"2388 clamp_min_36" [id=2388, type=clamp_min]; +"2389 expand_as_36" [id=2389, type=expand_as]; +"2390 div_36" [id=2390, type=div]; +"2391 quantize_per_tensor_default_112" [id=2391, type=quantize_per_tensor]; +"2392 dequantize_per_tensor_default_112" [id=2392, type=dequantize_per_tensor]; +"2393 linalg_vector_norm_37" [id=2393, type=linalg_vector_norm]; +"2394 clamp_min_37" [id=2394, type=clamp_min]; +"2395 expand_as_37" [id=2395, type=expand_as]; +"2396 div_37" [id=2396, type=div]; +"2397 quantize_per_tensor_default_113" [id=2397, type=quantize_per_tensor]; +"2398 dequantize_per_tensor_default_113" [id=2398, type=dequantize_per_tensor]; +"2399 transpose_36" [id=2399, type=transpose]; +"2400 matmul_36" [id=2400, type=matmul]; +"2401 clamp_18" [id=2401, type=clamp]; +"2402 exp_18" [id=2402, type=exp]; +"2403 mul_37" [id=2403, type=mul]; +"2404 add_63" [id=2404, type=add]; +"2405 softmax_18" [id=2405, type=softmax]; +"2406 dropout_72" [id=2406, type=dropout]; +"2407 matmul_37" [id=2407, type=matmul]; +"2408 transpose_37" [id=2408, type=transpose]; +"2409 reshape_83" [id=2409, type=reshape]; +"2410 reshape_83_0_0_nncf_smooth_quant_0" [id=2410, type=call_module]; +"2411 quantize_per_tensor_default_114" [id=2411, type=quantize_per_tensor]; +"2412 dequantize_per_tensor_default_114" [id=2412, type=dequantize_per_tensor]; +"2413 linear_113_scale_0" [id=2413, type=get_attr]; +"2414 linear_113_zero_point_0" [id=2414, type=get_attr]; +"2415 _frozen_param114" [id=2415, type=get_attr]; +"2416 dequantize_per_channel_default_114" [id=2416, type=dequantize_per_channel]; +"2417 linear_113" [id=2417, type=linear]; +"2418 dropout_73" [id=2418, type=dropout]; +"2419 view_102" [id=2419, type=view]; +"2420 permute_85" [id=2420, type=permute]; +"2421 reshape_84" [id=2421, type=reshape]; +"2422 slice_274" [id=2422, type=slice]; +"2423 slice_275" [id=2423, type=slice]; +"2424 slice_276" [id=2424, type=slice]; +"2425 slice_277" [id=2425, type=slice]; +"2426 contiguous_35" [id=2426, type=contiguous]; +"2427 layer_norm_39" [id=2427, type=layer_norm]; +"2428 add_64" [id=2428, type=add]; +"2429 add_64_0_0_nncf_smooth_quant_0" [id=2429, type=call_module]; +"2430 quantize_per_tensor_default_115" [id=2430, type=quantize_per_tensor]; +"2431 dequantize_per_tensor_default_115" [id=2431, type=dequantize_per_tensor]; +"2432 linear_114_scale_0" [id=2432, type=get_attr]; +"2433 linear_114_zero_point_0" [id=2433, type=get_attr]; +"2434 _frozen_param115" [id=2434, type=get_attr]; +"2435 dequantize_per_channel_default_115" [id=2435, type=dequantize_per_channel]; +"2436 linear_114" [id=2436, type=linear]; +"2437 gelu_18" [id=2437, type=gelu]; +"2438 dropout_74" [id=2438, type=dropout]; +"2439 dropout_74_0_0_nncf_smooth_quant_0" [id=2439, type=call_module]; +"2440 quantize_per_tensor_default_116" [id=2440, type=quantize_per_tensor]; +"2441 dequantize_per_tensor_default_116" [id=2441, type=dequantize_per_tensor]; +"2442 linear_115_scale_0" [id=2442, type=get_attr]; +"2443 linear_115_zero_point_0" [id=2443, type=get_attr]; +"2444 _frozen_param116" [id=2444, type=get_attr]; +"2445 dequantize_per_channel_default_116" [id=2445, type=dequantize_per_channel]; +"2446 linear_115" [id=2446, type=linear]; +"2447 dropout_75" [id=2447, type=dropout]; +"2448 layer_norm_40" [id=2448, type=layer_norm]; +"2449 add_65" [id=2449, type=add]; +"2450 features_5_15_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [id=2450, type=call_module]; +"2451 linear_116_scale_0" [id=2451, type=get_attr]; +"2452 linear_116_zero_point_0" [id=2452, type=get_attr]; +"2453 _frozen_param117" [id=2453, type=get_attr]; +"2454 dequantize_per_channel_default_117" [id=2454, type=dequantize_per_channel]; +"2455 linear_116" [id=2455, type=linear]; +"2456 relu__19" [id=2456, type=relu_]; +"2457 relu__19_0_0_nncf_smooth_quant_0" [id=2457, type=call_module]; +"2458 linear_117_scale_0" [id=2458, type=get_attr]; +"2459 linear_117_zero_point_0" [id=2459, type=get_attr]; +"2460 _frozen_param118" [id=2460, type=get_attr]; +"2461 dequantize_per_channel_default_118" [id=2461, type=dequantize_per_channel]; +"2462 linear_117" [id=2462, type=linear]; +"2463 view_103" [id=2463, type=view]; +"2464 index_19" [id=2464, type=index]; +"2465 view_104" [id=2465, type=view]; +"2466 permute_86" [id=2466, type=permute]; +"2467 contiguous_36" [id=2467, type=contiguous]; +"2468 unsqueeze_55" [id=2468, type=unsqueeze]; +"2469 sigmoid_19" [id=2469, type=sigmoid]; +"2470 mul_38" [id=2470, type=mul]; +"2471 pad_21" [id=2471, type=pad]; +"2472 roll_18" [id=2472, type=roll]; +"2473 view_105" [id=2473, type=view]; +"2474 permute_87" [id=2474, type=permute]; +"2475 reshape_85" [id=2475, type=reshape]; +"2476 clone_19" [id=2476, type=clone]; +"2477 reshape_85_0_0_nncf_smooth_quant_0" [id=2477, type=call_module]; +"2478 quantize_per_tensor_default_117" [id=2478, type=quantize_per_tensor]; +"2479 dequantize_per_tensor_default_117" [id=2479, type=dequantize_per_tensor]; +"2480 linear_118_scale_0" [id=2480, type=get_attr]; +"2481 linear_118_zero_point_0" [id=2481, type=get_attr]; +"2482 _frozen_param119" [id=2482, type=get_attr]; +"2483 dequantize_per_channel_default_119" [id=2483, type=dequantize_per_channel]; +"2484 linear_118" [id=2484, type=linear]; +"2485 reshape_86" [id=2485, type=reshape]; +"2486 permute_88" [id=2486, type=permute]; +"2487 select_57" [id=2487, type=select]; +"2488 select_58" [id=2488, type=select]; +"2489 select_59" [id=2489, type=select]; +"2490 linalg_vector_norm_38" [id=2490, type=linalg_vector_norm]; +"2491 clamp_min_38" [id=2491, type=clamp_min]; +"2492 expand_as_38" [id=2492, type=expand_as]; +"2493 div_38" [id=2493, type=div]; +"2494 quantize_per_tensor_default_118" [id=2494, type=quantize_per_tensor]; +"2495 dequantize_per_tensor_default_118" [id=2495, type=dequantize_per_tensor]; +"2496 linalg_vector_norm_39" [id=2496, type=linalg_vector_norm]; +"2497 clamp_min_39" [id=2497, type=clamp_min]; +"2498 expand_as_39" [id=2498, type=expand_as]; +"2499 div_39" [id=2499, type=div]; +"2500 quantize_per_tensor_default_119" [id=2500, type=quantize_per_tensor]; +"2501 dequantize_per_tensor_default_119" [id=2501, type=dequantize_per_tensor]; +"2502 transpose_38" [id=2502, type=transpose]; +"2503 matmul_38" [id=2503, type=matmul]; +"2504 clamp_19" [id=2504, type=clamp]; +"2505 exp_19" [id=2505, type=exp]; +"2506 mul_39" [id=2506, type=mul]; +"2507 add_66" [id=2507, type=add]; +"2508 new_zeros_9" [id=2508, type=new_zeros]; +"2509 view_106" [id=2509, type=view]; +"2510 permute_89" [id=2510, type=permute]; +"2511 reshape_87" [id=2511, type=reshape]; +"2512 unsqueeze_56" [id=2512, type=unsqueeze]; +"2513 unsqueeze_57" [id=2513, type=unsqueeze]; +"2514 sub_9" [id=2514, type=sub]; +"2515 ne_9" [id=2515, type=ne]; +"2516 masked_fill_18" [id=2516, type=masked_fill]; +"2517 eq_9" [id=2517, type=eq]; +"2518 masked_fill_19" [id=2518, type=masked_fill]; +"2519 view_107" [id=2519, type=view]; +"2520 unsqueeze_58" [id=2520, type=unsqueeze]; +"2521 unsqueeze_59" [id=2521, type=unsqueeze]; +"2522 add_67" [id=2522, type=add]; +"2523 view_108" [id=2523, type=view]; +"2524 softmax_19" [id=2524, type=softmax]; +"2525 dropout_76" [id=2525, type=dropout]; +"2526 matmul_39" [id=2526, type=matmul]; +"2527 transpose_39" [id=2527, type=transpose]; +"2528 reshape_88" [id=2528, type=reshape]; +"2529 reshape_88_0_0_nncf_smooth_quant_0" [id=2529, type=call_module]; +"2530 quantize_per_tensor_default_120" [id=2530, type=quantize_per_tensor]; +"2531 dequantize_per_tensor_default_120" [id=2531, type=dequantize_per_tensor]; +"2532 linear_119_scale_0" [id=2532, type=get_attr]; +"2533 linear_119_zero_point_0" [id=2533, type=get_attr]; +"2534 _frozen_param120" [id=2534, type=get_attr]; +"2535 dequantize_per_channel_default_120" [id=2535, type=dequantize_per_channel]; +"2536 linear_119" [id=2536, type=linear]; +"2537 dropout_77" [id=2537, type=dropout]; +"2538 view_109" [id=2538, type=view]; +"2539 permute_90" [id=2539, type=permute]; +"2540 reshape_89" [id=2540, type=reshape]; +"2541 roll_19" [id=2541, type=roll]; +"2542 slice_297" [id=2542, type=slice]; +"2543 slice_298" [id=2543, type=slice]; +"2544 slice_299" [id=2544, type=slice]; +"2545 slice_300" [id=2545, type=slice]; +"2546 contiguous_37" [id=2546, type=contiguous]; +"2547 layer_norm_41" [id=2547, type=layer_norm]; +"2548 add_68" [id=2548, type=add]; +"2549 add_68_0_0_nncf_smooth_quant_0" [id=2549, type=call_module]; +"2550 quantize_per_tensor_default_121" [id=2550, type=quantize_per_tensor]; +"2551 dequantize_per_tensor_default_121" [id=2551, type=dequantize_per_tensor]; +"2552 linear_120_scale_0" [id=2552, type=get_attr]; +"2553 linear_120_zero_point_0" [id=2553, type=get_attr]; +"2554 _frozen_param121" [id=2554, type=get_attr]; +"2555 dequantize_per_channel_default_121" [id=2555, type=dequantize_per_channel]; +"2556 linear_120" [id=2556, type=linear]; +"2557 gelu_19" [id=2557, type=gelu]; +"2558 dropout_78" [id=2558, type=dropout]; +"2559 dropout_78_0_0_nncf_smooth_quant_0" [id=2559, type=call_module]; +"2560 quantize_per_tensor_default_122" [id=2560, type=quantize_per_tensor]; +"2561 dequantize_per_tensor_default_122" [id=2561, type=dequantize_per_tensor]; +"2562 linear_121_scale_0" [id=2562, type=get_attr]; +"2563 linear_121_zero_point_0" [id=2563, type=get_attr]; +"2564 _frozen_param122" [id=2564, type=get_attr]; +"2565 dequantize_per_channel_default_122" [id=2565, type=dequantize_per_channel]; +"2566 linear_121" [id=2566, type=linear]; +"2567 dropout_79" [id=2567, type=dropout]; +"2568 layer_norm_42" [id=2568, type=layer_norm]; +"2569 add_69" [id=2569, type=add]; +"2570 features_5_16_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [id=2570, type=call_module]; +"2571 linear_122_scale_0" [id=2571, type=get_attr]; +"2572 linear_122_zero_point_0" [id=2572, type=get_attr]; +"2573 _frozen_param123" [id=2573, type=get_attr]; +"2574 dequantize_per_channel_default_123" [id=2574, type=dequantize_per_channel]; +"2575 linear_122" [id=2575, type=linear]; +"2576 relu__20" [id=2576, type=relu_]; +"2577 relu__20_0_0_nncf_smooth_quant_0" [id=2577, type=call_module]; +"2578 linear_123_scale_0" [id=2578, type=get_attr]; +"2579 linear_123_zero_point_0" [id=2579, type=get_attr]; +"2580 _frozen_param124" [id=2580, type=get_attr]; +"2581 dequantize_per_channel_default_124" [id=2581, type=dequantize_per_channel]; +"2582 linear_123" [id=2582, type=linear]; +"2583 view_110" [id=2583, type=view]; +"2584 index_20" [id=2584, type=index]; +"2585 view_111" [id=2585, type=view]; +"2586 permute_91" [id=2586, type=permute]; +"2587 contiguous_38" [id=2587, type=contiguous]; +"2588 unsqueeze_60" [id=2588, type=unsqueeze]; +"2589 sigmoid_20" [id=2589, type=sigmoid]; +"2590 mul_40" [id=2590, type=mul]; +"2591 pad_22" [id=2591, type=pad]; +"2592 view_112" [id=2592, type=view]; +"2593 permute_92" [id=2593, type=permute]; +"2594 reshape_90" [id=2594, type=reshape]; +"2595 clone_20" [id=2595, type=clone]; +"2596 reshape_90_0_0_nncf_smooth_quant_0" [id=2596, type=call_module]; +"2597 quantize_per_tensor_default_123" [id=2597, type=quantize_per_tensor]; +"2598 dequantize_per_tensor_default_123" [id=2598, type=dequantize_per_tensor]; +"2599 linear_124_scale_0" [id=2599, type=get_attr]; +"2600 linear_124_zero_point_0" [id=2600, type=get_attr]; +"2601 _frozen_param125" [id=2601, type=get_attr]; +"2602 dequantize_per_channel_default_125" [id=2602, type=dequantize_per_channel]; +"2603 linear_124" [id=2603, type=linear]; +"2604 reshape_91" [id=2604, type=reshape]; +"2605 permute_93" [id=2605, type=permute]; +"2606 select_60" [id=2606, type=select]; +"2607 select_61" [id=2607, type=select]; +"2608 select_62" [id=2608, type=select]; +"2609 linalg_vector_norm_40" [id=2609, type=linalg_vector_norm]; +"2610 clamp_min_40" [id=2610, type=clamp_min]; +"2611 expand_as_40" [id=2611, type=expand_as]; +"2612 div_40" [id=2612, type=div]; +"2613 quantize_per_tensor_default_124" [id=2613, type=quantize_per_tensor]; +"2614 dequantize_per_tensor_default_124" [id=2614, type=dequantize_per_tensor]; +"2615 linalg_vector_norm_41" [id=2615, type=linalg_vector_norm]; +"2616 clamp_min_41" [id=2616, type=clamp_min]; +"2617 expand_as_41" [id=2617, type=expand_as]; +"2618 div_41" [id=2618, type=div]; +"2619 quantize_per_tensor_default_125" [id=2619, type=quantize_per_tensor]; +"2620 dequantize_per_tensor_default_125" [id=2620, type=dequantize_per_tensor]; +"2621 transpose_40" [id=2621, type=transpose]; +"2622 matmul_40" [id=2622, type=matmul]; +"2623 clamp_20" [id=2623, type=clamp]; +"2624 exp_20" [id=2624, type=exp]; +"2625 mul_41" [id=2625, type=mul]; +"2626 add_70" [id=2626, type=add]; +"2627 softmax_20" [id=2627, type=softmax]; +"2628 dropout_80" [id=2628, type=dropout]; +"2629 matmul_41" [id=2629, type=matmul]; +"2630 transpose_41" [id=2630, type=transpose]; +"2631 reshape_92" [id=2631, type=reshape]; +"2632 reshape_92_0_0_nncf_smooth_quant_0" [id=2632, type=call_module]; +"2633 quantize_per_tensor_default_126" [id=2633, type=quantize_per_tensor]; +"2634 dequantize_per_tensor_default_126" [id=2634, type=dequantize_per_tensor]; +"2635 linear_125_scale_0" [id=2635, type=get_attr]; +"2636 linear_125_zero_point_0" [id=2636, type=get_attr]; +"2637 _frozen_param126" [id=2637, type=get_attr]; +"2638 dequantize_per_channel_default_126" [id=2638, type=dequantize_per_channel]; +"2639 linear_125" [id=2639, type=linear]; +"2640 dropout_81" [id=2640, type=dropout]; +"2641 view_113" [id=2641, type=view]; +"2642 permute_94" [id=2642, type=permute]; +"2643 reshape_93" [id=2643, type=reshape]; +"2644 slice_302" [id=2644, type=slice]; +"2645 slice_303" [id=2645, type=slice]; +"2646 slice_304" [id=2646, type=slice]; +"2647 slice_305" [id=2647, type=slice]; +"2648 contiguous_39" [id=2648, type=contiguous]; +"2649 layer_norm_43" [id=2649, type=layer_norm]; +"2650 add_71" [id=2650, type=add]; +"2651 add_71_0_0_nncf_smooth_quant_0" [id=2651, type=call_module]; +"2652 quantize_per_tensor_default_127" [id=2652, type=quantize_per_tensor]; +"2653 dequantize_per_tensor_default_127" [id=2653, type=dequantize_per_tensor]; +"2654 linear_126_scale_0" [id=2654, type=get_attr]; +"2655 linear_126_zero_point_0" [id=2655, type=get_attr]; +"2656 _frozen_param127" [id=2656, type=get_attr]; +"2657 dequantize_per_channel_default_127" [id=2657, type=dequantize_per_channel]; +"2658 linear_126" [id=2658, type=linear]; +"2659 gelu_20" [id=2659, type=gelu]; +"2660 dropout_82" [id=2660, type=dropout]; +"2661 dropout_82_0_0_nncf_smooth_quant_0" [id=2661, type=call_module]; +"2662 quantize_per_tensor_default_128" [id=2662, type=quantize_per_tensor]; +"2663 dequantize_per_tensor_default_128" [id=2663, type=dequantize_per_tensor]; +"2664 linear_127_scale_0" [id=2664, type=get_attr]; +"2665 linear_127_zero_point_0" [id=2665, type=get_attr]; +"2666 _frozen_param128" [id=2666, type=get_attr]; +"2667 dequantize_per_channel_default_128" [id=2667, type=dequantize_per_channel]; +"2668 linear_127" [id=2668, type=linear]; +"2669 dropout_83" [id=2669, type=dropout]; +"2670 layer_norm_44" [id=2670, type=layer_norm]; +"2671 add_72" [id=2671, type=add]; +"2672 features_5_17_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [id=2672, type=call_module]; +"2673 linear_128_scale_0" [id=2673, type=get_attr]; +"2674 linear_128_zero_point_0" [id=2674, type=get_attr]; +"2675 _frozen_param129" [id=2675, type=get_attr]; +"2676 dequantize_per_channel_default_129" [id=2676, type=dequantize_per_channel]; +"2677 linear_128" [id=2677, type=linear]; +"2678 relu__21" [id=2678, type=relu_]; +"2679 relu__21_0_0_nncf_smooth_quant_0" [id=2679, type=call_module]; +"2680 linear_129_scale_0" [id=2680, type=get_attr]; +"2681 linear_129_zero_point_0" [id=2681, type=get_attr]; +"2682 _frozen_param130" [id=2682, type=get_attr]; +"2683 dequantize_per_channel_default_130" [id=2683, type=dequantize_per_channel]; +"2684 linear_129" [id=2684, type=linear]; +"2685 view_114" [id=2685, type=view]; +"2686 index_21" [id=2686, type=index]; +"2687 view_115" [id=2687, type=view]; +"2688 permute_95" [id=2688, type=permute]; +"2689 contiguous_40" [id=2689, type=contiguous]; +"2690 unsqueeze_61" [id=2690, type=unsqueeze]; +"2691 sigmoid_21" [id=2691, type=sigmoid]; +"2692 mul_42" [id=2692, type=mul]; +"2693 pad_23" [id=2693, type=pad]; +"2694 roll_20" [id=2694, type=roll]; +"2695 view_116" [id=2695, type=view]; +"2696 permute_96" [id=2696, type=permute]; +"2697 reshape_94" [id=2697, type=reshape]; +"2698 clone_21" [id=2698, type=clone]; +"2699 reshape_94_0_0_nncf_smooth_quant_0" [id=2699, type=call_module]; +"2700 quantize_per_tensor_default_129" [id=2700, type=quantize_per_tensor]; +"2701 dequantize_per_tensor_default_129" [id=2701, type=dequantize_per_tensor]; +"2702 linear_130_scale_0" [id=2702, type=get_attr]; +"2703 linear_130_zero_point_0" [id=2703, type=get_attr]; +"2704 _frozen_param131" [id=2704, type=get_attr]; +"2705 dequantize_per_channel_default_131" [id=2705, type=dequantize_per_channel]; +"2706 linear_130" [id=2706, type=linear]; +"2707 reshape_95" [id=2707, type=reshape]; +"2708 permute_97" [id=2708, type=permute]; +"2709 select_63" [id=2709, type=select]; +"2710 select_64" [id=2710, type=select]; +"2711 select_65" [id=2711, type=select]; +"2712 linalg_vector_norm_42" [id=2712, type=linalg_vector_norm]; +"2713 clamp_min_42" [id=2713, type=clamp_min]; +"2714 expand_as_42" [id=2714, type=expand_as]; +"2715 div_42" [id=2715, type=div]; +"2716 quantize_per_tensor_default_130" [id=2716, type=quantize_per_tensor]; +"2717 dequantize_per_tensor_default_130" [id=2717, type=dequantize_per_tensor]; +"2718 linalg_vector_norm_43" [id=2718, type=linalg_vector_norm]; +"2719 clamp_min_43" [id=2719, type=clamp_min]; +"2720 expand_as_43" [id=2720, type=expand_as]; +"2721 div_43" [id=2721, type=div]; +"2722 quantize_per_tensor_default_131" [id=2722, type=quantize_per_tensor]; +"2723 dequantize_per_tensor_default_131" [id=2723, type=dequantize_per_tensor]; +"2724 transpose_42" [id=2724, type=transpose]; +"2725 matmul_42" [id=2725, type=matmul]; +"2726 clamp_21" [id=2726, type=clamp]; +"2727 exp_21" [id=2727, type=exp]; +"2728 mul_43" [id=2728, type=mul]; +"2729 add_73" [id=2729, type=add]; +"2730 new_zeros_10" [id=2730, type=new_zeros]; +"2731 view_117" [id=2731, type=view]; +"2732 permute_98" [id=2732, type=permute]; +"2733 reshape_96" [id=2733, type=reshape]; +"2734 unsqueeze_62" [id=2734, type=unsqueeze]; +"2735 unsqueeze_63" [id=2735, type=unsqueeze]; +"2736 sub_10" [id=2736, type=sub]; +"2737 ne_10" [id=2737, type=ne]; +"2738 masked_fill_20" [id=2738, type=masked_fill]; +"2739 eq_10" [id=2739, type=eq]; +"2740 masked_fill_21" [id=2740, type=masked_fill]; +"2741 view_118" [id=2741, type=view]; +"2742 unsqueeze_64" [id=2742, type=unsqueeze]; +"2743 unsqueeze_65" [id=2743, type=unsqueeze]; +"2744 add_74" [id=2744, type=add]; +"2745 view_119" [id=2745, type=view]; +"2746 softmax_21" [id=2746, type=softmax]; +"2747 dropout_84" [id=2747, type=dropout]; +"2748 matmul_43" [id=2748, type=matmul]; +"2749 transpose_43" [id=2749, type=transpose]; +"2750 reshape_97" [id=2750, type=reshape]; +"2751 reshape_97_0_0_nncf_smooth_quant_0" [id=2751, type=call_module]; +"2752 quantize_per_tensor_default_132" [id=2752, type=quantize_per_tensor]; +"2753 dequantize_per_tensor_default_132" [id=2753, type=dequantize_per_tensor]; +"2754 linear_131_scale_0" [id=2754, type=get_attr]; +"2755 linear_131_zero_point_0" [id=2755, type=get_attr]; +"2756 _frozen_param132" [id=2756, type=get_attr]; +"2757 dequantize_per_channel_default_132" [id=2757, type=dequantize_per_channel]; +"2758 linear_131" [id=2758, type=linear]; +"2759 dropout_85" [id=2759, type=dropout]; +"2760 view_120" [id=2760, type=view]; +"2761 permute_99" [id=2761, type=permute]; +"2762 reshape_98" [id=2762, type=reshape]; +"2763 roll_21" [id=2763, type=roll]; +"2764 slice_325" [id=2764, type=slice]; +"2765 slice_326" [id=2765, type=slice]; +"2766 slice_327" [id=2766, type=slice]; +"2767 slice_328" [id=2767, type=slice]; +"2768 contiguous_41" [id=2768, type=contiguous]; +"2769 layer_norm_45" [id=2769, type=layer_norm]; +"2770 add_75" [id=2770, type=add]; +"2771 add_75_0_0_nncf_smooth_quant_0" [id=2771, type=call_module]; +"2772 quantize_per_tensor_default_133" [id=2772, type=quantize_per_tensor]; +"2773 dequantize_per_tensor_default_133" [id=2773, type=dequantize_per_tensor]; +"2774 linear_132_scale_0" [id=2774, type=get_attr]; +"2775 linear_132_zero_point_0" [id=2775, type=get_attr]; +"2776 _frozen_param133" [id=2776, type=get_attr]; +"2777 dequantize_per_channel_default_133" [id=2777, type=dequantize_per_channel]; +"2778 linear_132" [id=2778, type=linear]; +"2779 gelu_21" [id=2779, type=gelu]; +"2780 dropout_86" [id=2780, type=dropout]; +"2781 dropout_86_0_0_nncf_smooth_quant_0" [id=2781, type=call_module]; +"2782 quantize_per_tensor_default_134" [id=2782, type=quantize_per_tensor]; +"2783 dequantize_per_tensor_default_134" [id=2783, type=dequantize_per_tensor]; +"2784 linear_133_scale_0" [id=2784, type=get_attr]; +"2785 linear_133_zero_point_0" [id=2785, type=get_attr]; +"2786 _frozen_param134" [id=2786, type=get_attr]; +"2787 dequantize_per_channel_default_134" [id=2787, type=dequantize_per_channel]; +"2788 linear_133" [id=2788, type=linear]; +"2789 dropout_87" [id=2789, type=dropout]; +"2790 layer_norm_46" [id=2790, type=layer_norm]; +"2791 add_76" [id=2791, type=add]; +"2792 pad_24" [id=2792, type=pad]; +"2793 slice_329" [id=2793, type=slice]; +"2794 slice_330" [id=2794, type=slice]; +"2795 slice_331" [id=2795, type=slice]; +"2796 slice_332" [id=2796, type=slice]; +"2797 slice_333" [id=2797, type=slice]; +"2798 slice_334" [id=2798, type=slice]; +"2799 slice_335" [id=2799, type=slice]; +"2800 slice_336" [id=2800, type=slice]; +"2801 slice_337" [id=2801, type=slice]; +"2802 slice_338" [id=2802, type=slice]; +"2803 slice_339" [id=2803, type=slice]; +"2804 slice_340" [id=2804, type=slice]; +"2805 cat_2" [id=2805, type=cat]; +"2806 cat_2_0_0_nncf_smooth_quant_0" [id=2806, type=call_module]; +"2807 quantize_per_tensor_default_135" [id=2807, type=quantize_per_tensor]; +"2808 dequantize_per_tensor_default_135" [id=2808, type=dequantize_per_tensor]; +"2809 linear_134_scale_0" [id=2809, type=get_attr]; +"2810 linear_134_zero_point_0" [id=2810, type=get_attr]; +"2811 _frozen_param135" [id=2811, type=get_attr]; +"2812 dequantize_per_channel_default_135" [id=2812, type=dequantize_per_channel]; +"2813 linear_134" [id=2813, type=linear]; +"2814 layer_norm_47" [id=2814, type=layer_norm]; +"2815 features_7_0_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [id=2815, type=call_module]; +"2816 linear_135_scale_0" [id=2816, type=get_attr]; +"2817 linear_135_zero_point_0" [id=2817, type=get_attr]; +"2818 _frozen_param136" [id=2818, type=get_attr]; +"2819 dequantize_per_channel_default_136" [id=2819, type=dequantize_per_channel]; +"2820 linear_135" [id=2820, type=linear]; +"2821 relu__22" [id=2821, type=relu_]; +"2822 relu__22_0_0_nncf_smooth_quant_0" [id=2822, type=call_module]; +"2823 linear_136_scale_0" [id=2823, type=get_attr]; +"2824 linear_136_zero_point_0" [id=2824, type=get_attr]; +"2825 _frozen_param137" [id=2825, type=get_attr]; +"2826 dequantize_per_channel_default_137" [id=2826, type=dequantize_per_channel]; +"2827 linear_136" [id=2827, type=linear]; +"2828 view_121" [id=2828, type=view]; +"2829 index_22" [id=2829, type=index]; +"2830 view_122" [id=2830, type=view]; +"2831 permute_100" [id=2831, type=permute]; +"2832 contiguous_42" [id=2832, type=contiguous]; +"2833 unsqueeze_66" [id=2833, type=unsqueeze]; +"2834 sigmoid_22" [id=2834, type=sigmoid]; +"2835 mul_44" [id=2835, type=mul]; +"2836 pad_25" [id=2836, type=pad]; +"2837 view_123" [id=2837, type=view]; +"2838 permute_101" [id=2838, type=permute]; +"2839 reshape_99" [id=2839, type=reshape]; +"2840 clone_22" [id=2840, type=clone]; +"2841 reshape_99_0_0_nncf_smooth_quant_0" [id=2841, type=call_module]; +"2842 quantize_per_tensor_default_136" [id=2842, type=quantize_per_tensor]; +"2843 dequantize_per_tensor_default_136" [id=2843, type=dequantize_per_tensor]; +"2844 linear_137_scale_0" [id=2844, type=get_attr]; +"2845 linear_137_zero_point_0" [id=2845, type=get_attr]; +"2846 _frozen_param138" [id=2846, type=get_attr]; +"2847 dequantize_per_channel_default_138" [id=2847, type=dequantize_per_channel]; +"2848 linear_137" [id=2848, type=linear]; +"2849 reshape_100" [id=2849, type=reshape]; +"2850 permute_102" [id=2850, type=permute]; +"2851 select_66" [id=2851, type=select]; +"2852 select_67" [id=2852, type=select]; +"2853 select_68" [id=2853, type=select]; +"2854 linalg_vector_norm_44" [id=2854, type=linalg_vector_norm]; +"2855 clamp_min_44" [id=2855, type=clamp_min]; +"2856 expand_as_44" [id=2856, type=expand_as]; +"2857 div_44" [id=2857, type=div]; +"2858 quantize_per_tensor_default_137" [id=2858, type=quantize_per_tensor]; +"2859 dequantize_per_tensor_default_137" [id=2859, type=dequantize_per_tensor]; +"2860 linalg_vector_norm_45" [id=2860, type=linalg_vector_norm]; +"2861 clamp_min_45" [id=2861, type=clamp_min]; +"2862 expand_as_45" [id=2862, type=expand_as]; +"2863 div_45" [id=2863, type=div]; +"2864 quantize_per_tensor_default_138" [id=2864, type=quantize_per_tensor]; +"2865 dequantize_per_tensor_default_138" [id=2865, type=dequantize_per_tensor]; +"2866 transpose_44" [id=2866, type=transpose]; +"2867 matmul_44" [id=2867, type=matmul]; +"2868 clamp_22" [id=2868, type=clamp]; +"2869 exp_22" [id=2869, type=exp]; +"2870 mul_45" [id=2870, type=mul]; +"2871 add_77" [id=2871, type=add]; +"2872 softmax_22" [id=2872, type=softmax]; +"2873 dropout_88" [id=2873, type=dropout]; +"2874 matmul_45" [id=2874, type=matmul]; +"2875 transpose_45" [id=2875, type=transpose]; +"2876 reshape_101" [id=2876, type=reshape]; +"2877 reshape_101_0_0_nncf_smooth_quant_0" [id=2877, type=call_module]; +"2878 quantize_per_tensor_default_139" [id=2878, type=quantize_per_tensor]; +"2879 dequantize_per_tensor_default_139" [id=2879, type=dequantize_per_tensor]; +"2880 linear_138_scale_0" [id=2880, type=get_attr]; +"2881 linear_138_zero_point_0" [id=2881, type=get_attr]; +"2882 _frozen_param139" [id=2882, type=get_attr]; +"2883 dequantize_per_channel_default_139" [id=2883, type=dequantize_per_channel]; +"2884 linear_138" [id=2884, type=linear]; +"2885 dropout_89" [id=2885, type=dropout]; +"2886 view_124" [id=2886, type=view]; +"2887 permute_103" [id=2887, type=permute]; +"2888 reshape_102" [id=2888, type=reshape]; +"2889 slice_342" [id=2889, type=slice]; +"2890 slice_343" [id=2890, type=slice]; +"2891 slice_344" [id=2891, type=slice]; +"2892 slice_345" [id=2892, type=slice]; +"2893 contiguous_43" [id=2893, type=contiguous]; +"2894 layer_norm_48" [id=2894, type=layer_norm]; +"2895 add_78" [id=2895, type=add]; +"2896 add_78_0_0_nncf_smooth_quant_0" [id=2896, type=call_module]; +"2897 quantize_per_tensor_default_140" [id=2897, type=quantize_per_tensor]; +"2898 dequantize_per_tensor_default_140" [id=2898, type=dequantize_per_tensor]; +"2899 linear_139_scale_0" [id=2899, type=get_attr]; +"2900 linear_139_zero_point_0" [id=2900, type=get_attr]; +"2901 _frozen_param140" [id=2901, type=get_attr]; +"2902 dequantize_per_channel_default_140" [id=2902, type=dequantize_per_channel]; +"2903 linear_139" [id=2903, type=linear]; +"2904 gelu_22" [id=2904, type=gelu]; +"2905 dropout_90" [id=2905, type=dropout]; +"2906 dropout_90_0_0_nncf_smooth_quant_0" [id=2906, type=call_module]; +"2907 quantize_per_tensor_default_141" [id=2907, type=quantize_per_tensor]; +"2908 dequantize_per_tensor_default_141" [id=2908, type=dequantize_per_tensor]; +"2909 linear_140_scale_0" [id=2909, type=get_attr]; +"2910 linear_140_zero_point_0" [id=2910, type=get_attr]; +"2911 _frozen_param141" [id=2911, type=get_attr]; +"2912 dequantize_per_channel_default_141" [id=2912, type=dequantize_per_channel]; +"2913 linear_140" [id=2913, type=linear]; +"2914 dropout_91" [id=2914, type=dropout]; +"2915 layer_norm_49" [id=2915, type=layer_norm]; +"2916 add_79" [id=2916, type=add]; +"2917 features_7_1_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [id=2917, type=call_module]; +"2918 linear_141_scale_0" [id=2918, type=get_attr]; +"2919 linear_141_zero_point_0" [id=2919, type=get_attr]; +"2920 _frozen_param142" [id=2920, type=get_attr]; +"2921 dequantize_per_channel_default_142" [id=2921, type=dequantize_per_channel]; +"2922 linear_141" [id=2922, type=linear]; +"2923 relu__23" [id=2923, type=relu_]; +"2924 relu__23_0_0_nncf_smooth_quant_0" [id=2924, type=call_module]; +"2925 linear_142_scale_0" [id=2925, type=get_attr]; +"2926 linear_142_zero_point_0" [id=2926, type=get_attr]; +"2927 _frozen_param143" [id=2927, type=get_attr]; +"2928 dequantize_per_channel_default_143" [id=2928, type=dequantize_per_channel]; +"2929 linear_142" [id=2929, type=linear]; +"2930 view_125" [id=2930, type=view]; +"2931 index_23" [id=2931, type=index]; +"2932 view_126" [id=2932, type=view]; +"2933 permute_104" [id=2933, type=permute]; +"2934 contiguous_44" [id=2934, type=contiguous]; +"2935 unsqueeze_67" [id=2935, type=unsqueeze]; +"2936 sigmoid_23" [id=2936, type=sigmoid]; +"2937 mul_46" [id=2937, type=mul]; +"2938 pad_26" [id=2938, type=pad]; +"2939 view_127" [id=2939, type=view]; +"2940 permute_105" [id=2940, type=permute]; +"2941 reshape_103" [id=2941, type=reshape]; +"2942 clone_23" [id=2942, type=clone]; +"2943 reshape_103_0_0_nncf_smooth_quant_0" [id=2943, type=call_module]; +"2944 quantize_per_tensor_default_142" [id=2944, type=quantize_per_tensor]; +"2945 dequantize_per_tensor_default_142" [id=2945, type=dequantize_per_tensor]; +"2946 linear_143_scale_0" [id=2946, type=get_attr]; +"2947 linear_143_zero_point_0" [id=2947, type=get_attr]; +"2948 _frozen_param144" [id=2948, type=get_attr]; +"2949 dequantize_per_channel_default_144" [id=2949, type=dequantize_per_channel]; +"2950 linear_143" [id=2950, type=linear]; +"2951 reshape_104" [id=2951, type=reshape]; +"2952 permute_106" [id=2952, type=permute]; +"2953 select_69" [id=2953, type=select]; +"2954 select_70" [id=2954, type=select]; +"2955 select_71" [id=2955, type=select]; +"2956 linalg_vector_norm_46" [id=2956, type=linalg_vector_norm]; +"2957 clamp_min_46" [id=2957, type=clamp_min]; +"2958 expand_as_46" [id=2958, type=expand_as]; +"2959 div_46" [id=2959, type=div]; +"2960 quantize_per_tensor_default_143" [id=2960, type=quantize_per_tensor]; +"2961 dequantize_per_tensor_default_143" [id=2961, type=dequantize_per_tensor]; +"2962 linalg_vector_norm_47" [id=2962, type=linalg_vector_norm]; +"2963 clamp_min_47" [id=2963, type=clamp_min]; +"2964 expand_as_47" [id=2964, type=expand_as]; +"2965 div_47" [id=2965, type=div]; +"2966 quantize_per_tensor_default_144" [id=2966, type=quantize_per_tensor]; +"2967 dequantize_per_tensor_default_144" [id=2967, type=dequantize_per_tensor]; +"2968 transpose_46" [id=2968, type=transpose]; +"2969 matmul_46" [id=2969, type=matmul]; +"2970 clamp_23" [id=2970, type=clamp]; +"2971 exp_23" [id=2971, type=exp]; +"2972 mul_47" [id=2972, type=mul]; +"2973 add_80" [id=2973, type=add]; +"2974 softmax_23" [id=2974, type=softmax]; +"2975 dropout_92" [id=2975, type=dropout]; +"2976 matmul_47" [id=2976, type=matmul]; +"2977 transpose_47" [id=2977, type=transpose]; +"2978 reshape_105" [id=2978, type=reshape]; +"2979 reshape_105_0_0_nncf_smooth_quant_0" [id=2979, type=call_module]; +"2980 quantize_per_tensor_default_145" [id=2980, type=quantize_per_tensor]; +"2981 dequantize_per_tensor_default_145" [id=2981, type=dequantize_per_tensor]; +"2982 linear_144_scale_0" [id=2982, type=get_attr]; +"2983 linear_144_zero_point_0" [id=2983, type=get_attr]; +"2984 _frozen_param145" [id=2984, type=get_attr]; +"2985 dequantize_per_channel_default_145" [id=2985, type=dequantize_per_channel]; +"2986 linear_144" [id=2986, type=linear]; +"2987 dropout_93" [id=2987, type=dropout]; +"2988 view_128" [id=2988, type=view]; +"2989 permute_107" [id=2989, type=permute]; +"2990 reshape_106" [id=2990, type=reshape]; +"2991 slice_347" [id=2991, type=slice]; +"2992 slice_348" [id=2992, type=slice]; +"2993 slice_349" [id=2993, type=slice]; +"2994 slice_350" [id=2994, type=slice]; +"2995 contiguous_45" [id=2995, type=contiguous]; +"2996 layer_norm_50" [id=2996, type=layer_norm]; +"2997 add_81" [id=2997, type=add]; +"2998 add_81_0_0_nncf_smooth_quant_0" [id=2998, type=call_module]; +"2999 quantize_per_tensor_default_146" [id=2999, type=quantize_per_tensor]; +"3000 dequantize_per_tensor_default_146" [id=3000, type=dequantize_per_tensor]; +"3001 linear_145_scale_0" [id=3001, type=get_attr]; +"3002 linear_145_zero_point_0" [id=3002, type=get_attr]; +"3003 _frozen_param146" [id=3003, type=get_attr]; +"3004 dequantize_per_channel_default_146" [id=3004, type=dequantize_per_channel]; +"3005 linear_145" [id=3005, type=linear]; +"3006 gelu_23" [id=3006, type=gelu]; +"3007 dropout_94" [id=3007, type=dropout]; +"3008 dropout_94_0_0_nncf_smooth_quant_0" [id=3008, type=call_module]; +"3009 quantize_per_tensor_default_147" [id=3009, type=quantize_per_tensor]; +"3010 dequantize_per_tensor_default_147" [id=3010, type=dequantize_per_tensor]; +"3011 linear_146_scale_0" [id=3011, type=get_attr]; +"3012 linear_146_zero_point_0" [id=3012, type=get_attr]; +"3013 _frozen_param147" [id=3013, type=get_attr]; +"3014 dequantize_per_channel_default_147" [id=3014, type=dequantize_per_channel]; +"3015 linear_146" [id=3015, type=linear]; +"3016 dropout_95" [id=3016, type=dropout]; +"3017 layer_norm_51" [id=3017, type=layer_norm]; +"3018 add_82" [id=3018, type=add]; +"3019 layer_norm_52" [id=3019, type=layer_norm]; +"3020 permute_108" [id=3020, type=permute]; +"3021 adaptive_avg_pool2d" [id=3021, type=adaptive_avg_pool2d]; +"3022 flatten" [id=3022, type=flatten]; +"3023 flatten_0_0_nncf_smooth_quant_0" [id=3023, type=call_module]; +"3024 quantize_per_tensor_default_148" [id=3024, type=quantize_per_tensor]; +"3025 dequantize_per_tensor_default_148" [id=3025, type=dequantize_per_tensor]; +"3026 linear_147_scale_0" [id=3026, type=get_attr]; +"3027 linear_147_zero_point_0" [id=3027, type=get_attr]; +"3028 _frozen_param148" [id=3028, type=get_attr]; +"3029 dequantize_per_channel_default_148" [id=3029, type=dequantize_per_channel]; +"3030 linear_147" [id=3030, type=linear]; +"3031 output" [id=3031, type=output]; +"0 features_1_0_attn_qkv_bias" -> "335 clone" [label="(288,)", style=solid]; +"1 features_1_0_attn_proj_bias" -> "379 linear_3" [label="(96,)", style=solid]; +"2 features_1_0_attn_logit_scale" -> "363 clamp" [label="(3, 1, 1)", style=solid]; +"3 features_1_1_attn_qkv_bias" -> "435 clone_1" [label="(288,)", style=solid]; +"4 features_1_1_attn_proj_bias" -> "495 linear_9" [label="(96,)", style=solid]; +"5 features_1_1_attn_logit_scale" -> "463 clamp_1" [label="(3, 1, 1)", style=solid]; +"6 features_3_0_attn_qkv_bias" -> "574 clone_2" [label="(576,)", style=solid]; +"7 features_3_0_attn_proj_bias" -> "618 linear_16" [label="(192,)", style=solid]; +"8 features_3_0_attn_logit_scale" -> "602 clamp_2" [label="(6, 1, 1)", style=solid]; +"9 features_3_1_attn_qkv_bias" -> "677 clone_3" [label="(576,)", style=solid]; +"10 features_3_1_attn_proj_bias" -> "737 linear_22" [label="(192,)", style=solid]; +"11 features_3_1_attn_logit_scale" -> "705 clamp_3" [label="(6, 1, 1)", style=solid]; +"12 features_5_0_attn_qkv_bias" -> "819 clone_4" [label="(1152,)", style=solid]; +"13 features_5_0_attn_proj_bias" -> "863 linear_29" [label="(384,)", style=solid]; +"14 features_5_0_attn_logit_scale" -> "847 clamp_4" [label="(12, 1, 1)", style=solid]; +"15 features_5_1_attn_qkv_bias" -> "922 clone_5" [label="(1152,)", style=solid]; +"16 features_5_1_attn_proj_bias" -> "982 linear_35" [label="(384,)", style=solid]; +"17 features_5_1_attn_logit_scale" -> "950 clamp_5" [label="(12, 1, 1)", style=solid]; +"18 features_5_2_attn_qkv_bias" -> "1041 clone_6" [label="(1152,)", style=solid]; +"19 features_5_2_attn_proj_bias" -> "1085 linear_41" [label="(384,)", style=solid]; +"20 features_5_2_attn_logit_scale" -> "1069 clamp_6" [label="(12, 1, 1)", style=solid]; +"21 features_5_3_attn_qkv_bias" -> "1144 clone_7" [label="(1152,)", style=solid]; +"22 features_5_3_attn_proj_bias" -> "1204 linear_47" [label="(384,)", style=solid]; +"23 features_5_3_attn_logit_scale" -> "1172 clamp_7" [label="(12, 1, 1)", style=solid]; +"24 features_5_4_attn_qkv_bias" -> "1263 clone_8" [label="(1152,)", style=solid]; +"25 features_5_4_attn_proj_bias" -> "1307 linear_53" [label="(384,)", style=solid]; +"26 features_5_4_attn_logit_scale" -> "1291 clamp_8" [label="(12, 1, 1)", style=solid]; +"27 features_5_5_attn_qkv_bias" -> "1366 clone_9" [label="(1152,)", style=solid]; +"28 features_5_5_attn_proj_bias" -> "1426 linear_59" [label="(384,)", style=solid]; +"29 features_5_5_attn_logit_scale" -> "1394 clamp_9" [label="(12, 1, 1)", style=solid]; +"30 features_5_6_attn_qkv_bias" -> "1485 clone_10" [label="(1152,)", style=solid]; +"31 features_5_6_attn_proj_bias" -> "1529 linear_65" [label="(384,)", style=solid]; +"32 features_5_6_attn_logit_scale" -> "1513 clamp_10" [label="(12, 1, 1)", style=solid]; +"33 features_5_7_attn_qkv_bias" -> "1588 clone_11" [label="(1152,)", style=solid]; +"34 features_5_7_attn_proj_bias" -> "1648 linear_71" [label="(384,)", style=solid]; +"35 features_5_7_attn_logit_scale" -> "1616 clamp_11" [label="(12, 1, 1)", style=solid]; +"36 features_5_8_attn_qkv_bias" -> "1707 clone_12" [label="(1152,)", style=solid]; +"37 features_5_8_attn_proj_bias" -> "1751 linear_77" [label="(384,)", style=solid]; +"38 features_5_8_attn_logit_scale" -> "1735 clamp_12" [label="(12, 1, 1)", style=solid]; +"39 features_5_9_attn_qkv_bias" -> "1810 clone_13" [label="(1152,)", style=solid]; +"40 features_5_9_attn_proj_bias" -> "1870 linear_83" [label="(384,)", style=solid]; +"41 features_5_9_attn_logit_scale" -> "1838 clamp_13" [label="(12, 1, 1)", style=solid]; +"42 features_5_10_attn_qkv_bias" -> "1929 clone_14" [label="(1152,)", style=solid]; +"43 features_5_10_attn_proj_bias" -> "1973 linear_89" [label="(384,)", style=solid]; +"44 features_5_10_attn_logit_scale" -> "1957 clamp_14" [label="(12, 1, 1)", style=solid]; +"45 features_5_11_attn_qkv_bias" -> "2032 clone_15" [label="(1152,)", style=solid]; +"46 features_5_11_attn_proj_bias" -> "2092 linear_95" [label="(384,)", style=solid]; +"47 features_5_11_attn_logit_scale" -> "2060 clamp_15" [label="(12, 1, 1)", style=solid]; +"48 features_5_12_attn_qkv_bias" -> "2151 clone_16" [label="(1152,)", style=solid]; +"49 features_5_12_attn_proj_bias" -> "2195 linear_101" [label="(384,)", style=solid]; +"50 features_5_12_attn_logit_scale" -> "2179 clamp_16" [label="(12, 1, 1)", style=solid]; +"51 features_5_13_attn_qkv_bias" -> "2254 clone_17" [label="(1152,)", style=solid]; +"52 features_5_13_attn_proj_bias" -> "2314 linear_107" [label="(384,)", style=solid]; +"53 features_5_13_attn_logit_scale" -> "2282 clamp_17" [label="(12, 1, 1)", style=solid]; +"54 features_5_14_attn_qkv_bias" -> "2373 clone_18" [label="(1152,)", style=solid]; +"55 features_5_14_attn_proj_bias" -> "2417 linear_113" [label="(384,)", style=solid]; +"56 features_5_14_attn_logit_scale" -> "2401 clamp_18" [label="(12, 1, 1)", style=solid]; +"57 features_5_15_attn_qkv_bias" -> "2476 clone_19" [label="(1152,)", style=solid]; +"58 features_5_15_attn_proj_bias" -> "2536 linear_119" [label="(384,)", style=solid]; +"59 features_5_15_attn_logit_scale" -> "2504 clamp_19" [label="(12, 1, 1)", style=solid]; +"60 features_5_16_attn_qkv_bias" -> "2595 clone_20" [label="(1152,)", style=solid]; +"61 features_5_16_attn_proj_bias" -> "2639 linear_125" [label="(384,)", style=solid]; +"62 features_5_16_attn_logit_scale" -> "2623 clamp_20" [label="(12, 1, 1)", style=solid]; +"63 features_5_17_attn_qkv_bias" -> "2698 clone_21" [label="(1152,)", style=solid]; +"64 features_5_17_attn_proj_bias" -> "2758 linear_131" [label="(384,)", style=solid]; +"65 features_5_17_attn_logit_scale" -> "2726 clamp_21" [label="(12, 1, 1)", style=solid]; +"66 features_7_0_attn_qkv_bias" -> "2840 clone_22" [label="(2304,)", style=solid]; +"67 features_7_0_attn_proj_bias" -> "2884 linear_138" [label="(768,)", style=solid]; +"68 features_7_0_attn_logit_scale" -> "2868 clamp_22" [label="(24, 1, 1)", style=solid]; +"69 features_7_1_attn_qkv_bias" -> "2942 clone_23" [label="(2304,)", style=solid]; +"70 features_7_1_attn_proj_bias" -> "2986 linear_144" [label="(768,)", style=solid]; +"71 features_7_1_attn_logit_scale" -> "2970 clamp_23" [label="(24, 1, 1)", style=solid]; +"72 features_0_0_bias" -> "307 conv2d" [label="(96,)", style=solid]; +"73 features_0_2_weight" -> "309 layer_norm" [label="(96,)", style=solid]; +"74 features_0_2_bias" -> "309 layer_norm" [label="(96,)", style=solid]; +"75 features_1_0_attn_cpb_mlp_0_bias" -> "315 linear" [label="(512,)", style=solid]; +"76 features_1_0_norm1_weight" -> "386 layer_norm_1" [label="(96,)", style=solid]; +"77 features_1_0_norm1_bias" -> "386 layer_norm_1" [label="(96,)", style=solid]; +"78 features_1_0_mlp_0_bias" -> "395 linear_4" [label="(384,)", style=solid]; +"79 features_1_0_mlp_3_bias" -> "405 linear_5" [label="(96,)", style=solid]; +"80 features_1_0_norm2_weight" -> "407 layer_norm_2" [label="(96,)", style=solid]; +"81 features_1_0_norm2_bias" -> "407 layer_norm_2" [label="(96,)", style=solid]; +"82 features_1_1_attn_cpb_mlp_0_bias" -> "414 linear_6" [label="(512,)", style=solid]; +"83 features_1_1_norm1_weight" -> "503 layer_norm_3" [label="(96,)", style=solid]; +"84 features_1_1_norm1_bias" -> "503 layer_norm_3" [label="(96,)", style=solid]; +"85 features_1_1_mlp_0_bias" -> "512 linear_10" [label="(384,)", style=solid]; +"86 features_1_1_mlp_3_bias" -> "522 linear_11" [label="(96,)", style=solid]; +"87 features_1_1_norm2_weight" -> "524 layer_norm_4" [label="(96,)", style=solid]; +"88 features_1_1_norm2_bias" -> "524 layer_norm_4" [label="(96,)", style=solid]; +"89 features_2_norm_weight" -> "548 layer_norm_5" [label="(192,)", style=solid]; +"90 features_2_norm_bias" -> "548 layer_norm_5" [label="(192,)", style=solid]; +"91 features_3_0_attn_cpb_mlp_0_bias" -> "554 linear_13" [label="(512,)", style=solid]; +"92 features_3_0_norm1_weight" -> "628 layer_norm_6" [label="(192,)", style=solid]; +"93 features_3_0_norm1_bias" -> "628 layer_norm_6" [label="(192,)", style=solid]; +"94 features_3_0_mlp_0_bias" -> "637 linear_17" [label="(768,)", style=solid]; +"95 features_3_0_mlp_3_bias" -> "647 linear_18" [label="(192,)", style=solid]; +"96 features_3_0_norm2_weight" -> "649 layer_norm_7" [label="(192,)", style=solid]; +"97 features_3_0_norm2_bias" -> "649 layer_norm_7" [label="(192,)", style=solid]; +"98 features_3_1_attn_cpb_mlp_0_bias" -> "656 linear_19" [label="(512,)", style=solid]; +"99 features_3_1_norm1_weight" -> "748 layer_norm_8" [label="(192,)", style=solid]; +"100 features_3_1_norm1_bias" -> "748 layer_norm_8" [label="(192,)", style=solid]; +"101 features_3_1_mlp_0_bias" -> "757 linear_23" [label="(768,)", style=solid]; +"102 features_3_1_mlp_3_bias" -> "767 linear_24" [label="(192,)", style=solid]; +"103 features_3_1_norm2_weight" -> "769 layer_norm_9" [label="(192,)", style=solid]; +"104 features_3_1_norm2_bias" -> "769 layer_norm_9" [label="(192,)", style=solid]; +"105 features_4_norm_weight" -> "793 layer_norm_10" [label="(384,)", style=solid]; +"106 features_4_norm_bias" -> "793 layer_norm_10" [label="(384,)", style=solid]; +"107 features_5_0_attn_cpb_mlp_0_bias" -> "799 linear_26" [label="(512,)", style=solid]; +"108 features_5_0_norm1_weight" -> "873 layer_norm_11" [label="(384,)", style=solid]; +"109 features_5_0_norm1_bias" -> "873 layer_norm_11" [label="(384,)", style=solid]; +"110 features_5_0_mlp_0_bias" -> "882 linear_30" [label="(1536,)", style=solid]; +"111 features_5_0_mlp_3_bias" -> "892 linear_31" [label="(384,)", style=solid]; +"112 features_5_0_norm2_weight" -> "894 layer_norm_12" [label="(384,)", style=solid]; +"113 features_5_0_norm2_bias" -> "894 layer_norm_12" [label="(384,)", style=solid]; +"114 features_5_1_attn_cpb_mlp_0_bias" -> "901 linear_32" [label="(512,)", style=solid]; +"115 features_5_1_norm1_weight" -> "993 layer_norm_13" [label="(384,)", style=solid]; +"116 features_5_1_norm1_bias" -> "993 layer_norm_13" [label="(384,)", style=solid]; +"117 features_5_1_mlp_0_bias" -> "1002 linear_36" [label="(1536,)", style=solid]; +"118 features_5_1_mlp_3_bias" -> "1012 linear_37" [label="(384,)", style=solid]; +"119 features_5_1_norm2_weight" -> "1014 layer_norm_14" [label="(384,)", style=solid]; +"120 features_5_1_norm2_bias" -> "1014 layer_norm_14" [label="(384,)", style=solid]; +"121 features_5_2_attn_cpb_mlp_0_bias" -> "1021 linear_38" [label="(512,)", style=solid]; +"122 features_5_2_norm1_weight" -> "1095 layer_norm_15" [label="(384,)", style=solid]; +"123 features_5_2_norm1_bias" -> "1095 layer_norm_15" [label="(384,)", style=solid]; +"124 features_5_2_mlp_0_bias" -> "1104 linear_42" [label="(1536,)", style=solid]; +"125 features_5_2_mlp_3_bias" -> "1114 linear_43" [label="(384,)", style=solid]; +"126 features_5_2_norm2_weight" -> "1116 layer_norm_16" [label="(384,)", style=solid]; +"127 features_5_2_norm2_bias" -> "1116 layer_norm_16" [label="(384,)", style=solid]; +"128 features_5_3_attn_cpb_mlp_0_bias" -> "1123 linear_44" [label="(512,)", style=solid]; +"129 features_5_3_norm1_weight" -> "1215 layer_norm_17" [label="(384,)", style=solid]; +"130 features_5_3_norm1_bias" -> "1215 layer_norm_17" [label="(384,)", style=solid]; +"131 features_5_3_mlp_0_bias" -> "1224 linear_48" [label="(1536,)", style=solid]; +"132 features_5_3_mlp_3_bias" -> "1234 linear_49" [label="(384,)", style=solid]; +"133 features_5_3_norm2_weight" -> "1236 layer_norm_18" [label="(384,)", style=solid]; +"134 features_5_3_norm2_bias" -> "1236 layer_norm_18" [label="(384,)", style=solid]; +"135 features_5_4_attn_cpb_mlp_0_bias" -> "1243 linear_50" [label="(512,)", style=solid]; +"136 features_5_4_norm1_weight" -> "1317 layer_norm_19" [label="(384,)", style=solid]; +"137 features_5_4_norm1_bias" -> "1317 layer_norm_19" [label="(384,)", style=solid]; +"138 features_5_4_mlp_0_bias" -> "1326 linear_54" [label="(1536,)", style=solid]; +"139 features_5_4_mlp_3_bias" -> "1336 linear_55" [label="(384,)", style=solid]; +"140 features_5_4_norm2_weight" -> "1338 layer_norm_20" [label="(384,)", style=solid]; +"141 features_5_4_norm2_bias" -> "1338 layer_norm_20" [label="(384,)", style=solid]; +"142 features_5_5_attn_cpb_mlp_0_bias" -> "1345 linear_56" [label="(512,)", style=solid]; +"143 features_5_5_norm1_weight" -> "1437 layer_norm_21" [label="(384,)", style=solid]; +"144 features_5_5_norm1_bias" -> "1437 layer_norm_21" [label="(384,)", style=solid]; +"145 features_5_5_mlp_0_bias" -> "1446 linear_60" [label="(1536,)", style=solid]; +"146 features_5_5_mlp_3_bias" -> "1456 linear_61" [label="(384,)", style=solid]; +"147 features_5_5_norm2_weight" -> "1458 layer_norm_22" [label="(384,)", style=solid]; +"148 features_5_5_norm2_bias" -> "1458 layer_norm_22" [label="(384,)", style=solid]; +"149 features_5_6_attn_cpb_mlp_0_bias" -> "1465 linear_62" [label="(512,)", style=solid]; +"150 features_5_6_norm1_weight" -> "1539 layer_norm_23" [label="(384,)", style=solid]; +"151 features_5_6_norm1_bias" -> "1539 layer_norm_23" [label="(384,)", style=solid]; +"152 features_5_6_mlp_0_bias" -> "1548 linear_66" [label="(1536,)", style=solid]; +"153 features_5_6_mlp_3_bias" -> "1558 linear_67" [label="(384,)", style=solid]; +"154 features_5_6_norm2_weight" -> "1560 layer_norm_24" [label="(384,)", style=solid]; +"155 features_5_6_norm2_bias" -> "1560 layer_norm_24" [label="(384,)", style=solid]; +"156 features_5_7_attn_cpb_mlp_0_bias" -> "1567 linear_68" [label="(512,)", style=solid]; +"157 features_5_7_norm1_weight" -> "1659 layer_norm_25" [label="(384,)", style=solid]; +"158 features_5_7_norm1_bias" -> "1659 layer_norm_25" [label="(384,)", style=solid]; +"159 features_5_7_mlp_0_bias" -> "1668 linear_72" [label="(1536,)", style=solid]; +"160 features_5_7_mlp_3_bias" -> "1678 linear_73" [label="(384,)", style=solid]; +"161 features_5_7_norm2_weight" -> "1680 layer_norm_26" [label="(384,)", style=solid]; +"162 features_5_7_norm2_bias" -> "1680 layer_norm_26" [label="(384,)", style=solid]; +"163 features_5_8_attn_cpb_mlp_0_bias" -> "1687 linear_74" [label="(512,)", style=solid]; +"164 features_5_8_norm1_weight" -> "1761 layer_norm_27" [label="(384,)", style=solid]; +"165 features_5_8_norm1_bias" -> "1761 layer_norm_27" [label="(384,)", style=solid]; +"166 features_5_8_mlp_0_bias" -> "1770 linear_78" [label="(1536,)", style=solid]; +"167 features_5_8_mlp_3_bias" -> "1780 linear_79" [label="(384,)", style=solid]; +"168 features_5_8_norm2_weight" -> "1782 layer_norm_28" [label="(384,)", style=solid]; +"169 features_5_8_norm2_bias" -> "1782 layer_norm_28" [label="(384,)", style=solid]; +"170 features_5_9_attn_cpb_mlp_0_bias" -> "1789 linear_80" [label="(512,)", style=solid]; +"171 features_5_9_norm1_weight" -> "1881 layer_norm_29" [label="(384,)", style=solid]; +"172 features_5_9_norm1_bias" -> "1881 layer_norm_29" [label="(384,)", style=solid]; +"173 features_5_9_mlp_0_bias" -> "1890 linear_84" [label="(1536,)", style=solid]; +"174 features_5_9_mlp_3_bias" -> "1900 linear_85" [label="(384,)", style=solid]; +"175 features_5_9_norm2_weight" -> "1902 layer_norm_30" [label="(384,)", style=solid]; +"176 features_5_9_norm2_bias" -> "1902 layer_norm_30" [label="(384,)", style=solid]; +"177 features_5_10_attn_cpb_mlp_0_bias" -> "1909 linear_86" [label="(512,)", style=solid]; +"178 features_5_10_norm1_weight" -> "1983 layer_norm_31" [label="(384,)", style=solid]; +"179 features_5_10_norm1_bias" -> "1983 layer_norm_31" [label="(384,)", style=solid]; +"180 features_5_10_mlp_0_bias" -> "1992 linear_90" [label="(1536,)", style=solid]; +"181 features_5_10_mlp_3_bias" -> "2002 linear_91" [label="(384,)", style=solid]; +"182 features_5_10_norm2_weight" -> "2004 layer_norm_32" [label="(384,)", style=solid]; +"183 features_5_10_norm2_bias" -> "2004 layer_norm_32" [label="(384,)", style=solid]; +"184 features_5_11_attn_cpb_mlp_0_bias" -> "2011 linear_92" [label="(512,)", style=solid]; +"185 features_5_11_norm1_weight" -> "2103 layer_norm_33" [label="(384,)", style=solid]; +"186 features_5_11_norm1_bias" -> "2103 layer_norm_33" [label="(384,)", style=solid]; +"187 features_5_11_mlp_0_bias" -> "2112 linear_96" [label="(1536,)", style=solid]; +"188 features_5_11_mlp_3_bias" -> "2122 linear_97" [label="(384,)", style=solid]; +"189 features_5_11_norm2_weight" -> "2124 layer_norm_34" [label="(384,)", style=solid]; +"190 features_5_11_norm2_bias" -> "2124 layer_norm_34" [label="(384,)", style=solid]; +"191 features_5_12_attn_cpb_mlp_0_bias" -> "2131 linear_98" [label="(512,)", style=solid]; +"192 features_5_12_norm1_weight" -> "2205 layer_norm_35" [label="(384,)", style=solid]; +"193 features_5_12_norm1_bias" -> "2205 layer_norm_35" [label="(384,)", style=solid]; +"194 features_5_12_mlp_0_bias" -> "2214 linear_102" [label="(1536,)", style=solid]; +"195 features_5_12_mlp_3_bias" -> "2224 linear_103" [label="(384,)", style=solid]; +"196 features_5_12_norm2_weight" -> "2226 layer_norm_36" [label="(384,)", style=solid]; +"197 features_5_12_norm2_bias" -> "2226 layer_norm_36" [label="(384,)", style=solid]; +"198 features_5_13_attn_cpb_mlp_0_bias" -> "2233 linear_104" [label="(512,)", style=solid]; +"199 features_5_13_norm1_weight" -> "2325 layer_norm_37" [label="(384,)", style=solid]; +"200 features_5_13_norm1_bias" -> "2325 layer_norm_37" [label="(384,)", style=solid]; +"201 features_5_13_mlp_0_bias" -> "2334 linear_108" [label="(1536,)", style=solid]; +"202 features_5_13_mlp_3_bias" -> "2344 linear_109" [label="(384,)", style=solid]; +"203 features_5_13_norm2_weight" -> "2346 layer_norm_38" [label="(384,)", style=solid]; +"204 features_5_13_norm2_bias" -> "2346 layer_norm_38" [label="(384,)", style=solid]; +"205 features_5_14_attn_cpb_mlp_0_bias" -> "2353 linear_110" [label="(512,)", style=solid]; +"206 features_5_14_norm1_weight" -> "2427 layer_norm_39" [label="(384,)", style=solid]; +"207 features_5_14_norm1_bias" -> "2427 layer_norm_39" [label="(384,)", style=solid]; +"208 features_5_14_mlp_0_bias" -> "2436 linear_114" [label="(1536,)", style=solid]; +"209 features_5_14_mlp_3_bias" -> "2446 linear_115" [label="(384,)", style=solid]; +"210 features_5_14_norm2_weight" -> "2448 layer_norm_40" [label="(384,)", style=solid]; +"211 features_5_14_norm2_bias" -> "2448 layer_norm_40" [label="(384,)", style=solid]; +"212 features_5_15_attn_cpb_mlp_0_bias" -> "2455 linear_116" [label="(512,)", style=solid]; +"213 features_5_15_norm1_weight" -> "2547 layer_norm_41" [label="(384,)", style=solid]; +"214 features_5_15_norm1_bias" -> "2547 layer_norm_41" [label="(384,)", style=solid]; +"215 features_5_15_mlp_0_bias" -> "2556 linear_120" [label="(1536,)", style=solid]; +"216 features_5_15_mlp_3_bias" -> "2566 linear_121" [label="(384,)", style=solid]; +"217 features_5_15_norm2_weight" -> "2568 layer_norm_42" [label="(384,)", style=solid]; +"218 features_5_15_norm2_bias" -> "2568 layer_norm_42" [label="(384,)", style=solid]; +"219 features_5_16_attn_cpb_mlp_0_bias" -> "2575 linear_122" [label="(512,)", style=solid]; +"220 features_5_16_norm1_weight" -> "2649 layer_norm_43" [label="(384,)", style=solid]; +"221 features_5_16_norm1_bias" -> "2649 layer_norm_43" [label="(384,)", style=solid]; +"222 features_5_16_mlp_0_bias" -> "2658 linear_126" [label="(1536,)", style=solid]; +"223 features_5_16_mlp_3_bias" -> "2668 linear_127" [label="(384,)", style=solid]; +"224 features_5_16_norm2_weight" -> "2670 layer_norm_44" [label="(384,)", style=solid]; +"225 features_5_16_norm2_bias" -> "2670 layer_norm_44" [label="(384,)", style=solid]; +"226 features_5_17_attn_cpb_mlp_0_bias" -> "2677 linear_128" [label="(512,)", style=solid]; +"227 features_5_17_norm1_weight" -> "2769 layer_norm_45" [label="(384,)", style=solid]; +"228 features_5_17_norm1_bias" -> "2769 layer_norm_45" [label="(384,)", style=solid]; +"229 features_5_17_mlp_0_bias" -> "2778 linear_132" [label="(1536,)", style=solid]; +"230 features_5_17_mlp_3_bias" -> "2788 linear_133" [label="(384,)", style=solid]; +"231 features_5_17_norm2_weight" -> "2790 layer_norm_46" [label="(384,)", style=solid]; +"232 features_5_17_norm2_bias" -> "2790 layer_norm_46" [label="(384,)", style=solid]; +"233 features_6_norm_weight" -> "2814 layer_norm_47" [label="(768,)", style=solid]; +"234 features_6_norm_bias" -> "2814 layer_norm_47" [label="(768,)", style=solid]; +"235 features_7_0_attn_cpb_mlp_0_bias" -> "2820 linear_135" [label="(512,)", style=solid]; +"236 features_7_0_norm1_weight" -> "2894 layer_norm_48" [label="(768,)", style=solid]; +"237 features_7_0_norm1_bias" -> "2894 layer_norm_48" [label="(768,)", style=solid]; +"238 features_7_0_mlp_0_bias" -> "2903 linear_139" [label="(3072,)", style=solid]; +"239 features_7_0_mlp_3_bias" -> "2913 linear_140" [label="(768,)", style=solid]; +"240 features_7_0_norm2_weight" -> "2915 layer_norm_49" [label="(768,)", style=solid]; +"241 features_7_0_norm2_bias" -> "2915 layer_norm_49" [label="(768,)", style=solid]; +"242 features_7_1_attn_cpb_mlp_0_bias" -> "2922 linear_141" [label="(512,)", style=solid]; +"243 features_7_1_norm1_weight" -> "2996 layer_norm_50" [label="(768,)", style=solid]; +"244 features_7_1_norm1_bias" -> "2996 layer_norm_50" [label="(768,)", style=solid]; +"245 features_7_1_mlp_0_bias" -> "3005 linear_145" [label="(3072,)", style=solid]; +"246 features_7_1_mlp_3_bias" -> "3015 linear_146" [label="(768,)", style=solid]; +"247 features_7_1_norm2_weight" -> "3017 layer_norm_51" [label="(768,)", style=solid]; +"248 features_7_1_norm2_bias" -> "3017 layer_norm_51" [label="(768,)", style=solid]; +"249 norm_weight" -> "3019 layer_norm_52" [label="(768,)", style=solid]; +"250 norm_bias" -> "3019 layer_norm_52" [label="(768,)", style=solid]; +"251 head_bias" -> "3030 linear_147" [label="(1000,)", style=solid]; +"252 features_1_0_attn_relative_coords_table" -> "310 features_1_0_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 2)", style=solid]; +"253 features_1_0_attn_relative_position_index" -> "324 index" [label="(4096,)", style=solid]; +"254 features_1_1_attn_relative_coords_table" -> "409 features_1_1_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 2)", style=solid]; +"255 features_1_1_attn_relative_position_index" -> "423 index_1" [label="(4096,)", style=solid]; +"256 features_3_0_attn_relative_coords_table" -> "549 features_3_0_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 2)", style=solid]; +"257 features_3_0_attn_relative_position_index" -> "563 index_2" [label="(4096,)", style=solid]; +"258 features_3_1_attn_relative_coords_table" -> "651 features_3_1_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 2)", style=solid]; +"259 features_3_1_attn_relative_position_index" -> "665 index_3" [label="(4096,)", style=solid]; +"260 features_5_0_attn_relative_coords_table" -> "794 features_5_0_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 2)", style=solid]; +"261 features_5_0_attn_relative_position_index" -> "808 index_4" [label="(4096,)", style=solid]; +"262 features_5_1_attn_relative_coords_table" -> "896 features_5_1_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 2)", style=solid]; +"263 features_5_1_attn_relative_position_index" -> "910 index_5" [label="(4096,)", style=solid]; +"264 features_5_2_attn_relative_coords_table" -> "1016 features_5_2_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 2)", style=solid]; +"265 features_5_2_attn_relative_position_index" -> "1030 index_6" [label="(4096,)", style=solid]; +"266 features_5_3_attn_relative_coords_table" -> "1118 features_5_3_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 2)", style=solid]; +"267 features_5_3_attn_relative_position_index" -> "1132 index_7" [label="(4096,)", style=solid]; +"268 features_5_4_attn_relative_coords_table" -> "1238 features_5_4_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 2)", style=solid]; +"269 features_5_4_attn_relative_position_index" -> "1252 index_8" [label="(4096,)", style=solid]; +"270 features_5_5_attn_relative_coords_table" -> "1340 features_5_5_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 2)", style=solid]; +"271 features_5_5_attn_relative_position_index" -> "1354 index_9" [label="(4096,)", style=solid]; +"272 features_5_6_attn_relative_coords_table" -> "1460 features_5_6_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 2)", style=solid]; +"273 features_5_6_attn_relative_position_index" -> "1474 index_10" [label="(4096,)", style=solid]; +"274 features_5_7_attn_relative_coords_table" -> "1562 features_5_7_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 2)", style=solid]; +"275 features_5_7_attn_relative_position_index" -> "1576 index_11" [label="(4096,)", style=solid]; +"276 features_5_8_attn_relative_coords_table" -> "1682 features_5_8_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 2)", style=solid]; +"277 features_5_8_attn_relative_position_index" -> "1696 index_12" [label="(4096,)", style=solid]; +"278 features_5_9_attn_relative_coords_table" -> "1784 features_5_9_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 2)", style=solid]; +"279 features_5_9_attn_relative_position_index" -> "1798 index_13" [label="(4096,)", style=solid]; +"280 features_5_10_attn_relative_coords_table" -> "1904 features_5_10_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 2)", style=solid]; +"281 features_5_10_attn_relative_position_index" -> "1918 index_14" [label="(4096,)", style=solid]; +"282 features_5_11_attn_relative_coords_table" -> "2006 features_5_11_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 2)", style=solid]; +"283 features_5_11_attn_relative_position_index" -> "2020 index_15" [label="(4096,)", style=solid]; +"284 features_5_12_attn_relative_coords_table" -> "2126 features_5_12_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 2)", style=solid]; +"285 features_5_12_attn_relative_position_index" -> "2140 index_16" [label="(4096,)", style=solid]; +"286 features_5_13_attn_relative_coords_table" -> "2228 features_5_13_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 2)", style=solid]; +"287 features_5_13_attn_relative_position_index" -> "2242 index_17" [label="(4096,)", style=solid]; +"288 features_5_14_attn_relative_coords_table" -> "2348 features_5_14_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 2)", style=solid]; +"289 features_5_14_attn_relative_position_index" -> "2362 index_18" [label="(4096,)", style=solid]; +"290 features_5_15_attn_relative_coords_table" -> "2450 features_5_15_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 2)", style=solid]; +"291 features_5_15_attn_relative_position_index" -> "2464 index_19" [label="(4096,)", style=solid]; +"292 features_5_16_attn_relative_coords_table" -> "2570 features_5_16_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 2)", style=solid]; +"293 features_5_16_attn_relative_position_index" -> "2584 index_20" [label="(4096,)", style=solid]; +"294 features_5_17_attn_relative_coords_table" -> "2672 features_5_17_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 2)", style=solid]; +"295 features_5_17_attn_relative_position_index" -> "2686 index_21" [label="(4096,)", style=solid]; +"296 features_7_0_attn_relative_coords_table" -> "2815 features_7_0_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 2)", style=solid]; +"297 features_7_0_attn_relative_position_index" -> "2829 index_22" [label="(4096,)", style=solid]; +"298 features_7_1_attn_relative_coords_table" -> "2917 features_7_1_attn_relative_coords_table_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 2)", style=solid]; +"299 features_7_1_attn_relative_position_index" -> "2931 index_23" [label="(4096,)", style=solid]; +"300 x" -> "301 quantize_per_tensor_default" [label="(1, 3, 224, 224)", style=solid]; +"301 quantize_per_tensor_default" -> "302 dequantize_per_tensor_default" [label="(1, 3, 224, 224)", style=solid]; +"302 dequantize_per_tensor_default" -> "307 conv2d" [label="(1, 3, 224, 224)", style=solid]; +"303 conv2d_scale_0" -> "306 dequantize_per_channel_default" [label="(96,)", style=solid]; +"304 conv2d_zero_point_0" -> "306 dequantize_per_channel_default" [label="(96,)", style=solid]; +"305 _frozen_param0" -> "306 dequantize_per_channel_default" [label="(96, 3, 4, 4)", style=solid]; +"306 dequantize_per_channel_default" -> "307 conv2d" [label="(96, 3, 4, 4)", style=solid]; +"307 conv2d" -> "308 permute" [label="(1, 96, 56, 56)", style=solid]; +"308 permute" -> "309 layer_norm" [label="(1, 56, 56, 96)", style=solid]; +"309 layer_norm" -> "331 pad" [label="(1, 56, 56, 96)", style=solid]; +"309 layer_norm" -> "387 add_1" [label="(1, 56, 56, 96)", style=solid]; +"310 features_1_0_attn_relative_coords_table_0_0_nncf_smooth_quant_0" -> "315 linear" [label="(1, 15, 15, 2)", style=solid]; +"311 linear_scale_0" -> "314 dequantize_per_channel_default_1" [label="(512,)", style=solid]; +"312 linear_zero_point_0" -> "314 dequantize_per_channel_default_1" [label="(512,)", style=solid]; +"313 _frozen_param1" -> "314 dequantize_per_channel_default_1" [label="(512, 2)", style=solid]; +"314 dequantize_per_channel_default_1" -> "315 linear" [label="(512, 2)", style=solid]; +"315 linear" -> "316 relu_" [label="(1, 15, 15, 512)", style=solid]; +"316 relu_" -> "317 relu__0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 512)", style=solid]; +"317 relu__0_0_nncf_smooth_quant_0" -> "322 linear_1" [label="(1, 15, 15, 512)", style=solid]; +"318 linear_1_scale_0" -> "321 dequantize_per_channel_default_2" [label="(3,)", style=solid]; +"319 linear_1_zero_point_0" -> "321 dequantize_per_channel_default_2" [label="(3,)", style=solid]; +"320 _frozen_param2" -> "321 dequantize_per_channel_default_2" [label="(3, 512)", style=solid]; +"321 dequantize_per_channel_default_2" -> "322 linear_1" [label="(3, 512)", style=solid]; +"322 linear_1" -> "323 view" [label="(1, 15, 15, 3)", style=solid]; +"323 view" -> "324 index" [label="(225, 3)", style=solid]; +"324 index" -> "325 view_1" [label="(4096, 3)", style=solid]; +"325 view_1" -> "326 permute_1" [label="(64, 64, 3)", style=solid]; +"326 permute_1" -> "327 contiguous" [label="(3, 64, 64)", style=solid]; +"327 contiguous" -> "328 unsqueeze" [label="(3, 64, 64)", style=solid]; +"328 unsqueeze" -> "329 sigmoid" [label="(1, 3, 64, 64)", style=solid]; +"329 sigmoid" -> "330 mul" [label="(1, 3, 64, 64)", style=solid]; +"330 mul" -> "366 add" [label="(1, 3, 64, 64)", style=solid]; +"331 pad" -> "332 view_2" [label="(1, 56, 56, 96)", style=solid]; +"332 view_2" -> "333 permute_2" [label="(1, 7, 8, 7, 8, 96)", style=solid]; +"333 permute_2" -> "334 reshape" [label="(1, 7, 7, 8, 8, 96)", style=solid]; +"334 reshape" -> "336 reshape_0_0_nncf_smooth_quant_0" [label="(49, 64, 96)", style=solid]; +"335 clone" -> "343 linear_2" [label="(288,)", style=solid]; +"336 reshape_0_0_nncf_smooth_quant_0" -> "337 quantize_per_tensor_default_1" [label="(49, 64, 96)", style=solid]; +"337 quantize_per_tensor_default_1" -> "338 dequantize_per_tensor_default_1" [label="(49, 64, 96)", style=solid]; +"338 dequantize_per_tensor_default_1" -> "343 linear_2" [label="(49, 64, 96)", style=solid]; +"339 linear_2_scale_0" -> "342 dequantize_per_channel_default_3" [label="(288,)", style=solid]; +"340 linear_2_zero_point_0" -> "342 dequantize_per_channel_default_3" [label="(288,)", style=solid]; +"341 _frozen_param3" -> "342 dequantize_per_channel_default_3" [label="(288, 96)", style=solid]; +"342 dequantize_per_channel_default_3" -> "343 linear_2" [label="(288, 96)", style=solid]; +"343 linear_2" -> "344 reshape_1" [label="(49, 64, 288)", style=solid]; +"344 reshape_1" -> "345 permute_3" [label="(49, 64, 3, 3, 32)", style=solid]; +"345 permute_3" -> "346 select" [label="(3, 49, 3, 64, 32)", style=solid]; +"345 permute_3" -> "347 select_1" [label="(3, 49, 3, 64, 32)", style=solid]; +"345 permute_3" -> "348 select_2" [label="(3, 49, 3, 64, 32)", style=solid]; +"346 select" -> "349 linalg_vector_norm" [label="(49, 3, 64, 32)", style=solid]; +"346 select" -> "351 expand_as" [label="(49, 3, 64, 32)", style=solid]; +"346 select" -> "352 div" [label="(49, 3, 64, 32)", style=solid]; +"347 select_1" -> "355 linalg_vector_norm_1" [label="(49, 3, 64, 32)", style=solid]; +"347 select_1" -> "357 expand_as_1" [label="(49, 3, 64, 32)", style=solid]; +"347 select_1" -> "358 div_1" [label="(49, 3, 64, 32)", style=solid]; +"348 select_2" -> "369 matmul_1" [label="(49, 3, 64, 32)", style=solid]; +"349 linalg_vector_norm" -> "350 clamp_min" [label="(49, 3, 64, 1)", style=solid]; +"350 clamp_min" -> "351 expand_as" [label="(49, 3, 64, 1)", style=solid]; +"351 expand_as" -> "352 div" [label="(49, 3, 64, 32)", style=solid]; +"352 div" -> "353 quantize_per_tensor_default_2" [label="(49, 3, 64, 32)", style=solid]; +"353 quantize_per_tensor_default_2" -> "354 dequantize_per_tensor_default_2" [label="(49, 3, 64, 32)", style=solid]; +"354 dequantize_per_tensor_default_2" -> "362 matmul" [label="(49, 3, 64, 32)", style=solid]; +"355 linalg_vector_norm_1" -> "356 clamp_min_1" [label="(49, 3, 64, 1)", style=solid]; +"356 clamp_min_1" -> "357 expand_as_1" [label="(49, 3, 64, 1)", style=solid]; +"357 expand_as_1" -> "358 div_1" [label="(49, 3, 64, 32)", style=solid]; +"358 div_1" -> "359 quantize_per_tensor_default_3" [label="(49, 3, 64, 32)", style=solid]; +"359 quantize_per_tensor_default_3" -> "360 dequantize_per_tensor_default_3" [label="(49, 3, 64, 32)", style=solid]; +"360 dequantize_per_tensor_default_3" -> "361 transpose" [label="(49, 3, 64, 32)", style=solid]; +"361 transpose" -> "362 matmul" [label="(49, 3, 32, 64)", style=solid]; +"362 matmul" -> "365 mul_1" [label="(49, 3, 64, 64)", style=solid]; +"363 clamp" -> "364 exp" [label="(3, 1, 1)", style=solid]; +"364 exp" -> "365 mul_1" [label="(3, 1, 1)", style=solid]; +"365 mul_1" -> "366 add" [label="(49, 3, 64, 64)", style=solid]; +"366 add" -> "367 softmax" [label="(49, 3, 64, 64)", style=solid]; +"367 softmax" -> "368 dropout" [label="(49, 3, 64, 64)", style=solid]; +"368 dropout" -> "369 matmul_1" [label="(49, 3, 64, 64)", style=solid]; +"369 matmul_1" -> "370 transpose_1" [label="(49, 3, 64, 32)", style=solid]; +"370 transpose_1" -> "371 reshape_2" [label="(49, 64, 3, 32)", style=solid]; +"371 reshape_2" -> "372 reshape_2_0_0_nncf_smooth_quant_0" [label="(49, 64, 96)", style=solid]; +"372 reshape_2_0_0_nncf_smooth_quant_0" -> "373 quantize_per_tensor_default_4" [label="(49, 64, 96)", style=solid]; +"373 quantize_per_tensor_default_4" -> "374 dequantize_per_tensor_default_4" [label="(49, 64, 96)", style=solid]; +"374 dequantize_per_tensor_default_4" -> "379 linear_3" [label="(49, 64, 96)", style=solid]; +"375 linear_3_scale_0" -> "378 dequantize_per_channel_default_4" [label="(96,)", style=solid]; +"376 linear_3_zero_point_0" -> "378 dequantize_per_channel_default_4" [label="(96,)", style=solid]; +"377 _frozen_param4" -> "378 dequantize_per_channel_default_4" [label="(96, 96)", style=solid]; +"378 dequantize_per_channel_default_4" -> "379 linear_3" [label="(96, 96)", style=solid]; +"379 linear_3" -> "380 dropout_1" [label="(49, 64, 96)", style=solid]; +"380 dropout_1" -> "381 view_3" [label="(49, 64, 96)", style=solid]; +"381 view_3" -> "382 permute_4" [label="(1, 7, 7, 8, 8, 96)", style=solid]; +"382 permute_4" -> "383 reshape_3" [label="(1, 7, 8, 7, 8, 96)", style=solid]; +"383 reshape_3" -> "384 slice_2" [label="(1, 56, 56, 96)", style=solid]; +"384 slice_2" -> "385 slice_3" [label="(1, 56, 56, 96)", style=solid]; +"385 slice_3" -> "386 layer_norm_1" [label="(1, 56, 56, 96)", style=solid]; +"386 layer_norm_1" -> "387 add_1" [label="(1, 56, 56, 96)", style=solid]; +"387 add_1" -> "388 add_1_0_0_nncf_smooth_quant_0" [label="(1, 56, 56, 96)", style=solid]; +"387 add_1" -> "408 add_2" [label="(1, 56, 56, 96)", style=solid]; +"388 add_1_0_0_nncf_smooth_quant_0" -> "389 quantize_per_tensor_default_5" [label="(1, 56, 56, 96)", style=solid]; +"389 quantize_per_tensor_default_5" -> "390 dequantize_per_tensor_default_5" [label="(1, 56, 56, 96)", style=solid]; +"390 dequantize_per_tensor_default_5" -> "395 linear_4" [label="(1, 56, 56, 96)", style=solid]; +"391 linear_4_scale_0" -> "394 dequantize_per_channel_default_5" [label="(384,)", style=solid]; +"392 linear_4_zero_point_0" -> "394 dequantize_per_channel_default_5" [label="(384,)", style=solid]; +"393 _frozen_param5" -> "394 dequantize_per_channel_default_5" [label="(384, 96)", style=solid]; +"394 dequantize_per_channel_default_5" -> "395 linear_4" [label="(384, 96)", style=solid]; +"395 linear_4" -> "396 gelu" [label="(1, 56, 56, 384)", style=solid]; +"396 gelu" -> "397 dropout_2" [label="(1, 56, 56, 384)", style=solid]; +"397 dropout_2" -> "398 dropout_2_0_0_nncf_smooth_quant_0" [label="(1, 56, 56, 384)", style=solid]; +"398 dropout_2_0_0_nncf_smooth_quant_0" -> "399 quantize_per_tensor_default_6" [label="(1, 56, 56, 384)", style=solid]; +"399 quantize_per_tensor_default_6" -> "400 dequantize_per_tensor_default_6" [label="(1, 56, 56, 384)", style=solid]; +"400 dequantize_per_tensor_default_6" -> "405 linear_5" [label="(1, 56, 56, 384)", style=solid]; +"401 linear_5_scale_0" -> "404 dequantize_per_channel_default_6" [label="(96,)", style=solid]; +"402 linear_5_zero_point_0" -> "404 dequantize_per_channel_default_6" [label="(96,)", style=solid]; +"403 _frozen_param6" -> "404 dequantize_per_channel_default_6" [label="(96, 384)", style=solid]; +"404 dequantize_per_channel_default_6" -> "405 linear_5" [label="(96, 384)", style=solid]; +"405 linear_5" -> "406 dropout_3" [label="(1, 56, 56, 96)", style=solid]; +"406 dropout_3" -> "407 layer_norm_2" [label="(1, 56, 56, 96)", style=solid]; +"407 layer_norm_2" -> "408 add_2" [label="(1, 56, 56, 96)", style=solid]; +"408 add_2" -> "430 pad_1" [label="(1, 56, 56, 96)", style=solid]; +"408 add_2" -> "504 add_5" [label="(1, 56, 56, 96)", style=solid]; +"409 features_1_1_attn_relative_coords_table_0_0_nncf_smooth_quant_0" -> "414 linear_6" [label="(1, 15, 15, 2)", style=solid]; +"410 linear_6_scale_0" -> "413 dequantize_per_channel_default_7" [label="(512,)", style=solid]; +"411 linear_6_zero_point_0" -> "413 dequantize_per_channel_default_7" [label="(512,)", style=solid]; +"412 _frozen_param7" -> "413 dequantize_per_channel_default_7" [label="(512, 2)", style=solid]; +"413 dequantize_per_channel_default_7" -> "414 linear_6" [label="(512, 2)", style=solid]; +"414 linear_6" -> "415 relu__1" [label="(1, 15, 15, 512)", style=solid]; +"415 relu__1" -> "416 relu__1_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 512)", style=solid]; +"416 relu__1_0_0_nncf_smooth_quant_0" -> "421 linear_7" [label="(1, 15, 15, 512)", style=solid]; +"417 linear_7_scale_0" -> "420 dequantize_per_channel_default_8" [label="(3,)", style=solid]; +"418 linear_7_zero_point_0" -> "420 dequantize_per_channel_default_8" [label="(3,)", style=solid]; +"419 _frozen_param8" -> "420 dequantize_per_channel_default_8" [label="(3, 512)", style=solid]; +"420 dequantize_per_channel_default_8" -> "421 linear_7" [label="(3, 512)", style=solid]; +"421 linear_7" -> "422 view_4" [label="(1, 15, 15, 3)", style=solid]; +"422 view_4" -> "423 index_1" [label="(225, 3)", style=solid]; +"423 index_1" -> "424 view_5" [label="(4096, 3)", style=solid]; +"424 view_5" -> "425 permute_5" [label="(64, 64, 3)", style=solid]; +"425 permute_5" -> "426 contiguous_1" [label="(3, 64, 64)", style=solid]; +"426 contiguous_1" -> "427 unsqueeze_1" [label="(3, 64, 64)", style=solid]; +"427 unsqueeze_1" -> "428 sigmoid_1" [label="(1, 3, 64, 64)", style=solid]; +"428 sigmoid_1" -> "429 mul_2" [label="(1, 3, 64, 64)", style=solid]; +"429 mul_2" -> "466 add_3" [label="(1, 3, 64, 64)", style=solid]; +"430 pad_1" -> "431 roll" [label="(1, 56, 56, 96)", style=solid]; +"431 roll" -> "432 view_6" [label="(1, 56, 56, 96)", style=solid]; +"432 view_6" -> "433 permute_6" [label="(1, 7, 8, 7, 8, 96)", style=solid]; +"433 permute_6" -> "434 reshape_4" [label="(1, 7, 7, 8, 8, 96)", style=solid]; +"434 reshape_4" -> "436 reshape_4_0_0_nncf_smooth_quant_0" [label="(49, 64, 96)", style=solid]; +"434 reshape_4" -> "467 new_zeros" [label="(49, 64, 96)", style=solid]; +"435 clone_1" -> "443 linear_8" [label="(288,)", style=solid]; +"436 reshape_4_0_0_nncf_smooth_quant_0" -> "437 quantize_per_tensor_default_7" [label="(49, 64, 96)", style=solid]; +"437 quantize_per_tensor_default_7" -> "438 dequantize_per_tensor_default_7" [label="(49, 64, 96)", style=solid]; +"438 dequantize_per_tensor_default_7" -> "443 linear_8" [label="(49, 64, 96)", style=solid]; +"439 linear_8_scale_0" -> "442 dequantize_per_channel_default_9" [label="(288,)", style=solid]; +"440 linear_8_zero_point_0" -> "442 dequantize_per_channel_default_9" [label="(288,)", style=solid]; +"441 _frozen_param9" -> "442 dequantize_per_channel_default_9" [label="(288, 96)", style=solid]; +"442 dequantize_per_channel_default_9" -> "443 linear_8" [label="(288, 96)", style=solid]; +"443 linear_8" -> "444 reshape_5" [label="(49, 64, 288)", style=solid]; +"444 reshape_5" -> "445 permute_7" [label="(49, 64, 3, 3, 32)", style=solid]; +"445 permute_7" -> "446 select_3" [label="(3, 49, 3, 64, 32)", style=solid]; +"445 permute_7" -> "447 select_4" [label="(3, 49, 3, 64, 32)", style=solid]; +"445 permute_7" -> "448 select_5" [label="(3, 49, 3, 64, 32)", style=solid]; +"446 select_3" -> "449 linalg_vector_norm_2" [label="(49, 3, 64, 32)", style=solid]; +"446 select_3" -> "451 expand_as_2" [label="(49, 3, 64, 32)", style=solid]; +"446 select_3" -> "452 div_2" [label="(49, 3, 64, 32)", style=solid]; +"447 select_4" -> "455 linalg_vector_norm_3" [label="(49, 3, 64, 32)", style=solid]; +"447 select_4" -> "457 expand_as_3" [label="(49, 3, 64, 32)", style=solid]; +"447 select_4" -> "458 div_3" [label="(49, 3, 64, 32)", style=solid]; +"448 select_5" -> "485 matmul_3" [label="(49, 3, 64, 32)", style=solid]; +"449 linalg_vector_norm_2" -> "450 clamp_min_2" [label="(49, 3, 64, 1)", style=solid]; +"450 clamp_min_2" -> "451 expand_as_2" [label="(49, 3, 64, 1)", style=solid]; +"451 expand_as_2" -> "452 div_2" [label="(49, 3, 64, 32)", style=solid]; +"452 div_2" -> "453 quantize_per_tensor_default_8" [label="(49, 3, 64, 32)", style=solid]; +"453 quantize_per_tensor_default_8" -> "454 dequantize_per_tensor_default_8" [label="(49, 3, 64, 32)", style=solid]; +"454 dequantize_per_tensor_default_8" -> "462 matmul_2" [label="(49, 3, 64, 32)", style=solid]; +"455 linalg_vector_norm_3" -> "456 clamp_min_3" [label="(49, 3, 64, 1)", style=solid]; +"456 clamp_min_3" -> "457 expand_as_3" [label="(49, 3, 64, 1)", style=solid]; +"457 expand_as_3" -> "458 div_3" [label="(49, 3, 64, 32)", style=solid]; +"458 div_3" -> "459 quantize_per_tensor_default_9" [label="(49, 3, 64, 32)", style=solid]; +"459 quantize_per_tensor_default_9" -> "460 dequantize_per_tensor_default_9" [label="(49, 3, 64, 32)", style=solid]; +"460 dequantize_per_tensor_default_9" -> "461 transpose_2" [label="(49, 3, 64, 32)", style=solid]; +"461 transpose_2" -> "462 matmul_2" [label="(49, 3, 32, 64)", style=solid]; +"462 matmul_2" -> "465 mul_3" [label="(49, 3, 64, 64)", style=solid]; +"463 clamp_1" -> "464 exp_1" [label="(3, 1, 1)", style=solid]; +"464 exp_1" -> "465 mul_3" [label="(3, 1, 1)", style=solid]; +"465 mul_3" -> "466 add_3" [label="(49, 3, 64, 64)", style=solid]; +"466 add_3" -> "478 view_8" [label="(49, 3, 64, 64)", style=solid]; +"467 new_zeros" -> "468 view_7" [label="(56, 56)", style=solid]; +"468 view_7" -> "469 permute_8" [label="(7, 8, 7, 8)", style=solid]; +"469 permute_8" -> "470 reshape_6" [label="(7, 7, 8, 8)", style=solid]; +"470 reshape_6" -> "471 unsqueeze_2" [label="(49, 64)", style=solid]; +"470 reshape_6" -> "472 unsqueeze_3" [label="(49, 64)", style=solid]; +"471 unsqueeze_2" -> "473 sub" [label="(49, 1, 64)", style=solid]; +"472 unsqueeze_3" -> "473 sub" [label="(49, 64, 1)", style=solid]; +"473 sub" -> "474 ne" [label="(49, 64, 64)", style=solid]; +"473 sub" -> "475 masked_fill" [label="(49, 64, 64)", style=solid]; +"473 sub" -> "476 eq" [label="(49, 64, 64)", style=solid]; +"474 ne" -> "475 masked_fill" [label="(49, 64, 64)", style=solid]; +"475 masked_fill" -> "477 masked_fill_1" [label="(49, 64, 64)", style=solid]; +"476 eq" -> "477 masked_fill_1" [label="(49, 64, 64)", style=solid]; +"477 masked_fill_1" -> "479 unsqueeze_4" [label="(49, 64, 64)", style=solid]; +"478 view_8" -> "481 add_4" [label="(1, 49, 3, 64, 64)", style=solid]; +"479 unsqueeze_4" -> "480 unsqueeze_5" [label="(49, 1, 64, 64)", style=solid]; +"480 unsqueeze_5" -> "481 add_4" [label="(1, 49, 1, 64, 64)", style=solid]; +"481 add_4" -> "482 view_9" [label="(1, 49, 3, 64, 64)", style=solid]; +"482 view_9" -> "483 softmax_1" [label="(49, 3, 64, 64)", style=solid]; +"483 softmax_1" -> "484 dropout_4" [label="(49, 3, 64, 64)", style=solid]; +"484 dropout_4" -> "485 matmul_3" [label="(49, 3, 64, 64)", style=solid]; +"485 matmul_3" -> "486 transpose_3" [label="(49, 3, 64, 32)", style=solid]; +"486 transpose_3" -> "487 reshape_7" [label="(49, 64, 3, 32)", style=solid]; +"487 reshape_7" -> "488 reshape_7_0_0_nncf_smooth_quant_0" [label="(49, 64, 96)", style=solid]; +"488 reshape_7_0_0_nncf_smooth_quant_0" -> "489 quantize_per_tensor_default_10" [label="(49, 64, 96)", style=solid]; +"489 quantize_per_tensor_default_10" -> "490 dequantize_per_tensor_default_10" [label="(49, 64, 96)", style=solid]; +"490 dequantize_per_tensor_default_10" -> "495 linear_9" [label="(49, 64, 96)", style=solid]; +"491 linear_9_scale_0" -> "494 dequantize_per_channel_default_10" [label="(96,)", style=solid]; +"492 linear_9_zero_point_0" -> "494 dequantize_per_channel_default_10" [label="(96,)", style=solid]; +"493 _frozen_param10" -> "494 dequantize_per_channel_default_10" [label="(96, 96)", style=solid]; +"494 dequantize_per_channel_default_10" -> "495 linear_9" [label="(96, 96)", style=solid]; +"495 linear_9" -> "496 dropout_5" [label="(49, 64, 96)", style=solid]; +"496 dropout_5" -> "497 view_10" [label="(49, 64, 96)", style=solid]; +"497 view_10" -> "498 permute_9" [label="(1, 7, 7, 8, 8, 96)", style=solid]; +"498 permute_9" -> "499 reshape_8" [label="(1, 7, 8, 7, 8, 96)", style=solid]; +"499 reshape_8" -> "500 roll_1" [label="(1, 56, 56, 96)", style=solid]; +"500 roll_1" -> "501 slice_23" [label="(1, 56, 56, 96)", style=solid]; +"501 slice_23" -> "502 slice_24" [label="(1, 56, 56, 96)", style=solid]; +"502 slice_24" -> "503 layer_norm_3" [label="(1, 56, 56, 96)", style=solid]; +"503 layer_norm_3" -> "504 add_5" [label="(1, 56, 56, 96)", style=solid]; +"504 add_5" -> "505 add_5_0_0_nncf_smooth_quant_0" [label="(1, 56, 56, 96)", style=solid]; +"504 add_5" -> "525 add_6" [label="(1, 56, 56, 96)", style=solid]; +"505 add_5_0_0_nncf_smooth_quant_0" -> "506 quantize_per_tensor_default_11" [label="(1, 56, 56, 96)", style=solid]; +"506 quantize_per_tensor_default_11" -> "507 dequantize_per_tensor_default_11" [label="(1, 56, 56, 96)", style=solid]; +"507 dequantize_per_tensor_default_11" -> "512 linear_10" [label="(1, 56, 56, 96)", style=solid]; +"508 linear_10_scale_0" -> "511 dequantize_per_channel_default_11" [label="(384,)", style=solid]; +"509 linear_10_zero_point_0" -> "511 dequantize_per_channel_default_11" [label="(384,)", style=solid]; +"510 _frozen_param11" -> "511 dequantize_per_channel_default_11" [label="(384, 96)", style=solid]; +"511 dequantize_per_channel_default_11" -> "512 linear_10" [label="(384, 96)", style=solid]; +"512 linear_10" -> "513 gelu_1" [label="(1, 56, 56, 384)", style=solid]; +"513 gelu_1" -> "514 dropout_6" [label="(1, 56, 56, 384)", style=solid]; +"514 dropout_6" -> "515 dropout_6_0_0_nncf_smooth_quant_0" [label="(1, 56, 56, 384)", style=solid]; +"515 dropout_6_0_0_nncf_smooth_quant_0" -> "516 quantize_per_tensor_default_12" [label="(1, 56, 56, 384)", style=solid]; +"516 quantize_per_tensor_default_12" -> "517 dequantize_per_tensor_default_12" [label="(1, 56, 56, 384)", style=solid]; +"517 dequantize_per_tensor_default_12" -> "522 linear_11" [label="(1, 56, 56, 384)", style=solid]; +"518 linear_11_scale_0" -> "521 dequantize_per_channel_default_12" [label="(96,)", style=solid]; +"519 linear_11_zero_point_0" -> "521 dequantize_per_channel_default_12" [label="(96,)", style=solid]; +"520 _frozen_param12" -> "521 dequantize_per_channel_default_12" [label="(96, 384)", style=solid]; +"521 dequantize_per_channel_default_12" -> "522 linear_11" [label="(96, 384)", style=solid]; +"522 linear_11" -> "523 dropout_7" [label="(1, 56, 56, 96)", style=solid]; +"523 dropout_7" -> "524 layer_norm_4" [label="(1, 56, 56, 96)", style=solid]; +"524 layer_norm_4" -> "525 add_6" [label="(1, 56, 56, 96)", style=solid]; +"525 add_6" -> "526 pad_2" [label="(1, 56, 56, 96)", style=solid]; +"526 pad_2" -> "527 slice_25" [label="(1, 56, 56, 96)", style=solid]; +"526 pad_2" -> "530 slice_28" [label="(1, 56, 56, 96)", style=solid]; +"526 pad_2" -> "533 slice_31" [label="(1, 56, 56, 96)", style=solid]; +"526 pad_2" -> "536 slice_34" [label="(1, 56, 56, 96)", style=solid]; +"527 slice_25" -> "528 slice_26" [label="(1, 28, 56, 96)", style=solid]; +"528 slice_26" -> "529 slice_27" [label="(1, 28, 28, 96)", style=solid]; +"529 slice_27" -> "539 cat" [label="(1, 28, 28, 96)", style=solid]; +"530 slice_28" -> "531 slice_29" [label="(1, 28, 56, 96)", style=solid]; +"531 slice_29" -> "532 slice_30" [label="(1, 28, 28, 96)", style=solid]; +"532 slice_30" -> "539 cat" [label="(1, 28, 28, 96)", style=solid]; +"533 slice_31" -> "534 slice_32" [label="(1, 28, 56, 96)", style=solid]; +"534 slice_32" -> "535 slice_33" [label="(1, 28, 28, 96)", style=solid]; +"535 slice_33" -> "539 cat" [label="(1, 28, 28, 96)", style=solid]; +"536 slice_34" -> "537 slice_35" [label="(1, 28, 56, 96)", style=solid]; +"537 slice_35" -> "538 slice_36" [label="(1, 28, 28, 96)", style=solid]; +"538 slice_36" -> "539 cat" [label="(1, 28, 28, 96)", style=solid]; +"539 cat" -> "540 cat_0_0_nncf_smooth_quant_0" [label="(1, 28, 28, 384)", style=solid]; +"540 cat_0_0_nncf_smooth_quant_0" -> "541 quantize_per_tensor_default_13" [label="(1, 28, 28, 384)", style=solid]; +"541 quantize_per_tensor_default_13" -> "542 dequantize_per_tensor_default_13" [label="(1, 28, 28, 384)", style=solid]; +"542 dequantize_per_tensor_default_13" -> "547 linear_12" [label="(1, 28, 28, 384)", style=solid]; +"543 linear_12_scale_0" -> "546 dequantize_per_channel_default_13" [label="(192,)", style=solid]; +"544 linear_12_zero_point_0" -> "546 dequantize_per_channel_default_13" [label="(192,)", style=solid]; +"545 _frozen_param13" -> "546 dequantize_per_channel_default_13" [label="(192, 384)", style=solid]; +"546 dequantize_per_channel_default_13" -> "547 linear_12" [label="(192, 384)", style=solid]; +"547 linear_12" -> "548 layer_norm_5" [label="(1, 28, 28, 192)", style=solid]; +"548 layer_norm_5" -> "570 pad_3" [label="(1, 28, 28, 192)", style=solid]; +"548 layer_norm_5" -> "629 add_8" [label="(1, 28, 28, 192)", style=solid]; +"549 features_3_0_attn_relative_coords_table_0_0_nncf_smooth_quant_0" -> "554 linear_13" [label="(1, 15, 15, 2)", style=solid]; +"550 linear_13_scale_0" -> "553 dequantize_per_channel_default_14" [label="(512,)", style=solid]; +"551 linear_13_zero_point_0" -> "553 dequantize_per_channel_default_14" [label="(512,)", style=solid]; +"552 _frozen_param14" -> "553 dequantize_per_channel_default_14" [label="(512, 2)", style=solid]; +"553 dequantize_per_channel_default_14" -> "554 linear_13" [label="(512, 2)", style=solid]; +"554 linear_13" -> "555 relu__2" [label="(1, 15, 15, 512)", style=solid]; +"555 relu__2" -> "556 relu__2_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 512)", style=solid]; +"556 relu__2_0_0_nncf_smooth_quant_0" -> "561 linear_14" [label="(1, 15, 15, 512)", style=solid]; +"557 linear_14_scale_0" -> "560 dequantize_per_channel_default_15" [label="(6,)", style=solid]; +"558 linear_14_zero_point_0" -> "560 dequantize_per_channel_default_15" [label="(6,)", style=solid]; +"559 _frozen_param15" -> "560 dequantize_per_channel_default_15" [label="(6, 512)", style=solid]; +"560 dequantize_per_channel_default_15" -> "561 linear_14" [label="(6, 512)", style=solid]; +"561 linear_14" -> "562 view_11" [label="(1, 15, 15, 6)", style=solid]; +"562 view_11" -> "563 index_2" [label="(225, 6)", style=solid]; +"563 index_2" -> "564 view_12" [label="(4096, 6)", style=solid]; +"564 view_12" -> "565 permute_10" [label="(64, 64, 6)", style=solid]; +"565 permute_10" -> "566 contiguous_2" [label="(6, 64, 64)", style=solid]; +"566 contiguous_2" -> "567 unsqueeze_6" [label="(6, 64, 64)", style=solid]; +"567 unsqueeze_6" -> "568 sigmoid_2" [label="(1, 6, 64, 64)", style=solid]; +"568 sigmoid_2" -> "569 mul_4" [label="(1, 6, 64, 64)", style=solid]; +"569 mul_4" -> "605 add_7" [label="(1, 6, 64, 64)", style=solid]; +"570 pad_3" -> "571 view_13" [label="(1, 32, 32, 192)", style=solid]; +"571 view_13" -> "572 permute_11" [label="(1, 4, 8, 4, 8, 192)", style=solid]; +"572 permute_11" -> "573 reshape_9" [label="(1, 4, 4, 8, 8, 192)", style=solid]; +"573 reshape_9" -> "575 reshape_9_0_0_nncf_smooth_quant_0" [label="(16, 64, 192)", style=solid]; +"574 clone_2" -> "582 linear_15" [label="(576,)", style=solid]; +"575 reshape_9_0_0_nncf_smooth_quant_0" -> "576 quantize_per_tensor_default_14" [label="(16, 64, 192)", style=solid]; +"576 quantize_per_tensor_default_14" -> "577 dequantize_per_tensor_default_14" [label="(16, 64, 192)", style=solid]; +"577 dequantize_per_tensor_default_14" -> "582 linear_15" [label="(16, 64, 192)", style=solid]; +"578 linear_15_scale_0" -> "581 dequantize_per_channel_default_16" [label="(576,)", style=solid]; +"579 linear_15_zero_point_0" -> "581 dequantize_per_channel_default_16" [label="(576,)", style=solid]; +"580 _frozen_param16" -> "581 dequantize_per_channel_default_16" [label="(576, 192)", style=solid]; +"581 dequantize_per_channel_default_16" -> "582 linear_15" [label="(576, 192)", style=solid]; +"582 linear_15" -> "583 reshape_10" [label="(16, 64, 576)", style=solid]; +"583 reshape_10" -> "584 permute_12" [label="(16, 64, 3, 6, 32)", style=solid]; +"584 permute_12" -> "585 select_6" [label="(3, 16, 6, 64, 32)", style=solid]; +"584 permute_12" -> "586 select_7" [label="(3, 16, 6, 64, 32)", style=solid]; +"584 permute_12" -> "587 select_8" [label="(3, 16, 6, 64, 32)", style=solid]; +"585 select_6" -> "588 linalg_vector_norm_4" [label="(16, 6, 64, 32)", style=solid]; +"585 select_6" -> "590 expand_as_4" [label="(16, 6, 64, 32)", style=solid]; +"585 select_6" -> "591 div_4" [label="(16, 6, 64, 32)", style=solid]; +"586 select_7" -> "594 linalg_vector_norm_5" [label="(16, 6, 64, 32)", style=solid]; +"586 select_7" -> "596 expand_as_5" [label="(16, 6, 64, 32)", style=solid]; +"586 select_7" -> "597 div_5" [label="(16, 6, 64, 32)", style=solid]; +"587 select_8" -> "608 matmul_5" [label="(16, 6, 64, 32)", style=solid]; +"588 linalg_vector_norm_4" -> "589 clamp_min_4" [label="(16, 6, 64, 1)", style=solid]; +"589 clamp_min_4" -> "590 expand_as_4" [label="(16, 6, 64, 1)", style=solid]; +"590 expand_as_4" -> "591 div_4" [label="(16, 6, 64, 32)", style=solid]; +"591 div_4" -> "592 quantize_per_tensor_default_15" [label="(16, 6, 64, 32)", style=solid]; +"592 quantize_per_tensor_default_15" -> "593 dequantize_per_tensor_default_15" [label="(16, 6, 64, 32)", style=solid]; +"593 dequantize_per_tensor_default_15" -> "601 matmul_4" [label="(16, 6, 64, 32)", style=solid]; +"594 linalg_vector_norm_5" -> "595 clamp_min_5" [label="(16, 6, 64, 1)", style=solid]; +"595 clamp_min_5" -> "596 expand_as_5" [label="(16, 6, 64, 1)", style=solid]; +"596 expand_as_5" -> "597 div_5" [label="(16, 6, 64, 32)", style=solid]; +"597 div_5" -> "598 quantize_per_tensor_default_16" [label="(16, 6, 64, 32)", style=solid]; +"598 quantize_per_tensor_default_16" -> "599 dequantize_per_tensor_default_16" [label="(16, 6, 64, 32)", style=solid]; +"599 dequantize_per_tensor_default_16" -> "600 transpose_4" [label="(16, 6, 64, 32)", style=solid]; +"600 transpose_4" -> "601 matmul_4" [label="(16, 6, 32, 64)", style=solid]; +"601 matmul_4" -> "604 mul_5" [label="(16, 6, 64, 64)", style=solid]; +"602 clamp_2" -> "603 exp_2" [label="(6, 1, 1)", style=solid]; +"603 exp_2" -> "604 mul_5" [label="(6, 1, 1)", style=solid]; +"604 mul_5" -> "605 add_7" [label="(16, 6, 64, 64)", style=solid]; +"605 add_7" -> "606 softmax_2" [label="(16, 6, 64, 64)", style=solid]; +"606 softmax_2" -> "607 dropout_8" [label="(16, 6, 64, 64)", style=solid]; +"607 dropout_8" -> "608 matmul_5" [label="(16, 6, 64, 64)", style=solid]; +"608 matmul_5" -> "609 transpose_5" [label="(16, 6, 64, 32)", style=solid]; +"609 transpose_5" -> "610 reshape_11" [label="(16, 64, 6, 32)", style=solid]; +"610 reshape_11" -> "611 reshape_11_0_0_nncf_smooth_quant_0" [label="(16, 64, 192)", style=solid]; +"611 reshape_11_0_0_nncf_smooth_quant_0" -> "612 quantize_per_tensor_default_17" [label="(16, 64, 192)", style=solid]; +"612 quantize_per_tensor_default_17" -> "613 dequantize_per_tensor_default_17" [label="(16, 64, 192)", style=solid]; +"613 dequantize_per_tensor_default_17" -> "618 linear_16" [label="(16, 64, 192)", style=solid]; +"614 linear_16_scale_0" -> "617 dequantize_per_channel_default_17" [label="(192,)", style=solid]; +"615 linear_16_zero_point_0" -> "617 dequantize_per_channel_default_17" [label="(192,)", style=solid]; +"616 _frozen_param17" -> "617 dequantize_per_channel_default_17" [label="(192, 192)", style=solid]; +"617 dequantize_per_channel_default_17" -> "618 linear_16" [label="(192, 192)", style=solid]; +"618 linear_16" -> "619 dropout_9" [label="(16, 64, 192)", style=solid]; +"619 dropout_9" -> "620 view_14" [label="(16, 64, 192)", style=solid]; +"620 view_14" -> "621 permute_13" [label="(1, 4, 4, 8, 8, 192)", style=solid]; +"621 permute_13" -> "622 reshape_12" [label="(1, 4, 8, 4, 8, 192)", style=solid]; +"622 reshape_12" -> "623 slice_38" [label="(1, 32, 32, 192)", style=solid]; +"623 slice_38" -> "624 slice_39" [label="(1, 32, 32, 192)", style=solid]; +"624 slice_39" -> "625 slice_40" [label="(1, 28, 32, 192)", style=solid]; +"625 slice_40" -> "626 slice_41" [label="(1, 28, 28, 192)", style=solid]; +"626 slice_41" -> "627 contiguous_3" [label="(1, 28, 28, 192)", style=solid]; +"627 contiguous_3" -> "628 layer_norm_6" [label="(1, 28, 28, 192)", style=solid]; +"628 layer_norm_6" -> "629 add_8" [label="(1, 28, 28, 192)", style=solid]; +"629 add_8" -> "630 add_8_0_0_nncf_smooth_quant_0" [label="(1, 28, 28, 192)", style=solid]; +"629 add_8" -> "650 add_9" [label="(1, 28, 28, 192)", style=solid]; +"630 add_8_0_0_nncf_smooth_quant_0" -> "631 quantize_per_tensor_default_18" [label="(1, 28, 28, 192)", style=solid]; +"631 quantize_per_tensor_default_18" -> "632 dequantize_per_tensor_default_18" [label="(1, 28, 28, 192)", style=solid]; +"632 dequantize_per_tensor_default_18" -> "637 linear_17" [label="(1, 28, 28, 192)", style=solid]; +"633 linear_17_scale_0" -> "636 dequantize_per_channel_default_18" [label="(768,)", style=solid]; +"634 linear_17_zero_point_0" -> "636 dequantize_per_channel_default_18" [label="(768,)", style=solid]; +"635 _frozen_param18" -> "636 dequantize_per_channel_default_18" [label="(768, 192)", style=solid]; +"636 dequantize_per_channel_default_18" -> "637 linear_17" [label="(768, 192)", style=solid]; +"637 linear_17" -> "638 gelu_2" [label="(1, 28, 28, 768)", style=solid]; +"638 gelu_2" -> "639 dropout_10" [label="(1, 28, 28, 768)", style=solid]; +"639 dropout_10" -> "640 dropout_10_0_0_nncf_smooth_quant_0" [label="(1, 28, 28, 768)", style=solid]; +"640 dropout_10_0_0_nncf_smooth_quant_0" -> "641 quantize_per_tensor_default_19" [label="(1, 28, 28, 768)", style=solid]; +"641 quantize_per_tensor_default_19" -> "642 dequantize_per_tensor_default_19" [label="(1, 28, 28, 768)", style=solid]; +"642 dequantize_per_tensor_default_19" -> "647 linear_18" [label="(1, 28, 28, 768)", style=solid]; +"643 linear_18_scale_0" -> "646 dequantize_per_channel_default_19" [label="(192,)", style=solid]; +"644 linear_18_zero_point_0" -> "646 dequantize_per_channel_default_19" [label="(192,)", style=solid]; +"645 _frozen_param19" -> "646 dequantize_per_channel_default_19" [label="(192, 768)", style=solid]; +"646 dequantize_per_channel_default_19" -> "647 linear_18" [label="(192, 768)", style=solid]; +"647 linear_18" -> "648 dropout_11" [label="(1, 28, 28, 192)", style=solid]; +"648 dropout_11" -> "649 layer_norm_7" [label="(1, 28, 28, 192)", style=solid]; +"649 layer_norm_7" -> "650 add_9" [label="(1, 28, 28, 192)", style=solid]; +"650 add_9" -> "672 pad_4" [label="(1, 28, 28, 192)", style=solid]; +"650 add_9" -> "749 add_12" [label="(1, 28, 28, 192)", style=solid]; +"651 features_3_1_attn_relative_coords_table_0_0_nncf_smooth_quant_0" -> "656 linear_19" [label="(1, 15, 15, 2)", style=solid]; +"652 linear_19_scale_0" -> "655 dequantize_per_channel_default_20" [label="(512,)", style=solid]; +"653 linear_19_zero_point_0" -> "655 dequantize_per_channel_default_20" [label="(512,)", style=solid]; +"654 _frozen_param20" -> "655 dequantize_per_channel_default_20" [label="(512, 2)", style=solid]; +"655 dequantize_per_channel_default_20" -> "656 linear_19" [label="(512, 2)", style=solid]; +"656 linear_19" -> "657 relu__3" [label="(1, 15, 15, 512)", style=solid]; +"657 relu__3" -> "658 relu__3_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 512)", style=solid]; +"658 relu__3_0_0_nncf_smooth_quant_0" -> "663 linear_20" [label="(1, 15, 15, 512)", style=solid]; +"659 linear_20_scale_0" -> "662 dequantize_per_channel_default_21" [label="(6,)", style=solid]; +"660 linear_20_zero_point_0" -> "662 dequantize_per_channel_default_21" [label="(6,)", style=solid]; +"661 _frozen_param21" -> "662 dequantize_per_channel_default_21" [label="(6, 512)", style=solid]; +"662 dequantize_per_channel_default_21" -> "663 linear_20" [label="(6, 512)", style=solid]; +"663 linear_20" -> "664 view_15" [label="(1, 15, 15, 6)", style=solid]; +"664 view_15" -> "665 index_3" [label="(225, 6)", style=solid]; +"665 index_3" -> "666 view_16" [label="(4096, 6)", style=solid]; +"666 view_16" -> "667 permute_14" [label="(64, 64, 6)", style=solid]; +"667 permute_14" -> "668 contiguous_4" [label="(6, 64, 64)", style=solid]; +"668 contiguous_4" -> "669 unsqueeze_7" [label="(6, 64, 64)", style=solid]; +"669 unsqueeze_7" -> "670 sigmoid_3" [label="(1, 6, 64, 64)", style=solid]; +"670 sigmoid_3" -> "671 mul_6" [label="(1, 6, 64, 64)", style=solid]; +"671 mul_6" -> "708 add_10" [label="(1, 6, 64, 64)", style=solid]; +"672 pad_4" -> "673 roll_2" [label="(1, 32, 32, 192)", style=solid]; +"673 roll_2" -> "674 view_17" [label="(1, 32, 32, 192)", style=solid]; +"674 view_17" -> "675 permute_15" [label="(1, 4, 8, 4, 8, 192)", style=solid]; +"675 permute_15" -> "676 reshape_13" [label="(1, 4, 4, 8, 8, 192)", style=solid]; +"676 reshape_13" -> "678 reshape_13_0_0_nncf_smooth_quant_0" [label="(16, 64, 192)", style=solid]; +"676 reshape_13" -> "709 new_zeros_1" [label="(16, 64, 192)", style=solid]; +"677 clone_3" -> "685 linear_21" [label="(576,)", style=solid]; +"678 reshape_13_0_0_nncf_smooth_quant_0" -> "679 quantize_per_tensor_default_20" [label="(16, 64, 192)", style=solid]; +"679 quantize_per_tensor_default_20" -> "680 dequantize_per_tensor_default_20" [label="(16, 64, 192)", style=solid]; +"680 dequantize_per_tensor_default_20" -> "685 linear_21" [label="(16, 64, 192)", style=solid]; +"681 linear_21_scale_0" -> "684 dequantize_per_channel_default_22" [label="(576,)", style=solid]; +"682 linear_21_zero_point_0" -> "684 dequantize_per_channel_default_22" [label="(576,)", style=solid]; +"683 _frozen_param22" -> "684 dequantize_per_channel_default_22" [label="(576, 192)", style=solid]; +"684 dequantize_per_channel_default_22" -> "685 linear_21" [label="(576, 192)", style=solid]; +"685 linear_21" -> "686 reshape_14" [label="(16, 64, 576)", style=solid]; +"686 reshape_14" -> "687 permute_16" [label="(16, 64, 3, 6, 32)", style=solid]; +"687 permute_16" -> "688 select_9" [label="(3, 16, 6, 64, 32)", style=solid]; +"687 permute_16" -> "689 select_10" [label="(3, 16, 6, 64, 32)", style=solid]; +"687 permute_16" -> "690 select_11" [label="(3, 16, 6, 64, 32)", style=solid]; +"688 select_9" -> "691 linalg_vector_norm_6" [label="(16, 6, 64, 32)", style=solid]; +"688 select_9" -> "693 expand_as_6" [label="(16, 6, 64, 32)", style=solid]; +"688 select_9" -> "694 div_6" [label="(16, 6, 64, 32)", style=solid]; +"689 select_10" -> "697 linalg_vector_norm_7" [label="(16, 6, 64, 32)", style=solid]; +"689 select_10" -> "699 expand_as_7" [label="(16, 6, 64, 32)", style=solid]; +"689 select_10" -> "700 div_7" [label="(16, 6, 64, 32)", style=solid]; +"690 select_11" -> "727 matmul_7" [label="(16, 6, 64, 32)", style=solid]; +"691 linalg_vector_norm_6" -> "692 clamp_min_6" [label="(16, 6, 64, 1)", style=solid]; +"692 clamp_min_6" -> "693 expand_as_6" [label="(16, 6, 64, 1)", style=solid]; +"693 expand_as_6" -> "694 div_6" [label="(16, 6, 64, 32)", style=solid]; +"694 div_6" -> "695 quantize_per_tensor_default_21" [label="(16, 6, 64, 32)", style=solid]; +"695 quantize_per_tensor_default_21" -> "696 dequantize_per_tensor_default_21" [label="(16, 6, 64, 32)", style=solid]; +"696 dequantize_per_tensor_default_21" -> "704 matmul_6" [label="(16, 6, 64, 32)", style=solid]; +"697 linalg_vector_norm_7" -> "698 clamp_min_7" [label="(16, 6, 64, 1)", style=solid]; +"698 clamp_min_7" -> "699 expand_as_7" [label="(16, 6, 64, 1)", style=solid]; +"699 expand_as_7" -> "700 div_7" [label="(16, 6, 64, 32)", style=solid]; +"700 div_7" -> "701 quantize_per_tensor_default_22" [label="(16, 6, 64, 32)", style=solid]; +"701 quantize_per_tensor_default_22" -> "702 dequantize_per_tensor_default_22" [label="(16, 6, 64, 32)", style=solid]; +"702 dequantize_per_tensor_default_22" -> "703 transpose_6" [label="(16, 6, 64, 32)", style=solid]; +"703 transpose_6" -> "704 matmul_6" [label="(16, 6, 32, 64)", style=solid]; +"704 matmul_6" -> "707 mul_7" [label="(16, 6, 64, 64)", style=solid]; +"705 clamp_3" -> "706 exp_3" [label="(6, 1, 1)", style=solid]; +"706 exp_3" -> "707 mul_7" [label="(6, 1, 1)", style=solid]; +"707 mul_7" -> "708 add_10" [label="(16, 6, 64, 64)", style=solid]; +"708 add_10" -> "720 view_19" [label="(16, 6, 64, 64)", style=solid]; +"709 new_zeros_1" -> "710 view_18" [label="(32, 32)", style=solid]; +"710 view_18" -> "711 permute_17" [label="(4, 8, 4, 8)", style=solid]; +"711 permute_17" -> "712 reshape_15" [label="(4, 4, 8, 8)", style=solid]; +"712 reshape_15" -> "713 unsqueeze_8" [label="(16, 64)", style=solid]; +"712 reshape_15" -> "714 unsqueeze_9" [label="(16, 64)", style=solid]; +"713 unsqueeze_8" -> "715 sub_1" [label="(16, 1, 64)", style=solid]; +"714 unsqueeze_9" -> "715 sub_1" [label="(16, 64, 1)", style=solid]; +"715 sub_1" -> "716 ne_1" [label="(16, 64, 64)", style=solid]; +"715 sub_1" -> "717 masked_fill_2" [label="(16, 64, 64)", style=solid]; +"715 sub_1" -> "718 eq_1" [label="(16, 64, 64)", style=solid]; +"716 ne_1" -> "717 masked_fill_2" [label="(16, 64, 64)", style=solid]; +"717 masked_fill_2" -> "719 masked_fill_3" [label="(16, 64, 64)", style=solid]; +"718 eq_1" -> "719 masked_fill_3" [label="(16, 64, 64)", style=solid]; +"719 masked_fill_3" -> "721 unsqueeze_10" [label="(16, 64, 64)", style=solid]; +"720 view_19" -> "723 add_11" [label="(1, 16, 6, 64, 64)", style=solid]; +"721 unsqueeze_10" -> "722 unsqueeze_11" [label="(16, 1, 64, 64)", style=solid]; +"722 unsqueeze_11" -> "723 add_11" [label="(1, 16, 1, 64, 64)", style=solid]; +"723 add_11" -> "724 view_20" [label="(1, 16, 6, 64, 64)", style=solid]; +"724 view_20" -> "725 softmax_3" [label="(16, 6, 64, 64)", style=solid]; +"725 softmax_3" -> "726 dropout_12" [label="(16, 6, 64, 64)", style=solid]; +"726 dropout_12" -> "727 matmul_7" [label="(16, 6, 64, 64)", style=solid]; +"727 matmul_7" -> "728 transpose_7" [label="(16, 6, 64, 32)", style=solid]; +"728 transpose_7" -> "729 reshape_16" [label="(16, 64, 6, 32)", style=solid]; +"729 reshape_16" -> "730 reshape_16_0_0_nncf_smooth_quant_0" [label="(16, 64, 192)", style=solid]; +"730 reshape_16_0_0_nncf_smooth_quant_0" -> "731 quantize_per_tensor_default_23" [label="(16, 64, 192)", style=solid]; +"731 quantize_per_tensor_default_23" -> "732 dequantize_per_tensor_default_23" [label="(16, 64, 192)", style=solid]; +"732 dequantize_per_tensor_default_23" -> "737 linear_22" [label="(16, 64, 192)", style=solid]; +"733 linear_22_scale_0" -> "736 dequantize_per_channel_default_23" [label="(192,)", style=solid]; +"734 linear_22_zero_point_0" -> "736 dequantize_per_channel_default_23" [label="(192,)", style=solid]; +"735 _frozen_param23" -> "736 dequantize_per_channel_default_23" [label="(192, 192)", style=solid]; +"736 dequantize_per_channel_default_23" -> "737 linear_22" [label="(192, 192)", style=solid]; +"737 linear_22" -> "738 dropout_13" [label="(16, 64, 192)", style=solid]; +"738 dropout_13" -> "739 view_21" [label="(16, 64, 192)", style=solid]; +"739 view_21" -> "740 permute_18" [label="(1, 4, 4, 8, 8, 192)", style=solid]; +"740 permute_18" -> "741 reshape_17" [label="(1, 4, 8, 4, 8, 192)", style=solid]; +"741 reshape_17" -> "742 roll_3" [label="(1, 32, 32, 192)", style=solid]; +"742 roll_3" -> "743 slice_61" [label="(1, 32, 32, 192)", style=solid]; +"743 slice_61" -> "744 slice_62" [label="(1, 32, 32, 192)", style=solid]; +"744 slice_62" -> "745 slice_63" [label="(1, 28, 32, 192)", style=solid]; +"745 slice_63" -> "746 slice_64" [label="(1, 28, 28, 192)", style=solid]; +"746 slice_64" -> "747 contiguous_5" [label="(1, 28, 28, 192)", style=solid]; +"747 contiguous_5" -> "748 layer_norm_8" [label="(1, 28, 28, 192)", style=solid]; +"748 layer_norm_8" -> "749 add_12" [label="(1, 28, 28, 192)", style=solid]; +"749 add_12" -> "750 add_12_0_0_nncf_smooth_quant_0" [label="(1, 28, 28, 192)", style=solid]; +"749 add_12" -> "770 add_13" [label="(1, 28, 28, 192)", style=solid]; +"750 add_12_0_0_nncf_smooth_quant_0" -> "751 quantize_per_tensor_default_24" [label="(1, 28, 28, 192)", style=solid]; +"751 quantize_per_tensor_default_24" -> "752 dequantize_per_tensor_default_24" [label="(1, 28, 28, 192)", style=solid]; +"752 dequantize_per_tensor_default_24" -> "757 linear_23" [label="(1, 28, 28, 192)", style=solid]; +"753 linear_23_scale_0" -> "756 dequantize_per_channel_default_24" [label="(768,)", style=solid]; +"754 linear_23_zero_point_0" -> "756 dequantize_per_channel_default_24" [label="(768,)", style=solid]; +"755 _frozen_param24" -> "756 dequantize_per_channel_default_24" [label="(768, 192)", style=solid]; +"756 dequantize_per_channel_default_24" -> "757 linear_23" [label="(768, 192)", style=solid]; +"757 linear_23" -> "758 gelu_3" [label="(1, 28, 28, 768)", style=solid]; +"758 gelu_3" -> "759 dropout_14" [label="(1, 28, 28, 768)", style=solid]; +"759 dropout_14" -> "760 dropout_14_0_0_nncf_smooth_quant_0" [label="(1, 28, 28, 768)", style=solid]; +"760 dropout_14_0_0_nncf_smooth_quant_0" -> "761 quantize_per_tensor_default_25" [label="(1, 28, 28, 768)", style=solid]; +"761 quantize_per_tensor_default_25" -> "762 dequantize_per_tensor_default_25" [label="(1, 28, 28, 768)", style=solid]; +"762 dequantize_per_tensor_default_25" -> "767 linear_24" [label="(1, 28, 28, 768)", style=solid]; +"763 linear_24_scale_0" -> "766 dequantize_per_channel_default_25" [label="(192,)", style=solid]; +"764 linear_24_zero_point_0" -> "766 dequantize_per_channel_default_25" [label="(192,)", style=solid]; +"765 _frozen_param25" -> "766 dequantize_per_channel_default_25" [label="(192, 768)", style=solid]; +"766 dequantize_per_channel_default_25" -> "767 linear_24" [label="(192, 768)", style=solid]; +"767 linear_24" -> "768 dropout_15" [label="(1, 28, 28, 192)", style=solid]; +"768 dropout_15" -> "769 layer_norm_9" [label="(1, 28, 28, 192)", style=solid]; +"769 layer_norm_9" -> "770 add_13" [label="(1, 28, 28, 192)", style=solid]; +"770 add_13" -> "771 pad_5" [label="(1, 28, 28, 192)", style=solid]; +"771 pad_5" -> "772 slice_65" [label="(1, 28, 28, 192)", style=solid]; +"771 pad_5" -> "775 slice_68" [label="(1, 28, 28, 192)", style=solid]; +"771 pad_5" -> "778 slice_71" [label="(1, 28, 28, 192)", style=solid]; +"771 pad_5" -> "781 slice_74" [label="(1, 28, 28, 192)", style=solid]; +"772 slice_65" -> "773 slice_66" [label="(1, 14, 28, 192)", style=solid]; +"773 slice_66" -> "774 slice_67" [label="(1, 14, 14, 192)", style=solid]; +"774 slice_67" -> "784 cat_1" [label="(1, 14, 14, 192)", style=solid]; +"775 slice_68" -> "776 slice_69" [label="(1, 14, 28, 192)", style=solid]; +"776 slice_69" -> "777 slice_70" [label="(1, 14, 14, 192)", style=solid]; +"777 slice_70" -> "784 cat_1" [label="(1, 14, 14, 192)", style=solid]; +"778 slice_71" -> "779 slice_72" [label="(1, 14, 28, 192)", style=solid]; +"779 slice_72" -> "780 slice_73" [label="(1, 14, 14, 192)", style=solid]; +"780 slice_73" -> "784 cat_1" [label="(1, 14, 14, 192)", style=solid]; +"781 slice_74" -> "782 slice_75" [label="(1, 14, 28, 192)", style=solid]; +"782 slice_75" -> "783 slice_76" [label="(1, 14, 14, 192)", style=solid]; +"783 slice_76" -> "784 cat_1" [label="(1, 14, 14, 192)", style=solid]; +"784 cat_1" -> "785 cat_1_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 768)", style=solid]; +"785 cat_1_0_0_nncf_smooth_quant_0" -> "786 quantize_per_tensor_default_26" [label="(1, 14, 14, 768)", style=solid]; +"786 quantize_per_tensor_default_26" -> "787 dequantize_per_tensor_default_26" [label="(1, 14, 14, 768)", style=solid]; +"787 dequantize_per_tensor_default_26" -> "792 linear_25" [label="(1, 14, 14, 768)", style=solid]; +"788 linear_25_scale_0" -> "791 dequantize_per_channel_default_26" [label="(384,)", style=solid]; +"789 linear_25_zero_point_0" -> "791 dequantize_per_channel_default_26" [label="(384,)", style=solid]; +"790 _frozen_param26" -> "791 dequantize_per_channel_default_26" [label="(384, 768)", style=solid]; +"791 dequantize_per_channel_default_26" -> "792 linear_25" [label="(384, 768)", style=solid]; +"792 linear_25" -> "793 layer_norm_10" [label="(1, 14, 14, 384)", style=solid]; +"793 layer_norm_10" -> "815 pad_6" [label="(1, 14, 14, 384)", style=solid]; +"793 layer_norm_10" -> "874 add_15" [label="(1, 14, 14, 384)", style=solid]; +"794 features_5_0_attn_relative_coords_table_0_0_nncf_smooth_quant_0" -> "799 linear_26" [label="(1, 15, 15, 2)", style=solid]; +"795 linear_26_scale_0" -> "798 dequantize_per_channel_default_27" [label="(512,)", style=solid]; +"796 linear_26_zero_point_0" -> "798 dequantize_per_channel_default_27" [label="(512,)", style=solid]; +"797 _frozen_param27" -> "798 dequantize_per_channel_default_27" [label="(512, 2)", style=solid]; +"798 dequantize_per_channel_default_27" -> "799 linear_26" [label="(512, 2)", style=solid]; +"799 linear_26" -> "800 relu__4" [label="(1, 15, 15, 512)", style=solid]; +"800 relu__4" -> "801 relu__4_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 512)", style=solid]; +"801 relu__4_0_0_nncf_smooth_quant_0" -> "806 linear_27" [label="(1, 15, 15, 512)", style=solid]; +"802 linear_27_scale_0" -> "805 dequantize_per_channel_default_28" [label="(12,)", style=solid]; +"803 linear_27_zero_point_0" -> "805 dequantize_per_channel_default_28" [label="(12,)", style=solid]; +"804 _frozen_param28" -> "805 dequantize_per_channel_default_28" [label="(12, 512)", style=solid]; +"805 dequantize_per_channel_default_28" -> "806 linear_27" [label="(12, 512)", style=solid]; +"806 linear_27" -> "807 view_22" [label="(1, 15, 15, 12)", style=solid]; +"807 view_22" -> "808 index_4" [label="(225, 12)", style=solid]; +"808 index_4" -> "809 view_23" [label="(4096, 12)", style=solid]; +"809 view_23" -> "810 permute_19" [label="(64, 64, 12)", style=solid]; +"810 permute_19" -> "811 contiguous_6" [label="(12, 64, 64)", style=solid]; +"811 contiguous_6" -> "812 unsqueeze_12" [label="(12, 64, 64)", style=solid]; +"812 unsqueeze_12" -> "813 sigmoid_4" [label="(1, 12, 64, 64)", style=solid]; +"813 sigmoid_4" -> "814 mul_8" [label="(1, 12, 64, 64)", style=solid]; +"814 mul_8" -> "850 add_14" [label="(1, 12, 64, 64)", style=solid]; +"815 pad_6" -> "816 view_24" [label="(1, 16, 16, 384)", style=solid]; +"816 view_24" -> "817 permute_20" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"817 permute_20" -> "818 reshape_18" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"818 reshape_18" -> "820 reshape_18_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"819 clone_4" -> "827 linear_28" [label="(1152,)", style=solid]; +"820 reshape_18_0_0_nncf_smooth_quant_0" -> "821 quantize_per_tensor_default_27" [label="(4, 64, 384)", style=solid]; +"821 quantize_per_tensor_default_27" -> "822 dequantize_per_tensor_default_27" [label="(4, 64, 384)", style=solid]; +"822 dequantize_per_tensor_default_27" -> "827 linear_28" [label="(4, 64, 384)", style=solid]; +"823 linear_28_scale_0" -> "826 dequantize_per_channel_default_29" [label="(1152,)", style=solid]; +"824 linear_28_zero_point_0" -> "826 dequantize_per_channel_default_29" [label="(1152,)", style=solid]; +"825 _frozen_param29" -> "826 dequantize_per_channel_default_29" [label="(1152, 384)", style=solid]; +"826 dequantize_per_channel_default_29" -> "827 linear_28" [label="(1152, 384)", style=solid]; +"827 linear_28" -> "828 reshape_19" [label="(4, 64, 1152)", style=solid]; +"828 reshape_19" -> "829 permute_21" [label="(4, 64, 3, 12, 32)", style=solid]; +"829 permute_21" -> "830 select_12" [label="(3, 4, 12, 64, 32)", style=solid]; +"829 permute_21" -> "831 select_13" [label="(3, 4, 12, 64, 32)", style=solid]; +"829 permute_21" -> "832 select_14" [label="(3, 4, 12, 64, 32)", style=solid]; +"830 select_12" -> "833 linalg_vector_norm_8" [label="(4, 12, 64, 32)", style=solid]; +"830 select_12" -> "835 expand_as_8" [label="(4, 12, 64, 32)", style=solid]; +"830 select_12" -> "836 div_8" [label="(4, 12, 64, 32)", style=solid]; +"831 select_13" -> "839 linalg_vector_norm_9" [label="(4, 12, 64, 32)", style=solid]; +"831 select_13" -> "841 expand_as_9" [label="(4, 12, 64, 32)", style=solid]; +"831 select_13" -> "842 div_9" [label="(4, 12, 64, 32)", style=solid]; +"832 select_14" -> "853 matmul_9" [label="(4, 12, 64, 32)", style=solid]; +"833 linalg_vector_norm_8" -> "834 clamp_min_8" [label="(4, 12, 64, 1)", style=solid]; +"834 clamp_min_8" -> "835 expand_as_8" [label="(4, 12, 64, 1)", style=solid]; +"835 expand_as_8" -> "836 div_8" [label="(4, 12, 64, 32)", style=solid]; +"836 div_8" -> "837 quantize_per_tensor_default_28" [label="(4, 12, 64, 32)", style=solid]; +"837 quantize_per_tensor_default_28" -> "838 dequantize_per_tensor_default_28" [label="(4, 12, 64, 32)", style=solid]; +"838 dequantize_per_tensor_default_28" -> "846 matmul_8" [label="(4, 12, 64, 32)", style=solid]; +"839 linalg_vector_norm_9" -> "840 clamp_min_9" [label="(4, 12, 64, 1)", style=solid]; +"840 clamp_min_9" -> "841 expand_as_9" [label="(4, 12, 64, 1)", style=solid]; +"841 expand_as_9" -> "842 div_9" [label="(4, 12, 64, 32)", style=solid]; +"842 div_9" -> "843 quantize_per_tensor_default_29" [label="(4, 12, 64, 32)", style=solid]; +"843 quantize_per_tensor_default_29" -> "844 dequantize_per_tensor_default_29" [label="(4, 12, 64, 32)", style=solid]; +"844 dequantize_per_tensor_default_29" -> "845 transpose_8" [label="(4, 12, 64, 32)", style=solid]; +"845 transpose_8" -> "846 matmul_8" [label="(4, 12, 32, 64)", style=solid]; +"846 matmul_8" -> "849 mul_9" [label="(4, 12, 64, 64)", style=solid]; +"847 clamp_4" -> "848 exp_4" [label="(12, 1, 1)", style=solid]; +"848 exp_4" -> "849 mul_9" [label="(12, 1, 1)", style=solid]; +"849 mul_9" -> "850 add_14" [label="(4, 12, 64, 64)", style=solid]; +"850 add_14" -> "851 softmax_4" [label="(4, 12, 64, 64)", style=solid]; +"851 softmax_4" -> "852 dropout_16" [label="(4, 12, 64, 64)", style=solid]; +"852 dropout_16" -> "853 matmul_9" [label="(4, 12, 64, 64)", style=solid]; +"853 matmul_9" -> "854 transpose_9" [label="(4, 12, 64, 32)", style=solid]; +"854 transpose_9" -> "855 reshape_20" [label="(4, 64, 12, 32)", style=solid]; +"855 reshape_20" -> "856 reshape_20_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"856 reshape_20_0_0_nncf_smooth_quant_0" -> "857 quantize_per_tensor_default_30" [label="(4, 64, 384)", style=solid]; +"857 quantize_per_tensor_default_30" -> "858 dequantize_per_tensor_default_30" [label="(4, 64, 384)", style=solid]; +"858 dequantize_per_tensor_default_30" -> "863 linear_29" [label="(4, 64, 384)", style=solid]; +"859 linear_29_scale_0" -> "862 dequantize_per_channel_default_30" [label="(384,)", style=solid]; +"860 linear_29_zero_point_0" -> "862 dequantize_per_channel_default_30" [label="(384,)", style=solid]; +"861 _frozen_param30" -> "862 dequantize_per_channel_default_30" [label="(384, 384)", style=solid]; +"862 dequantize_per_channel_default_30" -> "863 linear_29" [label="(384, 384)", style=solid]; +"863 linear_29" -> "864 dropout_17" [label="(4, 64, 384)", style=solid]; +"864 dropout_17" -> "865 view_25" [label="(4, 64, 384)", style=solid]; +"865 view_25" -> "866 permute_22" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"866 permute_22" -> "867 reshape_21" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"867 reshape_21" -> "868 slice_78" [label="(1, 16, 16, 384)", style=solid]; +"868 slice_78" -> "869 slice_79" [label="(1, 16, 16, 384)", style=solid]; +"869 slice_79" -> "870 slice_80" [label="(1, 14, 16, 384)", style=solid]; +"870 slice_80" -> "871 slice_81" [label="(1, 14, 14, 384)", style=solid]; +"871 slice_81" -> "872 contiguous_7" [label="(1, 14, 14, 384)", style=solid]; +"872 contiguous_7" -> "873 layer_norm_11" [label="(1, 14, 14, 384)", style=solid]; +"873 layer_norm_11" -> "874 add_15" [label="(1, 14, 14, 384)", style=solid]; +"874 add_15" -> "875 add_15_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 384)", style=solid]; +"874 add_15" -> "895 add_16" [label="(1, 14, 14, 384)", style=solid]; +"875 add_15_0_0_nncf_smooth_quant_0" -> "876 quantize_per_tensor_default_31" [label="(1, 14, 14, 384)", style=solid]; +"876 quantize_per_tensor_default_31" -> "877 dequantize_per_tensor_default_31" [label="(1, 14, 14, 384)", style=solid]; +"877 dequantize_per_tensor_default_31" -> "882 linear_30" [label="(1, 14, 14, 384)", style=solid]; +"878 linear_30_scale_0" -> "881 dequantize_per_channel_default_31" [label="(1536,)", style=solid]; +"879 linear_30_zero_point_0" -> "881 dequantize_per_channel_default_31" [label="(1536,)", style=solid]; +"880 _frozen_param31" -> "881 dequantize_per_channel_default_31" [label="(1536, 384)", style=solid]; +"881 dequantize_per_channel_default_31" -> "882 linear_30" [label="(1536, 384)", style=solid]; +"882 linear_30" -> "883 gelu_4" [label="(1, 14, 14, 1536)", style=solid]; +"883 gelu_4" -> "884 dropout_18" [label="(1, 14, 14, 1536)", style=solid]; +"884 dropout_18" -> "885 dropout_18_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 1536)", style=solid]; +"885 dropout_18_0_0_nncf_smooth_quant_0" -> "886 quantize_per_tensor_default_32" [label="(1, 14, 14, 1536)", style=solid]; +"886 quantize_per_tensor_default_32" -> "887 dequantize_per_tensor_default_32" [label="(1, 14, 14, 1536)", style=solid]; +"887 dequantize_per_tensor_default_32" -> "892 linear_31" [label="(1, 14, 14, 1536)", style=solid]; +"888 linear_31_scale_0" -> "891 dequantize_per_channel_default_32" [label="(384,)", style=solid]; +"889 linear_31_zero_point_0" -> "891 dequantize_per_channel_default_32" [label="(384,)", style=solid]; +"890 _frozen_param32" -> "891 dequantize_per_channel_default_32" [label="(384, 1536)", style=solid]; +"891 dequantize_per_channel_default_32" -> "892 linear_31" [label="(384, 1536)", style=solid]; +"892 linear_31" -> "893 dropout_19" [label="(1, 14, 14, 384)", style=solid]; +"893 dropout_19" -> "894 layer_norm_12" [label="(1, 14, 14, 384)", style=solid]; +"894 layer_norm_12" -> "895 add_16" [label="(1, 14, 14, 384)", style=solid]; +"895 add_16" -> "917 pad_7" [label="(1, 14, 14, 384)", style=solid]; +"895 add_16" -> "994 add_19" [label="(1, 14, 14, 384)", style=solid]; +"896 features_5_1_attn_relative_coords_table_0_0_nncf_smooth_quant_0" -> "901 linear_32" [label="(1, 15, 15, 2)", style=solid]; +"897 linear_32_scale_0" -> "900 dequantize_per_channel_default_33" [label="(512,)", style=solid]; +"898 linear_32_zero_point_0" -> "900 dequantize_per_channel_default_33" [label="(512,)", style=solid]; +"899 _frozen_param33" -> "900 dequantize_per_channel_default_33" [label="(512, 2)", style=solid]; +"900 dequantize_per_channel_default_33" -> "901 linear_32" [label="(512, 2)", style=solid]; +"901 linear_32" -> "902 relu__5" [label="(1, 15, 15, 512)", style=solid]; +"902 relu__5" -> "903 relu__5_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 512)", style=solid]; +"903 relu__5_0_0_nncf_smooth_quant_0" -> "908 linear_33" [label="(1, 15, 15, 512)", style=solid]; +"904 linear_33_scale_0" -> "907 dequantize_per_channel_default_34" [label="(12,)", style=solid]; +"905 linear_33_zero_point_0" -> "907 dequantize_per_channel_default_34" [label="(12,)", style=solid]; +"906 _frozen_param34" -> "907 dequantize_per_channel_default_34" [label="(12, 512)", style=solid]; +"907 dequantize_per_channel_default_34" -> "908 linear_33" [label="(12, 512)", style=solid]; +"908 linear_33" -> "909 view_26" [label="(1, 15, 15, 12)", style=solid]; +"909 view_26" -> "910 index_5" [label="(225, 12)", style=solid]; +"910 index_5" -> "911 view_27" [label="(4096, 12)", style=solid]; +"911 view_27" -> "912 permute_23" [label="(64, 64, 12)", style=solid]; +"912 permute_23" -> "913 contiguous_8" [label="(12, 64, 64)", style=solid]; +"913 contiguous_8" -> "914 unsqueeze_13" [label="(12, 64, 64)", style=solid]; +"914 unsqueeze_13" -> "915 sigmoid_5" [label="(1, 12, 64, 64)", style=solid]; +"915 sigmoid_5" -> "916 mul_10" [label="(1, 12, 64, 64)", style=solid]; +"916 mul_10" -> "953 add_17" [label="(1, 12, 64, 64)", style=solid]; +"917 pad_7" -> "918 roll_4" [label="(1, 16, 16, 384)", style=solid]; +"918 roll_4" -> "919 view_28" [label="(1, 16, 16, 384)", style=solid]; +"919 view_28" -> "920 permute_24" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"920 permute_24" -> "921 reshape_22" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"921 reshape_22" -> "923 reshape_22_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"921 reshape_22" -> "954 new_zeros_2" [label="(4, 64, 384)", style=solid]; +"922 clone_5" -> "930 linear_34" [label="(1152,)", style=solid]; +"923 reshape_22_0_0_nncf_smooth_quant_0" -> "924 quantize_per_tensor_default_33" [label="(4, 64, 384)", style=solid]; +"924 quantize_per_tensor_default_33" -> "925 dequantize_per_tensor_default_33" [label="(4, 64, 384)", style=solid]; +"925 dequantize_per_tensor_default_33" -> "930 linear_34" [label="(4, 64, 384)", style=solid]; +"926 linear_34_scale_0" -> "929 dequantize_per_channel_default_35" [label="(1152,)", style=solid]; +"927 linear_34_zero_point_0" -> "929 dequantize_per_channel_default_35" [label="(1152,)", style=solid]; +"928 _frozen_param35" -> "929 dequantize_per_channel_default_35" [label="(1152, 384)", style=solid]; +"929 dequantize_per_channel_default_35" -> "930 linear_34" [label="(1152, 384)", style=solid]; +"930 linear_34" -> "931 reshape_23" [label="(4, 64, 1152)", style=solid]; +"931 reshape_23" -> "932 permute_25" [label="(4, 64, 3, 12, 32)", style=solid]; +"932 permute_25" -> "933 select_15" [label="(3, 4, 12, 64, 32)", style=solid]; +"932 permute_25" -> "934 select_16" [label="(3, 4, 12, 64, 32)", style=solid]; +"932 permute_25" -> "935 select_17" [label="(3, 4, 12, 64, 32)", style=solid]; +"933 select_15" -> "936 linalg_vector_norm_10" [label="(4, 12, 64, 32)", style=solid]; +"933 select_15" -> "938 expand_as_10" [label="(4, 12, 64, 32)", style=solid]; +"933 select_15" -> "939 div_10" [label="(4, 12, 64, 32)", style=solid]; +"934 select_16" -> "942 linalg_vector_norm_11" [label="(4, 12, 64, 32)", style=solid]; +"934 select_16" -> "944 expand_as_11" [label="(4, 12, 64, 32)", style=solid]; +"934 select_16" -> "945 div_11" [label="(4, 12, 64, 32)", style=solid]; +"935 select_17" -> "972 matmul_11" [label="(4, 12, 64, 32)", style=solid]; +"936 linalg_vector_norm_10" -> "937 clamp_min_10" [label="(4, 12, 64, 1)", style=solid]; +"937 clamp_min_10" -> "938 expand_as_10" [label="(4, 12, 64, 1)", style=solid]; +"938 expand_as_10" -> "939 div_10" [label="(4, 12, 64, 32)", style=solid]; +"939 div_10" -> "940 quantize_per_tensor_default_34" [label="(4, 12, 64, 32)", style=solid]; +"940 quantize_per_tensor_default_34" -> "941 dequantize_per_tensor_default_34" [label="(4, 12, 64, 32)", style=solid]; +"941 dequantize_per_tensor_default_34" -> "949 matmul_10" [label="(4, 12, 64, 32)", style=solid]; +"942 linalg_vector_norm_11" -> "943 clamp_min_11" [label="(4, 12, 64, 1)", style=solid]; +"943 clamp_min_11" -> "944 expand_as_11" [label="(4, 12, 64, 1)", style=solid]; +"944 expand_as_11" -> "945 div_11" [label="(4, 12, 64, 32)", style=solid]; +"945 div_11" -> "946 quantize_per_tensor_default_35" [label="(4, 12, 64, 32)", style=solid]; +"946 quantize_per_tensor_default_35" -> "947 dequantize_per_tensor_default_35" [label="(4, 12, 64, 32)", style=solid]; +"947 dequantize_per_tensor_default_35" -> "948 transpose_10" [label="(4, 12, 64, 32)", style=solid]; +"948 transpose_10" -> "949 matmul_10" [label="(4, 12, 32, 64)", style=solid]; +"949 matmul_10" -> "952 mul_11" [label="(4, 12, 64, 64)", style=solid]; +"950 clamp_5" -> "951 exp_5" [label="(12, 1, 1)", style=solid]; +"951 exp_5" -> "952 mul_11" [label="(12, 1, 1)", style=solid]; +"952 mul_11" -> "953 add_17" [label="(4, 12, 64, 64)", style=solid]; +"953 add_17" -> "965 view_30" [label="(4, 12, 64, 64)", style=solid]; +"954 new_zeros_2" -> "955 view_29" [label="(16, 16)", style=solid]; +"955 view_29" -> "956 permute_26" [label="(2, 8, 2, 8)", style=solid]; +"956 permute_26" -> "957 reshape_24" [label="(2, 2, 8, 8)", style=solid]; +"957 reshape_24" -> "958 unsqueeze_14" [label="(4, 64)", style=solid]; +"957 reshape_24" -> "959 unsqueeze_15" [label="(4, 64)", style=solid]; +"958 unsqueeze_14" -> "960 sub_2" [label="(4, 1, 64)", style=solid]; +"959 unsqueeze_15" -> "960 sub_2" [label="(4, 64, 1)", style=solid]; +"960 sub_2" -> "961 ne_2" [label="(4, 64, 64)", style=solid]; +"960 sub_2" -> "962 masked_fill_4" [label="(4, 64, 64)", style=solid]; +"960 sub_2" -> "963 eq_2" [label="(4, 64, 64)", style=solid]; +"961 ne_2" -> "962 masked_fill_4" [label="(4, 64, 64)", style=solid]; +"962 masked_fill_4" -> "964 masked_fill_5" [label="(4, 64, 64)", style=solid]; +"963 eq_2" -> "964 masked_fill_5" [label="(4, 64, 64)", style=solid]; +"964 masked_fill_5" -> "966 unsqueeze_16" [label="(4, 64, 64)", style=solid]; +"965 view_30" -> "968 add_18" [label="(1, 4, 12, 64, 64)", style=solid]; +"966 unsqueeze_16" -> "967 unsqueeze_17" [label="(4, 1, 64, 64)", style=solid]; +"967 unsqueeze_17" -> "968 add_18" [label="(1, 4, 1, 64, 64)", style=solid]; +"968 add_18" -> "969 view_31" [label="(1, 4, 12, 64, 64)", style=solid]; +"969 view_31" -> "970 softmax_5" [label="(4, 12, 64, 64)", style=solid]; +"970 softmax_5" -> "971 dropout_20" [label="(4, 12, 64, 64)", style=solid]; +"971 dropout_20" -> "972 matmul_11" [label="(4, 12, 64, 64)", style=solid]; +"972 matmul_11" -> "973 transpose_11" [label="(4, 12, 64, 32)", style=solid]; +"973 transpose_11" -> "974 reshape_25" [label="(4, 64, 12, 32)", style=solid]; +"974 reshape_25" -> "975 reshape_25_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"975 reshape_25_0_0_nncf_smooth_quant_0" -> "976 quantize_per_tensor_default_36" [label="(4, 64, 384)", style=solid]; +"976 quantize_per_tensor_default_36" -> "977 dequantize_per_tensor_default_36" [label="(4, 64, 384)", style=solid]; +"977 dequantize_per_tensor_default_36" -> "982 linear_35" [label="(4, 64, 384)", style=solid]; +"978 linear_35_scale_0" -> "981 dequantize_per_channel_default_36" [label="(384,)", style=solid]; +"979 linear_35_zero_point_0" -> "981 dequantize_per_channel_default_36" [label="(384,)", style=solid]; +"980 _frozen_param36" -> "981 dequantize_per_channel_default_36" [label="(384, 384)", style=solid]; +"981 dequantize_per_channel_default_36" -> "982 linear_35" [label="(384, 384)", style=solid]; +"982 linear_35" -> "983 dropout_21" [label="(4, 64, 384)", style=solid]; +"983 dropout_21" -> "984 view_32" [label="(4, 64, 384)", style=solid]; +"984 view_32" -> "985 permute_27" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"985 permute_27" -> "986 reshape_26" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"986 reshape_26" -> "987 roll_5" [label="(1, 16, 16, 384)", style=solid]; +"987 roll_5" -> "988 slice_101" [label="(1, 16, 16, 384)", style=solid]; +"988 slice_101" -> "989 slice_102" [label="(1, 16, 16, 384)", style=solid]; +"989 slice_102" -> "990 slice_103" [label="(1, 14, 16, 384)", style=solid]; +"990 slice_103" -> "991 slice_104" [label="(1, 14, 14, 384)", style=solid]; +"991 slice_104" -> "992 contiguous_9" [label="(1, 14, 14, 384)", style=solid]; +"992 contiguous_9" -> "993 layer_norm_13" [label="(1, 14, 14, 384)", style=solid]; +"993 layer_norm_13" -> "994 add_19" [label="(1, 14, 14, 384)", style=solid]; +"994 add_19" -> "995 add_19_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 384)", style=solid]; +"994 add_19" -> "1015 add_20" [label="(1, 14, 14, 384)", style=solid]; +"995 add_19_0_0_nncf_smooth_quant_0" -> "996 quantize_per_tensor_default_37" [label="(1, 14, 14, 384)", style=solid]; +"996 quantize_per_tensor_default_37" -> "997 dequantize_per_tensor_default_37" [label="(1, 14, 14, 384)", style=solid]; +"997 dequantize_per_tensor_default_37" -> "1002 linear_36" [label="(1, 14, 14, 384)", style=solid]; +"998 linear_36_scale_0" -> "1001 dequantize_per_channel_default_37" [label="(1536,)", style=solid]; +"999 linear_36_zero_point_0" -> "1001 dequantize_per_channel_default_37" [label="(1536,)", style=solid]; +"1000 _frozen_param37" -> "1001 dequantize_per_channel_default_37" [label="(1536, 384)", style=solid]; +"1001 dequantize_per_channel_default_37" -> "1002 linear_36" [label="(1536, 384)", style=solid]; +"1002 linear_36" -> "1003 gelu_5" [label="(1, 14, 14, 1536)", style=solid]; +"1003 gelu_5" -> "1004 dropout_22" [label="(1, 14, 14, 1536)", style=solid]; +"1004 dropout_22" -> "1005 dropout_22_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 1536)", style=solid]; +"1005 dropout_22_0_0_nncf_smooth_quant_0" -> "1006 quantize_per_tensor_default_38" [label="(1, 14, 14, 1536)", style=solid]; +"1006 quantize_per_tensor_default_38" -> "1007 dequantize_per_tensor_default_38" [label="(1, 14, 14, 1536)", style=solid]; +"1007 dequantize_per_tensor_default_38" -> "1012 linear_37" [label="(1, 14, 14, 1536)", style=solid]; +"1008 linear_37_scale_0" -> "1011 dequantize_per_channel_default_38" [label="(384,)", style=solid]; +"1009 linear_37_zero_point_0" -> "1011 dequantize_per_channel_default_38" [label="(384,)", style=solid]; +"1010 _frozen_param38" -> "1011 dequantize_per_channel_default_38" [label="(384, 1536)", style=solid]; +"1011 dequantize_per_channel_default_38" -> "1012 linear_37" [label="(384, 1536)", style=solid]; +"1012 linear_37" -> "1013 dropout_23" [label="(1, 14, 14, 384)", style=solid]; +"1013 dropout_23" -> "1014 layer_norm_14" [label="(1, 14, 14, 384)", style=solid]; +"1014 layer_norm_14" -> "1015 add_20" [label="(1, 14, 14, 384)", style=solid]; +"1015 add_20" -> "1037 pad_8" [label="(1, 14, 14, 384)", style=solid]; +"1015 add_20" -> "1096 add_22" [label="(1, 14, 14, 384)", style=solid]; +"1016 features_5_2_attn_relative_coords_table_0_0_nncf_smooth_quant_0" -> "1021 linear_38" [label="(1, 15, 15, 2)", style=solid]; +"1017 linear_38_scale_0" -> "1020 dequantize_per_channel_default_39" [label="(512,)", style=solid]; +"1018 linear_38_zero_point_0" -> "1020 dequantize_per_channel_default_39" [label="(512,)", style=solid]; +"1019 _frozen_param39" -> "1020 dequantize_per_channel_default_39" [label="(512, 2)", style=solid]; +"1020 dequantize_per_channel_default_39" -> "1021 linear_38" [label="(512, 2)", style=solid]; +"1021 linear_38" -> "1022 relu__6" [label="(1, 15, 15, 512)", style=solid]; +"1022 relu__6" -> "1023 relu__6_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 512)", style=solid]; +"1023 relu__6_0_0_nncf_smooth_quant_0" -> "1028 linear_39" [label="(1, 15, 15, 512)", style=solid]; +"1024 linear_39_scale_0" -> "1027 dequantize_per_channel_default_40" [label="(12,)", style=solid]; +"1025 linear_39_zero_point_0" -> "1027 dequantize_per_channel_default_40" [label="(12,)", style=solid]; +"1026 _frozen_param40" -> "1027 dequantize_per_channel_default_40" [label="(12, 512)", style=solid]; +"1027 dequantize_per_channel_default_40" -> "1028 linear_39" [label="(12, 512)", style=solid]; +"1028 linear_39" -> "1029 view_33" [label="(1, 15, 15, 12)", style=solid]; +"1029 view_33" -> "1030 index_6" [label="(225, 12)", style=solid]; +"1030 index_6" -> "1031 view_34" [label="(4096, 12)", style=solid]; +"1031 view_34" -> "1032 permute_28" [label="(64, 64, 12)", style=solid]; +"1032 permute_28" -> "1033 contiguous_10" [label="(12, 64, 64)", style=solid]; +"1033 contiguous_10" -> "1034 unsqueeze_18" [label="(12, 64, 64)", style=solid]; +"1034 unsqueeze_18" -> "1035 sigmoid_6" [label="(1, 12, 64, 64)", style=solid]; +"1035 sigmoid_6" -> "1036 mul_12" [label="(1, 12, 64, 64)", style=solid]; +"1036 mul_12" -> "1072 add_21" [label="(1, 12, 64, 64)", style=solid]; +"1037 pad_8" -> "1038 view_35" [label="(1, 16, 16, 384)", style=solid]; +"1038 view_35" -> "1039 permute_29" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"1039 permute_29" -> "1040 reshape_27" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"1040 reshape_27" -> "1042 reshape_27_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"1041 clone_6" -> "1049 linear_40" [label="(1152,)", style=solid]; +"1042 reshape_27_0_0_nncf_smooth_quant_0" -> "1043 quantize_per_tensor_default_39" [label="(4, 64, 384)", style=solid]; +"1043 quantize_per_tensor_default_39" -> "1044 dequantize_per_tensor_default_39" [label="(4, 64, 384)", style=solid]; +"1044 dequantize_per_tensor_default_39" -> "1049 linear_40" [label="(4, 64, 384)", style=solid]; +"1045 linear_40_scale_0" -> "1048 dequantize_per_channel_default_41" [label="(1152,)", style=solid]; +"1046 linear_40_zero_point_0" -> "1048 dequantize_per_channel_default_41" [label="(1152,)", style=solid]; +"1047 _frozen_param41" -> "1048 dequantize_per_channel_default_41" [label="(1152, 384)", style=solid]; +"1048 dequantize_per_channel_default_41" -> "1049 linear_40" [label="(1152, 384)", style=solid]; +"1049 linear_40" -> "1050 reshape_28" [label="(4, 64, 1152)", style=solid]; +"1050 reshape_28" -> "1051 permute_30" [label="(4, 64, 3, 12, 32)", style=solid]; +"1051 permute_30" -> "1052 select_18" [label="(3, 4, 12, 64, 32)", style=solid]; +"1051 permute_30" -> "1053 select_19" [label="(3, 4, 12, 64, 32)", style=solid]; +"1051 permute_30" -> "1054 select_20" [label="(3, 4, 12, 64, 32)", style=solid]; +"1052 select_18" -> "1055 linalg_vector_norm_12" [label="(4, 12, 64, 32)", style=solid]; +"1052 select_18" -> "1057 expand_as_12" [label="(4, 12, 64, 32)", style=solid]; +"1052 select_18" -> "1058 div_12" [label="(4, 12, 64, 32)", style=solid]; +"1053 select_19" -> "1061 linalg_vector_norm_13" [label="(4, 12, 64, 32)", style=solid]; +"1053 select_19" -> "1063 expand_as_13" [label="(4, 12, 64, 32)", style=solid]; +"1053 select_19" -> "1064 div_13" [label="(4, 12, 64, 32)", style=solid]; +"1054 select_20" -> "1075 matmul_13" [label="(4, 12, 64, 32)", style=solid]; +"1055 linalg_vector_norm_12" -> "1056 clamp_min_12" [label="(4, 12, 64, 1)", style=solid]; +"1056 clamp_min_12" -> "1057 expand_as_12" [label="(4, 12, 64, 1)", style=solid]; +"1057 expand_as_12" -> "1058 div_12" [label="(4, 12, 64, 32)", style=solid]; +"1058 div_12" -> "1059 quantize_per_tensor_default_40" [label="(4, 12, 64, 32)", style=solid]; +"1059 quantize_per_tensor_default_40" -> "1060 dequantize_per_tensor_default_40" [label="(4, 12, 64, 32)", style=solid]; +"1060 dequantize_per_tensor_default_40" -> "1068 matmul_12" [label="(4, 12, 64, 32)", style=solid]; +"1061 linalg_vector_norm_13" -> "1062 clamp_min_13" [label="(4, 12, 64, 1)", style=solid]; +"1062 clamp_min_13" -> "1063 expand_as_13" [label="(4, 12, 64, 1)", style=solid]; +"1063 expand_as_13" -> "1064 div_13" [label="(4, 12, 64, 32)", style=solid]; +"1064 div_13" -> "1065 quantize_per_tensor_default_41" [label="(4, 12, 64, 32)", style=solid]; +"1065 quantize_per_tensor_default_41" -> "1066 dequantize_per_tensor_default_41" [label="(4, 12, 64, 32)", style=solid]; +"1066 dequantize_per_tensor_default_41" -> "1067 transpose_12" [label="(4, 12, 64, 32)", style=solid]; +"1067 transpose_12" -> "1068 matmul_12" [label="(4, 12, 32, 64)", style=solid]; +"1068 matmul_12" -> "1071 mul_13" [label="(4, 12, 64, 64)", style=solid]; +"1069 clamp_6" -> "1070 exp_6" [label="(12, 1, 1)", style=solid]; +"1070 exp_6" -> "1071 mul_13" [label="(12, 1, 1)", style=solid]; +"1071 mul_13" -> "1072 add_21" [label="(4, 12, 64, 64)", style=solid]; +"1072 add_21" -> "1073 softmax_6" [label="(4, 12, 64, 64)", style=solid]; +"1073 softmax_6" -> "1074 dropout_24" [label="(4, 12, 64, 64)", style=solid]; +"1074 dropout_24" -> "1075 matmul_13" [label="(4, 12, 64, 64)", style=solid]; +"1075 matmul_13" -> "1076 transpose_13" [label="(4, 12, 64, 32)", style=solid]; +"1076 transpose_13" -> "1077 reshape_29" [label="(4, 64, 12, 32)", style=solid]; +"1077 reshape_29" -> "1078 reshape_29_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"1078 reshape_29_0_0_nncf_smooth_quant_0" -> "1079 quantize_per_tensor_default_42" [label="(4, 64, 384)", style=solid]; +"1079 quantize_per_tensor_default_42" -> "1080 dequantize_per_tensor_default_42" [label="(4, 64, 384)", style=solid]; +"1080 dequantize_per_tensor_default_42" -> "1085 linear_41" [label="(4, 64, 384)", style=solid]; +"1081 linear_41_scale_0" -> "1084 dequantize_per_channel_default_42" [label="(384,)", style=solid]; +"1082 linear_41_zero_point_0" -> "1084 dequantize_per_channel_default_42" [label="(384,)", style=solid]; +"1083 _frozen_param42" -> "1084 dequantize_per_channel_default_42" [label="(384, 384)", style=solid]; +"1084 dequantize_per_channel_default_42" -> "1085 linear_41" [label="(384, 384)", style=solid]; +"1085 linear_41" -> "1086 dropout_25" [label="(4, 64, 384)", style=solid]; +"1086 dropout_25" -> "1087 view_36" [label="(4, 64, 384)", style=solid]; +"1087 view_36" -> "1088 permute_31" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"1088 permute_31" -> "1089 reshape_30" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"1089 reshape_30" -> "1090 slice_106" [label="(1, 16, 16, 384)", style=solid]; +"1090 slice_106" -> "1091 slice_107" [label="(1, 16, 16, 384)", style=solid]; +"1091 slice_107" -> "1092 slice_108" [label="(1, 14, 16, 384)", style=solid]; +"1092 slice_108" -> "1093 slice_109" [label="(1, 14, 14, 384)", style=solid]; +"1093 slice_109" -> "1094 contiguous_11" [label="(1, 14, 14, 384)", style=solid]; +"1094 contiguous_11" -> "1095 layer_norm_15" [label="(1, 14, 14, 384)", style=solid]; +"1095 layer_norm_15" -> "1096 add_22" [label="(1, 14, 14, 384)", style=solid]; +"1096 add_22" -> "1097 add_22_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 384)", style=solid]; +"1096 add_22" -> "1117 add_23" [label="(1, 14, 14, 384)", style=solid]; +"1097 add_22_0_0_nncf_smooth_quant_0" -> "1098 quantize_per_tensor_default_43" [label="(1, 14, 14, 384)", style=solid]; +"1098 quantize_per_tensor_default_43" -> "1099 dequantize_per_tensor_default_43" [label="(1, 14, 14, 384)", style=solid]; +"1099 dequantize_per_tensor_default_43" -> "1104 linear_42" [label="(1, 14, 14, 384)", style=solid]; +"1100 linear_42_scale_0" -> "1103 dequantize_per_channel_default_43" [label="(1536,)", style=solid]; +"1101 linear_42_zero_point_0" -> "1103 dequantize_per_channel_default_43" [label="(1536,)", style=solid]; +"1102 _frozen_param43" -> "1103 dequantize_per_channel_default_43" [label="(1536, 384)", style=solid]; +"1103 dequantize_per_channel_default_43" -> "1104 linear_42" [label="(1536, 384)", style=solid]; +"1104 linear_42" -> "1105 gelu_6" [label="(1, 14, 14, 1536)", style=solid]; +"1105 gelu_6" -> "1106 dropout_26" [label="(1, 14, 14, 1536)", style=solid]; +"1106 dropout_26" -> "1107 dropout_26_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 1536)", style=solid]; +"1107 dropout_26_0_0_nncf_smooth_quant_0" -> "1108 quantize_per_tensor_default_44" [label="(1, 14, 14, 1536)", style=solid]; +"1108 quantize_per_tensor_default_44" -> "1109 dequantize_per_tensor_default_44" [label="(1, 14, 14, 1536)", style=solid]; +"1109 dequantize_per_tensor_default_44" -> "1114 linear_43" [label="(1, 14, 14, 1536)", style=solid]; +"1110 linear_43_scale_0" -> "1113 dequantize_per_channel_default_44" [label="(384,)", style=solid]; +"1111 linear_43_zero_point_0" -> "1113 dequantize_per_channel_default_44" [label="(384,)", style=solid]; +"1112 _frozen_param44" -> "1113 dequantize_per_channel_default_44" [label="(384, 1536)", style=solid]; +"1113 dequantize_per_channel_default_44" -> "1114 linear_43" [label="(384, 1536)", style=solid]; +"1114 linear_43" -> "1115 dropout_27" [label="(1, 14, 14, 384)", style=solid]; +"1115 dropout_27" -> "1116 layer_norm_16" [label="(1, 14, 14, 384)", style=solid]; +"1116 layer_norm_16" -> "1117 add_23" [label="(1, 14, 14, 384)", style=solid]; +"1117 add_23" -> "1139 pad_9" [label="(1, 14, 14, 384)", style=solid]; +"1117 add_23" -> "1216 add_26" [label="(1, 14, 14, 384)", style=solid]; +"1118 features_5_3_attn_relative_coords_table_0_0_nncf_smooth_quant_0" -> "1123 linear_44" [label="(1, 15, 15, 2)", style=solid]; +"1119 linear_44_scale_0" -> "1122 dequantize_per_channel_default_45" [label="(512,)", style=solid]; +"1120 linear_44_zero_point_0" -> "1122 dequantize_per_channel_default_45" [label="(512,)", style=solid]; +"1121 _frozen_param45" -> "1122 dequantize_per_channel_default_45" [label="(512, 2)", style=solid]; +"1122 dequantize_per_channel_default_45" -> "1123 linear_44" [label="(512, 2)", style=solid]; +"1123 linear_44" -> "1124 relu__7" [label="(1, 15, 15, 512)", style=solid]; +"1124 relu__7" -> "1125 relu__7_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 512)", style=solid]; +"1125 relu__7_0_0_nncf_smooth_quant_0" -> "1130 linear_45" [label="(1, 15, 15, 512)", style=solid]; +"1126 linear_45_scale_0" -> "1129 dequantize_per_channel_default_46" [label="(12,)", style=solid]; +"1127 linear_45_zero_point_0" -> "1129 dequantize_per_channel_default_46" [label="(12,)", style=solid]; +"1128 _frozen_param46" -> "1129 dequantize_per_channel_default_46" [label="(12, 512)", style=solid]; +"1129 dequantize_per_channel_default_46" -> "1130 linear_45" [label="(12, 512)", style=solid]; +"1130 linear_45" -> "1131 view_37" [label="(1, 15, 15, 12)", style=solid]; +"1131 view_37" -> "1132 index_7" [label="(225, 12)", style=solid]; +"1132 index_7" -> "1133 view_38" [label="(4096, 12)", style=solid]; +"1133 view_38" -> "1134 permute_32" [label="(64, 64, 12)", style=solid]; +"1134 permute_32" -> "1135 contiguous_12" [label="(12, 64, 64)", style=solid]; +"1135 contiguous_12" -> "1136 unsqueeze_19" [label="(12, 64, 64)", style=solid]; +"1136 unsqueeze_19" -> "1137 sigmoid_7" [label="(1, 12, 64, 64)", style=solid]; +"1137 sigmoid_7" -> "1138 mul_14" [label="(1, 12, 64, 64)", style=solid]; +"1138 mul_14" -> "1175 add_24" [label="(1, 12, 64, 64)", style=solid]; +"1139 pad_9" -> "1140 roll_6" [label="(1, 16, 16, 384)", style=solid]; +"1140 roll_6" -> "1141 view_39" [label="(1, 16, 16, 384)", style=solid]; +"1141 view_39" -> "1142 permute_33" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"1142 permute_33" -> "1143 reshape_31" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"1143 reshape_31" -> "1145 reshape_31_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"1143 reshape_31" -> "1176 new_zeros_3" [label="(4, 64, 384)", style=solid]; +"1144 clone_7" -> "1152 linear_46" [label="(1152,)", style=solid]; +"1145 reshape_31_0_0_nncf_smooth_quant_0" -> "1146 quantize_per_tensor_default_45" [label="(4, 64, 384)", style=solid]; +"1146 quantize_per_tensor_default_45" -> "1147 dequantize_per_tensor_default_45" [label="(4, 64, 384)", style=solid]; +"1147 dequantize_per_tensor_default_45" -> "1152 linear_46" [label="(4, 64, 384)", style=solid]; +"1148 linear_46_scale_0" -> "1151 dequantize_per_channel_default_47" [label="(1152,)", style=solid]; +"1149 linear_46_zero_point_0" -> "1151 dequantize_per_channel_default_47" [label="(1152,)", style=solid]; +"1150 _frozen_param47" -> "1151 dequantize_per_channel_default_47" [label="(1152, 384)", style=solid]; +"1151 dequantize_per_channel_default_47" -> "1152 linear_46" [label="(1152, 384)", style=solid]; +"1152 linear_46" -> "1153 reshape_32" [label="(4, 64, 1152)", style=solid]; +"1153 reshape_32" -> "1154 permute_34" [label="(4, 64, 3, 12, 32)", style=solid]; +"1154 permute_34" -> "1155 select_21" [label="(3, 4, 12, 64, 32)", style=solid]; +"1154 permute_34" -> "1156 select_22" [label="(3, 4, 12, 64, 32)", style=solid]; +"1154 permute_34" -> "1157 select_23" [label="(3, 4, 12, 64, 32)", style=solid]; +"1155 select_21" -> "1158 linalg_vector_norm_14" [label="(4, 12, 64, 32)", style=solid]; +"1155 select_21" -> "1160 expand_as_14" [label="(4, 12, 64, 32)", style=solid]; +"1155 select_21" -> "1161 div_14" [label="(4, 12, 64, 32)", style=solid]; +"1156 select_22" -> "1164 linalg_vector_norm_15" [label="(4, 12, 64, 32)", style=solid]; +"1156 select_22" -> "1166 expand_as_15" [label="(4, 12, 64, 32)", style=solid]; +"1156 select_22" -> "1167 div_15" [label="(4, 12, 64, 32)", style=solid]; +"1157 select_23" -> "1194 matmul_15" [label="(4, 12, 64, 32)", style=solid]; +"1158 linalg_vector_norm_14" -> "1159 clamp_min_14" [label="(4, 12, 64, 1)", style=solid]; +"1159 clamp_min_14" -> "1160 expand_as_14" [label="(4, 12, 64, 1)", style=solid]; +"1160 expand_as_14" -> "1161 div_14" [label="(4, 12, 64, 32)", style=solid]; +"1161 div_14" -> "1162 quantize_per_tensor_default_46" [label="(4, 12, 64, 32)", style=solid]; +"1162 quantize_per_tensor_default_46" -> "1163 dequantize_per_tensor_default_46" [label="(4, 12, 64, 32)", style=solid]; +"1163 dequantize_per_tensor_default_46" -> "1171 matmul_14" [label="(4, 12, 64, 32)", style=solid]; +"1164 linalg_vector_norm_15" -> "1165 clamp_min_15" [label="(4, 12, 64, 1)", style=solid]; +"1165 clamp_min_15" -> "1166 expand_as_15" [label="(4, 12, 64, 1)", style=solid]; +"1166 expand_as_15" -> "1167 div_15" [label="(4, 12, 64, 32)", style=solid]; +"1167 div_15" -> "1168 quantize_per_tensor_default_47" [label="(4, 12, 64, 32)", style=solid]; +"1168 quantize_per_tensor_default_47" -> "1169 dequantize_per_tensor_default_47" [label="(4, 12, 64, 32)", style=solid]; +"1169 dequantize_per_tensor_default_47" -> "1170 transpose_14" [label="(4, 12, 64, 32)", style=solid]; +"1170 transpose_14" -> "1171 matmul_14" [label="(4, 12, 32, 64)", style=solid]; +"1171 matmul_14" -> "1174 mul_15" [label="(4, 12, 64, 64)", style=solid]; +"1172 clamp_7" -> "1173 exp_7" [label="(12, 1, 1)", style=solid]; +"1173 exp_7" -> "1174 mul_15" [label="(12, 1, 1)", style=solid]; +"1174 mul_15" -> "1175 add_24" [label="(4, 12, 64, 64)", style=solid]; +"1175 add_24" -> "1187 view_41" [label="(4, 12, 64, 64)", style=solid]; +"1176 new_zeros_3" -> "1177 view_40" [label="(16, 16)", style=solid]; +"1177 view_40" -> "1178 permute_35" [label="(2, 8, 2, 8)", style=solid]; +"1178 permute_35" -> "1179 reshape_33" [label="(2, 2, 8, 8)", style=solid]; +"1179 reshape_33" -> "1180 unsqueeze_20" [label="(4, 64)", style=solid]; +"1179 reshape_33" -> "1181 unsqueeze_21" [label="(4, 64)", style=solid]; +"1180 unsqueeze_20" -> "1182 sub_3" [label="(4, 1, 64)", style=solid]; +"1181 unsqueeze_21" -> "1182 sub_3" [label="(4, 64, 1)", style=solid]; +"1182 sub_3" -> "1183 ne_3" [label="(4, 64, 64)", style=solid]; +"1182 sub_3" -> "1184 masked_fill_6" [label="(4, 64, 64)", style=solid]; +"1182 sub_3" -> "1185 eq_3" [label="(4, 64, 64)", style=solid]; +"1183 ne_3" -> "1184 masked_fill_6" [label="(4, 64, 64)", style=solid]; +"1184 masked_fill_6" -> "1186 masked_fill_7" [label="(4, 64, 64)", style=solid]; +"1185 eq_3" -> "1186 masked_fill_7" [label="(4, 64, 64)", style=solid]; +"1186 masked_fill_7" -> "1188 unsqueeze_22" [label="(4, 64, 64)", style=solid]; +"1187 view_41" -> "1190 add_25" [label="(1, 4, 12, 64, 64)", style=solid]; +"1188 unsqueeze_22" -> "1189 unsqueeze_23" [label="(4, 1, 64, 64)", style=solid]; +"1189 unsqueeze_23" -> "1190 add_25" [label="(1, 4, 1, 64, 64)", style=solid]; +"1190 add_25" -> "1191 view_42" [label="(1, 4, 12, 64, 64)", style=solid]; +"1191 view_42" -> "1192 softmax_7" [label="(4, 12, 64, 64)", style=solid]; +"1192 softmax_7" -> "1193 dropout_28" [label="(4, 12, 64, 64)", style=solid]; +"1193 dropout_28" -> "1194 matmul_15" [label="(4, 12, 64, 64)", style=solid]; +"1194 matmul_15" -> "1195 transpose_15" [label="(4, 12, 64, 32)", style=solid]; +"1195 transpose_15" -> "1196 reshape_34" [label="(4, 64, 12, 32)", style=solid]; +"1196 reshape_34" -> "1197 reshape_34_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"1197 reshape_34_0_0_nncf_smooth_quant_0" -> "1198 quantize_per_tensor_default_48" [label="(4, 64, 384)", style=solid]; +"1198 quantize_per_tensor_default_48" -> "1199 dequantize_per_tensor_default_48" [label="(4, 64, 384)", style=solid]; +"1199 dequantize_per_tensor_default_48" -> "1204 linear_47" [label="(4, 64, 384)", style=solid]; +"1200 linear_47_scale_0" -> "1203 dequantize_per_channel_default_48" [label="(384,)", style=solid]; +"1201 linear_47_zero_point_0" -> "1203 dequantize_per_channel_default_48" [label="(384,)", style=solid]; +"1202 _frozen_param48" -> "1203 dequantize_per_channel_default_48" [label="(384, 384)", style=solid]; +"1203 dequantize_per_channel_default_48" -> "1204 linear_47" [label="(384, 384)", style=solid]; +"1204 linear_47" -> "1205 dropout_29" [label="(4, 64, 384)", style=solid]; +"1205 dropout_29" -> "1206 view_43" [label="(4, 64, 384)", style=solid]; +"1206 view_43" -> "1207 permute_36" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"1207 permute_36" -> "1208 reshape_35" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"1208 reshape_35" -> "1209 roll_7" [label="(1, 16, 16, 384)", style=solid]; +"1209 roll_7" -> "1210 slice_129" [label="(1, 16, 16, 384)", style=solid]; +"1210 slice_129" -> "1211 slice_130" [label="(1, 16, 16, 384)", style=solid]; +"1211 slice_130" -> "1212 slice_131" [label="(1, 14, 16, 384)", style=solid]; +"1212 slice_131" -> "1213 slice_132" [label="(1, 14, 14, 384)", style=solid]; +"1213 slice_132" -> "1214 contiguous_13" [label="(1, 14, 14, 384)", style=solid]; +"1214 contiguous_13" -> "1215 layer_norm_17" [label="(1, 14, 14, 384)", style=solid]; +"1215 layer_norm_17" -> "1216 add_26" [label="(1, 14, 14, 384)", style=solid]; +"1216 add_26" -> "1217 add_26_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 384)", style=solid]; +"1216 add_26" -> "1237 add_27" [label="(1, 14, 14, 384)", style=solid]; +"1217 add_26_0_0_nncf_smooth_quant_0" -> "1218 quantize_per_tensor_default_49" [label="(1, 14, 14, 384)", style=solid]; +"1218 quantize_per_tensor_default_49" -> "1219 dequantize_per_tensor_default_49" [label="(1, 14, 14, 384)", style=solid]; +"1219 dequantize_per_tensor_default_49" -> "1224 linear_48" [label="(1, 14, 14, 384)", style=solid]; +"1220 linear_48_scale_0" -> "1223 dequantize_per_channel_default_49" [label="(1536,)", style=solid]; +"1221 linear_48_zero_point_0" -> "1223 dequantize_per_channel_default_49" [label="(1536,)", style=solid]; +"1222 _frozen_param49" -> "1223 dequantize_per_channel_default_49" [label="(1536, 384)", style=solid]; +"1223 dequantize_per_channel_default_49" -> "1224 linear_48" [label="(1536, 384)", style=solid]; +"1224 linear_48" -> "1225 gelu_7" [label="(1, 14, 14, 1536)", style=solid]; +"1225 gelu_7" -> "1226 dropout_30" [label="(1, 14, 14, 1536)", style=solid]; +"1226 dropout_30" -> "1227 dropout_30_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 1536)", style=solid]; +"1227 dropout_30_0_0_nncf_smooth_quant_0" -> "1228 quantize_per_tensor_default_50" [label="(1, 14, 14, 1536)", style=solid]; +"1228 quantize_per_tensor_default_50" -> "1229 dequantize_per_tensor_default_50" [label="(1, 14, 14, 1536)", style=solid]; +"1229 dequantize_per_tensor_default_50" -> "1234 linear_49" [label="(1, 14, 14, 1536)", style=solid]; +"1230 linear_49_scale_0" -> "1233 dequantize_per_channel_default_50" [label="(384,)", style=solid]; +"1231 linear_49_zero_point_0" -> "1233 dequantize_per_channel_default_50" [label="(384,)", style=solid]; +"1232 _frozen_param50" -> "1233 dequantize_per_channel_default_50" [label="(384, 1536)", style=solid]; +"1233 dequantize_per_channel_default_50" -> "1234 linear_49" [label="(384, 1536)", style=solid]; +"1234 linear_49" -> "1235 dropout_31" [label="(1, 14, 14, 384)", style=solid]; +"1235 dropout_31" -> "1236 layer_norm_18" [label="(1, 14, 14, 384)", style=solid]; +"1236 layer_norm_18" -> "1237 add_27" [label="(1, 14, 14, 384)", style=solid]; +"1237 add_27" -> "1259 pad_10" [label="(1, 14, 14, 384)", style=solid]; +"1237 add_27" -> "1318 add_29" [label="(1, 14, 14, 384)", style=solid]; +"1238 features_5_4_attn_relative_coords_table_0_0_nncf_smooth_quant_0" -> "1243 linear_50" [label="(1, 15, 15, 2)", style=solid]; +"1239 linear_50_scale_0" -> "1242 dequantize_per_channel_default_51" [label="(512,)", style=solid]; +"1240 linear_50_zero_point_0" -> "1242 dequantize_per_channel_default_51" [label="(512,)", style=solid]; +"1241 _frozen_param51" -> "1242 dequantize_per_channel_default_51" [label="(512, 2)", style=solid]; +"1242 dequantize_per_channel_default_51" -> "1243 linear_50" [label="(512, 2)", style=solid]; +"1243 linear_50" -> "1244 relu__8" [label="(1, 15, 15, 512)", style=solid]; +"1244 relu__8" -> "1245 relu__8_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 512)", style=solid]; +"1245 relu__8_0_0_nncf_smooth_quant_0" -> "1250 linear_51" [label="(1, 15, 15, 512)", style=solid]; +"1246 linear_51_scale_0" -> "1249 dequantize_per_channel_default_52" [label="(12,)", style=solid]; +"1247 linear_51_zero_point_0" -> "1249 dequantize_per_channel_default_52" [label="(12,)", style=solid]; +"1248 _frozen_param52" -> "1249 dequantize_per_channel_default_52" [label="(12, 512)", style=solid]; +"1249 dequantize_per_channel_default_52" -> "1250 linear_51" [label="(12, 512)", style=solid]; +"1250 linear_51" -> "1251 view_44" [label="(1, 15, 15, 12)", style=solid]; +"1251 view_44" -> "1252 index_8" [label="(225, 12)", style=solid]; +"1252 index_8" -> "1253 view_45" [label="(4096, 12)", style=solid]; +"1253 view_45" -> "1254 permute_37" [label="(64, 64, 12)", style=solid]; +"1254 permute_37" -> "1255 contiguous_14" [label="(12, 64, 64)", style=solid]; +"1255 contiguous_14" -> "1256 unsqueeze_24" [label="(12, 64, 64)", style=solid]; +"1256 unsqueeze_24" -> "1257 sigmoid_8" [label="(1, 12, 64, 64)", style=solid]; +"1257 sigmoid_8" -> "1258 mul_16" [label="(1, 12, 64, 64)", style=solid]; +"1258 mul_16" -> "1294 add_28" [label="(1, 12, 64, 64)", style=solid]; +"1259 pad_10" -> "1260 view_46" [label="(1, 16, 16, 384)", style=solid]; +"1260 view_46" -> "1261 permute_38" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"1261 permute_38" -> "1262 reshape_36" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"1262 reshape_36" -> "1264 reshape_36_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"1263 clone_8" -> "1271 linear_52" [label="(1152,)", style=solid]; +"1264 reshape_36_0_0_nncf_smooth_quant_0" -> "1265 quantize_per_tensor_default_51" [label="(4, 64, 384)", style=solid]; +"1265 quantize_per_tensor_default_51" -> "1266 dequantize_per_tensor_default_51" [label="(4, 64, 384)", style=solid]; +"1266 dequantize_per_tensor_default_51" -> "1271 linear_52" [label="(4, 64, 384)", style=solid]; +"1267 linear_52_scale_0" -> "1270 dequantize_per_channel_default_53" [label="(1152,)", style=solid]; +"1268 linear_52_zero_point_0" -> "1270 dequantize_per_channel_default_53" [label="(1152,)", style=solid]; +"1269 _frozen_param53" -> "1270 dequantize_per_channel_default_53" [label="(1152, 384)", style=solid]; +"1270 dequantize_per_channel_default_53" -> "1271 linear_52" [label="(1152, 384)", style=solid]; +"1271 linear_52" -> "1272 reshape_37" [label="(4, 64, 1152)", style=solid]; +"1272 reshape_37" -> "1273 permute_39" [label="(4, 64, 3, 12, 32)", style=solid]; +"1273 permute_39" -> "1274 select_24" [label="(3, 4, 12, 64, 32)", style=solid]; +"1273 permute_39" -> "1275 select_25" [label="(3, 4, 12, 64, 32)", style=solid]; +"1273 permute_39" -> "1276 select_26" [label="(3, 4, 12, 64, 32)", style=solid]; +"1274 select_24" -> "1277 linalg_vector_norm_16" [label="(4, 12, 64, 32)", style=solid]; +"1274 select_24" -> "1279 expand_as_16" [label="(4, 12, 64, 32)", style=solid]; +"1274 select_24" -> "1280 div_16" [label="(4, 12, 64, 32)", style=solid]; +"1275 select_25" -> "1283 linalg_vector_norm_17" [label="(4, 12, 64, 32)", style=solid]; +"1275 select_25" -> "1285 expand_as_17" [label="(4, 12, 64, 32)", style=solid]; +"1275 select_25" -> "1286 div_17" [label="(4, 12, 64, 32)", style=solid]; +"1276 select_26" -> "1297 matmul_17" [label="(4, 12, 64, 32)", style=solid]; +"1277 linalg_vector_norm_16" -> "1278 clamp_min_16" [label="(4, 12, 64, 1)", style=solid]; +"1278 clamp_min_16" -> "1279 expand_as_16" [label="(4, 12, 64, 1)", style=solid]; +"1279 expand_as_16" -> "1280 div_16" [label="(4, 12, 64, 32)", style=solid]; +"1280 div_16" -> "1281 quantize_per_tensor_default_52" [label="(4, 12, 64, 32)", style=solid]; +"1281 quantize_per_tensor_default_52" -> "1282 dequantize_per_tensor_default_52" [label="(4, 12, 64, 32)", style=solid]; +"1282 dequantize_per_tensor_default_52" -> "1290 matmul_16" [label="(4, 12, 64, 32)", style=solid]; +"1283 linalg_vector_norm_17" -> "1284 clamp_min_17" [label="(4, 12, 64, 1)", style=solid]; +"1284 clamp_min_17" -> "1285 expand_as_17" [label="(4, 12, 64, 1)", style=solid]; +"1285 expand_as_17" -> "1286 div_17" [label="(4, 12, 64, 32)", style=solid]; +"1286 div_17" -> "1287 quantize_per_tensor_default_53" [label="(4, 12, 64, 32)", style=solid]; +"1287 quantize_per_tensor_default_53" -> "1288 dequantize_per_tensor_default_53" [label="(4, 12, 64, 32)", style=solid]; +"1288 dequantize_per_tensor_default_53" -> "1289 transpose_16" [label="(4, 12, 64, 32)", style=solid]; +"1289 transpose_16" -> "1290 matmul_16" [label="(4, 12, 32, 64)", style=solid]; +"1290 matmul_16" -> "1293 mul_17" [label="(4, 12, 64, 64)", style=solid]; +"1291 clamp_8" -> "1292 exp_8" [label="(12, 1, 1)", style=solid]; +"1292 exp_8" -> "1293 mul_17" [label="(12, 1, 1)", style=solid]; +"1293 mul_17" -> "1294 add_28" [label="(4, 12, 64, 64)", style=solid]; +"1294 add_28" -> "1295 softmax_8" [label="(4, 12, 64, 64)", style=solid]; +"1295 softmax_8" -> "1296 dropout_32" [label="(4, 12, 64, 64)", style=solid]; +"1296 dropout_32" -> "1297 matmul_17" [label="(4, 12, 64, 64)", style=solid]; +"1297 matmul_17" -> "1298 transpose_17" [label="(4, 12, 64, 32)", style=solid]; +"1298 transpose_17" -> "1299 reshape_38" [label="(4, 64, 12, 32)", style=solid]; +"1299 reshape_38" -> "1300 reshape_38_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"1300 reshape_38_0_0_nncf_smooth_quant_0" -> "1301 quantize_per_tensor_default_54" [label="(4, 64, 384)", style=solid]; +"1301 quantize_per_tensor_default_54" -> "1302 dequantize_per_tensor_default_54" [label="(4, 64, 384)", style=solid]; +"1302 dequantize_per_tensor_default_54" -> "1307 linear_53" [label="(4, 64, 384)", style=solid]; +"1303 linear_53_scale_0" -> "1306 dequantize_per_channel_default_54" [label="(384,)", style=solid]; +"1304 linear_53_zero_point_0" -> "1306 dequantize_per_channel_default_54" [label="(384,)", style=solid]; +"1305 _frozen_param54" -> "1306 dequantize_per_channel_default_54" [label="(384, 384)", style=solid]; +"1306 dequantize_per_channel_default_54" -> "1307 linear_53" [label="(384, 384)", style=solid]; +"1307 linear_53" -> "1308 dropout_33" [label="(4, 64, 384)", style=solid]; +"1308 dropout_33" -> "1309 view_47" [label="(4, 64, 384)", style=solid]; +"1309 view_47" -> "1310 permute_40" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"1310 permute_40" -> "1311 reshape_39" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"1311 reshape_39" -> "1312 slice_134" [label="(1, 16, 16, 384)", style=solid]; +"1312 slice_134" -> "1313 slice_135" [label="(1, 16, 16, 384)", style=solid]; +"1313 slice_135" -> "1314 slice_136" [label="(1, 14, 16, 384)", style=solid]; +"1314 slice_136" -> "1315 slice_137" [label="(1, 14, 14, 384)", style=solid]; +"1315 slice_137" -> "1316 contiguous_15" [label="(1, 14, 14, 384)", style=solid]; +"1316 contiguous_15" -> "1317 layer_norm_19" [label="(1, 14, 14, 384)", style=solid]; +"1317 layer_norm_19" -> "1318 add_29" [label="(1, 14, 14, 384)", style=solid]; +"1318 add_29" -> "1319 add_29_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 384)", style=solid]; +"1318 add_29" -> "1339 add_30" [label="(1, 14, 14, 384)", style=solid]; +"1319 add_29_0_0_nncf_smooth_quant_0" -> "1320 quantize_per_tensor_default_55" [label="(1, 14, 14, 384)", style=solid]; +"1320 quantize_per_tensor_default_55" -> "1321 dequantize_per_tensor_default_55" [label="(1, 14, 14, 384)", style=solid]; +"1321 dequantize_per_tensor_default_55" -> "1326 linear_54" [label="(1, 14, 14, 384)", style=solid]; +"1322 linear_54_scale_0" -> "1325 dequantize_per_channel_default_55" [label="(1536,)", style=solid]; +"1323 linear_54_zero_point_0" -> "1325 dequantize_per_channel_default_55" [label="(1536,)", style=solid]; +"1324 _frozen_param55" -> "1325 dequantize_per_channel_default_55" [label="(1536, 384)", style=solid]; +"1325 dequantize_per_channel_default_55" -> "1326 linear_54" [label="(1536, 384)", style=solid]; +"1326 linear_54" -> "1327 gelu_8" [label="(1, 14, 14, 1536)", style=solid]; +"1327 gelu_8" -> "1328 dropout_34" [label="(1, 14, 14, 1536)", style=solid]; +"1328 dropout_34" -> "1329 dropout_34_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 1536)", style=solid]; +"1329 dropout_34_0_0_nncf_smooth_quant_0" -> "1330 quantize_per_tensor_default_56" [label="(1, 14, 14, 1536)", style=solid]; +"1330 quantize_per_tensor_default_56" -> "1331 dequantize_per_tensor_default_56" [label="(1, 14, 14, 1536)", style=solid]; +"1331 dequantize_per_tensor_default_56" -> "1336 linear_55" [label="(1, 14, 14, 1536)", style=solid]; +"1332 linear_55_scale_0" -> "1335 dequantize_per_channel_default_56" [label="(384,)", style=solid]; +"1333 linear_55_zero_point_0" -> "1335 dequantize_per_channel_default_56" [label="(384,)", style=solid]; +"1334 _frozen_param56" -> "1335 dequantize_per_channel_default_56" [label="(384, 1536)", style=solid]; +"1335 dequantize_per_channel_default_56" -> "1336 linear_55" [label="(384, 1536)", style=solid]; +"1336 linear_55" -> "1337 dropout_35" [label="(1, 14, 14, 384)", style=solid]; +"1337 dropout_35" -> "1338 layer_norm_20" [label="(1, 14, 14, 384)", style=solid]; +"1338 layer_norm_20" -> "1339 add_30" [label="(1, 14, 14, 384)", style=solid]; +"1339 add_30" -> "1361 pad_11" [label="(1, 14, 14, 384)", style=solid]; +"1339 add_30" -> "1438 add_33" [label="(1, 14, 14, 384)", style=solid]; +"1340 features_5_5_attn_relative_coords_table_0_0_nncf_smooth_quant_0" -> "1345 linear_56" [label="(1, 15, 15, 2)", style=solid]; +"1341 linear_56_scale_0" -> "1344 dequantize_per_channel_default_57" [label="(512,)", style=solid]; +"1342 linear_56_zero_point_0" -> "1344 dequantize_per_channel_default_57" [label="(512,)", style=solid]; +"1343 _frozen_param57" -> "1344 dequantize_per_channel_default_57" [label="(512, 2)", style=solid]; +"1344 dequantize_per_channel_default_57" -> "1345 linear_56" [label="(512, 2)", style=solid]; +"1345 linear_56" -> "1346 relu__9" [label="(1, 15, 15, 512)", style=solid]; +"1346 relu__9" -> "1347 relu__9_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 512)", style=solid]; +"1347 relu__9_0_0_nncf_smooth_quant_0" -> "1352 linear_57" [label="(1, 15, 15, 512)", style=solid]; +"1348 linear_57_scale_0" -> "1351 dequantize_per_channel_default_58" [label="(12,)", style=solid]; +"1349 linear_57_zero_point_0" -> "1351 dequantize_per_channel_default_58" [label="(12,)", style=solid]; +"1350 _frozen_param58" -> "1351 dequantize_per_channel_default_58" [label="(12, 512)", style=solid]; +"1351 dequantize_per_channel_default_58" -> "1352 linear_57" [label="(12, 512)", style=solid]; +"1352 linear_57" -> "1353 view_48" [label="(1, 15, 15, 12)", style=solid]; +"1353 view_48" -> "1354 index_9" [label="(225, 12)", style=solid]; +"1354 index_9" -> "1355 view_49" [label="(4096, 12)", style=solid]; +"1355 view_49" -> "1356 permute_41" [label="(64, 64, 12)", style=solid]; +"1356 permute_41" -> "1357 contiguous_16" [label="(12, 64, 64)", style=solid]; +"1357 contiguous_16" -> "1358 unsqueeze_25" [label="(12, 64, 64)", style=solid]; +"1358 unsqueeze_25" -> "1359 sigmoid_9" [label="(1, 12, 64, 64)", style=solid]; +"1359 sigmoid_9" -> "1360 mul_18" [label="(1, 12, 64, 64)", style=solid]; +"1360 mul_18" -> "1397 add_31" [label="(1, 12, 64, 64)", style=solid]; +"1361 pad_11" -> "1362 roll_8" [label="(1, 16, 16, 384)", style=solid]; +"1362 roll_8" -> "1363 view_50" [label="(1, 16, 16, 384)", style=solid]; +"1363 view_50" -> "1364 permute_42" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"1364 permute_42" -> "1365 reshape_40" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"1365 reshape_40" -> "1367 reshape_40_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"1365 reshape_40" -> "1398 new_zeros_4" [label="(4, 64, 384)", style=solid]; +"1366 clone_9" -> "1374 linear_58" [label="(1152,)", style=solid]; +"1367 reshape_40_0_0_nncf_smooth_quant_0" -> "1368 quantize_per_tensor_default_57" [label="(4, 64, 384)", style=solid]; +"1368 quantize_per_tensor_default_57" -> "1369 dequantize_per_tensor_default_57" [label="(4, 64, 384)", style=solid]; +"1369 dequantize_per_tensor_default_57" -> "1374 linear_58" [label="(4, 64, 384)", style=solid]; +"1370 linear_58_scale_0" -> "1373 dequantize_per_channel_default_59" [label="(1152,)", style=solid]; +"1371 linear_58_zero_point_0" -> "1373 dequantize_per_channel_default_59" [label="(1152,)", style=solid]; +"1372 _frozen_param59" -> "1373 dequantize_per_channel_default_59" [label="(1152, 384)", style=solid]; +"1373 dequantize_per_channel_default_59" -> "1374 linear_58" [label="(1152, 384)", style=solid]; +"1374 linear_58" -> "1375 reshape_41" [label="(4, 64, 1152)", style=solid]; +"1375 reshape_41" -> "1376 permute_43" [label="(4, 64, 3, 12, 32)", style=solid]; +"1376 permute_43" -> "1377 select_27" [label="(3, 4, 12, 64, 32)", style=solid]; +"1376 permute_43" -> "1378 select_28" [label="(3, 4, 12, 64, 32)", style=solid]; +"1376 permute_43" -> "1379 select_29" [label="(3, 4, 12, 64, 32)", style=solid]; +"1377 select_27" -> "1380 linalg_vector_norm_18" [label="(4, 12, 64, 32)", style=solid]; +"1377 select_27" -> "1382 expand_as_18" [label="(4, 12, 64, 32)", style=solid]; +"1377 select_27" -> "1383 div_18" [label="(4, 12, 64, 32)", style=solid]; +"1378 select_28" -> "1386 linalg_vector_norm_19" [label="(4, 12, 64, 32)", style=solid]; +"1378 select_28" -> "1388 expand_as_19" [label="(4, 12, 64, 32)", style=solid]; +"1378 select_28" -> "1389 div_19" [label="(4, 12, 64, 32)", style=solid]; +"1379 select_29" -> "1416 matmul_19" [label="(4, 12, 64, 32)", style=solid]; +"1380 linalg_vector_norm_18" -> "1381 clamp_min_18" [label="(4, 12, 64, 1)", style=solid]; +"1381 clamp_min_18" -> "1382 expand_as_18" [label="(4, 12, 64, 1)", style=solid]; +"1382 expand_as_18" -> "1383 div_18" [label="(4, 12, 64, 32)", style=solid]; +"1383 div_18" -> "1384 quantize_per_tensor_default_58" [label="(4, 12, 64, 32)", style=solid]; +"1384 quantize_per_tensor_default_58" -> "1385 dequantize_per_tensor_default_58" [label="(4, 12, 64, 32)", style=solid]; +"1385 dequantize_per_tensor_default_58" -> "1393 matmul_18" [label="(4, 12, 64, 32)", style=solid]; +"1386 linalg_vector_norm_19" -> "1387 clamp_min_19" [label="(4, 12, 64, 1)", style=solid]; +"1387 clamp_min_19" -> "1388 expand_as_19" [label="(4, 12, 64, 1)", style=solid]; +"1388 expand_as_19" -> "1389 div_19" [label="(4, 12, 64, 32)", style=solid]; +"1389 div_19" -> "1390 quantize_per_tensor_default_59" [label="(4, 12, 64, 32)", style=solid]; +"1390 quantize_per_tensor_default_59" -> "1391 dequantize_per_tensor_default_59" [label="(4, 12, 64, 32)", style=solid]; +"1391 dequantize_per_tensor_default_59" -> "1392 transpose_18" [label="(4, 12, 64, 32)", style=solid]; +"1392 transpose_18" -> "1393 matmul_18" [label="(4, 12, 32, 64)", style=solid]; +"1393 matmul_18" -> "1396 mul_19" [label="(4, 12, 64, 64)", style=solid]; +"1394 clamp_9" -> "1395 exp_9" [label="(12, 1, 1)", style=solid]; +"1395 exp_9" -> "1396 mul_19" [label="(12, 1, 1)", style=solid]; +"1396 mul_19" -> "1397 add_31" [label="(4, 12, 64, 64)", style=solid]; +"1397 add_31" -> "1409 view_52" [label="(4, 12, 64, 64)", style=solid]; +"1398 new_zeros_4" -> "1399 view_51" [label="(16, 16)", style=solid]; +"1399 view_51" -> "1400 permute_44" [label="(2, 8, 2, 8)", style=solid]; +"1400 permute_44" -> "1401 reshape_42" [label="(2, 2, 8, 8)", style=solid]; +"1401 reshape_42" -> "1402 unsqueeze_26" [label="(4, 64)", style=solid]; +"1401 reshape_42" -> "1403 unsqueeze_27" [label="(4, 64)", style=solid]; +"1402 unsqueeze_26" -> "1404 sub_4" [label="(4, 1, 64)", style=solid]; +"1403 unsqueeze_27" -> "1404 sub_4" [label="(4, 64, 1)", style=solid]; +"1404 sub_4" -> "1405 ne_4" [label="(4, 64, 64)", style=solid]; +"1404 sub_4" -> "1406 masked_fill_8" [label="(4, 64, 64)", style=solid]; +"1404 sub_4" -> "1407 eq_4" [label="(4, 64, 64)", style=solid]; +"1405 ne_4" -> "1406 masked_fill_8" [label="(4, 64, 64)", style=solid]; +"1406 masked_fill_8" -> "1408 masked_fill_9" [label="(4, 64, 64)", style=solid]; +"1407 eq_4" -> "1408 masked_fill_9" [label="(4, 64, 64)", style=solid]; +"1408 masked_fill_9" -> "1410 unsqueeze_28" [label="(4, 64, 64)", style=solid]; +"1409 view_52" -> "1412 add_32" [label="(1, 4, 12, 64, 64)", style=solid]; +"1410 unsqueeze_28" -> "1411 unsqueeze_29" [label="(4, 1, 64, 64)", style=solid]; +"1411 unsqueeze_29" -> "1412 add_32" [label="(1, 4, 1, 64, 64)", style=solid]; +"1412 add_32" -> "1413 view_53" [label="(1, 4, 12, 64, 64)", style=solid]; +"1413 view_53" -> "1414 softmax_9" [label="(4, 12, 64, 64)", style=solid]; +"1414 softmax_9" -> "1415 dropout_36" [label="(4, 12, 64, 64)", style=solid]; +"1415 dropout_36" -> "1416 matmul_19" [label="(4, 12, 64, 64)", style=solid]; +"1416 matmul_19" -> "1417 transpose_19" [label="(4, 12, 64, 32)", style=solid]; +"1417 transpose_19" -> "1418 reshape_43" [label="(4, 64, 12, 32)", style=solid]; +"1418 reshape_43" -> "1419 reshape_43_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"1419 reshape_43_0_0_nncf_smooth_quant_0" -> "1420 quantize_per_tensor_default_60" [label="(4, 64, 384)", style=solid]; +"1420 quantize_per_tensor_default_60" -> "1421 dequantize_per_tensor_default_60" [label="(4, 64, 384)", style=solid]; +"1421 dequantize_per_tensor_default_60" -> "1426 linear_59" [label="(4, 64, 384)", style=solid]; +"1422 linear_59_scale_0" -> "1425 dequantize_per_channel_default_60" [label="(384,)", style=solid]; +"1423 linear_59_zero_point_0" -> "1425 dequantize_per_channel_default_60" [label="(384,)", style=solid]; +"1424 _frozen_param60" -> "1425 dequantize_per_channel_default_60" [label="(384, 384)", style=solid]; +"1425 dequantize_per_channel_default_60" -> "1426 linear_59" [label="(384, 384)", style=solid]; +"1426 linear_59" -> "1427 dropout_37" [label="(4, 64, 384)", style=solid]; +"1427 dropout_37" -> "1428 view_54" [label="(4, 64, 384)", style=solid]; +"1428 view_54" -> "1429 permute_45" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"1429 permute_45" -> "1430 reshape_44" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"1430 reshape_44" -> "1431 roll_9" [label="(1, 16, 16, 384)", style=solid]; +"1431 roll_9" -> "1432 slice_157" [label="(1, 16, 16, 384)", style=solid]; +"1432 slice_157" -> "1433 slice_158" [label="(1, 16, 16, 384)", style=solid]; +"1433 slice_158" -> "1434 slice_159" [label="(1, 14, 16, 384)", style=solid]; +"1434 slice_159" -> "1435 slice_160" [label="(1, 14, 14, 384)", style=solid]; +"1435 slice_160" -> "1436 contiguous_17" [label="(1, 14, 14, 384)", style=solid]; +"1436 contiguous_17" -> "1437 layer_norm_21" [label="(1, 14, 14, 384)", style=solid]; +"1437 layer_norm_21" -> "1438 add_33" [label="(1, 14, 14, 384)", style=solid]; +"1438 add_33" -> "1439 add_33_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 384)", style=solid]; +"1438 add_33" -> "1459 add_34" [label="(1, 14, 14, 384)", style=solid]; +"1439 add_33_0_0_nncf_smooth_quant_0" -> "1440 quantize_per_tensor_default_61" [label="(1, 14, 14, 384)", style=solid]; +"1440 quantize_per_tensor_default_61" -> "1441 dequantize_per_tensor_default_61" [label="(1, 14, 14, 384)", style=solid]; +"1441 dequantize_per_tensor_default_61" -> "1446 linear_60" [label="(1, 14, 14, 384)", style=solid]; +"1442 linear_60_scale_0" -> "1445 dequantize_per_channel_default_61" [label="(1536,)", style=solid]; +"1443 linear_60_zero_point_0" -> "1445 dequantize_per_channel_default_61" [label="(1536,)", style=solid]; +"1444 _frozen_param61" -> "1445 dequantize_per_channel_default_61" [label="(1536, 384)", style=solid]; +"1445 dequantize_per_channel_default_61" -> "1446 linear_60" [label="(1536, 384)", style=solid]; +"1446 linear_60" -> "1447 gelu_9" [label="(1, 14, 14, 1536)", style=solid]; +"1447 gelu_9" -> "1448 dropout_38" [label="(1, 14, 14, 1536)", style=solid]; +"1448 dropout_38" -> "1449 dropout_38_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 1536)", style=solid]; +"1449 dropout_38_0_0_nncf_smooth_quant_0" -> "1450 quantize_per_tensor_default_62" [label="(1, 14, 14, 1536)", style=solid]; +"1450 quantize_per_tensor_default_62" -> "1451 dequantize_per_tensor_default_62" [label="(1, 14, 14, 1536)", style=solid]; +"1451 dequantize_per_tensor_default_62" -> "1456 linear_61" [label="(1, 14, 14, 1536)", style=solid]; +"1452 linear_61_scale_0" -> "1455 dequantize_per_channel_default_62" [label="(384,)", style=solid]; +"1453 linear_61_zero_point_0" -> "1455 dequantize_per_channel_default_62" [label="(384,)", style=solid]; +"1454 _frozen_param62" -> "1455 dequantize_per_channel_default_62" [label="(384, 1536)", style=solid]; +"1455 dequantize_per_channel_default_62" -> "1456 linear_61" [label="(384, 1536)", style=solid]; +"1456 linear_61" -> "1457 dropout_39" [label="(1, 14, 14, 384)", style=solid]; +"1457 dropout_39" -> "1458 layer_norm_22" [label="(1, 14, 14, 384)", style=solid]; +"1458 layer_norm_22" -> "1459 add_34" [label="(1, 14, 14, 384)", style=solid]; +"1459 add_34" -> "1481 pad_12" [label="(1, 14, 14, 384)", style=solid]; +"1459 add_34" -> "1540 add_36" [label="(1, 14, 14, 384)", style=solid]; +"1460 features_5_6_attn_relative_coords_table_0_0_nncf_smooth_quant_0" -> "1465 linear_62" [label="(1, 15, 15, 2)", style=solid]; +"1461 linear_62_scale_0" -> "1464 dequantize_per_channel_default_63" [label="(512,)", style=solid]; +"1462 linear_62_zero_point_0" -> "1464 dequantize_per_channel_default_63" [label="(512,)", style=solid]; +"1463 _frozen_param63" -> "1464 dequantize_per_channel_default_63" [label="(512, 2)", style=solid]; +"1464 dequantize_per_channel_default_63" -> "1465 linear_62" [label="(512, 2)", style=solid]; +"1465 linear_62" -> "1466 relu__10" [label="(1, 15, 15, 512)", style=solid]; +"1466 relu__10" -> "1467 relu__10_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 512)", style=solid]; +"1467 relu__10_0_0_nncf_smooth_quant_0" -> "1472 linear_63" [label="(1, 15, 15, 512)", style=solid]; +"1468 linear_63_scale_0" -> "1471 dequantize_per_channel_default_64" [label="(12,)", style=solid]; +"1469 linear_63_zero_point_0" -> "1471 dequantize_per_channel_default_64" [label="(12,)", style=solid]; +"1470 _frozen_param64" -> "1471 dequantize_per_channel_default_64" [label="(12, 512)", style=solid]; +"1471 dequantize_per_channel_default_64" -> "1472 linear_63" [label="(12, 512)", style=solid]; +"1472 linear_63" -> "1473 view_55" [label="(1, 15, 15, 12)", style=solid]; +"1473 view_55" -> "1474 index_10" [label="(225, 12)", style=solid]; +"1474 index_10" -> "1475 view_56" [label="(4096, 12)", style=solid]; +"1475 view_56" -> "1476 permute_46" [label="(64, 64, 12)", style=solid]; +"1476 permute_46" -> "1477 contiguous_18" [label="(12, 64, 64)", style=solid]; +"1477 contiguous_18" -> "1478 unsqueeze_30" [label="(12, 64, 64)", style=solid]; +"1478 unsqueeze_30" -> "1479 sigmoid_10" [label="(1, 12, 64, 64)", style=solid]; +"1479 sigmoid_10" -> "1480 mul_20" [label="(1, 12, 64, 64)", style=solid]; +"1480 mul_20" -> "1516 add_35" [label="(1, 12, 64, 64)", style=solid]; +"1481 pad_12" -> "1482 view_57" [label="(1, 16, 16, 384)", style=solid]; +"1482 view_57" -> "1483 permute_47" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"1483 permute_47" -> "1484 reshape_45" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"1484 reshape_45" -> "1486 reshape_45_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"1485 clone_10" -> "1493 linear_64" [label="(1152,)", style=solid]; +"1486 reshape_45_0_0_nncf_smooth_quant_0" -> "1487 quantize_per_tensor_default_63" [label="(4, 64, 384)", style=solid]; +"1487 quantize_per_tensor_default_63" -> "1488 dequantize_per_tensor_default_63" [label="(4, 64, 384)", style=solid]; +"1488 dequantize_per_tensor_default_63" -> "1493 linear_64" [label="(4, 64, 384)", style=solid]; +"1489 linear_64_scale_0" -> "1492 dequantize_per_channel_default_65" [label="(1152,)", style=solid]; +"1490 linear_64_zero_point_0" -> "1492 dequantize_per_channel_default_65" [label="(1152,)", style=solid]; +"1491 _frozen_param65" -> "1492 dequantize_per_channel_default_65" [label="(1152, 384)", style=solid]; +"1492 dequantize_per_channel_default_65" -> "1493 linear_64" [label="(1152, 384)", style=solid]; +"1493 linear_64" -> "1494 reshape_46" [label="(4, 64, 1152)", style=solid]; +"1494 reshape_46" -> "1495 permute_48" [label="(4, 64, 3, 12, 32)", style=solid]; +"1495 permute_48" -> "1496 select_30" [label="(3, 4, 12, 64, 32)", style=solid]; +"1495 permute_48" -> "1497 select_31" [label="(3, 4, 12, 64, 32)", style=solid]; +"1495 permute_48" -> "1498 select_32" [label="(3, 4, 12, 64, 32)", style=solid]; +"1496 select_30" -> "1499 linalg_vector_norm_20" [label="(4, 12, 64, 32)", style=solid]; +"1496 select_30" -> "1501 expand_as_20" [label="(4, 12, 64, 32)", style=solid]; +"1496 select_30" -> "1502 div_20" [label="(4, 12, 64, 32)", style=solid]; +"1497 select_31" -> "1505 linalg_vector_norm_21" [label="(4, 12, 64, 32)", style=solid]; +"1497 select_31" -> "1507 expand_as_21" [label="(4, 12, 64, 32)", style=solid]; +"1497 select_31" -> "1508 div_21" [label="(4, 12, 64, 32)", style=solid]; +"1498 select_32" -> "1519 matmul_21" [label="(4, 12, 64, 32)", style=solid]; +"1499 linalg_vector_norm_20" -> "1500 clamp_min_20" [label="(4, 12, 64, 1)", style=solid]; +"1500 clamp_min_20" -> "1501 expand_as_20" [label="(4, 12, 64, 1)", style=solid]; +"1501 expand_as_20" -> "1502 div_20" [label="(4, 12, 64, 32)", style=solid]; +"1502 div_20" -> "1503 quantize_per_tensor_default_64" [label="(4, 12, 64, 32)", style=solid]; +"1503 quantize_per_tensor_default_64" -> "1504 dequantize_per_tensor_default_64" [label="(4, 12, 64, 32)", style=solid]; +"1504 dequantize_per_tensor_default_64" -> "1512 matmul_20" [label="(4, 12, 64, 32)", style=solid]; +"1505 linalg_vector_norm_21" -> "1506 clamp_min_21" [label="(4, 12, 64, 1)", style=solid]; +"1506 clamp_min_21" -> "1507 expand_as_21" [label="(4, 12, 64, 1)", style=solid]; +"1507 expand_as_21" -> "1508 div_21" [label="(4, 12, 64, 32)", style=solid]; +"1508 div_21" -> "1509 quantize_per_tensor_default_65" [label="(4, 12, 64, 32)", style=solid]; +"1509 quantize_per_tensor_default_65" -> "1510 dequantize_per_tensor_default_65" [label="(4, 12, 64, 32)", style=solid]; +"1510 dequantize_per_tensor_default_65" -> "1511 transpose_20" [label="(4, 12, 64, 32)", style=solid]; +"1511 transpose_20" -> "1512 matmul_20" [label="(4, 12, 32, 64)", style=solid]; +"1512 matmul_20" -> "1515 mul_21" [label="(4, 12, 64, 64)", style=solid]; +"1513 clamp_10" -> "1514 exp_10" [label="(12, 1, 1)", style=solid]; +"1514 exp_10" -> "1515 mul_21" [label="(12, 1, 1)", style=solid]; +"1515 mul_21" -> "1516 add_35" [label="(4, 12, 64, 64)", style=solid]; +"1516 add_35" -> "1517 softmax_10" [label="(4, 12, 64, 64)", style=solid]; +"1517 softmax_10" -> "1518 dropout_40" [label="(4, 12, 64, 64)", style=solid]; +"1518 dropout_40" -> "1519 matmul_21" [label="(4, 12, 64, 64)", style=solid]; +"1519 matmul_21" -> "1520 transpose_21" [label="(4, 12, 64, 32)", style=solid]; +"1520 transpose_21" -> "1521 reshape_47" [label="(4, 64, 12, 32)", style=solid]; +"1521 reshape_47" -> "1522 reshape_47_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"1522 reshape_47_0_0_nncf_smooth_quant_0" -> "1523 quantize_per_tensor_default_66" [label="(4, 64, 384)", style=solid]; +"1523 quantize_per_tensor_default_66" -> "1524 dequantize_per_tensor_default_66" [label="(4, 64, 384)", style=solid]; +"1524 dequantize_per_tensor_default_66" -> "1529 linear_65" [label="(4, 64, 384)", style=solid]; +"1525 linear_65_scale_0" -> "1528 dequantize_per_channel_default_66" [label="(384,)", style=solid]; +"1526 linear_65_zero_point_0" -> "1528 dequantize_per_channel_default_66" [label="(384,)", style=solid]; +"1527 _frozen_param66" -> "1528 dequantize_per_channel_default_66" [label="(384, 384)", style=solid]; +"1528 dequantize_per_channel_default_66" -> "1529 linear_65" [label="(384, 384)", style=solid]; +"1529 linear_65" -> "1530 dropout_41" [label="(4, 64, 384)", style=solid]; +"1530 dropout_41" -> "1531 view_58" [label="(4, 64, 384)", style=solid]; +"1531 view_58" -> "1532 permute_49" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"1532 permute_49" -> "1533 reshape_48" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"1533 reshape_48" -> "1534 slice_162" [label="(1, 16, 16, 384)", style=solid]; +"1534 slice_162" -> "1535 slice_163" [label="(1, 16, 16, 384)", style=solid]; +"1535 slice_163" -> "1536 slice_164" [label="(1, 14, 16, 384)", style=solid]; +"1536 slice_164" -> "1537 slice_165" [label="(1, 14, 14, 384)", style=solid]; +"1537 slice_165" -> "1538 contiguous_19" [label="(1, 14, 14, 384)", style=solid]; +"1538 contiguous_19" -> "1539 layer_norm_23" [label="(1, 14, 14, 384)", style=solid]; +"1539 layer_norm_23" -> "1540 add_36" [label="(1, 14, 14, 384)", style=solid]; +"1540 add_36" -> "1541 add_36_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 384)", style=solid]; +"1540 add_36" -> "1561 add_37" [label="(1, 14, 14, 384)", style=solid]; +"1541 add_36_0_0_nncf_smooth_quant_0" -> "1542 quantize_per_tensor_default_67" [label="(1, 14, 14, 384)", style=solid]; +"1542 quantize_per_tensor_default_67" -> "1543 dequantize_per_tensor_default_67" [label="(1, 14, 14, 384)", style=solid]; +"1543 dequantize_per_tensor_default_67" -> "1548 linear_66" [label="(1, 14, 14, 384)", style=solid]; +"1544 linear_66_scale_0" -> "1547 dequantize_per_channel_default_67" [label="(1536,)", style=solid]; +"1545 linear_66_zero_point_0" -> "1547 dequantize_per_channel_default_67" [label="(1536,)", style=solid]; +"1546 _frozen_param67" -> "1547 dequantize_per_channel_default_67" [label="(1536, 384)", style=solid]; +"1547 dequantize_per_channel_default_67" -> "1548 linear_66" [label="(1536, 384)", style=solid]; +"1548 linear_66" -> "1549 gelu_10" [label="(1, 14, 14, 1536)", style=solid]; +"1549 gelu_10" -> "1550 dropout_42" [label="(1, 14, 14, 1536)", style=solid]; +"1550 dropout_42" -> "1551 dropout_42_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 1536)", style=solid]; +"1551 dropout_42_0_0_nncf_smooth_quant_0" -> "1552 quantize_per_tensor_default_68" [label="(1, 14, 14, 1536)", style=solid]; +"1552 quantize_per_tensor_default_68" -> "1553 dequantize_per_tensor_default_68" [label="(1, 14, 14, 1536)", style=solid]; +"1553 dequantize_per_tensor_default_68" -> "1558 linear_67" [label="(1, 14, 14, 1536)", style=solid]; +"1554 linear_67_scale_0" -> "1557 dequantize_per_channel_default_68" [label="(384,)", style=solid]; +"1555 linear_67_zero_point_0" -> "1557 dequantize_per_channel_default_68" [label="(384,)", style=solid]; +"1556 _frozen_param68" -> "1557 dequantize_per_channel_default_68" [label="(384, 1536)", style=solid]; +"1557 dequantize_per_channel_default_68" -> "1558 linear_67" [label="(384, 1536)", style=solid]; +"1558 linear_67" -> "1559 dropout_43" [label="(1, 14, 14, 384)", style=solid]; +"1559 dropout_43" -> "1560 layer_norm_24" [label="(1, 14, 14, 384)", style=solid]; +"1560 layer_norm_24" -> "1561 add_37" [label="(1, 14, 14, 384)", style=solid]; +"1561 add_37" -> "1583 pad_13" [label="(1, 14, 14, 384)", style=solid]; +"1561 add_37" -> "1660 add_40" [label="(1, 14, 14, 384)", style=solid]; +"1562 features_5_7_attn_relative_coords_table_0_0_nncf_smooth_quant_0" -> "1567 linear_68" [label="(1, 15, 15, 2)", style=solid]; +"1563 linear_68_scale_0" -> "1566 dequantize_per_channel_default_69" [label="(512,)", style=solid]; +"1564 linear_68_zero_point_0" -> "1566 dequantize_per_channel_default_69" [label="(512,)", style=solid]; +"1565 _frozen_param69" -> "1566 dequantize_per_channel_default_69" [label="(512, 2)", style=solid]; +"1566 dequantize_per_channel_default_69" -> "1567 linear_68" [label="(512, 2)", style=solid]; +"1567 linear_68" -> "1568 relu__11" [label="(1, 15, 15, 512)", style=solid]; +"1568 relu__11" -> "1569 relu__11_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 512)", style=solid]; +"1569 relu__11_0_0_nncf_smooth_quant_0" -> "1574 linear_69" [label="(1, 15, 15, 512)", style=solid]; +"1570 linear_69_scale_0" -> "1573 dequantize_per_channel_default_70" [label="(12,)", style=solid]; +"1571 linear_69_zero_point_0" -> "1573 dequantize_per_channel_default_70" [label="(12,)", style=solid]; +"1572 _frozen_param70" -> "1573 dequantize_per_channel_default_70" [label="(12, 512)", style=solid]; +"1573 dequantize_per_channel_default_70" -> "1574 linear_69" [label="(12, 512)", style=solid]; +"1574 linear_69" -> "1575 view_59" [label="(1, 15, 15, 12)", style=solid]; +"1575 view_59" -> "1576 index_11" [label="(225, 12)", style=solid]; +"1576 index_11" -> "1577 view_60" [label="(4096, 12)", style=solid]; +"1577 view_60" -> "1578 permute_50" [label="(64, 64, 12)", style=solid]; +"1578 permute_50" -> "1579 contiguous_20" [label="(12, 64, 64)", style=solid]; +"1579 contiguous_20" -> "1580 unsqueeze_31" [label="(12, 64, 64)", style=solid]; +"1580 unsqueeze_31" -> "1581 sigmoid_11" [label="(1, 12, 64, 64)", style=solid]; +"1581 sigmoid_11" -> "1582 mul_22" [label="(1, 12, 64, 64)", style=solid]; +"1582 mul_22" -> "1619 add_38" [label="(1, 12, 64, 64)", style=solid]; +"1583 pad_13" -> "1584 roll_10" [label="(1, 16, 16, 384)", style=solid]; +"1584 roll_10" -> "1585 view_61" [label="(1, 16, 16, 384)", style=solid]; +"1585 view_61" -> "1586 permute_51" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"1586 permute_51" -> "1587 reshape_49" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"1587 reshape_49" -> "1589 reshape_49_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"1587 reshape_49" -> "1620 new_zeros_5" [label="(4, 64, 384)", style=solid]; +"1588 clone_11" -> "1596 linear_70" [label="(1152,)", style=solid]; +"1589 reshape_49_0_0_nncf_smooth_quant_0" -> "1590 quantize_per_tensor_default_69" [label="(4, 64, 384)", style=solid]; +"1590 quantize_per_tensor_default_69" -> "1591 dequantize_per_tensor_default_69" [label="(4, 64, 384)", style=solid]; +"1591 dequantize_per_tensor_default_69" -> "1596 linear_70" [label="(4, 64, 384)", style=solid]; +"1592 linear_70_scale_0" -> "1595 dequantize_per_channel_default_71" [label="(1152,)", style=solid]; +"1593 linear_70_zero_point_0" -> "1595 dequantize_per_channel_default_71" [label="(1152,)", style=solid]; +"1594 _frozen_param71" -> "1595 dequantize_per_channel_default_71" [label="(1152, 384)", style=solid]; +"1595 dequantize_per_channel_default_71" -> "1596 linear_70" [label="(1152, 384)", style=solid]; +"1596 linear_70" -> "1597 reshape_50" [label="(4, 64, 1152)", style=solid]; +"1597 reshape_50" -> "1598 permute_52" [label="(4, 64, 3, 12, 32)", style=solid]; +"1598 permute_52" -> "1599 select_33" [label="(3, 4, 12, 64, 32)", style=solid]; +"1598 permute_52" -> "1600 select_34" [label="(3, 4, 12, 64, 32)", style=solid]; +"1598 permute_52" -> "1601 select_35" [label="(3, 4, 12, 64, 32)", style=solid]; +"1599 select_33" -> "1602 linalg_vector_norm_22" [label="(4, 12, 64, 32)", style=solid]; +"1599 select_33" -> "1604 expand_as_22" [label="(4, 12, 64, 32)", style=solid]; +"1599 select_33" -> "1605 div_22" [label="(4, 12, 64, 32)", style=solid]; +"1600 select_34" -> "1608 linalg_vector_norm_23" [label="(4, 12, 64, 32)", style=solid]; +"1600 select_34" -> "1610 expand_as_23" [label="(4, 12, 64, 32)", style=solid]; +"1600 select_34" -> "1611 div_23" [label="(4, 12, 64, 32)", style=solid]; +"1601 select_35" -> "1638 matmul_23" [label="(4, 12, 64, 32)", style=solid]; +"1602 linalg_vector_norm_22" -> "1603 clamp_min_22" [label="(4, 12, 64, 1)", style=solid]; +"1603 clamp_min_22" -> "1604 expand_as_22" [label="(4, 12, 64, 1)", style=solid]; +"1604 expand_as_22" -> "1605 div_22" [label="(4, 12, 64, 32)", style=solid]; +"1605 div_22" -> "1606 quantize_per_tensor_default_70" [label="(4, 12, 64, 32)", style=solid]; +"1606 quantize_per_tensor_default_70" -> "1607 dequantize_per_tensor_default_70" [label="(4, 12, 64, 32)", style=solid]; +"1607 dequantize_per_tensor_default_70" -> "1615 matmul_22" [label="(4, 12, 64, 32)", style=solid]; +"1608 linalg_vector_norm_23" -> "1609 clamp_min_23" [label="(4, 12, 64, 1)", style=solid]; +"1609 clamp_min_23" -> "1610 expand_as_23" [label="(4, 12, 64, 1)", style=solid]; +"1610 expand_as_23" -> "1611 div_23" [label="(4, 12, 64, 32)", style=solid]; +"1611 div_23" -> "1612 quantize_per_tensor_default_71" [label="(4, 12, 64, 32)", style=solid]; +"1612 quantize_per_tensor_default_71" -> "1613 dequantize_per_tensor_default_71" [label="(4, 12, 64, 32)", style=solid]; +"1613 dequantize_per_tensor_default_71" -> "1614 transpose_22" [label="(4, 12, 64, 32)", style=solid]; +"1614 transpose_22" -> "1615 matmul_22" [label="(4, 12, 32, 64)", style=solid]; +"1615 matmul_22" -> "1618 mul_23" [label="(4, 12, 64, 64)", style=solid]; +"1616 clamp_11" -> "1617 exp_11" [label="(12, 1, 1)", style=solid]; +"1617 exp_11" -> "1618 mul_23" [label="(12, 1, 1)", style=solid]; +"1618 mul_23" -> "1619 add_38" [label="(4, 12, 64, 64)", style=solid]; +"1619 add_38" -> "1631 view_63" [label="(4, 12, 64, 64)", style=solid]; +"1620 new_zeros_5" -> "1621 view_62" [label="(16, 16)", style=solid]; +"1621 view_62" -> "1622 permute_53" [label="(2, 8, 2, 8)", style=solid]; +"1622 permute_53" -> "1623 reshape_51" [label="(2, 2, 8, 8)", style=solid]; +"1623 reshape_51" -> "1624 unsqueeze_32" [label="(4, 64)", style=solid]; +"1623 reshape_51" -> "1625 unsqueeze_33" [label="(4, 64)", style=solid]; +"1624 unsqueeze_32" -> "1626 sub_5" [label="(4, 1, 64)", style=solid]; +"1625 unsqueeze_33" -> "1626 sub_5" [label="(4, 64, 1)", style=solid]; +"1626 sub_5" -> "1627 ne_5" [label="(4, 64, 64)", style=solid]; +"1626 sub_5" -> "1628 masked_fill_10" [label="(4, 64, 64)", style=solid]; +"1626 sub_5" -> "1629 eq_5" [label="(4, 64, 64)", style=solid]; +"1627 ne_5" -> "1628 masked_fill_10" [label="(4, 64, 64)", style=solid]; +"1628 masked_fill_10" -> "1630 masked_fill_11" [label="(4, 64, 64)", style=solid]; +"1629 eq_5" -> "1630 masked_fill_11" [label="(4, 64, 64)", style=solid]; +"1630 masked_fill_11" -> "1632 unsqueeze_34" [label="(4, 64, 64)", style=solid]; +"1631 view_63" -> "1634 add_39" [label="(1, 4, 12, 64, 64)", style=solid]; +"1632 unsqueeze_34" -> "1633 unsqueeze_35" [label="(4, 1, 64, 64)", style=solid]; +"1633 unsqueeze_35" -> "1634 add_39" [label="(1, 4, 1, 64, 64)", style=solid]; +"1634 add_39" -> "1635 view_64" [label="(1, 4, 12, 64, 64)", style=solid]; +"1635 view_64" -> "1636 softmax_11" [label="(4, 12, 64, 64)", style=solid]; +"1636 softmax_11" -> "1637 dropout_44" [label="(4, 12, 64, 64)", style=solid]; +"1637 dropout_44" -> "1638 matmul_23" [label="(4, 12, 64, 64)", style=solid]; +"1638 matmul_23" -> "1639 transpose_23" [label="(4, 12, 64, 32)", style=solid]; +"1639 transpose_23" -> "1640 reshape_52" [label="(4, 64, 12, 32)", style=solid]; +"1640 reshape_52" -> "1641 reshape_52_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"1641 reshape_52_0_0_nncf_smooth_quant_0" -> "1642 quantize_per_tensor_default_72" [label="(4, 64, 384)", style=solid]; +"1642 quantize_per_tensor_default_72" -> "1643 dequantize_per_tensor_default_72" [label="(4, 64, 384)", style=solid]; +"1643 dequantize_per_tensor_default_72" -> "1648 linear_71" [label="(4, 64, 384)", style=solid]; +"1644 linear_71_scale_0" -> "1647 dequantize_per_channel_default_72" [label="(384,)", style=solid]; +"1645 linear_71_zero_point_0" -> "1647 dequantize_per_channel_default_72" [label="(384,)", style=solid]; +"1646 _frozen_param72" -> "1647 dequantize_per_channel_default_72" [label="(384, 384)", style=solid]; +"1647 dequantize_per_channel_default_72" -> "1648 linear_71" [label="(384, 384)", style=solid]; +"1648 linear_71" -> "1649 dropout_45" [label="(4, 64, 384)", style=solid]; +"1649 dropout_45" -> "1650 view_65" [label="(4, 64, 384)", style=solid]; +"1650 view_65" -> "1651 permute_54" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"1651 permute_54" -> "1652 reshape_53" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"1652 reshape_53" -> "1653 roll_11" [label="(1, 16, 16, 384)", style=solid]; +"1653 roll_11" -> "1654 slice_185" [label="(1, 16, 16, 384)", style=solid]; +"1654 slice_185" -> "1655 slice_186" [label="(1, 16, 16, 384)", style=solid]; +"1655 slice_186" -> "1656 slice_187" [label="(1, 14, 16, 384)", style=solid]; +"1656 slice_187" -> "1657 slice_188" [label="(1, 14, 14, 384)", style=solid]; +"1657 slice_188" -> "1658 contiguous_21" [label="(1, 14, 14, 384)", style=solid]; +"1658 contiguous_21" -> "1659 layer_norm_25" [label="(1, 14, 14, 384)", style=solid]; +"1659 layer_norm_25" -> "1660 add_40" [label="(1, 14, 14, 384)", style=solid]; +"1660 add_40" -> "1661 add_40_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 384)", style=solid]; +"1660 add_40" -> "1681 add_41" [label="(1, 14, 14, 384)", style=solid]; +"1661 add_40_0_0_nncf_smooth_quant_0" -> "1662 quantize_per_tensor_default_73" [label="(1, 14, 14, 384)", style=solid]; +"1662 quantize_per_tensor_default_73" -> "1663 dequantize_per_tensor_default_73" [label="(1, 14, 14, 384)", style=solid]; +"1663 dequantize_per_tensor_default_73" -> "1668 linear_72" [label="(1, 14, 14, 384)", style=solid]; +"1664 linear_72_scale_0" -> "1667 dequantize_per_channel_default_73" [label="(1536,)", style=solid]; +"1665 linear_72_zero_point_0" -> "1667 dequantize_per_channel_default_73" [label="(1536,)", style=solid]; +"1666 _frozen_param73" -> "1667 dequantize_per_channel_default_73" [label="(1536, 384)", style=solid]; +"1667 dequantize_per_channel_default_73" -> "1668 linear_72" [label="(1536, 384)", style=solid]; +"1668 linear_72" -> "1669 gelu_11" [label="(1, 14, 14, 1536)", style=solid]; +"1669 gelu_11" -> "1670 dropout_46" [label="(1, 14, 14, 1536)", style=solid]; +"1670 dropout_46" -> "1671 dropout_46_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 1536)", style=solid]; +"1671 dropout_46_0_0_nncf_smooth_quant_0" -> "1672 quantize_per_tensor_default_74" [label="(1, 14, 14, 1536)", style=solid]; +"1672 quantize_per_tensor_default_74" -> "1673 dequantize_per_tensor_default_74" [label="(1, 14, 14, 1536)", style=solid]; +"1673 dequantize_per_tensor_default_74" -> "1678 linear_73" [label="(1, 14, 14, 1536)", style=solid]; +"1674 linear_73_scale_0" -> "1677 dequantize_per_channel_default_74" [label="(384,)", style=solid]; +"1675 linear_73_zero_point_0" -> "1677 dequantize_per_channel_default_74" [label="(384,)", style=solid]; +"1676 _frozen_param74" -> "1677 dequantize_per_channel_default_74" [label="(384, 1536)", style=solid]; +"1677 dequantize_per_channel_default_74" -> "1678 linear_73" [label="(384, 1536)", style=solid]; +"1678 linear_73" -> "1679 dropout_47" [label="(1, 14, 14, 384)", style=solid]; +"1679 dropout_47" -> "1680 layer_norm_26" [label="(1, 14, 14, 384)", style=solid]; +"1680 layer_norm_26" -> "1681 add_41" [label="(1, 14, 14, 384)", style=solid]; +"1681 add_41" -> "1703 pad_14" [label="(1, 14, 14, 384)", style=solid]; +"1681 add_41" -> "1762 add_43" [label="(1, 14, 14, 384)", style=solid]; +"1682 features_5_8_attn_relative_coords_table_0_0_nncf_smooth_quant_0" -> "1687 linear_74" [label="(1, 15, 15, 2)", style=solid]; +"1683 linear_74_scale_0" -> "1686 dequantize_per_channel_default_75" [label="(512,)", style=solid]; +"1684 linear_74_zero_point_0" -> "1686 dequantize_per_channel_default_75" [label="(512,)", style=solid]; +"1685 _frozen_param75" -> "1686 dequantize_per_channel_default_75" [label="(512, 2)", style=solid]; +"1686 dequantize_per_channel_default_75" -> "1687 linear_74" [label="(512, 2)", style=solid]; +"1687 linear_74" -> "1688 relu__12" [label="(1, 15, 15, 512)", style=solid]; +"1688 relu__12" -> "1689 relu__12_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 512)", style=solid]; +"1689 relu__12_0_0_nncf_smooth_quant_0" -> "1694 linear_75" [label="(1, 15, 15, 512)", style=solid]; +"1690 linear_75_scale_0" -> "1693 dequantize_per_channel_default_76" [label="(12,)", style=solid]; +"1691 linear_75_zero_point_0" -> "1693 dequantize_per_channel_default_76" [label="(12,)", style=solid]; +"1692 _frozen_param76" -> "1693 dequantize_per_channel_default_76" [label="(12, 512)", style=solid]; +"1693 dequantize_per_channel_default_76" -> "1694 linear_75" [label="(12, 512)", style=solid]; +"1694 linear_75" -> "1695 view_66" [label="(1, 15, 15, 12)", style=solid]; +"1695 view_66" -> "1696 index_12" [label="(225, 12)", style=solid]; +"1696 index_12" -> "1697 view_67" [label="(4096, 12)", style=solid]; +"1697 view_67" -> "1698 permute_55" [label="(64, 64, 12)", style=solid]; +"1698 permute_55" -> "1699 contiguous_22" [label="(12, 64, 64)", style=solid]; +"1699 contiguous_22" -> "1700 unsqueeze_36" [label="(12, 64, 64)", style=solid]; +"1700 unsqueeze_36" -> "1701 sigmoid_12" [label="(1, 12, 64, 64)", style=solid]; +"1701 sigmoid_12" -> "1702 mul_24" [label="(1, 12, 64, 64)", style=solid]; +"1702 mul_24" -> "1738 add_42" [label="(1, 12, 64, 64)", style=solid]; +"1703 pad_14" -> "1704 view_68" [label="(1, 16, 16, 384)", style=solid]; +"1704 view_68" -> "1705 permute_56" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"1705 permute_56" -> "1706 reshape_54" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"1706 reshape_54" -> "1708 reshape_54_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"1707 clone_12" -> "1715 linear_76" [label="(1152,)", style=solid]; +"1708 reshape_54_0_0_nncf_smooth_quant_0" -> "1709 quantize_per_tensor_default_75" [label="(4, 64, 384)", style=solid]; +"1709 quantize_per_tensor_default_75" -> "1710 dequantize_per_tensor_default_75" [label="(4, 64, 384)", style=solid]; +"1710 dequantize_per_tensor_default_75" -> "1715 linear_76" [label="(4, 64, 384)", style=solid]; +"1711 linear_76_scale_0" -> "1714 dequantize_per_channel_default_77" [label="(1152,)", style=solid]; +"1712 linear_76_zero_point_0" -> "1714 dequantize_per_channel_default_77" [label="(1152,)", style=solid]; +"1713 _frozen_param77" -> "1714 dequantize_per_channel_default_77" [label="(1152, 384)", style=solid]; +"1714 dequantize_per_channel_default_77" -> "1715 linear_76" [label="(1152, 384)", style=solid]; +"1715 linear_76" -> "1716 reshape_55" [label="(4, 64, 1152)", style=solid]; +"1716 reshape_55" -> "1717 permute_57" [label="(4, 64, 3, 12, 32)", style=solid]; +"1717 permute_57" -> "1718 select_36" [label="(3, 4, 12, 64, 32)", style=solid]; +"1717 permute_57" -> "1719 select_37" [label="(3, 4, 12, 64, 32)", style=solid]; +"1717 permute_57" -> "1720 select_38" [label="(3, 4, 12, 64, 32)", style=solid]; +"1718 select_36" -> "1721 linalg_vector_norm_24" [label="(4, 12, 64, 32)", style=solid]; +"1718 select_36" -> "1723 expand_as_24" [label="(4, 12, 64, 32)", style=solid]; +"1718 select_36" -> "1724 div_24" [label="(4, 12, 64, 32)", style=solid]; +"1719 select_37" -> "1727 linalg_vector_norm_25" [label="(4, 12, 64, 32)", style=solid]; +"1719 select_37" -> "1729 expand_as_25" [label="(4, 12, 64, 32)", style=solid]; +"1719 select_37" -> "1730 div_25" [label="(4, 12, 64, 32)", style=solid]; +"1720 select_38" -> "1741 matmul_25" [label="(4, 12, 64, 32)", style=solid]; +"1721 linalg_vector_norm_24" -> "1722 clamp_min_24" [label="(4, 12, 64, 1)", style=solid]; +"1722 clamp_min_24" -> "1723 expand_as_24" [label="(4, 12, 64, 1)", style=solid]; +"1723 expand_as_24" -> "1724 div_24" [label="(4, 12, 64, 32)", style=solid]; +"1724 div_24" -> "1725 quantize_per_tensor_default_76" [label="(4, 12, 64, 32)", style=solid]; +"1725 quantize_per_tensor_default_76" -> "1726 dequantize_per_tensor_default_76" [label="(4, 12, 64, 32)", style=solid]; +"1726 dequantize_per_tensor_default_76" -> "1734 matmul_24" [label="(4, 12, 64, 32)", style=solid]; +"1727 linalg_vector_norm_25" -> "1728 clamp_min_25" [label="(4, 12, 64, 1)", style=solid]; +"1728 clamp_min_25" -> "1729 expand_as_25" [label="(4, 12, 64, 1)", style=solid]; +"1729 expand_as_25" -> "1730 div_25" [label="(4, 12, 64, 32)", style=solid]; +"1730 div_25" -> "1731 quantize_per_tensor_default_77" [label="(4, 12, 64, 32)", style=solid]; +"1731 quantize_per_tensor_default_77" -> "1732 dequantize_per_tensor_default_77" [label="(4, 12, 64, 32)", style=solid]; +"1732 dequantize_per_tensor_default_77" -> "1733 transpose_24" [label="(4, 12, 64, 32)", style=solid]; +"1733 transpose_24" -> "1734 matmul_24" [label="(4, 12, 32, 64)", style=solid]; +"1734 matmul_24" -> "1737 mul_25" [label="(4, 12, 64, 64)", style=solid]; +"1735 clamp_12" -> "1736 exp_12" [label="(12, 1, 1)", style=solid]; +"1736 exp_12" -> "1737 mul_25" [label="(12, 1, 1)", style=solid]; +"1737 mul_25" -> "1738 add_42" [label="(4, 12, 64, 64)", style=solid]; +"1738 add_42" -> "1739 softmax_12" [label="(4, 12, 64, 64)", style=solid]; +"1739 softmax_12" -> "1740 dropout_48" [label="(4, 12, 64, 64)", style=solid]; +"1740 dropout_48" -> "1741 matmul_25" [label="(4, 12, 64, 64)", style=solid]; +"1741 matmul_25" -> "1742 transpose_25" [label="(4, 12, 64, 32)", style=solid]; +"1742 transpose_25" -> "1743 reshape_56" [label="(4, 64, 12, 32)", style=solid]; +"1743 reshape_56" -> "1744 reshape_56_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"1744 reshape_56_0_0_nncf_smooth_quant_0" -> "1745 quantize_per_tensor_default_78" [label="(4, 64, 384)", style=solid]; +"1745 quantize_per_tensor_default_78" -> "1746 dequantize_per_tensor_default_78" [label="(4, 64, 384)", style=solid]; +"1746 dequantize_per_tensor_default_78" -> "1751 linear_77" [label="(4, 64, 384)", style=solid]; +"1747 linear_77_scale_0" -> "1750 dequantize_per_channel_default_78" [label="(384,)", style=solid]; +"1748 linear_77_zero_point_0" -> "1750 dequantize_per_channel_default_78" [label="(384,)", style=solid]; +"1749 _frozen_param78" -> "1750 dequantize_per_channel_default_78" [label="(384, 384)", style=solid]; +"1750 dequantize_per_channel_default_78" -> "1751 linear_77" [label="(384, 384)", style=solid]; +"1751 linear_77" -> "1752 dropout_49" [label="(4, 64, 384)", style=solid]; +"1752 dropout_49" -> "1753 view_69" [label="(4, 64, 384)", style=solid]; +"1753 view_69" -> "1754 permute_58" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"1754 permute_58" -> "1755 reshape_57" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"1755 reshape_57" -> "1756 slice_190" [label="(1, 16, 16, 384)", style=solid]; +"1756 slice_190" -> "1757 slice_191" [label="(1, 16, 16, 384)", style=solid]; +"1757 slice_191" -> "1758 slice_192" [label="(1, 14, 16, 384)", style=solid]; +"1758 slice_192" -> "1759 slice_193" [label="(1, 14, 14, 384)", style=solid]; +"1759 slice_193" -> "1760 contiguous_23" [label="(1, 14, 14, 384)", style=solid]; +"1760 contiguous_23" -> "1761 layer_norm_27" [label="(1, 14, 14, 384)", style=solid]; +"1761 layer_norm_27" -> "1762 add_43" [label="(1, 14, 14, 384)", style=solid]; +"1762 add_43" -> "1763 add_43_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 384)", style=solid]; +"1762 add_43" -> "1783 add_44" [label="(1, 14, 14, 384)", style=solid]; +"1763 add_43_0_0_nncf_smooth_quant_0" -> "1764 quantize_per_tensor_default_79" [label="(1, 14, 14, 384)", style=solid]; +"1764 quantize_per_tensor_default_79" -> "1765 dequantize_per_tensor_default_79" [label="(1, 14, 14, 384)", style=solid]; +"1765 dequantize_per_tensor_default_79" -> "1770 linear_78" [label="(1, 14, 14, 384)", style=solid]; +"1766 linear_78_scale_0" -> "1769 dequantize_per_channel_default_79" [label="(1536,)", style=solid]; +"1767 linear_78_zero_point_0" -> "1769 dequantize_per_channel_default_79" [label="(1536,)", style=solid]; +"1768 _frozen_param79" -> "1769 dequantize_per_channel_default_79" [label="(1536, 384)", style=solid]; +"1769 dequantize_per_channel_default_79" -> "1770 linear_78" [label="(1536, 384)", style=solid]; +"1770 linear_78" -> "1771 gelu_12" [label="(1, 14, 14, 1536)", style=solid]; +"1771 gelu_12" -> "1772 dropout_50" [label="(1, 14, 14, 1536)", style=solid]; +"1772 dropout_50" -> "1773 dropout_50_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 1536)", style=solid]; +"1773 dropout_50_0_0_nncf_smooth_quant_0" -> "1774 quantize_per_tensor_default_80" [label="(1, 14, 14, 1536)", style=solid]; +"1774 quantize_per_tensor_default_80" -> "1775 dequantize_per_tensor_default_80" [label="(1, 14, 14, 1536)", style=solid]; +"1775 dequantize_per_tensor_default_80" -> "1780 linear_79" [label="(1, 14, 14, 1536)", style=solid]; +"1776 linear_79_scale_0" -> "1779 dequantize_per_channel_default_80" [label="(384,)", style=solid]; +"1777 linear_79_zero_point_0" -> "1779 dequantize_per_channel_default_80" [label="(384,)", style=solid]; +"1778 _frozen_param80" -> "1779 dequantize_per_channel_default_80" [label="(384, 1536)", style=solid]; +"1779 dequantize_per_channel_default_80" -> "1780 linear_79" [label="(384, 1536)", style=solid]; +"1780 linear_79" -> "1781 dropout_51" [label="(1, 14, 14, 384)", style=solid]; +"1781 dropout_51" -> "1782 layer_norm_28" [label="(1, 14, 14, 384)", style=solid]; +"1782 layer_norm_28" -> "1783 add_44" [label="(1, 14, 14, 384)", style=solid]; +"1783 add_44" -> "1805 pad_15" [label="(1, 14, 14, 384)", style=solid]; +"1783 add_44" -> "1882 add_47" [label="(1, 14, 14, 384)", style=solid]; +"1784 features_5_9_attn_relative_coords_table_0_0_nncf_smooth_quant_0" -> "1789 linear_80" [label="(1, 15, 15, 2)", style=solid]; +"1785 linear_80_scale_0" -> "1788 dequantize_per_channel_default_81" [label="(512,)", style=solid]; +"1786 linear_80_zero_point_0" -> "1788 dequantize_per_channel_default_81" [label="(512,)", style=solid]; +"1787 _frozen_param81" -> "1788 dequantize_per_channel_default_81" [label="(512, 2)", style=solid]; +"1788 dequantize_per_channel_default_81" -> "1789 linear_80" [label="(512, 2)", style=solid]; +"1789 linear_80" -> "1790 relu__13" [label="(1, 15, 15, 512)", style=solid]; +"1790 relu__13" -> "1791 relu__13_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 512)", style=solid]; +"1791 relu__13_0_0_nncf_smooth_quant_0" -> "1796 linear_81" [label="(1, 15, 15, 512)", style=solid]; +"1792 linear_81_scale_0" -> "1795 dequantize_per_channel_default_82" [label="(12,)", style=solid]; +"1793 linear_81_zero_point_0" -> "1795 dequantize_per_channel_default_82" [label="(12,)", style=solid]; +"1794 _frozen_param82" -> "1795 dequantize_per_channel_default_82" [label="(12, 512)", style=solid]; +"1795 dequantize_per_channel_default_82" -> "1796 linear_81" [label="(12, 512)", style=solid]; +"1796 linear_81" -> "1797 view_70" [label="(1, 15, 15, 12)", style=solid]; +"1797 view_70" -> "1798 index_13" [label="(225, 12)", style=solid]; +"1798 index_13" -> "1799 view_71" [label="(4096, 12)", style=solid]; +"1799 view_71" -> "1800 permute_59" [label="(64, 64, 12)", style=solid]; +"1800 permute_59" -> "1801 contiguous_24" [label="(12, 64, 64)", style=solid]; +"1801 contiguous_24" -> "1802 unsqueeze_37" [label="(12, 64, 64)", style=solid]; +"1802 unsqueeze_37" -> "1803 sigmoid_13" [label="(1, 12, 64, 64)", style=solid]; +"1803 sigmoid_13" -> "1804 mul_26" [label="(1, 12, 64, 64)", style=solid]; +"1804 mul_26" -> "1841 add_45" [label="(1, 12, 64, 64)", style=solid]; +"1805 pad_15" -> "1806 roll_12" [label="(1, 16, 16, 384)", style=solid]; +"1806 roll_12" -> "1807 view_72" [label="(1, 16, 16, 384)", style=solid]; +"1807 view_72" -> "1808 permute_60" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"1808 permute_60" -> "1809 reshape_58" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"1809 reshape_58" -> "1811 reshape_58_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"1809 reshape_58" -> "1842 new_zeros_6" [label="(4, 64, 384)", style=solid]; +"1810 clone_13" -> "1818 linear_82" [label="(1152,)", style=solid]; +"1811 reshape_58_0_0_nncf_smooth_quant_0" -> "1812 quantize_per_tensor_default_81" [label="(4, 64, 384)", style=solid]; +"1812 quantize_per_tensor_default_81" -> "1813 dequantize_per_tensor_default_81" [label="(4, 64, 384)", style=solid]; +"1813 dequantize_per_tensor_default_81" -> "1818 linear_82" [label="(4, 64, 384)", style=solid]; +"1814 linear_82_scale_0" -> "1817 dequantize_per_channel_default_83" [label="(1152,)", style=solid]; +"1815 linear_82_zero_point_0" -> "1817 dequantize_per_channel_default_83" [label="(1152,)", style=solid]; +"1816 _frozen_param83" -> "1817 dequantize_per_channel_default_83" [label="(1152, 384)", style=solid]; +"1817 dequantize_per_channel_default_83" -> "1818 linear_82" [label="(1152, 384)", style=solid]; +"1818 linear_82" -> "1819 reshape_59" [label="(4, 64, 1152)", style=solid]; +"1819 reshape_59" -> "1820 permute_61" [label="(4, 64, 3, 12, 32)", style=solid]; +"1820 permute_61" -> "1821 select_39" [label="(3, 4, 12, 64, 32)", style=solid]; +"1820 permute_61" -> "1822 select_40" [label="(3, 4, 12, 64, 32)", style=solid]; +"1820 permute_61" -> "1823 select_41" [label="(3, 4, 12, 64, 32)", style=solid]; +"1821 select_39" -> "1824 linalg_vector_norm_26" [label="(4, 12, 64, 32)", style=solid]; +"1821 select_39" -> "1826 expand_as_26" [label="(4, 12, 64, 32)", style=solid]; +"1821 select_39" -> "1827 div_26" [label="(4, 12, 64, 32)", style=solid]; +"1822 select_40" -> "1830 linalg_vector_norm_27" [label="(4, 12, 64, 32)", style=solid]; +"1822 select_40" -> "1832 expand_as_27" [label="(4, 12, 64, 32)", style=solid]; +"1822 select_40" -> "1833 div_27" [label="(4, 12, 64, 32)", style=solid]; +"1823 select_41" -> "1860 matmul_27" [label="(4, 12, 64, 32)", style=solid]; +"1824 linalg_vector_norm_26" -> "1825 clamp_min_26" [label="(4, 12, 64, 1)", style=solid]; +"1825 clamp_min_26" -> "1826 expand_as_26" [label="(4, 12, 64, 1)", style=solid]; +"1826 expand_as_26" -> "1827 div_26" [label="(4, 12, 64, 32)", style=solid]; +"1827 div_26" -> "1828 quantize_per_tensor_default_82" [label="(4, 12, 64, 32)", style=solid]; +"1828 quantize_per_tensor_default_82" -> "1829 dequantize_per_tensor_default_82" [label="(4, 12, 64, 32)", style=solid]; +"1829 dequantize_per_tensor_default_82" -> "1837 matmul_26" [label="(4, 12, 64, 32)", style=solid]; +"1830 linalg_vector_norm_27" -> "1831 clamp_min_27" [label="(4, 12, 64, 1)", style=solid]; +"1831 clamp_min_27" -> "1832 expand_as_27" [label="(4, 12, 64, 1)", style=solid]; +"1832 expand_as_27" -> "1833 div_27" [label="(4, 12, 64, 32)", style=solid]; +"1833 div_27" -> "1834 quantize_per_tensor_default_83" [label="(4, 12, 64, 32)", style=solid]; +"1834 quantize_per_tensor_default_83" -> "1835 dequantize_per_tensor_default_83" [label="(4, 12, 64, 32)", style=solid]; +"1835 dequantize_per_tensor_default_83" -> "1836 transpose_26" [label="(4, 12, 64, 32)", style=solid]; +"1836 transpose_26" -> "1837 matmul_26" [label="(4, 12, 32, 64)", style=solid]; +"1837 matmul_26" -> "1840 mul_27" [label="(4, 12, 64, 64)", style=solid]; +"1838 clamp_13" -> "1839 exp_13" [label="(12, 1, 1)", style=solid]; +"1839 exp_13" -> "1840 mul_27" [label="(12, 1, 1)", style=solid]; +"1840 mul_27" -> "1841 add_45" [label="(4, 12, 64, 64)", style=solid]; +"1841 add_45" -> "1853 view_74" [label="(4, 12, 64, 64)", style=solid]; +"1842 new_zeros_6" -> "1843 view_73" [label="(16, 16)", style=solid]; +"1843 view_73" -> "1844 permute_62" [label="(2, 8, 2, 8)", style=solid]; +"1844 permute_62" -> "1845 reshape_60" [label="(2, 2, 8, 8)", style=solid]; +"1845 reshape_60" -> "1846 unsqueeze_38" [label="(4, 64)", style=solid]; +"1845 reshape_60" -> "1847 unsqueeze_39" [label="(4, 64)", style=solid]; +"1846 unsqueeze_38" -> "1848 sub_6" [label="(4, 1, 64)", style=solid]; +"1847 unsqueeze_39" -> "1848 sub_6" [label="(4, 64, 1)", style=solid]; +"1848 sub_6" -> "1849 ne_6" [label="(4, 64, 64)", style=solid]; +"1848 sub_6" -> "1850 masked_fill_12" [label="(4, 64, 64)", style=solid]; +"1848 sub_6" -> "1851 eq_6" [label="(4, 64, 64)", style=solid]; +"1849 ne_6" -> "1850 masked_fill_12" [label="(4, 64, 64)", style=solid]; +"1850 masked_fill_12" -> "1852 masked_fill_13" [label="(4, 64, 64)", style=solid]; +"1851 eq_6" -> "1852 masked_fill_13" [label="(4, 64, 64)", style=solid]; +"1852 masked_fill_13" -> "1854 unsqueeze_40" [label="(4, 64, 64)", style=solid]; +"1853 view_74" -> "1856 add_46" [label="(1, 4, 12, 64, 64)", style=solid]; +"1854 unsqueeze_40" -> "1855 unsqueeze_41" [label="(4, 1, 64, 64)", style=solid]; +"1855 unsqueeze_41" -> "1856 add_46" [label="(1, 4, 1, 64, 64)", style=solid]; +"1856 add_46" -> "1857 view_75" [label="(1, 4, 12, 64, 64)", style=solid]; +"1857 view_75" -> "1858 softmax_13" [label="(4, 12, 64, 64)", style=solid]; +"1858 softmax_13" -> "1859 dropout_52" [label="(4, 12, 64, 64)", style=solid]; +"1859 dropout_52" -> "1860 matmul_27" [label="(4, 12, 64, 64)", style=solid]; +"1860 matmul_27" -> "1861 transpose_27" [label="(4, 12, 64, 32)", style=solid]; +"1861 transpose_27" -> "1862 reshape_61" [label="(4, 64, 12, 32)", style=solid]; +"1862 reshape_61" -> "1863 reshape_61_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"1863 reshape_61_0_0_nncf_smooth_quant_0" -> "1864 quantize_per_tensor_default_84" [label="(4, 64, 384)", style=solid]; +"1864 quantize_per_tensor_default_84" -> "1865 dequantize_per_tensor_default_84" [label="(4, 64, 384)", style=solid]; +"1865 dequantize_per_tensor_default_84" -> "1870 linear_83" [label="(4, 64, 384)", style=solid]; +"1866 linear_83_scale_0" -> "1869 dequantize_per_channel_default_84" [label="(384,)", style=solid]; +"1867 linear_83_zero_point_0" -> "1869 dequantize_per_channel_default_84" [label="(384,)", style=solid]; +"1868 _frozen_param84" -> "1869 dequantize_per_channel_default_84" [label="(384, 384)", style=solid]; +"1869 dequantize_per_channel_default_84" -> "1870 linear_83" [label="(384, 384)", style=solid]; +"1870 linear_83" -> "1871 dropout_53" [label="(4, 64, 384)", style=solid]; +"1871 dropout_53" -> "1872 view_76" [label="(4, 64, 384)", style=solid]; +"1872 view_76" -> "1873 permute_63" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"1873 permute_63" -> "1874 reshape_62" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"1874 reshape_62" -> "1875 roll_13" [label="(1, 16, 16, 384)", style=solid]; +"1875 roll_13" -> "1876 slice_213" [label="(1, 16, 16, 384)", style=solid]; +"1876 slice_213" -> "1877 slice_214" [label="(1, 16, 16, 384)", style=solid]; +"1877 slice_214" -> "1878 slice_215" [label="(1, 14, 16, 384)", style=solid]; +"1878 slice_215" -> "1879 slice_216" [label="(1, 14, 14, 384)", style=solid]; +"1879 slice_216" -> "1880 contiguous_25" [label="(1, 14, 14, 384)", style=solid]; +"1880 contiguous_25" -> "1881 layer_norm_29" [label="(1, 14, 14, 384)", style=solid]; +"1881 layer_norm_29" -> "1882 add_47" [label="(1, 14, 14, 384)", style=solid]; +"1882 add_47" -> "1883 add_47_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 384)", style=solid]; +"1882 add_47" -> "1903 add_48" [label="(1, 14, 14, 384)", style=solid]; +"1883 add_47_0_0_nncf_smooth_quant_0" -> "1884 quantize_per_tensor_default_85" [label="(1, 14, 14, 384)", style=solid]; +"1884 quantize_per_tensor_default_85" -> "1885 dequantize_per_tensor_default_85" [label="(1, 14, 14, 384)", style=solid]; +"1885 dequantize_per_tensor_default_85" -> "1890 linear_84" [label="(1, 14, 14, 384)", style=solid]; +"1886 linear_84_scale_0" -> "1889 dequantize_per_channel_default_85" [label="(1536,)", style=solid]; +"1887 linear_84_zero_point_0" -> "1889 dequantize_per_channel_default_85" [label="(1536,)", style=solid]; +"1888 _frozen_param85" -> "1889 dequantize_per_channel_default_85" [label="(1536, 384)", style=solid]; +"1889 dequantize_per_channel_default_85" -> "1890 linear_84" [label="(1536, 384)", style=solid]; +"1890 linear_84" -> "1891 gelu_13" [label="(1, 14, 14, 1536)", style=solid]; +"1891 gelu_13" -> "1892 dropout_54" [label="(1, 14, 14, 1536)", style=solid]; +"1892 dropout_54" -> "1893 dropout_54_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 1536)", style=solid]; +"1893 dropout_54_0_0_nncf_smooth_quant_0" -> "1894 quantize_per_tensor_default_86" [label="(1, 14, 14, 1536)", style=solid]; +"1894 quantize_per_tensor_default_86" -> "1895 dequantize_per_tensor_default_86" [label="(1, 14, 14, 1536)", style=solid]; +"1895 dequantize_per_tensor_default_86" -> "1900 linear_85" [label="(1, 14, 14, 1536)", style=solid]; +"1896 linear_85_scale_0" -> "1899 dequantize_per_channel_default_86" [label="(384,)", style=solid]; +"1897 linear_85_zero_point_0" -> "1899 dequantize_per_channel_default_86" [label="(384,)", style=solid]; +"1898 _frozen_param86" -> "1899 dequantize_per_channel_default_86" [label="(384, 1536)", style=solid]; +"1899 dequantize_per_channel_default_86" -> "1900 linear_85" [label="(384, 1536)", style=solid]; +"1900 linear_85" -> "1901 dropout_55" [label="(1, 14, 14, 384)", style=solid]; +"1901 dropout_55" -> "1902 layer_norm_30" [label="(1, 14, 14, 384)", style=solid]; +"1902 layer_norm_30" -> "1903 add_48" [label="(1, 14, 14, 384)", style=solid]; +"1903 add_48" -> "1925 pad_16" [label="(1, 14, 14, 384)", style=solid]; +"1903 add_48" -> "1984 add_50" [label="(1, 14, 14, 384)", style=solid]; +"1904 features_5_10_attn_relative_coords_table_0_0_nncf_smooth_quant_0" -> "1909 linear_86" [label="(1, 15, 15, 2)", style=solid]; +"1905 linear_86_scale_0" -> "1908 dequantize_per_channel_default_87" [label="(512,)", style=solid]; +"1906 linear_86_zero_point_0" -> "1908 dequantize_per_channel_default_87" [label="(512,)", style=solid]; +"1907 _frozen_param87" -> "1908 dequantize_per_channel_default_87" [label="(512, 2)", style=solid]; +"1908 dequantize_per_channel_default_87" -> "1909 linear_86" [label="(512, 2)", style=solid]; +"1909 linear_86" -> "1910 relu__14" [label="(1, 15, 15, 512)", style=solid]; +"1910 relu__14" -> "1911 relu__14_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 512)", style=solid]; +"1911 relu__14_0_0_nncf_smooth_quant_0" -> "1916 linear_87" [label="(1, 15, 15, 512)", style=solid]; +"1912 linear_87_scale_0" -> "1915 dequantize_per_channel_default_88" [label="(12,)", style=solid]; +"1913 linear_87_zero_point_0" -> "1915 dequantize_per_channel_default_88" [label="(12,)", style=solid]; +"1914 _frozen_param88" -> "1915 dequantize_per_channel_default_88" [label="(12, 512)", style=solid]; +"1915 dequantize_per_channel_default_88" -> "1916 linear_87" [label="(12, 512)", style=solid]; +"1916 linear_87" -> "1917 view_77" [label="(1, 15, 15, 12)", style=solid]; +"1917 view_77" -> "1918 index_14" [label="(225, 12)", style=solid]; +"1918 index_14" -> "1919 view_78" [label="(4096, 12)", style=solid]; +"1919 view_78" -> "1920 permute_64" [label="(64, 64, 12)", style=solid]; +"1920 permute_64" -> "1921 contiguous_26" [label="(12, 64, 64)", style=solid]; +"1921 contiguous_26" -> "1922 unsqueeze_42" [label="(12, 64, 64)", style=solid]; +"1922 unsqueeze_42" -> "1923 sigmoid_14" [label="(1, 12, 64, 64)", style=solid]; +"1923 sigmoid_14" -> "1924 mul_28" [label="(1, 12, 64, 64)", style=solid]; +"1924 mul_28" -> "1960 add_49" [label="(1, 12, 64, 64)", style=solid]; +"1925 pad_16" -> "1926 view_79" [label="(1, 16, 16, 384)", style=solid]; +"1926 view_79" -> "1927 permute_65" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"1927 permute_65" -> "1928 reshape_63" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"1928 reshape_63" -> "1930 reshape_63_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"1929 clone_14" -> "1937 linear_88" [label="(1152,)", style=solid]; +"1930 reshape_63_0_0_nncf_smooth_quant_0" -> "1931 quantize_per_tensor_default_87" [label="(4, 64, 384)", style=solid]; +"1931 quantize_per_tensor_default_87" -> "1932 dequantize_per_tensor_default_87" [label="(4, 64, 384)", style=solid]; +"1932 dequantize_per_tensor_default_87" -> "1937 linear_88" [label="(4, 64, 384)", style=solid]; +"1933 linear_88_scale_0" -> "1936 dequantize_per_channel_default_89" [label="(1152,)", style=solid]; +"1934 linear_88_zero_point_0" -> "1936 dequantize_per_channel_default_89" [label="(1152,)", style=solid]; +"1935 _frozen_param89" -> "1936 dequantize_per_channel_default_89" [label="(1152, 384)", style=solid]; +"1936 dequantize_per_channel_default_89" -> "1937 linear_88" [label="(1152, 384)", style=solid]; +"1937 linear_88" -> "1938 reshape_64" [label="(4, 64, 1152)", style=solid]; +"1938 reshape_64" -> "1939 permute_66" [label="(4, 64, 3, 12, 32)", style=solid]; +"1939 permute_66" -> "1940 select_42" [label="(3, 4, 12, 64, 32)", style=solid]; +"1939 permute_66" -> "1941 select_43" [label="(3, 4, 12, 64, 32)", style=solid]; +"1939 permute_66" -> "1942 select_44" [label="(3, 4, 12, 64, 32)", style=solid]; +"1940 select_42" -> "1943 linalg_vector_norm_28" [label="(4, 12, 64, 32)", style=solid]; +"1940 select_42" -> "1945 expand_as_28" [label="(4, 12, 64, 32)", style=solid]; +"1940 select_42" -> "1946 div_28" [label="(4, 12, 64, 32)", style=solid]; +"1941 select_43" -> "1949 linalg_vector_norm_29" [label="(4, 12, 64, 32)", style=solid]; +"1941 select_43" -> "1951 expand_as_29" [label="(4, 12, 64, 32)", style=solid]; +"1941 select_43" -> "1952 div_29" [label="(4, 12, 64, 32)", style=solid]; +"1942 select_44" -> "1963 matmul_29" [label="(4, 12, 64, 32)", style=solid]; +"1943 linalg_vector_norm_28" -> "1944 clamp_min_28" [label="(4, 12, 64, 1)", style=solid]; +"1944 clamp_min_28" -> "1945 expand_as_28" [label="(4, 12, 64, 1)", style=solid]; +"1945 expand_as_28" -> "1946 div_28" [label="(4, 12, 64, 32)", style=solid]; +"1946 div_28" -> "1947 quantize_per_tensor_default_88" [label="(4, 12, 64, 32)", style=solid]; +"1947 quantize_per_tensor_default_88" -> "1948 dequantize_per_tensor_default_88" [label="(4, 12, 64, 32)", style=solid]; +"1948 dequantize_per_tensor_default_88" -> "1956 matmul_28" [label="(4, 12, 64, 32)", style=solid]; +"1949 linalg_vector_norm_29" -> "1950 clamp_min_29" [label="(4, 12, 64, 1)", style=solid]; +"1950 clamp_min_29" -> "1951 expand_as_29" [label="(4, 12, 64, 1)", style=solid]; +"1951 expand_as_29" -> "1952 div_29" [label="(4, 12, 64, 32)", style=solid]; +"1952 div_29" -> "1953 quantize_per_tensor_default_89" [label="(4, 12, 64, 32)", style=solid]; +"1953 quantize_per_tensor_default_89" -> "1954 dequantize_per_tensor_default_89" [label="(4, 12, 64, 32)", style=solid]; +"1954 dequantize_per_tensor_default_89" -> "1955 transpose_28" [label="(4, 12, 64, 32)", style=solid]; +"1955 transpose_28" -> "1956 matmul_28" [label="(4, 12, 32, 64)", style=solid]; +"1956 matmul_28" -> "1959 mul_29" [label="(4, 12, 64, 64)", style=solid]; +"1957 clamp_14" -> "1958 exp_14" [label="(12, 1, 1)", style=solid]; +"1958 exp_14" -> "1959 mul_29" [label="(12, 1, 1)", style=solid]; +"1959 mul_29" -> "1960 add_49" [label="(4, 12, 64, 64)", style=solid]; +"1960 add_49" -> "1961 softmax_14" [label="(4, 12, 64, 64)", style=solid]; +"1961 softmax_14" -> "1962 dropout_56" [label="(4, 12, 64, 64)", style=solid]; +"1962 dropout_56" -> "1963 matmul_29" [label="(4, 12, 64, 64)", style=solid]; +"1963 matmul_29" -> "1964 transpose_29" [label="(4, 12, 64, 32)", style=solid]; +"1964 transpose_29" -> "1965 reshape_65" [label="(4, 64, 12, 32)", style=solid]; +"1965 reshape_65" -> "1966 reshape_65_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"1966 reshape_65_0_0_nncf_smooth_quant_0" -> "1967 quantize_per_tensor_default_90" [label="(4, 64, 384)", style=solid]; +"1967 quantize_per_tensor_default_90" -> "1968 dequantize_per_tensor_default_90" [label="(4, 64, 384)", style=solid]; +"1968 dequantize_per_tensor_default_90" -> "1973 linear_89" [label="(4, 64, 384)", style=solid]; +"1969 linear_89_scale_0" -> "1972 dequantize_per_channel_default_90" [label="(384,)", style=solid]; +"1970 linear_89_zero_point_0" -> "1972 dequantize_per_channel_default_90" [label="(384,)", style=solid]; +"1971 _frozen_param90" -> "1972 dequantize_per_channel_default_90" [label="(384, 384)", style=solid]; +"1972 dequantize_per_channel_default_90" -> "1973 linear_89" [label="(384, 384)", style=solid]; +"1973 linear_89" -> "1974 dropout_57" [label="(4, 64, 384)", style=solid]; +"1974 dropout_57" -> "1975 view_80" [label="(4, 64, 384)", style=solid]; +"1975 view_80" -> "1976 permute_67" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"1976 permute_67" -> "1977 reshape_66" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"1977 reshape_66" -> "1978 slice_218" [label="(1, 16, 16, 384)", style=solid]; +"1978 slice_218" -> "1979 slice_219" [label="(1, 16, 16, 384)", style=solid]; +"1979 slice_219" -> "1980 slice_220" [label="(1, 14, 16, 384)", style=solid]; +"1980 slice_220" -> "1981 slice_221" [label="(1, 14, 14, 384)", style=solid]; +"1981 slice_221" -> "1982 contiguous_27" [label="(1, 14, 14, 384)", style=solid]; +"1982 contiguous_27" -> "1983 layer_norm_31" [label="(1, 14, 14, 384)", style=solid]; +"1983 layer_norm_31" -> "1984 add_50" [label="(1, 14, 14, 384)", style=solid]; +"1984 add_50" -> "1985 add_50_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 384)", style=solid]; +"1984 add_50" -> "2005 add_51" [label="(1, 14, 14, 384)", style=solid]; +"1985 add_50_0_0_nncf_smooth_quant_0" -> "1986 quantize_per_tensor_default_91" [label="(1, 14, 14, 384)", style=solid]; +"1986 quantize_per_tensor_default_91" -> "1987 dequantize_per_tensor_default_91" [label="(1, 14, 14, 384)", style=solid]; +"1987 dequantize_per_tensor_default_91" -> "1992 linear_90" [label="(1, 14, 14, 384)", style=solid]; +"1988 linear_90_scale_0" -> "1991 dequantize_per_channel_default_91" [label="(1536,)", style=solid]; +"1989 linear_90_zero_point_0" -> "1991 dequantize_per_channel_default_91" [label="(1536,)", style=solid]; +"1990 _frozen_param91" -> "1991 dequantize_per_channel_default_91" [label="(1536, 384)", style=solid]; +"1991 dequantize_per_channel_default_91" -> "1992 linear_90" [label="(1536, 384)", style=solid]; +"1992 linear_90" -> "1993 gelu_14" [label="(1, 14, 14, 1536)", style=solid]; +"1993 gelu_14" -> "1994 dropout_58" [label="(1, 14, 14, 1536)", style=solid]; +"1994 dropout_58" -> "1995 dropout_58_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 1536)", style=solid]; +"1995 dropout_58_0_0_nncf_smooth_quant_0" -> "1996 quantize_per_tensor_default_92" [label="(1, 14, 14, 1536)", style=solid]; +"1996 quantize_per_tensor_default_92" -> "1997 dequantize_per_tensor_default_92" [label="(1, 14, 14, 1536)", style=solid]; +"1997 dequantize_per_tensor_default_92" -> "2002 linear_91" [label="(1, 14, 14, 1536)", style=solid]; +"1998 linear_91_scale_0" -> "2001 dequantize_per_channel_default_92" [label="(384,)", style=solid]; +"1999 linear_91_zero_point_0" -> "2001 dequantize_per_channel_default_92" [label="(384,)", style=solid]; +"2000 _frozen_param92" -> "2001 dequantize_per_channel_default_92" [label="(384, 1536)", style=solid]; +"2001 dequantize_per_channel_default_92" -> "2002 linear_91" [label="(384, 1536)", style=solid]; +"2002 linear_91" -> "2003 dropout_59" [label="(1, 14, 14, 384)", style=solid]; +"2003 dropout_59" -> "2004 layer_norm_32" [label="(1, 14, 14, 384)", style=solid]; +"2004 layer_norm_32" -> "2005 add_51" [label="(1, 14, 14, 384)", style=solid]; +"2005 add_51" -> "2027 pad_17" [label="(1, 14, 14, 384)", style=solid]; +"2005 add_51" -> "2104 add_54" [label="(1, 14, 14, 384)", style=solid]; +"2006 features_5_11_attn_relative_coords_table_0_0_nncf_smooth_quant_0" -> "2011 linear_92" [label="(1, 15, 15, 2)", style=solid]; +"2007 linear_92_scale_0" -> "2010 dequantize_per_channel_default_93" [label="(512,)", style=solid]; +"2008 linear_92_zero_point_0" -> "2010 dequantize_per_channel_default_93" [label="(512,)", style=solid]; +"2009 _frozen_param93" -> "2010 dequantize_per_channel_default_93" [label="(512, 2)", style=solid]; +"2010 dequantize_per_channel_default_93" -> "2011 linear_92" [label="(512, 2)", style=solid]; +"2011 linear_92" -> "2012 relu__15" [label="(1, 15, 15, 512)", style=solid]; +"2012 relu__15" -> "2013 relu__15_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 512)", style=solid]; +"2013 relu__15_0_0_nncf_smooth_quant_0" -> "2018 linear_93" [label="(1, 15, 15, 512)", style=solid]; +"2014 linear_93_scale_0" -> "2017 dequantize_per_channel_default_94" [label="(12,)", style=solid]; +"2015 linear_93_zero_point_0" -> "2017 dequantize_per_channel_default_94" [label="(12,)", style=solid]; +"2016 _frozen_param94" -> "2017 dequantize_per_channel_default_94" [label="(12, 512)", style=solid]; +"2017 dequantize_per_channel_default_94" -> "2018 linear_93" [label="(12, 512)", style=solid]; +"2018 linear_93" -> "2019 view_81" [label="(1, 15, 15, 12)", style=solid]; +"2019 view_81" -> "2020 index_15" [label="(225, 12)", style=solid]; +"2020 index_15" -> "2021 view_82" [label="(4096, 12)", style=solid]; +"2021 view_82" -> "2022 permute_68" [label="(64, 64, 12)", style=solid]; +"2022 permute_68" -> "2023 contiguous_28" [label="(12, 64, 64)", style=solid]; +"2023 contiguous_28" -> "2024 unsqueeze_43" [label="(12, 64, 64)", style=solid]; +"2024 unsqueeze_43" -> "2025 sigmoid_15" [label="(1, 12, 64, 64)", style=solid]; +"2025 sigmoid_15" -> "2026 mul_30" [label="(1, 12, 64, 64)", style=solid]; +"2026 mul_30" -> "2063 add_52" [label="(1, 12, 64, 64)", style=solid]; +"2027 pad_17" -> "2028 roll_14" [label="(1, 16, 16, 384)", style=solid]; +"2028 roll_14" -> "2029 view_83" [label="(1, 16, 16, 384)", style=solid]; +"2029 view_83" -> "2030 permute_69" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"2030 permute_69" -> "2031 reshape_67" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"2031 reshape_67" -> "2033 reshape_67_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"2031 reshape_67" -> "2064 new_zeros_7" [label="(4, 64, 384)", style=solid]; +"2032 clone_15" -> "2040 linear_94" [label="(1152,)", style=solid]; +"2033 reshape_67_0_0_nncf_smooth_quant_0" -> "2034 quantize_per_tensor_default_93" [label="(4, 64, 384)", style=solid]; +"2034 quantize_per_tensor_default_93" -> "2035 dequantize_per_tensor_default_93" [label="(4, 64, 384)", style=solid]; +"2035 dequantize_per_tensor_default_93" -> "2040 linear_94" [label="(4, 64, 384)", style=solid]; +"2036 linear_94_scale_0" -> "2039 dequantize_per_channel_default_95" [label="(1152,)", style=solid]; +"2037 linear_94_zero_point_0" -> "2039 dequantize_per_channel_default_95" [label="(1152,)", style=solid]; +"2038 _frozen_param95" -> "2039 dequantize_per_channel_default_95" [label="(1152, 384)", style=solid]; +"2039 dequantize_per_channel_default_95" -> "2040 linear_94" [label="(1152, 384)", style=solid]; +"2040 linear_94" -> "2041 reshape_68" [label="(4, 64, 1152)", style=solid]; +"2041 reshape_68" -> "2042 permute_70" [label="(4, 64, 3, 12, 32)", style=solid]; +"2042 permute_70" -> "2043 select_45" [label="(3, 4, 12, 64, 32)", style=solid]; +"2042 permute_70" -> "2044 select_46" [label="(3, 4, 12, 64, 32)", style=solid]; +"2042 permute_70" -> "2045 select_47" [label="(3, 4, 12, 64, 32)", style=solid]; +"2043 select_45" -> "2046 linalg_vector_norm_30" [label="(4, 12, 64, 32)", style=solid]; +"2043 select_45" -> "2048 expand_as_30" [label="(4, 12, 64, 32)", style=solid]; +"2043 select_45" -> "2049 div_30" [label="(4, 12, 64, 32)", style=solid]; +"2044 select_46" -> "2052 linalg_vector_norm_31" [label="(4, 12, 64, 32)", style=solid]; +"2044 select_46" -> "2054 expand_as_31" [label="(4, 12, 64, 32)", style=solid]; +"2044 select_46" -> "2055 div_31" [label="(4, 12, 64, 32)", style=solid]; +"2045 select_47" -> "2082 matmul_31" [label="(4, 12, 64, 32)", style=solid]; +"2046 linalg_vector_norm_30" -> "2047 clamp_min_30" [label="(4, 12, 64, 1)", style=solid]; +"2047 clamp_min_30" -> "2048 expand_as_30" [label="(4, 12, 64, 1)", style=solid]; +"2048 expand_as_30" -> "2049 div_30" [label="(4, 12, 64, 32)", style=solid]; +"2049 div_30" -> "2050 quantize_per_tensor_default_94" [label="(4, 12, 64, 32)", style=solid]; +"2050 quantize_per_tensor_default_94" -> "2051 dequantize_per_tensor_default_94" [label="(4, 12, 64, 32)", style=solid]; +"2051 dequantize_per_tensor_default_94" -> "2059 matmul_30" [label="(4, 12, 64, 32)", style=solid]; +"2052 linalg_vector_norm_31" -> "2053 clamp_min_31" [label="(4, 12, 64, 1)", style=solid]; +"2053 clamp_min_31" -> "2054 expand_as_31" [label="(4, 12, 64, 1)", style=solid]; +"2054 expand_as_31" -> "2055 div_31" [label="(4, 12, 64, 32)", style=solid]; +"2055 div_31" -> "2056 quantize_per_tensor_default_95" [label="(4, 12, 64, 32)", style=solid]; +"2056 quantize_per_tensor_default_95" -> "2057 dequantize_per_tensor_default_95" [label="(4, 12, 64, 32)", style=solid]; +"2057 dequantize_per_tensor_default_95" -> "2058 transpose_30" [label="(4, 12, 64, 32)", style=solid]; +"2058 transpose_30" -> "2059 matmul_30" [label="(4, 12, 32, 64)", style=solid]; +"2059 matmul_30" -> "2062 mul_31" [label="(4, 12, 64, 64)", style=solid]; +"2060 clamp_15" -> "2061 exp_15" [label="(12, 1, 1)", style=solid]; +"2061 exp_15" -> "2062 mul_31" [label="(12, 1, 1)", style=solid]; +"2062 mul_31" -> "2063 add_52" [label="(4, 12, 64, 64)", style=solid]; +"2063 add_52" -> "2075 view_85" [label="(4, 12, 64, 64)", style=solid]; +"2064 new_zeros_7" -> "2065 view_84" [label="(16, 16)", style=solid]; +"2065 view_84" -> "2066 permute_71" [label="(2, 8, 2, 8)", style=solid]; +"2066 permute_71" -> "2067 reshape_69" [label="(2, 2, 8, 8)", style=solid]; +"2067 reshape_69" -> "2068 unsqueeze_44" [label="(4, 64)", style=solid]; +"2067 reshape_69" -> "2069 unsqueeze_45" [label="(4, 64)", style=solid]; +"2068 unsqueeze_44" -> "2070 sub_7" [label="(4, 1, 64)", style=solid]; +"2069 unsqueeze_45" -> "2070 sub_7" [label="(4, 64, 1)", style=solid]; +"2070 sub_7" -> "2071 ne_7" [label="(4, 64, 64)", style=solid]; +"2070 sub_7" -> "2072 masked_fill_14" [label="(4, 64, 64)", style=solid]; +"2070 sub_7" -> "2073 eq_7" [label="(4, 64, 64)", style=solid]; +"2071 ne_7" -> "2072 masked_fill_14" [label="(4, 64, 64)", style=solid]; +"2072 masked_fill_14" -> "2074 masked_fill_15" [label="(4, 64, 64)", style=solid]; +"2073 eq_7" -> "2074 masked_fill_15" [label="(4, 64, 64)", style=solid]; +"2074 masked_fill_15" -> "2076 unsqueeze_46" [label="(4, 64, 64)", style=solid]; +"2075 view_85" -> "2078 add_53" [label="(1, 4, 12, 64, 64)", style=solid]; +"2076 unsqueeze_46" -> "2077 unsqueeze_47" [label="(4, 1, 64, 64)", style=solid]; +"2077 unsqueeze_47" -> "2078 add_53" [label="(1, 4, 1, 64, 64)", style=solid]; +"2078 add_53" -> "2079 view_86" [label="(1, 4, 12, 64, 64)", style=solid]; +"2079 view_86" -> "2080 softmax_15" [label="(4, 12, 64, 64)", style=solid]; +"2080 softmax_15" -> "2081 dropout_60" [label="(4, 12, 64, 64)", style=solid]; +"2081 dropout_60" -> "2082 matmul_31" [label="(4, 12, 64, 64)", style=solid]; +"2082 matmul_31" -> "2083 transpose_31" [label="(4, 12, 64, 32)", style=solid]; +"2083 transpose_31" -> "2084 reshape_70" [label="(4, 64, 12, 32)", style=solid]; +"2084 reshape_70" -> "2085 reshape_70_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"2085 reshape_70_0_0_nncf_smooth_quant_0" -> "2086 quantize_per_tensor_default_96" [label="(4, 64, 384)", style=solid]; +"2086 quantize_per_tensor_default_96" -> "2087 dequantize_per_tensor_default_96" [label="(4, 64, 384)", style=solid]; +"2087 dequantize_per_tensor_default_96" -> "2092 linear_95" [label="(4, 64, 384)", style=solid]; +"2088 linear_95_scale_0" -> "2091 dequantize_per_channel_default_96" [label="(384,)", style=solid]; +"2089 linear_95_zero_point_0" -> "2091 dequantize_per_channel_default_96" [label="(384,)", style=solid]; +"2090 _frozen_param96" -> "2091 dequantize_per_channel_default_96" [label="(384, 384)", style=solid]; +"2091 dequantize_per_channel_default_96" -> "2092 linear_95" [label="(384, 384)", style=solid]; +"2092 linear_95" -> "2093 dropout_61" [label="(4, 64, 384)", style=solid]; +"2093 dropout_61" -> "2094 view_87" [label="(4, 64, 384)", style=solid]; +"2094 view_87" -> "2095 permute_72" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"2095 permute_72" -> "2096 reshape_71" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"2096 reshape_71" -> "2097 roll_15" [label="(1, 16, 16, 384)", style=solid]; +"2097 roll_15" -> "2098 slice_241" [label="(1, 16, 16, 384)", style=solid]; +"2098 slice_241" -> "2099 slice_242" [label="(1, 16, 16, 384)", style=solid]; +"2099 slice_242" -> "2100 slice_243" [label="(1, 14, 16, 384)", style=solid]; +"2100 slice_243" -> "2101 slice_244" [label="(1, 14, 14, 384)", style=solid]; +"2101 slice_244" -> "2102 contiguous_29" [label="(1, 14, 14, 384)", style=solid]; +"2102 contiguous_29" -> "2103 layer_norm_33" [label="(1, 14, 14, 384)", style=solid]; +"2103 layer_norm_33" -> "2104 add_54" [label="(1, 14, 14, 384)", style=solid]; +"2104 add_54" -> "2105 add_54_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 384)", style=solid]; +"2104 add_54" -> "2125 add_55" [label="(1, 14, 14, 384)", style=solid]; +"2105 add_54_0_0_nncf_smooth_quant_0" -> "2106 quantize_per_tensor_default_97" [label="(1, 14, 14, 384)", style=solid]; +"2106 quantize_per_tensor_default_97" -> "2107 dequantize_per_tensor_default_97" [label="(1, 14, 14, 384)", style=solid]; +"2107 dequantize_per_tensor_default_97" -> "2112 linear_96" [label="(1, 14, 14, 384)", style=solid]; +"2108 linear_96_scale_0" -> "2111 dequantize_per_channel_default_97" [label="(1536,)", style=solid]; +"2109 linear_96_zero_point_0" -> "2111 dequantize_per_channel_default_97" [label="(1536,)", style=solid]; +"2110 _frozen_param97" -> "2111 dequantize_per_channel_default_97" [label="(1536, 384)", style=solid]; +"2111 dequantize_per_channel_default_97" -> "2112 linear_96" [label="(1536, 384)", style=solid]; +"2112 linear_96" -> "2113 gelu_15" [label="(1, 14, 14, 1536)", style=solid]; +"2113 gelu_15" -> "2114 dropout_62" [label="(1, 14, 14, 1536)", style=solid]; +"2114 dropout_62" -> "2115 dropout_62_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 1536)", style=solid]; +"2115 dropout_62_0_0_nncf_smooth_quant_0" -> "2116 quantize_per_tensor_default_98" [label="(1, 14, 14, 1536)", style=solid]; +"2116 quantize_per_tensor_default_98" -> "2117 dequantize_per_tensor_default_98" [label="(1, 14, 14, 1536)", style=solid]; +"2117 dequantize_per_tensor_default_98" -> "2122 linear_97" [label="(1, 14, 14, 1536)", style=solid]; +"2118 linear_97_scale_0" -> "2121 dequantize_per_channel_default_98" [label="(384,)", style=solid]; +"2119 linear_97_zero_point_0" -> "2121 dequantize_per_channel_default_98" [label="(384,)", style=solid]; +"2120 _frozen_param98" -> "2121 dequantize_per_channel_default_98" [label="(384, 1536)", style=solid]; +"2121 dequantize_per_channel_default_98" -> "2122 linear_97" [label="(384, 1536)", style=solid]; +"2122 linear_97" -> "2123 dropout_63" [label="(1, 14, 14, 384)", style=solid]; +"2123 dropout_63" -> "2124 layer_norm_34" [label="(1, 14, 14, 384)", style=solid]; +"2124 layer_norm_34" -> "2125 add_55" [label="(1, 14, 14, 384)", style=solid]; +"2125 add_55" -> "2147 pad_18" [label="(1, 14, 14, 384)", style=solid]; +"2125 add_55" -> "2206 add_57" [label="(1, 14, 14, 384)", style=solid]; +"2126 features_5_12_attn_relative_coords_table_0_0_nncf_smooth_quant_0" -> "2131 linear_98" [label="(1, 15, 15, 2)", style=solid]; +"2127 linear_98_scale_0" -> "2130 dequantize_per_channel_default_99" [label="(512,)", style=solid]; +"2128 linear_98_zero_point_0" -> "2130 dequantize_per_channel_default_99" [label="(512,)", style=solid]; +"2129 _frozen_param99" -> "2130 dequantize_per_channel_default_99" [label="(512, 2)", style=solid]; +"2130 dequantize_per_channel_default_99" -> "2131 linear_98" [label="(512, 2)", style=solid]; +"2131 linear_98" -> "2132 relu__16" [label="(1, 15, 15, 512)", style=solid]; +"2132 relu__16" -> "2133 relu__16_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 512)", style=solid]; +"2133 relu__16_0_0_nncf_smooth_quant_0" -> "2138 linear_99" [label="(1, 15, 15, 512)", style=solid]; +"2134 linear_99_scale_0" -> "2137 dequantize_per_channel_default_100" [label="(12,)", style=solid]; +"2135 linear_99_zero_point_0" -> "2137 dequantize_per_channel_default_100" [label="(12,)", style=solid]; +"2136 _frozen_param100" -> "2137 dequantize_per_channel_default_100" [label="(12, 512)", style=solid]; +"2137 dequantize_per_channel_default_100" -> "2138 linear_99" [label="(12, 512)", style=solid]; +"2138 linear_99" -> "2139 view_88" [label="(1, 15, 15, 12)", style=solid]; +"2139 view_88" -> "2140 index_16" [label="(225, 12)", style=solid]; +"2140 index_16" -> "2141 view_89" [label="(4096, 12)", style=solid]; +"2141 view_89" -> "2142 permute_73" [label="(64, 64, 12)", style=solid]; +"2142 permute_73" -> "2143 contiguous_30" [label="(12, 64, 64)", style=solid]; +"2143 contiguous_30" -> "2144 unsqueeze_48" [label="(12, 64, 64)", style=solid]; +"2144 unsqueeze_48" -> "2145 sigmoid_16" [label="(1, 12, 64, 64)", style=solid]; +"2145 sigmoid_16" -> "2146 mul_32" [label="(1, 12, 64, 64)", style=solid]; +"2146 mul_32" -> "2182 add_56" [label="(1, 12, 64, 64)", style=solid]; +"2147 pad_18" -> "2148 view_90" [label="(1, 16, 16, 384)", style=solid]; +"2148 view_90" -> "2149 permute_74" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"2149 permute_74" -> "2150 reshape_72" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"2150 reshape_72" -> "2152 reshape_72_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"2151 clone_16" -> "2159 linear_100" [label="(1152,)", style=solid]; +"2152 reshape_72_0_0_nncf_smooth_quant_0" -> "2153 quantize_per_tensor_default_99" [label="(4, 64, 384)", style=solid]; +"2153 quantize_per_tensor_default_99" -> "2154 dequantize_per_tensor_default_99" [label="(4, 64, 384)", style=solid]; +"2154 dequantize_per_tensor_default_99" -> "2159 linear_100" [label="(4, 64, 384)", style=solid]; +"2155 linear_100_scale_0" -> "2158 dequantize_per_channel_default_101" [label="(1152,)", style=solid]; +"2156 linear_100_zero_point_0" -> "2158 dequantize_per_channel_default_101" [label="(1152,)", style=solid]; +"2157 _frozen_param101" -> "2158 dequantize_per_channel_default_101" [label="(1152, 384)", style=solid]; +"2158 dequantize_per_channel_default_101" -> "2159 linear_100" [label="(1152, 384)", style=solid]; +"2159 linear_100" -> "2160 reshape_73" [label="(4, 64, 1152)", style=solid]; +"2160 reshape_73" -> "2161 permute_75" [label="(4, 64, 3, 12, 32)", style=solid]; +"2161 permute_75" -> "2162 select_48" [label="(3, 4, 12, 64, 32)", style=solid]; +"2161 permute_75" -> "2163 select_49" [label="(3, 4, 12, 64, 32)", style=solid]; +"2161 permute_75" -> "2164 select_50" [label="(3, 4, 12, 64, 32)", style=solid]; +"2162 select_48" -> "2165 linalg_vector_norm_32" [label="(4, 12, 64, 32)", style=solid]; +"2162 select_48" -> "2167 expand_as_32" [label="(4, 12, 64, 32)", style=solid]; +"2162 select_48" -> "2168 div_32" [label="(4, 12, 64, 32)", style=solid]; +"2163 select_49" -> "2171 linalg_vector_norm_33" [label="(4, 12, 64, 32)", style=solid]; +"2163 select_49" -> "2173 expand_as_33" [label="(4, 12, 64, 32)", style=solid]; +"2163 select_49" -> "2174 div_33" [label="(4, 12, 64, 32)", style=solid]; +"2164 select_50" -> "2185 matmul_33" [label="(4, 12, 64, 32)", style=solid]; +"2165 linalg_vector_norm_32" -> "2166 clamp_min_32" [label="(4, 12, 64, 1)", style=solid]; +"2166 clamp_min_32" -> "2167 expand_as_32" [label="(4, 12, 64, 1)", style=solid]; +"2167 expand_as_32" -> "2168 div_32" [label="(4, 12, 64, 32)", style=solid]; +"2168 div_32" -> "2169 quantize_per_tensor_default_100" [label="(4, 12, 64, 32)", style=solid]; +"2169 quantize_per_tensor_default_100" -> "2170 dequantize_per_tensor_default_100" [label="(4, 12, 64, 32)", style=solid]; +"2170 dequantize_per_tensor_default_100" -> "2178 matmul_32" [label="(4, 12, 64, 32)", style=solid]; +"2171 linalg_vector_norm_33" -> "2172 clamp_min_33" [label="(4, 12, 64, 1)", style=solid]; +"2172 clamp_min_33" -> "2173 expand_as_33" [label="(4, 12, 64, 1)", style=solid]; +"2173 expand_as_33" -> "2174 div_33" [label="(4, 12, 64, 32)", style=solid]; +"2174 div_33" -> "2175 quantize_per_tensor_default_101" [label="(4, 12, 64, 32)", style=solid]; +"2175 quantize_per_tensor_default_101" -> "2176 dequantize_per_tensor_default_101" [label="(4, 12, 64, 32)", style=solid]; +"2176 dequantize_per_tensor_default_101" -> "2177 transpose_32" [label="(4, 12, 64, 32)", style=solid]; +"2177 transpose_32" -> "2178 matmul_32" [label="(4, 12, 32, 64)", style=solid]; +"2178 matmul_32" -> "2181 mul_33" [label="(4, 12, 64, 64)", style=solid]; +"2179 clamp_16" -> "2180 exp_16" [label="(12, 1, 1)", style=solid]; +"2180 exp_16" -> "2181 mul_33" [label="(12, 1, 1)", style=solid]; +"2181 mul_33" -> "2182 add_56" [label="(4, 12, 64, 64)", style=solid]; +"2182 add_56" -> "2183 softmax_16" [label="(4, 12, 64, 64)", style=solid]; +"2183 softmax_16" -> "2184 dropout_64" [label="(4, 12, 64, 64)", style=solid]; +"2184 dropout_64" -> "2185 matmul_33" [label="(4, 12, 64, 64)", style=solid]; +"2185 matmul_33" -> "2186 transpose_33" [label="(4, 12, 64, 32)", style=solid]; +"2186 transpose_33" -> "2187 reshape_74" [label="(4, 64, 12, 32)", style=solid]; +"2187 reshape_74" -> "2188 reshape_74_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"2188 reshape_74_0_0_nncf_smooth_quant_0" -> "2189 quantize_per_tensor_default_102" [label="(4, 64, 384)", style=solid]; +"2189 quantize_per_tensor_default_102" -> "2190 dequantize_per_tensor_default_102" [label="(4, 64, 384)", style=solid]; +"2190 dequantize_per_tensor_default_102" -> "2195 linear_101" [label="(4, 64, 384)", style=solid]; +"2191 linear_101_scale_0" -> "2194 dequantize_per_channel_default_102" [label="(384,)", style=solid]; +"2192 linear_101_zero_point_0" -> "2194 dequantize_per_channel_default_102" [label="(384,)", style=solid]; +"2193 _frozen_param102" -> "2194 dequantize_per_channel_default_102" [label="(384, 384)", style=solid]; +"2194 dequantize_per_channel_default_102" -> "2195 linear_101" [label="(384, 384)", style=solid]; +"2195 linear_101" -> "2196 dropout_65" [label="(4, 64, 384)", style=solid]; +"2196 dropout_65" -> "2197 view_91" [label="(4, 64, 384)", style=solid]; +"2197 view_91" -> "2198 permute_76" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"2198 permute_76" -> "2199 reshape_75" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"2199 reshape_75" -> "2200 slice_246" [label="(1, 16, 16, 384)", style=solid]; +"2200 slice_246" -> "2201 slice_247" [label="(1, 16, 16, 384)", style=solid]; +"2201 slice_247" -> "2202 slice_248" [label="(1, 14, 16, 384)", style=solid]; +"2202 slice_248" -> "2203 slice_249" [label="(1, 14, 14, 384)", style=solid]; +"2203 slice_249" -> "2204 contiguous_31" [label="(1, 14, 14, 384)", style=solid]; +"2204 contiguous_31" -> "2205 layer_norm_35" [label="(1, 14, 14, 384)", style=solid]; +"2205 layer_norm_35" -> "2206 add_57" [label="(1, 14, 14, 384)", style=solid]; +"2206 add_57" -> "2207 add_57_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 384)", style=solid]; +"2206 add_57" -> "2227 add_58" [label="(1, 14, 14, 384)", style=solid]; +"2207 add_57_0_0_nncf_smooth_quant_0" -> "2208 quantize_per_tensor_default_103" [label="(1, 14, 14, 384)", style=solid]; +"2208 quantize_per_tensor_default_103" -> "2209 dequantize_per_tensor_default_103" [label="(1, 14, 14, 384)", style=solid]; +"2209 dequantize_per_tensor_default_103" -> "2214 linear_102" [label="(1, 14, 14, 384)", style=solid]; +"2210 linear_102_scale_0" -> "2213 dequantize_per_channel_default_103" [label="(1536,)", style=solid]; +"2211 linear_102_zero_point_0" -> "2213 dequantize_per_channel_default_103" [label="(1536,)", style=solid]; +"2212 _frozen_param103" -> "2213 dequantize_per_channel_default_103" [label="(1536, 384)", style=solid]; +"2213 dequantize_per_channel_default_103" -> "2214 linear_102" [label="(1536, 384)", style=solid]; +"2214 linear_102" -> "2215 gelu_16" [label="(1, 14, 14, 1536)", style=solid]; +"2215 gelu_16" -> "2216 dropout_66" [label="(1, 14, 14, 1536)", style=solid]; +"2216 dropout_66" -> "2217 dropout_66_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 1536)", style=solid]; +"2217 dropout_66_0_0_nncf_smooth_quant_0" -> "2218 quantize_per_tensor_default_104" [label="(1, 14, 14, 1536)", style=solid]; +"2218 quantize_per_tensor_default_104" -> "2219 dequantize_per_tensor_default_104" [label="(1, 14, 14, 1536)", style=solid]; +"2219 dequantize_per_tensor_default_104" -> "2224 linear_103" [label="(1, 14, 14, 1536)", style=solid]; +"2220 linear_103_scale_0" -> "2223 dequantize_per_channel_default_104" [label="(384,)", style=solid]; +"2221 linear_103_zero_point_0" -> "2223 dequantize_per_channel_default_104" [label="(384,)", style=solid]; +"2222 _frozen_param104" -> "2223 dequantize_per_channel_default_104" [label="(384, 1536)", style=solid]; +"2223 dequantize_per_channel_default_104" -> "2224 linear_103" [label="(384, 1536)", style=solid]; +"2224 linear_103" -> "2225 dropout_67" [label="(1, 14, 14, 384)", style=solid]; +"2225 dropout_67" -> "2226 layer_norm_36" [label="(1, 14, 14, 384)", style=solid]; +"2226 layer_norm_36" -> "2227 add_58" [label="(1, 14, 14, 384)", style=solid]; +"2227 add_58" -> "2249 pad_19" [label="(1, 14, 14, 384)", style=solid]; +"2227 add_58" -> "2326 add_61" [label="(1, 14, 14, 384)", style=solid]; +"2228 features_5_13_attn_relative_coords_table_0_0_nncf_smooth_quant_0" -> "2233 linear_104" [label="(1, 15, 15, 2)", style=solid]; +"2229 linear_104_scale_0" -> "2232 dequantize_per_channel_default_105" [label="(512,)", style=solid]; +"2230 linear_104_zero_point_0" -> "2232 dequantize_per_channel_default_105" [label="(512,)", style=solid]; +"2231 _frozen_param105" -> "2232 dequantize_per_channel_default_105" [label="(512, 2)", style=solid]; +"2232 dequantize_per_channel_default_105" -> "2233 linear_104" [label="(512, 2)", style=solid]; +"2233 linear_104" -> "2234 relu__17" [label="(1, 15, 15, 512)", style=solid]; +"2234 relu__17" -> "2235 relu__17_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 512)", style=solid]; +"2235 relu__17_0_0_nncf_smooth_quant_0" -> "2240 linear_105" [label="(1, 15, 15, 512)", style=solid]; +"2236 linear_105_scale_0" -> "2239 dequantize_per_channel_default_106" [label="(12,)", style=solid]; +"2237 linear_105_zero_point_0" -> "2239 dequantize_per_channel_default_106" [label="(12,)", style=solid]; +"2238 _frozen_param106" -> "2239 dequantize_per_channel_default_106" [label="(12, 512)", style=solid]; +"2239 dequantize_per_channel_default_106" -> "2240 linear_105" [label="(12, 512)", style=solid]; +"2240 linear_105" -> "2241 view_92" [label="(1, 15, 15, 12)", style=solid]; +"2241 view_92" -> "2242 index_17" [label="(225, 12)", style=solid]; +"2242 index_17" -> "2243 view_93" [label="(4096, 12)", style=solid]; +"2243 view_93" -> "2244 permute_77" [label="(64, 64, 12)", style=solid]; +"2244 permute_77" -> "2245 contiguous_32" [label="(12, 64, 64)", style=solid]; +"2245 contiguous_32" -> "2246 unsqueeze_49" [label="(12, 64, 64)", style=solid]; +"2246 unsqueeze_49" -> "2247 sigmoid_17" [label="(1, 12, 64, 64)", style=solid]; +"2247 sigmoid_17" -> "2248 mul_34" [label="(1, 12, 64, 64)", style=solid]; +"2248 mul_34" -> "2285 add_59" [label="(1, 12, 64, 64)", style=solid]; +"2249 pad_19" -> "2250 roll_16" [label="(1, 16, 16, 384)", style=solid]; +"2250 roll_16" -> "2251 view_94" [label="(1, 16, 16, 384)", style=solid]; +"2251 view_94" -> "2252 permute_78" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"2252 permute_78" -> "2253 reshape_76" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"2253 reshape_76" -> "2255 reshape_76_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"2253 reshape_76" -> "2286 new_zeros_8" [label="(4, 64, 384)", style=solid]; +"2254 clone_17" -> "2262 linear_106" [label="(1152,)", style=solid]; +"2255 reshape_76_0_0_nncf_smooth_quant_0" -> "2256 quantize_per_tensor_default_105" [label="(4, 64, 384)", style=solid]; +"2256 quantize_per_tensor_default_105" -> "2257 dequantize_per_tensor_default_105" [label="(4, 64, 384)", style=solid]; +"2257 dequantize_per_tensor_default_105" -> "2262 linear_106" [label="(4, 64, 384)", style=solid]; +"2258 linear_106_scale_0" -> "2261 dequantize_per_channel_default_107" [label="(1152,)", style=solid]; +"2259 linear_106_zero_point_0" -> "2261 dequantize_per_channel_default_107" [label="(1152,)", style=solid]; +"2260 _frozen_param107" -> "2261 dequantize_per_channel_default_107" [label="(1152, 384)", style=solid]; +"2261 dequantize_per_channel_default_107" -> "2262 linear_106" [label="(1152, 384)", style=solid]; +"2262 linear_106" -> "2263 reshape_77" [label="(4, 64, 1152)", style=solid]; +"2263 reshape_77" -> "2264 permute_79" [label="(4, 64, 3, 12, 32)", style=solid]; +"2264 permute_79" -> "2265 select_51" [label="(3, 4, 12, 64, 32)", style=solid]; +"2264 permute_79" -> "2266 select_52" [label="(3, 4, 12, 64, 32)", style=solid]; +"2264 permute_79" -> "2267 select_53" [label="(3, 4, 12, 64, 32)", style=solid]; +"2265 select_51" -> "2268 linalg_vector_norm_34" [label="(4, 12, 64, 32)", style=solid]; +"2265 select_51" -> "2270 expand_as_34" [label="(4, 12, 64, 32)", style=solid]; +"2265 select_51" -> "2271 div_34" [label="(4, 12, 64, 32)", style=solid]; +"2266 select_52" -> "2274 linalg_vector_norm_35" [label="(4, 12, 64, 32)", style=solid]; +"2266 select_52" -> "2276 expand_as_35" [label="(4, 12, 64, 32)", style=solid]; +"2266 select_52" -> "2277 div_35" [label="(4, 12, 64, 32)", style=solid]; +"2267 select_53" -> "2304 matmul_35" [label="(4, 12, 64, 32)", style=solid]; +"2268 linalg_vector_norm_34" -> "2269 clamp_min_34" [label="(4, 12, 64, 1)", style=solid]; +"2269 clamp_min_34" -> "2270 expand_as_34" [label="(4, 12, 64, 1)", style=solid]; +"2270 expand_as_34" -> "2271 div_34" [label="(4, 12, 64, 32)", style=solid]; +"2271 div_34" -> "2272 quantize_per_tensor_default_106" [label="(4, 12, 64, 32)", style=solid]; +"2272 quantize_per_tensor_default_106" -> "2273 dequantize_per_tensor_default_106" [label="(4, 12, 64, 32)", style=solid]; +"2273 dequantize_per_tensor_default_106" -> "2281 matmul_34" [label="(4, 12, 64, 32)", style=solid]; +"2274 linalg_vector_norm_35" -> "2275 clamp_min_35" [label="(4, 12, 64, 1)", style=solid]; +"2275 clamp_min_35" -> "2276 expand_as_35" [label="(4, 12, 64, 1)", style=solid]; +"2276 expand_as_35" -> "2277 div_35" [label="(4, 12, 64, 32)", style=solid]; +"2277 div_35" -> "2278 quantize_per_tensor_default_107" [label="(4, 12, 64, 32)", style=solid]; +"2278 quantize_per_tensor_default_107" -> "2279 dequantize_per_tensor_default_107" [label="(4, 12, 64, 32)", style=solid]; +"2279 dequantize_per_tensor_default_107" -> "2280 transpose_34" [label="(4, 12, 64, 32)", style=solid]; +"2280 transpose_34" -> "2281 matmul_34" [label="(4, 12, 32, 64)", style=solid]; +"2281 matmul_34" -> "2284 mul_35" [label="(4, 12, 64, 64)", style=solid]; +"2282 clamp_17" -> "2283 exp_17" [label="(12, 1, 1)", style=solid]; +"2283 exp_17" -> "2284 mul_35" [label="(12, 1, 1)", style=solid]; +"2284 mul_35" -> "2285 add_59" [label="(4, 12, 64, 64)", style=solid]; +"2285 add_59" -> "2297 view_96" [label="(4, 12, 64, 64)", style=solid]; +"2286 new_zeros_8" -> "2287 view_95" [label="(16, 16)", style=solid]; +"2287 view_95" -> "2288 permute_80" [label="(2, 8, 2, 8)", style=solid]; +"2288 permute_80" -> "2289 reshape_78" [label="(2, 2, 8, 8)", style=solid]; +"2289 reshape_78" -> "2290 unsqueeze_50" [label="(4, 64)", style=solid]; +"2289 reshape_78" -> "2291 unsqueeze_51" [label="(4, 64)", style=solid]; +"2290 unsqueeze_50" -> "2292 sub_8" [label="(4, 1, 64)", style=solid]; +"2291 unsqueeze_51" -> "2292 sub_8" [label="(4, 64, 1)", style=solid]; +"2292 sub_8" -> "2293 ne_8" [label="(4, 64, 64)", style=solid]; +"2292 sub_8" -> "2294 masked_fill_16" [label="(4, 64, 64)", style=solid]; +"2292 sub_8" -> "2295 eq_8" [label="(4, 64, 64)", style=solid]; +"2293 ne_8" -> "2294 masked_fill_16" [label="(4, 64, 64)", style=solid]; +"2294 masked_fill_16" -> "2296 masked_fill_17" [label="(4, 64, 64)", style=solid]; +"2295 eq_8" -> "2296 masked_fill_17" [label="(4, 64, 64)", style=solid]; +"2296 masked_fill_17" -> "2298 unsqueeze_52" [label="(4, 64, 64)", style=solid]; +"2297 view_96" -> "2300 add_60" [label="(1, 4, 12, 64, 64)", style=solid]; +"2298 unsqueeze_52" -> "2299 unsqueeze_53" [label="(4, 1, 64, 64)", style=solid]; +"2299 unsqueeze_53" -> "2300 add_60" [label="(1, 4, 1, 64, 64)", style=solid]; +"2300 add_60" -> "2301 view_97" [label="(1, 4, 12, 64, 64)", style=solid]; +"2301 view_97" -> "2302 softmax_17" [label="(4, 12, 64, 64)", style=solid]; +"2302 softmax_17" -> "2303 dropout_68" [label="(4, 12, 64, 64)", style=solid]; +"2303 dropout_68" -> "2304 matmul_35" [label="(4, 12, 64, 64)", style=solid]; +"2304 matmul_35" -> "2305 transpose_35" [label="(4, 12, 64, 32)", style=solid]; +"2305 transpose_35" -> "2306 reshape_79" [label="(4, 64, 12, 32)", style=solid]; +"2306 reshape_79" -> "2307 reshape_79_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"2307 reshape_79_0_0_nncf_smooth_quant_0" -> "2308 quantize_per_tensor_default_108" [label="(4, 64, 384)", style=solid]; +"2308 quantize_per_tensor_default_108" -> "2309 dequantize_per_tensor_default_108" [label="(4, 64, 384)", style=solid]; +"2309 dequantize_per_tensor_default_108" -> "2314 linear_107" [label="(4, 64, 384)", style=solid]; +"2310 linear_107_scale_0" -> "2313 dequantize_per_channel_default_108" [label="(384,)", style=solid]; +"2311 linear_107_zero_point_0" -> "2313 dequantize_per_channel_default_108" [label="(384,)", style=solid]; +"2312 _frozen_param108" -> "2313 dequantize_per_channel_default_108" [label="(384, 384)", style=solid]; +"2313 dequantize_per_channel_default_108" -> "2314 linear_107" [label="(384, 384)", style=solid]; +"2314 linear_107" -> "2315 dropout_69" [label="(4, 64, 384)", style=solid]; +"2315 dropout_69" -> "2316 view_98" [label="(4, 64, 384)", style=solid]; +"2316 view_98" -> "2317 permute_81" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"2317 permute_81" -> "2318 reshape_80" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"2318 reshape_80" -> "2319 roll_17" [label="(1, 16, 16, 384)", style=solid]; +"2319 roll_17" -> "2320 slice_269" [label="(1, 16, 16, 384)", style=solid]; +"2320 slice_269" -> "2321 slice_270" [label="(1, 16, 16, 384)", style=solid]; +"2321 slice_270" -> "2322 slice_271" [label="(1, 14, 16, 384)", style=solid]; +"2322 slice_271" -> "2323 slice_272" [label="(1, 14, 14, 384)", style=solid]; +"2323 slice_272" -> "2324 contiguous_33" [label="(1, 14, 14, 384)", style=solid]; +"2324 contiguous_33" -> "2325 layer_norm_37" [label="(1, 14, 14, 384)", style=solid]; +"2325 layer_norm_37" -> "2326 add_61" [label="(1, 14, 14, 384)", style=solid]; +"2326 add_61" -> "2327 add_61_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 384)", style=solid]; +"2326 add_61" -> "2347 add_62" [label="(1, 14, 14, 384)", style=solid]; +"2327 add_61_0_0_nncf_smooth_quant_0" -> "2328 quantize_per_tensor_default_109" [label="(1, 14, 14, 384)", style=solid]; +"2328 quantize_per_tensor_default_109" -> "2329 dequantize_per_tensor_default_109" [label="(1, 14, 14, 384)", style=solid]; +"2329 dequantize_per_tensor_default_109" -> "2334 linear_108" [label="(1, 14, 14, 384)", style=solid]; +"2330 linear_108_scale_0" -> "2333 dequantize_per_channel_default_109" [label="(1536,)", style=solid]; +"2331 linear_108_zero_point_0" -> "2333 dequantize_per_channel_default_109" [label="(1536,)", style=solid]; +"2332 _frozen_param109" -> "2333 dequantize_per_channel_default_109" [label="(1536, 384)", style=solid]; +"2333 dequantize_per_channel_default_109" -> "2334 linear_108" [label="(1536, 384)", style=solid]; +"2334 linear_108" -> "2335 gelu_17" [label="(1, 14, 14, 1536)", style=solid]; +"2335 gelu_17" -> "2336 dropout_70" [label="(1, 14, 14, 1536)", style=solid]; +"2336 dropout_70" -> "2337 dropout_70_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 1536)", style=solid]; +"2337 dropout_70_0_0_nncf_smooth_quant_0" -> "2338 quantize_per_tensor_default_110" [label="(1, 14, 14, 1536)", style=solid]; +"2338 quantize_per_tensor_default_110" -> "2339 dequantize_per_tensor_default_110" [label="(1, 14, 14, 1536)", style=solid]; +"2339 dequantize_per_tensor_default_110" -> "2344 linear_109" [label="(1, 14, 14, 1536)", style=solid]; +"2340 linear_109_scale_0" -> "2343 dequantize_per_channel_default_110" [label="(384,)", style=solid]; +"2341 linear_109_zero_point_0" -> "2343 dequantize_per_channel_default_110" [label="(384,)", style=solid]; +"2342 _frozen_param110" -> "2343 dequantize_per_channel_default_110" [label="(384, 1536)", style=solid]; +"2343 dequantize_per_channel_default_110" -> "2344 linear_109" [label="(384, 1536)", style=solid]; +"2344 linear_109" -> "2345 dropout_71" [label="(1, 14, 14, 384)", style=solid]; +"2345 dropout_71" -> "2346 layer_norm_38" [label="(1, 14, 14, 384)", style=solid]; +"2346 layer_norm_38" -> "2347 add_62" [label="(1, 14, 14, 384)", style=solid]; +"2347 add_62" -> "2369 pad_20" [label="(1, 14, 14, 384)", style=solid]; +"2347 add_62" -> "2428 add_64" [label="(1, 14, 14, 384)", style=solid]; +"2348 features_5_14_attn_relative_coords_table_0_0_nncf_smooth_quant_0" -> "2353 linear_110" [label="(1, 15, 15, 2)", style=solid]; +"2349 linear_110_scale_0" -> "2352 dequantize_per_channel_default_111" [label="(512,)", style=solid]; +"2350 linear_110_zero_point_0" -> "2352 dequantize_per_channel_default_111" [label="(512,)", style=solid]; +"2351 _frozen_param111" -> "2352 dequantize_per_channel_default_111" [label="(512, 2)", style=solid]; +"2352 dequantize_per_channel_default_111" -> "2353 linear_110" [label="(512, 2)", style=solid]; +"2353 linear_110" -> "2354 relu__18" [label="(1, 15, 15, 512)", style=solid]; +"2354 relu__18" -> "2355 relu__18_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 512)", style=solid]; +"2355 relu__18_0_0_nncf_smooth_quant_0" -> "2360 linear_111" [label="(1, 15, 15, 512)", style=solid]; +"2356 linear_111_scale_0" -> "2359 dequantize_per_channel_default_112" [label="(12,)", style=solid]; +"2357 linear_111_zero_point_0" -> "2359 dequantize_per_channel_default_112" [label="(12,)", style=solid]; +"2358 _frozen_param112" -> "2359 dequantize_per_channel_default_112" [label="(12, 512)", style=solid]; +"2359 dequantize_per_channel_default_112" -> "2360 linear_111" [label="(12, 512)", style=solid]; +"2360 linear_111" -> "2361 view_99" [label="(1, 15, 15, 12)", style=solid]; +"2361 view_99" -> "2362 index_18" [label="(225, 12)", style=solid]; +"2362 index_18" -> "2363 view_100" [label="(4096, 12)", style=solid]; +"2363 view_100" -> "2364 permute_82" [label="(64, 64, 12)", style=solid]; +"2364 permute_82" -> "2365 contiguous_34" [label="(12, 64, 64)", style=solid]; +"2365 contiguous_34" -> "2366 unsqueeze_54" [label="(12, 64, 64)", style=solid]; +"2366 unsqueeze_54" -> "2367 sigmoid_18" [label="(1, 12, 64, 64)", style=solid]; +"2367 sigmoid_18" -> "2368 mul_36" [label="(1, 12, 64, 64)", style=solid]; +"2368 mul_36" -> "2404 add_63" [label="(1, 12, 64, 64)", style=solid]; +"2369 pad_20" -> "2370 view_101" [label="(1, 16, 16, 384)", style=solid]; +"2370 view_101" -> "2371 permute_83" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"2371 permute_83" -> "2372 reshape_81" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"2372 reshape_81" -> "2374 reshape_81_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"2373 clone_18" -> "2381 linear_112" [label="(1152,)", style=solid]; +"2374 reshape_81_0_0_nncf_smooth_quant_0" -> "2375 quantize_per_tensor_default_111" [label="(4, 64, 384)", style=solid]; +"2375 quantize_per_tensor_default_111" -> "2376 dequantize_per_tensor_default_111" [label="(4, 64, 384)", style=solid]; +"2376 dequantize_per_tensor_default_111" -> "2381 linear_112" [label="(4, 64, 384)", style=solid]; +"2377 linear_112_scale_0" -> "2380 dequantize_per_channel_default_113" [label="(1152,)", style=solid]; +"2378 linear_112_zero_point_0" -> "2380 dequantize_per_channel_default_113" [label="(1152,)", style=solid]; +"2379 _frozen_param113" -> "2380 dequantize_per_channel_default_113" [label="(1152, 384)", style=solid]; +"2380 dequantize_per_channel_default_113" -> "2381 linear_112" [label="(1152, 384)", style=solid]; +"2381 linear_112" -> "2382 reshape_82" [label="(4, 64, 1152)", style=solid]; +"2382 reshape_82" -> "2383 permute_84" [label="(4, 64, 3, 12, 32)", style=solid]; +"2383 permute_84" -> "2384 select_54" [label="(3, 4, 12, 64, 32)", style=solid]; +"2383 permute_84" -> "2385 select_55" [label="(3, 4, 12, 64, 32)", style=solid]; +"2383 permute_84" -> "2386 select_56" [label="(3, 4, 12, 64, 32)", style=solid]; +"2384 select_54" -> "2387 linalg_vector_norm_36" [label="(4, 12, 64, 32)", style=solid]; +"2384 select_54" -> "2389 expand_as_36" [label="(4, 12, 64, 32)", style=solid]; +"2384 select_54" -> "2390 div_36" [label="(4, 12, 64, 32)", style=solid]; +"2385 select_55" -> "2393 linalg_vector_norm_37" [label="(4, 12, 64, 32)", style=solid]; +"2385 select_55" -> "2395 expand_as_37" [label="(4, 12, 64, 32)", style=solid]; +"2385 select_55" -> "2396 div_37" [label="(4, 12, 64, 32)", style=solid]; +"2386 select_56" -> "2407 matmul_37" [label="(4, 12, 64, 32)", style=solid]; +"2387 linalg_vector_norm_36" -> "2388 clamp_min_36" [label="(4, 12, 64, 1)", style=solid]; +"2388 clamp_min_36" -> "2389 expand_as_36" [label="(4, 12, 64, 1)", style=solid]; +"2389 expand_as_36" -> "2390 div_36" [label="(4, 12, 64, 32)", style=solid]; +"2390 div_36" -> "2391 quantize_per_tensor_default_112" [label="(4, 12, 64, 32)", style=solid]; +"2391 quantize_per_tensor_default_112" -> "2392 dequantize_per_tensor_default_112" [label="(4, 12, 64, 32)", style=solid]; +"2392 dequantize_per_tensor_default_112" -> "2400 matmul_36" [label="(4, 12, 64, 32)", style=solid]; +"2393 linalg_vector_norm_37" -> "2394 clamp_min_37" [label="(4, 12, 64, 1)", style=solid]; +"2394 clamp_min_37" -> "2395 expand_as_37" [label="(4, 12, 64, 1)", style=solid]; +"2395 expand_as_37" -> "2396 div_37" [label="(4, 12, 64, 32)", style=solid]; +"2396 div_37" -> "2397 quantize_per_tensor_default_113" [label="(4, 12, 64, 32)", style=solid]; +"2397 quantize_per_tensor_default_113" -> "2398 dequantize_per_tensor_default_113" [label="(4, 12, 64, 32)", style=solid]; +"2398 dequantize_per_tensor_default_113" -> "2399 transpose_36" [label="(4, 12, 64, 32)", style=solid]; +"2399 transpose_36" -> "2400 matmul_36" [label="(4, 12, 32, 64)", style=solid]; +"2400 matmul_36" -> "2403 mul_37" [label="(4, 12, 64, 64)", style=solid]; +"2401 clamp_18" -> "2402 exp_18" [label="(12, 1, 1)", style=solid]; +"2402 exp_18" -> "2403 mul_37" [label="(12, 1, 1)", style=solid]; +"2403 mul_37" -> "2404 add_63" [label="(4, 12, 64, 64)", style=solid]; +"2404 add_63" -> "2405 softmax_18" [label="(4, 12, 64, 64)", style=solid]; +"2405 softmax_18" -> "2406 dropout_72" [label="(4, 12, 64, 64)", style=solid]; +"2406 dropout_72" -> "2407 matmul_37" [label="(4, 12, 64, 64)", style=solid]; +"2407 matmul_37" -> "2408 transpose_37" [label="(4, 12, 64, 32)", style=solid]; +"2408 transpose_37" -> "2409 reshape_83" [label="(4, 64, 12, 32)", style=solid]; +"2409 reshape_83" -> "2410 reshape_83_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"2410 reshape_83_0_0_nncf_smooth_quant_0" -> "2411 quantize_per_tensor_default_114" [label="(4, 64, 384)", style=solid]; +"2411 quantize_per_tensor_default_114" -> "2412 dequantize_per_tensor_default_114" [label="(4, 64, 384)", style=solid]; +"2412 dequantize_per_tensor_default_114" -> "2417 linear_113" [label="(4, 64, 384)", style=solid]; +"2413 linear_113_scale_0" -> "2416 dequantize_per_channel_default_114" [label="(384,)", style=solid]; +"2414 linear_113_zero_point_0" -> "2416 dequantize_per_channel_default_114" [label="(384,)", style=solid]; +"2415 _frozen_param114" -> "2416 dequantize_per_channel_default_114" [label="(384, 384)", style=solid]; +"2416 dequantize_per_channel_default_114" -> "2417 linear_113" [label="(384, 384)", style=solid]; +"2417 linear_113" -> "2418 dropout_73" [label="(4, 64, 384)", style=solid]; +"2418 dropout_73" -> "2419 view_102" [label="(4, 64, 384)", style=solid]; +"2419 view_102" -> "2420 permute_85" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"2420 permute_85" -> "2421 reshape_84" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"2421 reshape_84" -> "2422 slice_274" [label="(1, 16, 16, 384)", style=solid]; +"2422 slice_274" -> "2423 slice_275" [label="(1, 16, 16, 384)", style=solid]; +"2423 slice_275" -> "2424 slice_276" [label="(1, 14, 16, 384)", style=solid]; +"2424 slice_276" -> "2425 slice_277" [label="(1, 14, 14, 384)", style=solid]; +"2425 slice_277" -> "2426 contiguous_35" [label="(1, 14, 14, 384)", style=solid]; +"2426 contiguous_35" -> "2427 layer_norm_39" [label="(1, 14, 14, 384)", style=solid]; +"2427 layer_norm_39" -> "2428 add_64" [label="(1, 14, 14, 384)", style=solid]; +"2428 add_64" -> "2429 add_64_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 384)", style=solid]; +"2428 add_64" -> "2449 add_65" [label="(1, 14, 14, 384)", style=solid]; +"2429 add_64_0_0_nncf_smooth_quant_0" -> "2430 quantize_per_tensor_default_115" [label="(1, 14, 14, 384)", style=solid]; +"2430 quantize_per_tensor_default_115" -> "2431 dequantize_per_tensor_default_115" [label="(1, 14, 14, 384)", style=solid]; +"2431 dequantize_per_tensor_default_115" -> "2436 linear_114" [label="(1, 14, 14, 384)", style=solid]; +"2432 linear_114_scale_0" -> "2435 dequantize_per_channel_default_115" [label="(1536,)", style=solid]; +"2433 linear_114_zero_point_0" -> "2435 dequantize_per_channel_default_115" [label="(1536,)", style=solid]; +"2434 _frozen_param115" -> "2435 dequantize_per_channel_default_115" [label="(1536, 384)", style=solid]; +"2435 dequantize_per_channel_default_115" -> "2436 linear_114" [label="(1536, 384)", style=solid]; +"2436 linear_114" -> "2437 gelu_18" [label="(1, 14, 14, 1536)", style=solid]; +"2437 gelu_18" -> "2438 dropout_74" [label="(1, 14, 14, 1536)", style=solid]; +"2438 dropout_74" -> "2439 dropout_74_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 1536)", style=solid]; +"2439 dropout_74_0_0_nncf_smooth_quant_0" -> "2440 quantize_per_tensor_default_116" [label="(1, 14, 14, 1536)", style=solid]; +"2440 quantize_per_tensor_default_116" -> "2441 dequantize_per_tensor_default_116" [label="(1, 14, 14, 1536)", style=solid]; +"2441 dequantize_per_tensor_default_116" -> "2446 linear_115" [label="(1, 14, 14, 1536)", style=solid]; +"2442 linear_115_scale_0" -> "2445 dequantize_per_channel_default_116" [label="(384,)", style=solid]; +"2443 linear_115_zero_point_0" -> "2445 dequantize_per_channel_default_116" [label="(384,)", style=solid]; +"2444 _frozen_param116" -> "2445 dequantize_per_channel_default_116" [label="(384, 1536)", style=solid]; +"2445 dequantize_per_channel_default_116" -> "2446 linear_115" [label="(384, 1536)", style=solid]; +"2446 linear_115" -> "2447 dropout_75" [label="(1, 14, 14, 384)", style=solid]; +"2447 dropout_75" -> "2448 layer_norm_40" [label="(1, 14, 14, 384)", style=solid]; +"2448 layer_norm_40" -> "2449 add_65" [label="(1, 14, 14, 384)", style=solid]; +"2449 add_65" -> "2471 pad_21" [label="(1, 14, 14, 384)", style=solid]; +"2449 add_65" -> "2548 add_68" [label="(1, 14, 14, 384)", style=solid]; +"2450 features_5_15_attn_relative_coords_table_0_0_nncf_smooth_quant_0" -> "2455 linear_116" [label="(1, 15, 15, 2)", style=solid]; +"2451 linear_116_scale_0" -> "2454 dequantize_per_channel_default_117" [label="(512,)", style=solid]; +"2452 linear_116_zero_point_0" -> "2454 dequantize_per_channel_default_117" [label="(512,)", style=solid]; +"2453 _frozen_param117" -> "2454 dequantize_per_channel_default_117" [label="(512, 2)", style=solid]; +"2454 dequantize_per_channel_default_117" -> "2455 linear_116" [label="(512, 2)", style=solid]; +"2455 linear_116" -> "2456 relu__19" [label="(1, 15, 15, 512)", style=solid]; +"2456 relu__19" -> "2457 relu__19_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 512)", style=solid]; +"2457 relu__19_0_0_nncf_smooth_quant_0" -> "2462 linear_117" [label="(1, 15, 15, 512)", style=solid]; +"2458 linear_117_scale_0" -> "2461 dequantize_per_channel_default_118" [label="(12,)", style=solid]; +"2459 linear_117_zero_point_0" -> "2461 dequantize_per_channel_default_118" [label="(12,)", style=solid]; +"2460 _frozen_param118" -> "2461 dequantize_per_channel_default_118" [label="(12, 512)", style=solid]; +"2461 dequantize_per_channel_default_118" -> "2462 linear_117" [label="(12, 512)", style=solid]; +"2462 linear_117" -> "2463 view_103" [label="(1, 15, 15, 12)", style=solid]; +"2463 view_103" -> "2464 index_19" [label="(225, 12)", style=solid]; +"2464 index_19" -> "2465 view_104" [label="(4096, 12)", style=solid]; +"2465 view_104" -> "2466 permute_86" [label="(64, 64, 12)", style=solid]; +"2466 permute_86" -> "2467 contiguous_36" [label="(12, 64, 64)", style=solid]; +"2467 contiguous_36" -> "2468 unsqueeze_55" [label="(12, 64, 64)", style=solid]; +"2468 unsqueeze_55" -> "2469 sigmoid_19" [label="(1, 12, 64, 64)", style=solid]; +"2469 sigmoid_19" -> "2470 mul_38" [label="(1, 12, 64, 64)", style=solid]; +"2470 mul_38" -> "2507 add_66" [label="(1, 12, 64, 64)", style=solid]; +"2471 pad_21" -> "2472 roll_18" [label="(1, 16, 16, 384)", style=solid]; +"2472 roll_18" -> "2473 view_105" [label="(1, 16, 16, 384)", style=solid]; +"2473 view_105" -> "2474 permute_87" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"2474 permute_87" -> "2475 reshape_85" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"2475 reshape_85" -> "2477 reshape_85_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"2475 reshape_85" -> "2508 new_zeros_9" [label="(4, 64, 384)", style=solid]; +"2476 clone_19" -> "2484 linear_118" [label="(1152,)", style=solid]; +"2477 reshape_85_0_0_nncf_smooth_quant_0" -> "2478 quantize_per_tensor_default_117" [label="(4, 64, 384)", style=solid]; +"2478 quantize_per_tensor_default_117" -> "2479 dequantize_per_tensor_default_117" [label="(4, 64, 384)", style=solid]; +"2479 dequantize_per_tensor_default_117" -> "2484 linear_118" [label="(4, 64, 384)", style=solid]; +"2480 linear_118_scale_0" -> "2483 dequantize_per_channel_default_119" [label="(1152,)", style=solid]; +"2481 linear_118_zero_point_0" -> "2483 dequantize_per_channel_default_119" [label="(1152,)", style=solid]; +"2482 _frozen_param119" -> "2483 dequantize_per_channel_default_119" [label="(1152, 384)", style=solid]; +"2483 dequantize_per_channel_default_119" -> "2484 linear_118" [label="(1152, 384)", style=solid]; +"2484 linear_118" -> "2485 reshape_86" [label="(4, 64, 1152)", style=solid]; +"2485 reshape_86" -> "2486 permute_88" [label="(4, 64, 3, 12, 32)", style=solid]; +"2486 permute_88" -> "2487 select_57" [label="(3, 4, 12, 64, 32)", style=solid]; +"2486 permute_88" -> "2488 select_58" [label="(3, 4, 12, 64, 32)", style=solid]; +"2486 permute_88" -> "2489 select_59" [label="(3, 4, 12, 64, 32)", style=solid]; +"2487 select_57" -> "2490 linalg_vector_norm_38" [label="(4, 12, 64, 32)", style=solid]; +"2487 select_57" -> "2492 expand_as_38" [label="(4, 12, 64, 32)", style=solid]; +"2487 select_57" -> "2493 div_38" [label="(4, 12, 64, 32)", style=solid]; +"2488 select_58" -> "2496 linalg_vector_norm_39" [label="(4, 12, 64, 32)", style=solid]; +"2488 select_58" -> "2498 expand_as_39" [label="(4, 12, 64, 32)", style=solid]; +"2488 select_58" -> "2499 div_39" [label="(4, 12, 64, 32)", style=solid]; +"2489 select_59" -> "2526 matmul_39" [label="(4, 12, 64, 32)", style=solid]; +"2490 linalg_vector_norm_38" -> "2491 clamp_min_38" [label="(4, 12, 64, 1)", style=solid]; +"2491 clamp_min_38" -> "2492 expand_as_38" [label="(4, 12, 64, 1)", style=solid]; +"2492 expand_as_38" -> "2493 div_38" [label="(4, 12, 64, 32)", style=solid]; +"2493 div_38" -> "2494 quantize_per_tensor_default_118" [label="(4, 12, 64, 32)", style=solid]; +"2494 quantize_per_tensor_default_118" -> "2495 dequantize_per_tensor_default_118" [label="(4, 12, 64, 32)", style=solid]; +"2495 dequantize_per_tensor_default_118" -> "2503 matmul_38" [label="(4, 12, 64, 32)", style=solid]; +"2496 linalg_vector_norm_39" -> "2497 clamp_min_39" [label="(4, 12, 64, 1)", style=solid]; +"2497 clamp_min_39" -> "2498 expand_as_39" [label="(4, 12, 64, 1)", style=solid]; +"2498 expand_as_39" -> "2499 div_39" [label="(4, 12, 64, 32)", style=solid]; +"2499 div_39" -> "2500 quantize_per_tensor_default_119" [label="(4, 12, 64, 32)", style=solid]; +"2500 quantize_per_tensor_default_119" -> "2501 dequantize_per_tensor_default_119" [label="(4, 12, 64, 32)", style=solid]; +"2501 dequantize_per_tensor_default_119" -> "2502 transpose_38" [label="(4, 12, 64, 32)", style=solid]; +"2502 transpose_38" -> "2503 matmul_38" [label="(4, 12, 32, 64)", style=solid]; +"2503 matmul_38" -> "2506 mul_39" [label="(4, 12, 64, 64)", style=solid]; +"2504 clamp_19" -> "2505 exp_19" [label="(12, 1, 1)", style=solid]; +"2505 exp_19" -> "2506 mul_39" [label="(12, 1, 1)", style=solid]; +"2506 mul_39" -> "2507 add_66" [label="(4, 12, 64, 64)", style=solid]; +"2507 add_66" -> "2519 view_107" [label="(4, 12, 64, 64)", style=solid]; +"2508 new_zeros_9" -> "2509 view_106" [label="(16, 16)", style=solid]; +"2509 view_106" -> "2510 permute_89" [label="(2, 8, 2, 8)", style=solid]; +"2510 permute_89" -> "2511 reshape_87" [label="(2, 2, 8, 8)", style=solid]; +"2511 reshape_87" -> "2512 unsqueeze_56" [label="(4, 64)", style=solid]; +"2511 reshape_87" -> "2513 unsqueeze_57" [label="(4, 64)", style=solid]; +"2512 unsqueeze_56" -> "2514 sub_9" [label="(4, 1, 64)", style=solid]; +"2513 unsqueeze_57" -> "2514 sub_9" [label="(4, 64, 1)", style=solid]; +"2514 sub_9" -> "2515 ne_9" [label="(4, 64, 64)", style=solid]; +"2514 sub_9" -> "2516 masked_fill_18" [label="(4, 64, 64)", style=solid]; +"2514 sub_9" -> "2517 eq_9" [label="(4, 64, 64)", style=solid]; +"2515 ne_9" -> "2516 masked_fill_18" [label="(4, 64, 64)", style=solid]; +"2516 masked_fill_18" -> "2518 masked_fill_19" [label="(4, 64, 64)", style=solid]; +"2517 eq_9" -> "2518 masked_fill_19" [label="(4, 64, 64)", style=solid]; +"2518 masked_fill_19" -> "2520 unsqueeze_58" [label="(4, 64, 64)", style=solid]; +"2519 view_107" -> "2522 add_67" [label="(1, 4, 12, 64, 64)", style=solid]; +"2520 unsqueeze_58" -> "2521 unsqueeze_59" [label="(4, 1, 64, 64)", style=solid]; +"2521 unsqueeze_59" -> "2522 add_67" [label="(1, 4, 1, 64, 64)", style=solid]; +"2522 add_67" -> "2523 view_108" [label="(1, 4, 12, 64, 64)", style=solid]; +"2523 view_108" -> "2524 softmax_19" [label="(4, 12, 64, 64)", style=solid]; +"2524 softmax_19" -> "2525 dropout_76" [label="(4, 12, 64, 64)", style=solid]; +"2525 dropout_76" -> "2526 matmul_39" [label="(4, 12, 64, 64)", style=solid]; +"2526 matmul_39" -> "2527 transpose_39" [label="(4, 12, 64, 32)", style=solid]; +"2527 transpose_39" -> "2528 reshape_88" [label="(4, 64, 12, 32)", style=solid]; +"2528 reshape_88" -> "2529 reshape_88_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"2529 reshape_88_0_0_nncf_smooth_quant_0" -> "2530 quantize_per_tensor_default_120" [label="(4, 64, 384)", style=solid]; +"2530 quantize_per_tensor_default_120" -> "2531 dequantize_per_tensor_default_120" [label="(4, 64, 384)", style=solid]; +"2531 dequantize_per_tensor_default_120" -> "2536 linear_119" [label="(4, 64, 384)", style=solid]; +"2532 linear_119_scale_0" -> "2535 dequantize_per_channel_default_120" [label="(384,)", style=solid]; +"2533 linear_119_zero_point_0" -> "2535 dequantize_per_channel_default_120" [label="(384,)", style=solid]; +"2534 _frozen_param120" -> "2535 dequantize_per_channel_default_120" [label="(384, 384)", style=solid]; +"2535 dequantize_per_channel_default_120" -> "2536 linear_119" [label="(384, 384)", style=solid]; +"2536 linear_119" -> "2537 dropout_77" [label="(4, 64, 384)", style=solid]; +"2537 dropout_77" -> "2538 view_109" [label="(4, 64, 384)", style=solid]; +"2538 view_109" -> "2539 permute_90" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"2539 permute_90" -> "2540 reshape_89" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"2540 reshape_89" -> "2541 roll_19" [label="(1, 16, 16, 384)", style=solid]; +"2541 roll_19" -> "2542 slice_297" [label="(1, 16, 16, 384)", style=solid]; +"2542 slice_297" -> "2543 slice_298" [label="(1, 16, 16, 384)", style=solid]; +"2543 slice_298" -> "2544 slice_299" [label="(1, 14, 16, 384)", style=solid]; +"2544 slice_299" -> "2545 slice_300" [label="(1, 14, 14, 384)", style=solid]; +"2545 slice_300" -> "2546 contiguous_37" [label="(1, 14, 14, 384)", style=solid]; +"2546 contiguous_37" -> "2547 layer_norm_41" [label="(1, 14, 14, 384)", style=solid]; +"2547 layer_norm_41" -> "2548 add_68" [label="(1, 14, 14, 384)", style=solid]; +"2548 add_68" -> "2549 add_68_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 384)", style=solid]; +"2548 add_68" -> "2569 add_69" [label="(1, 14, 14, 384)", style=solid]; +"2549 add_68_0_0_nncf_smooth_quant_0" -> "2550 quantize_per_tensor_default_121" [label="(1, 14, 14, 384)", style=solid]; +"2550 quantize_per_tensor_default_121" -> "2551 dequantize_per_tensor_default_121" [label="(1, 14, 14, 384)", style=solid]; +"2551 dequantize_per_tensor_default_121" -> "2556 linear_120" [label="(1, 14, 14, 384)", style=solid]; +"2552 linear_120_scale_0" -> "2555 dequantize_per_channel_default_121" [label="(1536,)", style=solid]; +"2553 linear_120_zero_point_0" -> "2555 dequantize_per_channel_default_121" [label="(1536,)", style=solid]; +"2554 _frozen_param121" -> "2555 dequantize_per_channel_default_121" [label="(1536, 384)", style=solid]; +"2555 dequantize_per_channel_default_121" -> "2556 linear_120" [label="(1536, 384)", style=solid]; +"2556 linear_120" -> "2557 gelu_19" [label="(1, 14, 14, 1536)", style=solid]; +"2557 gelu_19" -> "2558 dropout_78" [label="(1, 14, 14, 1536)", style=solid]; +"2558 dropout_78" -> "2559 dropout_78_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 1536)", style=solid]; +"2559 dropout_78_0_0_nncf_smooth_quant_0" -> "2560 quantize_per_tensor_default_122" [label="(1, 14, 14, 1536)", style=solid]; +"2560 quantize_per_tensor_default_122" -> "2561 dequantize_per_tensor_default_122" [label="(1, 14, 14, 1536)", style=solid]; +"2561 dequantize_per_tensor_default_122" -> "2566 linear_121" [label="(1, 14, 14, 1536)", style=solid]; +"2562 linear_121_scale_0" -> "2565 dequantize_per_channel_default_122" [label="(384,)", style=solid]; +"2563 linear_121_zero_point_0" -> "2565 dequantize_per_channel_default_122" [label="(384,)", style=solid]; +"2564 _frozen_param122" -> "2565 dequantize_per_channel_default_122" [label="(384, 1536)", style=solid]; +"2565 dequantize_per_channel_default_122" -> "2566 linear_121" [label="(384, 1536)", style=solid]; +"2566 linear_121" -> "2567 dropout_79" [label="(1, 14, 14, 384)", style=solid]; +"2567 dropout_79" -> "2568 layer_norm_42" [label="(1, 14, 14, 384)", style=solid]; +"2568 layer_norm_42" -> "2569 add_69" [label="(1, 14, 14, 384)", style=solid]; +"2569 add_69" -> "2591 pad_22" [label="(1, 14, 14, 384)", style=solid]; +"2569 add_69" -> "2650 add_71" [label="(1, 14, 14, 384)", style=solid]; +"2570 features_5_16_attn_relative_coords_table_0_0_nncf_smooth_quant_0" -> "2575 linear_122" [label="(1, 15, 15, 2)", style=solid]; +"2571 linear_122_scale_0" -> "2574 dequantize_per_channel_default_123" [label="(512,)", style=solid]; +"2572 linear_122_zero_point_0" -> "2574 dequantize_per_channel_default_123" [label="(512,)", style=solid]; +"2573 _frozen_param123" -> "2574 dequantize_per_channel_default_123" [label="(512, 2)", style=solid]; +"2574 dequantize_per_channel_default_123" -> "2575 linear_122" [label="(512, 2)", style=solid]; +"2575 linear_122" -> "2576 relu__20" [label="(1, 15, 15, 512)", style=solid]; +"2576 relu__20" -> "2577 relu__20_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 512)", style=solid]; +"2577 relu__20_0_0_nncf_smooth_quant_0" -> "2582 linear_123" [label="(1, 15, 15, 512)", style=solid]; +"2578 linear_123_scale_0" -> "2581 dequantize_per_channel_default_124" [label="(12,)", style=solid]; +"2579 linear_123_zero_point_0" -> "2581 dequantize_per_channel_default_124" [label="(12,)", style=solid]; +"2580 _frozen_param124" -> "2581 dequantize_per_channel_default_124" [label="(12, 512)", style=solid]; +"2581 dequantize_per_channel_default_124" -> "2582 linear_123" [label="(12, 512)", style=solid]; +"2582 linear_123" -> "2583 view_110" [label="(1, 15, 15, 12)", style=solid]; +"2583 view_110" -> "2584 index_20" [label="(225, 12)", style=solid]; +"2584 index_20" -> "2585 view_111" [label="(4096, 12)", style=solid]; +"2585 view_111" -> "2586 permute_91" [label="(64, 64, 12)", style=solid]; +"2586 permute_91" -> "2587 contiguous_38" [label="(12, 64, 64)", style=solid]; +"2587 contiguous_38" -> "2588 unsqueeze_60" [label="(12, 64, 64)", style=solid]; +"2588 unsqueeze_60" -> "2589 sigmoid_20" [label="(1, 12, 64, 64)", style=solid]; +"2589 sigmoid_20" -> "2590 mul_40" [label="(1, 12, 64, 64)", style=solid]; +"2590 mul_40" -> "2626 add_70" [label="(1, 12, 64, 64)", style=solid]; +"2591 pad_22" -> "2592 view_112" [label="(1, 16, 16, 384)", style=solid]; +"2592 view_112" -> "2593 permute_92" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"2593 permute_92" -> "2594 reshape_90" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"2594 reshape_90" -> "2596 reshape_90_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"2595 clone_20" -> "2603 linear_124" [label="(1152,)", style=solid]; +"2596 reshape_90_0_0_nncf_smooth_quant_0" -> "2597 quantize_per_tensor_default_123" [label="(4, 64, 384)", style=solid]; +"2597 quantize_per_tensor_default_123" -> "2598 dequantize_per_tensor_default_123" [label="(4, 64, 384)", style=solid]; +"2598 dequantize_per_tensor_default_123" -> "2603 linear_124" [label="(4, 64, 384)", style=solid]; +"2599 linear_124_scale_0" -> "2602 dequantize_per_channel_default_125" [label="(1152,)", style=solid]; +"2600 linear_124_zero_point_0" -> "2602 dequantize_per_channel_default_125" [label="(1152,)", style=solid]; +"2601 _frozen_param125" -> "2602 dequantize_per_channel_default_125" [label="(1152, 384)", style=solid]; +"2602 dequantize_per_channel_default_125" -> "2603 linear_124" [label="(1152, 384)", style=solid]; +"2603 linear_124" -> "2604 reshape_91" [label="(4, 64, 1152)", style=solid]; +"2604 reshape_91" -> "2605 permute_93" [label="(4, 64, 3, 12, 32)", style=solid]; +"2605 permute_93" -> "2606 select_60" [label="(3, 4, 12, 64, 32)", style=solid]; +"2605 permute_93" -> "2607 select_61" [label="(3, 4, 12, 64, 32)", style=solid]; +"2605 permute_93" -> "2608 select_62" [label="(3, 4, 12, 64, 32)", style=solid]; +"2606 select_60" -> "2609 linalg_vector_norm_40" [label="(4, 12, 64, 32)", style=solid]; +"2606 select_60" -> "2611 expand_as_40" [label="(4, 12, 64, 32)", style=solid]; +"2606 select_60" -> "2612 div_40" [label="(4, 12, 64, 32)", style=solid]; +"2607 select_61" -> "2615 linalg_vector_norm_41" [label="(4, 12, 64, 32)", style=solid]; +"2607 select_61" -> "2617 expand_as_41" [label="(4, 12, 64, 32)", style=solid]; +"2607 select_61" -> "2618 div_41" [label="(4, 12, 64, 32)", style=solid]; +"2608 select_62" -> "2629 matmul_41" [label="(4, 12, 64, 32)", style=solid]; +"2609 linalg_vector_norm_40" -> "2610 clamp_min_40" [label="(4, 12, 64, 1)", style=solid]; +"2610 clamp_min_40" -> "2611 expand_as_40" [label="(4, 12, 64, 1)", style=solid]; +"2611 expand_as_40" -> "2612 div_40" [label="(4, 12, 64, 32)", style=solid]; +"2612 div_40" -> "2613 quantize_per_tensor_default_124" [label="(4, 12, 64, 32)", style=solid]; +"2613 quantize_per_tensor_default_124" -> "2614 dequantize_per_tensor_default_124" [label="(4, 12, 64, 32)", style=solid]; +"2614 dequantize_per_tensor_default_124" -> "2622 matmul_40" [label="(4, 12, 64, 32)", style=solid]; +"2615 linalg_vector_norm_41" -> "2616 clamp_min_41" [label="(4, 12, 64, 1)", style=solid]; +"2616 clamp_min_41" -> "2617 expand_as_41" [label="(4, 12, 64, 1)", style=solid]; +"2617 expand_as_41" -> "2618 div_41" [label="(4, 12, 64, 32)", style=solid]; +"2618 div_41" -> "2619 quantize_per_tensor_default_125" [label="(4, 12, 64, 32)", style=solid]; +"2619 quantize_per_tensor_default_125" -> "2620 dequantize_per_tensor_default_125" [label="(4, 12, 64, 32)", style=solid]; +"2620 dequantize_per_tensor_default_125" -> "2621 transpose_40" [label="(4, 12, 64, 32)", style=solid]; +"2621 transpose_40" -> "2622 matmul_40" [label="(4, 12, 32, 64)", style=solid]; +"2622 matmul_40" -> "2625 mul_41" [label="(4, 12, 64, 64)", style=solid]; +"2623 clamp_20" -> "2624 exp_20" [label="(12, 1, 1)", style=solid]; +"2624 exp_20" -> "2625 mul_41" [label="(12, 1, 1)", style=solid]; +"2625 mul_41" -> "2626 add_70" [label="(4, 12, 64, 64)", style=solid]; +"2626 add_70" -> "2627 softmax_20" [label="(4, 12, 64, 64)", style=solid]; +"2627 softmax_20" -> "2628 dropout_80" [label="(4, 12, 64, 64)", style=solid]; +"2628 dropout_80" -> "2629 matmul_41" [label="(4, 12, 64, 64)", style=solid]; +"2629 matmul_41" -> "2630 transpose_41" [label="(4, 12, 64, 32)", style=solid]; +"2630 transpose_41" -> "2631 reshape_92" [label="(4, 64, 12, 32)", style=solid]; +"2631 reshape_92" -> "2632 reshape_92_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"2632 reshape_92_0_0_nncf_smooth_quant_0" -> "2633 quantize_per_tensor_default_126" [label="(4, 64, 384)", style=solid]; +"2633 quantize_per_tensor_default_126" -> "2634 dequantize_per_tensor_default_126" [label="(4, 64, 384)", style=solid]; +"2634 dequantize_per_tensor_default_126" -> "2639 linear_125" [label="(4, 64, 384)", style=solid]; +"2635 linear_125_scale_0" -> "2638 dequantize_per_channel_default_126" [label="(384,)", style=solid]; +"2636 linear_125_zero_point_0" -> "2638 dequantize_per_channel_default_126" [label="(384,)", style=solid]; +"2637 _frozen_param126" -> "2638 dequantize_per_channel_default_126" [label="(384, 384)", style=solid]; +"2638 dequantize_per_channel_default_126" -> "2639 linear_125" [label="(384, 384)", style=solid]; +"2639 linear_125" -> "2640 dropout_81" [label="(4, 64, 384)", style=solid]; +"2640 dropout_81" -> "2641 view_113" [label="(4, 64, 384)", style=solid]; +"2641 view_113" -> "2642 permute_94" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"2642 permute_94" -> "2643 reshape_93" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"2643 reshape_93" -> "2644 slice_302" [label="(1, 16, 16, 384)", style=solid]; +"2644 slice_302" -> "2645 slice_303" [label="(1, 16, 16, 384)", style=solid]; +"2645 slice_303" -> "2646 slice_304" [label="(1, 14, 16, 384)", style=solid]; +"2646 slice_304" -> "2647 slice_305" [label="(1, 14, 14, 384)", style=solid]; +"2647 slice_305" -> "2648 contiguous_39" [label="(1, 14, 14, 384)", style=solid]; +"2648 contiguous_39" -> "2649 layer_norm_43" [label="(1, 14, 14, 384)", style=solid]; +"2649 layer_norm_43" -> "2650 add_71" [label="(1, 14, 14, 384)", style=solid]; +"2650 add_71" -> "2651 add_71_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 384)", style=solid]; +"2650 add_71" -> "2671 add_72" [label="(1, 14, 14, 384)", style=solid]; +"2651 add_71_0_0_nncf_smooth_quant_0" -> "2652 quantize_per_tensor_default_127" [label="(1, 14, 14, 384)", style=solid]; +"2652 quantize_per_tensor_default_127" -> "2653 dequantize_per_tensor_default_127" [label="(1, 14, 14, 384)", style=solid]; +"2653 dequantize_per_tensor_default_127" -> "2658 linear_126" [label="(1, 14, 14, 384)", style=solid]; +"2654 linear_126_scale_0" -> "2657 dequantize_per_channel_default_127" [label="(1536,)", style=solid]; +"2655 linear_126_zero_point_0" -> "2657 dequantize_per_channel_default_127" [label="(1536,)", style=solid]; +"2656 _frozen_param127" -> "2657 dequantize_per_channel_default_127" [label="(1536, 384)", style=solid]; +"2657 dequantize_per_channel_default_127" -> "2658 linear_126" [label="(1536, 384)", style=solid]; +"2658 linear_126" -> "2659 gelu_20" [label="(1, 14, 14, 1536)", style=solid]; +"2659 gelu_20" -> "2660 dropout_82" [label="(1, 14, 14, 1536)", style=solid]; +"2660 dropout_82" -> "2661 dropout_82_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 1536)", style=solid]; +"2661 dropout_82_0_0_nncf_smooth_quant_0" -> "2662 quantize_per_tensor_default_128" [label="(1, 14, 14, 1536)", style=solid]; +"2662 quantize_per_tensor_default_128" -> "2663 dequantize_per_tensor_default_128" [label="(1, 14, 14, 1536)", style=solid]; +"2663 dequantize_per_tensor_default_128" -> "2668 linear_127" [label="(1, 14, 14, 1536)", style=solid]; +"2664 linear_127_scale_0" -> "2667 dequantize_per_channel_default_128" [label="(384,)", style=solid]; +"2665 linear_127_zero_point_0" -> "2667 dequantize_per_channel_default_128" [label="(384,)", style=solid]; +"2666 _frozen_param128" -> "2667 dequantize_per_channel_default_128" [label="(384, 1536)", style=solid]; +"2667 dequantize_per_channel_default_128" -> "2668 linear_127" [label="(384, 1536)", style=solid]; +"2668 linear_127" -> "2669 dropout_83" [label="(1, 14, 14, 384)", style=solid]; +"2669 dropout_83" -> "2670 layer_norm_44" [label="(1, 14, 14, 384)", style=solid]; +"2670 layer_norm_44" -> "2671 add_72" [label="(1, 14, 14, 384)", style=solid]; +"2671 add_72" -> "2693 pad_23" [label="(1, 14, 14, 384)", style=solid]; +"2671 add_72" -> "2770 add_75" [label="(1, 14, 14, 384)", style=solid]; +"2672 features_5_17_attn_relative_coords_table_0_0_nncf_smooth_quant_0" -> "2677 linear_128" [label="(1, 15, 15, 2)", style=solid]; +"2673 linear_128_scale_0" -> "2676 dequantize_per_channel_default_129" [label="(512,)", style=solid]; +"2674 linear_128_zero_point_0" -> "2676 dequantize_per_channel_default_129" [label="(512,)", style=solid]; +"2675 _frozen_param129" -> "2676 dequantize_per_channel_default_129" [label="(512, 2)", style=solid]; +"2676 dequantize_per_channel_default_129" -> "2677 linear_128" [label="(512, 2)", style=solid]; +"2677 linear_128" -> "2678 relu__21" [label="(1, 15, 15, 512)", style=solid]; +"2678 relu__21" -> "2679 relu__21_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 512)", style=solid]; +"2679 relu__21_0_0_nncf_smooth_quant_0" -> "2684 linear_129" [label="(1, 15, 15, 512)", style=solid]; +"2680 linear_129_scale_0" -> "2683 dequantize_per_channel_default_130" [label="(12,)", style=solid]; +"2681 linear_129_zero_point_0" -> "2683 dequantize_per_channel_default_130" [label="(12,)", style=solid]; +"2682 _frozen_param130" -> "2683 dequantize_per_channel_default_130" [label="(12, 512)", style=solid]; +"2683 dequantize_per_channel_default_130" -> "2684 linear_129" [label="(12, 512)", style=solid]; +"2684 linear_129" -> "2685 view_114" [label="(1, 15, 15, 12)", style=solid]; +"2685 view_114" -> "2686 index_21" [label="(225, 12)", style=solid]; +"2686 index_21" -> "2687 view_115" [label="(4096, 12)", style=solid]; +"2687 view_115" -> "2688 permute_95" [label="(64, 64, 12)", style=solid]; +"2688 permute_95" -> "2689 contiguous_40" [label="(12, 64, 64)", style=solid]; +"2689 contiguous_40" -> "2690 unsqueeze_61" [label="(12, 64, 64)", style=solid]; +"2690 unsqueeze_61" -> "2691 sigmoid_21" [label="(1, 12, 64, 64)", style=solid]; +"2691 sigmoid_21" -> "2692 mul_42" [label="(1, 12, 64, 64)", style=solid]; +"2692 mul_42" -> "2729 add_73" [label="(1, 12, 64, 64)", style=solid]; +"2693 pad_23" -> "2694 roll_20" [label="(1, 16, 16, 384)", style=solid]; +"2694 roll_20" -> "2695 view_116" [label="(1, 16, 16, 384)", style=solid]; +"2695 view_116" -> "2696 permute_96" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"2696 permute_96" -> "2697 reshape_94" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"2697 reshape_94" -> "2699 reshape_94_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"2697 reshape_94" -> "2730 new_zeros_10" [label="(4, 64, 384)", style=solid]; +"2698 clone_21" -> "2706 linear_130" [label="(1152,)", style=solid]; +"2699 reshape_94_0_0_nncf_smooth_quant_0" -> "2700 quantize_per_tensor_default_129" [label="(4, 64, 384)", style=solid]; +"2700 quantize_per_tensor_default_129" -> "2701 dequantize_per_tensor_default_129" [label="(4, 64, 384)", style=solid]; +"2701 dequantize_per_tensor_default_129" -> "2706 linear_130" [label="(4, 64, 384)", style=solid]; +"2702 linear_130_scale_0" -> "2705 dequantize_per_channel_default_131" [label="(1152,)", style=solid]; +"2703 linear_130_zero_point_0" -> "2705 dequantize_per_channel_default_131" [label="(1152,)", style=solid]; +"2704 _frozen_param131" -> "2705 dequantize_per_channel_default_131" [label="(1152, 384)", style=solid]; +"2705 dequantize_per_channel_default_131" -> "2706 linear_130" [label="(1152, 384)", style=solid]; +"2706 linear_130" -> "2707 reshape_95" [label="(4, 64, 1152)", style=solid]; +"2707 reshape_95" -> "2708 permute_97" [label="(4, 64, 3, 12, 32)", style=solid]; +"2708 permute_97" -> "2709 select_63" [label="(3, 4, 12, 64, 32)", style=solid]; +"2708 permute_97" -> "2710 select_64" [label="(3, 4, 12, 64, 32)", style=solid]; +"2708 permute_97" -> "2711 select_65" [label="(3, 4, 12, 64, 32)", style=solid]; +"2709 select_63" -> "2712 linalg_vector_norm_42" [label="(4, 12, 64, 32)", style=solid]; +"2709 select_63" -> "2714 expand_as_42" [label="(4, 12, 64, 32)", style=solid]; +"2709 select_63" -> "2715 div_42" [label="(4, 12, 64, 32)", style=solid]; +"2710 select_64" -> "2718 linalg_vector_norm_43" [label="(4, 12, 64, 32)", style=solid]; +"2710 select_64" -> "2720 expand_as_43" [label="(4, 12, 64, 32)", style=solid]; +"2710 select_64" -> "2721 div_43" [label="(4, 12, 64, 32)", style=solid]; +"2711 select_65" -> "2748 matmul_43" [label="(4, 12, 64, 32)", style=solid]; +"2712 linalg_vector_norm_42" -> "2713 clamp_min_42" [label="(4, 12, 64, 1)", style=solid]; +"2713 clamp_min_42" -> "2714 expand_as_42" [label="(4, 12, 64, 1)", style=solid]; +"2714 expand_as_42" -> "2715 div_42" [label="(4, 12, 64, 32)", style=solid]; +"2715 div_42" -> "2716 quantize_per_tensor_default_130" [label="(4, 12, 64, 32)", style=solid]; +"2716 quantize_per_tensor_default_130" -> "2717 dequantize_per_tensor_default_130" [label="(4, 12, 64, 32)", style=solid]; +"2717 dequantize_per_tensor_default_130" -> "2725 matmul_42" [label="(4, 12, 64, 32)", style=solid]; +"2718 linalg_vector_norm_43" -> "2719 clamp_min_43" [label="(4, 12, 64, 1)", style=solid]; +"2719 clamp_min_43" -> "2720 expand_as_43" [label="(4, 12, 64, 1)", style=solid]; +"2720 expand_as_43" -> "2721 div_43" [label="(4, 12, 64, 32)", style=solid]; +"2721 div_43" -> "2722 quantize_per_tensor_default_131" [label="(4, 12, 64, 32)", style=solid]; +"2722 quantize_per_tensor_default_131" -> "2723 dequantize_per_tensor_default_131" [label="(4, 12, 64, 32)", style=solid]; +"2723 dequantize_per_tensor_default_131" -> "2724 transpose_42" [label="(4, 12, 64, 32)", style=solid]; +"2724 transpose_42" -> "2725 matmul_42" [label="(4, 12, 32, 64)", style=solid]; +"2725 matmul_42" -> "2728 mul_43" [label="(4, 12, 64, 64)", style=solid]; +"2726 clamp_21" -> "2727 exp_21" [label="(12, 1, 1)", style=solid]; +"2727 exp_21" -> "2728 mul_43" [label="(12, 1, 1)", style=solid]; +"2728 mul_43" -> "2729 add_73" [label="(4, 12, 64, 64)", style=solid]; +"2729 add_73" -> "2741 view_118" [label="(4, 12, 64, 64)", style=solid]; +"2730 new_zeros_10" -> "2731 view_117" [label="(16, 16)", style=solid]; +"2731 view_117" -> "2732 permute_98" [label="(2, 8, 2, 8)", style=solid]; +"2732 permute_98" -> "2733 reshape_96" [label="(2, 2, 8, 8)", style=solid]; +"2733 reshape_96" -> "2734 unsqueeze_62" [label="(4, 64)", style=solid]; +"2733 reshape_96" -> "2735 unsqueeze_63" [label="(4, 64)", style=solid]; +"2734 unsqueeze_62" -> "2736 sub_10" [label="(4, 1, 64)", style=solid]; +"2735 unsqueeze_63" -> "2736 sub_10" [label="(4, 64, 1)", style=solid]; +"2736 sub_10" -> "2737 ne_10" [label="(4, 64, 64)", style=solid]; +"2736 sub_10" -> "2738 masked_fill_20" [label="(4, 64, 64)", style=solid]; +"2736 sub_10" -> "2739 eq_10" [label="(4, 64, 64)", style=solid]; +"2737 ne_10" -> "2738 masked_fill_20" [label="(4, 64, 64)", style=solid]; +"2738 masked_fill_20" -> "2740 masked_fill_21" [label="(4, 64, 64)", style=solid]; +"2739 eq_10" -> "2740 masked_fill_21" [label="(4, 64, 64)", style=solid]; +"2740 masked_fill_21" -> "2742 unsqueeze_64" [label="(4, 64, 64)", style=solid]; +"2741 view_118" -> "2744 add_74" [label="(1, 4, 12, 64, 64)", style=solid]; +"2742 unsqueeze_64" -> "2743 unsqueeze_65" [label="(4, 1, 64, 64)", style=solid]; +"2743 unsqueeze_65" -> "2744 add_74" [label="(1, 4, 1, 64, 64)", style=solid]; +"2744 add_74" -> "2745 view_119" [label="(1, 4, 12, 64, 64)", style=solid]; +"2745 view_119" -> "2746 softmax_21" [label="(4, 12, 64, 64)", style=solid]; +"2746 softmax_21" -> "2747 dropout_84" [label="(4, 12, 64, 64)", style=solid]; +"2747 dropout_84" -> "2748 matmul_43" [label="(4, 12, 64, 64)", style=solid]; +"2748 matmul_43" -> "2749 transpose_43" [label="(4, 12, 64, 32)", style=solid]; +"2749 transpose_43" -> "2750 reshape_97" [label="(4, 64, 12, 32)", style=solid]; +"2750 reshape_97" -> "2751 reshape_97_0_0_nncf_smooth_quant_0" [label="(4, 64, 384)", style=solid]; +"2751 reshape_97_0_0_nncf_smooth_quant_0" -> "2752 quantize_per_tensor_default_132" [label="(4, 64, 384)", style=solid]; +"2752 quantize_per_tensor_default_132" -> "2753 dequantize_per_tensor_default_132" [label="(4, 64, 384)", style=solid]; +"2753 dequantize_per_tensor_default_132" -> "2758 linear_131" [label="(4, 64, 384)", style=solid]; +"2754 linear_131_scale_0" -> "2757 dequantize_per_channel_default_132" [label="(384,)", style=solid]; +"2755 linear_131_zero_point_0" -> "2757 dequantize_per_channel_default_132" [label="(384,)", style=solid]; +"2756 _frozen_param132" -> "2757 dequantize_per_channel_default_132" [label="(384, 384)", style=solid]; +"2757 dequantize_per_channel_default_132" -> "2758 linear_131" [label="(384, 384)", style=solid]; +"2758 linear_131" -> "2759 dropout_85" [label="(4, 64, 384)", style=solid]; +"2759 dropout_85" -> "2760 view_120" [label="(4, 64, 384)", style=solid]; +"2760 view_120" -> "2761 permute_99" [label="(1, 2, 2, 8, 8, 384)", style=solid]; +"2761 permute_99" -> "2762 reshape_98" [label="(1, 2, 8, 2, 8, 384)", style=solid]; +"2762 reshape_98" -> "2763 roll_21" [label="(1, 16, 16, 384)", style=solid]; +"2763 roll_21" -> "2764 slice_325" [label="(1, 16, 16, 384)", style=solid]; +"2764 slice_325" -> "2765 slice_326" [label="(1, 16, 16, 384)", style=solid]; +"2765 slice_326" -> "2766 slice_327" [label="(1, 14, 16, 384)", style=solid]; +"2766 slice_327" -> "2767 slice_328" [label="(1, 14, 14, 384)", style=solid]; +"2767 slice_328" -> "2768 contiguous_41" [label="(1, 14, 14, 384)", style=solid]; +"2768 contiguous_41" -> "2769 layer_norm_45" [label="(1, 14, 14, 384)", style=solid]; +"2769 layer_norm_45" -> "2770 add_75" [label="(1, 14, 14, 384)", style=solid]; +"2770 add_75" -> "2771 add_75_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 384)", style=solid]; +"2770 add_75" -> "2791 add_76" [label="(1, 14, 14, 384)", style=solid]; +"2771 add_75_0_0_nncf_smooth_quant_0" -> "2772 quantize_per_tensor_default_133" [label="(1, 14, 14, 384)", style=solid]; +"2772 quantize_per_tensor_default_133" -> "2773 dequantize_per_tensor_default_133" [label="(1, 14, 14, 384)", style=solid]; +"2773 dequantize_per_tensor_default_133" -> "2778 linear_132" [label="(1, 14, 14, 384)", style=solid]; +"2774 linear_132_scale_0" -> "2777 dequantize_per_channel_default_133" [label="(1536,)", style=solid]; +"2775 linear_132_zero_point_0" -> "2777 dequantize_per_channel_default_133" [label="(1536,)", style=solid]; +"2776 _frozen_param133" -> "2777 dequantize_per_channel_default_133" [label="(1536, 384)", style=solid]; +"2777 dequantize_per_channel_default_133" -> "2778 linear_132" [label="(1536, 384)", style=solid]; +"2778 linear_132" -> "2779 gelu_21" [label="(1, 14, 14, 1536)", style=solid]; +"2779 gelu_21" -> "2780 dropout_86" [label="(1, 14, 14, 1536)", style=solid]; +"2780 dropout_86" -> "2781 dropout_86_0_0_nncf_smooth_quant_0" [label="(1, 14, 14, 1536)", style=solid]; +"2781 dropout_86_0_0_nncf_smooth_quant_0" -> "2782 quantize_per_tensor_default_134" [label="(1, 14, 14, 1536)", style=solid]; +"2782 quantize_per_tensor_default_134" -> "2783 dequantize_per_tensor_default_134" [label="(1, 14, 14, 1536)", style=solid]; +"2783 dequantize_per_tensor_default_134" -> "2788 linear_133" [label="(1, 14, 14, 1536)", style=solid]; +"2784 linear_133_scale_0" -> "2787 dequantize_per_channel_default_134" [label="(384,)", style=solid]; +"2785 linear_133_zero_point_0" -> "2787 dequantize_per_channel_default_134" [label="(384,)", style=solid]; +"2786 _frozen_param134" -> "2787 dequantize_per_channel_default_134" [label="(384, 1536)", style=solid]; +"2787 dequantize_per_channel_default_134" -> "2788 linear_133" [label="(384, 1536)", style=solid]; +"2788 linear_133" -> "2789 dropout_87" [label="(1, 14, 14, 384)", style=solid]; +"2789 dropout_87" -> "2790 layer_norm_46" [label="(1, 14, 14, 384)", style=solid]; +"2790 layer_norm_46" -> "2791 add_76" [label="(1, 14, 14, 384)", style=solid]; +"2791 add_76" -> "2792 pad_24" [label="(1, 14, 14, 384)", style=solid]; +"2792 pad_24" -> "2793 slice_329" [label="(1, 14, 14, 384)", style=solid]; +"2792 pad_24" -> "2796 slice_332" [label="(1, 14, 14, 384)", style=solid]; +"2792 pad_24" -> "2799 slice_335" [label="(1, 14, 14, 384)", style=solid]; +"2792 pad_24" -> "2802 slice_338" [label="(1, 14, 14, 384)", style=solid]; +"2793 slice_329" -> "2794 slice_330" [label="(1, 7, 14, 384)", style=solid]; +"2794 slice_330" -> "2795 slice_331" [label="(1, 7, 7, 384)", style=solid]; +"2795 slice_331" -> "2805 cat_2" [label="(1, 7, 7, 384)", style=solid]; +"2796 slice_332" -> "2797 slice_333" [label="(1, 7, 14, 384)", style=solid]; +"2797 slice_333" -> "2798 slice_334" [label="(1, 7, 7, 384)", style=solid]; +"2798 slice_334" -> "2805 cat_2" [label="(1, 7, 7, 384)", style=solid]; +"2799 slice_335" -> "2800 slice_336" [label="(1, 7, 14, 384)", style=solid]; +"2800 slice_336" -> "2801 slice_337" [label="(1, 7, 7, 384)", style=solid]; +"2801 slice_337" -> "2805 cat_2" [label="(1, 7, 7, 384)", style=solid]; +"2802 slice_338" -> "2803 slice_339" [label="(1, 7, 14, 384)", style=solid]; +"2803 slice_339" -> "2804 slice_340" [label="(1, 7, 7, 384)", style=solid]; +"2804 slice_340" -> "2805 cat_2" [label="(1, 7, 7, 384)", style=solid]; +"2805 cat_2" -> "2806 cat_2_0_0_nncf_smooth_quant_0" [label="(1, 7, 7, 1536)", style=solid]; +"2806 cat_2_0_0_nncf_smooth_quant_0" -> "2807 quantize_per_tensor_default_135" [label="(1, 7, 7, 1536)", style=solid]; +"2807 quantize_per_tensor_default_135" -> "2808 dequantize_per_tensor_default_135" [label="(1, 7, 7, 1536)", style=solid]; +"2808 dequantize_per_tensor_default_135" -> "2813 linear_134" [label="(1, 7, 7, 1536)", style=solid]; +"2809 linear_134_scale_0" -> "2812 dequantize_per_channel_default_135" [label="(768,)", style=solid]; +"2810 linear_134_zero_point_0" -> "2812 dequantize_per_channel_default_135" [label="(768,)", style=solid]; +"2811 _frozen_param135" -> "2812 dequantize_per_channel_default_135" [label="(768, 1536)", style=solid]; +"2812 dequantize_per_channel_default_135" -> "2813 linear_134" [label="(768, 1536)", style=solid]; +"2813 linear_134" -> "2814 layer_norm_47" [label="(1, 7, 7, 768)", style=solid]; +"2814 layer_norm_47" -> "2836 pad_25" [label="(1, 7, 7, 768)", style=solid]; +"2814 layer_norm_47" -> "2895 add_78" [label="(1, 7, 7, 768)", style=solid]; +"2815 features_7_0_attn_relative_coords_table_0_0_nncf_smooth_quant_0" -> "2820 linear_135" [label="(1, 15, 15, 2)", style=solid]; +"2816 linear_135_scale_0" -> "2819 dequantize_per_channel_default_136" [label="(512,)", style=solid]; +"2817 linear_135_zero_point_0" -> "2819 dequantize_per_channel_default_136" [label="(512,)", style=solid]; +"2818 _frozen_param136" -> "2819 dequantize_per_channel_default_136" [label="(512, 2)", style=solid]; +"2819 dequantize_per_channel_default_136" -> "2820 linear_135" [label="(512, 2)", style=solid]; +"2820 linear_135" -> "2821 relu__22" [label="(1, 15, 15, 512)", style=solid]; +"2821 relu__22" -> "2822 relu__22_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 512)", style=solid]; +"2822 relu__22_0_0_nncf_smooth_quant_0" -> "2827 linear_136" [label="(1, 15, 15, 512)", style=solid]; +"2823 linear_136_scale_0" -> "2826 dequantize_per_channel_default_137" [label="(24,)", style=solid]; +"2824 linear_136_zero_point_0" -> "2826 dequantize_per_channel_default_137" [label="(24,)", style=solid]; +"2825 _frozen_param137" -> "2826 dequantize_per_channel_default_137" [label="(24, 512)", style=solid]; +"2826 dequantize_per_channel_default_137" -> "2827 linear_136" [label="(24, 512)", style=solid]; +"2827 linear_136" -> "2828 view_121" [label="(1, 15, 15, 24)", style=solid]; +"2828 view_121" -> "2829 index_22" [label="(225, 24)", style=solid]; +"2829 index_22" -> "2830 view_122" [label="(4096, 24)", style=solid]; +"2830 view_122" -> "2831 permute_100" [label="(64, 64, 24)", style=solid]; +"2831 permute_100" -> "2832 contiguous_42" [label="(24, 64, 64)", style=solid]; +"2832 contiguous_42" -> "2833 unsqueeze_66" [label="(24, 64, 64)", style=solid]; +"2833 unsqueeze_66" -> "2834 sigmoid_22" [label="(1, 24, 64, 64)", style=solid]; +"2834 sigmoid_22" -> "2835 mul_44" [label="(1, 24, 64, 64)", style=solid]; +"2835 mul_44" -> "2871 add_77" [label="(1, 24, 64, 64)", style=solid]; +"2836 pad_25" -> "2837 view_123" [label="(1, 8, 8, 768)", style=solid]; +"2837 view_123" -> "2838 permute_101" [label="(1, 1, 8, 1, 8, 768)", style=solid]; +"2838 permute_101" -> "2839 reshape_99" [label="(1, 1, 1, 8, 8, 768)", style=solid]; +"2839 reshape_99" -> "2841 reshape_99_0_0_nncf_smooth_quant_0" [label="(1, 64, 768)", style=solid]; +"2840 clone_22" -> "2848 linear_137" [label="(2304,)", style=solid]; +"2841 reshape_99_0_0_nncf_smooth_quant_0" -> "2842 quantize_per_tensor_default_136" [label="(1, 64, 768)", style=solid]; +"2842 quantize_per_tensor_default_136" -> "2843 dequantize_per_tensor_default_136" [label="(1, 64, 768)", style=solid]; +"2843 dequantize_per_tensor_default_136" -> "2848 linear_137" [label="(1, 64, 768)", style=solid]; +"2844 linear_137_scale_0" -> "2847 dequantize_per_channel_default_138" [label="(2304,)", style=solid]; +"2845 linear_137_zero_point_0" -> "2847 dequantize_per_channel_default_138" [label="(2304,)", style=solid]; +"2846 _frozen_param138" -> "2847 dequantize_per_channel_default_138" [label="(2304, 768)", style=solid]; +"2847 dequantize_per_channel_default_138" -> "2848 linear_137" [label="(2304, 768)", style=solid]; +"2848 linear_137" -> "2849 reshape_100" [label="(1, 64, 2304)", style=solid]; +"2849 reshape_100" -> "2850 permute_102" [label="(1, 64, 3, 24, 32)", style=solid]; +"2850 permute_102" -> "2851 select_66" [label="(3, 1, 24, 64, 32)", style=solid]; +"2850 permute_102" -> "2852 select_67" [label="(3, 1, 24, 64, 32)", style=solid]; +"2850 permute_102" -> "2853 select_68" [label="(3, 1, 24, 64, 32)", style=solid]; +"2851 select_66" -> "2854 linalg_vector_norm_44" [label="(1, 24, 64, 32)", style=solid]; +"2851 select_66" -> "2856 expand_as_44" [label="(1, 24, 64, 32)", style=solid]; +"2851 select_66" -> "2857 div_44" [label="(1, 24, 64, 32)", style=solid]; +"2852 select_67" -> "2860 linalg_vector_norm_45" [label="(1, 24, 64, 32)", style=solid]; +"2852 select_67" -> "2862 expand_as_45" [label="(1, 24, 64, 32)", style=solid]; +"2852 select_67" -> "2863 div_45" [label="(1, 24, 64, 32)", style=solid]; +"2853 select_68" -> "2874 matmul_45" [label="(1, 24, 64, 32)", style=solid]; +"2854 linalg_vector_norm_44" -> "2855 clamp_min_44" [label="(1, 24, 64, 1)", style=solid]; +"2855 clamp_min_44" -> "2856 expand_as_44" [label="(1, 24, 64, 1)", style=solid]; +"2856 expand_as_44" -> "2857 div_44" [label="(1, 24, 64, 32)", style=solid]; +"2857 div_44" -> "2858 quantize_per_tensor_default_137" [label="(1, 24, 64, 32)", style=solid]; +"2858 quantize_per_tensor_default_137" -> "2859 dequantize_per_tensor_default_137" [label="(1, 24, 64, 32)", style=solid]; +"2859 dequantize_per_tensor_default_137" -> "2867 matmul_44" [label="(1, 24, 64, 32)", style=solid]; +"2860 linalg_vector_norm_45" -> "2861 clamp_min_45" [label="(1, 24, 64, 1)", style=solid]; +"2861 clamp_min_45" -> "2862 expand_as_45" [label="(1, 24, 64, 1)", style=solid]; +"2862 expand_as_45" -> "2863 div_45" [label="(1, 24, 64, 32)", style=solid]; +"2863 div_45" -> "2864 quantize_per_tensor_default_138" [label="(1, 24, 64, 32)", style=solid]; +"2864 quantize_per_tensor_default_138" -> "2865 dequantize_per_tensor_default_138" [label="(1, 24, 64, 32)", style=solid]; +"2865 dequantize_per_tensor_default_138" -> "2866 transpose_44" [label="(1, 24, 64, 32)", style=solid]; +"2866 transpose_44" -> "2867 matmul_44" [label="(1, 24, 32, 64)", style=solid]; +"2867 matmul_44" -> "2870 mul_45" [label="(1, 24, 64, 64)", style=solid]; +"2868 clamp_22" -> "2869 exp_22" [label="(24, 1, 1)", style=solid]; +"2869 exp_22" -> "2870 mul_45" [label="(24, 1, 1)", style=solid]; +"2870 mul_45" -> "2871 add_77" [label="(1, 24, 64, 64)", style=solid]; +"2871 add_77" -> "2872 softmax_22" [label="(1, 24, 64, 64)", style=solid]; +"2872 softmax_22" -> "2873 dropout_88" [label="(1, 24, 64, 64)", style=solid]; +"2873 dropout_88" -> "2874 matmul_45" [label="(1, 24, 64, 64)", style=solid]; +"2874 matmul_45" -> "2875 transpose_45" [label="(1, 24, 64, 32)", style=solid]; +"2875 transpose_45" -> "2876 reshape_101" [label="(1, 64, 24, 32)", style=solid]; +"2876 reshape_101" -> "2877 reshape_101_0_0_nncf_smooth_quant_0" [label="(1, 64, 768)", style=solid]; +"2877 reshape_101_0_0_nncf_smooth_quant_0" -> "2878 quantize_per_tensor_default_139" [label="(1, 64, 768)", style=solid]; +"2878 quantize_per_tensor_default_139" -> "2879 dequantize_per_tensor_default_139" [label="(1, 64, 768)", style=solid]; +"2879 dequantize_per_tensor_default_139" -> "2884 linear_138" [label="(1, 64, 768)", style=solid]; +"2880 linear_138_scale_0" -> "2883 dequantize_per_channel_default_139" [label="(768,)", style=solid]; +"2881 linear_138_zero_point_0" -> "2883 dequantize_per_channel_default_139" [label="(768,)", style=solid]; +"2882 _frozen_param139" -> "2883 dequantize_per_channel_default_139" [label="(768, 768)", style=solid]; +"2883 dequantize_per_channel_default_139" -> "2884 linear_138" [label="(768, 768)", style=solid]; +"2884 linear_138" -> "2885 dropout_89" [label="(1, 64, 768)", style=solid]; +"2885 dropout_89" -> "2886 view_124" [label="(1, 64, 768)", style=solid]; +"2886 view_124" -> "2887 permute_103" [label="(1, 1, 1, 8, 8, 768)", style=solid]; +"2887 permute_103" -> "2888 reshape_102" [label="(1, 1, 8, 1, 8, 768)", style=solid]; +"2888 reshape_102" -> "2889 slice_342" [label="(1, 8, 8, 768)", style=solid]; +"2889 slice_342" -> "2890 slice_343" [label="(1, 8, 8, 768)", style=solid]; +"2890 slice_343" -> "2891 slice_344" [label="(1, 7, 8, 768)", style=solid]; +"2891 slice_344" -> "2892 slice_345" [label="(1, 7, 7, 768)", style=solid]; +"2892 slice_345" -> "2893 contiguous_43" [label="(1, 7, 7, 768)", style=solid]; +"2893 contiguous_43" -> "2894 layer_norm_48" [label="(1, 7, 7, 768)", style=solid]; +"2894 layer_norm_48" -> "2895 add_78" [label="(1, 7, 7, 768)", style=solid]; +"2895 add_78" -> "2896 add_78_0_0_nncf_smooth_quant_0" [label="(1, 7, 7, 768)", style=solid]; +"2895 add_78" -> "2916 add_79" [label="(1, 7, 7, 768)", style=solid]; +"2896 add_78_0_0_nncf_smooth_quant_0" -> "2897 quantize_per_tensor_default_140" [label="(1, 7, 7, 768)", style=solid]; +"2897 quantize_per_tensor_default_140" -> "2898 dequantize_per_tensor_default_140" [label="(1, 7, 7, 768)", style=solid]; +"2898 dequantize_per_tensor_default_140" -> "2903 linear_139" [label="(1, 7, 7, 768)", style=solid]; +"2899 linear_139_scale_0" -> "2902 dequantize_per_channel_default_140" [label="(3072,)", style=solid]; +"2900 linear_139_zero_point_0" -> "2902 dequantize_per_channel_default_140" [label="(3072,)", style=solid]; +"2901 _frozen_param140" -> "2902 dequantize_per_channel_default_140" [label="(3072, 768)", style=solid]; +"2902 dequantize_per_channel_default_140" -> "2903 linear_139" [label="(3072, 768)", style=solid]; +"2903 linear_139" -> "2904 gelu_22" [label="(1, 7, 7, 3072)", style=solid]; +"2904 gelu_22" -> "2905 dropout_90" [label="(1, 7, 7, 3072)", style=solid]; +"2905 dropout_90" -> "2906 dropout_90_0_0_nncf_smooth_quant_0" [label="(1, 7, 7, 3072)", style=solid]; +"2906 dropout_90_0_0_nncf_smooth_quant_0" -> "2907 quantize_per_tensor_default_141" [label="(1, 7, 7, 3072)", style=solid]; +"2907 quantize_per_tensor_default_141" -> "2908 dequantize_per_tensor_default_141" [label="(1, 7, 7, 3072)", style=solid]; +"2908 dequantize_per_tensor_default_141" -> "2913 linear_140" [label="(1, 7, 7, 3072)", style=solid]; +"2909 linear_140_scale_0" -> "2912 dequantize_per_channel_default_141" [label="(768,)", style=solid]; +"2910 linear_140_zero_point_0" -> "2912 dequantize_per_channel_default_141" [label="(768,)", style=solid]; +"2911 _frozen_param141" -> "2912 dequantize_per_channel_default_141" [label="(768, 3072)", style=solid]; +"2912 dequantize_per_channel_default_141" -> "2913 linear_140" [label="(768, 3072)", style=solid]; +"2913 linear_140" -> "2914 dropout_91" [label="(1, 7, 7, 768)", style=solid]; +"2914 dropout_91" -> "2915 layer_norm_49" [label="(1, 7, 7, 768)", style=solid]; +"2915 layer_norm_49" -> "2916 add_79" [label="(1, 7, 7, 768)", style=solid]; +"2916 add_79" -> "2938 pad_26" [label="(1, 7, 7, 768)", style=solid]; +"2916 add_79" -> "2997 add_81" [label="(1, 7, 7, 768)", style=solid]; +"2917 features_7_1_attn_relative_coords_table_0_0_nncf_smooth_quant_0" -> "2922 linear_141" [label="(1, 15, 15, 2)", style=solid]; +"2918 linear_141_scale_0" -> "2921 dequantize_per_channel_default_142" [label="(512,)", style=solid]; +"2919 linear_141_zero_point_0" -> "2921 dequantize_per_channel_default_142" [label="(512,)", style=solid]; +"2920 _frozen_param142" -> "2921 dequantize_per_channel_default_142" [label="(512, 2)", style=solid]; +"2921 dequantize_per_channel_default_142" -> "2922 linear_141" [label="(512, 2)", style=solid]; +"2922 linear_141" -> "2923 relu__23" [label="(1, 15, 15, 512)", style=solid]; +"2923 relu__23" -> "2924 relu__23_0_0_nncf_smooth_quant_0" [label="(1, 15, 15, 512)", style=solid]; +"2924 relu__23_0_0_nncf_smooth_quant_0" -> "2929 linear_142" [label="(1, 15, 15, 512)", style=solid]; +"2925 linear_142_scale_0" -> "2928 dequantize_per_channel_default_143" [label="(24,)", style=solid]; +"2926 linear_142_zero_point_0" -> "2928 dequantize_per_channel_default_143" [label="(24,)", style=solid]; +"2927 _frozen_param143" -> "2928 dequantize_per_channel_default_143" [label="(24, 512)", style=solid]; +"2928 dequantize_per_channel_default_143" -> "2929 linear_142" [label="(24, 512)", style=solid]; +"2929 linear_142" -> "2930 view_125" [label="(1, 15, 15, 24)", style=solid]; +"2930 view_125" -> "2931 index_23" [label="(225, 24)", style=solid]; +"2931 index_23" -> "2932 view_126" [label="(4096, 24)", style=solid]; +"2932 view_126" -> "2933 permute_104" [label="(64, 64, 24)", style=solid]; +"2933 permute_104" -> "2934 contiguous_44" [label="(24, 64, 64)", style=solid]; +"2934 contiguous_44" -> "2935 unsqueeze_67" [label="(24, 64, 64)", style=solid]; +"2935 unsqueeze_67" -> "2936 sigmoid_23" [label="(1, 24, 64, 64)", style=solid]; +"2936 sigmoid_23" -> "2937 mul_46" [label="(1, 24, 64, 64)", style=solid]; +"2937 mul_46" -> "2973 add_80" [label="(1, 24, 64, 64)", style=solid]; +"2938 pad_26" -> "2939 view_127" [label="(1, 8, 8, 768)", style=solid]; +"2939 view_127" -> "2940 permute_105" [label="(1, 1, 8, 1, 8, 768)", style=solid]; +"2940 permute_105" -> "2941 reshape_103" [label="(1, 1, 1, 8, 8, 768)", style=solid]; +"2941 reshape_103" -> "2943 reshape_103_0_0_nncf_smooth_quant_0" [label="(1, 64, 768)", style=solid]; +"2942 clone_23" -> "2950 linear_143" [label="(2304,)", style=solid]; +"2943 reshape_103_0_0_nncf_smooth_quant_0" -> "2944 quantize_per_tensor_default_142" [label="(1, 64, 768)", style=solid]; +"2944 quantize_per_tensor_default_142" -> "2945 dequantize_per_tensor_default_142" [label="(1, 64, 768)", style=solid]; +"2945 dequantize_per_tensor_default_142" -> "2950 linear_143" [label="(1, 64, 768)", style=solid]; +"2946 linear_143_scale_0" -> "2949 dequantize_per_channel_default_144" [label="(2304,)", style=solid]; +"2947 linear_143_zero_point_0" -> "2949 dequantize_per_channel_default_144" [label="(2304,)", style=solid]; +"2948 _frozen_param144" -> "2949 dequantize_per_channel_default_144" [label="(2304, 768)", style=solid]; +"2949 dequantize_per_channel_default_144" -> "2950 linear_143" [label="(2304, 768)", style=solid]; +"2950 linear_143" -> "2951 reshape_104" [label="(1, 64, 2304)", style=solid]; +"2951 reshape_104" -> "2952 permute_106" [label="(1, 64, 3, 24, 32)", style=solid]; +"2952 permute_106" -> "2953 select_69" [label="(3, 1, 24, 64, 32)", style=solid]; +"2952 permute_106" -> "2954 select_70" [label="(3, 1, 24, 64, 32)", style=solid]; +"2952 permute_106" -> "2955 select_71" [label="(3, 1, 24, 64, 32)", style=solid]; +"2953 select_69" -> "2956 linalg_vector_norm_46" [label="(1, 24, 64, 32)", style=solid]; +"2953 select_69" -> "2958 expand_as_46" [label="(1, 24, 64, 32)", style=solid]; +"2953 select_69" -> "2959 div_46" [label="(1, 24, 64, 32)", style=solid]; +"2954 select_70" -> "2962 linalg_vector_norm_47" [label="(1, 24, 64, 32)", style=solid]; +"2954 select_70" -> "2964 expand_as_47" [label="(1, 24, 64, 32)", style=solid]; +"2954 select_70" -> "2965 div_47" [label="(1, 24, 64, 32)", style=solid]; +"2955 select_71" -> "2976 matmul_47" [label="(1, 24, 64, 32)", style=solid]; +"2956 linalg_vector_norm_46" -> "2957 clamp_min_46" [label="(1, 24, 64, 1)", style=solid]; +"2957 clamp_min_46" -> "2958 expand_as_46" [label="(1, 24, 64, 1)", style=solid]; +"2958 expand_as_46" -> "2959 div_46" [label="(1, 24, 64, 32)", style=solid]; +"2959 div_46" -> "2960 quantize_per_tensor_default_143" [label="(1, 24, 64, 32)", style=solid]; +"2960 quantize_per_tensor_default_143" -> "2961 dequantize_per_tensor_default_143" [label="(1, 24, 64, 32)", style=solid]; +"2961 dequantize_per_tensor_default_143" -> "2969 matmul_46" [label="(1, 24, 64, 32)", style=solid]; +"2962 linalg_vector_norm_47" -> "2963 clamp_min_47" [label="(1, 24, 64, 1)", style=solid]; +"2963 clamp_min_47" -> "2964 expand_as_47" [label="(1, 24, 64, 1)", style=solid]; +"2964 expand_as_47" -> "2965 div_47" [label="(1, 24, 64, 32)", style=solid]; +"2965 div_47" -> "2966 quantize_per_tensor_default_144" [label="(1, 24, 64, 32)", style=solid]; +"2966 quantize_per_tensor_default_144" -> "2967 dequantize_per_tensor_default_144" [label="(1, 24, 64, 32)", style=solid]; +"2967 dequantize_per_tensor_default_144" -> "2968 transpose_46" [label="(1, 24, 64, 32)", style=solid]; +"2968 transpose_46" -> "2969 matmul_46" [label="(1, 24, 32, 64)", style=solid]; +"2969 matmul_46" -> "2972 mul_47" [label="(1, 24, 64, 64)", style=solid]; +"2970 clamp_23" -> "2971 exp_23" [label="(24, 1, 1)", style=solid]; +"2971 exp_23" -> "2972 mul_47" [label="(24, 1, 1)", style=solid]; +"2972 mul_47" -> "2973 add_80" [label="(1, 24, 64, 64)", style=solid]; +"2973 add_80" -> "2974 softmax_23" [label="(1, 24, 64, 64)", style=solid]; +"2974 softmax_23" -> "2975 dropout_92" [label="(1, 24, 64, 64)", style=solid]; +"2975 dropout_92" -> "2976 matmul_47" [label="(1, 24, 64, 64)", style=solid]; +"2976 matmul_47" -> "2977 transpose_47" [label="(1, 24, 64, 32)", style=solid]; +"2977 transpose_47" -> "2978 reshape_105" [label="(1, 64, 24, 32)", style=solid]; +"2978 reshape_105" -> "2979 reshape_105_0_0_nncf_smooth_quant_0" [label="(1, 64, 768)", style=solid]; +"2979 reshape_105_0_0_nncf_smooth_quant_0" -> "2980 quantize_per_tensor_default_145" [label="(1, 64, 768)", style=solid]; +"2980 quantize_per_tensor_default_145" -> "2981 dequantize_per_tensor_default_145" [label="(1, 64, 768)", style=solid]; +"2981 dequantize_per_tensor_default_145" -> "2986 linear_144" [label="(1, 64, 768)", style=solid]; +"2982 linear_144_scale_0" -> "2985 dequantize_per_channel_default_145" [label="(768,)", style=solid]; +"2983 linear_144_zero_point_0" -> "2985 dequantize_per_channel_default_145" [label="(768,)", style=solid]; +"2984 _frozen_param145" -> "2985 dequantize_per_channel_default_145" [label="(768, 768)", style=solid]; +"2985 dequantize_per_channel_default_145" -> "2986 linear_144" [label="(768, 768)", style=solid]; +"2986 linear_144" -> "2987 dropout_93" [label="(1, 64, 768)", style=solid]; +"2987 dropout_93" -> "2988 view_128" [label="(1, 64, 768)", style=solid]; +"2988 view_128" -> "2989 permute_107" [label="(1, 1, 1, 8, 8, 768)", style=solid]; +"2989 permute_107" -> "2990 reshape_106" [label="(1, 1, 8, 1, 8, 768)", style=solid]; +"2990 reshape_106" -> "2991 slice_347" [label="(1, 8, 8, 768)", style=solid]; +"2991 slice_347" -> "2992 slice_348" [label="(1, 8, 8, 768)", style=solid]; +"2992 slice_348" -> "2993 slice_349" [label="(1, 7, 8, 768)", style=solid]; +"2993 slice_349" -> "2994 slice_350" [label="(1, 7, 7, 768)", style=solid]; +"2994 slice_350" -> "2995 contiguous_45" [label="(1, 7, 7, 768)", style=solid]; +"2995 contiguous_45" -> "2996 layer_norm_50" [label="(1, 7, 7, 768)", style=solid]; +"2996 layer_norm_50" -> "2997 add_81" [label="(1, 7, 7, 768)", style=solid]; +"2997 add_81" -> "2998 add_81_0_0_nncf_smooth_quant_0" [label="(1, 7, 7, 768)", style=solid]; +"2997 add_81" -> "3018 add_82" [label="(1, 7, 7, 768)", style=solid]; +"2998 add_81_0_0_nncf_smooth_quant_0" -> "2999 quantize_per_tensor_default_146" [label="(1, 7, 7, 768)", style=solid]; +"2999 quantize_per_tensor_default_146" -> "3000 dequantize_per_tensor_default_146" [label="(1, 7, 7, 768)", style=solid]; +"3000 dequantize_per_tensor_default_146" -> "3005 linear_145" [label="(1, 7, 7, 768)", style=solid]; +"3001 linear_145_scale_0" -> "3004 dequantize_per_channel_default_146" [label="(3072,)", style=solid]; +"3002 linear_145_zero_point_0" -> "3004 dequantize_per_channel_default_146" [label="(3072,)", style=solid]; +"3003 _frozen_param146" -> "3004 dequantize_per_channel_default_146" [label="(3072, 768)", style=solid]; +"3004 dequantize_per_channel_default_146" -> "3005 linear_145" [label="(3072, 768)", style=solid]; +"3005 linear_145" -> "3006 gelu_23" [label="(1, 7, 7, 3072)", style=solid]; +"3006 gelu_23" -> "3007 dropout_94" [label="(1, 7, 7, 3072)", style=solid]; +"3007 dropout_94" -> "3008 dropout_94_0_0_nncf_smooth_quant_0" [label="(1, 7, 7, 3072)", style=solid]; +"3008 dropout_94_0_0_nncf_smooth_quant_0" -> "3009 quantize_per_tensor_default_147" [label="(1, 7, 7, 3072)", style=solid]; +"3009 quantize_per_tensor_default_147" -> "3010 dequantize_per_tensor_default_147" [label="(1, 7, 7, 3072)", style=solid]; +"3010 dequantize_per_tensor_default_147" -> "3015 linear_146" [label="(1, 7, 7, 3072)", style=solid]; +"3011 linear_146_scale_0" -> "3014 dequantize_per_channel_default_147" [label="(768,)", style=solid]; +"3012 linear_146_zero_point_0" -> "3014 dequantize_per_channel_default_147" [label="(768,)", style=solid]; +"3013 _frozen_param147" -> "3014 dequantize_per_channel_default_147" [label="(768, 3072)", style=solid]; +"3014 dequantize_per_channel_default_147" -> "3015 linear_146" [label="(768, 3072)", style=solid]; +"3015 linear_146" -> "3016 dropout_95" [label="(1, 7, 7, 768)", style=solid]; +"3016 dropout_95" -> "3017 layer_norm_51" [label="(1, 7, 7, 768)", style=solid]; +"3017 layer_norm_51" -> "3018 add_82" [label="(1, 7, 7, 768)", style=solid]; +"3018 add_82" -> "3019 layer_norm_52" [label="(1, 7, 7, 768)", style=solid]; +"3019 layer_norm_52" -> "3020 permute_108" [label="(1, 7, 7, 768)", style=solid]; +"3020 permute_108" -> "3021 adaptive_avg_pool2d" [label="(1, 768, 7, 7)", style=solid]; +"3021 adaptive_avg_pool2d" -> "3022 flatten" [label="(1, 768, 1, 1)", style=solid]; +"3022 flatten" -> "3023 flatten_0_0_nncf_smooth_quant_0" [label="(1, 768)", style=solid]; +"3023 flatten_0_0_nncf_smooth_quant_0" -> "3024 quantize_per_tensor_default_148" [label="(1, 768)", style=solid]; +"3024 quantize_per_tensor_default_148" -> "3025 dequantize_per_tensor_default_148" [label="(1, 768)", style=solid]; +"3025 dequantize_per_tensor_default_148" -> "3030 linear_147" [label="(1, 768)", style=solid]; +"3026 linear_147_scale_0" -> "3029 dequantize_per_channel_default_148" [label="(1000,)", style=solid]; +"3027 linear_147_zero_point_0" -> "3029 dequantize_per_channel_default_148" [label="(1000,)", style=solid]; +"3028 _frozen_param148" -> "3029 dequantize_per_channel_default_148" [label="(1000, 768)", style=solid]; +"3029 dequantize_per_channel_default_148" -> "3030 linear_147" [label="(1000, 768)", style=solid]; +"3030 linear_147" -> "3031 output" [label="(1, 1000)", style=solid]; +} diff --git a/tests/torch/data/reference_graphs/fx/experimental/OpenVINOQuantizer/synthetic_transformer.dot b/tests/torch/data/reference_graphs/fx/experimental/OpenVINOQuantizer/synthetic_transformer.dot new file mode 100644 index 00000000000..462a2e45e41 --- /dev/null +++ b/tests/torch/data/reference_graphs/fx/experimental/OpenVINOQuantizer/synthetic_transformer.dot @@ -0,0 +1,45 @@ +strict digraph { +"0 wte_weight" [id=0, type=get_attr]; +"1 linear_bias" [id=1, type=get_attr]; +"2 lm_head_bias" [id=2, type=get_attr]; +"3 input_ids" [id=3, type=input]; +"4 embedding" [id=4, type=embedding]; +"5 embedding_0_0_nncf_smooth_quant_0" [id=5, type=call_module]; +"6 quantize_per_tensor_default" [id=6, type=quantize_per_tensor]; +"7 dequantize_per_tensor_default" [id=7, type=dequantize_per_tensor]; +"8 linear_scale_0" [id=8, type=get_attr]; +"9 linear_zero_point_0" [id=9, type=get_attr]; +"10 _frozen_param0" [id=10, type=get_attr]; +"11 dequantize_per_channel_default" [id=11, type=dequantize_per_channel]; +"12 linear" [id=12, type=linear]; +"13 linear_0_0_nncf_smooth_quant_0" [id=13, type=call_module]; +"14 quantize_per_tensor_default_1" [id=14, type=quantize_per_tensor]; +"15 dequantize_per_tensor_default_1" [id=15, type=dequantize_per_tensor]; +"16 linear_1_scale_0" [id=16, type=get_attr]; +"17 linear_1_zero_point_0" [id=17, type=get_attr]; +"18 _frozen_param1" [id=18, type=get_attr]; +"19 dequantize_per_channel_default_1" [id=19, type=dequantize_per_channel]; +"20 linear_1" [id=20, type=linear]; +"21 output" [id=21, type=output]; +"0 wte_weight" -> "4 embedding" [label="(10, 5)", style=solid]; +"1 linear_bias" -> "12 linear" [label="(5,)", style=solid]; +"2 lm_head_bias" -> "20 linear_1" [label="(10,)", style=solid]; +"3 input_ids" -> "4 embedding" [label="(5,)", style=solid]; +"4 embedding" -> "5 embedding_0_0_nncf_smooth_quant_0" [label="(5, 5)", style=solid]; +"5 embedding_0_0_nncf_smooth_quant_0" -> "6 quantize_per_tensor_default" [label="(5, 5)", style=solid]; +"6 quantize_per_tensor_default" -> "7 dequantize_per_tensor_default" [label="(5, 5)", style=solid]; +"7 dequantize_per_tensor_default" -> "12 linear" [label="(5, 5)", style=solid]; +"8 linear_scale_0" -> "11 dequantize_per_channel_default" [label="(5,)", style=solid]; +"9 linear_zero_point_0" -> "11 dequantize_per_channel_default" [label="(5,)", style=solid]; +"10 _frozen_param0" -> "11 dequantize_per_channel_default" [label="(5, 5)", style=solid]; +"11 dequantize_per_channel_default" -> "12 linear" [label="(5, 5)", style=solid]; +"12 linear" -> "13 linear_0_0_nncf_smooth_quant_0" [label="(5, 5)", style=solid]; +"13 linear_0_0_nncf_smooth_quant_0" -> "14 quantize_per_tensor_default_1" [label="(5, 5)", style=solid]; +"14 quantize_per_tensor_default_1" -> "15 dequantize_per_tensor_default_1" [label="(5, 5)", style=solid]; +"15 dequantize_per_tensor_default_1" -> "20 linear_1" [label="(5, 5)", style=solid]; +"16 linear_1_scale_0" -> "19 dequantize_per_channel_default_1" [label="(10,)", style=solid]; +"17 linear_1_zero_point_0" -> "19 dequantize_per_channel_default_1" [label="(10,)", style=solid]; +"18 _frozen_param1" -> "19 dequantize_per_channel_default_1" [label="(10, 5)", style=solid]; +"19 dequantize_per_channel_default_1" -> "20 linear_1" [label="(10, 5)", style=solid]; +"20 linear_1" -> "21 output" [label="(5, 10)", style=solid]; +} diff --git a/tests/torch/data/reference_graphs/fx/experimental/OpenVINOQuantizer/unet.dot b/tests/torch/data/reference_graphs/fx/experimental/OpenVINOQuantizer/unet.dot new file mode 100644 index 00000000000..c1ab3d80c09 --- /dev/null +++ b/tests/torch/data/reference_graphs/fx/experimental/OpenVINOQuantizer/unet.dot @@ -0,0 +1,469 @@ +strict digraph { +"0 down_path_0_block_0_bias" [id=0, type=get_attr]; +"1 down_path_0_block_3_bias" [id=1, type=get_attr]; +"2 down_path_1_block_0_bias" [id=2, type=get_attr]; +"3 down_path_1_block_3_bias" [id=3, type=get_attr]; +"4 down_path_2_block_0_bias" [id=4, type=get_attr]; +"5 down_path_2_block_3_bias" [id=5, type=get_attr]; +"6 down_path_3_block_0_bias" [id=6, type=get_attr]; +"7 down_path_3_block_3_bias" [id=7, type=get_attr]; +"8 down_path_4_block_0_bias" [id=8, type=get_attr]; +"9 down_path_4_block_3_bias" [id=9, type=get_attr]; +"10 up_path_0_up_bias" [id=10, type=get_attr]; +"11 up_path_0_conv_block_block_0_bias" [id=11, type=get_attr]; +"12 up_path_0_conv_block_block_3_bias" [id=12, type=get_attr]; +"13 up_path_1_up_bias" [id=13, type=get_attr]; +"14 up_path_1_conv_block_block_0_bias" [id=14, type=get_attr]; +"15 up_path_1_conv_block_block_3_bias" [id=15, type=get_attr]; +"16 up_path_2_up_bias" [id=16, type=get_attr]; +"17 up_path_2_conv_block_block_0_bias" [id=17, type=get_attr]; +"18 up_path_2_conv_block_block_3_bias" [id=18, type=get_attr]; +"19 up_path_3_up_bias" [id=19, type=get_attr]; +"20 up_path_3_conv_block_block_0_bias" [id=20, type=get_attr]; +"21 up_path_3_conv_block_block_3_bias" [id=21, type=get_attr]; +"22 last_bias" [id=22, type=get_attr]; +"23 x" [id=23, type=input]; +"24 quantize_per_tensor_default_8" [id=24, type=quantize_per_tensor]; +"25 dequantize_per_tensor_default_12" [id=25, type=dequantize_per_tensor]; +"26 conv2d_scale_0" [id=26, type=get_attr]; +"27 conv2d_zero_point_0" [id=27, type=get_attr]; +"28 _frozen_param0" [id=28, type=get_attr]; +"29 dequantize_per_channel_default" [id=29, type=dequantize_per_channel]; +"30 conv2d" [id=30, type=conv2d]; +"31 relu" [id=31, type=relu]; +"32 quantize_per_tensor_default_9" [id=32, type=quantize_per_tensor]; +"33 dequantize_per_tensor_default_13" [id=33, type=dequantize_per_tensor]; +"34 conv2d_1_scale_0" [id=34, type=get_attr]; +"35 conv2d_1_zero_point_0" [id=35, type=get_attr]; +"36 _frozen_param1" [id=36, type=get_attr]; +"37 dequantize_per_channel_default_1" [id=37, type=dequantize_per_channel]; +"38 conv2d_1" [id=38, type=conv2d]; +"39 relu_1" [id=39, type=relu]; +"40 quantize_per_tensor_default" [id=40, type=quantize_per_tensor]; +"41 dequantize_per_tensor_default_1" [id=41, type=dequantize_per_tensor]; +"42 dequantize_per_tensor_default" [id=42, type=dequantize_per_tensor]; +"43 max_pool2d" [id=43, type=max_pool2d]; +"44 conv2d_2_scale_0" [id=44, type=get_attr]; +"45 conv2d_2_zero_point_0" [id=45, type=get_attr]; +"46 _frozen_param2" [id=46, type=get_attr]; +"47 dequantize_per_channel_default_2" [id=47, type=dequantize_per_channel]; +"48 conv2d_2" [id=48, type=conv2d]; +"49 relu_2" [id=49, type=relu]; +"50 quantize_per_tensor_default_10" [id=50, type=quantize_per_tensor]; +"51 dequantize_per_tensor_default_14" [id=51, type=dequantize_per_tensor]; +"52 conv2d_3_scale_0" [id=52, type=get_attr]; +"53 conv2d_3_zero_point_0" [id=53, type=get_attr]; +"54 _frozen_param3" [id=54, type=get_attr]; +"55 dequantize_per_channel_default_3" [id=55, type=dequantize_per_channel]; +"56 conv2d_3" [id=56, type=conv2d]; +"57 relu_3" [id=57, type=relu]; +"58 quantize_per_tensor_default_3" [id=58, type=quantize_per_tensor]; +"59 dequantize_per_tensor_default_5" [id=59, type=dequantize_per_tensor]; +"60 dequantize_per_tensor_default_4" [id=60, type=dequantize_per_tensor]; +"61 max_pool2d_1" [id=61, type=max_pool2d]; +"62 conv2d_4_scale_0" [id=62, type=get_attr]; +"63 conv2d_4_zero_point_0" [id=63, type=get_attr]; +"64 _frozen_param4" [id=64, type=get_attr]; +"65 dequantize_per_channel_default_4" [id=65, type=dequantize_per_channel]; +"66 conv2d_4" [id=66, type=conv2d]; +"67 relu_4" [id=67, type=relu]; +"68 quantize_per_tensor_default_11" [id=68, type=quantize_per_tensor]; +"69 dequantize_per_tensor_default_15" [id=69, type=dequantize_per_tensor]; +"70 conv2d_5_scale_0" [id=70, type=get_attr]; +"71 conv2d_5_zero_point_0" [id=71, type=get_attr]; +"72 _frozen_param5" [id=72, type=get_attr]; +"73 dequantize_per_channel_default_5" [id=73, type=dequantize_per_channel]; +"74 conv2d_5" [id=74, type=conv2d]; +"75 relu_5" [id=75, type=relu]; +"76 quantize_per_tensor_default_4" [id=76, type=quantize_per_tensor]; +"77 dequantize_per_tensor_default_7" [id=77, type=dequantize_per_tensor]; +"78 dequantize_per_tensor_default_6" [id=78, type=dequantize_per_tensor]; +"79 max_pool2d_2" [id=79, type=max_pool2d]; +"80 conv2d_6_scale_0" [id=80, type=get_attr]; +"81 conv2d_6_zero_point_0" [id=81, type=get_attr]; +"82 _frozen_param6" [id=82, type=get_attr]; +"83 dequantize_per_channel_default_6" [id=83, type=dequantize_per_channel]; +"84 conv2d_6" [id=84, type=conv2d]; +"85 relu_6" [id=85, type=relu]; +"86 quantize_per_tensor_default_12" [id=86, type=quantize_per_tensor]; +"87 dequantize_per_tensor_default_16" [id=87, type=dequantize_per_tensor]; +"88 conv2d_7_scale_0" [id=88, type=get_attr]; +"89 conv2d_7_zero_point_0" [id=89, type=get_attr]; +"90 _frozen_param7" [id=90, type=get_attr]; +"91 dequantize_per_channel_default_7" [id=91, type=dequantize_per_channel]; +"92 conv2d_7" [id=92, type=conv2d]; +"93 relu_7" [id=93, type=relu]; +"94 quantize_per_tensor_default_7" [id=94, type=quantize_per_tensor]; +"95 dequantize_per_tensor_default_11" [id=95, type=dequantize_per_tensor]; +"96 dequantize_per_tensor_default_10" [id=96, type=dequantize_per_tensor]; +"97 max_pool2d_3" [id=97, type=max_pool2d]; +"98 conv2d_8_scale_0" [id=98, type=get_attr]; +"99 conv2d_8_zero_point_0" [id=99, type=get_attr]; +"100 _frozen_param8" [id=100, type=get_attr]; +"101 dequantize_per_channel_default_8" [id=101, type=dequantize_per_channel]; +"102 conv2d_8" [id=102, type=conv2d]; +"103 relu_8" [id=103, type=relu]; +"104 quantize_per_tensor_default_13" [id=104, type=quantize_per_tensor]; +"105 dequantize_per_tensor_default_17" [id=105, type=dequantize_per_tensor]; +"106 conv2d_9_scale_0" [id=106, type=get_attr]; +"107 conv2d_9_zero_point_0" [id=107, type=get_attr]; +"108 _frozen_param9" [id=108, type=get_attr]; +"109 dequantize_per_channel_default_9" [id=109, type=dequantize_per_channel]; +"110 conv2d_9" [id=110, type=conv2d]; +"111 relu_9" [id=111, type=relu]; +"112 quantize_per_tensor_default_14" [id=112, type=quantize_per_tensor]; +"113 dequantize_per_tensor_default_18" [id=113, type=dequantize_per_tensor]; +"114 conv_transpose2d_scale_0" [id=114, type=get_attr]; +"115 conv_transpose2d_zero_point_0" [id=115, type=get_attr]; +"116 _frozen_param10" [id=116, type=get_attr]; +"117 dequantize_per_channel_default_10" [id=117, type=dequantize_per_channel]; +"118 conv_transpose2d" [id=118, type=conv_transpose2d]; +"119 quantize_per_tensor_default_6" [id=119, type=quantize_per_tensor]; +"120 dequantize_per_tensor_default_9" [id=120, type=dequantize_per_tensor]; +"121 slice_1" [id=121, type=slice]; +"122 slice_2" [id=122, type=slice]; +"123 slice_3" [id=123, type=slice]; +"124 slice_4" [id=124, type=slice]; +"125 cat" [id=125, type=cat]; +"126 conv2d_10_scale_0" [id=126, type=get_attr]; +"127 conv2d_10_zero_point_0" [id=127, type=get_attr]; +"128 _frozen_param11" [id=128, type=get_attr]; +"129 dequantize_per_channel_default_11" [id=129, type=dequantize_per_channel]; +"130 conv2d_10" [id=130, type=conv2d]; +"131 relu_10" [id=131, type=relu]; +"132 quantize_per_tensor_default_15" [id=132, type=quantize_per_tensor]; +"133 dequantize_per_tensor_default_19" [id=133, type=dequantize_per_tensor]; +"134 conv2d_11_scale_0" [id=134, type=get_attr]; +"135 conv2d_11_zero_point_0" [id=135, type=get_attr]; +"136 _frozen_param12" [id=136, type=get_attr]; +"137 dequantize_per_channel_default_12" [id=137, type=dequantize_per_channel]; +"138 conv2d_11" [id=138, type=conv2d]; +"139 relu_11" [id=139, type=relu]; +"140 quantize_per_tensor_default_16" [id=140, type=quantize_per_tensor]; +"141 dequantize_per_tensor_default_20" [id=141, type=dequantize_per_tensor]; +"142 conv_transpose2d_1_scale_0" [id=142, type=get_attr]; +"143 conv_transpose2d_1_zero_point_0" [id=143, type=get_attr]; +"144 _frozen_param13" [id=144, type=get_attr]; +"145 dequantize_per_channel_default_13" [id=145, type=dequantize_per_channel]; +"146 conv_transpose2d_1" [id=146, type=conv_transpose2d]; +"147 quantize_per_tensor_default_5" [id=147, type=quantize_per_tensor]; +"148 dequantize_per_tensor_default_8" [id=148, type=dequantize_per_tensor]; +"149 slice_5" [id=149, type=slice]; +"150 slice_6" [id=150, type=slice]; +"151 slice_7" [id=151, type=slice]; +"152 slice_8" [id=152, type=slice]; +"153 cat_1" [id=153, type=cat]; +"154 conv2d_12_scale_0" [id=154, type=get_attr]; +"155 conv2d_12_zero_point_0" [id=155, type=get_attr]; +"156 _frozen_param14" [id=156, type=get_attr]; +"157 dequantize_per_channel_default_14" [id=157, type=dequantize_per_channel]; +"158 conv2d_12" [id=158, type=conv2d]; +"159 relu_12" [id=159, type=relu]; +"160 quantize_per_tensor_default_17" [id=160, type=quantize_per_tensor]; +"161 dequantize_per_tensor_default_21" [id=161, type=dequantize_per_tensor]; +"162 conv2d_13_scale_0" [id=162, type=get_attr]; +"163 conv2d_13_zero_point_0" [id=163, type=get_attr]; +"164 _frozen_param15" [id=164, type=get_attr]; +"165 dequantize_per_channel_default_15" [id=165, type=dequantize_per_channel]; +"166 conv2d_13" [id=166, type=conv2d]; +"167 relu_13" [id=167, type=relu]; +"168 quantize_per_tensor_default_18" [id=168, type=quantize_per_tensor]; +"169 dequantize_per_tensor_default_22" [id=169, type=dequantize_per_tensor]; +"170 conv_transpose2d_2_scale_0" [id=170, type=get_attr]; +"171 conv_transpose2d_2_zero_point_0" [id=171, type=get_attr]; +"172 _frozen_param16" [id=172, type=get_attr]; +"173 dequantize_per_channel_default_16" [id=173, type=dequantize_per_channel]; +"174 conv_transpose2d_2" [id=174, type=conv_transpose2d]; +"175 quantize_per_tensor_default_2" [id=175, type=quantize_per_tensor]; +"176 dequantize_per_tensor_default_3" [id=176, type=dequantize_per_tensor]; +"177 slice_9" [id=177, type=slice]; +"178 slice_10" [id=178, type=slice]; +"179 slice_11" [id=179, type=slice]; +"180 slice_12" [id=180, type=slice]; +"181 cat_2" [id=181, type=cat]; +"182 conv2d_14_scale_0" [id=182, type=get_attr]; +"183 conv2d_14_zero_point_0" [id=183, type=get_attr]; +"184 _frozen_param17" [id=184, type=get_attr]; +"185 dequantize_per_channel_default_17" [id=185, type=dequantize_per_channel]; +"186 conv2d_14" [id=186, type=conv2d]; +"187 relu_14" [id=187, type=relu]; +"188 quantize_per_tensor_default_19" [id=188, type=quantize_per_tensor]; +"189 dequantize_per_tensor_default_23" [id=189, type=dequantize_per_tensor]; +"190 conv2d_15_scale_0" [id=190, type=get_attr]; +"191 conv2d_15_zero_point_0" [id=191, type=get_attr]; +"192 _frozen_param18" [id=192, type=get_attr]; +"193 dequantize_per_channel_default_18" [id=193, type=dequantize_per_channel]; +"194 conv2d_15" [id=194, type=conv2d]; +"195 relu_15" [id=195, type=relu]; +"196 quantize_per_tensor_default_20" [id=196, type=quantize_per_tensor]; +"197 dequantize_per_tensor_default_24" [id=197, type=dequantize_per_tensor]; +"198 conv_transpose2d_3_scale_0" [id=198, type=get_attr]; +"199 conv_transpose2d_3_zero_point_0" [id=199, type=get_attr]; +"200 _frozen_param19" [id=200, type=get_attr]; +"201 dequantize_per_channel_default_19" [id=201, type=dequantize_per_channel]; +"202 conv_transpose2d_3" [id=202, type=conv_transpose2d]; +"203 quantize_per_tensor_default_1" [id=203, type=quantize_per_tensor]; +"204 dequantize_per_tensor_default_2" [id=204, type=dequantize_per_tensor]; +"205 slice_13" [id=205, type=slice]; +"206 slice_14" [id=206, type=slice]; +"207 slice_15" [id=207, type=slice]; +"208 slice_16" [id=208, type=slice]; +"209 cat_3" [id=209, type=cat]; +"210 conv2d_16_scale_0" [id=210, type=get_attr]; +"211 conv2d_16_zero_point_0" [id=211, type=get_attr]; +"212 _frozen_param20" [id=212, type=get_attr]; +"213 dequantize_per_channel_default_20" [id=213, type=dequantize_per_channel]; +"214 conv2d_16" [id=214, type=conv2d]; +"215 relu_16" [id=215, type=relu]; +"216 quantize_per_tensor_default_21" [id=216, type=quantize_per_tensor]; +"217 dequantize_per_tensor_default_25" [id=217, type=dequantize_per_tensor]; +"218 conv2d_17_scale_0" [id=218, type=get_attr]; +"219 conv2d_17_zero_point_0" [id=219, type=get_attr]; +"220 _frozen_param21" [id=220, type=get_attr]; +"221 dequantize_per_channel_default_21" [id=221, type=dequantize_per_channel]; +"222 conv2d_17" [id=222, type=conv2d]; +"223 relu_17" [id=223, type=relu]; +"224 quantize_per_tensor_default_22" [id=224, type=quantize_per_tensor]; +"225 dequantize_per_tensor_default_26" [id=225, type=dequantize_per_tensor]; +"226 conv2d_18_scale_0" [id=226, type=get_attr]; +"227 conv2d_18_zero_point_0" [id=227, type=get_attr]; +"228 _frozen_param22" [id=228, type=get_attr]; +"229 dequantize_per_channel_default_22" [id=229, type=dequantize_per_channel]; +"230 conv2d_18" [id=230, type=conv2d]; +"231 output" [id=231, type=output]; +"0 down_path_0_block_0_bias" -> "30 conv2d" [label="(64,)", style=solid]; +"1 down_path_0_block_3_bias" -> "38 conv2d_1" [label="(64,)", style=solid]; +"2 down_path_1_block_0_bias" -> "48 conv2d_2" [label="(128,)", style=solid]; +"3 down_path_1_block_3_bias" -> "56 conv2d_3" [label="(128,)", style=solid]; +"4 down_path_2_block_0_bias" -> "66 conv2d_4" [label="(256,)", style=solid]; +"5 down_path_2_block_3_bias" -> "74 conv2d_5" [label="(256,)", style=solid]; +"6 down_path_3_block_0_bias" -> "84 conv2d_6" [label="(512,)", style=solid]; +"7 down_path_3_block_3_bias" -> "92 conv2d_7" [label="(512,)", style=solid]; +"8 down_path_4_block_0_bias" -> "102 conv2d_8" [label="(1024,)", style=solid]; +"9 down_path_4_block_3_bias" -> "110 conv2d_9" [label="(1024,)", style=solid]; +"10 up_path_0_up_bias" -> "118 conv_transpose2d" [label="(512,)", style=solid]; +"11 up_path_0_conv_block_block_0_bias" -> "130 conv2d_10" [label="(512,)", style=solid]; +"12 up_path_0_conv_block_block_3_bias" -> "138 conv2d_11" [label="(512,)", style=solid]; +"13 up_path_1_up_bias" -> "146 conv_transpose2d_1" [label="(256,)", style=solid]; +"14 up_path_1_conv_block_block_0_bias" -> "158 conv2d_12" [label="(256,)", style=solid]; +"15 up_path_1_conv_block_block_3_bias" -> "166 conv2d_13" [label="(256,)", style=solid]; +"16 up_path_2_up_bias" -> "174 conv_transpose2d_2" [label="(128,)", style=solid]; +"17 up_path_2_conv_block_block_0_bias" -> "186 conv2d_14" [label="(128,)", style=solid]; +"18 up_path_2_conv_block_block_3_bias" -> "194 conv2d_15" [label="(128,)", style=solid]; +"19 up_path_3_up_bias" -> "202 conv_transpose2d_3" [label="(64,)", style=solid]; +"20 up_path_3_conv_block_block_0_bias" -> "214 conv2d_16" [label="(64,)", style=solid]; +"21 up_path_3_conv_block_block_3_bias" -> "222 conv2d_17" [label="(64,)", style=solid]; +"22 last_bias" -> "230 conv2d_18" [label="(12,)", style=solid]; +"23 x" -> "24 quantize_per_tensor_default_8" [label="(1, 3, 224, 224)", style=solid]; +"24 quantize_per_tensor_default_8" -> "25 dequantize_per_tensor_default_12" [label="(1, 3, 224, 224)", style=solid]; +"25 dequantize_per_tensor_default_12" -> "30 conv2d" [label="(1, 3, 224, 224)", style=solid]; +"26 conv2d_scale_0" -> "29 dequantize_per_channel_default" [label="(64,)", style=solid]; +"27 conv2d_zero_point_0" -> "29 dequantize_per_channel_default" [label="(64,)", style=solid]; +"28 _frozen_param0" -> "29 dequantize_per_channel_default" [label="(64, 3, 3, 3)", style=solid]; +"29 dequantize_per_channel_default" -> "30 conv2d" [label="(64, 3, 3, 3)", style=solid]; +"30 conv2d" -> "31 relu" [label="(1, 64, 222, 222)", style=solid]; +"31 relu" -> "32 quantize_per_tensor_default_9" [label="(1, 64, 222, 222)", style=solid]; +"32 quantize_per_tensor_default_9" -> "33 dequantize_per_tensor_default_13" [label="(1, 64, 222, 222)", style=solid]; +"33 dequantize_per_tensor_default_13" -> "38 conv2d_1" [label="(1, 64, 222, 222)", style=solid]; +"34 conv2d_1_scale_0" -> "37 dequantize_per_channel_default_1" [label="(64,)", style=solid]; +"35 conv2d_1_zero_point_0" -> "37 dequantize_per_channel_default_1" [label="(64,)", style=solid]; +"36 _frozen_param1" -> "37 dequantize_per_channel_default_1" [label="(64, 64, 3, 3)", style=solid]; +"37 dequantize_per_channel_default_1" -> "38 conv2d_1" [label="(64, 64, 3, 3)", style=solid]; +"38 conv2d_1" -> "39 relu_1" [label="(1, 64, 220, 220)", style=solid]; +"39 relu_1" -> "40 quantize_per_tensor_default" [label="(1, 64, 220, 220)", style=solid]; +"40 quantize_per_tensor_default" -> "41 dequantize_per_tensor_default_1" [label="(1, 64, 220, 220)", style=solid]; +"40 quantize_per_tensor_default" -> "42 dequantize_per_tensor_default" [label="(1, 64, 220, 220)", style=solid]; +"41 dequantize_per_tensor_default_1" -> "205 slice_13" [label="(1, 64, 220, 220)", style=solid]; +"42 dequantize_per_tensor_default" -> "43 max_pool2d" [label="(1, 64, 220, 220)", style=solid]; +"43 max_pool2d" -> "48 conv2d_2" [label="(1, 64, 110, 110)", style=solid]; +"44 conv2d_2_scale_0" -> "47 dequantize_per_channel_default_2" [label="(128,)", style=solid]; +"45 conv2d_2_zero_point_0" -> "47 dequantize_per_channel_default_2" [label="(128,)", style=solid]; +"46 _frozen_param2" -> "47 dequantize_per_channel_default_2" [label="(128, 64, 3, 3)", style=solid]; +"47 dequantize_per_channel_default_2" -> "48 conv2d_2" [label="(128, 64, 3, 3)", style=solid]; +"48 conv2d_2" -> "49 relu_2" [label="(1, 128, 108, 108)", style=solid]; +"49 relu_2" -> "50 quantize_per_tensor_default_10" [label="(1, 128, 108, 108)", style=solid]; +"50 quantize_per_tensor_default_10" -> "51 dequantize_per_tensor_default_14" [label="(1, 128, 108, 108)", style=solid]; +"51 dequantize_per_tensor_default_14" -> "56 conv2d_3" [label="(1, 128, 108, 108)", style=solid]; +"52 conv2d_3_scale_0" -> "55 dequantize_per_channel_default_3" [label="(128,)", style=solid]; +"53 conv2d_3_zero_point_0" -> "55 dequantize_per_channel_default_3" [label="(128,)", style=solid]; +"54 _frozen_param3" -> "55 dequantize_per_channel_default_3" [label="(128, 128, 3, 3)", style=solid]; +"55 dequantize_per_channel_default_3" -> "56 conv2d_3" [label="(128, 128, 3, 3)", style=solid]; +"56 conv2d_3" -> "57 relu_3" [label="(1, 128, 106, 106)", style=solid]; +"57 relu_3" -> "58 quantize_per_tensor_default_3" [label="(1, 128, 106, 106)", style=solid]; +"58 quantize_per_tensor_default_3" -> "59 dequantize_per_tensor_default_5" [label="(1, 128, 106, 106)", style=solid]; +"58 quantize_per_tensor_default_3" -> "60 dequantize_per_tensor_default_4" [label="(1, 128, 106, 106)", style=solid]; +"59 dequantize_per_tensor_default_5" -> "177 slice_9" [label="(1, 128, 106, 106)", style=solid]; +"60 dequantize_per_tensor_default_4" -> "61 max_pool2d_1" [label="(1, 128, 106, 106)", style=solid]; +"61 max_pool2d_1" -> "66 conv2d_4" [label="(1, 128, 53, 53)", style=solid]; +"62 conv2d_4_scale_0" -> "65 dequantize_per_channel_default_4" [label="(256,)", style=solid]; +"63 conv2d_4_zero_point_0" -> "65 dequantize_per_channel_default_4" [label="(256,)", style=solid]; +"64 _frozen_param4" -> "65 dequantize_per_channel_default_4" [label="(256, 128, 3, 3)", style=solid]; +"65 dequantize_per_channel_default_4" -> "66 conv2d_4" [label="(256, 128, 3, 3)", style=solid]; +"66 conv2d_4" -> "67 relu_4" [label="(1, 256, 51, 51)", style=solid]; +"67 relu_4" -> "68 quantize_per_tensor_default_11" [label="(1, 256, 51, 51)", style=solid]; +"68 quantize_per_tensor_default_11" -> "69 dequantize_per_tensor_default_15" [label="(1, 256, 51, 51)", style=solid]; +"69 dequantize_per_tensor_default_15" -> "74 conv2d_5" [label="(1, 256, 51, 51)", style=solid]; +"70 conv2d_5_scale_0" -> "73 dequantize_per_channel_default_5" [label="(256,)", style=solid]; +"71 conv2d_5_zero_point_0" -> "73 dequantize_per_channel_default_5" [label="(256,)", style=solid]; +"72 _frozen_param5" -> "73 dequantize_per_channel_default_5" [label="(256, 256, 3, 3)", style=solid]; +"73 dequantize_per_channel_default_5" -> "74 conv2d_5" [label="(256, 256, 3, 3)", style=solid]; +"74 conv2d_5" -> "75 relu_5" [label="(1, 256, 49, 49)", style=solid]; +"75 relu_5" -> "76 quantize_per_tensor_default_4" [label="(1, 256, 49, 49)", style=solid]; +"76 quantize_per_tensor_default_4" -> "77 dequantize_per_tensor_default_7" [label="(1, 256, 49, 49)", style=solid]; +"76 quantize_per_tensor_default_4" -> "78 dequantize_per_tensor_default_6" [label="(1, 256, 49, 49)", style=solid]; +"77 dequantize_per_tensor_default_7" -> "149 slice_5" [label="(1, 256, 49, 49)", style=solid]; +"78 dequantize_per_tensor_default_6" -> "79 max_pool2d_2" [label="(1, 256, 49, 49)", style=solid]; +"79 max_pool2d_2" -> "84 conv2d_6" [label="(1, 256, 24, 24)", style=solid]; +"80 conv2d_6_scale_0" -> "83 dequantize_per_channel_default_6" [label="(512,)", style=solid]; +"81 conv2d_6_zero_point_0" -> "83 dequantize_per_channel_default_6" [label="(512,)", style=solid]; +"82 _frozen_param6" -> "83 dequantize_per_channel_default_6" [label="(512, 256, 3, 3)", style=solid]; +"83 dequantize_per_channel_default_6" -> "84 conv2d_6" [label="(512, 256, 3, 3)", style=solid]; +"84 conv2d_6" -> "85 relu_6" [label="(1, 512, 22, 22)", style=solid]; +"85 relu_6" -> "86 quantize_per_tensor_default_12" [label="(1, 512, 22, 22)", style=solid]; +"86 quantize_per_tensor_default_12" -> "87 dequantize_per_tensor_default_16" [label="(1, 512, 22, 22)", style=solid]; +"87 dequantize_per_tensor_default_16" -> "92 conv2d_7" [label="(1, 512, 22, 22)", style=solid]; +"88 conv2d_7_scale_0" -> "91 dequantize_per_channel_default_7" [label="(512,)", style=solid]; +"89 conv2d_7_zero_point_0" -> "91 dequantize_per_channel_default_7" [label="(512,)", style=solid]; +"90 _frozen_param7" -> "91 dequantize_per_channel_default_7" [label="(512, 512, 3, 3)", style=solid]; +"91 dequantize_per_channel_default_7" -> "92 conv2d_7" [label="(512, 512, 3, 3)", style=solid]; +"92 conv2d_7" -> "93 relu_7" [label="(1, 512, 20, 20)", style=solid]; +"93 relu_7" -> "94 quantize_per_tensor_default_7" [label="(1, 512, 20, 20)", style=solid]; +"94 quantize_per_tensor_default_7" -> "95 dequantize_per_tensor_default_11" [label="(1, 512, 20, 20)", style=solid]; +"94 quantize_per_tensor_default_7" -> "96 dequantize_per_tensor_default_10" [label="(1, 512, 20, 20)", style=solid]; +"95 dequantize_per_tensor_default_11" -> "121 slice_1" [label="(1, 512, 20, 20)", style=solid]; +"96 dequantize_per_tensor_default_10" -> "97 max_pool2d_3" [label="(1, 512, 20, 20)", style=solid]; +"97 max_pool2d_3" -> "102 conv2d_8" [label="(1, 512, 10, 10)", style=solid]; +"98 conv2d_8_scale_0" -> "101 dequantize_per_channel_default_8" [label="(1024,)", style=solid]; +"99 conv2d_8_zero_point_0" -> "101 dequantize_per_channel_default_8" [label="(1024,)", style=solid]; +"100 _frozen_param8" -> "101 dequantize_per_channel_default_8" [label="(1024, 512, 3, 3)", style=solid]; +"101 dequantize_per_channel_default_8" -> "102 conv2d_8" [label="(1024, 512, 3, 3)", style=solid]; +"102 conv2d_8" -> "103 relu_8" [label="(1, 1024, 8, 8)", style=solid]; +"103 relu_8" -> "104 quantize_per_tensor_default_13" [label="(1, 1024, 8, 8)", style=solid]; +"104 quantize_per_tensor_default_13" -> "105 dequantize_per_tensor_default_17" [label="(1, 1024, 8, 8)", style=solid]; +"105 dequantize_per_tensor_default_17" -> "110 conv2d_9" [label="(1, 1024, 8, 8)", style=solid]; +"106 conv2d_9_scale_0" -> "109 dequantize_per_channel_default_9" [label="(1024,)", style=solid]; +"107 conv2d_9_zero_point_0" -> "109 dequantize_per_channel_default_9" [label="(1024,)", style=solid]; +"108 _frozen_param9" -> "109 dequantize_per_channel_default_9" [label="(1024, 1024, 3, 3)", style=solid]; +"109 dequantize_per_channel_default_9" -> "110 conv2d_9" [label="(1024, 1024, 3, 3)", style=solid]; +"110 conv2d_9" -> "111 relu_9" [label="(1, 1024, 6, 6)", style=solid]; +"111 relu_9" -> "112 quantize_per_tensor_default_14" [label="(1, 1024, 6, 6)", style=solid]; +"112 quantize_per_tensor_default_14" -> "113 dequantize_per_tensor_default_18" [label="(1, 1024, 6, 6)", style=solid]; +"113 dequantize_per_tensor_default_18" -> "118 conv_transpose2d" [label="(1, 1024, 6, 6)", style=solid]; +"114 conv_transpose2d_scale_0" -> "117 dequantize_per_channel_default_10" [label="(1024,)", style=solid]; +"115 conv_transpose2d_zero_point_0" -> "117 dequantize_per_channel_default_10" [label="(1024,)", style=solid]; +"116 _frozen_param10" -> "117 dequantize_per_channel_default_10" [label="(1024, 512, 2, 2)", style=solid]; +"117 dequantize_per_channel_default_10" -> "118 conv_transpose2d" [label="(1024, 512, 2, 2)", style=solid]; +"118 conv_transpose2d" -> "119 quantize_per_tensor_default_6" [label="(1, 512, 12, 12)", style=solid]; +"119 quantize_per_tensor_default_6" -> "120 dequantize_per_tensor_default_9" [label="(1, 512, 12, 12)", style=solid]; +"120 dequantize_per_tensor_default_9" -> "125 cat" [label="(1, 512, 12, 12)", style=solid]; +"121 slice_1" -> "122 slice_2" [label="(1, 512, 20, 20)", style=solid]; +"122 slice_2" -> "123 slice_3" [label="(1, 512, 20, 20)", style=solid]; +"123 slice_3" -> "124 slice_4" [label="(1, 512, 12, 20)", style=solid]; +"124 slice_4" -> "125 cat" [label="(1, 512, 12, 12)", style=solid]; +"125 cat" -> "130 conv2d_10" [label="(1, 1024, 12, 12)", style=solid]; +"126 conv2d_10_scale_0" -> "129 dequantize_per_channel_default_11" [label="(512,)", style=solid]; +"127 conv2d_10_zero_point_0" -> "129 dequantize_per_channel_default_11" [label="(512,)", style=solid]; +"128 _frozen_param11" -> "129 dequantize_per_channel_default_11" [label="(512, 1024, 3, 3)", style=solid]; +"129 dequantize_per_channel_default_11" -> "130 conv2d_10" [label="(512, 1024, 3, 3)", style=solid]; +"130 conv2d_10" -> "131 relu_10" [label="(1, 512, 10, 10)", style=solid]; +"131 relu_10" -> "132 quantize_per_tensor_default_15" [label="(1, 512, 10, 10)", style=solid]; +"132 quantize_per_tensor_default_15" -> "133 dequantize_per_tensor_default_19" [label="(1, 512, 10, 10)", style=solid]; +"133 dequantize_per_tensor_default_19" -> "138 conv2d_11" [label="(1, 512, 10, 10)", style=solid]; +"134 conv2d_11_scale_0" -> "137 dequantize_per_channel_default_12" [label="(512,)", style=solid]; +"135 conv2d_11_zero_point_0" -> "137 dequantize_per_channel_default_12" [label="(512,)", style=solid]; +"136 _frozen_param12" -> "137 dequantize_per_channel_default_12" [label="(512, 512, 3, 3)", style=solid]; +"137 dequantize_per_channel_default_12" -> "138 conv2d_11" [label="(512, 512, 3, 3)", style=solid]; +"138 conv2d_11" -> "139 relu_11" [label="(1, 512, 8, 8)", style=solid]; +"139 relu_11" -> "140 quantize_per_tensor_default_16" [label="(1, 512, 8, 8)", style=solid]; +"140 quantize_per_tensor_default_16" -> "141 dequantize_per_tensor_default_20" [label="(1, 512, 8, 8)", style=solid]; +"141 dequantize_per_tensor_default_20" -> "146 conv_transpose2d_1" [label="(1, 512, 8, 8)", style=solid]; +"142 conv_transpose2d_1_scale_0" -> "145 dequantize_per_channel_default_13" [label="(512,)", style=solid]; +"143 conv_transpose2d_1_zero_point_0" -> "145 dequantize_per_channel_default_13" [label="(512,)", style=solid]; +"144 _frozen_param13" -> "145 dequantize_per_channel_default_13" [label="(512, 256, 2, 2)", style=solid]; +"145 dequantize_per_channel_default_13" -> "146 conv_transpose2d_1" [label="(512, 256, 2, 2)", style=solid]; +"146 conv_transpose2d_1" -> "147 quantize_per_tensor_default_5" [label="(1, 256, 16, 16)", style=solid]; +"147 quantize_per_tensor_default_5" -> "148 dequantize_per_tensor_default_8" [label="(1, 256, 16, 16)", style=solid]; +"148 dequantize_per_tensor_default_8" -> "153 cat_1" [label="(1, 256, 16, 16)", style=solid]; +"149 slice_5" -> "150 slice_6" [label="(1, 256, 49, 49)", style=solid]; +"150 slice_6" -> "151 slice_7" [label="(1, 256, 49, 49)", style=solid]; +"151 slice_7" -> "152 slice_8" [label="(1, 256, 16, 49)", style=solid]; +"152 slice_8" -> "153 cat_1" [label="(1, 256, 16, 16)", style=solid]; +"153 cat_1" -> "158 conv2d_12" [label="(1, 512, 16, 16)", style=solid]; +"154 conv2d_12_scale_0" -> "157 dequantize_per_channel_default_14" [label="(256,)", style=solid]; +"155 conv2d_12_zero_point_0" -> "157 dequantize_per_channel_default_14" [label="(256,)", style=solid]; +"156 _frozen_param14" -> "157 dequantize_per_channel_default_14" [label="(256, 512, 3, 3)", style=solid]; +"157 dequantize_per_channel_default_14" -> "158 conv2d_12" [label="(256, 512, 3, 3)", style=solid]; +"158 conv2d_12" -> "159 relu_12" [label="(1, 256, 14, 14)", style=solid]; +"159 relu_12" -> "160 quantize_per_tensor_default_17" [label="(1, 256, 14, 14)", style=solid]; +"160 quantize_per_tensor_default_17" -> "161 dequantize_per_tensor_default_21" [label="(1, 256, 14, 14)", style=solid]; +"161 dequantize_per_tensor_default_21" -> "166 conv2d_13" [label="(1, 256, 14, 14)", style=solid]; +"162 conv2d_13_scale_0" -> "165 dequantize_per_channel_default_15" [label="(256,)", style=solid]; +"163 conv2d_13_zero_point_0" -> "165 dequantize_per_channel_default_15" [label="(256,)", style=solid]; +"164 _frozen_param15" -> "165 dequantize_per_channel_default_15" [label="(256, 256, 3, 3)", style=solid]; +"165 dequantize_per_channel_default_15" -> "166 conv2d_13" [label="(256, 256, 3, 3)", style=solid]; +"166 conv2d_13" -> "167 relu_13" [label="(1, 256, 12, 12)", style=solid]; +"167 relu_13" -> "168 quantize_per_tensor_default_18" [label="(1, 256, 12, 12)", style=solid]; +"168 quantize_per_tensor_default_18" -> "169 dequantize_per_tensor_default_22" [label="(1, 256, 12, 12)", style=solid]; +"169 dequantize_per_tensor_default_22" -> "174 conv_transpose2d_2" [label="(1, 256, 12, 12)", style=solid]; +"170 conv_transpose2d_2_scale_0" -> "173 dequantize_per_channel_default_16" [label="(256,)", style=solid]; +"171 conv_transpose2d_2_zero_point_0" -> "173 dequantize_per_channel_default_16" [label="(256,)", style=solid]; +"172 _frozen_param16" -> "173 dequantize_per_channel_default_16" [label="(256, 128, 2, 2)", style=solid]; +"173 dequantize_per_channel_default_16" -> "174 conv_transpose2d_2" [label="(256, 128, 2, 2)", style=solid]; +"174 conv_transpose2d_2" -> "175 quantize_per_tensor_default_2" [label="(1, 128, 24, 24)", style=solid]; +"175 quantize_per_tensor_default_2" -> "176 dequantize_per_tensor_default_3" [label="(1, 128, 24, 24)", style=solid]; +"176 dequantize_per_tensor_default_3" -> "181 cat_2" [label="(1, 128, 24, 24)", style=solid]; +"177 slice_9" -> "178 slice_10" [label="(1, 128, 106, 106)", style=solid]; +"178 slice_10" -> "179 slice_11" [label="(1, 128, 106, 106)", style=solid]; +"179 slice_11" -> "180 slice_12" [label="(1, 128, 24, 106)", style=solid]; +"180 slice_12" -> "181 cat_2" [label="(1, 128, 24, 24)", style=solid]; +"181 cat_2" -> "186 conv2d_14" [label="(1, 256, 24, 24)", style=solid]; +"182 conv2d_14_scale_0" -> "185 dequantize_per_channel_default_17" [label="(128,)", style=solid]; +"183 conv2d_14_zero_point_0" -> "185 dequantize_per_channel_default_17" [label="(128,)", style=solid]; +"184 _frozen_param17" -> "185 dequantize_per_channel_default_17" [label="(128, 256, 3, 3)", style=solid]; +"185 dequantize_per_channel_default_17" -> "186 conv2d_14" [label="(128, 256, 3, 3)", style=solid]; +"186 conv2d_14" -> "187 relu_14" [label="(1, 128, 22, 22)", style=solid]; +"187 relu_14" -> "188 quantize_per_tensor_default_19" [label="(1, 128, 22, 22)", style=solid]; +"188 quantize_per_tensor_default_19" -> "189 dequantize_per_tensor_default_23" [label="(1, 128, 22, 22)", style=solid]; +"189 dequantize_per_tensor_default_23" -> "194 conv2d_15" [label="(1, 128, 22, 22)", style=solid]; +"190 conv2d_15_scale_0" -> "193 dequantize_per_channel_default_18" [label="(128,)", style=solid]; +"191 conv2d_15_zero_point_0" -> "193 dequantize_per_channel_default_18" [label="(128,)", style=solid]; +"192 _frozen_param18" -> "193 dequantize_per_channel_default_18" [label="(128, 128, 3, 3)", style=solid]; +"193 dequantize_per_channel_default_18" -> "194 conv2d_15" [label="(128, 128, 3, 3)", style=solid]; +"194 conv2d_15" -> "195 relu_15" [label="(1, 128, 20, 20)", style=solid]; +"195 relu_15" -> "196 quantize_per_tensor_default_20" [label="(1, 128, 20, 20)", style=solid]; +"196 quantize_per_tensor_default_20" -> "197 dequantize_per_tensor_default_24" [label="(1, 128, 20, 20)", style=solid]; +"197 dequantize_per_tensor_default_24" -> "202 conv_transpose2d_3" [label="(1, 128, 20, 20)", style=solid]; +"198 conv_transpose2d_3_scale_0" -> "201 dequantize_per_channel_default_19" [label="(128,)", style=solid]; +"199 conv_transpose2d_3_zero_point_0" -> "201 dequantize_per_channel_default_19" [label="(128,)", style=solid]; +"200 _frozen_param19" -> "201 dequantize_per_channel_default_19" [label="(128, 64, 2, 2)", style=solid]; +"201 dequantize_per_channel_default_19" -> "202 conv_transpose2d_3" [label="(128, 64, 2, 2)", style=solid]; +"202 conv_transpose2d_3" -> "203 quantize_per_tensor_default_1" [label="(1, 64, 40, 40)", style=solid]; +"203 quantize_per_tensor_default_1" -> "204 dequantize_per_tensor_default_2" [label="(1, 64, 40, 40)", style=solid]; +"204 dequantize_per_tensor_default_2" -> "209 cat_3" [label="(1, 64, 40, 40)", style=solid]; +"205 slice_13" -> "206 slice_14" [label="(1, 64, 220, 220)", style=solid]; +"206 slice_14" -> "207 slice_15" [label="(1, 64, 220, 220)", style=solid]; +"207 slice_15" -> "208 slice_16" [label="(1, 64, 40, 220)", style=solid]; +"208 slice_16" -> "209 cat_3" [label="(1, 64, 40, 40)", style=solid]; +"209 cat_3" -> "214 conv2d_16" [label="(1, 128, 40, 40)", style=solid]; +"210 conv2d_16_scale_0" -> "213 dequantize_per_channel_default_20" [label="(64,)", style=solid]; +"211 conv2d_16_zero_point_0" -> "213 dequantize_per_channel_default_20" [label="(64,)", style=solid]; +"212 _frozen_param20" -> "213 dequantize_per_channel_default_20" [label="(64, 128, 3, 3)", style=solid]; +"213 dequantize_per_channel_default_20" -> "214 conv2d_16" [label="(64, 128, 3, 3)", style=solid]; +"214 conv2d_16" -> "215 relu_16" [label="(1, 64, 38, 38)", style=solid]; +"215 relu_16" -> "216 quantize_per_tensor_default_21" [label="(1, 64, 38, 38)", style=solid]; +"216 quantize_per_tensor_default_21" -> "217 dequantize_per_tensor_default_25" [label="(1, 64, 38, 38)", style=solid]; +"217 dequantize_per_tensor_default_25" -> "222 conv2d_17" [label="(1, 64, 38, 38)", style=solid]; +"218 conv2d_17_scale_0" -> "221 dequantize_per_channel_default_21" [label="(64,)", style=solid]; +"219 conv2d_17_zero_point_0" -> "221 dequantize_per_channel_default_21" [label="(64,)", style=solid]; +"220 _frozen_param21" -> "221 dequantize_per_channel_default_21" [label="(64, 64, 3, 3)", style=solid]; +"221 dequantize_per_channel_default_21" -> "222 conv2d_17" [label="(64, 64, 3, 3)", style=solid]; +"222 conv2d_17" -> "223 relu_17" [label="(1, 64, 36, 36)", style=solid]; +"223 relu_17" -> "224 quantize_per_tensor_default_22" [label="(1, 64, 36, 36)", style=solid]; +"224 quantize_per_tensor_default_22" -> "225 dequantize_per_tensor_default_26" [label="(1, 64, 36, 36)", style=solid]; +"225 dequantize_per_tensor_default_26" -> "230 conv2d_18" [label="(1, 64, 36, 36)", style=solid]; +"226 conv2d_18_scale_0" -> "229 dequantize_per_channel_default_22" [label="(12,)", style=solid]; +"227 conv2d_18_zero_point_0" -> "229 dequantize_per_channel_default_22" [label="(12,)", style=solid]; +"228 _frozen_param22" -> "229 dequantize_per_channel_default_22" [label="(12, 64, 1, 1)", style=solid]; +"229 dequantize_per_channel_default_22" -> "230 conv2d_18" [label="(12, 64, 1, 1)", style=solid]; +"230 conv2d_18" -> "231 output" [label="(1, 12, 36, 36)", style=solid]; +} diff --git a/tests/torch/data/reference_graphs/fx/experimental/OpenVINOQuantizer/vit_b_16.dot b/tests/torch/data/reference_graphs/fx/experimental/OpenVINOQuantizer/vit_b_16.dot new file mode 100644 index 00000000000..6209b772176 --- /dev/null +++ b/tests/torch/data/reference_graphs/fx/experimental/OpenVINOQuantizer/vit_b_16.dot @@ -0,0 +1,1913 @@ +strict digraph { +"0 class_token" [id=0, type=get_attr]; +"1 encoder_pos_embedding" [id=1, type=get_attr]; +"2 conv_proj_bias" [id=2, type=get_attr]; +"3 encoder_layers_encoder_layer_0_ln_1_weight" [id=3, type=get_attr]; +"4 encoder_layers_encoder_layer_0_ln_1_bias" [id=4, type=get_attr]; +"5 encoder_layers_encoder_layer_0_self_attention_in_proj_bias" [id=5, type=get_attr]; +"6 encoder_layers_encoder_layer_0_self_attention_out_proj_bias" [id=6, type=get_attr]; +"7 encoder_layers_encoder_layer_0_ln_2_weight" [id=7, type=get_attr]; +"8 encoder_layers_encoder_layer_0_ln_2_bias" [id=8, type=get_attr]; +"9 encoder_layers_encoder_layer_0_mlp_0_bias" [id=9, type=get_attr]; +"10 encoder_layers_encoder_layer_0_mlp_3_bias" [id=10, type=get_attr]; +"11 encoder_layers_encoder_layer_1_ln_1_weight" [id=11, type=get_attr]; +"12 encoder_layers_encoder_layer_1_ln_1_bias" [id=12, type=get_attr]; +"13 encoder_layers_encoder_layer_1_self_attention_in_proj_bias" [id=13, type=get_attr]; +"14 encoder_layers_encoder_layer_1_self_attention_out_proj_bias" [id=14, type=get_attr]; +"15 encoder_layers_encoder_layer_1_ln_2_weight" [id=15, type=get_attr]; +"16 encoder_layers_encoder_layer_1_ln_2_bias" [id=16, type=get_attr]; +"17 encoder_layers_encoder_layer_1_mlp_0_bias" [id=17, type=get_attr]; +"18 encoder_layers_encoder_layer_1_mlp_3_bias" [id=18, type=get_attr]; +"19 encoder_layers_encoder_layer_2_ln_1_weight" [id=19, type=get_attr]; +"20 encoder_layers_encoder_layer_2_ln_1_bias" [id=20, type=get_attr]; +"21 encoder_layers_encoder_layer_2_self_attention_in_proj_bias" [id=21, type=get_attr]; +"22 encoder_layers_encoder_layer_2_self_attention_out_proj_bias" [id=22, type=get_attr]; +"23 encoder_layers_encoder_layer_2_ln_2_weight" [id=23, type=get_attr]; +"24 encoder_layers_encoder_layer_2_ln_2_bias" [id=24, type=get_attr]; +"25 encoder_layers_encoder_layer_2_mlp_0_bias" [id=25, type=get_attr]; +"26 encoder_layers_encoder_layer_2_mlp_3_bias" [id=26, type=get_attr]; +"27 encoder_layers_encoder_layer_3_ln_1_weight" [id=27, type=get_attr]; +"28 encoder_layers_encoder_layer_3_ln_1_bias" [id=28, type=get_attr]; +"29 encoder_layers_encoder_layer_3_self_attention_in_proj_bias" [id=29, type=get_attr]; +"30 encoder_layers_encoder_layer_3_self_attention_out_proj_bias" [id=30, type=get_attr]; +"31 encoder_layers_encoder_layer_3_ln_2_weight" [id=31, type=get_attr]; +"32 encoder_layers_encoder_layer_3_ln_2_bias" [id=32, type=get_attr]; +"33 encoder_layers_encoder_layer_3_mlp_0_bias" [id=33, type=get_attr]; +"34 encoder_layers_encoder_layer_3_mlp_3_bias" [id=34, type=get_attr]; +"35 encoder_layers_encoder_layer_4_ln_1_weight" [id=35, type=get_attr]; +"36 encoder_layers_encoder_layer_4_ln_1_bias" [id=36, type=get_attr]; +"37 encoder_layers_encoder_layer_4_self_attention_in_proj_bias" [id=37, type=get_attr]; +"38 encoder_layers_encoder_layer_4_self_attention_out_proj_bias" [id=38, type=get_attr]; +"39 encoder_layers_encoder_layer_4_ln_2_weight" [id=39, type=get_attr]; +"40 encoder_layers_encoder_layer_4_ln_2_bias" [id=40, type=get_attr]; +"41 encoder_layers_encoder_layer_4_mlp_0_bias" [id=41, type=get_attr]; +"42 encoder_layers_encoder_layer_4_mlp_3_bias" [id=42, type=get_attr]; +"43 encoder_layers_encoder_layer_5_ln_1_weight" [id=43, type=get_attr]; +"44 encoder_layers_encoder_layer_5_ln_1_bias" [id=44, type=get_attr]; +"45 encoder_layers_encoder_layer_5_self_attention_in_proj_bias" [id=45, type=get_attr]; +"46 encoder_layers_encoder_layer_5_self_attention_out_proj_bias" [id=46, type=get_attr]; +"47 encoder_layers_encoder_layer_5_ln_2_weight" [id=47, type=get_attr]; +"48 encoder_layers_encoder_layer_5_ln_2_bias" [id=48, type=get_attr]; +"49 encoder_layers_encoder_layer_5_mlp_0_bias" [id=49, type=get_attr]; +"50 encoder_layers_encoder_layer_5_mlp_3_bias" [id=50, type=get_attr]; +"51 encoder_layers_encoder_layer_6_ln_1_weight" [id=51, type=get_attr]; +"52 encoder_layers_encoder_layer_6_ln_1_bias" [id=52, type=get_attr]; +"53 encoder_layers_encoder_layer_6_self_attention_in_proj_bias" [id=53, type=get_attr]; +"54 encoder_layers_encoder_layer_6_self_attention_out_proj_bias" [id=54, type=get_attr]; +"55 encoder_layers_encoder_layer_6_ln_2_weight" [id=55, type=get_attr]; +"56 encoder_layers_encoder_layer_6_ln_2_bias" [id=56, type=get_attr]; +"57 encoder_layers_encoder_layer_6_mlp_0_bias" [id=57, type=get_attr]; +"58 encoder_layers_encoder_layer_6_mlp_3_bias" [id=58, type=get_attr]; +"59 encoder_layers_encoder_layer_7_ln_1_weight" [id=59, type=get_attr]; +"60 encoder_layers_encoder_layer_7_ln_1_bias" [id=60, type=get_attr]; +"61 encoder_layers_encoder_layer_7_self_attention_in_proj_bias" [id=61, type=get_attr]; +"62 encoder_layers_encoder_layer_7_self_attention_out_proj_bias" [id=62, type=get_attr]; +"63 encoder_layers_encoder_layer_7_ln_2_weight" [id=63, type=get_attr]; +"64 encoder_layers_encoder_layer_7_ln_2_bias" [id=64, type=get_attr]; +"65 encoder_layers_encoder_layer_7_mlp_0_bias" [id=65, type=get_attr]; +"66 encoder_layers_encoder_layer_7_mlp_3_bias" [id=66, type=get_attr]; +"67 encoder_layers_encoder_layer_8_ln_1_weight" [id=67, type=get_attr]; +"68 encoder_layers_encoder_layer_8_ln_1_bias" [id=68, type=get_attr]; +"69 encoder_layers_encoder_layer_8_self_attention_in_proj_bias" [id=69, type=get_attr]; +"70 encoder_layers_encoder_layer_8_self_attention_out_proj_bias" [id=70, type=get_attr]; +"71 encoder_layers_encoder_layer_8_ln_2_weight" [id=71, type=get_attr]; +"72 encoder_layers_encoder_layer_8_ln_2_bias" [id=72, type=get_attr]; +"73 encoder_layers_encoder_layer_8_mlp_0_bias" [id=73, type=get_attr]; +"74 encoder_layers_encoder_layer_8_mlp_3_bias" [id=74, type=get_attr]; +"75 encoder_layers_encoder_layer_9_ln_1_weight" [id=75, type=get_attr]; +"76 encoder_layers_encoder_layer_9_ln_1_bias" [id=76, type=get_attr]; +"77 encoder_layers_encoder_layer_9_self_attention_in_proj_bias" [id=77, type=get_attr]; +"78 encoder_layers_encoder_layer_9_self_attention_out_proj_bias" [id=78, type=get_attr]; +"79 encoder_layers_encoder_layer_9_ln_2_weight" [id=79, type=get_attr]; +"80 encoder_layers_encoder_layer_9_ln_2_bias" [id=80, type=get_attr]; +"81 encoder_layers_encoder_layer_9_mlp_0_bias" [id=81, type=get_attr]; +"82 encoder_layers_encoder_layer_9_mlp_3_bias" [id=82, type=get_attr]; +"83 encoder_layers_encoder_layer_10_ln_1_weight" [id=83, type=get_attr]; +"84 encoder_layers_encoder_layer_10_ln_1_bias" [id=84, type=get_attr]; +"85 encoder_layers_encoder_layer_10_self_attention_in_proj_bias" [id=85, type=get_attr]; +"86 encoder_layers_encoder_layer_10_self_attention_out_proj_bias" [id=86, type=get_attr]; +"87 encoder_layers_encoder_layer_10_ln_2_weight" [id=87, type=get_attr]; +"88 encoder_layers_encoder_layer_10_ln_2_bias" [id=88, type=get_attr]; +"89 encoder_layers_encoder_layer_10_mlp_0_bias" [id=89, type=get_attr]; +"90 encoder_layers_encoder_layer_10_mlp_3_bias" [id=90, type=get_attr]; +"91 encoder_layers_encoder_layer_11_ln_1_weight" [id=91, type=get_attr]; +"92 encoder_layers_encoder_layer_11_ln_1_bias" [id=92, type=get_attr]; +"93 encoder_layers_encoder_layer_11_self_attention_in_proj_bias" [id=93, type=get_attr]; +"94 encoder_layers_encoder_layer_11_self_attention_out_proj_bias" [id=94, type=get_attr]; +"95 encoder_layers_encoder_layer_11_ln_2_weight" [id=95, type=get_attr]; +"96 encoder_layers_encoder_layer_11_ln_2_bias" [id=96, type=get_attr]; +"97 encoder_layers_encoder_layer_11_mlp_0_bias" [id=97, type=get_attr]; +"98 encoder_layers_encoder_layer_11_mlp_3_bias" [id=98, type=get_attr]; +"99 encoder_ln_weight" [id=99, type=get_attr]; +"100 encoder_ln_bias" [id=100, type=get_attr]; +"101 heads_head_bias" [id=101, type=get_attr]; +"102 x" [id=102, type=input]; +"103 quantize_per_tensor_default" [id=103, type=quantize_per_tensor]; +"104 dequantize_per_tensor_default" [id=104, type=dequantize_per_tensor]; +"105 conv2d_scale_0" [id=105, type=get_attr]; +"106 conv2d_zero_point_0" [id=106, type=get_attr]; +"107 _frozen_param0" [id=107, type=get_attr]; +"108 dequantize_per_channel_default" [id=108, type=dequantize_per_channel]; +"109 conv2d" [id=109, type=conv2d]; +"110 reshape" [id=110, type=reshape]; +"111 permute" [id=111, type=permute]; +"112 expand" [id=112, type=expand]; +"113 cat" [id=113, type=cat]; +"114 add" [id=114, type=add]; +"115 dropout" [id=115, type=dropout]; +"116 layer_norm" [id=116, type=layer_norm]; +"117 transpose" [id=117, type=transpose]; +"118 transpose_0_0_nncf_smooth_quant_0" [id=118, type=call_module]; +"119 quantize_per_tensor_default_1" [id=119, type=quantize_per_tensor]; +"120 dequantize_per_tensor_default_1" [id=120, type=dequantize_per_tensor]; +"121 linear_scale_0" [id=121, type=get_attr]; +"122 linear_zero_point_0" [id=122, type=get_attr]; +"123 _frozen_param1" [id=123, type=get_attr]; +"124 dequantize_per_channel_default_1" [id=124, type=dequantize_per_channel]; +"125 linear" [id=125, type=linear]; +"126 unflatten" [id=126, type=unflatten]; +"127 unsqueeze" [id=127, type=unsqueeze]; +"128 transpose_1" [id=128, type=transpose]; +"129 squeeze" [id=129, type=squeeze]; +"130 contiguous" [id=130, type=contiguous]; +"131 quantize_per_tensor_default_2" [id=131, type=quantize_per_tensor]; +"132 dequantize_per_tensor_default_2" [id=132, type=dequantize_per_tensor]; +"133 select" [id=133, type=select]; +"134 quantize_per_tensor_default_3" [id=134, type=quantize_per_tensor]; +"135 dequantize_per_tensor_default_3" [id=135, type=dequantize_per_tensor]; +"136 select_1" [id=136, type=select]; +"137 select_2" [id=137, type=select]; +"138 view" [id=138, type=view]; +"139 transpose_2" [id=139, type=transpose]; +"140 view_1" [id=140, type=view]; +"141 transpose_3" [id=141, type=transpose]; +"142 view_2" [id=142, type=view]; +"143 transpose_4" [id=143, type=transpose]; +"144 view_3" [id=144, type=view]; +"145 view_4" [id=145, type=view]; +"146 view_5" [id=146, type=view]; +"147 scaled_dot_product_attention" [id=147, type=scaled_dot_product_attention]; +"148 permute_1" [id=148, type=permute]; +"149 view_6" [id=149, type=view]; +"150 view_6_0_0_nncf_smooth_quant_0" [id=150, type=call_module]; +"151 quantize_per_tensor_default_4" [id=151, type=quantize_per_tensor]; +"152 dequantize_per_tensor_default_4" [id=152, type=dequantize_per_tensor]; +"153 linear_1_scale_0" [id=153, type=get_attr]; +"154 linear_1_zero_point_0" [id=154, type=get_attr]; +"155 _frozen_param2" [id=155, type=get_attr]; +"156 dequantize_per_channel_default_2" [id=156, type=dequantize_per_channel]; +"157 linear_1" [id=157, type=linear]; +"158 view_7" [id=158, type=view]; +"159 transpose_5" [id=159, type=transpose]; +"160 dropout_1" [id=160, type=dropout]; +"161 add_1" [id=161, type=add]; +"162 layer_norm_1" [id=162, type=layer_norm]; +"163 layer_norm_1_0_0_nncf_smooth_quant_0" [id=163, type=call_module]; +"164 quantize_per_tensor_default_5" [id=164, type=quantize_per_tensor]; +"165 dequantize_per_tensor_default_5" [id=165, type=dequantize_per_tensor]; +"166 linear_2_scale_0" [id=166, type=get_attr]; +"167 linear_2_zero_point_0" [id=167, type=get_attr]; +"168 _frozen_param3" [id=168, type=get_attr]; +"169 dequantize_per_channel_default_3" [id=169, type=dequantize_per_channel]; +"170 linear_2" [id=170, type=linear]; +"171 gelu" [id=171, type=gelu]; +"172 dropout_2" [id=172, type=dropout]; +"173 dropout_2_0_0_nncf_smooth_quant_0" [id=173, type=call_module]; +"174 quantize_per_tensor_default_6" [id=174, type=quantize_per_tensor]; +"175 dequantize_per_tensor_default_6" [id=175, type=dequantize_per_tensor]; +"176 linear_3_scale_0" [id=176, type=get_attr]; +"177 linear_3_zero_point_0" [id=177, type=get_attr]; +"178 _frozen_param4" [id=178, type=get_attr]; +"179 dequantize_per_channel_default_4" [id=179, type=dequantize_per_channel]; +"180 linear_3" [id=180, type=linear]; +"181 dropout_3" [id=181, type=dropout]; +"182 add_2" [id=182, type=add]; +"183 layer_norm_2" [id=183, type=layer_norm]; +"184 transpose_6" [id=184, type=transpose]; +"185 transpose_6_0_0_nncf_smooth_quant_0" [id=185, type=call_module]; +"186 quantize_per_tensor_default_7" [id=186, type=quantize_per_tensor]; +"187 dequantize_per_tensor_default_7" [id=187, type=dequantize_per_tensor]; +"188 linear_4_scale_0" [id=188, type=get_attr]; +"189 linear_4_zero_point_0" [id=189, type=get_attr]; +"190 _frozen_param5" [id=190, type=get_attr]; +"191 dequantize_per_channel_default_5" [id=191, type=dequantize_per_channel]; +"192 linear_4" [id=192, type=linear]; +"193 unflatten_1" [id=193, type=unflatten]; +"194 unsqueeze_1" [id=194, type=unsqueeze]; +"195 transpose_7" [id=195, type=transpose]; +"196 squeeze_1" [id=196, type=squeeze]; +"197 contiguous_1" [id=197, type=contiguous]; +"198 quantize_per_tensor_default_8" [id=198, type=quantize_per_tensor]; +"199 dequantize_per_tensor_default_8" [id=199, type=dequantize_per_tensor]; +"200 select_3" [id=200, type=select]; +"201 quantize_per_tensor_default_9" [id=201, type=quantize_per_tensor]; +"202 dequantize_per_tensor_default_9" [id=202, type=dequantize_per_tensor]; +"203 select_4" [id=203, type=select]; +"204 select_5" [id=204, type=select]; +"205 view_8" [id=205, type=view]; +"206 transpose_8" [id=206, type=transpose]; +"207 view_9" [id=207, type=view]; +"208 transpose_9" [id=208, type=transpose]; +"209 view_10" [id=209, type=view]; +"210 transpose_10" [id=210, type=transpose]; +"211 view_11" [id=211, type=view]; +"212 view_12" [id=212, type=view]; +"213 view_13" [id=213, type=view]; +"214 scaled_dot_product_attention_1" [id=214, type=scaled_dot_product_attention]; +"215 permute_2" [id=215, type=permute]; +"216 view_14" [id=216, type=view]; +"217 view_14_0_0_nncf_smooth_quant_0" [id=217, type=call_module]; +"218 quantize_per_tensor_default_10" [id=218, type=quantize_per_tensor]; +"219 dequantize_per_tensor_default_10" [id=219, type=dequantize_per_tensor]; +"220 linear_5_scale_0" [id=220, type=get_attr]; +"221 linear_5_zero_point_0" [id=221, type=get_attr]; +"222 _frozen_param6" [id=222, type=get_attr]; +"223 dequantize_per_channel_default_6" [id=223, type=dequantize_per_channel]; +"224 linear_5" [id=224, type=linear]; +"225 view_15" [id=225, type=view]; +"226 transpose_11" [id=226, type=transpose]; +"227 dropout_4" [id=227, type=dropout]; +"228 add_3" [id=228, type=add]; +"229 layer_norm_3" [id=229, type=layer_norm]; +"230 layer_norm_3_0_0_nncf_smooth_quant_0" [id=230, type=call_module]; +"231 quantize_per_tensor_default_11" [id=231, type=quantize_per_tensor]; +"232 dequantize_per_tensor_default_11" [id=232, type=dequantize_per_tensor]; +"233 linear_6_scale_0" [id=233, type=get_attr]; +"234 linear_6_zero_point_0" [id=234, type=get_attr]; +"235 _frozen_param7" [id=235, type=get_attr]; +"236 dequantize_per_channel_default_7" [id=236, type=dequantize_per_channel]; +"237 linear_6" [id=237, type=linear]; +"238 gelu_1" [id=238, type=gelu]; +"239 dropout_5" [id=239, type=dropout]; +"240 dropout_5_0_0_nncf_smooth_quant_0" [id=240, type=call_module]; +"241 quantize_per_tensor_default_12" [id=241, type=quantize_per_tensor]; +"242 dequantize_per_tensor_default_12" [id=242, type=dequantize_per_tensor]; +"243 linear_7_scale_0" [id=243, type=get_attr]; +"244 linear_7_zero_point_0" [id=244, type=get_attr]; +"245 _frozen_param8" [id=245, type=get_attr]; +"246 dequantize_per_channel_default_8" [id=246, type=dequantize_per_channel]; +"247 linear_7" [id=247, type=linear]; +"248 dropout_6" [id=248, type=dropout]; +"249 add_4" [id=249, type=add]; +"250 layer_norm_4" [id=250, type=layer_norm]; +"251 transpose_12" [id=251, type=transpose]; +"252 transpose_12_0_0_nncf_smooth_quant_0" [id=252, type=call_module]; +"253 quantize_per_tensor_default_13" [id=253, type=quantize_per_tensor]; +"254 dequantize_per_tensor_default_13" [id=254, type=dequantize_per_tensor]; +"255 linear_8_scale_0" [id=255, type=get_attr]; +"256 linear_8_zero_point_0" [id=256, type=get_attr]; +"257 _frozen_param9" [id=257, type=get_attr]; +"258 dequantize_per_channel_default_9" [id=258, type=dequantize_per_channel]; +"259 linear_8" [id=259, type=linear]; +"260 unflatten_2" [id=260, type=unflatten]; +"261 unsqueeze_2" [id=261, type=unsqueeze]; +"262 transpose_13" [id=262, type=transpose]; +"263 squeeze_2" [id=263, type=squeeze]; +"264 contiguous_2" [id=264, type=contiguous]; +"265 quantize_per_tensor_default_14" [id=265, type=quantize_per_tensor]; +"266 dequantize_per_tensor_default_14" [id=266, type=dequantize_per_tensor]; +"267 select_6" [id=267, type=select]; +"268 quantize_per_tensor_default_15" [id=268, type=quantize_per_tensor]; +"269 dequantize_per_tensor_default_15" [id=269, type=dequantize_per_tensor]; +"270 select_7" [id=270, type=select]; +"271 select_8" [id=271, type=select]; +"272 view_16" [id=272, type=view]; +"273 transpose_14" [id=273, type=transpose]; +"274 view_17" [id=274, type=view]; +"275 transpose_15" [id=275, type=transpose]; +"276 view_18" [id=276, type=view]; +"277 transpose_16" [id=277, type=transpose]; +"278 view_19" [id=278, type=view]; +"279 view_20" [id=279, type=view]; +"280 view_21" [id=280, type=view]; +"281 scaled_dot_product_attention_2" [id=281, type=scaled_dot_product_attention]; +"282 permute_3" [id=282, type=permute]; +"283 view_22" [id=283, type=view]; +"284 view_22_0_0_nncf_smooth_quant_0" [id=284, type=call_module]; +"285 quantize_per_tensor_default_16" [id=285, type=quantize_per_tensor]; +"286 dequantize_per_tensor_default_16" [id=286, type=dequantize_per_tensor]; +"287 linear_9_scale_0" [id=287, type=get_attr]; +"288 linear_9_zero_point_0" [id=288, type=get_attr]; +"289 _frozen_param10" [id=289, type=get_attr]; +"290 dequantize_per_channel_default_10" [id=290, type=dequantize_per_channel]; +"291 linear_9" [id=291, type=linear]; +"292 view_23" [id=292, type=view]; +"293 transpose_17" [id=293, type=transpose]; +"294 dropout_7" [id=294, type=dropout]; +"295 add_5" [id=295, type=add]; +"296 layer_norm_5" [id=296, type=layer_norm]; +"297 layer_norm_5_0_0_nncf_smooth_quant_0" [id=297, type=call_module]; +"298 quantize_per_tensor_default_17" [id=298, type=quantize_per_tensor]; +"299 dequantize_per_tensor_default_17" [id=299, type=dequantize_per_tensor]; +"300 linear_10_scale_0" [id=300, type=get_attr]; +"301 linear_10_zero_point_0" [id=301, type=get_attr]; +"302 _frozen_param11" [id=302, type=get_attr]; +"303 dequantize_per_channel_default_11" [id=303, type=dequantize_per_channel]; +"304 linear_10" [id=304, type=linear]; +"305 gelu_2" [id=305, type=gelu]; +"306 dropout_8" [id=306, type=dropout]; +"307 dropout_8_0_0_nncf_smooth_quant_0" [id=307, type=call_module]; +"308 quantize_per_tensor_default_18" [id=308, type=quantize_per_tensor]; +"309 dequantize_per_tensor_default_18" [id=309, type=dequantize_per_tensor]; +"310 linear_11_scale_0" [id=310, type=get_attr]; +"311 linear_11_zero_point_0" [id=311, type=get_attr]; +"312 _frozen_param12" [id=312, type=get_attr]; +"313 dequantize_per_channel_default_12" [id=313, type=dequantize_per_channel]; +"314 linear_11" [id=314, type=linear]; +"315 dropout_9" [id=315, type=dropout]; +"316 add_6" [id=316, type=add]; +"317 layer_norm_6" [id=317, type=layer_norm]; +"318 transpose_18" [id=318, type=transpose]; +"319 transpose_18_0_0_nncf_smooth_quant_0" [id=319, type=call_module]; +"320 quantize_per_tensor_default_19" [id=320, type=quantize_per_tensor]; +"321 dequantize_per_tensor_default_19" [id=321, type=dequantize_per_tensor]; +"322 linear_12_scale_0" [id=322, type=get_attr]; +"323 linear_12_zero_point_0" [id=323, type=get_attr]; +"324 _frozen_param13" [id=324, type=get_attr]; +"325 dequantize_per_channel_default_13" [id=325, type=dequantize_per_channel]; +"326 linear_12" [id=326, type=linear]; +"327 unflatten_3" [id=327, type=unflatten]; +"328 unsqueeze_3" [id=328, type=unsqueeze]; +"329 transpose_19" [id=329, type=transpose]; +"330 squeeze_3" [id=330, type=squeeze]; +"331 contiguous_3" [id=331, type=contiguous]; +"332 quantize_per_tensor_default_20" [id=332, type=quantize_per_tensor]; +"333 dequantize_per_tensor_default_20" [id=333, type=dequantize_per_tensor]; +"334 select_9" [id=334, type=select]; +"335 quantize_per_tensor_default_21" [id=335, type=quantize_per_tensor]; +"336 dequantize_per_tensor_default_21" [id=336, type=dequantize_per_tensor]; +"337 select_10" [id=337, type=select]; +"338 select_11" [id=338, type=select]; +"339 view_24" [id=339, type=view]; +"340 transpose_20" [id=340, type=transpose]; +"341 view_25" [id=341, type=view]; +"342 transpose_21" [id=342, type=transpose]; +"343 view_26" [id=343, type=view]; +"344 transpose_22" [id=344, type=transpose]; +"345 view_27" [id=345, type=view]; +"346 view_28" [id=346, type=view]; +"347 view_29" [id=347, type=view]; +"348 scaled_dot_product_attention_3" [id=348, type=scaled_dot_product_attention]; +"349 permute_4" [id=349, type=permute]; +"350 view_30" [id=350, type=view]; +"351 view_30_0_0_nncf_smooth_quant_0" [id=351, type=call_module]; +"352 quantize_per_tensor_default_22" [id=352, type=quantize_per_tensor]; +"353 dequantize_per_tensor_default_22" [id=353, type=dequantize_per_tensor]; +"354 linear_13_scale_0" [id=354, type=get_attr]; +"355 linear_13_zero_point_0" [id=355, type=get_attr]; +"356 _frozen_param14" [id=356, type=get_attr]; +"357 dequantize_per_channel_default_14" [id=357, type=dequantize_per_channel]; +"358 linear_13" [id=358, type=linear]; +"359 view_31" [id=359, type=view]; +"360 transpose_23" [id=360, type=transpose]; +"361 dropout_10" [id=361, type=dropout]; +"362 add_7" [id=362, type=add]; +"363 layer_norm_7" [id=363, type=layer_norm]; +"364 layer_norm_7_0_0_nncf_smooth_quant_0" [id=364, type=call_module]; +"365 quantize_per_tensor_default_23" [id=365, type=quantize_per_tensor]; +"366 dequantize_per_tensor_default_23" [id=366, type=dequantize_per_tensor]; +"367 linear_14_scale_0" [id=367, type=get_attr]; +"368 linear_14_zero_point_0" [id=368, type=get_attr]; +"369 _frozen_param15" [id=369, type=get_attr]; +"370 dequantize_per_channel_default_15" [id=370, type=dequantize_per_channel]; +"371 linear_14" [id=371, type=linear]; +"372 gelu_3" [id=372, type=gelu]; +"373 dropout_11" [id=373, type=dropout]; +"374 dropout_11_0_0_nncf_smooth_quant_0" [id=374, type=call_module]; +"375 quantize_per_tensor_default_24" [id=375, type=quantize_per_tensor]; +"376 dequantize_per_tensor_default_24" [id=376, type=dequantize_per_tensor]; +"377 linear_15_scale_0" [id=377, type=get_attr]; +"378 linear_15_zero_point_0" [id=378, type=get_attr]; +"379 _frozen_param16" [id=379, type=get_attr]; +"380 dequantize_per_channel_default_16" [id=380, type=dequantize_per_channel]; +"381 linear_15" [id=381, type=linear]; +"382 dropout_12" [id=382, type=dropout]; +"383 add_8" [id=383, type=add]; +"384 layer_norm_8" [id=384, type=layer_norm]; +"385 transpose_24" [id=385, type=transpose]; +"386 transpose_24_0_0_nncf_smooth_quant_0" [id=386, type=call_module]; +"387 quantize_per_tensor_default_25" [id=387, type=quantize_per_tensor]; +"388 dequantize_per_tensor_default_25" [id=388, type=dequantize_per_tensor]; +"389 linear_16_scale_0" [id=389, type=get_attr]; +"390 linear_16_zero_point_0" [id=390, type=get_attr]; +"391 _frozen_param17" [id=391, type=get_attr]; +"392 dequantize_per_channel_default_17" [id=392, type=dequantize_per_channel]; +"393 linear_16" [id=393, type=linear]; +"394 unflatten_4" [id=394, type=unflatten]; +"395 unsqueeze_4" [id=395, type=unsqueeze]; +"396 transpose_25" [id=396, type=transpose]; +"397 squeeze_4" [id=397, type=squeeze]; +"398 contiguous_4" [id=398, type=contiguous]; +"399 quantize_per_tensor_default_26" [id=399, type=quantize_per_tensor]; +"400 dequantize_per_tensor_default_26" [id=400, type=dequantize_per_tensor]; +"401 select_12" [id=401, type=select]; +"402 quantize_per_tensor_default_27" [id=402, type=quantize_per_tensor]; +"403 dequantize_per_tensor_default_27" [id=403, type=dequantize_per_tensor]; +"404 select_13" [id=404, type=select]; +"405 select_14" [id=405, type=select]; +"406 view_32" [id=406, type=view]; +"407 transpose_26" [id=407, type=transpose]; +"408 view_33" [id=408, type=view]; +"409 transpose_27" [id=409, type=transpose]; +"410 view_34" [id=410, type=view]; +"411 transpose_28" [id=411, type=transpose]; +"412 view_35" [id=412, type=view]; +"413 view_36" [id=413, type=view]; +"414 view_37" [id=414, type=view]; +"415 scaled_dot_product_attention_4" [id=415, type=scaled_dot_product_attention]; +"416 permute_5" [id=416, type=permute]; +"417 view_38" [id=417, type=view]; +"418 view_38_0_0_nncf_smooth_quant_0" [id=418, type=call_module]; +"419 quantize_per_tensor_default_28" [id=419, type=quantize_per_tensor]; +"420 dequantize_per_tensor_default_28" [id=420, type=dequantize_per_tensor]; +"421 linear_17_scale_0" [id=421, type=get_attr]; +"422 linear_17_zero_point_0" [id=422, type=get_attr]; +"423 _frozen_param18" [id=423, type=get_attr]; +"424 dequantize_per_channel_default_18" [id=424, type=dequantize_per_channel]; +"425 linear_17" [id=425, type=linear]; +"426 view_39" [id=426, type=view]; +"427 transpose_29" [id=427, type=transpose]; +"428 dropout_13" [id=428, type=dropout]; +"429 add_9" [id=429, type=add]; +"430 layer_norm_9" [id=430, type=layer_norm]; +"431 layer_norm_9_0_0_nncf_smooth_quant_0" [id=431, type=call_module]; +"432 quantize_per_tensor_default_29" [id=432, type=quantize_per_tensor]; +"433 dequantize_per_tensor_default_29" [id=433, type=dequantize_per_tensor]; +"434 linear_18_scale_0" [id=434, type=get_attr]; +"435 linear_18_zero_point_0" [id=435, type=get_attr]; +"436 _frozen_param19" [id=436, type=get_attr]; +"437 dequantize_per_channel_default_19" [id=437, type=dequantize_per_channel]; +"438 linear_18" [id=438, type=linear]; +"439 gelu_4" [id=439, type=gelu]; +"440 dropout_14" [id=440, type=dropout]; +"441 dropout_14_0_0_nncf_smooth_quant_0" [id=441, type=call_module]; +"442 quantize_per_tensor_default_30" [id=442, type=quantize_per_tensor]; +"443 dequantize_per_tensor_default_30" [id=443, type=dequantize_per_tensor]; +"444 linear_19_scale_0" [id=444, type=get_attr]; +"445 linear_19_zero_point_0" [id=445, type=get_attr]; +"446 _frozen_param20" [id=446, type=get_attr]; +"447 dequantize_per_channel_default_20" [id=447, type=dequantize_per_channel]; +"448 linear_19" [id=448, type=linear]; +"449 dropout_15" [id=449, type=dropout]; +"450 add_10" [id=450, type=add]; +"451 layer_norm_10" [id=451, type=layer_norm]; +"452 transpose_30" [id=452, type=transpose]; +"453 transpose_30_0_0_nncf_smooth_quant_0" [id=453, type=call_module]; +"454 quantize_per_tensor_default_31" [id=454, type=quantize_per_tensor]; +"455 dequantize_per_tensor_default_31" [id=455, type=dequantize_per_tensor]; +"456 linear_20_scale_0" [id=456, type=get_attr]; +"457 linear_20_zero_point_0" [id=457, type=get_attr]; +"458 _frozen_param21" [id=458, type=get_attr]; +"459 dequantize_per_channel_default_21" [id=459, type=dequantize_per_channel]; +"460 linear_20" [id=460, type=linear]; +"461 unflatten_5" [id=461, type=unflatten]; +"462 unsqueeze_5" [id=462, type=unsqueeze]; +"463 transpose_31" [id=463, type=transpose]; +"464 squeeze_5" [id=464, type=squeeze]; +"465 contiguous_5" [id=465, type=contiguous]; +"466 quantize_per_tensor_default_32" [id=466, type=quantize_per_tensor]; +"467 dequantize_per_tensor_default_32" [id=467, type=dequantize_per_tensor]; +"468 select_15" [id=468, type=select]; +"469 quantize_per_tensor_default_33" [id=469, type=quantize_per_tensor]; +"470 dequantize_per_tensor_default_33" [id=470, type=dequantize_per_tensor]; +"471 select_16" [id=471, type=select]; +"472 select_17" [id=472, type=select]; +"473 view_40" [id=473, type=view]; +"474 transpose_32" [id=474, type=transpose]; +"475 view_41" [id=475, type=view]; +"476 transpose_33" [id=476, type=transpose]; +"477 view_42" [id=477, type=view]; +"478 transpose_34" [id=478, type=transpose]; +"479 view_43" [id=479, type=view]; +"480 view_44" [id=480, type=view]; +"481 view_45" [id=481, type=view]; +"482 scaled_dot_product_attention_5" [id=482, type=scaled_dot_product_attention]; +"483 permute_6" [id=483, type=permute]; +"484 view_46" [id=484, type=view]; +"485 view_46_0_0_nncf_smooth_quant_0" [id=485, type=call_module]; +"486 quantize_per_tensor_default_34" [id=486, type=quantize_per_tensor]; +"487 dequantize_per_tensor_default_34" [id=487, type=dequantize_per_tensor]; +"488 linear_21_scale_0" [id=488, type=get_attr]; +"489 linear_21_zero_point_0" [id=489, type=get_attr]; +"490 _frozen_param22" [id=490, type=get_attr]; +"491 dequantize_per_channel_default_22" [id=491, type=dequantize_per_channel]; +"492 linear_21" [id=492, type=linear]; +"493 view_47" [id=493, type=view]; +"494 transpose_35" [id=494, type=transpose]; +"495 dropout_16" [id=495, type=dropout]; +"496 add_11" [id=496, type=add]; +"497 layer_norm_11" [id=497, type=layer_norm]; +"498 layer_norm_11_0_0_nncf_smooth_quant_0" [id=498, type=call_module]; +"499 quantize_per_tensor_default_35" [id=499, type=quantize_per_tensor]; +"500 dequantize_per_tensor_default_35" [id=500, type=dequantize_per_tensor]; +"501 linear_22_scale_0" [id=501, type=get_attr]; +"502 linear_22_zero_point_0" [id=502, type=get_attr]; +"503 _frozen_param23" [id=503, type=get_attr]; +"504 dequantize_per_channel_default_23" [id=504, type=dequantize_per_channel]; +"505 linear_22" [id=505, type=linear]; +"506 gelu_5" [id=506, type=gelu]; +"507 dropout_17" [id=507, type=dropout]; +"508 dropout_17_0_0_nncf_smooth_quant_0" [id=508, type=call_module]; +"509 quantize_per_tensor_default_36" [id=509, type=quantize_per_tensor]; +"510 dequantize_per_tensor_default_36" [id=510, type=dequantize_per_tensor]; +"511 linear_23_scale_0" [id=511, type=get_attr]; +"512 linear_23_zero_point_0" [id=512, type=get_attr]; +"513 _frozen_param24" [id=513, type=get_attr]; +"514 dequantize_per_channel_default_24" [id=514, type=dequantize_per_channel]; +"515 linear_23" [id=515, type=linear]; +"516 dropout_18" [id=516, type=dropout]; +"517 add_12" [id=517, type=add]; +"518 layer_norm_12" [id=518, type=layer_norm]; +"519 transpose_36" [id=519, type=transpose]; +"520 transpose_36_0_0_nncf_smooth_quant_0" [id=520, type=call_module]; +"521 quantize_per_tensor_default_37" [id=521, type=quantize_per_tensor]; +"522 dequantize_per_tensor_default_37" [id=522, type=dequantize_per_tensor]; +"523 linear_24_scale_0" [id=523, type=get_attr]; +"524 linear_24_zero_point_0" [id=524, type=get_attr]; +"525 _frozen_param25" [id=525, type=get_attr]; +"526 dequantize_per_channel_default_25" [id=526, type=dequantize_per_channel]; +"527 linear_24" [id=527, type=linear]; +"528 unflatten_6" [id=528, type=unflatten]; +"529 unsqueeze_6" [id=529, type=unsqueeze]; +"530 transpose_37" [id=530, type=transpose]; +"531 squeeze_6" [id=531, type=squeeze]; +"532 contiguous_6" [id=532, type=contiguous]; +"533 quantize_per_tensor_default_38" [id=533, type=quantize_per_tensor]; +"534 dequantize_per_tensor_default_38" [id=534, type=dequantize_per_tensor]; +"535 select_18" [id=535, type=select]; +"536 quantize_per_tensor_default_39" [id=536, type=quantize_per_tensor]; +"537 dequantize_per_tensor_default_39" [id=537, type=dequantize_per_tensor]; +"538 select_19" [id=538, type=select]; +"539 select_20" [id=539, type=select]; +"540 view_48" [id=540, type=view]; +"541 transpose_38" [id=541, type=transpose]; +"542 view_49" [id=542, type=view]; +"543 transpose_39" [id=543, type=transpose]; +"544 view_50" [id=544, type=view]; +"545 transpose_40" [id=545, type=transpose]; +"546 view_51" [id=546, type=view]; +"547 view_52" [id=547, type=view]; +"548 view_53" [id=548, type=view]; +"549 scaled_dot_product_attention_6" [id=549, type=scaled_dot_product_attention]; +"550 permute_7" [id=550, type=permute]; +"551 view_54" [id=551, type=view]; +"552 view_54_0_0_nncf_smooth_quant_0" [id=552, type=call_module]; +"553 quantize_per_tensor_default_40" [id=553, type=quantize_per_tensor]; +"554 dequantize_per_tensor_default_40" [id=554, type=dequantize_per_tensor]; +"555 linear_25_scale_0" [id=555, type=get_attr]; +"556 linear_25_zero_point_0" [id=556, type=get_attr]; +"557 _frozen_param26" [id=557, type=get_attr]; +"558 dequantize_per_channel_default_26" [id=558, type=dequantize_per_channel]; +"559 linear_25" [id=559, type=linear]; +"560 view_55" [id=560, type=view]; +"561 transpose_41" [id=561, type=transpose]; +"562 dropout_19" [id=562, type=dropout]; +"563 add_13" [id=563, type=add]; +"564 layer_norm_13" [id=564, type=layer_norm]; +"565 layer_norm_13_0_0_nncf_smooth_quant_0" [id=565, type=call_module]; +"566 quantize_per_tensor_default_41" [id=566, type=quantize_per_tensor]; +"567 dequantize_per_tensor_default_41" [id=567, type=dequantize_per_tensor]; +"568 linear_26_scale_0" [id=568, type=get_attr]; +"569 linear_26_zero_point_0" [id=569, type=get_attr]; +"570 _frozen_param27" [id=570, type=get_attr]; +"571 dequantize_per_channel_default_27" [id=571, type=dequantize_per_channel]; +"572 linear_26" [id=572, type=linear]; +"573 gelu_6" [id=573, type=gelu]; +"574 dropout_20" [id=574, type=dropout]; +"575 dropout_20_0_0_nncf_smooth_quant_0" [id=575, type=call_module]; +"576 quantize_per_tensor_default_42" [id=576, type=quantize_per_tensor]; +"577 dequantize_per_tensor_default_42" [id=577, type=dequantize_per_tensor]; +"578 linear_27_scale_0" [id=578, type=get_attr]; +"579 linear_27_zero_point_0" [id=579, type=get_attr]; +"580 _frozen_param28" [id=580, type=get_attr]; +"581 dequantize_per_channel_default_28" [id=581, type=dequantize_per_channel]; +"582 linear_27" [id=582, type=linear]; +"583 dropout_21" [id=583, type=dropout]; +"584 add_14" [id=584, type=add]; +"585 layer_norm_14" [id=585, type=layer_norm]; +"586 transpose_42" [id=586, type=transpose]; +"587 transpose_42_0_0_nncf_smooth_quant_0" [id=587, type=call_module]; +"588 quantize_per_tensor_default_43" [id=588, type=quantize_per_tensor]; +"589 dequantize_per_tensor_default_43" [id=589, type=dequantize_per_tensor]; +"590 linear_28_scale_0" [id=590, type=get_attr]; +"591 linear_28_zero_point_0" [id=591, type=get_attr]; +"592 _frozen_param29" [id=592, type=get_attr]; +"593 dequantize_per_channel_default_29" [id=593, type=dequantize_per_channel]; +"594 linear_28" [id=594, type=linear]; +"595 unflatten_7" [id=595, type=unflatten]; +"596 unsqueeze_7" [id=596, type=unsqueeze]; +"597 transpose_43" [id=597, type=transpose]; +"598 squeeze_7" [id=598, type=squeeze]; +"599 contiguous_7" [id=599, type=contiguous]; +"600 quantize_per_tensor_default_44" [id=600, type=quantize_per_tensor]; +"601 dequantize_per_tensor_default_44" [id=601, type=dequantize_per_tensor]; +"602 select_21" [id=602, type=select]; +"603 quantize_per_tensor_default_45" [id=603, type=quantize_per_tensor]; +"604 dequantize_per_tensor_default_45" [id=604, type=dequantize_per_tensor]; +"605 select_22" [id=605, type=select]; +"606 select_23" [id=606, type=select]; +"607 view_56" [id=607, type=view]; +"608 transpose_44" [id=608, type=transpose]; +"609 view_57" [id=609, type=view]; +"610 transpose_45" [id=610, type=transpose]; +"611 view_58" [id=611, type=view]; +"612 transpose_46" [id=612, type=transpose]; +"613 view_59" [id=613, type=view]; +"614 view_60" [id=614, type=view]; +"615 view_61" [id=615, type=view]; +"616 scaled_dot_product_attention_7" [id=616, type=scaled_dot_product_attention]; +"617 permute_8" [id=617, type=permute]; +"618 view_62" [id=618, type=view]; +"619 view_62_0_0_nncf_smooth_quant_0" [id=619, type=call_module]; +"620 quantize_per_tensor_default_46" [id=620, type=quantize_per_tensor]; +"621 dequantize_per_tensor_default_46" [id=621, type=dequantize_per_tensor]; +"622 linear_29_scale_0" [id=622, type=get_attr]; +"623 linear_29_zero_point_0" [id=623, type=get_attr]; +"624 _frozen_param30" [id=624, type=get_attr]; +"625 dequantize_per_channel_default_30" [id=625, type=dequantize_per_channel]; +"626 linear_29" [id=626, type=linear]; +"627 view_63" [id=627, type=view]; +"628 transpose_47" [id=628, type=transpose]; +"629 dropout_22" [id=629, type=dropout]; +"630 add_15" [id=630, type=add]; +"631 layer_norm_15" [id=631, type=layer_norm]; +"632 layer_norm_15_0_0_nncf_smooth_quant_0" [id=632, type=call_module]; +"633 quantize_per_tensor_default_47" [id=633, type=quantize_per_tensor]; +"634 dequantize_per_tensor_default_47" [id=634, type=dequantize_per_tensor]; +"635 linear_30_scale_0" [id=635, type=get_attr]; +"636 linear_30_zero_point_0" [id=636, type=get_attr]; +"637 _frozen_param31" [id=637, type=get_attr]; +"638 dequantize_per_channel_default_31" [id=638, type=dequantize_per_channel]; +"639 linear_30" [id=639, type=linear]; +"640 gelu_7" [id=640, type=gelu]; +"641 dropout_23" [id=641, type=dropout]; +"642 dropout_23_0_0_nncf_smooth_quant_0" [id=642, type=call_module]; +"643 quantize_per_tensor_default_48" [id=643, type=quantize_per_tensor]; +"644 dequantize_per_tensor_default_48" [id=644, type=dequantize_per_tensor]; +"645 linear_31_scale_0" [id=645, type=get_attr]; +"646 linear_31_zero_point_0" [id=646, type=get_attr]; +"647 _frozen_param32" [id=647, type=get_attr]; +"648 dequantize_per_channel_default_32" [id=648, type=dequantize_per_channel]; +"649 linear_31" [id=649, type=linear]; +"650 dropout_24" [id=650, type=dropout]; +"651 add_16" [id=651, type=add]; +"652 layer_norm_16" [id=652, type=layer_norm]; +"653 transpose_48" [id=653, type=transpose]; +"654 transpose_48_0_0_nncf_smooth_quant_0" [id=654, type=call_module]; +"655 quantize_per_tensor_default_49" [id=655, type=quantize_per_tensor]; +"656 dequantize_per_tensor_default_49" [id=656, type=dequantize_per_tensor]; +"657 linear_32_scale_0" [id=657, type=get_attr]; +"658 linear_32_zero_point_0" [id=658, type=get_attr]; +"659 _frozen_param33" [id=659, type=get_attr]; +"660 dequantize_per_channel_default_33" [id=660, type=dequantize_per_channel]; +"661 linear_32" [id=661, type=linear]; +"662 unflatten_8" [id=662, type=unflatten]; +"663 unsqueeze_8" [id=663, type=unsqueeze]; +"664 transpose_49" [id=664, type=transpose]; +"665 squeeze_8" [id=665, type=squeeze]; +"666 contiguous_8" [id=666, type=contiguous]; +"667 quantize_per_tensor_default_50" [id=667, type=quantize_per_tensor]; +"668 dequantize_per_tensor_default_50" [id=668, type=dequantize_per_tensor]; +"669 select_24" [id=669, type=select]; +"670 quantize_per_tensor_default_51" [id=670, type=quantize_per_tensor]; +"671 dequantize_per_tensor_default_51" [id=671, type=dequantize_per_tensor]; +"672 select_25" [id=672, type=select]; +"673 select_26" [id=673, type=select]; +"674 view_64" [id=674, type=view]; +"675 transpose_50" [id=675, type=transpose]; +"676 view_65" [id=676, type=view]; +"677 transpose_51" [id=677, type=transpose]; +"678 view_66" [id=678, type=view]; +"679 transpose_52" [id=679, type=transpose]; +"680 view_67" [id=680, type=view]; +"681 view_68" [id=681, type=view]; +"682 view_69" [id=682, type=view]; +"683 scaled_dot_product_attention_8" [id=683, type=scaled_dot_product_attention]; +"684 permute_9" [id=684, type=permute]; +"685 view_70" [id=685, type=view]; +"686 view_70_0_0_nncf_smooth_quant_0" [id=686, type=call_module]; +"687 quantize_per_tensor_default_52" [id=687, type=quantize_per_tensor]; +"688 dequantize_per_tensor_default_52" [id=688, type=dequantize_per_tensor]; +"689 linear_33_scale_0" [id=689, type=get_attr]; +"690 linear_33_zero_point_0" [id=690, type=get_attr]; +"691 _frozen_param34" [id=691, type=get_attr]; +"692 dequantize_per_channel_default_34" [id=692, type=dequantize_per_channel]; +"693 linear_33" [id=693, type=linear]; +"694 view_71" [id=694, type=view]; +"695 transpose_53" [id=695, type=transpose]; +"696 dropout_25" [id=696, type=dropout]; +"697 add_17" [id=697, type=add]; +"698 layer_norm_17" [id=698, type=layer_norm]; +"699 layer_norm_17_0_0_nncf_smooth_quant_0" [id=699, type=call_module]; +"700 quantize_per_tensor_default_53" [id=700, type=quantize_per_tensor]; +"701 dequantize_per_tensor_default_53" [id=701, type=dequantize_per_tensor]; +"702 linear_34_scale_0" [id=702, type=get_attr]; +"703 linear_34_zero_point_0" [id=703, type=get_attr]; +"704 _frozen_param35" [id=704, type=get_attr]; +"705 dequantize_per_channel_default_35" [id=705, type=dequantize_per_channel]; +"706 linear_34" [id=706, type=linear]; +"707 gelu_8" [id=707, type=gelu]; +"708 dropout_26" [id=708, type=dropout]; +"709 dropout_26_0_0_nncf_smooth_quant_0" [id=709, type=call_module]; +"710 quantize_per_tensor_default_54" [id=710, type=quantize_per_tensor]; +"711 dequantize_per_tensor_default_54" [id=711, type=dequantize_per_tensor]; +"712 linear_35_scale_0" [id=712, type=get_attr]; +"713 linear_35_zero_point_0" [id=713, type=get_attr]; +"714 _frozen_param36" [id=714, type=get_attr]; +"715 dequantize_per_channel_default_36" [id=715, type=dequantize_per_channel]; +"716 linear_35" [id=716, type=linear]; +"717 dropout_27" [id=717, type=dropout]; +"718 add_18" [id=718, type=add]; +"719 layer_norm_18" [id=719, type=layer_norm]; +"720 transpose_54" [id=720, type=transpose]; +"721 transpose_54_0_0_nncf_smooth_quant_0" [id=721, type=call_module]; +"722 quantize_per_tensor_default_55" [id=722, type=quantize_per_tensor]; +"723 dequantize_per_tensor_default_55" [id=723, type=dequantize_per_tensor]; +"724 linear_36_scale_0" [id=724, type=get_attr]; +"725 linear_36_zero_point_0" [id=725, type=get_attr]; +"726 _frozen_param37" [id=726, type=get_attr]; +"727 dequantize_per_channel_default_37" [id=727, type=dequantize_per_channel]; +"728 linear_36" [id=728, type=linear]; +"729 unflatten_9" [id=729, type=unflatten]; +"730 unsqueeze_9" [id=730, type=unsqueeze]; +"731 transpose_55" [id=731, type=transpose]; +"732 squeeze_9" [id=732, type=squeeze]; +"733 contiguous_9" [id=733, type=contiguous]; +"734 quantize_per_tensor_default_56" [id=734, type=quantize_per_tensor]; +"735 dequantize_per_tensor_default_56" [id=735, type=dequantize_per_tensor]; +"736 select_27" [id=736, type=select]; +"737 quantize_per_tensor_default_57" [id=737, type=quantize_per_tensor]; +"738 dequantize_per_tensor_default_57" [id=738, type=dequantize_per_tensor]; +"739 select_28" [id=739, type=select]; +"740 select_29" [id=740, type=select]; +"741 view_72" [id=741, type=view]; +"742 transpose_56" [id=742, type=transpose]; +"743 view_73" [id=743, type=view]; +"744 transpose_57" [id=744, type=transpose]; +"745 view_74" [id=745, type=view]; +"746 transpose_58" [id=746, type=transpose]; +"747 view_75" [id=747, type=view]; +"748 view_76" [id=748, type=view]; +"749 view_77" [id=749, type=view]; +"750 scaled_dot_product_attention_9" [id=750, type=scaled_dot_product_attention]; +"751 permute_10" [id=751, type=permute]; +"752 view_78" [id=752, type=view]; +"753 view_78_0_0_nncf_smooth_quant_0" [id=753, type=call_module]; +"754 quantize_per_tensor_default_58" [id=754, type=quantize_per_tensor]; +"755 dequantize_per_tensor_default_58" [id=755, type=dequantize_per_tensor]; +"756 linear_37_scale_0" [id=756, type=get_attr]; +"757 linear_37_zero_point_0" [id=757, type=get_attr]; +"758 _frozen_param38" [id=758, type=get_attr]; +"759 dequantize_per_channel_default_38" [id=759, type=dequantize_per_channel]; +"760 linear_37" [id=760, type=linear]; +"761 view_79" [id=761, type=view]; +"762 transpose_59" [id=762, type=transpose]; +"763 dropout_28" [id=763, type=dropout]; +"764 add_19" [id=764, type=add]; +"765 layer_norm_19" [id=765, type=layer_norm]; +"766 layer_norm_19_0_0_nncf_smooth_quant_0" [id=766, type=call_module]; +"767 quantize_per_tensor_default_59" [id=767, type=quantize_per_tensor]; +"768 dequantize_per_tensor_default_59" [id=768, type=dequantize_per_tensor]; +"769 linear_38_scale_0" [id=769, type=get_attr]; +"770 linear_38_zero_point_0" [id=770, type=get_attr]; +"771 _frozen_param39" [id=771, type=get_attr]; +"772 dequantize_per_channel_default_39" [id=772, type=dequantize_per_channel]; +"773 linear_38" [id=773, type=linear]; +"774 gelu_9" [id=774, type=gelu]; +"775 dropout_29" [id=775, type=dropout]; +"776 dropout_29_0_0_nncf_smooth_quant_0" [id=776, type=call_module]; +"777 quantize_per_tensor_default_60" [id=777, type=quantize_per_tensor]; +"778 dequantize_per_tensor_default_60" [id=778, type=dequantize_per_tensor]; +"779 linear_39_scale_0" [id=779, type=get_attr]; +"780 linear_39_zero_point_0" [id=780, type=get_attr]; +"781 _frozen_param40" [id=781, type=get_attr]; +"782 dequantize_per_channel_default_40" [id=782, type=dequantize_per_channel]; +"783 linear_39" [id=783, type=linear]; +"784 dropout_30" [id=784, type=dropout]; +"785 add_20" [id=785, type=add]; +"786 layer_norm_20" [id=786, type=layer_norm]; +"787 transpose_60" [id=787, type=transpose]; +"788 transpose_60_0_0_nncf_smooth_quant_0" [id=788, type=call_module]; +"789 quantize_per_tensor_default_61" [id=789, type=quantize_per_tensor]; +"790 dequantize_per_tensor_default_61" [id=790, type=dequantize_per_tensor]; +"791 linear_40_scale_0" [id=791, type=get_attr]; +"792 linear_40_zero_point_0" [id=792, type=get_attr]; +"793 _frozen_param41" [id=793, type=get_attr]; +"794 dequantize_per_channel_default_41" [id=794, type=dequantize_per_channel]; +"795 linear_40" [id=795, type=linear]; +"796 unflatten_10" [id=796, type=unflatten]; +"797 unsqueeze_10" [id=797, type=unsqueeze]; +"798 transpose_61" [id=798, type=transpose]; +"799 squeeze_10" [id=799, type=squeeze]; +"800 contiguous_10" [id=800, type=contiguous]; +"801 quantize_per_tensor_default_62" [id=801, type=quantize_per_tensor]; +"802 dequantize_per_tensor_default_62" [id=802, type=dequantize_per_tensor]; +"803 select_30" [id=803, type=select]; +"804 quantize_per_tensor_default_63" [id=804, type=quantize_per_tensor]; +"805 dequantize_per_tensor_default_63" [id=805, type=dequantize_per_tensor]; +"806 select_31" [id=806, type=select]; +"807 select_32" [id=807, type=select]; +"808 view_80" [id=808, type=view]; +"809 transpose_62" [id=809, type=transpose]; +"810 view_81" [id=810, type=view]; +"811 transpose_63" [id=811, type=transpose]; +"812 view_82" [id=812, type=view]; +"813 transpose_64" [id=813, type=transpose]; +"814 view_83" [id=814, type=view]; +"815 view_84" [id=815, type=view]; +"816 view_85" [id=816, type=view]; +"817 scaled_dot_product_attention_10" [id=817, type=scaled_dot_product_attention]; +"818 permute_11" [id=818, type=permute]; +"819 view_86" [id=819, type=view]; +"820 view_86_0_0_nncf_smooth_quant_0" [id=820, type=call_module]; +"821 quantize_per_tensor_default_64" [id=821, type=quantize_per_tensor]; +"822 dequantize_per_tensor_default_64" [id=822, type=dequantize_per_tensor]; +"823 linear_41_scale_0" [id=823, type=get_attr]; +"824 linear_41_zero_point_0" [id=824, type=get_attr]; +"825 _frozen_param42" [id=825, type=get_attr]; +"826 dequantize_per_channel_default_42" [id=826, type=dequantize_per_channel]; +"827 linear_41" [id=827, type=linear]; +"828 view_87" [id=828, type=view]; +"829 transpose_65" [id=829, type=transpose]; +"830 dropout_31" [id=830, type=dropout]; +"831 add_21" [id=831, type=add]; +"832 layer_norm_21" [id=832, type=layer_norm]; +"833 layer_norm_21_0_0_nncf_smooth_quant_0" [id=833, type=call_module]; +"834 quantize_per_tensor_default_65" [id=834, type=quantize_per_tensor]; +"835 dequantize_per_tensor_default_65" [id=835, type=dequantize_per_tensor]; +"836 linear_42_scale_0" [id=836, type=get_attr]; +"837 linear_42_zero_point_0" [id=837, type=get_attr]; +"838 _frozen_param43" [id=838, type=get_attr]; +"839 dequantize_per_channel_default_43" [id=839, type=dequantize_per_channel]; +"840 linear_42" [id=840, type=linear]; +"841 gelu_10" [id=841, type=gelu]; +"842 dropout_32" [id=842, type=dropout]; +"843 dropout_32_0_0_nncf_smooth_quant_0" [id=843, type=call_module]; +"844 quantize_per_tensor_default_66" [id=844, type=quantize_per_tensor]; +"845 dequantize_per_tensor_default_66" [id=845, type=dequantize_per_tensor]; +"846 linear_43_scale_0" [id=846, type=get_attr]; +"847 linear_43_zero_point_0" [id=847, type=get_attr]; +"848 _frozen_param44" [id=848, type=get_attr]; +"849 dequantize_per_channel_default_44" [id=849, type=dequantize_per_channel]; +"850 linear_43" [id=850, type=linear]; +"851 dropout_33" [id=851, type=dropout]; +"852 add_22" [id=852, type=add]; +"853 layer_norm_22" [id=853, type=layer_norm]; +"854 transpose_66" [id=854, type=transpose]; +"855 transpose_66_0_0_nncf_smooth_quant_0" [id=855, type=call_module]; +"856 quantize_per_tensor_default_67" [id=856, type=quantize_per_tensor]; +"857 dequantize_per_tensor_default_67" [id=857, type=dequantize_per_tensor]; +"858 linear_44_scale_0" [id=858, type=get_attr]; +"859 linear_44_zero_point_0" [id=859, type=get_attr]; +"860 _frozen_param45" [id=860, type=get_attr]; +"861 dequantize_per_channel_default_45" [id=861, type=dequantize_per_channel]; +"862 linear_44" [id=862, type=linear]; +"863 unflatten_11" [id=863, type=unflatten]; +"864 unsqueeze_11" [id=864, type=unsqueeze]; +"865 transpose_67" [id=865, type=transpose]; +"866 squeeze_11" [id=866, type=squeeze]; +"867 contiguous_11" [id=867, type=contiguous]; +"868 quantize_per_tensor_default_68" [id=868, type=quantize_per_tensor]; +"869 dequantize_per_tensor_default_68" [id=869, type=dequantize_per_tensor]; +"870 select_33" [id=870, type=select]; +"871 quantize_per_tensor_default_69" [id=871, type=quantize_per_tensor]; +"872 dequantize_per_tensor_default_69" [id=872, type=dequantize_per_tensor]; +"873 select_34" [id=873, type=select]; +"874 select_35" [id=874, type=select]; +"875 view_88" [id=875, type=view]; +"876 transpose_68" [id=876, type=transpose]; +"877 view_89" [id=877, type=view]; +"878 transpose_69" [id=878, type=transpose]; +"879 view_90" [id=879, type=view]; +"880 transpose_70" [id=880, type=transpose]; +"881 view_91" [id=881, type=view]; +"882 view_92" [id=882, type=view]; +"883 view_93" [id=883, type=view]; +"884 scaled_dot_product_attention_11" [id=884, type=scaled_dot_product_attention]; +"885 permute_12" [id=885, type=permute]; +"886 view_94" [id=886, type=view]; +"887 view_94_0_0_nncf_smooth_quant_0" [id=887, type=call_module]; +"888 quantize_per_tensor_default_70" [id=888, type=quantize_per_tensor]; +"889 dequantize_per_tensor_default_70" [id=889, type=dequantize_per_tensor]; +"890 linear_45_scale_0" [id=890, type=get_attr]; +"891 linear_45_zero_point_0" [id=891, type=get_attr]; +"892 _frozen_param46" [id=892, type=get_attr]; +"893 dequantize_per_channel_default_46" [id=893, type=dequantize_per_channel]; +"894 linear_45" [id=894, type=linear]; +"895 view_95" [id=895, type=view]; +"896 transpose_71" [id=896, type=transpose]; +"897 dropout_34" [id=897, type=dropout]; +"898 add_23" [id=898, type=add]; +"899 layer_norm_23" [id=899, type=layer_norm]; +"900 layer_norm_23_0_0_nncf_smooth_quant_0" [id=900, type=call_module]; +"901 quantize_per_tensor_default_71" [id=901, type=quantize_per_tensor]; +"902 dequantize_per_tensor_default_71" [id=902, type=dequantize_per_tensor]; +"903 linear_46_scale_0" [id=903, type=get_attr]; +"904 linear_46_zero_point_0" [id=904, type=get_attr]; +"905 _frozen_param47" [id=905, type=get_attr]; +"906 dequantize_per_channel_default_47" [id=906, type=dequantize_per_channel]; +"907 linear_46" [id=907, type=linear]; +"908 gelu_11" [id=908, type=gelu]; +"909 dropout_35" [id=909, type=dropout]; +"910 dropout_35_0_0_nncf_smooth_quant_0" [id=910, type=call_module]; +"911 quantize_per_tensor_default_72" [id=911, type=quantize_per_tensor]; +"912 dequantize_per_tensor_default_72" [id=912, type=dequantize_per_tensor]; +"913 linear_47_scale_0" [id=913, type=get_attr]; +"914 linear_47_zero_point_0" [id=914, type=get_attr]; +"915 _frozen_param48" [id=915, type=get_attr]; +"916 dequantize_per_channel_default_48" [id=916, type=dequantize_per_channel]; +"917 linear_47" [id=917, type=linear]; +"918 dropout_36" [id=918, type=dropout]; +"919 add_24" [id=919, type=add]; +"920 layer_norm_24" [id=920, type=layer_norm]; +"921 slice_1" [id=921, type=slice]; +"922 select_36" [id=922, type=select]; +"923 select_36_0_0_nncf_smooth_quant_0" [id=923, type=call_module]; +"924 quantize_per_tensor_default_73" [id=924, type=quantize_per_tensor]; +"925 dequantize_per_tensor_default_73" [id=925, type=dequantize_per_tensor]; +"926 linear_48_scale_0" [id=926, type=get_attr]; +"927 linear_48_zero_point_0" [id=927, type=get_attr]; +"928 _frozen_param49" [id=928, type=get_attr]; +"929 dequantize_per_channel_default_49" [id=929, type=dequantize_per_channel]; +"930 linear_48" [id=930, type=linear]; +"931 output" [id=931, type=output]; +"0 class_token" -> "112 expand" [label="(1, 1, 768)", style=solid]; +"1 encoder_pos_embedding" -> "114 add" [label="(1, 197, 768)", style=solid]; +"2 conv_proj_bias" -> "109 conv2d" [label="(768,)", style=solid]; +"3 encoder_layers_encoder_layer_0_ln_1_weight" -> "116 layer_norm" [label="(768,)", style=solid]; +"4 encoder_layers_encoder_layer_0_ln_1_bias" -> "116 layer_norm" [label="(768,)", style=solid]; +"5 encoder_layers_encoder_layer_0_self_attention_in_proj_bias" -> "125 linear" [label="(2304,)", style=solid]; +"6 encoder_layers_encoder_layer_0_self_attention_out_proj_bias" -> "157 linear_1" [label="(768,)", style=solid]; +"7 encoder_layers_encoder_layer_0_ln_2_weight" -> "162 layer_norm_1" [label="(768,)", style=solid]; +"8 encoder_layers_encoder_layer_0_ln_2_bias" -> "162 layer_norm_1" [label="(768,)", style=solid]; +"9 encoder_layers_encoder_layer_0_mlp_0_bias" -> "170 linear_2" [label="(3072,)", style=solid]; +"10 encoder_layers_encoder_layer_0_mlp_3_bias" -> "180 linear_3" [label="(768,)", style=solid]; +"11 encoder_layers_encoder_layer_1_ln_1_weight" -> "183 layer_norm_2" [label="(768,)", style=solid]; +"12 encoder_layers_encoder_layer_1_ln_1_bias" -> "183 layer_norm_2" [label="(768,)", style=solid]; +"13 encoder_layers_encoder_layer_1_self_attention_in_proj_bias" -> "192 linear_4" [label="(2304,)", style=solid]; +"14 encoder_layers_encoder_layer_1_self_attention_out_proj_bias" -> "224 linear_5" [label="(768,)", style=solid]; +"15 encoder_layers_encoder_layer_1_ln_2_weight" -> "229 layer_norm_3" [label="(768,)", style=solid]; +"16 encoder_layers_encoder_layer_1_ln_2_bias" -> "229 layer_norm_3" [label="(768,)", style=solid]; +"17 encoder_layers_encoder_layer_1_mlp_0_bias" -> "237 linear_6" [label="(3072,)", style=solid]; +"18 encoder_layers_encoder_layer_1_mlp_3_bias" -> "247 linear_7" [label="(768,)", style=solid]; +"19 encoder_layers_encoder_layer_2_ln_1_weight" -> "250 layer_norm_4" [label="(768,)", style=solid]; +"20 encoder_layers_encoder_layer_2_ln_1_bias" -> "250 layer_norm_4" [label="(768,)", style=solid]; +"21 encoder_layers_encoder_layer_2_self_attention_in_proj_bias" -> "259 linear_8" [label="(2304,)", style=solid]; +"22 encoder_layers_encoder_layer_2_self_attention_out_proj_bias" -> "291 linear_9" [label="(768,)", style=solid]; +"23 encoder_layers_encoder_layer_2_ln_2_weight" -> "296 layer_norm_5" [label="(768,)", style=solid]; +"24 encoder_layers_encoder_layer_2_ln_2_bias" -> "296 layer_norm_5" [label="(768,)", style=solid]; +"25 encoder_layers_encoder_layer_2_mlp_0_bias" -> "304 linear_10" [label="(3072,)", style=solid]; +"26 encoder_layers_encoder_layer_2_mlp_3_bias" -> "314 linear_11" [label="(768,)", style=solid]; +"27 encoder_layers_encoder_layer_3_ln_1_weight" -> "317 layer_norm_6" [label="(768,)", style=solid]; +"28 encoder_layers_encoder_layer_3_ln_1_bias" -> "317 layer_norm_6" [label="(768,)", style=solid]; +"29 encoder_layers_encoder_layer_3_self_attention_in_proj_bias" -> "326 linear_12" [label="(2304,)", style=solid]; +"30 encoder_layers_encoder_layer_3_self_attention_out_proj_bias" -> "358 linear_13" [label="(768,)", style=solid]; +"31 encoder_layers_encoder_layer_3_ln_2_weight" -> "363 layer_norm_7" [label="(768,)", style=solid]; +"32 encoder_layers_encoder_layer_3_ln_2_bias" -> "363 layer_norm_7" [label="(768,)", style=solid]; +"33 encoder_layers_encoder_layer_3_mlp_0_bias" -> "371 linear_14" [label="(3072,)", style=solid]; +"34 encoder_layers_encoder_layer_3_mlp_3_bias" -> "381 linear_15" [label="(768,)", style=solid]; +"35 encoder_layers_encoder_layer_4_ln_1_weight" -> "384 layer_norm_8" [label="(768,)", style=solid]; +"36 encoder_layers_encoder_layer_4_ln_1_bias" -> "384 layer_norm_8" [label="(768,)", style=solid]; +"37 encoder_layers_encoder_layer_4_self_attention_in_proj_bias" -> "393 linear_16" [label="(2304,)", style=solid]; +"38 encoder_layers_encoder_layer_4_self_attention_out_proj_bias" -> "425 linear_17" [label="(768,)", style=solid]; +"39 encoder_layers_encoder_layer_4_ln_2_weight" -> "430 layer_norm_9" [label="(768,)", style=solid]; +"40 encoder_layers_encoder_layer_4_ln_2_bias" -> "430 layer_norm_9" [label="(768,)", style=solid]; +"41 encoder_layers_encoder_layer_4_mlp_0_bias" -> "438 linear_18" [label="(3072,)", style=solid]; +"42 encoder_layers_encoder_layer_4_mlp_3_bias" -> "448 linear_19" [label="(768,)", style=solid]; +"43 encoder_layers_encoder_layer_5_ln_1_weight" -> "451 layer_norm_10" [label="(768,)", style=solid]; +"44 encoder_layers_encoder_layer_5_ln_1_bias" -> "451 layer_norm_10" [label="(768,)", style=solid]; +"45 encoder_layers_encoder_layer_5_self_attention_in_proj_bias" -> "460 linear_20" [label="(2304,)", style=solid]; +"46 encoder_layers_encoder_layer_5_self_attention_out_proj_bias" -> "492 linear_21" [label="(768,)", style=solid]; +"47 encoder_layers_encoder_layer_5_ln_2_weight" -> "497 layer_norm_11" [label="(768,)", style=solid]; +"48 encoder_layers_encoder_layer_5_ln_2_bias" -> "497 layer_norm_11" [label="(768,)", style=solid]; +"49 encoder_layers_encoder_layer_5_mlp_0_bias" -> "505 linear_22" [label="(3072,)", style=solid]; +"50 encoder_layers_encoder_layer_5_mlp_3_bias" -> "515 linear_23" [label="(768,)", style=solid]; +"51 encoder_layers_encoder_layer_6_ln_1_weight" -> "518 layer_norm_12" [label="(768,)", style=solid]; +"52 encoder_layers_encoder_layer_6_ln_1_bias" -> "518 layer_norm_12" [label="(768,)", style=solid]; +"53 encoder_layers_encoder_layer_6_self_attention_in_proj_bias" -> "527 linear_24" [label="(2304,)", style=solid]; +"54 encoder_layers_encoder_layer_6_self_attention_out_proj_bias" -> "559 linear_25" [label="(768,)", style=solid]; +"55 encoder_layers_encoder_layer_6_ln_2_weight" -> "564 layer_norm_13" [label="(768,)", style=solid]; +"56 encoder_layers_encoder_layer_6_ln_2_bias" -> "564 layer_norm_13" [label="(768,)", style=solid]; +"57 encoder_layers_encoder_layer_6_mlp_0_bias" -> "572 linear_26" [label="(3072,)", style=solid]; +"58 encoder_layers_encoder_layer_6_mlp_3_bias" -> "582 linear_27" [label="(768,)", style=solid]; +"59 encoder_layers_encoder_layer_7_ln_1_weight" -> "585 layer_norm_14" [label="(768,)", style=solid]; +"60 encoder_layers_encoder_layer_7_ln_1_bias" -> "585 layer_norm_14" [label="(768,)", style=solid]; +"61 encoder_layers_encoder_layer_7_self_attention_in_proj_bias" -> "594 linear_28" [label="(2304,)", style=solid]; +"62 encoder_layers_encoder_layer_7_self_attention_out_proj_bias" -> "626 linear_29" [label="(768,)", style=solid]; +"63 encoder_layers_encoder_layer_7_ln_2_weight" -> "631 layer_norm_15" [label="(768,)", style=solid]; +"64 encoder_layers_encoder_layer_7_ln_2_bias" -> "631 layer_norm_15" [label="(768,)", style=solid]; +"65 encoder_layers_encoder_layer_7_mlp_0_bias" -> "639 linear_30" [label="(3072,)", style=solid]; +"66 encoder_layers_encoder_layer_7_mlp_3_bias" -> "649 linear_31" [label="(768,)", style=solid]; +"67 encoder_layers_encoder_layer_8_ln_1_weight" -> "652 layer_norm_16" [label="(768,)", style=solid]; +"68 encoder_layers_encoder_layer_8_ln_1_bias" -> "652 layer_norm_16" [label="(768,)", style=solid]; +"69 encoder_layers_encoder_layer_8_self_attention_in_proj_bias" -> "661 linear_32" [label="(2304,)", style=solid]; +"70 encoder_layers_encoder_layer_8_self_attention_out_proj_bias" -> "693 linear_33" [label="(768,)", style=solid]; +"71 encoder_layers_encoder_layer_8_ln_2_weight" -> "698 layer_norm_17" [label="(768,)", style=solid]; +"72 encoder_layers_encoder_layer_8_ln_2_bias" -> "698 layer_norm_17" [label="(768,)", style=solid]; +"73 encoder_layers_encoder_layer_8_mlp_0_bias" -> "706 linear_34" [label="(3072,)", style=solid]; +"74 encoder_layers_encoder_layer_8_mlp_3_bias" -> "716 linear_35" [label="(768,)", style=solid]; +"75 encoder_layers_encoder_layer_9_ln_1_weight" -> "719 layer_norm_18" [label="(768,)", style=solid]; +"76 encoder_layers_encoder_layer_9_ln_1_bias" -> "719 layer_norm_18" [label="(768,)", style=solid]; +"77 encoder_layers_encoder_layer_9_self_attention_in_proj_bias" -> "728 linear_36" [label="(2304,)", style=solid]; +"78 encoder_layers_encoder_layer_9_self_attention_out_proj_bias" -> "760 linear_37" [label="(768,)", style=solid]; +"79 encoder_layers_encoder_layer_9_ln_2_weight" -> "765 layer_norm_19" [label="(768,)", style=solid]; +"80 encoder_layers_encoder_layer_9_ln_2_bias" -> "765 layer_norm_19" [label="(768,)", style=solid]; +"81 encoder_layers_encoder_layer_9_mlp_0_bias" -> "773 linear_38" [label="(3072,)", style=solid]; +"82 encoder_layers_encoder_layer_9_mlp_3_bias" -> "783 linear_39" [label="(768,)", style=solid]; +"83 encoder_layers_encoder_layer_10_ln_1_weight" -> "786 layer_norm_20" [label="(768,)", style=solid]; +"84 encoder_layers_encoder_layer_10_ln_1_bias" -> "786 layer_norm_20" [label="(768,)", style=solid]; +"85 encoder_layers_encoder_layer_10_self_attention_in_proj_bias" -> "795 linear_40" [label="(2304,)", style=solid]; +"86 encoder_layers_encoder_layer_10_self_attention_out_proj_bias" -> "827 linear_41" [label="(768,)", style=solid]; +"87 encoder_layers_encoder_layer_10_ln_2_weight" -> "832 layer_norm_21" [label="(768,)", style=solid]; +"88 encoder_layers_encoder_layer_10_ln_2_bias" -> "832 layer_norm_21" [label="(768,)", style=solid]; +"89 encoder_layers_encoder_layer_10_mlp_0_bias" -> "840 linear_42" [label="(3072,)", style=solid]; +"90 encoder_layers_encoder_layer_10_mlp_3_bias" -> "850 linear_43" [label="(768,)", style=solid]; +"91 encoder_layers_encoder_layer_11_ln_1_weight" -> "853 layer_norm_22" [label="(768,)", style=solid]; +"92 encoder_layers_encoder_layer_11_ln_1_bias" -> "853 layer_norm_22" [label="(768,)", style=solid]; +"93 encoder_layers_encoder_layer_11_self_attention_in_proj_bias" -> "862 linear_44" [label="(2304,)", style=solid]; +"94 encoder_layers_encoder_layer_11_self_attention_out_proj_bias" -> "894 linear_45" [label="(768,)", style=solid]; +"95 encoder_layers_encoder_layer_11_ln_2_weight" -> "899 layer_norm_23" [label="(768,)", style=solid]; +"96 encoder_layers_encoder_layer_11_ln_2_bias" -> "899 layer_norm_23" [label="(768,)", style=solid]; +"97 encoder_layers_encoder_layer_11_mlp_0_bias" -> "907 linear_46" [label="(3072,)", style=solid]; +"98 encoder_layers_encoder_layer_11_mlp_3_bias" -> "917 linear_47" [label="(768,)", style=solid]; +"99 encoder_ln_weight" -> "920 layer_norm_24" [label="(768,)", style=solid]; +"100 encoder_ln_bias" -> "920 layer_norm_24" [label="(768,)", style=solid]; +"101 heads_head_bias" -> "930 linear_48" [label="(1000,)", style=solid]; +"102 x" -> "103 quantize_per_tensor_default" [label="(1, 3, 224, 224)", style=solid]; +"103 quantize_per_tensor_default" -> "104 dequantize_per_tensor_default" [label="(1, 3, 224, 224)", style=solid]; +"104 dequantize_per_tensor_default" -> "109 conv2d" [label="(1, 3, 224, 224)", style=solid]; +"105 conv2d_scale_0" -> "108 dequantize_per_channel_default" [label="(768,)", style=solid]; +"106 conv2d_zero_point_0" -> "108 dequantize_per_channel_default" [label="(768,)", style=solid]; +"107 _frozen_param0" -> "108 dequantize_per_channel_default" [label="(768, 3, 16, 16)", style=solid]; +"108 dequantize_per_channel_default" -> "109 conv2d" [label="(768, 3, 16, 16)", style=solid]; +"109 conv2d" -> "110 reshape" [label="(1, 768, 14, 14)", style=solid]; +"110 reshape" -> "111 permute" [label="(1, 768, 196)", style=solid]; +"111 permute" -> "113 cat" [label="(1, 196, 768)", style=solid]; +"112 expand" -> "113 cat" [label="(1, 1, 768)", style=solid]; +"113 cat" -> "114 add" [label="(1, 197, 768)", style=solid]; +"114 add" -> "115 dropout" [label="(1, 197, 768)", style=solid]; +"115 dropout" -> "116 layer_norm" [label="(1, 197, 768)", style=solid]; +"115 dropout" -> "161 add_1" [label="(1, 197, 768)", style=solid]; +"116 layer_norm" -> "117 transpose" [label="(1, 197, 768)", style=solid]; +"117 transpose" -> "118 transpose_0_0_nncf_smooth_quant_0" [label="(197, 1, 768)", style=solid]; +"118 transpose_0_0_nncf_smooth_quant_0" -> "119 quantize_per_tensor_default_1" [label="(197, 1, 768)", style=solid]; +"119 quantize_per_tensor_default_1" -> "120 dequantize_per_tensor_default_1" [label="(197, 1, 768)", style=solid]; +"120 dequantize_per_tensor_default_1" -> "125 linear" [label="(197, 1, 768)", style=solid]; +"121 linear_scale_0" -> "124 dequantize_per_channel_default_1" [label="(2304,)", style=solid]; +"122 linear_zero_point_0" -> "124 dequantize_per_channel_default_1" [label="(2304,)", style=solid]; +"123 _frozen_param1" -> "124 dequantize_per_channel_default_1" [label="(2304, 768)", style=solid]; +"124 dequantize_per_channel_default_1" -> "125 linear" [label="(2304, 768)", style=solid]; +"125 linear" -> "126 unflatten" [label="(197, 1, 2304)", style=solid]; +"126 unflatten" -> "127 unsqueeze" [label="(197, 1, 3, 768)", style=solid]; +"127 unsqueeze" -> "128 transpose_1" [label="(1, 197, 1, 3, 768)", style=solid]; +"128 transpose_1" -> "129 squeeze" [label="(3, 197, 1, 1, 768)", style=solid]; +"129 squeeze" -> "130 contiguous" [label="(3, 197, 1, 768)", style=solid]; +"130 contiguous" -> "131 quantize_per_tensor_default_2" [label="(3, 197, 1, 768)", style=solid]; +"130 contiguous" -> "134 quantize_per_tensor_default_3" [label="(3, 197, 1, 768)", style=solid]; +"130 contiguous" -> "137 select_2" [label="(3, 197, 1, 768)", style=solid]; +"131 quantize_per_tensor_default_2" -> "132 dequantize_per_tensor_default_2" [label="(3, 197, 1, 768)", style=solid]; +"132 dequantize_per_tensor_default_2" -> "133 select" [label="(3, 197, 1, 768)", style=solid]; +"133 select" -> "138 view" [label="(197, 1, 768)", style=solid]; +"134 quantize_per_tensor_default_3" -> "135 dequantize_per_tensor_default_3" [label="(3, 197, 1, 768)", style=solid]; +"135 dequantize_per_tensor_default_3" -> "136 select_1" [label="(3, 197, 1, 768)", style=solid]; +"136 select_1" -> "140 view_1" [label="(197, 1, 768)", style=solid]; +"137 select_2" -> "142 view_2" [label="(197, 1, 768)", style=solid]; +"138 view" -> "139 transpose_2" [label="(197, 12, 64)", style=solid]; +"139 transpose_2" -> "144 view_3" [label="(12, 197, 64)", style=solid]; +"140 view_1" -> "141 transpose_3" [label="(197, 12, 64)", style=solid]; +"141 transpose_3" -> "145 view_4" [label="(12, 197, 64)", style=solid]; +"142 view_2" -> "143 transpose_4" [label="(197, 12, 64)", style=solid]; +"143 transpose_4" -> "146 view_5" [label="(12, 197, 64)", style=solid]; +"144 view_3" -> "147 scaled_dot_product_attention" [label="(1, 12, 197, 64)", style=solid]; +"145 view_4" -> "147 scaled_dot_product_attention" [label="(1, 12, 197, 64)", style=solid]; +"146 view_5" -> "147 scaled_dot_product_attention" [label="(1, 12, 197, 64)", style=solid]; +"147 scaled_dot_product_attention" -> "148 permute_1" [label="(1, 12, 197, 64)", style=solid]; +"148 permute_1" -> "149 view_6" [label="(197, 1, 12, 64)", style=solid]; +"149 view_6" -> "150 view_6_0_0_nncf_smooth_quant_0" [label="(197, 768)", style=solid]; +"150 view_6_0_0_nncf_smooth_quant_0" -> "151 quantize_per_tensor_default_4" [label="(197, 768)", style=solid]; +"151 quantize_per_tensor_default_4" -> "152 dequantize_per_tensor_default_4" [label="(197, 768)", style=solid]; +"152 dequantize_per_tensor_default_4" -> "157 linear_1" [label="(197, 768)", style=solid]; +"153 linear_1_scale_0" -> "156 dequantize_per_channel_default_2" [label="(768,)", style=solid]; +"154 linear_1_zero_point_0" -> "156 dequantize_per_channel_default_2" [label="(768,)", style=solid]; +"155 _frozen_param2" -> "156 dequantize_per_channel_default_2" [label="(768, 768)", style=solid]; +"156 dequantize_per_channel_default_2" -> "157 linear_1" [label="(768, 768)", style=solid]; +"157 linear_1" -> "158 view_7" [label="(197, 768)", style=solid]; +"158 view_7" -> "159 transpose_5" [label="(197, 1, 768)", style=solid]; +"159 transpose_5" -> "160 dropout_1" [label="(1, 197, 768)", style=solid]; +"160 dropout_1" -> "161 add_1" [label="(1, 197, 768)", style=solid]; +"161 add_1" -> "162 layer_norm_1" [label="(1, 197, 768)", style=solid]; +"161 add_1" -> "182 add_2" [label="(1, 197, 768)", style=solid]; +"162 layer_norm_1" -> "163 layer_norm_1_0_0_nncf_smooth_quant_0" [label="(1, 197, 768)", style=solid]; +"163 layer_norm_1_0_0_nncf_smooth_quant_0" -> "164 quantize_per_tensor_default_5" [label="(1, 197, 768)", style=solid]; +"164 quantize_per_tensor_default_5" -> "165 dequantize_per_tensor_default_5" [label="(1, 197, 768)", style=solid]; +"165 dequantize_per_tensor_default_5" -> "170 linear_2" [label="(1, 197, 768)", style=solid]; +"166 linear_2_scale_0" -> "169 dequantize_per_channel_default_3" [label="(3072,)", style=solid]; +"167 linear_2_zero_point_0" -> "169 dequantize_per_channel_default_3" [label="(3072,)", style=solid]; +"168 _frozen_param3" -> "169 dequantize_per_channel_default_3" [label="(3072, 768)", style=solid]; +"169 dequantize_per_channel_default_3" -> "170 linear_2" [label="(3072, 768)", style=solid]; +"170 linear_2" -> "171 gelu" [label="(1, 197, 3072)", style=solid]; +"171 gelu" -> "172 dropout_2" [label="(1, 197, 3072)", style=solid]; +"172 dropout_2" -> "173 dropout_2_0_0_nncf_smooth_quant_0" [label="(1, 197, 3072)", style=solid]; +"173 dropout_2_0_0_nncf_smooth_quant_0" -> "174 quantize_per_tensor_default_6" [label="(1, 197, 3072)", style=solid]; +"174 quantize_per_tensor_default_6" -> "175 dequantize_per_tensor_default_6" [label="(1, 197, 3072)", style=solid]; +"175 dequantize_per_tensor_default_6" -> "180 linear_3" [label="(1, 197, 3072)", style=solid]; +"176 linear_3_scale_0" -> "179 dequantize_per_channel_default_4" [label="(768,)", style=solid]; +"177 linear_3_zero_point_0" -> "179 dequantize_per_channel_default_4" [label="(768,)", style=solid]; +"178 _frozen_param4" -> "179 dequantize_per_channel_default_4" [label="(768, 3072)", style=solid]; +"179 dequantize_per_channel_default_4" -> "180 linear_3" [label="(768, 3072)", style=solid]; +"180 linear_3" -> "181 dropout_3" [label="(1, 197, 768)", style=solid]; +"181 dropout_3" -> "182 add_2" [label="(1, 197, 768)", style=solid]; +"182 add_2" -> "183 layer_norm_2" [label="(1, 197, 768)", style=solid]; +"182 add_2" -> "228 add_3" [label="(1, 197, 768)", style=solid]; +"183 layer_norm_2" -> "184 transpose_6" [label="(1, 197, 768)", style=solid]; +"184 transpose_6" -> "185 transpose_6_0_0_nncf_smooth_quant_0" [label="(197, 1, 768)", style=solid]; +"185 transpose_6_0_0_nncf_smooth_quant_0" -> "186 quantize_per_tensor_default_7" [label="(197, 1, 768)", style=solid]; +"186 quantize_per_tensor_default_7" -> "187 dequantize_per_tensor_default_7" [label="(197, 1, 768)", style=solid]; +"187 dequantize_per_tensor_default_7" -> "192 linear_4" [label="(197, 1, 768)", style=solid]; +"188 linear_4_scale_0" -> "191 dequantize_per_channel_default_5" [label="(2304,)", style=solid]; +"189 linear_4_zero_point_0" -> "191 dequantize_per_channel_default_5" [label="(2304,)", style=solid]; +"190 _frozen_param5" -> "191 dequantize_per_channel_default_5" [label="(2304, 768)", style=solid]; +"191 dequantize_per_channel_default_5" -> "192 linear_4" [label="(2304, 768)", style=solid]; +"192 linear_4" -> "193 unflatten_1" [label="(197, 1, 2304)", style=solid]; +"193 unflatten_1" -> "194 unsqueeze_1" [label="(197, 1, 3, 768)", style=solid]; +"194 unsqueeze_1" -> "195 transpose_7" [label="(1, 197, 1, 3, 768)", style=solid]; +"195 transpose_7" -> "196 squeeze_1" [label="(3, 197, 1, 1, 768)", style=solid]; +"196 squeeze_1" -> "197 contiguous_1" [label="(3, 197, 1, 768)", style=solid]; +"197 contiguous_1" -> "198 quantize_per_tensor_default_8" [label="(3, 197, 1, 768)", style=solid]; +"197 contiguous_1" -> "201 quantize_per_tensor_default_9" [label="(3, 197, 1, 768)", style=solid]; +"197 contiguous_1" -> "204 select_5" [label="(3, 197, 1, 768)", style=solid]; +"198 quantize_per_tensor_default_8" -> "199 dequantize_per_tensor_default_8" [label="(3, 197, 1, 768)", style=solid]; +"199 dequantize_per_tensor_default_8" -> "200 select_3" [label="(3, 197, 1, 768)", style=solid]; +"200 select_3" -> "205 view_8" [label="(197, 1, 768)", style=solid]; +"201 quantize_per_tensor_default_9" -> "202 dequantize_per_tensor_default_9" [label="(3, 197, 1, 768)", style=solid]; +"202 dequantize_per_tensor_default_9" -> "203 select_4" [label="(3, 197, 1, 768)", style=solid]; +"203 select_4" -> "207 view_9" [label="(197, 1, 768)", style=solid]; +"204 select_5" -> "209 view_10" [label="(197, 1, 768)", style=solid]; +"205 view_8" -> "206 transpose_8" [label="(197, 12, 64)", style=solid]; +"206 transpose_8" -> "211 view_11" [label="(12, 197, 64)", style=solid]; +"207 view_9" -> "208 transpose_9" [label="(197, 12, 64)", style=solid]; +"208 transpose_9" -> "212 view_12" [label="(12, 197, 64)", style=solid]; +"209 view_10" -> "210 transpose_10" [label="(197, 12, 64)", style=solid]; +"210 transpose_10" -> "213 view_13" [label="(12, 197, 64)", style=solid]; +"211 view_11" -> "214 scaled_dot_product_attention_1" [label="(1, 12, 197, 64)", style=solid]; +"212 view_12" -> "214 scaled_dot_product_attention_1" [label="(1, 12, 197, 64)", style=solid]; +"213 view_13" -> "214 scaled_dot_product_attention_1" [label="(1, 12, 197, 64)", style=solid]; +"214 scaled_dot_product_attention_1" -> "215 permute_2" [label="(1, 12, 197, 64)", style=solid]; +"215 permute_2" -> "216 view_14" [label="(197, 1, 12, 64)", style=solid]; +"216 view_14" -> "217 view_14_0_0_nncf_smooth_quant_0" [label="(197, 768)", style=solid]; +"217 view_14_0_0_nncf_smooth_quant_0" -> "218 quantize_per_tensor_default_10" [label="(197, 768)", style=solid]; +"218 quantize_per_tensor_default_10" -> "219 dequantize_per_tensor_default_10" [label="(197, 768)", style=solid]; +"219 dequantize_per_tensor_default_10" -> "224 linear_5" [label="(197, 768)", style=solid]; +"220 linear_5_scale_0" -> "223 dequantize_per_channel_default_6" [label="(768,)", style=solid]; +"221 linear_5_zero_point_0" -> "223 dequantize_per_channel_default_6" [label="(768,)", style=solid]; +"222 _frozen_param6" -> "223 dequantize_per_channel_default_6" [label="(768, 768)", style=solid]; +"223 dequantize_per_channel_default_6" -> "224 linear_5" [label="(768, 768)", style=solid]; +"224 linear_5" -> "225 view_15" [label="(197, 768)", style=solid]; +"225 view_15" -> "226 transpose_11" [label="(197, 1, 768)", style=solid]; +"226 transpose_11" -> "227 dropout_4" [label="(1, 197, 768)", style=solid]; +"227 dropout_4" -> "228 add_3" [label="(1, 197, 768)", style=solid]; +"228 add_3" -> "229 layer_norm_3" [label="(1, 197, 768)", style=solid]; +"228 add_3" -> "249 add_4" [label="(1, 197, 768)", style=solid]; +"229 layer_norm_3" -> "230 layer_norm_3_0_0_nncf_smooth_quant_0" [label="(1, 197, 768)", style=solid]; +"230 layer_norm_3_0_0_nncf_smooth_quant_0" -> "231 quantize_per_tensor_default_11" [label="(1, 197, 768)", style=solid]; +"231 quantize_per_tensor_default_11" -> "232 dequantize_per_tensor_default_11" [label="(1, 197, 768)", style=solid]; +"232 dequantize_per_tensor_default_11" -> "237 linear_6" [label="(1, 197, 768)", style=solid]; +"233 linear_6_scale_0" -> "236 dequantize_per_channel_default_7" [label="(3072,)", style=solid]; +"234 linear_6_zero_point_0" -> "236 dequantize_per_channel_default_7" [label="(3072,)", style=solid]; +"235 _frozen_param7" -> "236 dequantize_per_channel_default_7" [label="(3072, 768)", style=solid]; +"236 dequantize_per_channel_default_7" -> "237 linear_6" [label="(3072, 768)", style=solid]; +"237 linear_6" -> "238 gelu_1" [label="(1, 197, 3072)", style=solid]; +"238 gelu_1" -> "239 dropout_5" [label="(1, 197, 3072)", style=solid]; +"239 dropout_5" -> "240 dropout_5_0_0_nncf_smooth_quant_0" [label="(1, 197, 3072)", style=solid]; +"240 dropout_5_0_0_nncf_smooth_quant_0" -> "241 quantize_per_tensor_default_12" [label="(1, 197, 3072)", style=solid]; +"241 quantize_per_tensor_default_12" -> "242 dequantize_per_tensor_default_12" [label="(1, 197, 3072)", style=solid]; +"242 dequantize_per_tensor_default_12" -> "247 linear_7" [label="(1, 197, 3072)", style=solid]; +"243 linear_7_scale_0" -> "246 dequantize_per_channel_default_8" [label="(768,)", style=solid]; +"244 linear_7_zero_point_0" -> "246 dequantize_per_channel_default_8" [label="(768,)", style=solid]; +"245 _frozen_param8" -> "246 dequantize_per_channel_default_8" [label="(768, 3072)", style=solid]; +"246 dequantize_per_channel_default_8" -> "247 linear_7" [label="(768, 3072)", style=solid]; +"247 linear_7" -> "248 dropout_6" [label="(1, 197, 768)", style=solid]; +"248 dropout_6" -> "249 add_4" [label="(1, 197, 768)", style=solid]; +"249 add_4" -> "250 layer_norm_4" [label="(1, 197, 768)", style=solid]; +"249 add_4" -> "295 add_5" [label="(1, 197, 768)", style=solid]; +"250 layer_norm_4" -> "251 transpose_12" [label="(1, 197, 768)", style=solid]; +"251 transpose_12" -> "252 transpose_12_0_0_nncf_smooth_quant_0" [label="(197, 1, 768)", style=solid]; +"252 transpose_12_0_0_nncf_smooth_quant_0" -> "253 quantize_per_tensor_default_13" [label="(197, 1, 768)", style=solid]; +"253 quantize_per_tensor_default_13" -> "254 dequantize_per_tensor_default_13" [label="(197, 1, 768)", style=solid]; +"254 dequantize_per_tensor_default_13" -> "259 linear_8" [label="(197, 1, 768)", style=solid]; +"255 linear_8_scale_0" -> "258 dequantize_per_channel_default_9" [label="(2304,)", style=solid]; +"256 linear_8_zero_point_0" -> "258 dequantize_per_channel_default_9" [label="(2304,)", style=solid]; +"257 _frozen_param9" -> "258 dequantize_per_channel_default_9" [label="(2304, 768)", style=solid]; +"258 dequantize_per_channel_default_9" -> "259 linear_8" [label="(2304, 768)", style=solid]; +"259 linear_8" -> "260 unflatten_2" [label="(197, 1, 2304)", style=solid]; +"260 unflatten_2" -> "261 unsqueeze_2" [label="(197, 1, 3, 768)", style=solid]; +"261 unsqueeze_2" -> "262 transpose_13" [label="(1, 197, 1, 3, 768)", style=solid]; +"262 transpose_13" -> "263 squeeze_2" [label="(3, 197, 1, 1, 768)", style=solid]; +"263 squeeze_2" -> "264 contiguous_2" [label="(3, 197, 1, 768)", style=solid]; +"264 contiguous_2" -> "265 quantize_per_tensor_default_14" [label="(3, 197, 1, 768)", style=solid]; +"264 contiguous_2" -> "268 quantize_per_tensor_default_15" [label="(3, 197, 1, 768)", style=solid]; +"264 contiguous_2" -> "271 select_8" [label="(3, 197, 1, 768)", style=solid]; +"265 quantize_per_tensor_default_14" -> "266 dequantize_per_tensor_default_14" [label="(3, 197, 1, 768)", style=solid]; +"266 dequantize_per_tensor_default_14" -> "267 select_6" [label="(3, 197, 1, 768)", style=solid]; +"267 select_6" -> "272 view_16" [label="(197, 1, 768)", style=solid]; +"268 quantize_per_tensor_default_15" -> "269 dequantize_per_tensor_default_15" [label="(3, 197, 1, 768)", style=solid]; +"269 dequantize_per_tensor_default_15" -> "270 select_7" [label="(3, 197, 1, 768)", style=solid]; +"270 select_7" -> "274 view_17" [label="(197, 1, 768)", style=solid]; +"271 select_8" -> "276 view_18" [label="(197, 1, 768)", style=solid]; +"272 view_16" -> "273 transpose_14" [label="(197, 12, 64)", style=solid]; +"273 transpose_14" -> "278 view_19" [label="(12, 197, 64)", style=solid]; +"274 view_17" -> "275 transpose_15" [label="(197, 12, 64)", style=solid]; +"275 transpose_15" -> "279 view_20" [label="(12, 197, 64)", style=solid]; +"276 view_18" -> "277 transpose_16" [label="(197, 12, 64)", style=solid]; +"277 transpose_16" -> "280 view_21" [label="(12, 197, 64)", style=solid]; +"278 view_19" -> "281 scaled_dot_product_attention_2" [label="(1, 12, 197, 64)", style=solid]; +"279 view_20" -> "281 scaled_dot_product_attention_2" [label="(1, 12, 197, 64)", style=solid]; +"280 view_21" -> "281 scaled_dot_product_attention_2" [label="(1, 12, 197, 64)", style=solid]; +"281 scaled_dot_product_attention_2" -> "282 permute_3" [label="(1, 12, 197, 64)", style=solid]; +"282 permute_3" -> "283 view_22" [label="(197, 1, 12, 64)", style=solid]; +"283 view_22" -> "284 view_22_0_0_nncf_smooth_quant_0" [label="(197, 768)", style=solid]; +"284 view_22_0_0_nncf_smooth_quant_0" -> "285 quantize_per_tensor_default_16" [label="(197, 768)", style=solid]; +"285 quantize_per_tensor_default_16" -> "286 dequantize_per_tensor_default_16" [label="(197, 768)", style=solid]; +"286 dequantize_per_tensor_default_16" -> "291 linear_9" [label="(197, 768)", style=solid]; +"287 linear_9_scale_0" -> "290 dequantize_per_channel_default_10" [label="(768,)", style=solid]; +"288 linear_9_zero_point_0" -> "290 dequantize_per_channel_default_10" [label="(768,)", style=solid]; +"289 _frozen_param10" -> "290 dequantize_per_channel_default_10" [label="(768, 768)", style=solid]; +"290 dequantize_per_channel_default_10" -> "291 linear_9" [label="(768, 768)", style=solid]; +"291 linear_9" -> "292 view_23" [label="(197, 768)", style=solid]; +"292 view_23" -> "293 transpose_17" [label="(197, 1, 768)", style=solid]; +"293 transpose_17" -> "294 dropout_7" [label="(1, 197, 768)", style=solid]; +"294 dropout_7" -> "295 add_5" [label="(1, 197, 768)", style=solid]; +"295 add_5" -> "296 layer_norm_5" [label="(1, 197, 768)", style=solid]; +"295 add_5" -> "316 add_6" [label="(1, 197, 768)", style=solid]; +"296 layer_norm_5" -> "297 layer_norm_5_0_0_nncf_smooth_quant_0" [label="(1, 197, 768)", style=solid]; +"297 layer_norm_5_0_0_nncf_smooth_quant_0" -> "298 quantize_per_tensor_default_17" [label="(1, 197, 768)", style=solid]; +"298 quantize_per_tensor_default_17" -> "299 dequantize_per_tensor_default_17" [label="(1, 197, 768)", style=solid]; +"299 dequantize_per_tensor_default_17" -> "304 linear_10" [label="(1, 197, 768)", style=solid]; +"300 linear_10_scale_0" -> "303 dequantize_per_channel_default_11" [label="(3072,)", style=solid]; +"301 linear_10_zero_point_0" -> "303 dequantize_per_channel_default_11" [label="(3072,)", style=solid]; +"302 _frozen_param11" -> "303 dequantize_per_channel_default_11" [label="(3072, 768)", style=solid]; +"303 dequantize_per_channel_default_11" -> "304 linear_10" [label="(3072, 768)", style=solid]; +"304 linear_10" -> "305 gelu_2" [label="(1, 197, 3072)", style=solid]; +"305 gelu_2" -> "306 dropout_8" [label="(1, 197, 3072)", style=solid]; +"306 dropout_8" -> "307 dropout_8_0_0_nncf_smooth_quant_0" [label="(1, 197, 3072)", style=solid]; +"307 dropout_8_0_0_nncf_smooth_quant_0" -> "308 quantize_per_tensor_default_18" [label="(1, 197, 3072)", style=solid]; +"308 quantize_per_tensor_default_18" -> "309 dequantize_per_tensor_default_18" [label="(1, 197, 3072)", style=solid]; +"309 dequantize_per_tensor_default_18" -> "314 linear_11" [label="(1, 197, 3072)", style=solid]; +"310 linear_11_scale_0" -> "313 dequantize_per_channel_default_12" [label="(768,)", style=solid]; +"311 linear_11_zero_point_0" -> "313 dequantize_per_channel_default_12" [label="(768,)", style=solid]; +"312 _frozen_param12" -> "313 dequantize_per_channel_default_12" [label="(768, 3072)", style=solid]; +"313 dequantize_per_channel_default_12" -> "314 linear_11" [label="(768, 3072)", style=solid]; +"314 linear_11" -> "315 dropout_9" [label="(1, 197, 768)", style=solid]; +"315 dropout_9" -> "316 add_6" [label="(1, 197, 768)", style=solid]; +"316 add_6" -> "317 layer_norm_6" [label="(1, 197, 768)", style=solid]; +"316 add_6" -> "362 add_7" [label="(1, 197, 768)", style=solid]; +"317 layer_norm_6" -> "318 transpose_18" [label="(1, 197, 768)", style=solid]; +"318 transpose_18" -> "319 transpose_18_0_0_nncf_smooth_quant_0" [label="(197, 1, 768)", style=solid]; +"319 transpose_18_0_0_nncf_smooth_quant_0" -> "320 quantize_per_tensor_default_19" [label="(197, 1, 768)", style=solid]; +"320 quantize_per_tensor_default_19" -> "321 dequantize_per_tensor_default_19" [label="(197, 1, 768)", style=solid]; +"321 dequantize_per_tensor_default_19" -> "326 linear_12" [label="(197, 1, 768)", style=solid]; +"322 linear_12_scale_0" -> "325 dequantize_per_channel_default_13" [label="(2304,)", style=solid]; +"323 linear_12_zero_point_0" -> "325 dequantize_per_channel_default_13" [label="(2304,)", style=solid]; +"324 _frozen_param13" -> "325 dequantize_per_channel_default_13" [label="(2304, 768)", style=solid]; +"325 dequantize_per_channel_default_13" -> "326 linear_12" [label="(2304, 768)", style=solid]; +"326 linear_12" -> "327 unflatten_3" [label="(197, 1, 2304)", style=solid]; +"327 unflatten_3" -> "328 unsqueeze_3" [label="(197, 1, 3, 768)", style=solid]; +"328 unsqueeze_3" -> "329 transpose_19" [label="(1, 197, 1, 3, 768)", style=solid]; +"329 transpose_19" -> "330 squeeze_3" [label="(3, 197, 1, 1, 768)", style=solid]; +"330 squeeze_3" -> "331 contiguous_3" [label="(3, 197, 1, 768)", style=solid]; +"331 contiguous_3" -> "332 quantize_per_tensor_default_20" [label="(3, 197, 1, 768)", style=solid]; +"331 contiguous_3" -> "335 quantize_per_tensor_default_21" [label="(3, 197, 1, 768)", style=solid]; +"331 contiguous_3" -> "338 select_11" [label="(3, 197, 1, 768)", style=solid]; +"332 quantize_per_tensor_default_20" -> "333 dequantize_per_tensor_default_20" [label="(3, 197, 1, 768)", style=solid]; +"333 dequantize_per_tensor_default_20" -> "334 select_9" [label="(3, 197, 1, 768)", style=solid]; +"334 select_9" -> "339 view_24" [label="(197, 1, 768)", style=solid]; +"335 quantize_per_tensor_default_21" -> "336 dequantize_per_tensor_default_21" [label="(3, 197, 1, 768)", style=solid]; +"336 dequantize_per_tensor_default_21" -> "337 select_10" [label="(3, 197, 1, 768)", style=solid]; +"337 select_10" -> "341 view_25" [label="(197, 1, 768)", style=solid]; +"338 select_11" -> "343 view_26" [label="(197, 1, 768)", style=solid]; +"339 view_24" -> "340 transpose_20" [label="(197, 12, 64)", style=solid]; +"340 transpose_20" -> "345 view_27" [label="(12, 197, 64)", style=solid]; +"341 view_25" -> "342 transpose_21" [label="(197, 12, 64)", style=solid]; +"342 transpose_21" -> "346 view_28" [label="(12, 197, 64)", style=solid]; +"343 view_26" -> "344 transpose_22" [label="(197, 12, 64)", style=solid]; +"344 transpose_22" -> "347 view_29" [label="(12, 197, 64)", style=solid]; +"345 view_27" -> "348 scaled_dot_product_attention_3" [label="(1, 12, 197, 64)", style=solid]; +"346 view_28" -> "348 scaled_dot_product_attention_3" [label="(1, 12, 197, 64)", style=solid]; +"347 view_29" -> "348 scaled_dot_product_attention_3" [label="(1, 12, 197, 64)", style=solid]; +"348 scaled_dot_product_attention_3" -> "349 permute_4" [label="(1, 12, 197, 64)", style=solid]; +"349 permute_4" -> "350 view_30" [label="(197, 1, 12, 64)", style=solid]; +"350 view_30" -> "351 view_30_0_0_nncf_smooth_quant_0" [label="(197, 768)", style=solid]; +"351 view_30_0_0_nncf_smooth_quant_0" -> "352 quantize_per_tensor_default_22" [label="(197, 768)", style=solid]; +"352 quantize_per_tensor_default_22" -> "353 dequantize_per_tensor_default_22" [label="(197, 768)", style=solid]; +"353 dequantize_per_tensor_default_22" -> "358 linear_13" [label="(197, 768)", style=solid]; +"354 linear_13_scale_0" -> "357 dequantize_per_channel_default_14" [label="(768,)", style=solid]; +"355 linear_13_zero_point_0" -> "357 dequantize_per_channel_default_14" [label="(768,)", style=solid]; +"356 _frozen_param14" -> "357 dequantize_per_channel_default_14" [label="(768, 768)", style=solid]; +"357 dequantize_per_channel_default_14" -> "358 linear_13" [label="(768, 768)", style=solid]; +"358 linear_13" -> "359 view_31" [label="(197, 768)", style=solid]; +"359 view_31" -> "360 transpose_23" [label="(197, 1, 768)", style=solid]; +"360 transpose_23" -> "361 dropout_10" [label="(1, 197, 768)", style=solid]; +"361 dropout_10" -> "362 add_7" [label="(1, 197, 768)", style=solid]; +"362 add_7" -> "363 layer_norm_7" [label="(1, 197, 768)", style=solid]; +"362 add_7" -> "383 add_8" [label="(1, 197, 768)", style=solid]; +"363 layer_norm_7" -> "364 layer_norm_7_0_0_nncf_smooth_quant_0" [label="(1, 197, 768)", style=solid]; +"364 layer_norm_7_0_0_nncf_smooth_quant_0" -> "365 quantize_per_tensor_default_23" [label="(1, 197, 768)", style=solid]; +"365 quantize_per_tensor_default_23" -> "366 dequantize_per_tensor_default_23" [label="(1, 197, 768)", style=solid]; +"366 dequantize_per_tensor_default_23" -> "371 linear_14" [label="(1, 197, 768)", style=solid]; +"367 linear_14_scale_0" -> "370 dequantize_per_channel_default_15" [label="(3072,)", style=solid]; +"368 linear_14_zero_point_0" -> "370 dequantize_per_channel_default_15" [label="(3072,)", style=solid]; +"369 _frozen_param15" -> "370 dequantize_per_channel_default_15" [label="(3072, 768)", style=solid]; +"370 dequantize_per_channel_default_15" -> "371 linear_14" [label="(3072, 768)", style=solid]; +"371 linear_14" -> "372 gelu_3" [label="(1, 197, 3072)", style=solid]; +"372 gelu_3" -> "373 dropout_11" [label="(1, 197, 3072)", style=solid]; +"373 dropout_11" -> "374 dropout_11_0_0_nncf_smooth_quant_0" [label="(1, 197, 3072)", style=solid]; +"374 dropout_11_0_0_nncf_smooth_quant_0" -> "375 quantize_per_tensor_default_24" [label="(1, 197, 3072)", style=solid]; +"375 quantize_per_tensor_default_24" -> "376 dequantize_per_tensor_default_24" [label="(1, 197, 3072)", style=solid]; +"376 dequantize_per_tensor_default_24" -> "381 linear_15" [label="(1, 197, 3072)", style=solid]; +"377 linear_15_scale_0" -> "380 dequantize_per_channel_default_16" [label="(768,)", style=solid]; +"378 linear_15_zero_point_0" -> "380 dequantize_per_channel_default_16" [label="(768,)", style=solid]; +"379 _frozen_param16" -> "380 dequantize_per_channel_default_16" [label="(768, 3072)", style=solid]; +"380 dequantize_per_channel_default_16" -> "381 linear_15" [label="(768, 3072)", style=solid]; +"381 linear_15" -> "382 dropout_12" [label="(1, 197, 768)", style=solid]; +"382 dropout_12" -> "383 add_8" [label="(1, 197, 768)", style=solid]; +"383 add_8" -> "384 layer_norm_8" [label="(1, 197, 768)", style=solid]; +"383 add_8" -> "429 add_9" [label="(1, 197, 768)", style=solid]; +"384 layer_norm_8" -> "385 transpose_24" [label="(1, 197, 768)", style=solid]; +"385 transpose_24" -> "386 transpose_24_0_0_nncf_smooth_quant_0" [label="(197, 1, 768)", style=solid]; +"386 transpose_24_0_0_nncf_smooth_quant_0" -> "387 quantize_per_tensor_default_25" [label="(197, 1, 768)", style=solid]; +"387 quantize_per_tensor_default_25" -> "388 dequantize_per_tensor_default_25" [label="(197, 1, 768)", style=solid]; +"388 dequantize_per_tensor_default_25" -> "393 linear_16" [label="(197, 1, 768)", style=solid]; +"389 linear_16_scale_0" -> "392 dequantize_per_channel_default_17" [label="(2304,)", style=solid]; +"390 linear_16_zero_point_0" -> "392 dequantize_per_channel_default_17" [label="(2304,)", style=solid]; +"391 _frozen_param17" -> "392 dequantize_per_channel_default_17" [label="(2304, 768)", style=solid]; +"392 dequantize_per_channel_default_17" -> "393 linear_16" [label="(2304, 768)", style=solid]; +"393 linear_16" -> "394 unflatten_4" [label="(197, 1, 2304)", style=solid]; +"394 unflatten_4" -> "395 unsqueeze_4" [label="(197, 1, 3, 768)", style=solid]; +"395 unsqueeze_4" -> "396 transpose_25" [label="(1, 197, 1, 3, 768)", style=solid]; +"396 transpose_25" -> "397 squeeze_4" [label="(3, 197, 1, 1, 768)", style=solid]; +"397 squeeze_4" -> "398 contiguous_4" [label="(3, 197, 1, 768)", style=solid]; +"398 contiguous_4" -> "399 quantize_per_tensor_default_26" [label="(3, 197, 1, 768)", style=solid]; +"398 contiguous_4" -> "402 quantize_per_tensor_default_27" [label="(3, 197, 1, 768)", style=solid]; +"398 contiguous_4" -> "405 select_14" [label="(3, 197, 1, 768)", style=solid]; +"399 quantize_per_tensor_default_26" -> "400 dequantize_per_tensor_default_26" [label="(3, 197, 1, 768)", style=solid]; +"400 dequantize_per_tensor_default_26" -> "401 select_12" [label="(3, 197, 1, 768)", style=solid]; +"401 select_12" -> "406 view_32" [label="(197, 1, 768)", style=solid]; +"402 quantize_per_tensor_default_27" -> "403 dequantize_per_tensor_default_27" [label="(3, 197, 1, 768)", style=solid]; +"403 dequantize_per_tensor_default_27" -> "404 select_13" [label="(3, 197, 1, 768)", style=solid]; +"404 select_13" -> "408 view_33" [label="(197, 1, 768)", style=solid]; +"405 select_14" -> "410 view_34" [label="(197, 1, 768)", style=solid]; +"406 view_32" -> "407 transpose_26" [label="(197, 12, 64)", style=solid]; +"407 transpose_26" -> "412 view_35" [label="(12, 197, 64)", style=solid]; +"408 view_33" -> "409 transpose_27" [label="(197, 12, 64)", style=solid]; +"409 transpose_27" -> "413 view_36" [label="(12, 197, 64)", style=solid]; +"410 view_34" -> "411 transpose_28" [label="(197, 12, 64)", style=solid]; +"411 transpose_28" -> "414 view_37" [label="(12, 197, 64)", style=solid]; +"412 view_35" -> "415 scaled_dot_product_attention_4" [label="(1, 12, 197, 64)", style=solid]; +"413 view_36" -> "415 scaled_dot_product_attention_4" [label="(1, 12, 197, 64)", style=solid]; +"414 view_37" -> "415 scaled_dot_product_attention_4" [label="(1, 12, 197, 64)", style=solid]; +"415 scaled_dot_product_attention_4" -> "416 permute_5" [label="(1, 12, 197, 64)", style=solid]; +"416 permute_5" -> "417 view_38" [label="(197, 1, 12, 64)", style=solid]; +"417 view_38" -> "418 view_38_0_0_nncf_smooth_quant_0" [label="(197, 768)", style=solid]; +"418 view_38_0_0_nncf_smooth_quant_0" -> "419 quantize_per_tensor_default_28" [label="(197, 768)", style=solid]; +"419 quantize_per_tensor_default_28" -> "420 dequantize_per_tensor_default_28" [label="(197, 768)", style=solid]; +"420 dequantize_per_tensor_default_28" -> "425 linear_17" [label="(197, 768)", style=solid]; +"421 linear_17_scale_0" -> "424 dequantize_per_channel_default_18" [label="(768,)", style=solid]; +"422 linear_17_zero_point_0" -> "424 dequantize_per_channel_default_18" [label="(768,)", style=solid]; +"423 _frozen_param18" -> "424 dequantize_per_channel_default_18" [label="(768, 768)", style=solid]; +"424 dequantize_per_channel_default_18" -> "425 linear_17" [label="(768, 768)", style=solid]; +"425 linear_17" -> "426 view_39" [label="(197, 768)", style=solid]; +"426 view_39" -> "427 transpose_29" [label="(197, 1, 768)", style=solid]; +"427 transpose_29" -> "428 dropout_13" [label="(1, 197, 768)", style=solid]; +"428 dropout_13" -> "429 add_9" [label="(1, 197, 768)", style=solid]; +"429 add_9" -> "430 layer_norm_9" [label="(1, 197, 768)", style=solid]; +"429 add_9" -> "450 add_10" [label="(1, 197, 768)", style=solid]; +"430 layer_norm_9" -> "431 layer_norm_9_0_0_nncf_smooth_quant_0" [label="(1, 197, 768)", style=solid]; +"431 layer_norm_9_0_0_nncf_smooth_quant_0" -> "432 quantize_per_tensor_default_29" [label="(1, 197, 768)", style=solid]; +"432 quantize_per_tensor_default_29" -> "433 dequantize_per_tensor_default_29" [label="(1, 197, 768)", style=solid]; +"433 dequantize_per_tensor_default_29" -> "438 linear_18" [label="(1, 197, 768)", style=solid]; +"434 linear_18_scale_0" -> "437 dequantize_per_channel_default_19" [label="(3072,)", style=solid]; +"435 linear_18_zero_point_0" -> "437 dequantize_per_channel_default_19" [label="(3072,)", style=solid]; +"436 _frozen_param19" -> "437 dequantize_per_channel_default_19" [label="(3072, 768)", style=solid]; +"437 dequantize_per_channel_default_19" -> "438 linear_18" [label="(3072, 768)", style=solid]; +"438 linear_18" -> "439 gelu_4" [label="(1, 197, 3072)", style=solid]; +"439 gelu_4" -> "440 dropout_14" [label="(1, 197, 3072)", style=solid]; +"440 dropout_14" -> "441 dropout_14_0_0_nncf_smooth_quant_0" [label="(1, 197, 3072)", style=solid]; +"441 dropout_14_0_0_nncf_smooth_quant_0" -> "442 quantize_per_tensor_default_30" [label="(1, 197, 3072)", style=solid]; +"442 quantize_per_tensor_default_30" -> "443 dequantize_per_tensor_default_30" [label="(1, 197, 3072)", style=solid]; +"443 dequantize_per_tensor_default_30" -> "448 linear_19" [label="(1, 197, 3072)", style=solid]; +"444 linear_19_scale_0" -> "447 dequantize_per_channel_default_20" [label="(768,)", style=solid]; +"445 linear_19_zero_point_0" -> "447 dequantize_per_channel_default_20" [label="(768,)", style=solid]; +"446 _frozen_param20" -> "447 dequantize_per_channel_default_20" [label="(768, 3072)", style=solid]; +"447 dequantize_per_channel_default_20" -> "448 linear_19" [label="(768, 3072)", style=solid]; +"448 linear_19" -> "449 dropout_15" [label="(1, 197, 768)", style=solid]; +"449 dropout_15" -> "450 add_10" [label="(1, 197, 768)", style=solid]; +"450 add_10" -> "451 layer_norm_10" [label="(1, 197, 768)", style=solid]; +"450 add_10" -> "496 add_11" [label="(1, 197, 768)", style=solid]; +"451 layer_norm_10" -> "452 transpose_30" [label="(1, 197, 768)", style=solid]; +"452 transpose_30" -> "453 transpose_30_0_0_nncf_smooth_quant_0" [label="(197, 1, 768)", style=solid]; +"453 transpose_30_0_0_nncf_smooth_quant_0" -> "454 quantize_per_tensor_default_31" [label="(197, 1, 768)", style=solid]; +"454 quantize_per_tensor_default_31" -> "455 dequantize_per_tensor_default_31" [label="(197, 1, 768)", style=solid]; +"455 dequantize_per_tensor_default_31" -> "460 linear_20" [label="(197, 1, 768)", style=solid]; +"456 linear_20_scale_0" -> "459 dequantize_per_channel_default_21" [label="(2304,)", style=solid]; +"457 linear_20_zero_point_0" -> "459 dequantize_per_channel_default_21" [label="(2304,)", style=solid]; +"458 _frozen_param21" -> "459 dequantize_per_channel_default_21" [label="(2304, 768)", style=solid]; +"459 dequantize_per_channel_default_21" -> "460 linear_20" [label="(2304, 768)", style=solid]; +"460 linear_20" -> "461 unflatten_5" [label="(197, 1, 2304)", style=solid]; +"461 unflatten_5" -> "462 unsqueeze_5" [label="(197, 1, 3, 768)", style=solid]; +"462 unsqueeze_5" -> "463 transpose_31" [label="(1, 197, 1, 3, 768)", style=solid]; +"463 transpose_31" -> "464 squeeze_5" [label="(3, 197, 1, 1, 768)", style=solid]; +"464 squeeze_5" -> "465 contiguous_5" [label="(3, 197, 1, 768)", style=solid]; +"465 contiguous_5" -> "466 quantize_per_tensor_default_32" [label="(3, 197, 1, 768)", style=solid]; +"465 contiguous_5" -> "469 quantize_per_tensor_default_33" [label="(3, 197, 1, 768)", style=solid]; +"465 contiguous_5" -> "472 select_17" [label="(3, 197, 1, 768)", style=solid]; +"466 quantize_per_tensor_default_32" -> "467 dequantize_per_tensor_default_32" [label="(3, 197, 1, 768)", style=solid]; +"467 dequantize_per_tensor_default_32" -> "468 select_15" [label="(3, 197, 1, 768)", style=solid]; +"468 select_15" -> "473 view_40" [label="(197, 1, 768)", style=solid]; +"469 quantize_per_tensor_default_33" -> "470 dequantize_per_tensor_default_33" [label="(3, 197, 1, 768)", style=solid]; +"470 dequantize_per_tensor_default_33" -> "471 select_16" [label="(3, 197, 1, 768)", style=solid]; +"471 select_16" -> "475 view_41" [label="(197, 1, 768)", style=solid]; +"472 select_17" -> "477 view_42" [label="(197, 1, 768)", style=solid]; +"473 view_40" -> "474 transpose_32" [label="(197, 12, 64)", style=solid]; +"474 transpose_32" -> "479 view_43" [label="(12, 197, 64)", style=solid]; +"475 view_41" -> "476 transpose_33" [label="(197, 12, 64)", style=solid]; +"476 transpose_33" -> "480 view_44" [label="(12, 197, 64)", style=solid]; +"477 view_42" -> "478 transpose_34" [label="(197, 12, 64)", style=solid]; +"478 transpose_34" -> "481 view_45" [label="(12, 197, 64)", style=solid]; +"479 view_43" -> "482 scaled_dot_product_attention_5" [label="(1, 12, 197, 64)", style=solid]; +"480 view_44" -> "482 scaled_dot_product_attention_5" [label="(1, 12, 197, 64)", style=solid]; +"481 view_45" -> "482 scaled_dot_product_attention_5" [label="(1, 12, 197, 64)", style=solid]; +"482 scaled_dot_product_attention_5" -> "483 permute_6" [label="(1, 12, 197, 64)", style=solid]; +"483 permute_6" -> "484 view_46" [label="(197, 1, 12, 64)", style=solid]; +"484 view_46" -> "485 view_46_0_0_nncf_smooth_quant_0" [label="(197, 768)", style=solid]; +"485 view_46_0_0_nncf_smooth_quant_0" -> "486 quantize_per_tensor_default_34" [label="(197, 768)", style=solid]; +"486 quantize_per_tensor_default_34" -> "487 dequantize_per_tensor_default_34" [label="(197, 768)", style=solid]; +"487 dequantize_per_tensor_default_34" -> "492 linear_21" [label="(197, 768)", style=solid]; +"488 linear_21_scale_0" -> "491 dequantize_per_channel_default_22" [label="(768,)", style=solid]; +"489 linear_21_zero_point_0" -> "491 dequantize_per_channel_default_22" [label="(768,)", style=solid]; +"490 _frozen_param22" -> "491 dequantize_per_channel_default_22" [label="(768, 768)", style=solid]; +"491 dequantize_per_channel_default_22" -> "492 linear_21" [label="(768, 768)", style=solid]; +"492 linear_21" -> "493 view_47" [label="(197, 768)", style=solid]; +"493 view_47" -> "494 transpose_35" [label="(197, 1, 768)", style=solid]; +"494 transpose_35" -> "495 dropout_16" [label="(1, 197, 768)", style=solid]; +"495 dropout_16" -> "496 add_11" [label="(1, 197, 768)", style=solid]; +"496 add_11" -> "497 layer_norm_11" [label="(1, 197, 768)", style=solid]; +"496 add_11" -> "517 add_12" [label="(1, 197, 768)", style=solid]; +"497 layer_norm_11" -> "498 layer_norm_11_0_0_nncf_smooth_quant_0" [label="(1, 197, 768)", style=solid]; +"498 layer_norm_11_0_0_nncf_smooth_quant_0" -> "499 quantize_per_tensor_default_35" [label="(1, 197, 768)", style=solid]; +"499 quantize_per_tensor_default_35" -> "500 dequantize_per_tensor_default_35" [label="(1, 197, 768)", style=solid]; +"500 dequantize_per_tensor_default_35" -> "505 linear_22" [label="(1, 197, 768)", style=solid]; +"501 linear_22_scale_0" -> "504 dequantize_per_channel_default_23" [label="(3072,)", style=solid]; +"502 linear_22_zero_point_0" -> "504 dequantize_per_channel_default_23" [label="(3072,)", style=solid]; +"503 _frozen_param23" -> "504 dequantize_per_channel_default_23" [label="(3072, 768)", style=solid]; +"504 dequantize_per_channel_default_23" -> "505 linear_22" [label="(3072, 768)", style=solid]; +"505 linear_22" -> "506 gelu_5" [label="(1, 197, 3072)", style=solid]; +"506 gelu_5" -> "507 dropout_17" [label="(1, 197, 3072)", style=solid]; +"507 dropout_17" -> "508 dropout_17_0_0_nncf_smooth_quant_0" [label="(1, 197, 3072)", style=solid]; +"508 dropout_17_0_0_nncf_smooth_quant_0" -> "509 quantize_per_tensor_default_36" [label="(1, 197, 3072)", style=solid]; +"509 quantize_per_tensor_default_36" -> "510 dequantize_per_tensor_default_36" [label="(1, 197, 3072)", style=solid]; +"510 dequantize_per_tensor_default_36" -> "515 linear_23" [label="(1, 197, 3072)", style=solid]; +"511 linear_23_scale_0" -> "514 dequantize_per_channel_default_24" [label="(768,)", style=solid]; +"512 linear_23_zero_point_0" -> "514 dequantize_per_channel_default_24" [label="(768,)", style=solid]; +"513 _frozen_param24" -> "514 dequantize_per_channel_default_24" [label="(768, 3072)", style=solid]; +"514 dequantize_per_channel_default_24" -> "515 linear_23" [label="(768, 3072)", style=solid]; +"515 linear_23" -> "516 dropout_18" [label="(1, 197, 768)", style=solid]; +"516 dropout_18" -> "517 add_12" [label="(1, 197, 768)", style=solid]; +"517 add_12" -> "518 layer_norm_12" [label="(1, 197, 768)", style=solid]; +"517 add_12" -> "563 add_13" [label="(1, 197, 768)", style=solid]; +"518 layer_norm_12" -> "519 transpose_36" [label="(1, 197, 768)", style=solid]; +"519 transpose_36" -> "520 transpose_36_0_0_nncf_smooth_quant_0" [label="(197, 1, 768)", style=solid]; +"520 transpose_36_0_0_nncf_smooth_quant_0" -> "521 quantize_per_tensor_default_37" [label="(197, 1, 768)", style=solid]; +"521 quantize_per_tensor_default_37" -> "522 dequantize_per_tensor_default_37" [label="(197, 1, 768)", style=solid]; +"522 dequantize_per_tensor_default_37" -> "527 linear_24" [label="(197, 1, 768)", style=solid]; +"523 linear_24_scale_0" -> "526 dequantize_per_channel_default_25" [label="(2304,)", style=solid]; +"524 linear_24_zero_point_0" -> "526 dequantize_per_channel_default_25" [label="(2304,)", style=solid]; +"525 _frozen_param25" -> "526 dequantize_per_channel_default_25" [label="(2304, 768)", style=solid]; +"526 dequantize_per_channel_default_25" -> "527 linear_24" [label="(2304, 768)", style=solid]; +"527 linear_24" -> "528 unflatten_6" [label="(197, 1, 2304)", style=solid]; +"528 unflatten_6" -> "529 unsqueeze_6" [label="(197, 1, 3, 768)", style=solid]; +"529 unsqueeze_6" -> "530 transpose_37" [label="(1, 197, 1, 3, 768)", style=solid]; +"530 transpose_37" -> "531 squeeze_6" [label="(3, 197, 1, 1, 768)", style=solid]; +"531 squeeze_6" -> "532 contiguous_6" [label="(3, 197, 1, 768)", style=solid]; +"532 contiguous_6" -> "533 quantize_per_tensor_default_38" [label="(3, 197, 1, 768)", style=solid]; +"532 contiguous_6" -> "536 quantize_per_tensor_default_39" [label="(3, 197, 1, 768)", style=solid]; +"532 contiguous_6" -> "539 select_20" [label="(3, 197, 1, 768)", style=solid]; +"533 quantize_per_tensor_default_38" -> "534 dequantize_per_tensor_default_38" [label="(3, 197, 1, 768)", style=solid]; +"534 dequantize_per_tensor_default_38" -> "535 select_18" [label="(3, 197, 1, 768)", style=solid]; +"535 select_18" -> "540 view_48" [label="(197, 1, 768)", style=solid]; +"536 quantize_per_tensor_default_39" -> "537 dequantize_per_tensor_default_39" [label="(3, 197, 1, 768)", style=solid]; +"537 dequantize_per_tensor_default_39" -> "538 select_19" [label="(3, 197, 1, 768)", style=solid]; +"538 select_19" -> "542 view_49" [label="(197, 1, 768)", style=solid]; +"539 select_20" -> "544 view_50" [label="(197, 1, 768)", style=solid]; +"540 view_48" -> "541 transpose_38" [label="(197, 12, 64)", style=solid]; +"541 transpose_38" -> "546 view_51" [label="(12, 197, 64)", style=solid]; +"542 view_49" -> "543 transpose_39" [label="(197, 12, 64)", style=solid]; +"543 transpose_39" -> "547 view_52" [label="(12, 197, 64)", style=solid]; +"544 view_50" -> "545 transpose_40" [label="(197, 12, 64)", style=solid]; +"545 transpose_40" -> "548 view_53" [label="(12, 197, 64)", style=solid]; +"546 view_51" -> "549 scaled_dot_product_attention_6" [label="(1, 12, 197, 64)", style=solid]; +"547 view_52" -> "549 scaled_dot_product_attention_6" [label="(1, 12, 197, 64)", style=solid]; +"548 view_53" -> "549 scaled_dot_product_attention_6" [label="(1, 12, 197, 64)", style=solid]; +"549 scaled_dot_product_attention_6" -> "550 permute_7" [label="(1, 12, 197, 64)", style=solid]; +"550 permute_7" -> "551 view_54" [label="(197, 1, 12, 64)", style=solid]; +"551 view_54" -> "552 view_54_0_0_nncf_smooth_quant_0" [label="(197, 768)", style=solid]; +"552 view_54_0_0_nncf_smooth_quant_0" -> "553 quantize_per_tensor_default_40" [label="(197, 768)", style=solid]; +"553 quantize_per_tensor_default_40" -> "554 dequantize_per_tensor_default_40" [label="(197, 768)", style=solid]; +"554 dequantize_per_tensor_default_40" -> "559 linear_25" [label="(197, 768)", style=solid]; +"555 linear_25_scale_0" -> "558 dequantize_per_channel_default_26" [label="(768,)", style=solid]; +"556 linear_25_zero_point_0" -> "558 dequantize_per_channel_default_26" [label="(768,)", style=solid]; +"557 _frozen_param26" -> "558 dequantize_per_channel_default_26" [label="(768, 768)", style=solid]; +"558 dequantize_per_channel_default_26" -> "559 linear_25" [label="(768, 768)", style=solid]; +"559 linear_25" -> "560 view_55" [label="(197, 768)", style=solid]; +"560 view_55" -> "561 transpose_41" [label="(197, 1, 768)", style=solid]; +"561 transpose_41" -> "562 dropout_19" [label="(1, 197, 768)", style=solid]; +"562 dropout_19" -> "563 add_13" [label="(1, 197, 768)", style=solid]; +"563 add_13" -> "564 layer_norm_13" [label="(1, 197, 768)", style=solid]; +"563 add_13" -> "584 add_14" [label="(1, 197, 768)", style=solid]; +"564 layer_norm_13" -> "565 layer_norm_13_0_0_nncf_smooth_quant_0" [label="(1, 197, 768)", style=solid]; +"565 layer_norm_13_0_0_nncf_smooth_quant_0" -> "566 quantize_per_tensor_default_41" [label="(1, 197, 768)", style=solid]; +"566 quantize_per_tensor_default_41" -> "567 dequantize_per_tensor_default_41" [label="(1, 197, 768)", style=solid]; +"567 dequantize_per_tensor_default_41" -> "572 linear_26" [label="(1, 197, 768)", style=solid]; +"568 linear_26_scale_0" -> "571 dequantize_per_channel_default_27" [label="(3072,)", style=solid]; +"569 linear_26_zero_point_0" -> "571 dequantize_per_channel_default_27" [label="(3072,)", style=solid]; +"570 _frozen_param27" -> "571 dequantize_per_channel_default_27" [label="(3072, 768)", style=solid]; +"571 dequantize_per_channel_default_27" -> "572 linear_26" [label="(3072, 768)", style=solid]; +"572 linear_26" -> "573 gelu_6" [label="(1, 197, 3072)", style=solid]; +"573 gelu_6" -> "574 dropout_20" [label="(1, 197, 3072)", style=solid]; +"574 dropout_20" -> "575 dropout_20_0_0_nncf_smooth_quant_0" [label="(1, 197, 3072)", style=solid]; +"575 dropout_20_0_0_nncf_smooth_quant_0" -> "576 quantize_per_tensor_default_42" [label="(1, 197, 3072)", style=solid]; +"576 quantize_per_tensor_default_42" -> "577 dequantize_per_tensor_default_42" [label="(1, 197, 3072)", style=solid]; +"577 dequantize_per_tensor_default_42" -> "582 linear_27" [label="(1, 197, 3072)", style=solid]; +"578 linear_27_scale_0" -> "581 dequantize_per_channel_default_28" [label="(768,)", style=solid]; +"579 linear_27_zero_point_0" -> "581 dequantize_per_channel_default_28" [label="(768,)", style=solid]; +"580 _frozen_param28" -> "581 dequantize_per_channel_default_28" [label="(768, 3072)", style=solid]; +"581 dequantize_per_channel_default_28" -> "582 linear_27" [label="(768, 3072)", style=solid]; +"582 linear_27" -> "583 dropout_21" [label="(1, 197, 768)", style=solid]; +"583 dropout_21" -> "584 add_14" [label="(1, 197, 768)", style=solid]; +"584 add_14" -> "585 layer_norm_14" [label="(1, 197, 768)", style=solid]; +"584 add_14" -> "630 add_15" [label="(1, 197, 768)", style=solid]; +"585 layer_norm_14" -> "586 transpose_42" [label="(1, 197, 768)", style=solid]; +"586 transpose_42" -> "587 transpose_42_0_0_nncf_smooth_quant_0" [label="(197, 1, 768)", style=solid]; +"587 transpose_42_0_0_nncf_smooth_quant_0" -> "588 quantize_per_tensor_default_43" [label="(197, 1, 768)", style=solid]; +"588 quantize_per_tensor_default_43" -> "589 dequantize_per_tensor_default_43" [label="(197, 1, 768)", style=solid]; +"589 dequantize_per_tensor_default_43" -> "594 linear_28" [label="(197, 1, 768)", style=solid]; +"590 linear_28_scale_0" -> "593 dequantize_per_channel_default_29" [label="(2304,)", style=solid]; +"591 linear_28_zero_point_0" -> "593 dequantize_per_channel_default_29" [label="(2304,)", style=solid]; +"592 _frozen_param29" -> "593 dequantize_per_channel_default_29" [label="(2304, 768)", style=solid]; +"593 dequantize_per_channel_default_29" -> "594 linear_28" [label="(2304, 768)", style=solid]; +"594 linear_28" -> "595 unflatten_7" [label="(197, 1, 2304)", style=solid]; +"595 unflatten_7" -> "596 unsqueeze_7" [label="(197, 1, 3, 768)", style=solid]; +"596 unsqueeze_7" -> "597 transpose_43" [label="(1, 197, 1, 3, 768)", style=solid]; +"597 transpose_43" -> "598 squeeze_7" [label="(3, 197, 1, 1, 768)", style=solid]; +"598 squeeze_7" -> "599 contiguous_7" [label="(3, 197, 1, 768)", style=solid]; +"599 contiguous_7" -> "600 quantize_per_tensor_default_44" [label="(3, 197, 1, 768)", style=solid]; +"599 contiguous_7" -> "603 quantize_per_tensor_default_45" [label="(3, 197, 1, 768)", style=solid]; +"599 contiguous_7" -> "606 select_23" [label="(3, 197, 1, 768)", style=solid]; +"600 quantize_per_tensor_default_44" -> "601 dequantize_per_tensor_default_44" [label="(3, 197, 1, 768)", style=solid]; +"601 dequantize_per_tensor_default_44" -> "602 select_21" [label="(3, 197, 1, 768)", style=solid]; +"602 select_21" -> "607 view_56" [label="(197, 1, 768)", style=solid]; +"603 quantize_per_tensor_default_45" -> "604 dequantize_per_tensor_default_45" [label="(3, 197, 1, 768)", style=solid]; +"604 dequantize_per_tensor_default_45" -> "605 select_22" [label="(3, 197, 1, 768)", style=solid]; +"605 select_22" -> "609 view_57" [label="(197, 1, 768)", style=solid]; +"606 select_23" -> "611 view_58" [label="(197, 1, 768)", style=solid]; +"607 view_56" -> "608 transpose_44" [label="(197, 12, 64)", style=solid]; +"608 transpose_44" -> "613 view_59" [label="(12, 197, 64)", style=solid]; +"609 view_57" -> "610 transpose_45" [label="(197, 12, 64)", style=solid]; +"610 transpose_45" -> "614 view_60" [label="(12, 197, 64)", style=solid]; +"611 view_58" -> "612 transpose_46" [label="(197, 12, 64)", style=solid]; +"612 transpose_46" -> "615 view_61" [label="(12, 197, 64)", style=solid]; +"613 view_59" -> "616 scaled_dot_product_attention_7" [label="(1, 12, 197, 64)", style=solid]; +"614 view_60" -> "616 scaled_dot_product_attention_7" [label="(1, 12, 197, 64)", style=solid]; +"615 view_61" -> "616 scaled_dot_product_attention_7" [label="(1, 12, 197, 64)", style=solid]; +"616 scaled_dot_product_attention_7" -> "617 permute_8" [label="(1, 12, 197, 64)", style=solid]; +"617 permute_8" -> "618 view_62" [label="(197, 1, 12, 64)", style=solid]; +"618 view_62" -> "619 view_62_0_0_nncf_smooth_quant_0" [label="(197, 768)", style=solid]; +"619 view_62_0_0_nncf_smooth_quant_0" -> "620 quantize_per_tensor_default_46" [label="(197, 768)", style=solid]; +"620 quantize_per_tensor_default_46" -> "621 dequantize_per_tensor_default_46" [label="(197, 768)", style=solid]; +"621 dequantize_per_tensor_default_46" -> "626 linear_29" [label="(197, 768)", style=solid]; +"622 linear_29_scale_0" -> "625 dequantize_per_channel_default_30" [label="(768,)", style=solid]; +"623 linear_29_zero_point_0" -> "625 dequantize_per_channel_default_30" [label="(768,)", style=solid]; +"624 _frozen_param30" -> "625 dequantize_per_channel_default_30" [label="(768, 768)", style=solid]; +"625 dequantize_per_channel_default_30" -> "626 linear_29" [label="(768, 768)", style=solid]; +"626 linear_29" -> "627 view_63" [label="(197, 768)", style=solid]; +"627 view_63" -> "628 transpose_47" [label="(197, 1, 768)", style=solid]; +"628 transpose_47" -> "629 dropout_22" [label="(1, 197, 768)", style=solid]; +"629 dropout_22" -> "630 add_15" [label="(1, 197, 768)", style=solid]; +"630 add_15" -> "631 layer_norm_15" [label="(1, 197, 768)", style=solid]; +"630 add_15" -> "651 add_16" [label="(1, 197, 768)", style=solid]; +"631 layer_norm_15" -> "632 layer_norm_15_0_0_nncf_smooth_quant_0" [label="(1, 197, 768)", style=solid]; +"632 layer_norm_15_0_0_nncf_smooth_quant_0" -> "633 quantize_per_tensor_default_47" [label="(1, 197, 768)", style=solid]; +"633 quantize_per_tensor_default_47" -> "634 dequantize_per_tensor_default_47" [label="(1, 197, 768)", style=solid]; +"634 dequantize_per_tensor_default_47" -> "639 linear_30" [label="(1, 197, 768)", style=solid]; +"635 linear_30_scale_0" -> "638 dequantize_per_channel_default_31" [label="(3072,)", style=solid]; +"636 linear_30_zero_point_0" -> "638 dequantize_per_channel_default_31" [label="(3072,)", style=solid]; +"637 _frozen_param31" -> "638 dequantize_per_channel_default_31" [label="(3072, 768)", style=solid]; +"638 dequantize_per_channel_default_31" -> "639 linear_30" [label="(3072, 768)", style=solid]; +"639 linear_30" -> "640 gelu_7" [label="(1, 197, 3072)", style=solid]; +"640 gelu_7" -> "641 dropout_23" [label="(1, 197, 3072)", style=solid]; +"641 dropout_23" -> "642 dropout_23_0_0_nncf_smooth_quant_0" [label="(1, 197, 3072)", style=solid]; +"642 dropout_23_0_0_nncf_smooth_quant_0" -> "643 quantize_per_tensor_default_48" [label="(1, 197, 3072)", style=solid]; +"643 quantize_per_tensor_default_48" -> "644 dequantize_per_tensor_default_48" [label="(1, 197, 3072)", style=solid]; +"644 dequantize_per_tensor_default_48" -> "649 linear_31" [label="(1, 197, 3072)", style=solid]; +"645 linear_31_scale_0" -> "648 dequantize_per_channel_default_32" [label="(768,)", style=solid]; +"646 linear_31_zero_point_0" -> "648 dequantize_per_channel_default_32" [label="(768,)", style=solid]; +"647 _frozen_param32" -> "648 dequantize_per_channel_default_32" [label="(768, 3072)", style=solid]; +"648 dequantize_per_channel_default_32" -> "649 linear_31" [label="(768, 3072)", style=solid]; +"649 linear_31" -> "650 dropout_24" [label="(1, 197, 768)", style=solid]; +"650 dropout_24" -> "651 add_16" [label="(1, 197, 768)", style=solid]; +"651 add_16" -> "652 layer_norm_16" [label="(1, 197, 768)", style=solid]; +"651 add_16" -> "697 add_17" [label="(1, 197, 768)", style=solid]; +"652 layer_norm_16" -> "653 transpose_48" [label="(1, 197, 768)", style=solid]; +"653 transpose_48" -> "654 transpose_48_0_0_nncf_smooth_quant_0" [label="(197, 1, 768)", style=solid]; +"654 transpose_48_0_0_nncf_smooth_quant_0" -> "655 quantize_per_tensor_default_49" [label="(197, 1, 768)", style=solid]; +"655 quantize_per_tensor_default_49" -> "656 dequantize_per_tensor_default_49" [label="(197, 1, 768)", style=solid]; +"656 dequantize_per_tensor_default_49" -> "661 linear_32" [label="(197, 1, 768)", style=solid]; +"657 linear_32_scale_0" -> "660 dequantize_per_channel_default_33" [label="(2304,)", style=solid]; +"658 linear_32_zero_point_0" -> "660 dequantize_per_channel_default_33" [label="(2304,)", style=solid]; +"659 _frozen_param33" -> "660 dequantize_per_channel_default_33" [label="(2304, 768)", style=solid]; +"660 dequantize_per_channel_default_33" -> "661 linear_32" [label="(2304, 768)", style=solid]; +"661 linear_32" -> "662 unflatten_8" [label="(197, 1, 2304)", style=solid]; +"662 unflatten_8" -> "663 unsqueeze_8" [label="(197, 1, 3, 768)", style=solid]; +"663 unsqueeze_8" -> "664 transpose_49" [label="(1, 197, 1, 3, 768)", style=solid]; +"664 transpose_49" -> "665 squeeze_8" [label="(3, 197, 1, 1, 768)", style=solid]; +"665 squeeze_8" -> "666 contiguous_8" [label="(3, 197, 1, 768)", style=solid]; +"666 contiguous_8" -> "667 quantize_per_tensor_default_50" [label="(3, 197, 1, 768)", style=solid]; +"666 contiguous_8" -> "670 quantize_per_tensor_default_51" [label="(3, 197, 1, 768)", style=solid]; +"666 contiguous_8" -> "673 select_26" [label="(3, 197, 1, 768)", style=solid]; +"667 quantize_per_tensor_default_50" -> "668 dequantize_per_tensor_default_50" [label="(3, 197, 1, 768)", style=solid]; +"668 dequantize_per_tensor_default_50" -> "669 select_24" [label="(3, 197, 1, 768)", style=solid]; +"669 select_24" -> "674 view_64" [label="(197, 1, 768)", style=solid]; +"670 quantize_per_tensor_default_51" -> "671 dequantize_per_tensor_default_51" [label="(3, 197, 1, 768)", style=solid]; +"671 dequantize_per_tensor_default_51" -> "672 select_25" [label="(3, 197, 1, 768)", style=solid]; +"672 select_25" -> "676 view_65" [label="(197, 1, 768)", style=solid]; +"673 select_26" -> "678 view_66" [label="(197, 1, 768)", style=solid]; +"674 view_64" -> "675 transpose_50" [label="(197, 12, 64)", style=solid]; +"675 transpose_50" -> "680 view_67" [label="(12, 197, 64)", style=solid]; +"676 view_65" -> "677 transpose_51" [label="(197, 12, 64)", style=solid]; +"677 transpose_51" -> "681 view_68" [label="(12, 197, 64)", style=solid]; +"678 view_66" -> "679 transpose_52" [label="(197, 12, 64)", style=solid]; +"679 transpose_52" -> "682 view_69" [label="(12, 197, 64)", style=solid]; +"680 view_67" -> "683 scaled_dot_product_attention_8" [label="(1, 12, 197, 64)", style=solid]; +"681 view_68" -> "683 scaled_dot_product_attention_8" [label="(1, 12, 197, 64)", style=solid]; +"682 view_69" -> "683 scaled_dot_product_attention_8" [label="(1, 12, 197, 64)", style=solid]; +"683 scaled_dot_product_attention_8" -> "684 permute_9" [label="(1, 12, 197, 64)", style=solid]; +"684 permute_9" -> "685 view_70" [label="(197, 1, 12, 64)", style=solid]; +"685 view_70" -> "686 view_70_0_0_nncf_smooth_quant_0" [label="(197, 768)", style=solid]; +"686 view_70_0_0_nncf_smooth_quant_0" -> "687 quantize_per_tensor_default_52" [label="(197, 768)", style=solid]; +"687 quantize_per_tensor_default_52" -> "688 dequantize_per_tensor_default_52" [label="(197, 768)", style=solid]; +"688 dequantize_per_tensor_default_52" -> "693 linear_33" [label="(197, 768)", style=solid]; +"689 linear_33_scale_0" -> "692 dequantize_per_channel_default_34" [label="(768,)", style=solid]; +"690 linear_33_zero_point_0" -> "692 dequantize_per_channel_default_34" [label="(768,)", style=solid]; +"691 _frozen_param34" -> "692 dequantize_per_channel_default_34" [label="(768, 768)", style=solid]; +"692 dequantize_per_channel_default_34" -> "693 linear_33" [label="(768, 768)", style=solid]; +"693 linear_33" -> "694 view_71" [label="(197, 768)", style=solid]; +"694 view_71" -> "695 transpose_53" [label="(197, 1, 768)", style=solid]; +"695 transpose_53" -> "696 dropout_25" [label="(1, 197, 768)", style=solid]; +"696 dropout_25" -> "697 add_17" [label="(1, 197, 768)", style=solid]; +"697 add_17" -> "698 layer_norm_17" [label="(1, 197, 768)", style=solid]; +"697 add_17" -> "718 add_18" [label="(1, 197, 768)", style=solid]; +"698 layer_norm_17" -> "699 layer_norm_17_0_0_nncf_smooth_quant_0" [label="(1, 197, 768)", style=solid]; +"699 layer_norm_17_0_0_nncf_smooth_quant_0" -> "700 quantize_per_tensor_default_53" [label="(1, 197, 768)", style=solid]; +"700 quantize_per_tensor_default_53" -> "701 dequantize_per_tensor_default_53" [label="(1, 197, 768)", style=solid]; +"701 dequantize_per_tensor_default_53" -> "706 linear_34" [label="(1, 197, 768)", style=solid]; +"702 linear_34_scale_0" -> "705 dequantize_per_channel_default_35" [label="(3072,)", style=solid]; +"703 linear_34_zero_point_0" -> "705 dequantize_per_channel_default_35" [label="(3072,)", style=solid]; +"704 _frozen_param35" -> "705 dequantize_per_channel_default_35" [label="(3072, 768)", style=solid]; +"705 dequantize_per_channel_default_35" -> "706 linear_34" [label="(3072, 768)", style=solid]; +"706 linear_34" -> "707 gelu_8" [label="(1, 197, 3072)", style=solid]; +"707 gelu_8" -> "708 dropout_26" [label="(1, 197, 3072)", style=solid]; +"708 dropout_26" -> "709 dropout_26_0_0_nncf_smooth_quant_0" [label="(1, 197, 3072)", style=solid]; +"709 dropout_26_0_0_nncf_smooth_quant_0" -> "710 quantize_per_tensor_default_54" [label="(1, 197, 3072)", style=solid]; +"710 quantize_per_tensor_default_54" -> "711 dequantize_per_tensor_default_54" [label="(1, 197, 3072)", style=solid]; +"711 dequantize_per_tensor_default_54" -> "716 linear_35" [label="(1, 197, 3072)", style=solid]; +"712 linear_35_scale_0" -> "715 dequantize_per_channel_default_36" [label="(768,)", style=solid]; +"713 linear_35_zero_point_0" -> "715 dequantize_per_channel_default_36" [label="(768,)", style=solid]; +"714 _frozen_param36" -> "715 dequantize_per_channel_default_36" [label="(768, 3072)", style=solid]; +"715 dequantize_per_channel_default_36" -> "716 linear_35" [label="(768, 3072)", style=solid]; +"716 linear_35" -> "717 dropout_27" [label="(1, 197, 768)", style=solid]; +"717 dropout_27" -> "718 add_18" [label="(1, 197, 768)", style=solid]; +"718 add_18" -> "719 layer_norm_18" [label="(1, 197, 768)", style=solid]; +"718 add_18" -> "764 add_19" [label="(1, 197, 768)", style=solid]; +"719 layer_norm_18" -> "720 transpose_54" [label="(1, 197, 768)", style=solid]; +"720 transpose_54" -> "721 transpose_54_0_0_nncf_smooth_quant_0" [label="(197, 1, 768)", style=solid]; +"721 transpose_54_0_0_nncf_smooth_quant_0" -> "722 quantize_per_tensor_default_55" [label="(197, 1, 768)", style=solid]; +"722 quantize_per_tensor_default_55" -> "723 dequantize_per_tensor_default_55" [label="(197, 1, 768)", style=solid]; +"723 dequantize_per_tensor_default_55" -> "728 linear_36" [label="(197, 1, 768)", style=solid]; +"724 linear_36_scale_0" -> "727 dequantize_per_channel_default_37" [label="(2304,)", style=solid]; +"725 linear_36_zero_point_0" -> "727 dequantize_per_channel_default_37" [label="(2304,)", style=solid]; +"726 _frozen_param37" -> "727 dequantize_per_channel_default_37" [label="(2304, 768)", style=solid]; +"727 dequantize_per_channel_default_37" -> "728 linear_36" [label="(2304, 768)", style=solid]; +"728 linear_36" -> "729 unflatten_9" [label="(197, 1, 2304)", style=solid]; +"729 unflatten_9" -> "730 unsqueeze_9" [label="(197, 1, 3, 768)", style=solid]; +"730 unsqueeze_9" -> "731 transpose_55" [label="(1, 197, 1, 3, 768)", style=solid]; +"731 transpose_55" -> "732 squeeze_9" [label="(3, 197, 1, 1, 768)", style=solid]; +"732 squeeze_9" -> "733 contiguous_9" [label="(3, 197, 1, 768)", style=solid]; +"733 contiguous_9" -> "734 quantize_per_tensor_default_56" [label="(3, 197, 1, 768)", style=solid]; +"733 contiguous_9" -> "737 quantize_per_tensor_default_57" [label="(3, 197, 1, 768)", style=solid]; +"733 contiguous_9" -> "740 select_29" [label="(3, 197, 1, 768)", style=solid]; +"734 quantize_per_tensor_default_56" -> "735 dequantize_per_tensor_default_56" [label="(3, 197, 1, 768)", style=solid]; +"735 dequantize_per_tensor_default_56" -> "736 select_27" [label="(3, 197, 1, 768)", style=solid]; +"736 select_27" -> "741 view_72" [label="(197, 1, 768)", style=solid]; +"737 quantize_per_tensor_default_57" -> "738 dequantize_per_tensor_default_57" [label="(3, 197, 1, 768)", style=solid]; +"738 dequantize_per_tensor_default_57" -> "739 select_28" [label="(3, 197, 1, 768)", style=solid]; +"739 select_28" -> "743 view_73" [label="(197, 1, 768)", style=solid]; +"740 select_29" -> "745 view_74" [label="(197, 1, 768)", style=solid]; +"741 view_72" -> "742 transpose_56" [label="(197, 12, 64)", style=solid]; +"742 transpose_56" -> "747 view_75" [label="(12, 197, 64)", style=solid]; +"743 view_73" -> "744 transpose_57" [label="(197, 12, 64)", style=solid]; +"744 transpose_57" -> "748 view_76" [label="(12, 197, 64)", style=solid]; +"745 view_74" -> "746 transpose_58" [label="(197, 12, 64)", style=solid]; +"746 transpose_58" -> "749 view_77" [label="(12, 197, 64)", style=solid]; +"747 view_75" -> "750 scaled_dot_product_attention_9" [label="(1, 12, 197, 64)", style=solid]; +"748 view_76" -> "750 scaled_dot_product_attention_9" [label="(1, 12, 197, 64)", style=solid]; +"749 view_77" -> "750 scaled_dot_product_attention_9" [label="(1, 12, 197, 64)", style=solid]; +"750 scaled_dot_product_attention_9" -> "751 permute_10" [label="(1, 12, 197, 64)", style=solid]; +"751 permute_10" -> "752 view_78" [label="(197, 1, 12, 64)", style=solid]; +"752 view_78" -> "753 view_78_0_0_nncf_smooth_quant_0" [label="(197, 768)", style=solid]; +"753 view_78_0_0_nncf_smooth_quant_0" -> "754 quantize_per_tensor_default_58" [label="(197, 768)", style=solid]; +"754 quantize_per_tensor_default_58" -> "755 dequantize_per_tensor_default_58" [label="(197, 768)", style=solid]; +"755 dequantize_per_tensor_default_58" -> "760 linear_37" [label="(197, 768)", style=solid]; +"756 linear_37_scale_0" -> "759 dequantize_per_channel_default_38" [label="(768,)", style=solid]; +"757 linear_37_zero_point_0" -> "759 dequantize_per_channel_default_38" [label="(768,)", style=solid]; +"758 _frozen_param38" -> "759 dequantize_per_channel_default_38" [label="(768, 768)", style=solid]; +"759 dequantize_per_channel_default_38" -> "760 linear_37" [label="(768, 768)", style=solid]; +"760 linear_37" -> "761 view_79" [label="(197, 768)", style=solid]; +"761 view_79" -> "762 transpose_59" [label="(197, 1, 768)", style=solid]; +"762 transpose_59" -> "763 dropout_28" [label="(1, 197, 768)", style=solid]; +"763 dropout_28" -> "764 add_19" [label="(1, 197, 768)", style=solid]; +"764 add_19" -> "765 layer_norm_19" [label="(1, 197, 768)", style=solid]; +"764 add_19" -> "785 add_20" [label="(1, 197, 768)", style=solid]; +"765 layer_norm_19" -> "766 layer_norm_19_0_0_nncf_smooth_quant_0" [label="(1, 197, 768)", style=solid]; +"766 layer_norm_19_0_0_nncf_smooth_quant_0" -> "767 quantize_per_tensor_default_59" [label="(1, 197, 768)", style=solid]; +"767 quantize_per_tensor_default_59" -> "768 dequantize_per_tensor_default_59" [label="(1, 197, 768)", style=solid]; +"768 dequantize_per_tensor_default_59" -> "773 linear_38" [label="(1, 197, 768)", style=solid]; +"769 linear_38_scale_0" -> "772 dequantize_per_channel_default_39" [label="(3072,)", style=solid]; +"770 linear_38_zero_point_0" -> "772 dequantize_per_channel_default_39" [label="(3072,)", style=solid]; +"771 _frozen_param39" -> "772 dequantize_per_channel_default_39" [label="(3072, 768)", style=solid]; +"772 dequantize_per_channel_default_39" -> "773 linear_38" [label="(3072, 768)", style=solid]; +"773 linear_38" -> "774 gelu_9" [label="(1, 197, 3072)", style=solid]; +"774 gelu_9" -> "775 dropout_29" [label="(1, 197, 3072)", style=solid]; +"775 dropout_29" -> "776 dropout_29_0_0_nncf_smooth_quant_0" [label="(1, 197, 3072)", style=solid]; +"776 dropout_29_0_0_nncf_smooth_quant_0" -> "777 quantize_per_tensor_default_60" [label="(1, 197, 3072)", style=solid]; +"777 quantize_per_tensor_default_60" -> "778 dequantize_per_tensor_default_60" [label="(1, 197, 3072)", style=solid]; +"778 dequantize_per_tensor_default_60" -> "783 linear_39" [label="(1, 197, 3072)", style=solid]; +"779 linear_39_scale_0" -> "782 dequantize_per_channel_default_40" [label="(768,)", style=solid]; +"780 linear_39_zero_point_0" -> "782 dequantize_per_channel_default_40" [label="(768,)", style=solid]; +"781 _frozen_param40" -> "782 dequantize_per_channel_default_40" [label="(768, 3072)", style=solid]; +"782 dequantize_per_channel_default_40" -> "783 linear_39" [label="(768, 3072)", style=solid]; +"783 linear_39" -> "784 dropout_30" [label="(1, 197, 768)", style=solid]; +"784 dropout_30" -> "785 add_20" [label="(1, 197, 768)", style=solid]; +"785 add_20" -> "786 layer_norm_20" [label="(1, 197, 768)", style=solid]; +"785 add_20" -> "831 add_21" [label="(1, 197, 768)", style=solid]; +"786 layer_norm_20" -> "787 transpose_60" [label="(1, 197, 768)", style=solid]; +"787 transpose_60" -> "788 transpose_60_0_0_nncf_smooth_quant_0" [label="(197, 1, 768)", style=solid]; +"788 transpose_60_0_0_nncf_smooth_quant_0" -> "789 quantize_per_tensor_default_61" [label="(197, 1, 768)", style=solid]; +"789 quantize_per_tensor_default_61" -> "790 dequantize_per_tensor_default_61" [label="(197, 1, 768)", style=solid]; +"790 dequantize_per_tensor_default_61" -> "795 linear_40" [label="(197, 1, 768)", style=solid]; +"791 linear_40_scale_0" -> "794 dequantize_per_channel_default_41" [label="(2304,)", style=solid]; +"792 linear_40_zero_point_0" -> "794 dequantize_per_channel_default_41" [label="(2304,)", style=solid]; +"793 _frozen_param41" -> "794 dequantize_per_channel_default_41" [label="(2304, 768)", style=solid]; +"794 dequantize_per_channel_default_41" -> "795 linear_40" [label="(2304, 768)", style=solid]; +"795 linear_40" -> "796 unflatten_10" [label="(197, 1, 2304)", style=solid]; +"796 unflatten_10" -> "797 unsqueeze_10" [label="(197, 1, 3, 768)", style=solid]; +"797 unsqueeze_10" -> "798 transpose_61" [label="(1, 197, 1, 3, 768)", style=solid]; +"798 transpose_61" -> "799 squeeze_10" [label="(3, 197, 1, 1, 768)", style=solid]; +"799 squeeze_10" -> "800 contiguous_10" [label="(3, 197, 1, 768)", style=solid]; +"800 contiguous_10" -> "801 quantize_per_tensor_default_62" [label="(3, 197, 1, 768)", style=solid]; +"800 contiguous_10" -> "804 quantize_per_tensor_default_63" [label="(3, 197, 1, 768)", style=solid]; +"800 contiguous_10" -> "807 select_32" [label="(3, 197, 1, 768)", style=solid]; +"801 quantize_per_tensor_default_62" -> "802 dequantize_per_tensor_default_62" [label="(3, 197, 1, 768)", style=solid]; +"802 dequantize_per_tensor_default_62" -> "803 select_30" [label="(3, 197, 1, 768)", style=solid]; +"803 select_30" -> "808 view_80" [label="(197, 1, 768)", style=solid]; +"804 quantize_per_tensor_default_63" -> "805 dequantize_per_tensor_default_63" [label="(3, 197, 1, 768)", style=solid]; +"805 dequantize_per_tensor_default_63" -> "806 select_31" [label="(3, 197, 1, 768)", style=solid]; +"806 select_31" -> "810 view_81" [label="(197, 1, 768)", style=solid]; +"807 select_32" -> "812 view_82" [label="(197, 1, 768)", style=solid]; +"808 view_80" -> "809 transpose_62" [label="(197, 12, 64)", style=solid]; +"809 transpose_62" -> "814 view_83" [label="(12, 197, 64)", style=solid]; +"810 view_81" -> "811 transpose_63" [label="(197, 12, 64)", style=solid]; +"811 transpose_63" -> "815 view_84" [label="(12, 197, 64)", style=solid]; +"812 view_82" -> "813 transpose_64" [label="(197, 12, 64)", style=solid]; +"813 transpose_64" -> "816 view_85" [label="(12, 197, 64)", style=solid]; +"814 view_83" -> "817 scaled_dot_product_attention_10" [label="(1, 12, 197, 64)", style=solid]; +"815 view_84" -> "817 scaled_dot_product_attention_10" [label="(1, 12, 197, 64)", style=solid]; +"816 view_85" -> "817 scaled_dot_product_attention_10" [label="(1, 12, 197, 64)", style=solid]; +"817 scaled_dot_product_attention_10" -> "818 permute_11" [label="(1, 12, 197, 64)", style=solid]; +"818 permute_11" -> "819 view_86" [label="(197, 1, 12, 64)", style=solid]; +"819 view_86" -> "820 view_86_0_0_nncf_smooth_quant_0" [label="(197, 768)", style=solid]; +"820 view_86_0_0_nncf_smooth_quant_0" -> "821 quantize_per_tensor_default_64" [label="(197, 768)", style=solid]; +"821 quantize_per_tensor_default_64" -> "822 dequantize_per_tensor_default_64" [label="(197, 768)", style=solid]; +"822 dequantize_per_tensor_default_64" -> "827 linear_41" [label="(197, 768)", style=solid]; +"823 linear_41_scale_0" -> "826 dequantize_per_channel_default_42" [label="(768,)", style=solid]; +"824 linear_41_zero_point_0" -> "826 dequantize_per_channel_default_42" [label="(768,)", style=solid]; +"825 _frozen_param42" -> "826 dequantize_per_channel_default_42" [label="(768, 768)", style=solid]; +"826 dequantize_per_channel_default_42" -> "827 linear_41" [label="(768, 768)", style=solid]; +"827 linear_41" -> "828 view_87" [label="(197, 768)", style=solid]; +"828 view_87" -> "829 transpose_65" [label="(197, 1, 768)", style=solid]; +"829 transpose_65" -> "830 dropout_31" [label="(1, 197, 768)", style=solid]; +"830 dropout_31" -> "831 add_21" [label="(1, 197, 768)", style=solid]; +"831 add_21" -> "832 layer_norm_21" [label="(1, 197, 768)", style=solid]; +"831 add_21" -> "852 add_22" [label="(1, 197, 768)", style=solid]; +"832 layer_norm_21" -> "833 layer_norm_21_0_0_nncf_smooth_quant_0" [label="(1, 197, 768)", style=solid]; +"833 layer_norm_21_0_0_nncf_smooth_quant_0" -> "834 quantize_per_tensor_default_65" [label="(1, 197, 768)", style=solid]; +"834 quantize_per_tensor_default_65" -> "835 dequantize_per_tensor_default_65" [label="(1, 197, 768)", style=solid]; +"835 dequantize_per_tensor_default_65" -> "840 linear_42" [label="(1, 197, 768)", style=solid]; +"836 linear_42_scale_0" -> "839 dequantize_per_channel_default_43" [label="(3072,)", style=solid]; +"837 linear_42_zero_point_0" -> "839 dequantize_per_channel_default_43" [label="(3072,)", style=solid]; +"838 _frozen_param43" -> "839 dequantize_per_channel_default_43" [label="(3072, 768)", style=solid]; +"839 dequantize_per_channel_default_43" -> "840 linear_42" [label="(3072, 768)", style=solid]; +"840 linear_42" -> "841 gelu_10" [label="(1, 197, 3072)", style=solid]; +"841 gelu_10" -> "842 dropout_32" [label="(1, 197, 3072)", style=solid]; +"842 dropout_32" -> "843 dropout_32_0_0_nncf_smooth_quant_0" [label="(1, 197, 3072)", style=solid]; +"843 dropout_32_0_0_nncf_smooth_quant_0" -> "844 quantize_per_tensor_default_66" [label="(1, 197, 3072)", style=solid]; +"844 quantize_per_tensor_default_66" -> "845 dequantize_per_tensor_default_66" [label="(1, 197, 3072)", style=solid]; +"845 dequantize_per_tensor_default_66" -> "850 linear_43" [label="(1, 197, 3072)", style=solid]; +"846 linear_43_scale_0" -> "849 dequantize_per_channel_default_44" [label="(768,)", style=solid]; +"847 linear_43_zero_point_0" -> "849 dequantize_per_channel_default_44" [label="(768,)", style=solid]; +"848 _frozen_param44" -> "849 dequantize_per_channel_default_44" [label="(768, 3072)", style=solid]; +"849 dequantize_per_channel_default_44" -> "850 linear_43" [label="(768, 3072)", style=solid]; +"850 linear_43" -> "851 dropout_33" [label="(1, 197, 768)", style=solid]; +"851 dropout_33" -> "852 add_22" [label="(1, 197, 768)", style=solid]; +"852 add_22" -> "853 layer_norm_22" [label="(1, 197, 768)", style=solid]; +"852 add_22" -> "898 add_23" [label="(1, 197, 768)", style=solid]; +"853 layer_norm_22" -> "854 transpose_66" [label="(1, 197, 768)", style=solid]; +"854 transpose_66" -> "855 transpose_66_0_0_nncf_smooth_quant_0" [label="(197, 1, 768)", style=solid]; +"855 transpose_66_0_0_nncf_smooth_quant_0" -> "856 quantize_per_tensor_default_67" [label="(197, 1, 768)", style=solid]; +"856 quantize_per_tensor_default_67" -> "857 dequantize_per_tensor_default_67" [label="(197, 1, 768)", style=solid]; +"857 dequantize_per_tensor_default_67" -> "862 linear_44" [label="(197, 1, 768)", style=solid]; +"858 linear_44_scale_0" -> "861 dequantize_per_channel_default_45" [label="(2304,)", style=solid]; +"859 linear_44_zero_point_0" -> "861 dequantize_per_channel_default_45" [label="(2304,)", style=solid]; +"860 _frozen_param45" -> "861 dequantize_per_channel_default_45" [label="(2304, 768)", style=solid]; +"861 dequantize_per_channel_default_45" -> "862 linear_44" [label="(2304, 768)", style=solid]; +"862 linear_44" -> "863 unflatten_11" [label="(197, 1, 2304)", style=solid]; +"863 unflatten_11" -> "864 unsqueeze_11" [label="(197, 1, 3, 768)", style=solid]; +"864 unsqueeze_11" -> "865 transpose_67" [label="(1, 197, 1, 3, 768)", style=solid]; +"865 transpose_67" -> "866 squeeze_11" [label="(3, 197, 1, 1, 768)", style=solid]; +"866 squeeze_11" -> "867 contiguous_11" [label="(3, 197, 1, 768)", style=solid]; +"867 contiguous_11" -> "868 quantize_per_tensor_default_68" [label="(3, 197, 1, 768)", style=solid]; +"867 contiguous_11" -> "871 quantize_per_tensor_default_69" [label="(3, 197, 1, 768)", style=solid]; +"867 contiguous_11" -> "874 select_35" [label="(3, 197, 1, 768)", style=solid]; +"868 quantize_per_tensor_default_68" -> "869 dequantize_per_tensor_default_68" [label="(3, 197, 1, 768)", style=solid]; +"869 dequantize_per_tensor_default_68" -> "870 select_33" [label="(3, 197, 1, 768)", style=solid]; +"870 select_33" -> "875 view_88" [label="(197, 1, 768)", style=solid]; +"871 quantize_per_tensor_default_69" -> "872 dequantize_per_tensor_default_69" [label="(3, 197, 1, 768)", style=solid]; +"872 dequantize_per_tensor_default_69" -> "873 select_34" [label="(3, 197, 1, 768)", style=solid]; +"873 select_34" -> "877 view_89" [label="(197, 1, 768)", style=solid]; +"874 select_35" -> "879 view_90" [label="(197, 1, 768)", style=solid]; +"875 view_88" -> "876 transpose_68" [label="(197, 12, 64)", style=solid]; +"876 transpose_68" -> "881 view_91" [label="(12, 197, 64)", style=solid]; +"877 view_89" -> "878 transpose_69" [label="(197, 12, 64)", style=solid]; +"878 transpose_69" -> "882 view_92" [label="(12, 197, 64)", style=solid]; +"879 view_90" -> "880 transpose_70" [label="(197, 12, 64)", style=solid]; +"880 transpose_70" -> "883 view_93" [label="(12, 197, 64)", style=solid]; +"881 view_91" -> "884 scaled_dot_product_attention_11" [label="(1, 12, 197, 64)", style=solid]; +"882 view_92" -> "884 scaled_dot_product_attention_11" [label="(1, 12, 197, 64)", style=solid]; +"883 view_93" -> "884 scaled_dot_product_attention_11" [label="(1, 12, 197, 64)", style=solid]; +"884 scaled_dot_product_attention_11" -> "885 permute_12" [label="(1, 12, 197, 64)", style=solid]; +"885 permute_12" -> "886 view_94" [label="(197, 1, 12, 64)", style=solid]; +"886 view_94" -> "887 view_94_0_0_nncf_smooth_quant_0" [label="(197, 768)", style=solid]; +"887 view_94_0_0_nncf_smooth_quant_0" -> "888 quantize_per_tensor_default_70" [label="(197, 768)", style=solid]; +"888 quantize_per_tensor_default_70" -> "889 dequantize_per_tensor_default_70" [label="(197, 768)", style=solid]; +"889 dequantize_per_tensor_default_70" -> "894 linear_45" [label="(197, 768)", style=solid]; +"890 linear_45_scale_0" -> "893 dequantize_per_channel_default_46" [label="(768,)", style=solid]; +"891 linear_45_zero_point_0" -> "893 dequantize_per_channel_default_46" [label="(768,)", style=solid]; +"892 _frozen_param46" -> "893 dequantize_per_channel_default_46" [label="(768, 768)", style=solid]; +"893 dequantize_per_channel_default_46" -> "894 linear_45" [label="(768, 768)", style=solid]; +"894 linear_45" -> "895 view_95" [label="(197, 768)", style=solid]; +"895 view_95" -> "896 transpose_71" [label="(197, 1, 768)", style=solid]; +"896 transpose_71" -> "897 dropout_34" [label="(1, 197, 768)", style=solid]; +"897 dropout_34" -> "898 add_23" [label="(1, 197, 768)", style=solid]; +"898 add_23" -> "899 layer_norm_23" [label="(1, 197, 768)", style=solid]; +"898 add_23" -> "919 add_24" [label="(1, 197, 768)", style=solid]; +"899 layer_norm_23" -> "900 layer_norm_23_0_0_nncf_smooth_quant_0" [label="(1, 197, 768)", style=solid]; +"900 layer_norm_23_0_0_nncf_smooth_quant_0" -> "901 quantize_per_tensor_default_71" [label="(1, 197, 768)", style=solid]; +"901 quantize_per_tensor_default_71" -> "902 dequantize_per_tensor_default_71" [label="(1, 197, 768)", style=solid]; +"902 dequantize_per_tensor_default_71" -> "907 linear_46" [label="(1, 197, 768)", style=solid]; +"903 linear_46_scale_0" -> "906 dequantize_per_channel_default_47" [label="(3072,)", style=solid]; +"904 linear_46_zero_point_0" -> "906 dequantize_per_channel_default_47" [label="(3072,)", style=solid]; +"905 _frozen_param47" -> "906 dequantize_per_channel_default_47" [label="(3072, 768)", style=solid]; +"906 dequantize_per_channel_default_47" -> "907 linear_46" [label="(3072, 768)", style=solid]; +"907 linear_46" -> "908 gelu_11" [label="(1, 197, 3072)", style=solid]; +"908 gelu_11" -> "909 dropout_35" [label="(1, 197, 3072)", style=solid]; +"909 dropout_35" -> "910 dropout_35_0_0_nncf_smooth_quant_0" [label="(1, 197, 3072)", style=solid]; +"910 dropout_35_0_0_nncf_smooth_quant_0" -> "911 quantize_per_tensor_default_72" [label="(1, 197, 3072)", style=solid]; +"911 quantize_per_tensor_default_72" -> "912 dequantize_per_tensor_default_72" [label="(1, 197, 3072)", style=solid]; +"912 dequantize_per_tensor_default_72" -> "917 linear_47" [label="(1, 197, 3072)", style=solid]; +"913 linear_47_scale_0" -> "916 dequantize_per_channel_default_48" [label="(768,)", style=solid]; +"914 linear_47_zero_point_0" -> "916 dequantize_per_channel_default_48" [label="(768,)", style=solid]; +"915 _frozen_param48" -> "916 dequantize_per_channel_default_48" [label="(768, 3072)", style=solid]; +"916 dequantize_per_channel_default_48" -> "917 linear_47" [label="(768, 3072)", style=solid]; +"917 linear_47" -> "918 dropout_36" [label="(1, 197, 768)", style=solid]; +"918 dropout_36" -> "919 add_24" [label="(1, 197, 768)", style=solid]; +"919 add_24" -> "920 layer_norm_24" [label="(1, 197, 768)", style=solid]; +"920 layer_norm_24" -> "921 slice_1" [label="(1, 197, 768)", style=solid]; +"921 slice_1" -> "922 select_36" [label="(1, 197, 768)", style=solid]; +"922 select_36" -> "923 select_36_0_0_nncf_smooth_quant_0" [label="(1, 768)", style=solid]; +"923 select_36_0_0_nncf_smooth_quant_0" -> "924 quantize_per_tensor_default_73" [label="(1, 768)", style=solid]; +"924 quantize_per_tensor_default_73" -> "925 dequantize_per_tensor_default_73" [label="(1, 768)", style=solid]; +"925 dequantize_per_tensor_default_73" -> "930 linear_48" [label="(1, 768)", style=solid]; +"926 linear_48_scale_0" -> "929 dequantize_per_channel_default_49" [label="(1000,)", style=solid]; +"927 linear_48_zero_point_0" -> "929 dequantize_per_channel_default_49" [label="(1000,)", style=solid]; +"928 _frozen_param49" -> "929 dequantize_per_channel_default_49" [label="(1000, 768)", style=solid]; +"929 dequantize_per_channel_default_49" -> "930 linear_48" [label="(1000, 768)", style=solid]; +"930 linear_48" -> "931 output" [label="(1, 1000)", style=solid]; +} diff --git a/tests/torch/data/reference_graphs/fx/experimental/OpenVINOQuantizer/yolo11n_sdpa_block.dot b/tests/torch/data/reference_graphs/fx/experimental/OpenVINOQuantizer/yolo11n_sdpa_block.dot new file mode 100644 index 00000000000..63ad8ac0b09 --- /dev/null +++ b/tests/torch/data/reference_graphs/fx/experimental/OpenVINOQuantizer/yolo11n_sdpa_block.dot @@ -0,0 +1,61 @@ +strict digraph { +"0 x" [id=0, type=input]; +"1 x_0_0_nncf_smooth_quant_0" [id=1, type=call_module]; +"2 quantize_per_tensor_default" [id=2, type=quantize_per_tensor]; +"3 dequantize_per_tensor_default" [id=3, type=dequantize_per_tensor]; +"4 linear_scale_0" [id=4, type=get_attr]; +"5 linear_zero_point_0" [id=5, type=get_attr]; +"6 _frozen_param0" [id=6, type=get_attr]; +"7 dequantize_per_channel_default" [id=7, type=dequantize_per_channel]; +"8 linear" [id=8, type=linear]; +"9 quantize_per_tensor_default_1" [id=9, type=quantize_per_tensor]; +"10 dequantize_per_tensor_default_1" [id=10, type=dequantize_per_tensor]; +"11 slice_1" [id=11, type=slice]; +"12 slice_2" [id=12, type=slice]; +"13 slice_3" [id=13, type=slice]; +"14 quantize_per_tensor_default_2" [id=14, type=quantize_per_tensor]; +"15 dequantize_per_tensor_default_2" [id=15, type=dequantize_per_tensor]; +"16 slice_4" [id=16, type=slice]; +"17 slice_5" [id=17, type=slice]; +"18 slice_6" [id=18, type=slice]; +"19 slice_7" [id=19, type=slice]; +"20 slice_8" [id=20, type=slice]; +"21 slice_9" [id=21, type=slice]; +"22 transpose" [id=22, type=transpose]; +"23 matmul" [id=23, type=matmul]; +"24 div_" [id=24, type=div_]; +"25 softmax" [id=25, type=softmax]; +"26 transpose_1" [id=26, type=transpose]; +"27 matmul_1" [id=27, type=matmul]; +"28 output" [id=28, type=output]; +"0 x" -> "1 x_0_0_nncf_smooth_quant_0" [label="(1, 2, 4)", style=solid]; +"1 x_0_0_nncf_smooth_quant_0" -> "2 quantize_per_tensor_default" [label="(1, 2, 4)", style=solid]; +"2 quantize_per_tensor_default" -> "3 dequantize_per_tensor_default" [label="(1, 2, 4)", style=solid]; +"3 dequantize_per_tensor_default" -> "8 linear" [label="(1, 2, 4)", style=solid]; +"4 linear_scale_0" -> "7 dequantize_per_channel_default" [label="(12,)", style=solid]; +"5 linear_zero_point_0" -> "7 dequantize_per_channel_default" [label="(12,)", style=solid]; +"6 _frozen_param0" -> "7 dequantize_per_channel_default" [label="(12, 4)", style=solid]; +"7 dequantize_per_channel_default" -> "8 linear" [label="(12, 4)", style=solid]; +"8 linear" -> "9 quantize_per_tensor_default_1" [label="(1, 2, 12)", style=solid]; +"8 linear" -> "14 quantize_per_tensor_default_2" [label="(1, 2, 12)", style=solid]; +"8 linear" -> "19 slice_7" [label="(1, 2, 12)", style=solid]; +"9 quantize_per_tensor_default_1" -> "10 dequantize_per_tensor_default_1" [label="(1, 2, 12)", style=solid]; +"10 dequantize_per_tensor_default_1" -> "11 slice_1" [label="(1, 2, 12)", style=solid]; +"11 slice_1" -> "12 slice_2" [label="(1, 2, 12)", style=solid]; +"12 slice_2" -> "13 slice_3" [label="(1, 2, 12)", style=solid]; +"13 slice_3" -> "23 matmul" [label="(1, 2, 4)", style=solid]; +"14 quantize_per_tensor_default_2" -> "15 dequantize_per_tensor_default_2" [label="(1, 2, 12)", style=solid]; +"15 dequantize_per_tensor_default_2" -> "16 slice_4" [label="(1, 2, 12)", style=solid]; +"16 slice_4" -> "17 slice_5" [label="(1, 2, 12)", style=solid]; +"17 slice_5" -> "18 slice_6" [label="(1, 2, 12)", style=solid]; +"18 slice_6" -> "22 transpose" [label="(1, 2, 4)", style=solid]; +"19 slice_7" -> "20 slice_8" [label="(1, 2, 12)", style=solid]; +"20 slice_8" -> "21 slice_9" [label="(1, 2, 12)", style=solid]; +"21 slice_9" -> "27 matmul_1" [label="(1, 2, 4)", style=solid]; +"22 transpose" -> "23 matmul" [label="(1, 4, 2)", style=solid]; +"23 matmul" -> "24 div_" [label="(1, 2, 2)", style=solid]; +"24 div_" -> "25 softmax" [label="(1, 2, 2)", style=solid]; +"25 softmax" -> "26 transpose_1" [label="(1, 2, 2)", style=solid]; +"26 transpose_1" -> "27 matmul_1" [label="(1, 2, 2)", style=solid]; +"27 matmul_1" -> "28 output" [label="(1, 2, 4)", style=solid]; +}