AC: remove usage MO (openvinotoolkit#3046)

* AC: remove usage MO

* fix tests

* fix tests

* minor fixes

Author: eaidova

tools/accuracy_checker/openvino/tools/accuracy_checker/argparser.py

@@ -236,45 +236,6 @@ def add_openvino_specific_args(parser):
         choices=['avx512', 'avx2', 'sse4'],
         required=False
     )
-    openvino_specific_args.add_argument(
-        '-M', '--model_optimizer',
-        help='path to model optimizer directory',
-        type=partial(get_path, is_directory=True),
-        # there is no default value because if user did not specify it we use specific locations
-        # defined in model_conversion.py
-        required=False
-    )
-    openvino_specific_args.add_argument(
-        '--tf_custom_op_config_dir',
-        help='path to directory with tensorflow custom operation configuration files for model optimizer',
-        type=partial(get_path, is_directory=True),
-        # there is no default value because if user did not specify it we use specific location
-        # defined in model_conversion.py
-        required=False
-    )
-    openvino_specific_args.add_argument(
-        '--transformations_config_dir',
-        help='path to directory with Model Optimizer transformations configuration files',
-        type=partial(get_path, is_directory=True),
-        # there is no default value because if user did not specify it we use specific location
-        # defined in model_conversion.py
-        required=False
-    )
-    openvino_specific_args.add_argument(
-        '--tf_obj_detection_api_pipeline_config_path',
-        help='path to directory with tensorflow object detection api pipeline configuration files for model optimizer',
-        type=partial(get_path, is_directory=True),
-        # there is no default value because if user did not specify it we use specific location
-        # defined in model_conversion.py
-        required=False
-    )
-    openvino_specific_args.add_argument(
-        '--deprecated_ir_v7',
-        help='allow generation IR v7 via Model Optimizer',
-        type=cast_to_bool,
-        default=False,
-        required=False
-    )
     openvino_specific_args.add_argument(
         '-dc', '--device_config',
         help='Inference Engine device specific config file',
@@ -299,13 +260,6 @@ def add_openvino_specific_args(parser):
         help='model format for automatic search (e.g. blob, xml, onnx)',
         required=False
     )
-    openvino_specific_args.add_argument(
-        '-C', '--converted_models',
-        help='directory to store Model Optimizer converted models. Used for DLSDK launcher only',
-        type=partial(get_path, is_directory=True),
-        default=Path.cwd(),
-        required=False
-    )
     openvino_specific_args.add_argument(
         '-am', '--affinity_map',
         help='prefix path to the affinity maps',

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

@@ -68,13 +68,6 @@
     'model': 'models',
     'weights': 'models',
     'color_coeff': ['model_attributes', 'models'],
-    'caffe_model': 'models',
-    'caffe_weights': 'models',
-    'tf_model': 'models',
-    'tf_meta': 'models',
-    'mxnet_weights': 'models',
-    'onnx_model': 'models',
-    'kaldi_model': 'models',
     'saved_model_dir': 'models',
     'params': 'models'
 }
@@ -90,11 +83,6 @@
 DEFINITION_ENV_VAR = 'DEFINITIONS_FILE'
 CONFIG_SHARED_PARAMETERS = []
 ACCEPTABLE_MODEL = [
-    'caffe_model', 'caffe_weights',
-    'tf_model', 'tf_meta',
-    'mxnet_weights',
-    'onnx_model',
-    'kaldi_model',
     'model',
     'saved_model_dir',
     'params'
@@ -393,9 +381,6 @@ def merge_modules(config, arguments, update_launcher_entry):
         }
 
         additional_keys = [
-            'model_optimizer', 'tf_custom_op_config_dir',
-            'tf_obj_detection_api_pipeline_config_path',
-            'transformations_config_dir',
             'cpu_extensions_mode', 'vpu_log_level'
         ]
         arguments_dict = arguments if isinstance(arguments, dict) else vars(arguments)
@@ -843,32 +828,7 @@ def get_mode(config):
     return next(iter(evaluation_keys))
 
 
-def merge_converted_model_path(converted_models_dir, mo_output_dir):
-    if mo_output_dir:
-        mo_output_dir = Path(mo_output_dir)
-        if mo_output_dir.is_absolute():
-            return mo_output_dir
-        return converted_models_dir / mo_output_dir
-    return converted_models_dir
-
-
 def merge_dlsdk_launcher_args(arguments, launcher_entry, update_launcher_entry):
-    def _convert_models_args(launcher_entry):
-        if 'deprecated_ir_v7' in arguments and arguments.deprecated_ir_v7:
-            mo_flags = launcher_entry.get('mo_flags', [])
-            mo_flags.append('generate_deprecated_IR_V7')
-            launcher_entry['mo_flags'] = mo_flags
-        if 'converted_models' in arguments and arguments.converted_models:
-            mo_params = launcher_entry.get('mo_params', {})
-            mo_params.update({
-                'output_dir': merge_converted_model_path(arguments.converted_models,
-                                                         mo_params.get('output_dir'))
-            })
-
-            launcher_entry['mo_params'] = mo_params
-
-        return launcher_entry
-
     def _async_evaluation_args(launcher_entry):
         if 'async_mode' in arguments:
             launcher_entry['async_mode'] = arguments.async_mode
