def driver_R1(onnx_modelproto_bytes,
precision: str,
output_model_name: str,
outputs: list,
output_dir: str,
scale: float,
user_shapes: [None, list, np.array] = None,
mean_scale_values: [dict, list] = ()):
try:
model_proto = onnx.load_from_string(bytes(onnx_modelproto_bytes))
except Exception as e:
print("[python] onnx exception: ", str(e))
model_graph = model_proto.graph # pylint: disable=no-member
update_extractors_with_extensions(onnx_op_extractors)
try:
graph = protobuf2nx(model_proto)
log.debug("Number of nodes in NX graph: {}".format(
graph.number_of_nodes()))
graph.__setattr__(
'name',
output_model_name if output_model_name else model_proto.graph.name) # pylint: disable=no-member
graph.graph['layout'] = 'NCHW'
graph.graph['cmd_params'] = argparse.Namespace(
batch=None,
data_type='float',
disable_fusing=False,
disable_gfusing=False,
disable_resnet_optimization=False,
enable_concat_optimization=False,
extensions=mo_extensions,
finegrain_fusing=None,
framework='onnx',
freeze_placeholder_with_value=None,
generate_deprecated_IR_V2=False,
input=None,
input_model=None,
input_shape=None,
keep_shape_ops=False,
log_level='ERROR',
mean_scale_values={},
mean_values=(),
model_name=None,
move_to_preprocess=False,
output=None,
output_dir='.',
placeholder_shapes=None,
reverse_input_channels=False,
scale=None,
scale_values=(),
silent=False,
version=False)
graph.graph['fw'] = 'onnx'
graph.graph[
'feature_dim'] = 1 if graph.graph['layout'] == 'NCHW' else 3
graph.graph['ir_version'] = 5
except Exception as e:
raise Error(
'Cannot pre-process ONNX graph after reading from model file "{}". '
'File is corrupt or has unsupported format. Details: {}. ' +
refer_to_faq_msg(44), model_file_name, str(e)) from e
graph.check_empty_graph(
'protobuf2nx. It may happen due to problems with loaded model')
extract_node_attrs(
graph, lambda node: onnx_op_extractor(
node, check_for_duplicates(onnx_op_extractors)))
# --------------------------------- LOAD END ------------------------------------------------------
class_registration.apply_replacements(
graph, class_registration.ClassType.FRONT_REPLACER)
class_registration.apply_replacements(
graph, class_registration.ClassType.MIDDLE_REPLACER)
fuse_pad(graph)
graph_clean_up_onnx(graph)
mark_unfused_nodes(graph, 'False')
convert_batch_norm(graph)
graph_clean_up_onnx(graph)
convert_scale_shift_to_mul_add(graph)
graph_clean_up_onnx(graph)
fuse_mul_add_sequence(graph)
graph_clean_up_onnx(graph)
fuse_linear_ops(graph)
graph_clean_up_onnx(graph)
grouped_convolutions_fusing(graph)
graph_clean_up_onnx(graph)
fuse_linear_ops(graph)
graph_clean_up_onnx(graph)
convert_muladd_to_scaleshift_or_power(graph)
graph_clean_up_onnx(graph)
convert_mul_add_to_power(graph)
graph_clean_up_onnx(graph)
convert_reshape(graph)
graph_clean_up_onnx(graph)
convert_add_or_mul_to_scaleshift(graph) # scale = 1
graph_clean_up_onnx(graph)
fuse_pad(graph)
graph_clean_up_onnx(graph)
fuse_sequence_of_reshapes(graph)
graph_clean_up_onnx(graph)
pattern = EltwiseInputNormalize()
pattern.find_and_replace_pattern(graph)
merge_nodes_permutations(graph)
permute_data_nodes_attrs(graph)
permute_op_nodes_attrs(graph)
class_registration.apply_replacements(
graph, class_registration.ClassType.BACK_REPLACER)
for_graph_and_each_sub_graph_recursively(graph, remove_const_ops)
CreateConstNodesReplacement().find_and_replace_pattern(graph)
for_graph_and_each_sub_graph_recursively(graph, remove_output_ops)
weights, xml_string = prepare_emit_ir(graph=graph,
data_type=precision,
output_dir=output_dir,
output_model_name=output_model_name,
meta_info={'unset': []})
return weights, xml_string
def driver(argv: argparse.Namespace, model_file_name: str, output_model_name: str, output_dir: str):
meta_info = get_meta_info(argv)
model_proto = load_onnx_model(model_file_name)
model_graph = model_proto.graph # pylint: disable=no-member
# print(model_graph)
# assert len(model_graph) == 1, "An ONNX model contains more than 1 graph: unsupported"
log.debug("Number of nodes in graph_def: {}".format(len(model_graph.node)))
log.debug("Number of all input ports (not true inputs) in graph_def: {}".format(len(model_graph.input)))
log.debug("Number of initializers in graph_def: {}".format(len(model_graph.initializer)))
log.debug("Number of real inputs in graph_def: {}".format(len(model_graph.input) - len(model_graph.initializer)))
update_extractors_with_extensions(onnx_op_extractors)
try:
graph = protobuf2nx(model_proto)
log.debug("Number of nodes in NX graph: {}".format(graph.number_of_nodes()))
graph.__setattr__('name',
output_model_name if output_model_name else model_proto.graph.name) # pylint: disable=no-member
graph.graph['layout'] = 'NCHW'
graph.graph['cmd_params'] = argv
graph.graph['fw'] = 'onnx'
graph.graph['feature_dim'] = 1 if graph.graph['layout'] == 'NCHW' else 3
graph.graph['ir_version'] = 2 if argv.generate_deprecated_IR_V2 else 5
except Exception as e:
raise Error(
'Cannot pre-process ONNX graph after reading from model file "{}". ' \
'File is corrupt or has unsupported format. Details: {}. ' +
refer_to_faq_msg(44),
model_file_name,
str(e)
) from e
graph.check_empty_graph('protobuf2nx. It may happen due to problems with loaded model')
extract_node_attrs(graph, lambda node: onnx_op_extractor(node, check_for_duplicates(onnx_op_extractors)))
# --------------------------------- LOAD END ------------------------------------------------------
class_registration.apply_replacements(graph, class_registration.ClassType.FRONT_REPLACER)
class_registration.apply_replacements(graph, class_registration.ClassType.MIDDLE_REPLACER)
fuse_pad(graph)
graph_clean_up_onnx(graph)
# Mark nodes with attr 'can_be_fused': False to disable fusing for specified nodes
mark_unfused_nodes(graph, argv.finegrain_fusing)
# Converting FusedBatchNorm layer to Mul->Add->Mul->Add sequence
# IE doesn't support BN with 4 inputs, so we have to split it to two ScaleShift
convert_batch_norm(graph)
graph_clean_up_onnx(graph)
if not argv.disable_fusing:
# Converting ScaleShift layer to Mul->Add
convert_scale_shift_to_mul_add(graph)
graph_clean_up_onnx(graph)
# Fusing the sequences of Mul/Add operations
fuse_mul_add_sequence(graph)
graph_clean_up_onnx(graph)
# Fusing linear operation to Convolution
fuse_linear_ops(graph)
graph_clean_up_onnx(graph)
if not argv.disable_gfusing:
grouped_convolutions_fusing(graph)
graph_clean_up_onnx(graph)
if not argv.disable_fusing:
fuse_linear_ops(graph)
graph_clean_up_onnx(graph)
AddQuantizeFuse().find_and_replace_pattern(graph)
MulQuantizeFuse().find_and_replace_pattern(graph)
convert_muladd_to_scaleshift_or_power(graph)
graph_clean_up_onnx(graph)
convert_mul_add_to_power(graph)
graph_clean_up_onnx(graph)
convert_reshape(graph)
graph_clean_up_onnx(graph)
convert_add_or_mul_to_scaleshift(graph) # scale = 1
graph_clean_up_onnx(graph)
fuse_pad(graph)
graph_clean_up_onnx(graph)
if argv.reverse_input_channels:
reverse_input_channels(graph)
if argv.move_to_preprocess:
move_scaleshift_to_preprocess(graph)
graph_clean_up_onnx(graph)
fuse_sequence_of_reshapes(graph)
graph_clean_up_onnx(graph)
pattern = EltwiseInputNormalize()
pattern.find_and_replace_pattern(graph)
merge_nodes_permutations(graph)
permute_data_nodes_attrs(graph)
permute_op_nodes_attrs(graph)
class_registration.apply_replacements(graph, class_registration.ClassType.BACK_REPLACER)
for_graph_and_each_sub_graph_recursively(graph, remove_const_ops)
CreateConstNodesReplacement().find_and_replace_pattern(graph)
for_graph_and_each_sub_graph_recursively(graph, remove_output_ops)
prepare_emit_ir(graph=graph, data_type=argv.data_type, output_dir=output_dir, output_model_name=output_model_name,
meta_info=meta_info)
return 0
def driver_R5(onnx_modelproto_bytes,
precision: str,
output_model_name: str,
outputs: list,
output_dir: str,
scale: float,
user_shapes: [None, list, np.array] = None,
mean_scale_values: [dict, list] = ()):
try:
model_proto = onnx.load_from_string(bytes(onnx_modelproto_bytes))
except Exception as e:
print("[python] onnx exception: ", str(e))
model_graph = model_proto.graph # pylint: disable=no-member
log.debug("Number of nodes in graph_def: {}".format(len(model_graph.node)))
log.debug(
"Number of all input ports (not true inputs) in graph_def: {}".format(
len(model_graph.input)))
log.debug("Number of initializers in graph_def: {}".format(
len(model_graph.initializer)))
log.debug("Number of real inputs in graph_def: {}".format(
len(model_graph.input) - len(model_graph.initializer)))
update_extractors_with_extensions(onnx_op_extractors)
try:
graph = protobuf2nx(model_proto)
log.debug("Number of nodes in NX graph: {}".format(
graph.number_of_nodes()))
graph.__setattr__(
'name',
output_model_name if output_model_name else model_proto.graph.name) # pylint: disable=no-member
graph.graph['layout'] = 'NCHW'
graph.graph['fw'] = 'onnx'
graph.graph[
'feature_dim'] = 1 if graph.graph['layout'] == 'NCHW' else 3
graph.graph['ir_version'] = 4
extract_node_attrs(graph, lambda node:
(True, common_onnx_fields(node)))
except Exception as e:
raise Error(
'Cannot pre-process ONNX graph after reading from model file "{}". '
'File is corrupt or has unsupported format. Details: {}. ' +
refer_to_faq_msg(44), model_file_name, str(e)) from e
check_empty_graph(
graph, 'protobuf2nx. It may happen due to problems with loaded model')
packed_user_shapes, packed_outputs, _ = user_data_repack(
graph, user_shapes, outputs, None)
output_op_nodes = add_output_ops(graph, packed_outputs)
input_op_nodes = add_input_ops(graph, packed_user_shapes, True)
graph_clean_up(graph)
check_empty_graph(graph, 'add_output_ops and add_input_ops')
extract_node_attrs(
graph, lambda node: onnx_op_extractor(
node, check_for_duplicates(onnx_op_extractors)))
class_registration.apply_replacements(
graph, class_registration.ClassType.FRONT_REPLACER)
create_tensor_nodes(graph)
graph_clean_up(graph)
override_placeholder_shapes(graph, packed_user_shapes)
graph_clean_up(graph)
remove_op_nodes(graph, {'op': 'Identity'})
graph_clean_up(graph)
remove_output_ops(graph)
partial_infer(graph)
graph_clean_up(graph)
check_empty_graph(graph, 'partial_infer')
input_op_nodes = add_input_ops(graph, packed_user_shapes, False)
graph_clean_up(graph)
check_empty_graph(graph, 'add_input_ops')
scale_input(graph, scale)
add_mean_scale_values(graph, mean_scale_values)
convert_dilated_convolution(graph)
graph_clean_up(graph)
graph_clean_up(graph)
remove_op_nodes(graph, {'op': 'Identity'})
remove_useless_split(graph)
class_registration.apply_replacements(
graph, class_registration.ClassType.MIDDLE_REPLACER)
convert_gemm_to_fully_connected(graph)
NormalizeFullyConnected().find_and_replace_pattern(graph)
fuse_pad(graph)
graph_clean_up(graph)
convert_batch_norm(graph)
graph_clean_up(graph)
convert_scale_shift_to_mul_add(graph)
graph_clean_up(graph)
fuse_mul_add_sequence(graph)
graph_clean_up(graph)
fuse_linear_ops(graph)
graph_clean_up(graph)
grouped_convolutions_fusing(graph)
graph_clean_up(graph)
fuse_linear_ops(graph)
graph_clean_up(graph)
convert_muladd_to_scaleshift_or_power(graph)
graph_clean_up(graph)
convert_mul_add_to_power(graph)
graph_clean_up(graph)
convert_reshape(graph)
convert_add_to_scaleshift(graph) # scale = 1
convert_mul_to_scaleshift(graph) # biases = 0
fuse_pad(graph)
graph_clean_up(graph)
fuse_sequence_of_reshapes(graph)
graph_clean_up(graph)
pattern = EltwiseInputNormalize()
pattern.find_and_replace_pattern(graph)
merge_nodes_permutations(graph)
permute_data_nodes_attrs(graph)
permute_op_nodes_attrs(graph)
class_registration.apply_replacements(
graph, class_registration.ClassType.BACK_REPLACER)
weights, xml_string = prepare_emit_ir(graph=graph,
data_type=precision,
output_dir=output_dir,
output_model_name=output_model_name,
meta_info={'unset': []})
return weights, xml_string
def driver(argv: argparse.Namespace,
model_file_name: str,
output_model_name: str,
outputs: list,
output_dir: str,
scale: float,
user_shapes: [None, list, np.array] = None,
mean_scale_values: [dict, list] = ()):
meta_info = get_meta_info(argv)
model_proto = load_onnx_model(model_file_name)
model_graph = model_proto.graph # pylint: disable=no-member
#print(model_graph)
#assert len(model_graph) == 1, "An ONNX model contains more than 1 graph: unsupported"
log.debug("Number of nodes in graph_def: {}".format(len(model_graph.node)))
log.debug(
"Number of all input ports (not true inputs) in graph_def: {}".format(
len(model_graph.input)))
log.debug("Number of initializers in graph_def: {}".format(
len(model_graph.initializer)))
log.debug("Number of real inputs in graph_def: {}".format(
len(model_graph.input) - len(model_graph.initializer)))
update_extractors_with_extensions(onnx_op_extractors)
try:
graph = protobuf2nx(model_proto)
log.debug("Number of nodes in NX graph: {}".format(
graph.number_of_nodes()))
graph.__setattr__(
'name',
output_model_name if output_model_name else model_proto.graph.name) # pylint: disable=no-member
graph.graph['layout'] = 'NCHW'
graph.graph['cmd_params'] = argv
graph.graph['fw'] = 'onnx'
graph.graph[
'feature_dim'] = 1 if graph.graph['layout'] == 'NCHW' else 3
graph.graph['ir_version'] = 2 if argv.generate_deprecated_IR_V2 else 4
# extract basic attributes earlier to enable some passes that relies on them before full attribute
# extractor is called
extract_node_attrs(graph, lambda node:
(True, common_onnx_fields(node)))
except Exception as e:
raise Error(
'Cannot pre-process ONNX graph after reading from model file "{}". ' \
'File is corrupt or has unsupported format. Details: {}. ' +
refer_to_faq_msg(44),
model_file_name,
str(e)
) from e
check_empty_graph(
graph, 'protobuf2nx. It may happen due to problems with loaded model')
packed_user_shapes, packed_outputs, _ = user_data_repack(
graph, user_shapes, outputs, None)
output_op_nodes = add_output_ops(graph, packed_outputs)
input_op_nodes = add_input_ops(graph, packed_user_shapes, True)
# this call of 'graph_clean_up' removes child nodes of outputs which is useful when custom output is specified
graph_clean_up(graph)
check_empty_graph(graph, 'add_output_ops and add_input_ops')
extract_node_attrs(
graph, lambda node: onnx_op_extractor(
node, check_for_duplicates(onnx_op_extractors)))
class_registration.apply_replacements(
graph, class_registration.ClassType.FRONT_REPLACER)
create_tensor_nodes(graph)
graph_clean_up(graph)
override_placeholder_shapes(graph, packed_user_shapes)
override_batch(graph, argv.batch)
graph_clean_up(graph)
remove_op_nodes(graph, {'op': 'Identity'})
graph_clean_up(graph)
remove_output_ops(graph)
partial_infer(graph)
graph_clean_up(graph)
check_empty_graph(graph, 'partial_infer')
input_op_nodes = add_input_ops(graph, packed_user_shapes, False)
graph_clean_up(graph)
check_empty_graph(graph, 'add_input_ops')
#change_placeholders_types_to_FP32(graph)
scale_input(graph, scale)
add_mean_scale_values(graph, mean_scale_values)
convert_dilated_convolution(graph)
graph_clean_up(graph)
graph_clean_up(graph)
remove_op_nodes(graph, {'op': 'Identity'})
remove_useless_split(graph)
class_registration.apply_replacements(
graph, class_registration.ClassType.MIDDLE_REPLACER)
convert_gemm_to_fully_connected(graph)
NormalizeFullyConnected().find_and_replace_pattern(graph)
fuse_pad(graph)
graph_clean_up(graph)
# Mark nodes with attr 'can_be_fused': False to disable fusing for specified nodes
mark_unfused_nodes(graph, argv.finegrain_fusing)
# Converting FusedBatchNorm layer to Mul->Add->Mul->Add sequence
# IE doesn't support BN with 4 inputs, so we have to split it to two ScaleShift
convert_batch_norm(graph)
graph_clean_up(graph)
if not argv.disable_fusing:
# Converting ScaleShift layer to Mul->Add
convert_scale_shift_to_mul_add(graph)
graph_clean_up(graph)
# Fusing the sequences of Mul/Add operations
fuse_mul_add_sequence(graph)
graph_clean_up(graph)
# Fusing linear operation to Convolution
fuse_linear_ops(graph)
graph_clean_up(graph)
if not argv.disable_gfusing:
grouped_convolutions_fusing(graph)
graph_clean_up(graph)
if not argv.disable_fusing:
fuse_linear_ops(graph)
graph_clean_up(graph)
convert_muladd_to_scaleshift_or_power(graph)
graph_clean_up(graph)
convert_mul_add_to_power(graph)
graph_clean_up(graph)
convert_reshape(graph)
convert_add_to_scaleshift(graph) # scale = 1
convert_mul_to_scaleshift(graph) # biases = 0
fuse_pad(graph)
graph_clean_up(graph)
if argv.reverse_input_channels:
reverse_input_channels(graph)
if argv.move_to_preprocess:
move_scaleshift_to_preprocess(graph)
graph_clean_up(graph)
fuse_sequence_of_reshapes(graph)
graph_clean_up(graph)
pattern = EltwiseInputNormalize()
pattern.find_and_replace_pattern(graph)
merge_nodes_permutations(graph)
permute_data_nodes_attrs(graph)
permute_op_nodes_attrs(graph)
class_registration.apply_replacements(
graph, class_registration.ClassType.BACK_REPLACER)
prepare_emit_ir(graph=graph,
data_type=argv.data_type,
output_dir=output_dir,
output_model_name=output_model_name,
meta_info=meta_info)
return 0