Fixed background_matting_evaluator in case quantization (#3296)

Author: Anna Grebneva

models/public/robust-video-matting-mobilenetv3/accuracy-check.yml

@@ -2,7 +2,8 @@ evaluations:
   - name: robust-video-matting-mobilenetv3
     module: custom_evaluators.sequential_background_matting_evaluator.SequentialBackgroundMatting
     module_config:
-
+      network_info:
+        background_matting_model: {}
       launchers:
         - framework: openvino
           adapter:

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

@@ -25,12 +25,10 @@
 
 
 class SequentialBackgroundMatting(BaseCustomEvaluator):
-    def __init__(self, dataset_config, launcher, model, input_feeder, adapter, orig_config):
+    def __init__(self, dataset_config, launcher, model, adapter, orig_config):
         super().__init__(dataset_config, launcher, orig_config)
         self.model = model
-        self.input_feeder = input_feeder
         self.adapter = adapter
-        self.inputs = input_feeder.network_inputs
 
     def _process(self, output_callback, calculate_metrics, progress_reporter, metric_config, csv_file):
         previous_video_id = None
@@ -42,10 +40,10 @@ def _process(self, output_callback, calculate_metrics, progress_reporter, metric
             filled_inputs = self.input_feeder.fill_inputs(batch_inputs)
             for i, filled_input in enumerate(filled_inputs):
                 filled_input.update(rnn_inputs[i])
-            batch_raw_results = self.model.predict(batch_identifiers, filled_inputs)
-            batch_predictions = self.adapter.process(batch_raw_results, batch_identifiers, batch_meta)
+            batch_raw_results, batch_results = self.model.predict(batch_identifiers, filled_inputs)
+            batch_predictions = self.adapter.process(batch_results, batch_identifiers, batch_meta)
             previous_video_id = batch_annotation[0].video_id
-            rnn_inputs = self.model.set_rnn_inputs(batch_raw_results)
+            rnn_inputs = self.model.set_rnn_inputs(batch_results)
             annotation, prediction = self.postprocessor.process_batch(batch_annotation, batch_predictions)
             metrics_result = self._get_metrics_result(batch_input_ids, annotation, prediction, calculate_metrics)
             if output_callback:
@@ -60,21 +58,16 @@ def from_configs(cls, config, delayed_model_loading=False, orig_config=None):
             config.get('network_info', {}), launcher, config.get('_models', []), config.get('_model_is_blob'),
             delayed_model_loading
         )
-        launcher.network = model.model.network
-        launcher_config = config['launchers'][0]
-        postpone_model_loading = False
-        input_precision = launcher_config.get('_input_precision', [])
-        input_layouts = launcher_config.get('_input_layout', '')
-        input_feeder = InputFeeder(
-            launcher.config.get('inputs', []), model.model.launcher.inputs, cls.input_shape, launcher.fit_to_input,
-            launcher.default_layout, launcher_config['framework'] == 'dummy' or postpone_model_loading, input_precision,
-            input_layouts
-        )
-        adapter = create_adapter(launcher_config.get('adapter', 'background_matting_with_pha_and_fgr'))
-        return cls(dataset_config, launcher, model, input_feeder, adapter, orig_config)
+        adapter = create_adapter(config['launchers'][0].get('adapter', 'background_matting_with_pha_and_fgr'))
+        return cls(dataset_config, launcher, model, adapter, orig_config)
 
-    def input_shape(self, input_name):
-        return self.inputs[input_name]
+    @property
+    def input_feeder(self):
+        return self.model.model.input_feeder
+
+    @property
+    def inputs(self):
+        return self.input_feeder.network_inputs
 
 
 class SequentialBackgroundMattingModel(BaseCascadeModel):
@@ -99,10 +92,12 @@ def __init__(self, network_info, launcher, models_args, is_blob, delayed_model_l
 
     def predict(self, identifiers, input_data):
         batch_raw_results = []
+        batch_results = []
         for identifier, data in zip(identifiers, input_data):
-            raw_results = self.model.predict(identifier, data)
+            results, raw_results = self.model.predict(identifier, data)
             batch_raw_results.append(raw_results)
-        return batch_raw_results
+            batch_results.append(results)
+        return batch_raw_results, batch_results
 
     def reset_rnn_inputs(self, batch_size):
         output = []
@@ -129,9 +124,34 @@ def set_rnn_inputs(self, outputs):
 
 class DLSDKSequentialBackgroundMattingModel(BaseDLSDKModel):
     def predict(self, identifiers, input_data):
-        return self.exec_network.infer(input_data)
+        outputs = self.exec_network.infer(input_data)
+        if isinstance(outputs, tuple):
+            outputs, raw_outputs = outputs
+        else:
+            raw_outputs = outputs
+        return outputs, raw_outputs
+
+    def input_shape(self, input_name):
+        return self.launcher.inputs[input_name]
+
+    def load_network(self, network, launcher):
+        super().load_network(network, launcher)
+        self.launcher = launcher
+        self.launcher.network = self.network
+        self.input_feeder = InputFeeder(self.launcher.config.get('inputs', []), self.launcher.inputs, self.input_shape,
+                                        self.launcher.fit_to_input, self.launcher.default_layout)
 
 
 class OpenVINOModelSequentialBackgroundMattingModel(BaseOpenVINOModel):
     def predict(self, identifiers, input_data):
-        return self.infer(input_data)
+        return self.infer(input_data, raw_results=True)
+
+    def input_shape(self, input_name):
+        return self.launcher.inputs[input_name]
+
+    def load_network(self, network, launcher):
+        super().load_network(network, launcher)
+        self.launcher = launcher
+        self.launcher.network = self.network
+        self.input_feeder = InputFeeder(self.launcher.config.get('inputs', []), self.launcher.inputs, self.input_shape,
+                                        self.launcher.fit_to_input, self.launcher.default_layout)