@@ -888,7 +848,6 @@ def _async_evaluation_args(launcher_entry):
         return launcher_entry
 
     launcher_entry.update(update_launcher_entry)
-    _convert_models_args(launcher_entry)
     _async_evaluation_args(launcher_entry)
 
     if 'device_config' in arguments and arguments.device_config:

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

@@ -215,11 +215,7 @@ def set_input_and_output(self):
                 self.adapter.output_blob = output_blob
 
     def load_model(self, network_info, launcher, log=False):
-        if 'onnx_model' in network_info:
-            network_info.update(launcher.config)
-            model, weights = launcher.convert_model(network_info)
-        else:
-            model, weights = self.automatic_model_search(network_info)
+        model, weights = self.automatic_model_search(network_info)
         if weights is None and model.suffix != '.onnx':
             self.exec_network = launcher.ie_core.import_network(str(model))
         else:
@@ -302,11 +298,7 @@ def load_network(self, network, launcher):
             self.exec_network = launcher.ie_core.compile_model(self.network, launcher.device)
 
     def load_model(self, network_info, launcher, log=False):
-        if 'onnx_model' in network_info:
-            network_info.update(launcher.config)
-            model, weights = launcher.convert_model(network_info)
-        else:
-            model, weights = self.automatic_model_search(network_info)
+        model, weights = self.automatic_model_search(network_info)
         if weights is None and model.suffix != '.onnx':
             self.exec_network = launcher.ie_core.import_network(str(model))
         else:

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

@@ -353,37 +353,8 @@ def fit_to_input(self, data, layer_name, layout, precision, template=None):
             data = data.astype(precision)
         return data
 
-    def prepare_model(self, launcher):
-        launcher_specific_entries = [
-            'model', 'weights', 'caffe_model', 'caffe_weights', 'tf_model', 'inputs', 'outputs', '_model_optimizer'
-        ]
-
-        def update_mo_params(launcher_config, model_config):
-            for entry in launcher_specific_entries:
-                if entry not in launcher_config:
-                    continue
-                if entry in model_config:
-                    continue
-                model_config[entry] = launcher_config[entry]
-            model_mo_flags, model_mo_params = model_config.get('mo_flags', []), model_config.get('mo_params', {})
-            launcher_mo_flags, launcher_mo_params = launcher_config.get('mo_flags', []), launcher_config.get(
-                'mo_params', {})
-            for launcher_flag in launcher_mo_flags:
-                if launcher_flag not in model_mo_flags:
-                    model_mo_flags.append(launcher_flag)
-
-            for launcher_mo_key, launcher_mo_value in launcher_mo_params.items():
-                if launcher_mo_key not in model_mo_params:
-                    model_mo_params[launcher_mo_key] = launcher_mo_value
-
-            model_config['mo_flags'] = model_mo_flags
-            model_config['mo_params'] = model_mo_params
-
-        update_mo_params(launcher.config, self.model_info)
-        if 'caffe_model' in self.model_info:
-            model, weights = launcher.convert_model(self.model_info)
-        else:
-            model, weights = self.auto_model_search(self.model_info)
+    def prepare_model(self):
+        model, weights = self.auto_model_search(self.model_info)
         return model, weights
 
     def auto_model_search(self, network_info):
@@ -547,37 +518,8 @@ def fit_to_input(self, data, layer_name, layout, precision, template=None):
             data = data.astype(precision)
         return data
 
-    def prepare_model(self, launcher):
-        launcher_specific_entries = [
-            'model', 'weights', 'caffe_model', 'caffe_weights', 'tf_model', 'inputs', 'outputs', '_model_optimizer'
-        ]
-
-        def update_mo_params(launcher_config, model_config):
-            for entry in launcher_specific_entries:
-                if entry not in launcher_config:
-                    continue
-                if entry in model_config:
-                    continue
-                model_config[entry] = launcher_config[entry]
-            model_mo_flags, model_mo_params = model_config.get('mo_flags', []), model_config.get('mo_params', {})
-            launcher_mo_flags, launcher_mo_params = launcher_config.get('mo_flags', []), launcher_config.get(
-                'mo_params', {})
-            for launcher_flag in launcher_mo_flags:
-                if launcher_flag not in model_mo_flags:
-                    model_mo_flags.append(launcher_flag)
-
-            for launcher_mo_key, launcher_mo_value in launcher_mo_params.items():
-                if launcher_mo_key not in model_mo_params:
-                    model_mo_params[launcher_mo_key] = launcher_mo_value
-
-            model_config['mo_flags'] = model_mo_flags
-            model_config['mo_params'] = model_mo_params
-
-        update_mo_params(launcher.config, self.model_info)
-        if 'caffe_model' in self.model_info:
-            model, weights = launcher.convert_model(self.model_info)
-        else:
-            model, weights = self.auto_model_search(self.model_info)
+    def prepare_model(self):
+        model, weights = self.auto_model_search(self.model_info)
         return model, weights
 
     def auto_model_search(self, network_info):
