Ignored scope matching working with multiple NNCFGraphs

nncf/common/graph/graph.py

@@ -238,7 +238,7 @@ def get_nodes_by_types(self, type_list: List[str]) -> List[NNCFNode]:
         :return: List of nodes with provided types.
         """
         all_nodes_of_type = []
-        for nncf_node in self.get_all_nodes():
+        for nncf_node in self.nodes.values():
             if nncf_node.node_type in type_list:
                 all_nodes_of_type.append(nncf_node)
         return all_nodes_of_type

nncf/onnx/quantization/quantize_model.py

@@ -30,8 +30,9 @@
 from nncf.quantization.algorithms.accuracy_control.algorithm import calculate_accuracy_drop
 from nncf.quantization.algorithms.accuracy_control.evaluator import Evaluator
 from nncf.quantization.algorithms.post_training.algorithm import PostTrainingQuantization
+from nncf.quantization.quantize_model import BATCHWISE_STATISTICS_WARNING
+from nncf.quantization.quantize_model import is_model_no_batchwise_support
 from nncf.quantization.quantize_model import quantize_with_tune_hyperparams
-from nncf.quantization.quantize_model import warning_model_no_batchwise_support
 from nncf.quantization.telemetry_extractors import CompressionStartedWithQuantizeApi
 from nncf.scopes import IgnoredScope
 from nncf.telemetry import tracked_function
@@ -83,7 +84,8 @@ def quantize_impl(
     )
 
     graph = GraphConverter.create_nncf_graph(model)
-    warning_model_no_batchwise_support(graph, advanced_parameters, model_type, OPERATIONS_OUTPUT_HAS_NO_BATCH_AXIS)
+    if is_model_no_batchwise_support(graph, advanced_parameters, model_type, OPERATIONS_OUTPUT_HAS_NO_BATCH_AXIS):
+        nncf_logger.warning(BATCHWISE_STATISTICS_WARNING)
     quantized_model = quantization_algorithm.apply(model, graph, dataset=calibration_dataset)
 
     return quantized_model

nncf/openvino/quantization/quantize_ifmodel.py

@@ -10,14 +10,13 @@
 # limitations under the License.
 
 from itertools import islice
-from typing import List, Optional, Tuple
+from typing import Dict, List, Optional, Tuple
 
 import openvino.runtime as ov
 
 from nncf import Dataset
 from nncf.common import factory
 from nncf.common.engine import Engine
-from nncf.common.factory import NNCFGraphFactory
 from nncf.common.graph.graph import NNCFGraph
 from nncf.common.graph.graph import NNCFNode
 from nncf.common.graph.model_transformer import ModelTransformer
@@ -135,26 +134,25 @@ def _add_outputs_before_if_node(model_transformer: ModelTransformer, model: ov.M
 def apply_algorithm_if_bodies(
     algorithm: Algorithm,
     parent_model: ov.Model,
-    parent_graph: NNCFGraph,
+    graphs: Dict[int, NNCFGraph],
     parent_dataset: Dataset,
     subset_size: int,
     current_model_num: int,
-    all_models_num: int,
     parent_statistic_points: Optional[StatisticPointsContainer] = None,
 ) -> Tuple[ov.Model, int]:
     """
     Applies an algorithm recursievley to each bodies of If node.
 
     :param parent_model: Model to apply algorithm.
-    :param parent_graph: Graph of a model.
+    :param graphs: Mapping from model_number and its graph.
     :param parent_dataset: Dataset for algorithm.
     :param subset_size: Size of a dataset to use for calibration.
     :param current_model_num: Current model number.
