def main(cli_parser: argparse.ArgumentParser, framework: str):
telemetry = tm.Telemetry(app_name='Model Optimizer',
app_version=get_version())
telemetry.start_session()
telemetry.send_event('mo', 'version', get_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()
if framework:
argv.framework = framework
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()
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()
telemetry.force_shutdown(1.0)
return 1
def add_meta_data(net: xml.etree.ElementTree.Element, meta_info: dict):
meta = SubElement(net, 'meta_data')
SubElement(meta, 'MO_version').set('value', get_version())
parameters = SubElement(meta, 'cli_parameters')
[SubElement(parameters, str(key)).set('value', str(meta_info[key])) for key in sorted(meta_info.keys()) if
key != 'unset']
SubElement(parameters, 'unset').set('unset_cli_parameters', ', '.join(sorted(meta_info['unset'])))
def add_meta_data(net: Element, meta_info: dict):
if meta_info == {}:
log.warning(
'`meta_info` is not provided, IR will not contain appropriate section.'
)
else:
meta = SubElement(net, 'meta_data')
SubElement(meta, 'MO_version').set('value', get_version())
parameters = SubElement(meta, 'cli_parameters')
[
SubElement(parameters, str(key)).set('value', str(meta_info[key]))
for key in sorted(meta_info.keys())
if key not in ('unset', 'quantization_parameters')
]
if 'unset' in meta_info:
SubElement(parameters,
'unset').set('unset_cli_parameters',
', '.join(sorted(meta_info['unset'])))
def print_argv(argv: argparse.Namespace, is_caffe: bool, is_tf: bool,
is_mxnet: bool, is_kaldi: bool, is_onnx: bool, model_name: str):
print('Model Optimizer arguments:')
props = OrderedDict()
props['common_args'] = get_common_cli_options(model_name)
if is_caffe:
props['caffe_args'] = get_caffe_cli_options()
if is_tf:
props['tf_args'] = get_tf_cli_options()
if is_mxnet:
props['mxnet_args'] = get_mxnet_cli_options()
if is_kaldi:
props['kaldi_args'] = get_kaldi_cli_options()
if is_onnx:
props['onnx_args'] = get_onnx_cli_options()
framework_specifics_map = {
'common_args': 'Common parameters:',
'caffe_args': 'Caffe specific parameters:',
'tf_args': 'TensorFlow specific parameters:',
'mxnet_args': 'MXNet specific parameters:',
'kaldi_args': 'Kaldi specific parameters:',
'onnx_args': 'ONNX specific parameters:',
}
lines = []
for key in props:
lines.append(framework_specifics_map[key])
for (op, desc) in props[key].items():
if isinstance(desc, list):
lines.append('\t{}: \t{}'.format(
desc[0], desc[1](getattr(argv, op, 'NONE'))))
else:
if op is 'k':
default_path = os.path.join(
os.path.dirname(sys.argv[0]),
'extensions/front/caffe/CustomLayersMapping.xml')
if getattr(argv, op, 'NONE') == default_path:
lines.append('\t{}: \t{}'.format(desc, 'Default'))
continue
lines.append('\t{}: \t{}'.format(desc,
getattr(argv, op, 'NONE')))
lines.append('Model Optimizer version: \t{}'.format(get_version()))
print('\n'.join(lines), flush=True)
def prepare_ir(argv: argparse.Namespace):
is_tf, is_caffe, is_mxnet, is_kaldi, is_onnx = deduce_framework_by_namespace(
argv)
if not any([is_tf, is_caffe, is_mxnet, is_kaldi, is_onnx]):
raise Error(
'Framework {} is not a valid target. Please use --framework with one from the list: caffe, tf, '
'mxnet, kaldi, onnx. ' + refer_to_faq_msg(15), argv.framework)
if is_tf and not argv.input_model and not argv.saved_model_dir and not argv.input_meta_graph:
raise Error(
'Path to input model or saved model dir is required: use --input_model, --saved_model_dir or '
'--input_meta_graph')
elif is_mxnet and not argv.input_model and not argv.input_symbol and not argv.pretrained_model_name:
raise Error(
'Path to input model or input symbol or pretrained_model_name is required: use --input_model or '
'--input_symbol or --pretrained_model_name')
elif is_caffe and not argv.input_model and not argv.input_proto:
raise Error(
'Path to input model or input proto is required: use --input_model or --input_proto'
)
elif (is_kaldi or is_onnx) and not argv.input_model:
raise Error('Path to input model is required: use --input_model.')
log.debug(str(argv))
log.debug("Model Optimizer started")
t = tm.Telemetry()
t.start_session()
model_name = "<UNKNOWN_NAME>"
if argv.model_name:
model_name = argv.model_name
elif argv.input_model:
model_name = get_model_name(argv.input_model)
elif is_tf and argv.saved_model_dir:
model_name = "saved_model"
elif is_tf and argv.input_meta_graph:
model_name = get_model_name(argv.input_meta_graph)
elif is_mxnet and argv.input_symbol:
model_name = get_model_name(argv.input_symbol)
argv.model_name = model_name
log.debug('Output model name would be {}{{.xml, .bin}}'.format(
argv.model_name))
# if --input_proto is not provided, try to retrieve another one
# by suffix substitution from model file name
if is_caffe and not argv.input_proto:
argv.input_proto = replace_ext(argv.input_model, '.caffemodel',
'.prototxt')
if not argv.input_proto:
raise Error(
"Cannot find prototxt file: for Caffe please specify --input_proto - a "
+
"protobuf file that stores topology and --input_model that stores "
+ "pretrained weights. " + refer_to_faq_msg(20))
log.info('Deduced name for prototxt: {}'.format(argv.input_proto))
if not argv.silent:
print_argv(argv, is_caffe, is_tf, is_mxnet, is_kaldi, is_onnx,
argv.model_name)
# This try-except is additional reinsurance that the IE
# dependency search does not break the MO pipeline
try:
if not find_ie_version(silent=argv.silent) and not argv.silent:
print(
"[ WARNING ] Could not find the Inference Engine Python API. At this moment, the Inference Engine dependency is not required, but will be required in future releases."
)
print(
"[ WARNING ] Consider building the Inference Engine Python API from sources or try to install OpenVINO (TM) Toolkit using \"install_prerequisites.{}\""
.format("bat" if sys.platform == "windows" else "sh"))
# If the IE was not found, it will not print the MO version, so we have to print it manually
print("{}: \t{}".format("Model Optimizer version", get_version()))
except Exception as e:
pass
ret_code = check_requirements(framework=argv.framework)
if ret_code:
raise Error(
'check_requirements exit with return code {}'.format(ret_code))
if is_tf and argv.tensorflow_use_custom_operations_config is not None:
argv.transformations_config = argv.tensorflow_use_custom_operations_config
if is_caffe and argv.mean_file and argv.mean_values:
raise Error(
'Both --mean_file and mean_values are specified. Specify either mean file or mean values. '
+ refer_to_faq_msg(17))
elif is_caffe and argv.mean_file and argv.mean_file_offsets:
values = get_tuple_values(argv.mean_file_offsets,
t=int,
num_exp_values=2)
mean_file_offsets = np.array([int(x) for x in values[0].split(',')])
if not all([offset >= 0 for offset in mean_file_offsets]):
raise Error(
"Negative value specified for --mean_file_offsets option. "
"Please specify positive integer values in format '(x,y)'. " +
refer_to_faq_msg(18))
argv.mean_file_offsets = mean_file_offsets
if argv.scale and argv.scale_values:
raise Error(
'Both --scale and --scale_values are defined. Specify either scale factor or scale values per input '
+ 'channels. ' + refer_to_faq_msg(19))
if argv.scale and argv.scale < 1.0:
log.error(
"The scale value is less than 1.0. This is most probably an issue because the scale value specifies "
"floating point value which all input values will be *divided*.",
extra={'is_warning': True})
if argv.input_model and (is_tf and argv.saved_model_dir):
raise Error('Both --input_model and --saved_model_dir are defined. '
'Specify either input model or saved model directory.')
if is_tf:
if argv.saved_model_tags is not None:
if ' ' in argv.saved_model_tags:
raise Error(
'Incorrect saved model tag was provided. Specify --saved_model_tags with no spaces in it'
)
argv.saved_model_tags = argv.saved_model_tags.split(',')
argv.output = argv.output.split(',') if argv.output else None
argv.placeholder_shapes, argv.placeholder_data_types = get_placeholder_shapes(
argv.input, argv.input_shape, argv.batch)
mean_values = parse_tuple_pairs(argv.mean_values)
scale_values = parse_tuple_pairs(argv.scale_values)
mean_scale = get_mean_scale_dictionary(mean_values, scale_values,
argv.input)
argv.mean_scale_values = mean_scale
if not os.path.exists(argv.output_dir):
try:
os.makedirs(argv.output_dir)
except PermissionError as e:
raise Error(
"Failed to create directory {}. Permission denied! " +
refer_to_faq_msg(22), argv.output_dir) from e
else:
if not os.access(argv.output_dir, os.W_OK):
raise Error(
"Output directory {} is not writable for current user. " +
refer_to_faq_msg(22), argv.output_dir)
log.debug("Placeholder shapes : {}".format(argv.placeholder_shapes))
if hasattr(argv,
'extensions') and argv.extensions and argv.extensions != '':
extensions = argv.extensions.split(',')
else:
extensions = None
argv.freeze_placeholder_with_value, argv.input = get_freeze_placeholder_values(
argv.input, argv.freeze_placeholder_with_value)
if is_tf:
t.send_event('mo', 'framework', 'tf')
from mo.front.tf.register_custom_ops import get_front_classes
import_extensions.load_dirs(argv.framework, extensions,
get_front_classes)
elif is_caffe:
t.send_event('mo', 'framework', 'caffe')
from mo.front.caffe.register_custom_ops import get_front_classes
import_extensions.load_dirs(argv.framework, extensions,
get_front_classes)
elif is_mxnet:
t.send_event('mo', 'framework', 'mxnet')
from mo.front.mxnet.register_custom_ops import get_front_classes
import_extensions.load_dirs(argv.framework, extensions,
get_front_classes)
elif is_kaldi:
t.send_event('mo', 'framework', 'kaldi')
from mo.front.kaldi.register_custom_ops import get_front_classes
import_extensions.load_dirs(argv.framework, extensions,
get_front_classes)
elif is_onnx:
t.send_event('mo', 'framework', 'onnx')
from mo.front.onnx.register_custom_ops import get_front_classes
import_extensions.load_dirs(argv.framework, extensions,
get_front_classes)
graph = unified_pipeline(argv)
return graph
def import_core_modules(silent: bool, path_to_module: str):
"""
This function checks that InferenceEngine 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.inference_engine import get_version, read_network # pylint: disable=import-error,no-name-in-module
from openvino.offline_transformations import ApplyMOCTransformations, ApplyLowLatencyTransformation, \
ApplyMakeStatefulTransformation, GenerateMappingFile # pylint: disable=import-error,no-name-in-module
# TODO: it is temporary import to check that nGraph python API is available. But in future
# we need to replace it with Frontend imports
from ngraph.impl.op import Parameter # pylint: disable=import-error,no-name-in-module
from _pyngraph import PartialShape, Dimension # pylint: disable=import-error,no-name-in-module
import openvino # pylint: disable=import-error,no-name-in-module
import ngraph # pylint: disable=import-error,no-name-in-module
import ngraph.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- {}: \t{}".format("Inference Engine found in",
os.path.dirname(openvino.__file__)))
# TODO: when nGraph version will be available we need to start compare it to IE and MO versions. Ticket: 58091
print("\t- {}: \t{}".format("nGraph found in",
os.path.dirname(ngraph.__file__)))
print("{}: \t{}".format("Inference Engine version", ie_version))
print("{}: \t{}".format("Model Optimizer version", mo_version))
versions_mismatch = False
if mo_version != ie_version:
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 Inference Engine versions do no match."
)
print(
"[ WARNING ] Consider building the Inference Engine 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 Inference Engine 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_get_version(self, mock_open, mock_isfile):
mock_isfile.return_value = True
mock_open.return_value.__enter__ = mock_open
self.assertEqual(get_version(), '2021.1.0-1028-55e4d5673a8')
def test_unknown_version(self):
self.assertEqual(get_version(), "unknown version")
def test_release_version_extractor_neg(self, mock_open, mock_isfile):
mock_isfile.return_value = True
mock_open.return_value.__enter__ = mock_open
self.assertEqual(extract_release_version(get_version()), (None, None))
def test_custom_release_version_extractor(self, mock_open, mock_isfile):
mock_isfile.return_value = True
mock_open.return_value.__enter__ = mock_open
self.assertEqual(extract_release_version(get_version()), ('2021', '1'))
def import_core_modules(silent: bool, path_to_module: str):
try:
from openvino.inference_engine import IECore, get_version # pylint: disable=import-error
from openvino.offline_transformations import ApplyMOCTransformations, CheckAPI # pylint: disable=import-error
import openvino # pylint: disable=import-error
if silent:
return True
ie_version = str(get_version())
mo_version = str(v.get_version()) # pylint: disable=no-member
print("\t- {}: \t{}".format("Inference Engine found in",
os.path.dirname(openvino.__file__)))
print("{}: \t{}".format("Inference Engine version", ie_version))
print("{}: \t {}".format("Model Optimizer version", mo_version))
versions_mismatch = False
# MO and IE version have a small difference in the beginning of version because
# IE version also includes API version. For example:
# Inference Engine version: 2.1.custom_HEAD_4c8eae0ee2d403f8f5ae15b2c9ad19cfa5a9e1f9
# Model Optimizer version: custom_HEAD_4c8eae0ee2d403f8f5ae15b2c9ad19cfa5a9e1f9
# So to match this versions we skip IE API version.
if not re.match(r"^([0-9]+).([0-9]+).{}$".format(mo_version),
ie_version):
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 Inference Engine versions do no match."
)
print(
"[ WARNING ] Consider building the Inference Engine 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) and not silent:
print(
"[ WARNING ] Failed to import Inference Engine 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 driver(argv: argparse.Namespace):
if argv.version:
print('Version of Model Optimizer is: {}'.format(get_version()))
return 0
init_logger(argv.log_level.upper(), argv.silent)
start_time = datetime.datetime.now()
if not argv.framework:
if 'saved_model_dir' in argv and argv.saved_model_dir or \
'input_meta_graph' in argv and argv.input_meta_graph:
argv.framework = 'tf'
elif 'input_symbol ' in argv and argv.input_symbol or \
'pretrained_model_name' in argv and argv.pretrained_model_name:
argv.framework = 'mxnet'
elif 'input_proto' in argv and argv.input_proto:
argv.framework = 'caffe'
elif argv.input_model is None:
raise Error('Path to input model is required: use --input_model.')
else:
argv.framework = guess_framework_by_ext(argv.input_model)
if not argv.framework:
raise Error(
'Framework name can not be deduced from the given options: {}={}. '
+
'Use --framework to choose one of caffe, tf, mxnet, kaldi, onnx',
'--input_model',
argv.input_model,
refer_to_faq_msg(15),
)
is_tf, is_caffe, is_mxnet, is_kaldi, is_onnx = (
argv.framework == x for x in ['tf', 'caffe', 'mxnet', 'kaldi', 'onnx'])
if is_tf and not argv.input_model and not argv.saved_model_dir and not argv.input_meta_graph:
raise Error(
'Path to input model or saved model dir is required: use --input_model, --saved_model_dir or '
'--input_meta_graph')
elif is_mxnet and not argv.input_model and not argv.input_symbol and not argv.pretrained_model_name:
raise Error(
'Path to input model or input symbol or pretrained_model_name is required: use --input_model or '
'--input_symbol or --pretrained_model_name')
elif is_caffe and not argv.input_model and not argv.input_proto:
raise Error(
'Path to input model or input proto is required: use --input_model or --input_proto'
)
elif (is_kaldi or is_onnx) and not argv.input_model:
raise Error('Path to input model is required: use --input_model.')
log.debug(str(argv))
log.debug("Model Optimizer started")
model_name = "<UNKNOWN_NAME>"
if argv.model_name:
model_name = argv.model_name
elif argv.input_model:
model_name = get_model_name(argv.input_model)
elif is_tf and argv.saved_model_dir:
model_name = "saved_model"
elif is_tf and argv.input_meta_graph:
model_name = get_model_name(argv.input_meta_graph)
elif is_mxnet and argv.input_symbol:
model_name = get_model_name(argv.input_symbol)
log.debug('Output model name would be {}{{.xml, .bin}}'.format(model_name))
# if --input_proto is not provided, try to retrieve another one
# by suffix substitution from model file name
if is_caffe and not argv.input_proto:
argv.input_proto = replace_ext(argv.input_model, '.caffemodel',
'.prototxt')
if not argv.input_proto:
raise Error(
"Cannot find prototxt file: for Caffe please specify --input_proto - a "
+
"protobuf file that stores topology and --input_model that stores "
+ "pretrained weights. " + refer_to_faq_msg(20))
log.info('Deduced name for prototxt: {}'.format(argv.input_proto))
if not argv.silent:
print_argv(argv, is_caffe, is_tf, is_mxnet, is_kaldi, is_onnx,
model_name)
if not any([is_tf, is_caffe, is_mxnet, is_kaldi, is_onnx]):
raise Error(
'Framework {} is not a valid target. ' +
'Please use --framework with one from the list: caffe, tf, mxnet, kaldi, onnx. '
+ refer_to_faq_msg(15), argv.framework)
ret_code = check_requirements(framework=argv.framework)
if ret_code:
return ret_code
if is_mxnet and not argv.input_shape:
raise Error(
'Input shape is required to convert MXNet model. Please provide it with --input_shape. '
+ refer_to_faq_msg(16))
mean_file_offsets = None
if is_caffe and argv.mean_file and argv.mean_values:
raise Error(
'Both --mean_file and mean_values are specified. Specify either mean file or mean values. '
+ refer_to_faq_msg(17))
elif is_caffe and argv.mean_file and argv.mean_file_offsets:
values = get_tuple_values(argv.mean_file_offsets,
t=int,
num_exp_values=2)
mean_file_offsets = np.array([int(x) for x in values[0].split(',')])
if not all([offset >= 0 for offset in mean_file_offsets]):
raise Error(
"Negative value specified for --mean_file_offsets option. "
"Please specify positive integer values in format '(x,y)'. " +
refer_to_faq_msg(18))
custom_layers_mapping_path = argv.k if is_caffe and argv.k else None
if argv.scale and argv.scale_values:
raise Error(
'Both --scale and --scale_values are defined. Specify either scale factor or scale values per input '
+ 'channels. ' + refer_to_faq_msg(19))
if argv.scale and argv.scale < 1.0:
log.error(
"The scale value is less than 1.0. This is most probably an issue because the scale value specifies "
"floating point value which all input values will be *divided*.",
extra={'is_warning': True})
if argv.input_model and (is_tf and argv.saved_model_dir):
raise Error('Both --input_model and --saved_model_dir are defined. '
'Specify either input model or saved model directory.')
if is_tf:
if argv.saved_model_tags is not None:
if ' ' in argv.saved_model_tags:
raise Error(
'Incorrect saved model tag was provided. Specify --saved_model_tags with no spaces in it'
)
argv.saved_model_tags = argv.saved_model_tags.split(',')
argv.output = argv.output.split(',') if argv.output else None
argv.placeholder_shapes = get_placeholder_shapes(argv.input,
argv.input_shape,
argv.batch)
mean_values = parse_tuple_pairs(argv.mean_values)
scale_values = parse_tuple_pairs(argv.scale_values)
mean_scale = get_mean_scale_dictionary(mean_values, scale_values,
argv.input)
argv.mean_scale_values = mean_scale
if not os.path.exists(argv.output_dir):
try:
os.makedirs(argv.output_dir)
except PermissionError as e:
raise Error(
"Failed to create directory {}. Permission denied! " +
refer_to_faq_msg(22), argv.output_dir) from e
else:
if not os.access(argv.output_dir, os.W_OK):
raise Error(
"Output directory {} is not writable for current user. " +
refer_to_faq_msg(22), argv.output_dir)
log.debug("Placeholder shapes : {}".format(argv.placeholder_shapes))
ret_res = 1
if hasattr(argv,
'extensions') and argv.extensions and argv.extensions != '':
extensions = argv.extensions.split(',')
else:
extensions = None
argv.freeze_placeholder_with_value, argv.input = get_freeze_placeholder_values(
argv.input, argv.freeze_placeholder_with_value)
if is_tf:
import mo.pipeline.tf as mo_tf
from mo.front.tf.register_custom_ops import get_front_classes
import_extensions.load_dirs(argv.framework, extensions,
get_front_classes)
ret_res = mo_tf.tf2nx(argv,
argv.input_model,
model_name,
argv.output_dir,
is_binary=not argv.input_model_is_text)
elif is_caffe:
import mo.pipeline.caffe as mo_caffe
from mo.front.caffe.register_custom_ops import get_front_classes
import_extensions.load_dirs(argv.framework, extensions,
get_front_classes)
ret_res = mo_caffe.driver(
argv,
argv.input_proto,
argv.input_model,
model_name,
argv.output_dir,
argv.caffe_parser_path,
mean_file=argv.mean_file,
mean_file_offsets=mean_file_offsets,
custom_layers_mapping_path=custom_layers_mapping_path)
elif is_mxnet:
import mo.pipeline.mx as mo_mxnet
from mo.front.mxnet.register_custom_ops import get_front_classes
import_extensions.load_dirs(argv.framework, extensions,
get_front_classes)
ret_res = mo_mxnet.driver(argv, argv.input_model, model_name,
argv.output_dir)
elif is_kaldi:
import mo.pipeline.kaldi as mo_kaldi
from mo.front.kaldi.register_custom_ops import get_front_classes
import_extensions.load_dirs(argv.framework, extensions,
get_front_classes)
ret_res = mo_kaldi.driver(argv, argv.input_model, model_name,
argv.output_dir)
elif is_onnx:
import mo.pipeline.onnx as mo_onnx
from mo.front.onnx.register_custom_ops import get_front_classes
import_extensions.load_dirs(argv.framework, extensions,
get_front_classes)
ret_res = mo_onnx.driver(argv, argv.input_model, model_name,
argv.output_dir)
if ret_res != 0:
return ret_res
if not (is_tf and argv.tensorflow_custom_operations_config_update):
output_dir = argv.output_dir if argv.output_dir != '.' else os.getcwd()
print('\n[ SUCCESS ] Generated IR model.')
print('[ SUCCESS ] XML file: {}.xml'.format(
os.path.join(output_dir, model_name)))
print('[ SUCCESS ] BIN file: {}.bin'.format(
os.path.join(output_dir, model_name)))
elapsed_time = datetime.datetime.now() - start_time
print('[ SUCCESS ] Total execution time: {:.2f} seconds. '.format(
elapsed_time.total_seconds()))
return ret_res
def collect_env():
env_info = {}
env_info['sys.platform'] = sys.platform
env_info['Python'] = sys.version.replace('\n', '')
cuda_available = torch.cuda.is_available()
env_info['CUDA available'] = cuda_available
if cuda_available:
from torch.utils.cpp_extension import CUDA_HOME
env_info['CUDA_HOME'] = CUDA_HOME
if CUDA_HOME is not None and osp.isdir(CUDA_HOME):
try:
nvcc = osp.join(CUDA_HOME, 'bin/nvcc')
nvcc = subprocess.check_output(f'"{nvcc}" -V | tail -n1',
shell=True)
nvcc = nvcc.decode('utf-8').strip()
except subprocess.SubprocessError:
nvcc = 'Not Available'
env_info['NVCC'] = nvcc
devices = defaultdict(list)
for k in range(torch.cuda.device_count()):
devices[torch.cuda.get_device_name(k)].append(str(k))
for name, devids in devices.items():
env_info['GPU ' + ','.join(devids)] = name
gcc = subprocess.check_output('gcc --version | head -n1', shell=True)
gcc = gcc.decode('utf-8').strip()
env_info['GCC'] = gcc
env_info['PyTorch'] = torch.__version__
env_info['PyTorch compiling details'] = torch.__config__.show()
env_info['TorchVision'] = torchvision.__version__
env_info['OpenCV'] = cv2.__version__
env_info['MMCV'] = mmcv.__version__
env_info['MMDetection'] = mmdet.__version__
from mmdet.ops import get_compiler_version, get_compiling_cuda_version
env_info['MMDetection Compiler'] = get_compiler_version()
env_info['MMDetection CUDA Compiler'] = get_compiling_cuda_version()
from mmdet.integration.nncf.utils import get_nncf_version
env_info['NNCF'] = get_nncf_version()
env_info['ONNX'] = None
with suppress(ImportError):
import onnx
env_info['ONNX'] = onnx.__version__
env_info['ONNXRuntime'] = None
with suppress(ImportError):
import onnxruntime
env_info['ONNXRuntime'] = onnxruntime.__version__
env_info['OpenVINO MO'] = None
with suppress(ImportError):
from mo.utils.version import get_version
env_info['OpenVINO MO'] = get_version()
env_info['OpenVINO IE'] = None
with suppress(ImportError):
import openvino.inference_engine as ie
env_info['OpenVINO IE'] = ie.__version__
return env_info