@@ -707,7 +649,7 @@ def __init__(
         self.adapter = None
         self.is_dynamic = False
         if not delayed_model_loading:
-            model_xml, model_bin = self.prepare_model(launcher)
+            model_xml, model_bin = self.prepare_model()
             self.load_model({'model': model_xml, 'weights': model_bin}, launcher, 'pnet_', log=True)
             pnet_outs = model_info['outputs']
             pnet_adapter_config = launcher.config.get('adapter', {'type': 'mtcnn_p', **pnet_outs})
@@ -758,7 +700,7 @@ def __init__(
         self.adapter = None
         self.is_dynamic = False
         if not delayed_model_loading:
-            model_xml, model_bin = self.prepare_model(launcher)
+            model_xml, model_bin = self.prepare_model()
             self.load_model({'model': model_xml, 'weights': model_bin}, launcher, 'pnet_', log=True)
             pnet_outs = model_info['outputs']
             pnet_adapter_config = launcher.config.get('adapter', {'type': 'mtcnn_p', **pnet_outs})
@@ -810,7 +752,7 @@ def __init__(
         self.is_dynamic = False
         self.launcher = launcher
         if not delayed_model_loading:
-            model_xml, model_bin = self.prepare_model(launcher)
+            model_xml, model_bin = self.prepare_model()
             self.load_model({'model': model_xml, 'weights': model_bin}, launcher, 'rnet_', log=True)
 
     def predict(self, input_blobs, batch_meta, output_callback=None):
@@ -829,7 +771,7 @@ def __init__(
         self.is_dynamic = False
         self.launcher = launcher
         if not delayed_model_loading:
-            model_xml, model_bin = self.prepare_model(launcher)
+            model_xml, model_bin = self.prepare_model()
             self.load_model({'model': model_xml, 'weights': model_bin}, launcher, 'rnet_', log=True)
 
     def predict(self, input_blobs, batch_meta, output_callback=None):
@@ -848,7 +790,7 @@ def __init__(
         self.is_dynamic = False
         self.launcher = launcher
         if not delayed_model_loading:
-            model_xml, model_bin = self.prepare_model(launcher)
+            model_xml, model_bin = self.prepare_model()
             self.load_model({'model': model_xml, 'weights': model_bin}, launcher, 'onet_', log=True)
 
     def predict(self, input_blobs, batch_meta, output_callback=None):
@@ -865,7 +807,7 @@ def __init__(
         self.is_dynamic = False
         self.launcher = launcher
         if not delayed_model_loading:
-            model_xml, model_bin = self.prepare_model(launcher)
+            model_xml, model_bin = self.prepare_model()
             self.load_model({'model': model_xml, 'weights': model_bin}, launcher, 'onet_', log=True)
 
     def predict(self, input_blobs, batch_meta, output_callback=None):

tools/accuracy_checker/openvino/tools/accuracy_checker/launcher/dlsdk_launcher.py

@@ -24,7 +24,7 @@
 
 from .dlsdk_launcher_config import (
     HETERO_KEYWORD, MULTI_DEVICE_KEYWORD, NIREQ_REGEX, VPU_PLUGINS,
-    get_cpu_extension, mo_convert_model,
+    get_cpu_extension,
     DLSDK_LAUNCHER_PARAMETERS,
     DLSDKLauncherConfigValidator,
     automatic_model_search
@@ -110,16 +110,11 @@ def __init__(self, config_entry, model_name='', delayed_model_loading=False,
         self.preprocessor = preprocessor
 
         if not delayed_model_loading:
-            if dlsdk_launcher_config.need_conversion:
-                self._model, self._weights = mo_convert_model(
-                    self.config, self.parameters(), dlsdk_launcher_config.framework
-                )
-            else:
-                self._model, self._weights = automatic_model_search(
-                    self._model_name, self.get_value_from_config('model'),
-                    self.get_value_from_config('weights'),
-                    self.get_value_from_config('_model_type')
-                )
+            self._model, self._weights = automatic_model_search(
+                self._model_name, self.get_value_from_config('model'),
+                self.get_value_from_config('weights'),
+                self.get_value_from_config('_model_type')
+            )
             self.load_network(log=True, preprocessing=preprocessor)
             self.allow_reshape_input = self.get_value_from_config('allow_reshape_input') and self.network is not None
         else: