def test_mapper(self, params):
"""Test mapper function."""
mapper = ONNXToMindSporeMapper()
converter_name, converted_params, converted_settings, _ = \
mapper.convert(params['input']['op_name'], params['input']['params'], params['input']['weights'])
assert params['expected_output']['converter_name'] == converter_name
assert params['expected_output'][
'converted_params'] == converted_params
assert isinstance(converted_settings, Setting)
def test_mapper(self):
"""Test code generation."""
onnx_info = {
"op_name":
"onnx::CumSum",
"attributes": {},
"weights": [
NodeWeight(weight_name="axis",
weight_value=np.int32(0),
weight_location=0)
]
}
template, exchange_msg, outputs_lists, outputs_mapping = ONNXToMindSporeMapper.convert(
onnx_info['op_name'], onnx_info['attributes'],
onnx_info['weights'])
exchange_msg['var_0']['variable_name'] = 'cumsum_op'
exchange_msg['var_0']['inputs'] = ['x']
fragment = Fragment(data_entity=exchange_msg,
code_template=template,
outputs=outputs_lists,
outputs_mapping=outputs_mapping)
code = fragment()
init_code = code[0]
construct_code = code[1]
self.assertEqual(init_code, [
"self.cumsum_op = P.CumSum(exclusive=False, reverse=False)",
"self.cumsum_op_axis = 0"
])
self.assertEqual(
construct_code,
["opt_cumsum_op = self.cumsum_op(x, self.cumsum_op_axis)"])
def test_save_source_file(self, get_raw_params, params):
"""Test save_source_file function."""
tree_params = params['tree_params']
out_folder = 'out_folder'
report_folder = params['report_dir']
model_name = 'model_name'
mapper = ONNXToMindSporeMapper()
tree = self._create_tree(get_raw_params=get_raw_params,
params=tree_params)
tree.save_source_files(out_folder, mapper, model_name, report_folder)
out_path = os.path.realpath(
os.path.join(out_folder, f"{model_name}.py"))
report_folder_test = report_folder if report_folder else out_folder
report_path = os.path.realpath(
os.path.join(report_folder_test, f"report_of_{model_name}.txt"))
try:
assert os.path.exists(out_path)
assert os.path.exists(report_path)
with open(out_path, 'r') as out_r:
code = out_r.read()
assert 'nn.ReLU' in code
assert 'onnx.Unknown' in code
with open(report_path, 'r') as report_r:
report = report_r.read()
assert "[UnConvert] 'onnx::Unknown' didn't convert." in report
assert "Converted Rate: 50.00%." in report
finally:
shutil.rmtree(out_folder)
if report_folder:
shutil.rmtree(report_folder)
def _generate_snippet_template(**kwargs):
"""Generate snippet template."""
template, exchange_msg, outputs_list, outputs_mapping = ONNXToMindSporeMapper._generate_snippet_template(
**kwargs)
op = kwargs.get("operation")
args = kwargs.get("converted_params", dict())
weights = kwargs.get("weights")
params = kwargs["raw_params"]
ipt_shape = params["input_shape"]
starts = SliceMapper._find_val_by_index(0, weights)
ends = SliceMapper._find_val_by_index(1, weights)
axes = SliceMapper._find_val_by_index(2, weights, np.array(list(range(len(ipt_shape)))))
steps = SliceMapper._find_val_by_index(3, weights, np.array([1 for _ in range(len(ipt_shape))]))
if not op:
raise ValueError("Can not get MindSpore operation name.")
if not weights:
raise ValueError("Can not get required params from slice.")
if axes.shape != (1,):
ordered_begin = sorted(zip(starts.tolist(), axes.tolist()), key=lambda x: x[1], reverse=False)
ordered_end = sorted(zip(ends.tolist(), axes.tolist()), key=lambda x: x[1], reverse=False)
ordered_strides = sorted(zip(steps.tolist(), axes.tolist()), key=lambda x: x[1], reverse=False)
begin = [i[0] for i in ordered_begin]
end = [min(i[0], ipt_shape[i[1]]) for i in ordered_end]
strides = [i[0] for i in ordered_strides]
else:
axis = axes.tolist()[0]
begin = [0 for _ in range(len(ipt_shape))]
end = list(ipt_shape)
strides = [1 for _ in range(len(ipt_shape))]
begin[axis] = starts.tolist()[0]
end[axis] = min(ends.tolist()[0], end[axis])
strides[axis] = steps.tolist()[0]
args['begin'] = tuple(begin)
args['end'] = tuple(end)
args['strides'] = tuple(strides)
variable_slot = "var_0"
init_template = f"self.{{{variable_slot}}} = {op}()"
init_begin = f"self.{{{variable_slot}}}_begin = {{begin}}"
init_end = f"self.{{{variable_slot}}}_end = {{end}}"
init_strides = f"self.{{{variable_slot}}}_strides = {{strides}}"
construct_template = f"opt_{{{variable_slot}}} = self.{{{variable_slot}}}" \
f"({{{ExchangeMessageKeywords.VariableScope.value.INPUTS.value}}}, " \
f"self.{{{variable_slot}}}_begin, self.{{{variable_slot}}}_end, " \
f"self.{{{variable_slot}}}_strides)"
template = reset_init_or_construct(template, variable_slot,
[init_template, init_begin, init_end, init_strides],
TemplateKeywords.INIT.value)
template = reset_init_or_construct(template, variable_slot, [construct_template],
TemplateKeywords.CONSTRUCT.value)
return template, exchange_msg, outputs_list, outputs_mapping
def _generate_snippet_template(**kwargs):
op = kwargs.get("operation")
args = kwargs.get("converted_params", dict())
if "onnx" in op or op == "P.MaxPool3D":
return ONNXToMindSporeMapper._generate_snippet_template(**kwargs)
ms_opt_shape = PoolMapper._get_ms_opt_shape(**kwargs)
tensor_opt_shape = kwargs['raw_params']['output_shape']
tensor_ipt_shape = kwargs['raw_params']['input_shape']
kernel_shape = kwargs['raw_params']['kernel_shape']
dilations = kwargs['raw_params'].get('dilations', (1, 1))
strides = kwargs['raw_params']['strides']
if not op:
raise ValueError("Can not get MindSpore operation name.")
variable_slot = "var_0"
init_template = f"self.{{{variable_slot}}} = {op}({', '.join(['%s={%s}' % (p, p) for p in args])})"
construct_template = f"opt_{{{variable_slot}}} = self.{{{variable_slot}}}(opt_{{{variable_slot}}})"
init_template_pad, construct_template_pad, paddings = \
PoolMapper._generate_pad_init_and_construct(tensor_opt_shape, tensor_ipt_shape,
ms_opt_shape, variable_slot,
kernel_shape, dilations, strides)
template = {
variable_slot: {
TemplateKeywords.INIT.value:
[init_template_pad, init_template],
TemplateKeywords.CONSTRUCT.value:
[construct_template_pad, construct_template]
}
}
args['paddings'] = paddings
exchange_msg = {
variable_slot: {
ExchangeMessageKeywords.VariableScope.value.OPERATION.value:
op,
ExchangeMessageKeywords.VariableScope.value.VARIABLE_NAME.value:
None,
ExchangeMessageKeywords.VariableScope.value.OUTPUT_TYPE.value:
ExchangeMessageKeywords.VariableScope.value.TSR_TYPE.value,
ExchangeMessageKeywords.VariableScope.value.INPUTS.value: [],
ExchangeMessageKeywords.VariableScope.value.ARGS.value:
args,
ExchangeMessageKeywords.VariableScope.value.WEIGHTS.value:
dict(),
ExchangeMessageKeywords.VariableScope.value.TRAINABLE_PARAMS.value:
dict()
}
}
outputs_list = [f"opt_{{{variable_slot}}}"]
outputs_mapping = ((0, 0), )
return template, exchange_msg, outputs_list, outputs_mapping
def _generate_snippet_template(**kwargs):
template, exchange_msg, outputs_list, outputs_mapping = ONNXToMindSporeMapper._generate_snippet_template(
**kwargs)
raw_params = kwargs.get("raw_params", dict())
kernel_size = raw_params.get("kernel_shape")
dim = len(kernel_size)
if dim == 3:
return template, exchange_msg, outputs_list, outputs_mapping
return ConvBackPropInputMapper.generate_snippet_template(**kwargs)
def _generate_snippet_template(**kwargs):
template, exchange_msg, outputs_list, outputs_mapping = ONNXToMindSporeMapper._generate_snippet_template(
**kwargs)
op = kwargs.get("operation")
args = kwargs.get("converted_params")
weights = kwargs.get("weights")
trainable_params = kwargs.get("trainable_params", dict())
if not weights:
return template, exchange_msg, outputs_list, outputs_mapping
tensor = PowMapper._find_val_by_index(0, weights)
input_shape = tensor.shape
input_dtype = tensor.dtype
input_location = PowMapper._find_location_by_index(0, weights)
variable_slot = "var_0"
init_template = f"self.{{{variable_slot}}} = {op}()"
inputs_in_construct = [f"{{{ExchangeMessageKeywords.VariableScope.value.INPUTS.value}}}"]
if input_location != -1:
inputs_in_construct.insert(input_location, f"self.{{{variable_slot}}}_input_weight")
if input_shape:
args["input_shape"] = input_shape
args["input_dtype"] = input_dtype
init_tensor = f"self.{{{variable_slot}}}_input_weight = " \
f"Parameter(Tensor(np.random.uniform(0, 1, {{input_shape}}).astype(np.{{input_dtype}})), " \
f"name=None)"
else:
args["input_value"] = tensor.tolist()
init_tensor = f"self.{{{variable_slot}}}_input_weight = {{input_value}}"
construct_template = f"opt_{{{variable_slot}}} = self.{{{variable_slot}}}" \
f"({', '.join(inputs_in_construct)})"
template = reset_init_or_construct(template, variable_slot, [init_template, init_tensor],
TemplateKeywords.INIT.value)
template = reset_init_or_construct(template, variable_slot, [construct_template],
TemplateKeywords.CONSTRUCT.value)
exchange_msg = {
variable_slot: {
ExchangeMessageKeywords.VariableScope.value.OPERATION.value: op,
ExchangeMessageKeywords.VariableScope.value.VARIABLE_NAME.value: None,
ExchangeMessageKeywords.VariableScope.value.OUTPUT_TYPE.value:
ExchangeMessageKeywords.VariableScope.value.TSR_TYPE.value,
ExchangeMessageKeywords.VariableScope.value.INPUTS.value: [],
ExchangeMessageKeywords.VariableScope.value.ARGS.value: args,
ExchangeMessageKeywords.VariableScope.value.WEIGHTS.value: weights,
ExchangeMessageKeywords.VariableScope.value.TRAINABLE_PARAMS.value: trainable_params
}
}
outputs_list = [f"opt_{{{variable_slot}}}"]
outputs_mapping = ((0, 0),)
return template, exchange_msg, outputs_list, outputs_mapping
def _generate_snippet_template(**kwargs):
template, exchange_msg, outputs_list, outputs_mapping = ONNXToMindSporeMapper._generate_snippet_template(
**kwargs)
raw_params = kwargs.get("raw_params")
perm = raw_params["perm"]
variable_slot = "var_0"
construct_template = f"opt_{{{variable_slot}}} = self.{{{variable_slot}}}" \
f"({{{ExchangeMessageKeywords.VariableScope.value.INPUTS.value}}}, {tuple(perm)})"
template = reset_init_or_construct(template, variable_slot,
[construct_template],
TemplateKeywords.CONSTRUCT.value)
return template, exchange_msg, outputs_list, outputs_mapping
def _generate_snippet_template(**kwargs):
template, exchange_msg, outputs_list, outputs_mapping = ONNXToMindSporeMapper._generate_snippet_template(
**kwargs)
op = kwargs.get("operation")
args = kwargs.get("converted_params")
weights = kwargs.get("weights")
trainable_params = kwargs.get('trainable_params', dict())
if not op:
raise ValueError("Can not get MindSpore operation name.")
if not weights:
return template, exchange_msg, outputs_list, outputs_mapping
variable_slot = "var_0"
init_template = f"self.{{{variable_slot}}} = {op}({', '.join(['%s={%s}' % (p, p) for p in args])})"
# Note: adding weight shape to args is now deprecated due to conflict of partial weights share processing.
variable_slot_param_name = f"{variable_slot}/w"
init_tensor = f"self.{{{variable_slot}}}_w = {{{variable_slot_param_name}}}"
construct_template = f"opt_{{{variable_slot}}} = self.{{{variable_slot}}}" \
f"({{{ExchangeMessageKeywords.VariableScope.value.INPUTS.value}}}," \
f"self.{{{variable_slot}}}_w)"
template = {
variable_slot: {
TemplateKeywords.INIT.value: [init_template, init_tensor],
TemplateKeywords.CONSTRUCT.value: [construct_template]
}
}
exchange_msg = {
variable_slot: {
ExchangeMessageKeywords.VariableScope.value.OPERATION.value:
op,
ExchangeMessageKeywords.VariableScope.value.VARIABLE_NAME.value:
None,
ExchangeMessageKeywords.VariableScope.value.OUTPUT_TYPE.value:
ExchangeMessageKeywords.VariableScope.value.TSR_TYPE.value,
ExchangeMessageKeywords.VariableScope.value.INPUTS.value: [],
ExchangeMessageKeywords.VariableScope.value.ARGS.value:
args,
ExchangeMessageKeywords.VariableScope.value.WEIGHTS.value:
weights,
ExchangeMessageKeywords.VariableScope.value.TRAINABLE_PARAMS.value:
trainable_params,
ExchangeMessageKeywords.VariableScope.value.PARAMETERS_DECLARED.value:
{
"w": ""
}
}
}
outputs_list = [f"opt_{{{variable_slot}}}"]
outputs_mapping = ((0, 0), )
return template, exchange_msg, outputs_list, outputs_mapping
def _generate_snippet_template(**kwargs):
template, exchange_msg, outputs_list, outputs_mapping = ONNXToMindSporeMapper._generate_snippet_template(
**kwargs)
raw_params = kwargs.get('raw_params', dict())
trans_a = raw_params.get('transA', 0)
if not trans_a:
return template, exchange_msg, outputs_list, outputs_mapping
op = kwargs.get("operation")
args = kwargs.get("converted_params")
weights = kwargs.get("weights")
trainable_params = kwargs.get('trainable_params', dict())
if not op:
raise ValueError("Can not get MindSpore operation name.")
input_rank = len(raw_params['input_shape'])
input_perm = [i for i in range(input_rank)]
input_perm[-2], input_perm[-1] = input_perm[-1], input_perm[-2]
variable_slot = "var_0"
init_input_perm = f"self.{{{variable_slot}}}_input_perm = {{input_perm}}"
init_template = f"self.{{{variable_slot}}} = {op}({', '.join(['%s={%s}' % (p, p) for p in args])})"
inputs_in_construct = [f"{{{ExchangeMessageKeywords.VariableScope.value.INPUTS.value}}}",
f"self.{{{variable_slot}}}_input_perm"]
args['input_perm'] = tuple(input_perm)
construct_transpose = f"opt_{{{variable_slot}}}_transpose = P.Transpose()({', '.join(inputs_in_construct)})"
construct_template = f"opt_{{{variable_slot}}} = self.{{{variable_slot}}}(opt_{{{variable_slot}}}_transpose)"
template = reset_init_or_construct(template, variable_slot, [init_input_perm, init_template],
TemplateKeywords.INIT.value)
template = reset_init_or_construct(template, variable_slot, [construct_transpose, construct_template],
TemplateKeywords.CONSTRUCT.value)
exchange_msg = {
variable_slot: {
ExchangeMessageKeywords.VariableScope.value.OPERATION.value: op,
ExchangeMessageKeywords.VariableScope.value.VARIABLE_NAME.value: None,
ExchangeMessageKeywords.VariableScope.value.OUTPUT_TYPE.value:
ExchangeMessageKeywords.VariableScope.value.TSR_TYPE.value,
ExchangeMessageKeywords.VariableScope.value.INPUTS.value: [],
ExchangeMessageKeywords.VariableScope.value.ARGS.value: args,
ExchangeMessageKeywords.VariableScope.value.WEIGHTS.value: weights,
ExchangeMessageKeywords.VariableScope.value.TRAINABLE_PARAMS.value: trainable_params
}
}
outputs_list = [f"opt_{{{variable_slot}}}"]
outputs_mapping = ((0, 0),)
return template, exchange_msg, outputs_list, outputs_mapping
def _generate_snippet_template(**kwargs):
template, exchange_msg, outputs_list, outputs_mapping = ONNXToMindSporeMapper._generate_snippet_template(
**kwargs)
op = kwargs.get("operation")
args = kwargs.get("converted_params")
weights = kwargs.get("weights")
trainable_params = kwargs.get("trainable_params", dict())
if not weights:
variable_slot = "var_0"
construct_template = \
f"opt_{{{variable_slot}}} = {op}()({{{ExchangeMessageKeywords.VariableScope.value.INPUTS.value}}}) "
template = {
variable_slot: {
TemplateKeywords.INIT.value: [],
TemplateKeywords.CONSTRUCT.value: [construct_template]
}
}
return template, exchange_msg, outputs_list, outputs_mapping
return DivMapper._generate_snippet_template_with_weights(
weights, args, template, op, trainable_params)
def _generate_snippet_template(**kwargs):
template, exchange_msg, outputs_list, outputs_mapping = ONNXToMindSporeMapper._generate_snippet_template(
**kwargs)
op = kwargs.get("operation")
args = kwargs.get("converted_params")
weights = kwargs.get("weights")
trainable_params = kwargs.get('trainable_params', dict())
if not op:
raise ValueError("Can not get MindSpore operation name.")
if not weights:
return template, exchange_msg, outputs_list, outputs_mapping
tensor = AddMapper._find_val_by_index(0, weights)
bias_shape = tensor.shape
bias_location = AddMapper._find_location_by_index(0, weights)
variable_slot = "var_0"
init_template = f"self.{{{variable_slot}}} = {op}({', '.join(['%s={%s}' % (p, p) for p in args])})"
inputs_in_construct = [
f"{{{ExchangeMessageKeywords.VariableScope.value.INPUTS.value}}}"
]
if bias_location != -1:
inputs_in_construct.insert(bias_location,
f"self.{{{variable_slot}}}_bias")
if bias_shape:
# Note: adding weight shape to args is now deprecated due to conflict of partial weights share processing.
variable_slot_param_name = f"{variable_slot}/bias"
init_tensor = f"self.{{{variable_slot}}}_bias = {{{variable_slot_param_name}}}"
else:
args["bias_value"] = tensor.tolist()
init_tensor = f"self.{{{variable_slot}}}_bias = {{bias_value}}"
construct_template = f"opt_{{{variable_slot}}} = self.{{{variable_slot}}}" \
f"({', '.join(inputs_in_construct)})"
template = {
variable_slot: {
TemplateKeywords.INIT.value: [init_template, init_tensor],
TemplateKeywords.CONSTRUCT.value: [construct_template]
}
}
exchange_msg = {
variable_slot: {
ExchangeMessageKeywords.VariableScope.value.OPERATION.value:
op,
ExchangeMessageKeywords.VariableScope.value.VARIABLE_NAME.value:
None,
ExchangeMessageKeywords.VariableScope.value.OUTPUT_TYPE.value:
ExchangeMessageKeywords.VariableScope.value.TSR_TYPE.value,
ExchangeMessageKeywords.VariableScope.value.INPUTS.value: [],
ExchangeMessageKeywords.VariableScope.value.ARGS.value:
args,
ExchangeMessageKeywords.VariableScope.value.WEIGHTS.value:
weights,
ExchangeMessageKeywords.VariableScope.value.TRAINABLE_PARAMS.value:
trainable_params
}
}
if bias_shape:
exchange_msg[variable_slot][ExchangeMessageKeywords.VariableScope.
value.PARAMETERS_DECLARED.value] = {
"bias": ""
}
outputs_list = [f"opt_{{{variable_slot}}}"]
outputs_mapping = ((0, 0), )
return template, exchange_msg, outputs_list, outputs_mapping
def test_mapper(self, params):
"""Test mapper function."""
_, _, _, _ = ONNXToMindSporeMapper.convert(params['input']['op_name'],
params['input']['params'],
params['input']['weights'])
