def validate(platform, model_file, weight_file, input_file, mace_out_file,
device_type, input_shape, output_shape, input_data_format_str,
output_data_format_str, input_node, output_node,
validation_threshold, input_data_type, backend,
validation_outputs_data, log_file):
input_names = [name for name in input_node.split(',')]
input_shape_strs = [shape for shape in input_shape.split(':')]
input_shapes = [[int(x) for x in common.split_shape(shape)]
for shape in input_shape_strs]
output_shape_strs = [shape for shape in output_shape.split(':')]
output_shapes = [[int(x) for x in common.split_shape(shape)]
for shape in output_shape_strs]
input_data_formats = [df for df in input_data_format_str.split(',')]
output_data_formats = [df for df in output_data_format_str.split(',')]
if input_data_type:
input_data_types = [
data_type for data_type in input_data_type.split(',')
]
else:
input_data_types = ['float32'] * len(input_names)
output_names = [name for name in output_node.split(',')]
assert len(input_names) == len(input_shapes)
if not isinstance(validation_outputs_data, list):
if os.path.isfile(validation_outputs_data) or \
validation_outputs_data.startswith("http://") or \
validation_outputs_data.startswith("https://"):
validation_outputs = [validation_outputs_data]
else:
validation_outputs = []
else:
validation_outputs = validation_outputs_data
if validation_outputs:
validate_with_file(platform, device_type, output_names, output_shapes,
mace_out_file, validation_outputs,
validation_threshold, log_file)
elif platform == 'tensorflow':
validate_tf_model(platform, device_type, model_file, input_file,
mace_out_file, input_names, input_shapes,
input_data_formats, output_names, output_shapes,
output_data_formats, validation_threshold,
input_data_types, log_file)
elif platform == 'caffe':
validate_caffe_model(platform, device_type, model_file, input_file,
mace_out_file, weight_file, input_names,
input_shapes, input_data_formats, output_names,
output_shapes, output_data_formats,
validation_threshold, log_file)
elif platform == 'onnx':
validate_onnx_model(platform, device_type, model_file, input_file,
mace_out_file, input_names, input_shapes,
input_data_formats, output_names, output_shapes,
output_data_formats, validation_threshold,
input_data_types, backend, log_file)
elif platform == 'megengine':
validate_megengine_model(platform, device_type, model_file, input_file,
mace_out_file, input_names, input_shapes,
input_data_formats, output_names,
output_shapes, output_data_formats,
validation_threshold, input_data_types,
log_file)
def generate_input_data(input_file, input_node, input_shape, input_ranges,
input_data_type):
input_names = [name for name in input_node.split(',')]
input_shapes = [shape for shape in input_shape.split(':')]
if input_ranges:
input_ranges = [r for r in input_ranges.split(':')]
else:
input_ranges = ["-1,1"] * len(input_names)
print("The scope of generated data: ", input_ranges)
if input_data_type:
input_data_types = [
data_type for data_type in input_data_type.split(',')
]
else:
input_data_types = ['float32'] * len(input_names)
assert len(input_names) == len(input_shapes) == len(input_ranges) == len(
input_data_types) # noqa
for i in range(len(input_names)):
shape = [int(x) for x in common.split_shape(input_shapes[i])]
input_range = [float(x) for x in input_ranges[i].split(',')]
generate_data(input_names[i], shape, input_file, input_range,
input_data_types[i])
six.print_("Generate input file done.")
def get_output_map(self, target_abi, output_nodes, output_shapes,
model_output_dir):
output_map = {}
for i in range(len(output_nodes)):
output_name = output_nodes[i]
formatted_name = common.formatted_file_name(
"model_out", output_name)
if target_abi != "host":
if os.path.exists("%s/%s" %
(model_output_dir, formatted_name)):
sh.rm("-rf", "%s/%s" % (model_output_dir, formatted_name))
self.pull_from_data_dir(formatted_name, model_output_dir)
output_file_path = os.path.join(model_output_dir, formatted_name)
output_shape = [
int(x) for x in common.split_shape(output_shapes[i])
]
output_map[output_name] = np.fromfile(
output_file_path, dtype=np.float32).reshape(output_shape)
return output_map
def gen_input(model_output_dir,
input_nodes,
input_shapes,
input_files=None,
input_ranges=None,
input_data_types=None,
input_data_map=None,
input_file_name="model_input"):
for input_name in input_nodes:
formatted_name = common.formatted_file_name(input_file_name,
input_name)
if os.path.exists("%s/%s" % (model_output_dir, formatted_name)):
sh.rm("%s/%s" % (model_output_dir, formatted_name))
input_file_list = []
if isinstance(input_files, list):
input_file_list.extend(input_files)
else:
input_file_list.append(input_files)
if input_data_map:
for i in range(len(input_nodes)):
dst_input_file = model_output_dir + '/' + \
common.formatted_file_name(input_file_name,
input_nodes[i])
input_name = input_nodes[i]
common.mace_check(
input_name in input_data_map, common.ModuleName.RUN,
"The preprocessor API in PrecisionValidator"
" script should return all inputs of model")
if input_data_types[i] == 'float32':
input_data = np.array(input_data_map[input_name],
dtype=np.float32)
elif input_data_types[i] == 'int32':
input_data = np.array(input_data_map[input_name],
dtype=np.int32)
else:
common.mace_check(
False, common.ModuleName.RUN,
'Do not support input data type %s' % input_data_types[i])
common.mace_check(
list(map(int, common.split_shape(input_shapes[i]))) == list(
input_data.shape), common.ModuleName.RUN,
"The shape return from preprocessor API of"
" PrecisionValidator script is not same with"
" model deployment file. %s vs %s" %
(str(input_shapes[i]), str(input_data.shape)))
input_data.tofile(dst_input_file)
elif len(input_file_list) != 0:
input_name_list = []
if isinstance(input_nodes, list):
input_name_list.extend(input_nodes)
else:
input_name_list.append(input_nodes)
common.mace_check(
len(input_file_list) == len(input_name_list),
common.ModuleName.RUN,
'If input_files set, the input files should '
'match the input names.')
for i in range(len(input_file_list)):
if input_file_list[i] is not None:
dst_input_file = model_output_dir + '/' + \
common.formatted_file_name(input_file_name,
input_name_list[i])
if input_file_list[i].startswith("http://") or \
input_file_list[i].startswith("https://"):
six.moves.urllib.request.urlretrieve(
input_file_list[i], dst_input_file)
else:
sh.cp("-f", input_file_list[i], dst_input_file)
else:
# generate random input files
input_nodes_str = ",".join(input_nodes)
input_shapes_str = ":".join(input_shapes)
input_ranges_str = ":".join(input_ranges)
input_data_types_str = ",".join(input_data_types)
generate_input_data("%s/%s" % (model_output_dir, input_file_name),
input_nodes_str, input_shapes_str,
input_ranges_str, input_data_types_str)
