def main(cli_parser: argparse.ArgumentParser, fem: FrontEndManager, framework: str): telemetry = tm.Telemetry(tid=get_tid(), app_name='Model Optimizer', app_version=get_simplified_mo_version()) telemetry.start_session('mo') telemetry.send_event('mo', 'version', get_simplified_mo_version()) try: # Initialize logger with 'ERROR' as default level to be able to form nice messages # before arg parser deliver log_level requested by user init_logger('ERROR', False) argv = cli_parser.parse_args() send_params_info(argv, cli_parser) if framework: argv.framework = framework argv.feManager = fem ov_update_message = None if not hasattr(argv, 'silent') or not argv.silent: ov_update_message = get_ov_update_message() ret_code = driver(argv) if ov_update_message: print(ov_update_message) telemetry.send_event('mo', 'conversion_result', 'success') telemetry.end_session('mo') telemetry.force_shutdown(1.0) return ret_code except (FileNotFoundError, NotADirectoryError) as e: log.error('File {} was not found'.format( str(e).split('No such file or directory:')[1])) log.debug(traceback.format_exc()) except Error as err: analysis_results = AnalysisResults() if analysis_results.get_messages() is not None: for el in analysis_results.get_messages(): log.error(el, extra={'analysis_info': True}) log.error(err) log.debug(traceback.format_exc()) except FrameworkError as err: log.error(err, extra={'framework_error': True}) log.debug(traceback.format_exc()) except Exception as err: log.error("-------------------------------------------------") log.error("----------------- INTERNAL ERROR ----------------") log.error("Unexpected exception happened.") log.error( "Please contact Model Optimizer developers and forward the following information:" ) log.error(str(err)) log.error(traceback.format_exc()) log.error("---------------- END OF BUG REPORT --------------") log.error("-------------------------------------------------") telemetry.send_event('mo', 'conversion_result', 'fail') telemetry.end_session('mo') telemetry.force_shutdown(1.0) return 1
def import_core_modules(silent: bool, path_to_module: str): """ This function checks that OpenVINO Python API is available and necessary python modules exists. So the next list of imports must contain all IE/NG Python API imports that are used inside MO. :param silent: enables or disables logs printing to stdout :param path_to_module: path where python API modules were found :return: True if all imports were successful and False otherwise """ try: from openvino.offline_transformations import apply_moc_transformations, apply_moc_legacy_transformations,\ apply_low_latency_transformation # pylint: disable=import-error,no-name-in-module from openvino.offline_transformations import apply_make_stateful_transformation, generate_mapping_file # pylint: disable=import-error,no-name-in-module from openvino.offline_transformations import generate_mapping_file, apply_make_stateful_transformation, serialize # pylint: disable=import-error,no-name-in-module from openvino.runtime import Model, get_version # pylint: disable=import-error,no-name-in-module from openvino.runtime.op import Parameter # pylint: disable=import-error,no-name-in-module from openvino.runtime import PartialShape, Dimension # pylint: disable=import-error,no-name-in-module from openvino.frontend import FrontEndManager, FrontEnd # pylint: disable=no-name-in-module,import-error import openvino.frontend # pylint: disable=import-error,no-name-in-module if silent: return True ie_version = str(get_version()) mo_version = str(v.get_version()) # pylint: disable=no-member,no-name-in-module print("{}: \t{}".format("OpenVINO runtime found in", os.path.dirname(openvino.__file__))) print("{}: \t{}".format("OpenVINO runtime version", ie_version)) print("{}: \t{}".format("Model Optimizer version", mo_version)) versions_mismatch = False mo_hash = v.extract_hash_from_version(mo_version) ie_hash = v.extract_hash_from_version(ie_version) if mo_hash is not None and ie_hash is not None: min_length = min(len(mo_hash), len(ie_hash)) mo_hash = mo_hash[:min_length] ie_hash = ie_hash[:min_length] if mo_hash != ie_hash or mo_hash is None or ie_hash is None: versions_mismatch = True extracted_mo_release_version = v.extract_release_version( mo_version) mo_is_custom = extracted_mo_release_version == (None, None) print( "[ WARNING ] Model Optimizer and OpenVINO runtime versions do no match." ) print( "[ WARNING ] Consider building the OpenVINO Python API from sources or reinstall OpenVINO " "(TM) toolkit using", end=" ") if mo_is_custom: print( "\"pip install openvino\" (may be incompatible with the current Model Optimizer version)" ) else: print("\"pip install openvino=={}.{}\"".format( *extracted_mo_release_version)) simplified_mo_version = v.get_simplified_mo_version() message = str( dict({ "platform": platform.system(), "mo_version": simplified_mo_version, "ie_version": v.get_simplified_ie_version(version=ie_version), "versions_mismatch": versions_mismatch, })) send_telemetry(simplified_mo_version, message, 'ie_version_check') return True except Exception as e: # Do not print a warning if module wasn't found or silent mode is on if "No module named 'openvino" not in str(e): print("[ WARNING ] Failed to import OpenVINO Python API in: {}". format(path_to_module)) print("[ WARNING ] {}".format(e)) # Send telemetry message about warning simplified_mo_version = v.get_simplified_mo_version() message = str( dict({ "platform": platform.system(), "mo_version": simplified_mo_version, "ie_version": v.get_simplified_ie_version(env=os.environ), "python_version": sys.version, "error_type": classify_error_type(e), })) send_telemetry(simplified_mo_version, message, 'ie_import_failed') return False
def test_simplify_mo_version_custom(self, mock_open, mock_isfile): mock_isfile.return_value = True mock_open.return_value.__enter__ = mock_open self.assertEqual(get_simplified_mo_version(), "custom")
def emit_ir(graph: Graph, argv: argparse.Namespace): NormalizeTI().find_and_replace_pattern(graph) for_graph_and_each_sub_graph_recursively( graph, RemoveConstOps().find_and_replace_pattern) for_graph_and_each_sub_graph_recursively( graph, CreateConstNodesReplacement().find_and_replace_pattern) if 'feManager' in argv: del argv.feManager mean_data = deepcopy(graph.graph['mf']) if 'mf' in graph.graph else None input_names = deepcopy( graph.graph['input_names']) if 'input_names' in graph.graph else [] prepare_emit_ir(graph=graph, data_type=graph.graph['cmd_params'].data_type, output_dir=argv.output_dir, output_model_name=argv.model_name, mean_data=mean_data, input_names=input_names, meta_info=get_meta_info(argv), use_temporary_path=True) # This graph cleanup is required to avoid double memory consumption graph.clear() if not (argv.framework == 'tf' and argv.tensorflow_custom_operations_config_update): output_dir = argv.output_dir if argv.output_dir != '.' else os.getcwd() orig_model_name = os.path.normpath( os.path.join(output_dir, argv.model_name)) return_code = "not executed" try: if not argv.legacy_ir_generation: from openvino.tools.mo.back.offline_transformations import apply_offline_transformations apply_offline_transformations(orig_model_name, argv) if "compress_fp16" in argv and argv.compress_fp16: # restore data_type cmd parameter argv.data_type = 'FP16' return_code = 0 except Exception as e: return_code = "failed" log.error(e) message = str( dict({ "platform": platform.system(), "mo_version": get_simplified_mo_version(), "ie_version": get_simplified_ie_version(env=os.environ), "python_version": sys.version, "return_code": return_code })) t = tm.Telemetry() t.send_event('mo', 'offline_transformations_status', message) if return_code != 0: raise Error("offline transformations step has failed.") for suf in [".xml", ".bin", ".mapping"]: # remove existing files path_to_file = orig_model_name + "_tmp" + suf if os.path.exists(path_to_file): os.remove(path_to_file) # add meta information to IR append_ir_info(file=orig_model_name, meta_info=get_meta_info(argv), mean_data=mean_data, input_names=input_names) print('[ SUCCESS ] Generated IR version {} model.'.format( get_ir_version(argv))) print('[ SUCCESS ] XML file: {}.xml'.format(orig_model_name)) print('[ SUCCESS ] BIN file: {}.bin'.format(orig_model_name)) return 0
def test_simplify_mo_version_release(self, mock_open, mock_isfile): mock_isfile.return_value = True mock_open.return_value.__enter__ = mock_open self.assertEqual(get_simplified_mo_version(), "2021.1")