def save_restored_graph(graph: Graph, path: str, meta_data, name=None): """ Function to apply all necessary transforms from back stage to prepare and save restored graph and metadata. :param graph: Graph to save :param path: Path to saved IR :param meta_data: Namespace with converting parameters restored from IR :param name: Name for saved IR :return: """ if name is None: name = graph.name precision = data_type_str_to_precision(graph.graph['cmd_params'].data_type) assert precision in ['FP16', 'FP32'], 'Cannot define precision for restored model!' # List items order matters, do not change it. transformation_list = [ ConvolutionWithGroupsResolver, StridedSliceMasksNormalizer, PackBinaryWeights, BlobNormalizer, ConvolutionNormalizer, KaldiRemoveMemoryOutputBackReplacementPattern, ] # We need to run some specific passes from MO back stage. apply_replacements_list(graph, transformation_list) # Transformations with enabled=False should be run manually. 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) prepare_emit_ir(graph, precision, path, name, meta_info=meta_data)
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) 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=graph.graph['mf'] if 'mf' in graph.graph else None, input_names=graph.graph['input_names'] if 'input_names' in graph.graph else [], meta_info=get_meta_info(argv)) if not (argv.framework == '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 version {} model.'.format( get_ir_version(argv))) print('[ SUCCESS ] XML file: {}.xml'.format( os.path.join(output_dir, argv.model_name))) print('[ SUCCESS ] BIN file: {}.bin'.format( os.path.join(output_dir, argv.model_name))) return 0
def save_restored_graph(graph: Graph, path: str, meta_data, name=None): """ Function to apply all necessary transforms from back stage to prepare and save restored graph and metadata. :param graph: Graph to save :param path: Path to saved IR :param meta_data: Namespace with converting parameters restored from IR :param name: Name for saved IR :return: """ if name is None: name = graph.name if 'data_type' not in meta_data: log.debug( 'Provided `meta_data` does not contain `data_type` parameter. Set `data_type`' ' parameter value to `FP32`.') # Set data_type to FP32. All restored constants will be saved in provided data type. data_type = 'FP32' # We need to specify this attribute to pass graph transformations. This information will not be saved into IR. # All constants and placeholders will be saved with same types as restored from IR graph.graph['cmd_params'].data_type = data_type else: data_type = data_type_str_to_precision( graph.graph['cmd_params'].data_type) assert data_type in ['FP16', 'FP32'], '`data_type` value {} is not supported by MO,' \ ' cannot save graph'.format(data_type) # List items order matters, do not change it. transformation_list = [ ConvolutionWithGroupsResolver, StridedSliceMasksNormalizer, PackBinaryWeights, BlobNormalizer, ConvolutionNormalizer, MarkNodesWithShapeValues, ] # We need to run some specific passes from MO back stage. apply_replacements_list(graph, transformation_list) # Transformations with enabled=False should be run manually. 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) prepare_emit_ir(graph, data_type, path, name, meta_info=meta_data, used_by_ir_reader=True)
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) 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=graph.graph['mf'] if 'mf' in graph.graph else None, input_names=graph.graph['input_names'] if 'input_names' in graph.graph else [], meta_info=get_meta_info(argv)) 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)) # This try-except is additional reinsurance that the IE # dependency search does not break the MO pipeline try: if find_ie_version(silent=True): path_to_offline_transformations = os.path.join( os.path.realpath(os.path.dirname(__file__)), 'back', 'offline_transformations.py') status = subprocess.run([ sys.executable, path_to_offline_transformations, orig_model_name ], env=os.environ, timeout=100) if status.returncode != 0 and not argv.silent: print("[ WARNING ] offline_transformations return code {}". format(status.returncode)) except Exception as e: # TODO: send error message pass 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 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" # This try-except is additional reinsurance that the IE # dependency search does not break the MO pipeline try: if not argv.legacy_ir_generation: path_to_offline_transformations = os.path.join( os.path.realpath(os.path.dirname(__file__)), 'back', 'offline_transformations.py') cmd = [ sys.executable, path_to_offline_transformations, "--input_model", orig_model_name, "--framework", argv.framework, "--transform", argv.transform ] if "compress_fp16" in argv and argv.compress_fp16: cmd += ["--compress_fp16"] # restore data_type cmd parameter argv.data_type = 'FP16' status = subprocess.run(cmd, env=os.environ) return_code = status.returncode 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 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) 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 [] # Remove temporary ie_is_available key from argv no to have it in IR ie_is_available = argv.ie_is_available del argv.ie_is_available 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" # This try-except is additional reinsurance that the IE # dependency search does not break the MO pipeline try: if not argv.legacy_ir_generation and ie_is_available: path_to_offline_transformations = os.path.join( os.path.realpath(os.path.dirname(__file__)), 'back', 'offline_transformations.py') status = subprocess.run([ sys.executable, path_to_offline_transformations, "--input_model", orig_model_name, "--framework", argv.framework, "--transform", argv.transform ], env=os.environ) return_code = status.returncode except Exception as e: return_code = "failed" log.error(e, extra={'is_warning': True}) 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 IR wasn't produced by offline_transformations step we need to fallback to IR # produced by prepare_ir. This IR needs to be renamed from XXX_tmp.xml to XXX.xml suffixes = [".xml", ".bin", ".mapping"] if return_code != 0: if len(argv.transform) != 0: # Remove temporary IR before throwing exception for suf in suffixes: path_to_file = orig_model_name + "_tmp" + suf if os.path.exists(path_to_file): os.remove(path_to_file) raise Error("Failed to apply transformations: {}".format( argv.transform)) log.error("Using fallback to produce IR.", extra={'is_warning': True}) for suf in suffixes: # remove existing files path_to_file = orig_model_name + suf if os.path.exists(path_to_file): os.remove(path_to_file) # rename tmp IR to original name os.rename(orig_model_name + "_tmp" + suf, orig_model_name + suf) else: for suf in suffixes: # 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 driver(argv, input_model, output_model_name, output_dir): meta_info = get_meta_info(argv) EltwiseChecker.enabled = False try: graph = load_kaldi_model(input_model) except Exception as e: raise Error('Model Optimizer is not able to parse Kaldi model {}. '.format(input_model) + refer_to_faq_msg(91)) from e graph.check_empty_graph('load_kaldi_nnet_model') graph.graph['cmd_params'] = argv graph.graph['fw'] = 'kaldi' if graph.graph['cmd_params'].generate_experimental_IR_V10: version = 10 else: version = 6 graph.graph['ir_version'] = 2 if argv.generate_deprecated_IR_V2 else version update_extractors_with_extensions(kaldi_type_extractors) extract_node_attrs(graph, lambda node: kaldi_extractor(node)) # --------------------------------- LOAD END ------------------------------------------------------ class_registration.apply_replacements(graph, [class_registration.ClassType.FRONT_REPLACER]) MoveEmbeddedInputsToInputs().find_and_replace_pattern(graph) graph = partial_infer(graph) ReplacePNormNodePattern().find_and_replace_pattern(graph) ReplaceMemoryOffsetNodePattern().find_and_replace_pattern(graph) ReplaceMemoryOffsetWithMemoryNodePattern().find_and_replace_pattern(graph) RemoveMemoryDuplicationPattern().find_and_replace_pattern(graph) MergeNeighborSplicePattern().find_and_replace_pattern(graph) RemoveUselessCropsPattern().find_and_replace_pattern(graph) RemoveIdentity().find_and_replace_pattern(graph) graph.clean_up() AddSelectBeforeMemoryNodePattern().find_and_replace_pattern(graph) ReplaceSpliceNodePattern().find_and_replace_pattern(graph) graph.clean_up() # The order is intentional, firstly eliminate repeated, then remove redundant FuseRepeatedReshapes().find_and_replace_pattern(graph) EliminateRedundantReshape().find_and_replace_pattern(graph) graph.clean_up() graph.check_empty_graph('partial_infer') MatMulToFullyConnected().find_and_replace_pattern(graph) graph.clean_up() SSBiasAddonForFC().find_and_replace_pattern(graph) graph.clean_up() BiasAddonForFC().find_and_replace_pattern(graph) graph.clean_up() if argv.counts: try: counts = read_counts_file(argv.counts) except Exception as e: raise Error('Model Optimizer is not able to read counts file {}'.format(argv.counts) + refer_to_faq_msg(92)) from e apply_biases_to_last_layer(graph, counts) if argv.remove_output_softmax: RemoveLastSoftMaxPattern().find_and_replace_pattern(graph) graph.clean_up() log.debug("After removing softmax") graph.print_graph_stat() LeakyReluToReluWithNegativeSlope().find_and_replace_pattern(graph) TransposeToPermute().find_and_replace_pattern(graph) DivideToEltwises().find_and_replace_pattern(graph) SubtractToEltwises().find_and_replace_pattern(graph) SimpleEltwiseToEltwiseOp().find_and_replace_pattern(graph) # Intentionally after all transformations if argv.remove_memory: CutMemory().find_and_replace_pattern(graph) graph.clean_up() ParameterToInput().find_and_replace_pattern(graph) KaldiRemoveMemoryOutputBackReplacementPattern().find_and_replace_pattern(graph) ForceStrictPrecision().find_and_replace_pattern(graph) RemoveConstOps().find_and_replace_pattern(graph) CreateConstNodesReplacement().find_and_replace_pattern(graph) RemoveOutputOps().find_and_replace_pattern(graph) prepare_emit_ir(graph, argv.data_type, output_dir, output_model_name, meta_info=meta_info) return 0
def save_restored_graph(graph: Graph, path: str, meta_data, name=None): """ Function to apply all necessary transforms from back stage to prepare and save restored graph and metadata. :param graph: Graph to save :param path: Path to saved IR :param meta_data: Namespace with converting parameters restored from IR :param name: Name for saved IR :return: """ if name is None: name = graph.name precisions = set() for op in graph.get_op_nodes(): if op.type in ('Convolution', 'MatMul'): if op.in_port(1).get_source().node.type == 'FakeQuantize': data_type = op.in_port(1).get_source().node.in_port( 0).get_source().node.soft_get('data_type', None) else: data_type = op.in_port(1).get_source().node.soft_get( 'data_type', None) if data_type is not None: precisions.add(np_data_type_to_precision(data_type)) else: log.warning( 'Cannot check data type for node {} with type {}, skip it.' .format(op.name, op.type)) precision = 'FP16' if 'FP16' in precisions else 'FP32' # We need to run some specific passes from MO back stage. # After some of them we need to clean up graph! for_graph_and_each_sub_graph_recursively( graph, ConvolutionWithGroupsResolver().find_and_replace_pattern) for_graph_and_each_sub_graph_recursively( graph, TopKNormalizer().find_and_replace_pattern) graph.clean_up() for_graph_and_each_sub_graph_recursively( graph, StridedSliceMasksNormalizer().find_and_replace_pattern) for_graph_and_each_sub_graph_recursively( graph, BlobNormalizer().find_and_replace_pattern) for_graph_and_each_sub_graph_recursively( graph, ConvolutionNormalizer().find_and_replace_pattern) 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) prepare_emit_ir(graph, precision, path, name, meta_info=meta_data)