-    :param all_models_num: All model numbers.
     :param parent_statistic_points: Statistics points for algorithm.
     :return: A model for every bodies of If nodes the algorithm was applied and the latest model number.
     """
-    nncf_logger.info(f"Iteration [{current_model_num}/{all_models_num}] ...")
+    nncf_logger.info(f"Iteration [{current_model_num}/{len(graphs)}] ...")
+    parent_graph = graphs[current_model_num]
     quantized_model = algorithm.apply(parent_model, parent_graph, parent_statistic_points, parent_dataset)
     if get_number_if_op(parent_model) == 0:
         return quantized_model, current_model_num
@@ -183,20 +181,18 @@ def apply_algorithm_if_bodies(
         then_quantized_model, current_model_num = apply_algorithm_if_bodies(
             algorithm,
             then_model,
-            NNCFGraphFactory.create(then_model),
+            graphs,
             then_dataset,
             subset_size,
             current_model_num + 1,
-            all_models_num,
         )
         else_quantized_model, current_model_num = apply_algorithm_if_bodies(
             algorithm,
             else_model,
-            NNCFGraphFactory.create(else_model),
+            graphs,
             else_dataset,
             subset_size,
             current_model_num + 1,
-            all_models_num,
         )
         model_transformer_int8 = factory.ModelTransformerFactory.create(quantized_model)
         quantized_model = _update_if_body(model_transformer_int8, if_node, True, then_quantized_model)

nncf/openvino/quantization/quantize_model.py

@@ -20,6 +20,8 @@
 from nncf.common.quantization.structs import QuantizationPreset
 from nncf.data import Dataset
 from nncf.openvino.graph.metatypes.groups import OPERATIONS_OUTPUT_HAS_NO_BATCH_AXIS
+from nncf.openvino.graph.metatypes.openvino_metatypes import OVIfMetatype
+from nncf.openvino.graph.metatypes.openvino_metatypes import get_node_metatype
 from nncf.openvino.graph.model_utils import remove_friendly_name_duplicates
 from nncf.openvino.graph.nncf_graph_builder import GraphConverter
 from nncf.openvino.graph.node_utils import get_number_if_op
@@ -42,10 +44,13 @@
 from nncf.quantization.algorithms.accuracy_control.evaluator import Evaluator
 from nncf.quantization.algorithms.post_training.algorithm import PostTrainingQuantization
 from nncf.quantization.algorithms.weight_compression.algorithm import WeightCompression
+from nncf.quantization.quantize_model import BATCHWISE_STATISTICS_WARNING
+from nncf.quantization.quantize_model import is_model_no_batchwise_support
 from nncf.quantization.quantize_model import quantize_with_tune_hyperparams
-from nncf.quantization.quantize_model import warning_model_no_batchwise_support
 from nncf.quantization.telemetry_extractors import CompressionStartedWithQuantizeApi
 from nncf.scopes import IgnoredScope
+from nncf.scopes import get_ignored_scope_match
+from nncf.scopes import validate_ignored_scope
 from nncf.telemetry.decorator import tracked_function
 from nncf.telemetry.events import NNCF_OV_CATEGORY
 
@@ -72,6 +77,22 @@ def native_quantize_if_op_impl(
         raise NotImplementedError(
             "The BiasCorrection algorithm is not supported for OpenVINO models with If operation."
         )
+    graphs = {}
+
+    def _get_all_graphs(model: ov.Model, current_cnt: int):
+        graphs[current_cnt] = NNCFGraphFactory.create(model)
+        for op in model.get_ops():
+            if get_node_metatype(op) == OVIfMetatype:
+                current_cnt = _get_all_graphs(op.get_function(0), current_cnt + 1)
+                current_cnt = _get_all_graphs(op.get_function(1), current_cnt + 1)
+        return current_cnt
+
+    _get_all_graphs(model, 1)
+    if ignored_scope and ignored_scope.validate:
+        validate_ignored_scope(ignored_scope, get_ignored_scope_match(ignored_scope, graphs.values())[0])
+        ignored_scope = IgnoredScope(
+            ignored_scope.names, ignored_scope.patterns, ignored_scope.types, ignored_scope.subgraphs, validate=False
+        )
     quantization_algorithm = PostTrainingQuantization(
         mode=mode,
         preset=preset,
@@ -82,17 +103,17 @@ def native_quantize_if_op_impl(
         ignored_scope=ignored_scope,
         advanced_parameters=advanced_parameters,
     )
-
-    graph = GraphConverter.create_nncf_graph(model)
-    warning_model_no_batchwise_support(graph, advanced_parameters, model_type, OPERATIONS_OUTPUT_HAS_NO_BATCH_AXIS)
+    for graph in graphs.values():
+        if is_model_no_batchwise_support(graph, advanced_parameters, model_type, OPERATIONS_OUTPUT_HAS_NO_BATCH_AXIS):
+            nncf_logger.warning(BATCHWISE_STATISTICS_WARNING)
+            break
     if_ops_number = get_number_if_op(model)
-    all_models_number = if_ops_number * 2 + 1
     nncf_logger.info(
         f"The model consists of {if_ops_number} If node(-s) with then and else bodies. \
             Main model and all If bodies will be quantized recursively."
     )
     quantized_model, _ = apply_algorithm_if_bodies(
-        quantization_algorithm, model, graph, calibration_dataset, subset_size, 1, all_models_number
+        quantization_algorithm, model, graphs, calibration_dataset, subset_size, 1
     )
 
     if is_weight_compression_needed(advanced_parameters):
@@ -140,7 +161,8 @@ def native_quantize_impl(
         advanced_parameters=advanced_parameters,
     )
     graph = GraphConverter.create_nncf_graph(model)
-    warning_model_no_batchwise_support(graph, advanced_parameters, model_type, OPERATIONS_OUTPUT_HAS_NO_BATCH_AXIS)
+    if is_model_no_batchwise_support(graph, advanced_parameters, model_type, OPERATIONS_OUTPUT_HAS_NO_BATCH_AXIS):
+        nncf_logger.warning(BATCHWISE_STATISTICS_WARNING)
     quantized_model = quantization_algorithm.apply(model, graph, dataset=calibration_dataset)
 
     if is_weight_compression_needed(advanced_parameters):

nncf/quantization/quantize_model.py

@@ -16,7 +16,6 @@
 from nncf.common.deprecation import warning_deprecated
 from nncf.common.graph import NNCFGraph
 from nncf.common.graph.operator_metatypes import OperatorMetatype
-from nncf.common.logging.logger import nncf_logger
 from nncf.common.quantization.structs import QuantizationPreset
 from nncf.common.utils.api_marker import api
 from nncf.common.utils.backend import BackendType
@@ -47,26 +46,25 @@
 )
 
 
-def warning_model_no_batchwise_support(
+def is_model_no_batchwise_support(
     graph: NNCFGraph,
     advanced_quantization_parameters: Optional[AdvancedQuantizationParameters],
     model_type: ModelType,
     no_batchwise_support_metatypes: List[OperatorMetatype],
 ) -> None:
     """
-    Prints the warning message if batchwise statistics could lead to a significant accuracy drop.
+    Returns True if batchwise statistics could lead to a significant accuracy drop.
 
     :param graph: Model's NNCFGraph.
     :param advanced_quantization_parameters: AdvancedQuantizationParameters.
     :param model_type: Model type algorithm option.
     :param no_batchwise_support_metatypes: Meatypes having no batchwise statistics support.
     """
-    if (
+    return (
         advanced_quantization_parameters
         and advanced_quantization_parameters.batchwise_statistics
         and (graph.get_nodes_by_metatypes(no_batchwise_support_metatypes) or model_type == ModelType.TRANSFORMER)
-    ):
-        nncf_logger.warning(BATCHWISE_STATISTICS_WARNING)
+    )
 
 
 def _update_advanced_quantization_parameters(