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")
