def initialize(self):
"""Initialize the OnnxDataLoader."""
# Parse ONNX Graph level info
self._parse_graph()
# 1. parse all tensors
self._parse_tensors()
# 2. parse all nodes, note that parse tensors must be done as nodes require tensor info
# to process the node weight sharing.
self._parse_nodes()
# 3. parse value info (incl. node output shape)
if self._is_infer_shape:
try:
self._infer_model()
self._parse_value_info()
self._parse_node_output_shape()
except Exception as e:
log.error(str(e))
log.exception(e)
raise e
# 4. Optimize graph to eliminate some nodes.
self._find_nodes_to_be_eliminated()
# 5. build nodes connections
self.build_nodes_connection()
# 6. Run onnx model to fetch actual value of eliminated nodes.
self._fetch_eliminated_nodes_value()
def _trace_torch_graph(self, input_shape):
"""
Trace torch computational graph.
Args:
input_shape (tuple): Shape.
Returns:
object, pytorch graph.
"""
import torch
from torch.onnx import OperatorExportTypes
from .torch_utils import OverloadTorchModuleTemporarily
from .torch_utils import create_autograd_variable
from .torch_utils import onnx_tracer
batched_sample = create_autograd_variable(torch.rand(*input_shape))
try:
# Assign execution mode to eval.
self.model.eval()
with OverloadTorchModuleTemporarily() as _:
# In pytorch higher version, trace function has a known.
graph = onnx_tracer(self.model, batched_sample,
OperatorExportTypes.ONNX)
return graph
except RuntimeError as error:
log.error(str(error))
log.exception(error)
raise error
def initialize(self):
"""Initialize the OnnxDataLoader."""
# check init conditions met
if not self._check_initialization():
err = ModuleNotFoundError("Unable to Find ONNX Model")
log.error(str(err))
log.exception(err)
# 1. parse all nodes
self._parse_nodes()
# 2. parse value info (incl. node output shape)
if self._is_infer_shape:
try:
self._infer_model()
self._parse_value_info()
self._parse_node_output_shape()
except Exception as e:
log.error(str(e))
log.exception(e)
raise e
# 3. parse all tensors
self._parse_tensors()
# 4. Optimize graph to eliminate some nodes.
self._find_nodes_to_be_eliminated()
# 5. build nodes connections
self.build_nodes_connection()
# 6. Run onnx model to fetch actual value of eliminated nodes.
self._fetch_eliminated_nodes_value()
def _run(in_files, model_file, shape, input_nodes, output_nodes, out_dir,
report, project_path):
"""
Run converter command.
Args:
in_files (str): The file path or directory to convert.
model_file(str): The pytorch .pth to convert on graph based schema.
shape(list): The input tensor shape of module_file.
input_nodes(str): The input node(s) name of Tensorflow model, split by ','.
output_nodes(str): The output node(s) name of Tensorflow model, split by ','.
out_dir (str): The output directory to save converted file.
report (str): The report file path.
project_path(str): Pytorch scripts project path.
"""
if in_files:
files_config = {
'root_path': in_files,
'in_files': [],
'outfile_dir': out_dir,
'report_dir': report if report else out_dir
}
if os.path.isfile(in_files):
files_config['root_path'] = os.path.dirname(in_files)
files_config['in_files'] = [in_files]
else:
for root_dir, _, files in os.walk(in_files):
for file in files:
files_config['in_files'].append(
os.path.join(root_dir, file))
main(files_config)
log_console.info("\n")
log_console.info("MindConverter: conversion is completed.")
log_console.info("\n")
elif model_file:
file_config = {
'model_file': model_file,
'shape': shape if shape else [],
'input_nodes': input_nodes,
'output_nodes': output_nodes,
'outfile_dir': out_dir,
'report_dir': report if report else out_dir
}
if project_path:
paths = sys.path
if project_path not in paths:
sys.path.append(project_path)
main_graph_base_converter(file_config)
log_console.info("\n")
log_console.info("MindConverter: conversion is completed.")
log_console.info("\n")
else:
error_msg = "`--in_file` and `--model_file` should be set at least one."
error = FileNotFoundError(error_msg)
log.error(str(error))
log.exception(error)
raise error
def check_dependency_integrity(*packages):
"""Check dependency package integrity."""
try:
for pkg in packages:
import_module(pkg)
return True
except ImportError as e:
log.exception(e)
return False
def _f(arch, mapper):
try:
output = func(arch, mapper=mapper)
except cls.raise_from() as e:
error = cls(msg=msg)
log.error(msg)
log.exception(e)
raise error from e
return output
def _f(arch, model_path, **kwargs):
try:
output = func(arch, model_path=model_path, **kwargs)
except cls.raise_from() as e:
error = cls(msg=msg)
log.error(msg)
log.exception(e)
raise error from e
return output
def _f(file_config):
try:
func(file_config=file_config)
except cls.raise_from() as e:
error = cls(msg=msg)
detail_info = f"Error detail: {str(e)}"
log_console.error(str(error))
log_console.error(detail_info)
log.exception(e)
sys.exit(-1)
def save_source_files(self, out_folder: str, mapper: Mapper,
model_name: str,
report_folder: str = None,
scope_name_map: dict = None) -> NoReturn:
"""
Save source codes to target folder.
Args:
report_folder (str): Report folder.
mapper (Mapper): Mapper of third party framework and mindspore.
model_name(str): Name of Converted model.
out_folder (str): Output folder.
scope_name_map(str): Scope name map of tensorflow.
"""
if scope_name_map:
self._scope_name_map = scope_name_map
try:
self._adjust_structure()
code_fragments = self._generate_codes(mapper)
except (NodeInputTypeNotSupport, ScriptGenerateFail, ReportGenerateFail) as e:
log.error("Error occur when generating codes.")
raise e
out_folder = os.path.realpath(out_folder)
if not report_folder:
report_folder = out_folder
else:
report_folder = os.path.realpath(report_folder)
if not os.path.exists(out_folder):
os.makedirs(out_folder, self.modes_usr)
if not os.path.exists(report_folder):
os.makedirs(report_folder, self.modes_usr)
for file_name in code_fragments:
code, report = code_fragments[file_name]
try:
with os.fdopen(os.open(os.path.realpath(os.path.join(out_folder, f"{model_name}.py")),
self.flags, self.modes), 'w') as file:
file.write(code)
except IOError as error:
log.error(str(error))
log.exception(error)
raise error
try:
with os.fdopen(os.open(os.path.realpath(os.path.join(report_folder,
f"report_of_{model_name}.txt")),
self.flags, stat.S_IRUSR), "w") as rpt_f:
rpt_f.write(report)
except IOError as error:
log.error(str(error))
log.exception(error)
raise error
def __new__(cls, *args, **kwargs):
"""Control the create action of graph."""
model_param = args[0] if args else kwargs.get(
cls._REQUIRED_PARAM_OF_MODEL)
if not model_param:
error = ValueError(f"`{cls._REQUIRED_PARAM_OF_MODEL}` "
f"can not be None.")
log.error(str(error))
log.exception(error)
raise error
return super(BaseGraph, cls).__new__(cls)
def _f(graph_path, sample_shape, output_folder, report_folder):
try:
func(graph_path=graph_path,
sample_shape=sample_shape,
output_folder=output_folder,
report_folder=report_folder)
except cls.raise_from() as e:
error = cls(msg=msg)
detail_info = f"Error detail: {str(e)}"
log_console.error(str(error))
log_console.error(detail_info)
log.exception(e)
sys.exit(-1)
def _f(*args, **kwargs):
try:
output = func(*args, **kwargs)
except cls.raise_from() as e:
error = cls(msg=msg)
error_code = e.error_code() if isinstance(e, MindConverterException) else None
error.root_exception_error_code = error_code
log.error(msg)
log.exception(e)
raise error
except Exception as e:
log.error(msg)
log.exception(e)
raise e
return output
def _f(graph_path: str,
sample_shape: tuple,
output_folder: str,
report_folder: str = None):
# Check whether pytorch is installed.
if not find_spec("torch"):
error = ModuleNotFoundError(
"PyTorch is required when using graph based "
"scripts converter, and PyTorch vision must "
"be consisted with model generation runtime.")
log.error(str(error))
log.exception(error)
raise error
func(graph_path=graph_path,
sample_shape=sample_shape,
output_folder=output_folder,
report_folder=report_folder)
def normalize_dict_key(d):
"""
Normalize dictionary key.
Note:
The normalization is removing :0 in each node or output name.
Args:
d (dict): Dictionary where keys are node/output names.
Returns:
dict, normalized dictionary.
"""
if not isinstance(d, (dict, OrderedDict)):
error_msg = "Error occurs in normalizing dictionary key.\
Object passed in is not a dictionary."
error = TypeError(error_msg)
log.error(error_msg)
log.exception(error)
raise error
new_d = None
if isinstance(d, dict):
new_d = {}
for key_old in d.keys():
key_new = key_old.split(':')[0]
new_d[key_new] = d.get(key_old)
if isinstance(d, OrderedDict):
new_d = OrderedDict()
for key_old in d.keys():
key_new = key_old.split(':')[0]
new_d[key_new] = d.get(key_old)
if not new_d:
error_msg = "Error occurs in normalizing dictionary key."
error = ValueError(error_msg)
log.error(error_msg)
log.exception(error)
raise error
return new_d
def _f(*args, **kwargs):
try:
res = func(*args, **kwargs)
except cls.raise_from() as e:
error = cls() if not msg else cls(msg=msg)
detail_info = str(e)
if not isinstance(e, MindConverterException):
detail_info = cls.normalize_error_msg(str(e))
log.error(error)
log_console.error("\n")
log_console.error(detail_info)
log_console.error("\n")
log.exception(e)
sys.exit(0)
except ModuleNotFoundError as e:
detail_info = "Error detail: Required package not found, please check the runtime environment."
log_console.error("\n")
log_console.error(str(e))
log_console.error(detail_info)
log_console.error("\n")
log.exception(e)
sys.exit(0)
return res
def _f(*args, **kwargs):
try:
res = func(*args, **kwargs)
except cls.raise_from() as e:
error = cls() if not msg else cls(msg=msg)
detail_info = str(e)
only_console = False
if not isinstance(e, MindConverterException):
detail_info = cls.normalize_error_msg(str(e))
else:
only_console = e.only_console
log_console.error(detail_info, only_console=only_console)
if not only_console:
log.error(error)
log.exception(e)
log_console.warning(get_lib_notice_info())
sys.exit(-1)
except ModuleNotFoundError as e:
detail_info = "Error detail: Required package not found, please check the runtime environment."
log_console.error(f"{str(e)}\n{detail_info}")
log.exception(e)
log_console.warning(get_lib_notice_info())
sys.exit(-1)
return res
def initialize(self):
"""Initialize the OnnxDataLoader."""
# check init conditions met
if not self._check_initialization():
err = ModuleNotFoundError("Unable to Find ONNX Model")
log.error(str(err))
log.exception(err)
# 1. parse all nodes
self._parse_nodes()
# 2. parse value info (incl. node output shape)
if self._is_infer_shape:
try:
self._infer_model()
except Exception as e:
log.error(str(e))
log.exception(e)
raise e
if self.inferred_model:
try:
self._parse_value_info()
except Exception as e:
log.error(str(e))
log.exception(e)
raise e
try:
self._parse_node_output_shape()
except Exception as e:
log.error(str(e))
log.exception(e)
raise e
# 3. parse all tensors
self._parse_tensors()
# 4. build nodes connections
self.build_nodes_connection()
