def create_measure(device, flag="t4"): if device == 'arm' or device == 'aarch64': measure_option = autotvm.measure_option(builder=autotvm.LocalBuilder( build_func='ndk' if use_android else 'default'), runner=autotvm.RPCRunner( "pi", host='0.0.0.0', port=9190, number=5, timeout=10, )) elif ('x86' in device): measure_option = autotvm.measure_option( builder=autotvm.LocalBuilder(), runner=autotvm.LocalRunner(number=5, repeat=1, min_repeat_ms=1000), ) elif device == 'gpu': measure_option = autotvm.measure_option( builder=autotvm.LocalBuilder(timeout=1000), runner=autotvm.RPCRunner( flag, # change the device key to your key '0.0.0.0', 9190, number=20, repeat=3, timeout=1000, min_repeat_ms=150)) return measure_option
def test_autotvm(hexagon_session): """Top level test function for testing autotvm""" logfilename = "./hexagon.autotvm.log" options = { "log_filename": logfilename, "early_stopping": None, "measure_option": autotvm.measure_option( builder=autotvm.LocalBuilder(timeout=15), runner=autotvm.RPCRunner( module_loader=HexagonModuleLoader(hexagon_session), key=hexagon_session._remote_kw["key"], host=hexagon_session._remote_kw["host"], port=hexagon_session._remote_kw["port"], number=3, timeout=15, min_repeat_ms=150, # cooldown_interval=150 ), ), } target_hexagon = tvm.target.hexagon("v68") task = autotvm.task.create( "demo_template", args=[], target=target_hexagon, target_host=target_hexagon ) tune_tasks([task], **options)
def tune_and_evaluate(): df = pd.read_csv(args.layer_info) df = df[df['filename'] == args.layer] filenames = df.filename for net_fname in filenames: print('Tuning: ', net_fname) #### TUNING OPTION #### log_file = "models/%s/logs/%s.log" % (args.model, args.log_file) tuning_opt = { 'log_filename': log_file, 'n_trial': args.n_trials, 'measure_option': autotvm.measure_option(builder=autotvm.LocalBuilder(timeout=10), runner=autotvm.RPCRunner( args.device_key, '0.0.0.0', 9190, number=20, repeat=3, timeout=4, min_repeat_ms=150)), } in_c = int(df.loc[df.filename == net_fname, 'in_channels']) in_x = int(df.loc[df.filename == net_fname, 'input_spatial_x']) out_c = int(df.loc[df.filename == net_fname, 'out_channels']) input_shape = (1, in_c, in_x, in_x) print(input_shape) # extract workloads from relay program print("\tExtract tasks...") net, params = get_network(net_fname, input_shape) tasks = autotvm.task.extract_from_program(net['main'], target=target, target_host=target_host, params=params, ops=(relay.op.nn.conv2d, )) # run tuning tasks print("\tTuning...") tune_tasks(tasks, **tuning_opt)
def tuning_model(model_path): dtype='float32' ox, shape_dict = get_model(model_path) input_name = list(shape_dict.keys())[0] device_key = None if args.target == 'gpu': device_key = 'V100' use_android = False log_file = get_logfile() other_option = { 'model_path': model_path, 'dtype': dtype, 'input_name': input_name, 'device_key': device_key, 'use_android': use_android } if args.target == 'x86' or args.target == 'cpu': measure_option = autotvm.measure_option( builder=autotvm.LocalBuilder(), runner=autotvm.LocalRunner( number=10, repeat=1, min_repeat_ms=1000 ) ) elif args.target == 'gpu': measure_option = autotvm.measure_option( builder=autotvm.LocalBuilder(timeout=10), runner=autotvm.RPCRunner( device_key, '0.0.0.0', 9190, number=20, repeat=3, timeout=4, min_repeat_ms=150) ) n_trial = 200 tuning_option = { 'log_filename': log_file, 'tuner': 'xgb', 'n_trial': n_trial, 'early_stopping': 80, 'measure_option': measure_option } graph, lib, params = tuning(tuning_option, **other_option) return graph, lib, params
def __init__(self, task, target, device_key): self.task = task self.target = target self.device_key = device_key self.best_config = None self.best_latency = None self.early_stopping = None self.record = None self.tuner = 'xgb' self.n_trial = 30 self.measure_option = autotvm.measure_option( builder=autotvm.LocalBuilder(build_func="default"), runner=autotvm.RPCRunner( device_key, host="115.145.179.79", port=9090, number=5, timeout=10, ), )
def __init__(self, host='115.145.178.78', port=3306, user='******', password='******', db='modeldb'): self.host = host self.port = port self.user = user self.password = password self.db = pymysql.connect(host=host, port=port, user=user, password=password, db=db) self.cursor = self.db.cursor() self.device_key_list = ['xu4'] #self.target_list = [tvm.target.Target("llvm -device=arm_cpu -mtriple=armv7l-linux-gnueabihf -mattr=+neon")] self.target_list = ["llvm -device=arm_cpu -mtriple=armv7l-linux-gnueabihf -mattr=+neon"] self.measure_option = autotvm.measure_option( builder=autotvm.LocalBuilder(build_func="default"), runner=autotvm.RPCRunner( self.device_key_list[0], host="115.145.179.79", port=9090, number=5, timeout=10, ), )
task = autotvm.task.create( group_conv2d, args=(N, CI, H, W, CO, KH, KW, strides, padding, dilation, groups), target=tvm.target.vta(), target_host=env.target_host, template_key="direct", ) print(task.config_space) # Tune measure_option = autotvm.measure_option( builder=autotvm.LocalBuilder(), runner=autotvm.RPCRunner( env.TARGET, host=tracker_host, port=int(tracker_port), number=5, timeout=60, # check_correctness=True, # TODO: re-enable when check_correctness works again. ), ) # Run Tuner tuner = autotvm.tuner.RandomTuner(task) tuner.tune( n_trial=len(task.config_space), early_stopping=None, measure_option=measure_option, callbacks=[ autotvm.callback.progress_bar(len(task.config_space), prefix=prefix), autotvm.callback.log_to_file(tmp_log_file),
def tune_and_compile(graph: Graph, batch_size, target, target_host, device=None): # # this function is adopted and modified from tvm tutorial # log_dir = "./tvm_schedule_configs" os.makedirs(log_dir, exist_ok=True) log_file = os.path.join(log_dir, f"{graph.name}_{device}_{batch_size}.log") tuning_option = { 'log_filename': log_file, 'tuner': 'ga', 'n_trial': 2000, 'early_stopping': 600, 'measure_option': autotvm.measure_option( builder=autotvm.LocalBuilder(timeout=10), # runner=autotvm.LocalRunner(number=20, repeat=3, timeout=4, min_repeat_ms=150), runner=autotvm.RPCRunner( 'v100', # change the device key to your key '0.0.0.0', 9190, number=20, repeat=3, timeout=4), ) } # You can skip the implementation of this function for this tutorial. def tune_tasks(tasks, measure_option, tuner, n_trial, early_stopping, log_filename, use_transfer_learning=True): # create tmp log file tmp_log_file = log_filename + ".tmp" for i, tsk in enumerate(reversed(tasks)): prefix = "[Task %2d/%2d] " % (i + 1, len(tasks)) # create tuner if tuner == 'xgb' or tuner == 'xgb-rank': tuner_obj = XGBTuner(tsk, loss_type='rank') elif tuner == 'ga': tuner_obj = GATuner(tsk, pop_size=100) elif tuner == 'random': tuner_obj = RandomTuner(tsk) elif tuner == 'gridsearch': tuner_obj = GridSearchTuner(tsk) else: raise ValueError("Invalid tuner: " + tuner) if use_transfer_learning: if os.path.isfile(tmp_log_file): tuner_obj.load_history(autotvm.record.load_from_file(tmp_log_file)) # do tuning # print(f"tsk.config_space {tsk.config_space}") tuner_obj.tune(n_trial=min(n_trial, len(tsk.config_space)), early_stopping=early_stopping, measure_option=measure_option, callbacks=[ autotvm.callback.progress_bar(n_trial, prefix=prefix), autotvm.callback.log_to_file(tmp_log_file)]) # pick best records to a cache file autotvm.record.pick_best(tmp_log_file, log_filename) os.remove(tmp_log_file) mod, params = graph2relay(graph, batch_size) input_shape = (batch_size,) + tuple(graph.enter_node.output_shape) out_shape = (batch_size,) + tuple(graph.blocks[-1].exit_node.output_shape) # print(input_shape, out_shape) tasks = autotvm.task.extract_from_program(mod["main"], target=target, target_host=target_host, params=params, ops=(relay.op.nn.conv2d,)) # run tuning tasks if os.path.exists(log_file): print(f"Tuned config found, use {log_file} as config") else: print("Tuning...") tune_tasks(tasks, **tuning_option) # compile kernels with history best records with autotvm.apply_history_best(log_file): # print("Compile...") with relay.build_config(opt_level=3): # opt_level = 3 has problem graph, lib, params = relay.build_module.build(mod, target=target, target_host=target_host, params=params) return graph, lib, params
dtype = 'float32' device_key = 'tx2' tuning_option = { 'log_filename': log_file, 'tuner': 'xgb', 'n_trial': 200, 'early_stopping': 600, 'measure_option': autotvm.measure_option( builder=autotvm.LocalBuilder(timeout=10), #runner=autotvm.LocalRunner(number=20, repeat=3, timeout=4, min_repeat_ms=150), runner=autotvm.RPCRunner( device_key, # change the device key to your key '0.0.0.0', 9192, number=5, repeat=3, timeout=100, min_repeat_ms=150) ), } def tune_tasks(tasks, measure_option, tuner='xgb', n_trial=200, early_stopping=None, log_filename='tuning.log', use_transfer_learning=True, try_winograd=True): if try_winograd: for i in range(len(tasks)): try: # try winograd template
tuning_opt = { 'log_filename': 'resnet-18.log', 'tuner': 'random', 'n_trial': 1e9, 'early_stopping': None, 'measure_option': autotvm.measure_option(builder=autotvm.LocalBuilder( build_func=vta.vta_autotvm_build_func), runner=autotvm.RPCRunner( env.TARGET, tracker_host, tracker_port, number=4, repeat=3, timeout=60, check_correctness=True)) } tune_tasks(tasks, **tuning_opt) # compile kernels with history best records with autotvm.tophub.context(target, extra_files=[tuning_opt['log_filename']]): # ResNet parameters input_shape = (1, 3, 224, 224) dtype = 'float32'\ # Compile network
dtype = 'float32' source = 'darknet' tuning_option = { 'log_filename': log_file, 'tuner': 'xgb', 'n_trial': 200, 'early_stopping': 100, 'measure_option': autotvm.measure_option( builder=autotvm.LocalBuilder(timeout=1000), runner=autotvm.RPCRunner( 'jetbot', '0.0.0.0', 9190, number=5, timeout=1000, ) ), } def get_tf_yolov3_tiny( model_path=("/hdd02/zhangyiyang/Tensorflow-YOLOv3/" "weights/raw-yolov3-tiny.pb"), outputs=['yolov3_tiny/concat_6'],): input_shape = (1, 416, 416, 3) with tf.compat.v1.gfile.GFile(model_path, 'rb') as f: graph_def = tf.compat.v1.GraphDef() graph_def.ParseFromString(f.read())
# Workload parameters N = wl.batch CI = wl.in_filter CO = wl.out_filter task = autotvm.task.create(dense, args=(N, CI, CO), target=tvm.target.vta(), target_host=env.target_host, template_key='direct') print(task.config_space) measure_option = autotvm.measure_option(builder=autotvm.LocalBuilder( build_func=vta.vta_autotvm_build_func), runner=autotvm.RPCRunner( env.TARGET, tracket_host, int(tracket_port), number=4, repeat=3, timeout=10000, check_correctness=True)) tuner = autotvm.tuner.RandomTuner(task) tuner.tune(n_trial=len(task.config_space), measure_option=measure_option, callbacks=[autotvm.callback.log_to_file('dense.log')]) print("\nBest tuner config:") print(tuner.best_config)
# titanx 2 2 0 # gfx900 1 1 0 # ---------------------------------- # # Finally, we need to change the tuning option to use RPCRunner. Use the code below # to replace the corresponding part above. tuning_option = { "log_filename": log_file, "tuner": "xgb", "n_trial": 2000, "early_stopping": 600, "measure_option": autotvm.measure_option( builder=autotvm.LocalBuilder(timeout=10), runner=autotvm.RPCRunner( "1080ti", # change the device key to your key "0.0.0.0", 9190, number=20, repeat=3, timeout=4, min_repeat_ms=150, ), ), }
print('network:', network) log_file = "%s.log" % network dtype='float32' tuning_option = { 'log_filename': log_file, 'tuner': 'xgb', 'n_trial': NTRIAL, 'early_stopping': 600, 'measure_option': autotvm.measure_option( builder=autotvm.LocalBuilder(timeout=10), #runner=autotvm.LocalRunner(number=20, repeat=3, timeout=4, min_repeat_ms=150), runner=autotvm.RPCRunner( '1080ti', '0.0.0.0', 9123, number=5, timeout=10000) ), } def conv_5x5(net, out_channels, prefix, activation=True, kernel=(5,5)): # 5x5 Convolution weight = relay.var(prefix + "_weight") net = relay.nn.conv2d( net, weight, strides=(1,1), padding=(0, 0), channels=out_channels, kernel_size=kernel) # BatchNorm base_name = prefix + "_bn" gamma = relay.var(base_name + "_gamma")
stop_pack = "nn.global_avg_pool2d" # Tuning option log_file = "%s.%s.log" % (device, network) tuning_option = { "log_filename": log_file, "tuner": "random", "n_trial": 1000, "early_stopping": None, "measure_option": autotvm.measure_option( builder=autotvm.LocalBuilder(), runner=autotvm.RPCRunner( env.TARGET, host=tracker_host, port=tracker_port, number=5, timeout=60, module_loader=vta.module_loader(), # check_correctness=True, # TODO: re-enable when check_correctness works again. ), ), } #################################################################### # # .. note:: How to set tuning options # # In general, the default values provided here work well. # If you have enough time budget, you can set :code:`n_trial`, :code:`early_stopping` # to larger values, makes the tuning run for longer. # If your device is under-powered or your conv2d operators are large, consider
"log_filename": log_file, "tuner": "xgb", "n_trial": 1500, "early_stopping": 800, "measure_option": autotvm.measure_option( builder=autotvm.LocalBuilder( build_func="ndk" if use_android else "default"), runner=autotvm.RPCRunner( device_key, host="127.0.0.1", port=9190, number=5, timeout=10, ), ), } #################################################################### # # .. note:: How to set tuning options # # In general, the default values provided here work well. # If you have enough time budget, you can set :code:`n_trial`, :code:`early_stopping` larger, # which makes the tuning run longer. # If your device runs very slow or your conv2d operators have many GFLOPs, considering to # set timeout larger.
task = autotvm.task.create( dense, args=(N, CI, CO), target=tvm.target.vta(), target_host=env.target_host, template_key="direct", ) print(task.config_space) # Tune measure_option = autotvm.measure_option( builder=autotvm.LocalBuilder(), runner=autotvm.RPCRunner( env.TARGET, host=tracket_host, port=int(tracket_port), number=5, timeout=60, check_correctness=True, ), ) # Run Tuner tuner = autotvm.tuner.RandomTuner(task) tuner.tune( n_trial=len(task.config_space), early_stopping=None, measure_option=measure_option, callbacks=[ autotvm.callback.progress_bar(len(task.config_space), prefix=prefix), autotvm.callback.log_to_file(tmp_log_file), ],
def drive_tune(args): """Invoke auto-tuning with command line arguments Parameters ---------- args: argparse.Namespace Arguments from command line parser. """ # extra arguments validation before importing the model, so that obvious errors # are pointed in advance. if args.rpc_tracker: parsed_url = urlparse("//%s" % args.rpc_tracker) rpc_hostname = parsed_url.hostname rpc_port = parsed_url.port or 9090 logger.info("RPC tracker hostname: %s", rpc_hostname) logger.info("RPC tracker port: %s", rpc_port) if not args.rpc_key: raise common.TVMCException( "need to provide an RPC tracker key (--rpc-key) for remote tuning" ) target = common.target_from_cli(args.target) mod, params = frontends.load_model(args.FILE, args.model_format) # min_repeat_ms should be: # a. the value provided by the user, if any, or # b. 0ms in case target is "cpu"; otherwise 1000ms if args.min_repeat_ms is not None: min_repeat_ms = args.min_repeat_ms else: min_repeat_ms = 0 if target.keys[0] == "cpu" else 1000 logger.debug("Default --min-repeat-ms for this target is %s", min_repeat_ms) tasks = get_tuning_tasks( mod=mod, params=params, target=target, target_host=args.target_host, alter_layout=args.desired_layout, ) if args.rpc_tracker: runner = autotvm.RPCRunner( key=args.rpc_key, host=rpc_hostname, port=rpc_port, number=args.number, repeat=args.repeat, n_parallel=args.parallel, timeout=args.timeout, min_repeat_ms=min_repeat_ms, ) else: logger.info("starting localhost tuning") runner = autotvm.LocalRunner( number=args.number, repeat=args.repeat, timeout=args.timeout, min_repeat_ms=min_repeat_ms, ) tuning_option = { "tuner": args.tuner, "trials": args.trials, "early_stopping": args.early_stopping, "measure_option": autotvm.measure_option( builder=autotvm.LocalBuilder(build_func="default"), runner=runner), "tuning_records": args.tuning_records, } logger.debug(" tuning options: %s", tuning_option) tune_tasks(tasks, args.output, **tuning_option)
# Set up tuning options tuning_option = { 'log_filename': log_file, 'tuner': tuner, 'early_stopping': None, 'n_trial': trials, 'measure_option': autotvm.measure_option(builder=autotvm.LocalBuilder(build_func='default'), runner=autotvm.RPCRunner( device_key, host='fleet.cs.washington.edu', port=9190, number=1, timeout=20)), } def tune_kernels(tasks, measure_option, tuner=tuner, n_trial=trials, early_stopping=None, log_filename=log_file): for i, tsk in enumerate(tasks): prefix = "[Task %2d/%2d] " % (i + 1, len(tasks))
params=params, ops=(tvm.relay.op.nn.conv2d,), target=target, target_host=env.target_host) # Perform Autotuning print("Tuning...") tuning_opt = { 'log_filename': opt.log_filename, 'tuner': opt.tuner, 'n_trial': 1e9, 'early_stopping': None, 'measure_option': autotvm.measure_option( builder=autotvm.LocalBuilder(build_func=vta.vta_autotvm_build_func), runner=autotvm.RPCRunner(env.TARGET, tracker_host, tracker_port, number=4, min_repeat_ms=150, repeat=opt.measurements, timeout=60, check_correctness=True)) } tune_tasks(tasks, **tuning_opt) # Compile kernels with history best records with autotvm.tophub.context(target, extra_files=[opt.log_filename]): # Compile network print("Compiling network with best tuning parameters...") with relay.build_config(opt_level=3, disabled_pass={"AlterOpLayout"}): if target.device_name != "vta": graph, lib, params = relay.build( relay_prog, target=target, params=params, target_host=env.target_host) else:
# ---------------------------------- # 1080ti 4 4 0 # titanx 2 2 0 # gfx900 1 1 0 # ---------------------------------- # # Finally, we need to change the tuning option to use RPCRunner. Use the code below # to replace the corresponding part above. tuning_option = { 'log_filename': log_file, 'tuner': 'xgb', 'n_trial': 2000, 'early_stopping': 600, 'measure_option': autotvm.measure_option( builder=autotvm.LocalBuilder(timeout=10), runner=autotvm.RPCRunner( '1080ti', # change the device key to your key 'localhost', 9190, number=20, repeat=3, timeout=4), ), }
#### TUNING OPTION #### network = "resnet-18" log_file = "%s.%s.log" % (device_key, network) dtype = "float32" tuning_option = { "log_filename": log_file, "tuner": "xgb", "n_trial": 1000, "early_stopping": 450, "measure_option": autotvm.measure_option( builder=autotvm.LocalBuilder(build_func="ndk" if use_android else "default"), runner=autotvm.RPCRunner( device_key, host="0.0.0.0", port=9190, number=10, timeout=5, ), ), } #################################################################### # # .. note:: How to set tuning options # # In general, the default values provided here work well. # If you have enough time budget, you can set :code:`n_trial`, :code:`early_stopping` larger, # which makes the tuning run longer. # If your device runs very slow or your conv2d operators have many GFLOPs, considering to # set timeout larger.
# 1080ti 4 4 0 # titanx 2 2 0 # gfx900 1 1 0 # ---------------------------------- # # Finally, we need to change the tuning option to use RPCRunner. Use the code below # to replace the corresponding part above. tuning_option = { 'log_filename': log_file, 'tuner': 'xgb', 'n_trial': 2000, 'early_stopping': 600, 'measure_option': autotvm.measure_option( builder=autotvm.LocalBuilder(timeout=10), runner=autotvm.RPCRunner( '1080ti', # change the device key to your key '0.0.0.0', 9190, number=20, repeat=3, timeout=4, min_repeat_ms=150), ), }
opt.log_filename, "tuner": opt.tuner, "n_trial": 1e9, "early_stopping": None, "measure_option": autotvm.measure_option( builder=autotvm.LocalBuilder( build_func=vta.vta_autotvm_build_func), runner=autotvm.RPCRunner( env.TARGET, tracker_host, tracker_port, number=4, min_repeat_ms=150, repeat=opt.measurements, timeout=60, # check_correctness=True, # TODO: re-enable when check_correctness works again. ), ), } tune_tasks(tasks, **tuning_opt) # Compile kernels with history best records with autotvm.tophub.context(target, extra_files=[opt.log_filename]): # Compile network print("Compiling network with best tuning parameters...") if target.device_name != "vta": with tvm.transform.PassContext(opt_level=3,
'log_filename': log_file, 'tuner': 'xgb', 'n_trial': 1000, 'early_stopping': 450, 'measure_option': autotvm.measure_option( builder=autotvm.LocalBuilder( build_func='ndk' if use_android else 'default'), runner=autotvm.RPCRunner( device_key, host='localhost', port=9190, number=10, timeout=5, ), ), } #################################################################### # # .. note:: How to set tuning options # # In general, the default values provided here work well. # If you have enough time budget, you can set :code:`n_trial`, :code:`early_stopping` larger, # which makes the tuning run longer. # If your device runs very slow or your conv2d operators have many GFLOPs, considering to # set timeout larger.
'log_filename': log_file, 'tuner': 'xgb', 'n_trial': 10, 'early_stopping': 450, 'measure_option': autotvm.measure_option( builder=autotvm.LocalBuilder( build_func='ndk' if use_android else 'default'), runner=autotvm.RPCRunner( device_key, host=tracker_host, port=tracker_port, number=1, timeout=5, ), ), } #################################################################### # # .. note:: How to set tuning options # # In general, the default values provided here work well. # If you have enough time budget, you can set :code:`n_trial`, :code:`early_stopping` larger, # which makes the tuning run longer. # If your device runs very slow or your conv2d operators have many GFLOPs, considering to # set timeout larger.
log_file = "%s.%s.log" % (device, network) tuning_option = { 'log_filename': log_file, 'tuner': 'random', 'n_trial': 1000, 'early_stopping': None, 'measure_option': autotvm.measure_option( builder=autotvm.LocalBuilder(), runner=autotvm.RPCRunner(env.TARGET, host=tracker_host, port=tracker_port, number=5, timeout=60, check_correctness=True), ), } #################################################################### # # .. note:: How to set tuning options # # In general, the default values provided here work well. # If you have enough time budget, you can set :code:`n_trial`, :code:`early_stopping` # to larger values, makes the tuning run for longer. # If your device is under-powered or your conv2d operators are large, consider # setting a longer timeout. #
'log_filename': log_file, 'tuner': 'xgb', 'n_trial': 1000, 'early_stopping': 800, 'measure_option': autotvm.measure_option( builder=autotvm.LocalBuilder( build_func='ndk' if use_android else 'default'), runner=autotvm.RPCRunner( device_key, host='fleet', port=9190, number=5, timeout=10, ), ), } #################################################################### # # .. note:: How to set tuning options # # In general, the default values provided here work well. # If you have enough time budget, you can set :code:`n_trial`, :code:`early_stopping` larger, # which makes the tuning run longer. # If your device runs very slow or your conv2d operators have many GFLOPs, considering to # set timeout larger.
network = 'new-mobilenetv2-128_S' log_file = "%s,%s.log" % (device_key, network) dtype = 'float32' tuning_option = { 'log_filename': log_file, 'tuner': 'xgb', 'n_trial': 1500, 'early_stopping': 800, 'measure_option': autotvm.measure_option( builder=autotvm.LocalBuilder('default'), runner=autotvm.RPCRunner( device_key, host='0.0.0.0', port=9090, number=5, timeout=10, ) ), } # You can skip the implementation of this function for this tutorial. def tune_tasks(tasks, measure_option, tuner='xgb', n_trial=1000, early_stopping=None, log_filename='tuning.log', use_transfer_learning=False, try_winograd=True,
builder=autotvm.LocalBuilder(timeout=10), runner=autotvm.LocalRunner(number=20, repeat=3, timeout=4, min_repeat_ms=150)), } tuning_rpc_option = { 'log_filename': log_file, 'tuner': 'xgb', 'n_trial': 1000, 'early_stopping': 1000, 'measure_option': autotvm.measure_option( builder=autotvm.LocalBuilder(timeout=1000), runner=autotvm.RPCRunner( 'nano', host='0.0.0.0', port=9190, number=2, repeat = 3, timeout=2000, #min_repeat_ms=150 ),), } def prune_old_tasks(tasks, log_file): tmp_log_file = log_file + ".tmp" if os.path.isfile(tmp_log_file): autotvm.record.pick_best(tmp_log_file, log_file) if os.path.isfile(log_file): new_tasks = [] history = autotvm.record.ApplyHistoryBest(log_file) for task in tasks: if history._query_inside(task.target, task.workload) is None: new_tasks.append(task) return new_tasks