AC: port important bugfix for 2022/1 (#3404)

Author: eaidova

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

@@ -15,6 +15,7 @@
 """
 #pylint:disable=no-name-in-module
 #pylint:disable=package-absolute-imports
+import io
 import multiprocessing
 from pathlib import Path
 import re
@@ -45,28 +46,15 @@
 
 
 format_map = {
-      'f32': np.float32,
-      'i32': np.int32,
-      'i64': np.int64,
-      'fp16': np.float16,
-      'f16': np.float16,
-      'i16': np.int16,
-      'u16': np.uint16,
-      'i8': np.int8,
-      'u8': np.uint8,
+      'f32': np.float32, 'i32': np.int32, 'i64': np.int64,
+      'fp16': np.float16, 'f16': np.float16, 'i16': np.int16, 'u16': np.uint16,
+      'i8': np.int8, 'u8': np.uint8,
       'boolean': np.uint8
 }
 
 PRECISION_STR_TO_TYPE = {
-    'FP32': Type.f32,
-    'FP16': Type.f16,
-    'U8': Type.u8,
-    'U16': Type.u16,
-    'I8': Type.i8,
-    'I16': Type.i16,
-    'I32': Type.i32,
-    'I64': Type.i64,
-    'BOOL': Type.boolean
+    'FP32': Type.f32, 'FP16': Type.f16, 'U8': Type.u8, 'U16': Type.u16, 'I8': Type.i8, 'I16': Type.i16,
+    'I32': Type.i32, 'I64': Type.i64, 'BOOL': Type.boolean
 }
 
 
@@ -461,8 +449,7 @@ def _prepare_multi_device(self, log=True):
             if 'num_requests' in self.config:
                 warning(
                     "number requests already provided in device name specification. "
-                    "'num_requests' option will be ignored."
-                )
+                    "'num_requests' option will be ignored.")
         elif 'num_requests' in self.config and self.config['num_requests'] != 'AUTO':
             num_per_device_requests = get_or_parse_value(self.config['num_request'], casting_type=int)
         else:
@@ -502,15 +489,15 @@ def _log_versions(self):
         for device_name, device_version in versions.items():
             print_info("    {device_name} - {descr}: {maj}.{min}.{num}".format(
                 device_name=device_name, descr=device_version.description, maj=device_version.major,
-                min=device_version.minor, num=device_version.build_number
-            ))
+                min=device_version.minor, num=device_version.build_number))
 
     def _create_network(self, input_shapes=None):
         model_path = Path(self._model)
         compiled_model = model_path.suffix == '.blob'
         if compiled_model:
             self.network = None
-            self.exec_network = self.ie_core.import_model(str(self._model), self._device)
+            with open(str(self._model), 'rb') as f: #pylint:disable=unspecified-encoding
+                self.exec_network = self.ie_core.import_model(io.BytesIO(f), 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
@@ -560,26 +547,29 @@ def _set_batch_size(self, batch_size):
             if layer_name in self.const_inputs:
                 input_shapes[layer_name] = parse_partial_shape(input_node.get_node().partial_shape)
             else:
-                layer_shape = parse_partial_shape(input_node.get_node().partial_shape)
-                layout = self.inputs[layer_name].layout
-                if '...' in str(layout):
-                    layout = self.get_layout_from_config(layer_name)
-                else:
-                    layout = str(layout).replace('[', '').replace(']', '').replace(',', '')
+                layer_shape = list(parse_partial_shape(input_node.get_node().partial_shape))
+                layout = self._process_layout(self.inputs[layer_name].layout, layer_name)
                 batch_pos = layout.find('N')
                 if batch_pos != -1:
                     layer_shape[batch_pos] = batch_size
                 input_shapes[layer_name] = layer_shape
         self._reshape_input(input_shapes, batch_size == -1)
         self._batch = batch_size
 
+    def _process_layout(self, ov_layout, layer_name):
+        if '...' in str(ov_layout) or ov_layout is None:
+            ov_layout = self.get_layout_from_config(layer_name)
+        else:
+            ov_layout = str(ov_layout).replace('[', '').replace(']', '').replace(',', '')
+        return ov_layout
+
     def _get_model_batch_size(self):
         input_nodes = self.network.inputs if self.network else self.exec_network.inputs
         input_info = input_nodes[0]
-        if '...' in str(input_info.get_node().layout):
-            layout = self.get_layout_from_config(input_info.get_node().friendly_name)
-        else:
-            layout = str(input_info.get_node().layout).replace('[', '').replace(']', '').replace(',', '')
+        layout = (
+            self._process_layout(input_info.get_node().layout, input_info.get_node().friendly_name)
+            or self.default_layout
+        )
         batch_pos = layout.find('N')
         if batch_pos != -1:
             return parse_partial_shape(input_info.partial_shape)[batch_pos]
@@ -599,7 +589,6 @@ def load_network(self, network=None, log=False, preprocessing=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)}
-
         if not self._postpone_input_configuration:
             self._set_precision()
             self._set_input_shape()
@@ -674,7 +663,7 @@ def dyn_batch_only(self):
                 if num_undef > 1:
                     return False
             layout = self.inputs[input_name].layout
-            if '...' in str(layout):
+            if '...' in str(layout) or layout is None:
                 layout = self.get_layout_from_config(input_name)
             else:
                 layout = str(layout).replace('[', '').replace(']', '').replace(',', '')
@@ -715,6 +704,8 @@ def read_network(self, model, weights):
             network = self.ie_core.read_model(model=str(model), weights=str(weights))
         else:
             network = self.ie_core.read_model(model=str(model))
+        self.input_to_tensor_name = self.get_input_tensor_name_mapping(network)
+        self.input_to_index = {inp.get_node().friendly_name: idx for idx, inp in enumerate(network.inputs)}
         return network
 
     def inputs_info_for_meta(self, inputs=None):
@@ -851,8 +842,7 @@ def _set_precision(self):
             if 'precision' in input_config:
                 if self.network:
                     self.inputs[input_config['name']].set_element_type(
-                        PRECISION_STR_TO_TYPE[input_config['precision'].upper()]
-                    )
+                        PRECISION_STR_TO_TYPE[input_config['precision'].upper()])
 
     def _set_input_shape(self):
         if not self.network: