AC: fix input data providing for tensor (#2941)

* AC: fix input data providing for tensor

* handle tensor names for tf

Author: eaidova

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

@@ -52,16 +52,18 @@ def configure(self):
         pass
 
     @staticmethod
-    def check_output_name(output_name, outputs, suffix='/sink_port_0'):
+    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
-        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
+        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
 
     @classmethod

tools/accuracy_checker/openvino/tools/accuracy_checker/config/config_reader.py

@@ -793,7 +793,7 @@ def merge_entry_paths(keys, value, args, value_id=0):
             selected_argument = select_arg_path(args[arg_candidate], value_id, argument)
             prefix_path = selected_argument
             if not selected_argument.is_dir():
-                if argument in ALLOW_FILE_OR_DIR:
+                if arg_candidate in ALLOW_FILE_OR_DIR:
                     prefix_path = selected_argument.parent
                 else:
                     raise ConfigError('argument: {} should be a directory'.format(argument))

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

@@ -43,7 +43,6 @@
 )
 from .launcher import Launcher
 from ..logging import print_info
-from .input_feeder import PRECISION_TO_DTYPE
 
 
 format_map = {
@@ -193,11 +192,14 @@ def predict(self, inputs, metadata=None, **kwargs):
         results = []
         for infer_inputs in inputs:
             if self._do_reshape:
-                input_shapes = {layer_name: data.shape for layer_name, data in infer_inputs.items()}
+                input_shapes = {
+                    layer_name: data.shape for layer_name, data in infer_inputs.items()
+                }
                 self._reshape_input(input_shapes)
             if self.infer_request is None:
                 self.infer_request = self.exec_network.create_infer_request()
-            outputs = self.infer_request.infer(inputs=infer_inputs)
+            feed_dict = {self.input_to_tensor_name[layer_name]: data for layer_name, data in infer_inputs.items()}
+            outputs = self.infer_request.infer(inputs=feed_dict)
             results.append({
                 out_node.get_node().friendly_name: out_res
                 for out_node, out_res in zip(self.exec_network.outputs, outputs)
@@ -214,10 +216,13 @@ def predict(self, inputs, metadata=None, **kwargs):
 
     def _predict_sequential(self, inputs, metadata=None, **kwargs):
         lstm_inputs_feed = self._fill_lstm_inputs()
+        if not self.infer_request:
+            self.infer_request = self.exec_network.create_infer_request()
         results = []
         for feed_dict in inputs:
             feed_dict.update(lstm_inputs_feed)
-            out_tensors = self.exec_network.infer_new_request(feed_dict)
+            infer_inputs = {self.input_to_tensor_name[layer_name]: data for layer_name, data in feed_dict.items()}
+            out_tensors = self.infer_request.infer(infer_inputs)
             output_result = {
                 out_node.get_node().friendly_name: out_tensor
                 for out_node, out_tensor in zip(self.exec_network.outputs, out_tensors)
@@ -236,9 +241,10 @@ def _predict_sequential(self, inputs, metadata=None, **kwargs):
 
     def predict_async(self, ir, inputs, metadata=None, context=None, **kwargs):
         infer_inputs = inputs[0]
+        feed_dict = {self.input_to_tensor_name[name]: data for name, data in infer_inputs.items()}
         if metadata is not None:
             self._fill_meta(metadata)
-        ir.infer(infer_inputs, metadata, context)
+        ir.infer(feed_dict, metadata, context)
 
     def _fill_meta(self, metadata):
         for meta_ in metadata:
@@ -319,7 +325,7 @@ def _reshape_input(self, shapes, make_dynamic=False):
             del self.exec_network
         if self.infer_request is not None:
             self.infer_request = None
-        self.network.reshape({k: PartialShape(shape) for k, shape in shapes.items()})
+        self.network.reshape({self.input_to_tensor_name[k]: PartialShape(shape) for k, shape in shapes.items()})
         self.dyn_input_layers, self._partial_shapes = self.get_dynamic_inputs(self.network)
         if self.dyn_input_layers and make_dynamic:
             return
@@ -523,6 +529,7 @@ 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)
 
         if not self._postpone_input_configuration:
             self._set_precision()
@@ -572,6 +579,13 @@ def is_dynamic(data_info):
 
         return inputs_with_undefined_shapes, partial_shapes
 
+    @staticmethod
+    def get_input_tensor_name_mapping(network):
+        inputs_mapping = {}
+        for input_node in network.inputs:
+            inputs_mapping[input_node.get_node().friendly_name] = input_node.get_tensor().get_any_name()
+        return inputs_mapping
+
     @property
     def dyn_batch_only(self):
         if not self.dyn_input_layers:
@@ -772,9 +786,11 @@ def _configure_lstm_inputs(self):
     def _fill_lstm_inputs(self, infer_outputs=None):
         feed_dict = {}
         for lstm_var, output_layer in self._lstm_inputs.items():
-            layer_shape = self.inputs[lstm_var].shape
+            layer_shape = parse_partial_shape(self.inputs[lstm_var].partial_shape)
+            if infer_outputs and output_layer not in infer_outputs:
+                raise 'Output node with name {} not found'.format(output_layer)
             input_data = infer_outputs[output_layer].reshape(layer_shape) if infer_outputs else np.zeros(
-                layer_shape, dtype=PRECISION_TO_DTYPE[self.inputs[lstm_var].precision]
+                layer_shape, dtype=format_map[self.inputs[lstm_var].element_type.get_type_name()]
             )
             feed_dict[lstm_var] = input_data
         return feed_dict
@@ -856,10 +872,11 @@ 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()}
         if batch_meta is not None:
             self._fill_meta(batch_meta)
         context = (batch_id, batch_input_ids, batch_annotation, batch_identifiers, batch_meta)
-        return infer_inputs, context
+        return feed_dict, context
 
     def get_result_from_request(self, request):
         return [{