def main():
parser = argparse.ArgumentParser(
description="Converts ONNX model to ELL model\n"
"Example:\n"
"onnx_import.py model.onnx\n"
"This outputs 'model.ell' which can be compiled with ELL's 'wrap' tool\n"
)
parser.add_argument("input",
type=Text,
help="Input model file (onnx or protobuf)")
parser.add_argument("--zip_ell_model",
help="zips the output ELL model if set",
action="store_true")
parser.add_argument(
"--verbose",
help="print verbose output during the import. Helps to diagnose ",
action="store_true")
parser.add_argument(
'-o',
'--output_directory',
help='Path to output directory (default: input file directory)',
default=None)
model_options = parser.add_argument_group('model_options')
model_options.add_argument(
"--step_interval",
help="produce a steppable ELL model for a millisecond interval",
default=None)
model_options.add_argument(
"--lag_threshold",
help=
"number of step intervals to fall behind before notifying the caller.\n"
"used when step_interval is set\n",
default=None)
logger.add_logging_args(parser)
args = parser.parse_args()
logger.setup(args)
convert(args.input, args.output_directory, args.zip_ell_model,
args.step_interval, args.lag_threshold)
arg_parser.add_argument("--apikey",
help="API key for picluster server",
default=None)
arg_parser.add_argument("--username",
help="Username for logon to remote machine",
default=None)
arg_parser.add_argument("--password",
help="Password for logon to remote machine",
default=None)
arg_parser.add_argument("--command",
help="The command to run on the remote machine",
default=None)
arg_parser.add_argument(
"--timeout",
type=int,
default=300,
help="Timeout for the command in seconds (default 300 seconds)")
logger.add_logging_args(arg_parser)
args = arg_parser.parse_args()
logger.setup(args)
runner = RemoteRunner(ipaddress=args.ipaddress,
cluster=args.cluster,
username=args.username,
password=args.password,
command=args.command,
timeout=args.timeout,
apikey=args.apikey)
runner.run_command()
def main(args):
arg_parser = argparse.ArgumentParser(
description="Converts CNTK model to ELL model\n"
"Example:\n"
" cntk_import.py model.cntk\n"
"This outputs 'model.ell' which can be compiled with ELL's 'wrap' tool\n")
arg_parser.add_argument(
"cntk_model_file",
help="path to a CNTK model file, or a zip archive of a CNTK model file")
arg_parser.add_argument(
"--zip_ell_model",
help="zips the output ELL model if set", action="store_true")
arg_parser.add_argument(
"--use_legacy_importer",
help="specifies whether to use the new importer engine or the legacy importer", action="store_true")
arg_parser.add_argument(
"--plot_model",
help="specifies whether to plot the model using SVG to cntk_model_file.svg", action="store_true")
arg_parser.add_argument(
"--verify_vision_model",
help="verifies the imported vision ELL model produces the same output as the original CNTK model",
action="store_true")
arg_parser.add_argument(
"--verify_audio_model",
help="verifies the imported audio ELL model produces the same output as the original CNTK model",
action="store_true")
model_options = arg_parser.add_argument_group('model_options')
model_options.add_argument(
"--step_interval",
help="produce a steppable ELL model for a millisecond interval",
type=float)
model_options.add_argument(
"--lag_threshold",
help="millisecond time lag before notifying the caller.\n"
"used when step_interval is set\n",
type=float)
logger.add_logging_args(arg_parser)
args = arg_parser.parse_args(args)
_logger = logger.setup(args)
args = vars(args)
step_interval = args['step_interval']
lag_threshold = args['lag_threshold']
if step_interval is not None and lag_threshold is None:
lag_threshold = step_interval * 2
plot_model = args["plot_model"]
verify_model = {"vision": args["verify_vision_model"],
"audio": args["verify_audio_model"]}
# extract the model if it's in an archive
unzip = ziptools.Extractor(args['cntk_model_file'])
success, filename = unzip.extract_file(".cntk")
if success:
_logger.info("Extracted: " + filename)
else:
# not a zip archive
filename = args['cntk_model_file']
if not args["use_legacy_importer"]:
_logger.info("-- Using new importer engine --")
ell_map = cntk_to_ell.map_from_cntk_model_using_new_engine(filename, step_interval, lag_threshold, plot_model,
verify_model)
else:
_logger.info("-- Using legacy importer --")
predictor = cntk_to_ell.predictor_from_cntk_model(filename)
ell_map = ell.neural.utilities.ell_map_from_predictor(predictor, step_interval, lag_threshold)
model_file_name = os.path.splitext(filename)[0] + ".ell"
_logger.info("\nSaving model file: '" + model_file_name + "'")
ell_map.Save(model_file_name)
if args["zip_ell_model"]:
_logger.info("Zipping model file: '" + model_file_name + ".zip'")
zipper = ziptools.Zipper()
zipper.zip_file(model_file_name, model_file_name + ".zip")
os.remove(model_file_name)
def add_profile_runner_args(arg_parser):
arg_parser.add_argument("--platform_regex", help="Regex to match test platform name on. Defaults = {}".format(default_platform_regex))
arg_parser.add_argument("--parallel_run", help="The maximum number of profile operations to run in parallel. Also the maximum number of devices to attempt to claim.", default=24, type=int)
arg_parser.add_argument("--cluster", help="http address of the cluster server that controls access to the target devices", default=os.getenv("RPI_CLUSTER"))
arg_parser.add_argument("--ipaddress", help="The address of the target device if you don't have a cluster")
arg_parser.add_argument("--apikey", help="The ApiKey to use for the cluster", default=os.getenv("RPI_APIKEY"))
arg_parser.add_argument("--username", help="The username for pi machine", default="pi")
arg_parser.add_argument("--password", help="The password for pi machines", default=os.getenv("RPI_PASSWORD"))
if __name__ == "__main__":
parser = argparse.ArgumentParser("Run built profilers on target devices")
parser.add_argument("--input_path", "-i", help="Path to built profilers", required=True)
parser.add_argument("--output_path", "-o", help="Path to store profiling results in", required=True)
logger.add_logging_args(parser)
add_profile_runner_args(parser)
optimizer_util.add_all_shared_args(parser)
args = parser.parse_args()
all_profile_options = optimizer_util.ProfileOptions.parse_option_list_from_file(args.options)
run_profilers(input_path=args.input_path,
model_path=args.model_path,
models=args.models,
output_path=args.output_path,
all_profile_options=all_profile_options,
cluster=args.cluster,
ipaddress=args.ipaddress,
api_key=args.apikey,
password=args.password,
def parse_command_line(self, args=None):
arg_parser = _PassArgsParser(prog="wrap", description="""This tool wraps a given ELL model in a CMake buildable \
project that builds a language specific module that can call the ELL model on a given target platform.
The supported languages are:
python (default)
cpp
The supported target platforms are:
pi0 Raspberry Pi 0
pi3 Raspberry Pi 3
orangepi0 Orange Pi Zero
aarch64 arm64 Linux, works on Qualcomm DragonBoards
host (default) your host computer architecture""")
for arg in self.arguments.keys():
argdef = self.arguments[arg]
if "required" in argdef.keys():
arg_parser.add_argument("--" + arg, "-" + argdef["short"],
help=argdef["help"], required=True)
elif "choices" in argdef.keys():
arg_parser.add_argument("--" + arg, "-" + argdef["short"],
help=argdef["help"], default=argdef["default"],
choices=argdef["choices"])
elif type(argdef["default"]) is bool and not argdef["default"]:
arg_parser.add_argument("--" + arg, "-" + argdef["short"],
help=argdef["help"], action="store_true", default=False)
else:
arg_parser.add_argument("--" + arg, "-" + argdef["short"],
help=argdef["help"], default=argdef["default"])
compile_args = []
if '--' in args:
index = args.index('--')
compile_args = args[index + 1:]
args = args[:index]
logger.add_logging_args(arg_parser)
args = arg_parser.parse_args(args)
self.logger = logger.setup(args)
self.model_file = args.model_file
_, tail = os.path.split(self.model_file)
self.model_file_base = os.path.splitext(tail)[0]
self.model_name = args.module_name
if not self.model_name:
self.model_name = self.model_file_base.replace('-', '_')
self.language = args.language
self.target = args.target
self.objext = self.get_objext(self.target)
self.output_dir = args.outdir
if self.output_dir is None:
self.output_dir = self.target
if os.path.isfile(self.output_dir + ".py"):
raise Exception("You have a python module named '{}', which will conflict with the --outdir of '{}'. \
Please specify a different outdir.".format(self.output_dir + ".py", self.output_dir))
self.profile = args.profile
self.verbose = self.logger.getVerbose() or args.verbose
self.llvm_format = args.llvm_format
self.optimization_level = args.optimization_level
self.no_opt_tool = args.no_opt_tool or self.optimization_level in ['0', 'g']
self.no_llc_tool = args.no_llc_tool
self.optimize = not args.no_optimize
self.fuse_linear_ops = not args.no_fuse_linear_ops
self.optimize_reorder = not args.no_optimize_reorder
self.debug = args.debug
self.blas = self.str2bool(args.blas)
self.swig = self.language != "cpp"
self.cpp_header = self.language == "cpp"
self.compile_args = compile_args