def save_model_to_code(namespace, model, params, model_checksum,
params_checksum, device, output, gencode_params):
util.mkdir_p(output)
cwd = os.path.dirname(__file__)
j2_env = Environment(loader=FileSystemLoader(cwd + "/template"),
trim_blocks=True)
j2_env.filters["stringfy"] = stringfy
template_name = "tensor_source.jinja2"
counter = 0
for tensor in model.tensors:
# convert tensor
source = j2_env.get_template(template_name).render(
tensor=tensor,
tensor_id=counter,
tag=namespace,
)
with open(output + "/tensor" + str(counter) + ".cc", "w") as f:
f.write(source)
counter += 1
if gencode_params:
template_name = "tensor_data.jinja2"
source = j2_env.get_template(template_name).render(
tag=namespace, model_data_size=len(params), model_data=params)
with open(output + "/tensor_data.cc", "w") as f:
f.write(source)
template_name = "operator.jinja2"
counter = 0
op_size = len(model.op)
for start in range(0, op_size, 10):
source = j2_env.get_template(template_name).render(
start=start,
end=min(start + 10, op_size),
net=model,
tag=namespace,
device=device.value,
)
with open(output + "/op" + str(counter) + ".cc", "w") as f:
f.write(source)
counter += 1
# generate model source files
build_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
template_name = "model.jinja2"
checksum = "{},{}".format(model_checksum, params_checksum)
source = j2_env.get_template(template_name).render(net=model,
tag=namespace,
checksum=checksum,
build_time=build_time)
with open(output + "/model.cc", "w") as f:
f.write(source)
template_name = 'model_header.jinja2'
source = j2_env.get_template(template_name).render(tag=namespace, )
with open(output + "/" + namespace + '.h', "w") as f:
f.write(source)
def gen_mace_engine_factory(model_name, embed_model_data, output):
util.mkdir_p(output)
cwd = os.path.dirname(__file__)
j2_env = Environment(loader=FileSystemLoader(cwd + "/template"),
trim_blocks=True)
# generate mace_run BUILD file
template_name = 'mace_engine_factory.h.jinja2'
model_name = list(model_name)
source = j2_env.get_template(template_name).render(
model_tags=model_name,
embed_model_data=embed_model_data,
)
with open(output + '/mace_engine_factory.h', "w") as f:
f.write(source)
def convert(conf, output):
for model_name, model_conf in conf["models"].items():
model_output = output + "/" + model_name + "/model"
org_model_dir = output + "/" + model_name + "/org_model"
util.mkdir_p(model_output)
util.mkdir_p(org_model_dir)
model_conf = normalize_model_config(model_conf)
model_file = util.download_or_get_model(
model_conf[ModelKeys.model_file_path], # noqa
model_conf[ModelKeys.model_sha256_checksum], # noqa
output + "/" + model_name + "/org_model")
model_conf[ModelKeys.model_file_path] = model_file
if ModelKeys.weight_file_path in model_conf:
weight_file = util.download_or_get_model(
model_conf[ModelKeys.weight_file_path],
model_conf[ModelKeys.weight_sha256_checksum], "/tmp/")
model_conf[ModelKeys.weight_file_path] = weight_file
# TODO: remove the following after quantize tool is made
if ModelKeys.quantize_range_file in model_conf:
range_file = util.download_or_get_model(
model_conf[ModelKeys.quantize_range_file], "", model_output)
model_conf[ModelKeys.quantize_range_file] = range_file
mace_model = convert_model(model_conf)
try:
visualizer = visualize_model.ModelVisualizer(
model_name, mace_model, model_output)
visualizer.save_html()
except: # noqa
print("Failed to visualize model:", sys.exc_info())
model, params = merge_params(mace_model)
output_model_file = model_output + "/" + model_name + ".pb"
output_params_file = model_output + "/" + model_name + ".data"
with open(output_model_file, "wb") as f:
f.write(model.SerializeToString())
with open(output_params_file, "wb") as f:
f.write(bytearray(params))
with open(output_model_file + "_txt", "w") as f:
f.write(str(model))
def save_model_to_file(model_name, model, params, output):
util.mkdir_p(output)
with open(output + "/" + model_name + ".pb", "wb") as f:
f.write(model.SerializeToString())
with open(output + "/" + model_name + ".data", "wb") as f:
f.write(params)
def run_model_for_device(flags, args, dev, model_name, model_conf):
runtime = flags.runtime
target_abi = flags.target_abi
install_dir = run_target.default_install_dir(target_abi) + "/" + model_name
sysdir = install_dir + "/interior"
dev.mkdir(sysdir)
if not runtime:
runtime = model_conf[ModelKeys.runtime]
if runtime == DeviceType.CPU_GPU:
runtime = DeviceType.GPU
else:
runtime = config_parser.parse_device_type(runtime)
# install models to devices
workdir = flags.output + "/" + model_name
model_file = model_name + ".pb"
model_data_file = model_name + ".data"
model_path = workdir + "/model/" + model_file
model_data_path = workdir + "/model/" + model_data_file
if os.path.exists(model_path) and os.path.exists(model_data_path):
dev.install(Target(model_path), install_dir)
dev.install(Target(model_data_path), install_dir)
else:
MaceLogger.warning("No models exist in %s, use --model_file and"
" --model_data_file specified in args" % model_path)
if ModelKeys.check_tensors in model_conf:
model_conf[ModelKeys.output_tensors] = model_conf[
ModelKeys.check_tensors]
model_conf[ModelKeys.output_shapes] = model_conf[
ModelKeys.check_shapes]
model_file_path = ""
if not flags.gencode_model:
model_file_path = install_dir + "/" + model_file
model_data_file_path = ""
if not flags.gencode_param:
model_data_file_path = install_dir + "/" + model_data_file
model_args = {
"model_name":
model_name,
"model_file":
model_file_path,
"model_data_file":
model_data_file_path,
"input_node":
",".join(model_conf[ModelKeys.input_tensors]),
"input_shape":
join_2d_array(model_conf[ModelKeys.input_shapes]),
"output_node":
",".join(model_conf[ModelKeys.output_tensors]),
"output_shape":
join_2d_array(model_conf[ModelKeys.output_shapes]),
"input_data_format":
",".join([df.name for df in model_conf[ModelKeys.input_data_formats]]),
"output_data_format":
",".join([df.name
for df in model_conf[ModelKeys.output_data_formats]]),
"device":
runtime.name
}
opts = [
"--%s=%s" % (arg_key, arg_val)
for arg_key, arg_val in model_args.items()
] + args
should_generate_data = (flags.validate or flags.tune
or "--benchmark" in opts)
if should_generate_data:
tmpdirname = tempfile.mkdtemp()
input_file_prefix = tmpdirname + "/" + model_name
if ModelKeys.validation_inputs_data in model_conf:
input_tensor = model_conf[ModelKeys.input_tensors]
input_data = model_conf[ModelKeys.validation_inputs_data]
mace_check(
len(input_tensor) == len(input_data),
"len(input_tensor) != len(validate_data")
for i in range(len(input_tensor)):
util.download_or_get_file(
model_conf[ModelKeys.validation_inputs_data][i], "",
util.formatted_file_name(input_file_prefix,
input_tensor[i]))
else:
generate_input_data(input_file_prefix,
model_conf[ModelKeys.input_tensors],
model_conf[ModelKeys.input_shapes],
model_conf[ModelKeys.input_ranges],
model_conf[ModelKeys.input_data_types])
dev.install(Target(tmpdirname), install_dir + "/validate_in")
target_input_file = "%s/validate_in/%s" % (install_dir, model_name)
target_output_dir = "%s/validate_out" % install_dir
dev.mkdir(target_output_dir)
target_output_file = target_output_dir + "/" + model_name
opts += [
"--input_file=%s" % target_input_file,
"--output_file=%s" % target_output_file
]
# run
envs = flags.envs.split(" ") + ["MACE_INTERNAL_STORAGE_PATH=%s" % sysdir]
if flags.tune:
envs += [
"MACE_TUNING=1",
"MACE_RUN_PARAMETER_PATH=%s/interior/tune_params" % install_dir
]
opts += ["--round=0"]
if flags.vlog_level > 0:
envs += ["MACE_CPP_MIN_VLOG_LEVEL=%s" % flags.vlog_level]
build_dir = flags.build_dir + "/" + target_abi
libs = []
if model_conf[ModelKeys.runtime] == DeviceType.HEXAGON:
libs += ["third_party/nnlib/%s/libhexagon_controller.so" % target_abi]
elif model_conf[ModelKeys.runtime] == DeviceType.APU:
libs += ["third_party/apu/libapu-frontend.so"]
target = Target(build_dir + "/install/bin/mace_run",
libs,
opts=opts,
envs=envs)
run_target.run_target(target_abi,
install_dir,
target,
device_ids=flags.target_socs)
if runtime == DeviceType.GPU:
opencl_dir = workdir + "/opencl"
util.mkdir_p(opencl_dir)
dev.pull(
Target(install_dir + "/interior/mace_cl_compiled_program.bin"),
"%s/%s_compiled_opencl_kernel.%s.%s.bin" %
(opencl_dir, model_name, dev.info()["ro.product.model"].replace(
' ', ''), dev.info()["ro.board.platform"]))
if flags.tune:
dev.pull(
Target(install_dir + "/interior/tune_params"),
"%s/%s_tuned_opencl_parameter.%s.%s.bin" %
(opencl_dir, model_name,
dev.info()["ro.product.model"].replace(
' ', ''), dev.info()["ro.board.platform"]))
if flags.validate:
validate_model_file = util.download_or_get_model(
model_conf[ModelKeys.model_file_path],
model_conf[ModelKeys.model_sha256_checksum], tmpdirname)
validate_weight_file = ""
if ModelKeys.weight_file_path in model_conf:
validate_weight_file = util.download_or_get_model(
model_conf[ModelKeys.weight_file_path],
model_conf[ModelKeys.weight_sha256_checksum], tmpdirname)
dev.pull(Target(target_output_dir), tmpdirname + "/validate_out")
output_file_prefix = tmpdirname + "/validate_out/" + model_name
validate.validate(
model_conf[ModelKeys.platform], validate_model_file,
validate_weight_file, input_file_prefix, output_file_prefix,
model_conf[ModelKeys.input_shapes],
model_conf[ModelKeys.output_shapes],
model_conf[ModelKeys.input_data_formats],
model_conf[ModelKeys.output_data_formats],
model_conf[ModelKeys.input_tensors],
model_conf[ModelKeys.output_tensors], flags.validate_threshold,
model_conf[ModelKeys.input_data_types], flags.backend, "", "")
if should_generate_data:
shutil.rmtree(tmpdirname)
parser.add_argument(
'--output',
type=str,
default="build",
help="output dir")
parser.add_argument(
"--gencode",
action="store_true",
help="generate code")
flgs, _ = parser.parse_known_args()
return flgs
if __name__ == '__main__':
flags = parse_args()
util.mkdir_p(flags.output)
opencl_binary_files = []
if flags.binary_files:
opencl_binary_files = flags.binary_files.split(",")
opencl_tuning_files = []
if flags.tuning_files:
opencl_tuning_files = flags.tuning_files.split(",")
compiled_opencl_kernel_prefix = "compiled_opencl_kernel"
tuned_opencl_parameter_prefix = "tuned_opencl_parameter"
if not opencl_binary_files and not opencl_tuning_files:
for root, dirs, files in os.walk("build", topdown=False):
for name in files:
if compiled_opencl_kernel_prefix in name:
opencl_binary_files.append(os.path.join(root, name))