AC: handle port name in sequence inference (#3018)

* AC: handle port name in sequence inference

* reshape using indexes

* input output info better logging

Author: eaidova

tools/accuracy_checker/openvino/tools/accuracy_checker/adapters/adapter.py

@@ -16,7 +16,7 @@
 
 from ..config import BaseField, ConfigValidator, StringField, ConfigError
 from ..dependency import ClassProvider, UnregisteredProviderException
-from ..utils import get_parameter_value_from_config
+from ..utils import get_parameter_value_from_config, postprocess_output_name
 
 
 class Adapter(ClassProvider):
@@ -53,18 +53,7 @@ def configure(self):
 
     @staticmethod
     def check_output_name(output_name, outputs, suffix=('/sink_port_0', ':0')):
-        suffixes = [suffix] if isinstance(suffix, str) else suffix
-        outputs = outputs[0] if isinstance(outputs, list) else outputs
-        if output_name in outputs:
-            return output_name
-        for suffix_ in suffixes:
-            if suffix_ in output_name:
-                preprocessed_output_name = output_name.replace(suffix_, '')
-            else:
-                preprocessed_output_name = '{}{}'.format(output_name, suffix_)
-            if preprocessed_output_name in outputs:
-                return preprocessed_output_name
-        return output_name
+        return postprocess_output_name(output_name, outputs, suffix, raise_error=False)
 
     @classmethod
     def validate_config(cls, config, fetch_only=False, uri_prefix='', **kwargs):
@@ -121,6 +110,7 @@ def reset(self):
     def release(self):
         pass
 
+
 class AdapterField(BaseField):
     def validate(self, entry, field_uri=None, fetch_only=False, validation_scheme=None):
         errors_stack = super().validate(entry, field_uri, fetch_only, validation_scheme)

tools/accuracy_checker/openvino/tools/accuracy_checker/evaluators/custom_evaluators/base_models.py

@@ -262,14 +262,18 @@ def input_tensors_mapping(self):
 
         return node_to_tensor
 
+    def input_index_mapping(self):
+        inputs = self.network.inputs if self.network is not None else self.exec_network.inputs
+        return {inp.get_node().friendly_name: idx for idx, inp in enumerate(inputs)}
+
     def _reshape_input(self, input_shapes):
         if self.is_dynamic:
             return
         if hasattr(self, 'exec_network') and self.exec_network is not None:
             del self.infer_request
             del self.exec_network
-        tensor_mapping = self.input_tensors_mapping()
-        input_shapes_for_tensors = {tensor_mapping[name]: shape for name, shape in input_shapes.items()}
+        index_mapping = self.input_index_mapping()
+        input_shapes_for_tensors = {index_mapping[name]: shape for name, shape in input_shapes.items()}
         self.launcher.reshape_network(self.network, input_shapes_for_tensors)
         self.dynamic_inputs, self.partial_shapes = self.launcher.get_dynamic_inputs(self.network)
         if not self.is_dynamic and self.dynamic_inputs:

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

@@ -38,6 +38,7 @@
     string_to_tuple,
     get_or_parse_value,
     parse_partial_shape,
+    postprocess_output_name
 )
 from .launcher import Launcher
 from ..logging import print_info
@@ -330,7 +331,7 @@ def _reshape_input(self, shapes, make_dynamic=False):
             p_shape = PartialShape(
                 [Dimension(d) if not isinstance(d, tuple) else Dimension(d[0], d[1]) for d in shape]
             )
-            partial_shapes[self.input_to_tensor_name[name]] = p_shape
+            partial_shapes[self.input_to_index[name]] = p_shape
 
         self.network.reshape(partial_shapes)
         self.dyn_input_layers, self._partial_shapes = self.get_dynamic_inputs(self.network)
@@ -548,6 +549,7 @@ def load_network(self, network=None, log=False, preprocessing=None):
         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)}
 
         if not self._postpone_input_configuration:
             self._set_precision()
@@ -813,8 +815,8 @@ def _fill_lstm_inputs(self, infer_outputs=None):
         feed_dict = {}
         for lstm_var, output_layer in self._lstm_inputs.items():
             layer_shape = parse_partial_shape(self.inputs[lstm_var].partial_shape)
-            if infer_outputs and output_layer not in infer_outputs:
-                raise ConfigError('Output node with name {} not found'.format(output_layer))
+            if infer_outputs:
+                output_layer = postprocess_output_name(output_layer, infer_outputs)
             input_data = infer_outputs[output_layer].reshape(layer_shape) if infer_outputs else np.zeros(
                 layer_shape, dtype=format_map[self.inputs[lstm_var].element_type.get_type_name()]
             )
@@ -831,13 +833,15 @@ def print_input_output_info(network, prefix=None):
         network_outputs = network.outputs
         for input_info in network_inputs:
             input_node = input_info.get_node()
-            print_info('\tLayer name: {}'.format(input_node.friendly_name))
+            print_info('\tNode name: {}'.format(input_node.friendly_name))
+            print_info('\tTensor names: {}'.format(', '.join(input_info.get_names())))
             print_info('\tprecision: {}'.format(input_node.element_type.get_type_name()))
             print_info('\tshape: {}\n'.format(parse_partial_shape(input_node.get_partial_shape())))
         print_info('Output info')
         for output_info in network_outputs:
             out_node = output_info.get_node()
-            print_info('\tLayer name: {}'.format(out_node.friendly_name))
+            print_info('\tNode name: {}'.format(out_node.friendly_name))
+            print_info('\tTensor names: {}'.format(', '.join(output_info.get_names())))
             precision = out_node.get_output_element_type(0).get_type_name()
             print_info('\tprecision: {}'.format(precision))
             shape = parse_partial_shape(out_node.get_output_partial_shape(0))

tools/accuracy_checker/openvino/tools/accuracy_checker/utils.py

@@ -975,3 +975,20 @@ def parse_partial_shape(partial_shape):
         shape_list.append(string_to_tuple(shape_range, casting_type=int))
         s_pos = min(close_brace + 2, e_pos)
     return shape_list
+
+
+def postprocess_output_name(output_name, outputs, suffix=('/sink_port_0', ':0'), raise_error=True):
+    suffixes = [suffix] if isinstance(suffix, str) else suffix
+    outputs = outputs[0] if isinstance(outputs, list) else outputs
+    if output_name in outputs:
+        return output_name
+    for suffix_ in suffixes:
+        if suffix_ in output_name:
+            preprocessed_output_name = output_name.replace(suffix_, '')
+        else:
+            preprocessed_output_name = '{}{}'.format(output_name, suffix_)
+        if preprocessed_output_name in outputs:
+            return preprocessed_output_name
+    if raise_error:
+        raise ValueError('Output name: {} not found'.format(output_name))
+    return output_name