AC: fix batch size settings (#3096)

* AC: fix batch size settings

* update condition for updateting input config{

* fix printing input info twice, update layout for dice

Author: eaidova

tools/accuracy_checker/openvino/tools/accuracy_checker/evaluators/model_evaluator.py

@@ -98,7 +98,7 @@ def from_configs(cls, model_config, delayed_annotation_loading=False):
             input_layouts
         )
         if not postpone_model_loading:
-            if input_precision:
+            if input_precision or input_layouts:
                 launcher.update_input_configuration(input_feeder.inputs_config)
             input_feeder.update_layout_configuration(launcher.layout_mapping)
             preprocessor.input_shapes = launcher.inputs_info_for_meta()

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

@@ -125,9 +125,10 @@ def __init__(self, config_entry, model_name='', delayed_model_loading=False,
                     self.get_value_from_config('weights'),
                     self.get_value_from_config('_model_type')
             )
-            self.load_network(log=True, preprocessing=preprocessor)
+            self.load_network(log=postpone_inputs_configuration, preprocessing=preprocessor)
             self.allow_reshape_input = self.get_value_from_config('allow_reshape_input') and self.network is not None
-            self.try_to_set_default_layout()
+            if postpone_inputs_configuration:
+                self.try_to_set_default_layout()
         else:
             self.allow_reshape_input = self.get_value_from_config('allow_reshape_input')
         self._target_layout_mapping = {}
@@ -511,19 +512,15 @@ def _create_network(self, input_shapes=None):
             self.network = None
             self.exec_network = self.ie_core.import_model(str(self._model), self._device)
             self.original_outputs = self.exec_network.outputs
-            ie_input_info = self.exec_network.inputs
-            input_info = ie_input_info[0]
-            batch_pos = (
-                input_info.get_node().layout.get_index_by_name('N')
-                if input_info.get_node().layout.has_name('N') else -1
-            )
-
-            self._batch = parse_partial_shape(input_info.partial_shape)[batch_pos] if batch_pos != -1 else 1
+            model_batch = self._get_model_batch_size()
+            self._batch = model_batch if model_batch is not None else 1
             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
+        model_batch = self._get_model_batch_size()
+        model_batch = 1 if model_batch is None else model_batch
         outputs = self.config.get('outputs')
         if outputs:
             def output_preprocessing(output_string):
@@ -536,13 +533,53 @@ def output_preprocessing(output_string):
             self.network.add_outputs(preprocessed_outputs)
         if input_shapes is not None:
             self.network.reshape(input_shapes)
-        self._batch = self.config.get('batch', 1)
+        self._batch = self.config.get('batch', model_batch)
+        self._set_batch_size(self._batch)
         affinity_map_path = self.config.get('affinity_map')
         if affinity_map_path and self._is_hetero():
             self._set_affinity(affinity_map_path)
         elif affinity_map_path:
             warning('affinity_map config is applicable only for HETERO device')
 
+    def _set_batch_size(self, batch_size):
+        model_batch_size = self._get_model_batch_size()
+        model_batch_size = 1 if model_batch_size is None else model_batch_size
+        if batch_size is None:
+            batch_size = model_batch_size
+        if batch_size == model_batch_size:
+            self._batch = batch_size
+            return
+        input_shapes = {}
+        for input_node in self.network.inputs:
+            layer_name = input_node.get_node().friendly_name
+            if layer_name in self.const_inputs:
+                input_shapes[layer_name] = parse_partial_shape(layer_name.partial_shape)
+            else:
+                layer_shape = parse_partial_shape(layer_name.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(',', '')
+                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 _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(',', '')
+        batch_pos = layout.find('N')
+        if batch_pos != -1:
+            return parse_partial_shape(input_info.partial_shape)[batch_pos]
+        return None
+
     def load_network(self, network=None, log=False, preprocessing=None):
         if hasattr(self, 'exec_network'):
             del self.exec_network
@@ -573,6 +610,7 @@ def update_input_configuration(self, input_config):
         self._set_precision()
         self._set_input_shape()
         self.try_to_set_default_layout()
+        self._set_batch_size(self.config.get('batch'))
         self.dyn_input_layers, self._partial_shapes = self.get_dynamic_inputs(self.network)
         self.print_input_output_info(self.network if self.network is not None else self.exec_network)
         if self.preprocessor:

tools/accuracy_checker/openvino/tools/accuracy_checker/metrics/semantic_segmentation.py

@@ -247,7 +247,8 @@ class SegmentationDSCAcc(PerImageEvaluationMetric):
     def update(self, annotation, prediction):
         result = []
         for prediction_mask, annotation_mask in zip(prediction.mask, annotation.mask):
-            annotation_mask = np.transpose(annotation_mask, (2, 0, 1))
+            if annotation_mask.shape[0] != prediction_mask.shape[1]:
+                annotation_mask = np.transpose(annotation_mask, (2, 0, 1))
             annotation_mask = np.expand_dims(annotation_mask, 0)
             numerator = np.sum(prediction_mask * annotation_mask) * 2.0 + 1.0
             denominator = np.sum(annotation_mask) + np.sum(prediction_mask) + 1.0