AC: fix output tenors maring release (#3426)

Author: eaidova

tools/accuracy_checker/openvino/tools/accuracy_checker/launcher/openvino_launcher.py

@@ -22,6 +22,7 @@
 import warnings
 import numpy as np
 from openvino.runtime import Core, AsyncInferQueue, get_version, PartialShape, Type, Dimension
+from openvino.preprocess import PrePostProcessor
 from .dlsdk_launcher_config import (
     HETERO_KEYWORD, MULTI_DEVICE_KEYWORD, NIREQ_REGEX, VPU_PLUGINS,
     get_cpu_extension,
@@ -494,19 +495,24 @@ def _log_versions(self):
     def _create_network(self, input_shapes=None):
         model_path = Path(self._model)
         compiled_model = model_path.suffix == '.blob'
+        self.out_tensor_name_to_node = {}
         if compiled_model:
             self.network = None
             with open(str(self._model), 'rb') as f: #pylint:disable=unspecified-encoding
                 self.exec_network = self.ie_core.import_model(io.BytesIO(f.read()), self._device)
             self.original_outputs = self.exec_network.outputs
             model_batch = self._get_model_batch_size()
             self._batch = model_batch if model_batch is not None else 1
+            for out in self.original_outputs:
+                if not out.names:
+                    continue
+                for name in out.names:
+                    self.out_tensor_name_to_node[name] = out.get_node().friendly_name
             return
         if self._weights is None and self._model.suffix != '.onnx':
             self._weights = model_path.parent / (model_path.name.split(model_path.suffix)[0] + '.bin')
         self.network = self.read_network(self._model, self._weights)
         self.original_outputs = self.network.outputs
-        self.out_tensor_name_to_node = {}
         for out in self.original_outputs:
             if not out.names:
                 continue
@@ -587,8 +593,10 @@ def load_network(self, network=None, log=False, preprocessing=None):
             self.network = network
         if self.network is not None:
             self.dyn_input_layers, self._partial_shapes = self.get_dynamic_inputs(self.network)
-        self.input_to_tensor_name = self.get_input_tensor_name_mapping(self.network)
-        self.input_to_index = {inp.get_node().friendly_name: idx for idx, inp in enumerate(self.network.inputs)}
+        self.input_to_tensor_name = self.get_input_tensor_name_mapping(
+            self.network if self.network is not None else self.exec_network)
+        network_inputs = self.network.inputs if self.network is not None else self.exec_network.inputs
+        self.input_to_index = {inp.get_node().friendly_name: idx for idx, inp in enumerate(network_inputs)}
         if not self._postpone_input_configuration:
             self._set_precision()
             self._set_input_shape()
@@ -597,12 +605,13 @@ def load_network(self, network=None, log=False, preprocessing=None):
                 self.print_input_output_info(self.network if self.network is not None else self.exec_network)
             if preprocessing:
                 self._set_preprocess(preprocessing)
+                self.dyn_input_layers, self._partial_shapes = self.get_dynamic_inputs(self.network)
             model_batch = self._get_model_batch_size()
             model_batch = 1 if model_batch is None else model_batch
             self._batch = self.config.get('batch', model_batch)
             self._set_batch_size(self._batch)
             self.try_to_set_default_layout()
-            if self.network and not preprocessing and (not self.dyn_input_layers or self.is_dynamic):
+            if self.network and (not self.dyn_input_layers or self.is_dynamic or self.disable_resize_to_input):
                 self.exec_network = self.ie_core.compile_model(self.network, self._device)
                 self.infer_request = self.exec_network.create_infer_request()
 
@@ -838,11 +847,15 @@ def _data_to_blob(self, layer_shape, data, layout):  # pylint:disable=R0911,R091
 
     def _set_precision(self):
         config_inputs = self.config.get('inputs', [])
-        for input_config in config_inputs:
-            if 'precision' in input_config:
-                if self.network:
-                    self.inputs[input_config['name']].set_element_type(
-                        PRECISION_STR_TO_TYPE[input_config['precision'].upper()])
+        has_precisions = ['precision' in inp for inp in config_inputs]
+        if has_precisions and self.network:
+            preprocessor = PrePostProcessor(self.network)
+            for input_config in config_inputs:
+                if 'precision' in input_config:
+                    name = input_config['name']
+                    element_type =  PRECISION_STR_TO_TYPE[input_config['precision'].upper()]
+                    preprocessor.input(self.input_to_index[name]).tensor().set_element_type(element_type)
+            self.network = preprocessor.build()
 
     def _set_input_shape(self):
         if not self.network:
@@ -914,33 +927,28 @@ def _set_preprocess(self, preprocess):
             preprocess_steps = preprocess.ie_preprocess_steps
             if not preprocess_steps:
                 return
-            for input_name, input_info in self.network.input_info.items():
+            preprocessor = PrePostProcessor(self.network)
+            for input_name in self.inputs:
                 if input_name in self.const_inputs + self.image_info_inputs:
                     continue
+                input_id = self.input_to_index[input_name]
                 for (name, value) in preprocess_steps:
-                    setattr(input_info.preprocess_info, name, value)
-                if preprocess.ie_processor.has_normalization():
-                    channel_id = input_info.layout.find('C')
-                    if channel_id != -1:
-                        num_channels = input_info.input_data.shape[channel_id]
-                        preprocess.ie_processor.set_normalization(num_channels, input_info.preprocess_info)
-            self.disable_resize_to_input = preprocess.ie_processor.has_resize()
-            self._use_set_blob = self.disable_resize_to_input
-            self.load_network(self.network)
+                    if name == 'resize_algorithm':
+                        preprocessor.input(input_id).tensor().set_spatial_dynamic_shape()
+                        preprocessor.input(input_id).preprocess().resize(value)
+                        self.need_dyn_resolving = False
+                    if name == 'convert_color_format':
+                        src, dst = value
+                        preprocessor.input(input_id).tensor().set_color_format(src)
+                        preprocessor.input(input_id).preprocess().convert_color(dst)
+                    if name == 'mean_variant':
+                        mean, scale = value
+                        if mean is not None:
+                            preprocessor.input(input_id).preprocess().mean(mean)
+                        if scale is not None:
+                            preprocessor.input(input_id).preprocess().scale(scale)
+            self.network = preprocessor.build()
             self._preprocess_steps = preprocess_steps
-            return
-        preprocess_info_by_input = {}
-        preprocess_info = preprocess.preprocess_info
-        for input_name in self.inputs:
-            if input_name in self.const_inputs + self.image_info_inputs:
-                continue
-            if preprocess.ie_processor.has_normalization():
-                channel_id = self.inputs[input_name].layout.find('C')
-                if channel_id != -1:
-                    num_channels = self.inputs[input_name].shape[channel_id]
-                    preprocess.ie_processor.set_normalization(num_channels, preprocess_info)
-            preprocess_info_by_input[input_name] = preprocess_info
-        self._preprocess_info = preprocess_info_by_input
         self.disable_resize_to_input = preprocess.ie_processor.has_resize()
 
     def get_model_file_type(self):
@@ -958,8 +966,7 @@ def get_infer_queue(self, log=True):
             debug('Prepared async infer queue with {} requests'.format(len(queue)))
         return queue
 
-    def prepare_data_for_request(self,
-                                 inputs, batch_meta, batch_id, batch_input_ids,
+    def prepare_data_for_request(self, inputs, batch_meta, batch_id, batch_input_ids,
                                  batch_annotation, batch_identifiers):
         infer_inputs = inputs[0]
         feed_dict = {self.input_to_tensor_name[name]: data for name, data in infer_inputs.items()}