def run(argv_str=None): from template_lib.utils.config import parse_args_and_setup_myargs, config2args run_script = os.path.relpath(__file__, os.getcwd()) args1, myargs, _ = parse_args_and_setup_myargs(argv_str, run_script=run_script, start_tb=False) myargs.args = args1 myargs.config = getattr(myargs.config, args1.command) args = default_argument_parser().parse_args(args=[]) args = config2args(myargs.config.args, args) args.opts += ['OUTPUT_DIR', args1.outdir + '/detectron2'] print("Command Line Args:", args) myargs = D2Utils.unset_myargs_for_multiple_processing( myargs, num_gpus=args.num_gpus) launch( main, args.num_gpus, num_machines=args.num_machines, machine_rank=args.machine_rank, dist_url=args.dist_url, args=(args, myargs), )
def train(args: argparse.Namespace) -> None: r"""Launch distributed training by using Detecton2's `launch()` function Parameters ---------- args : argparse.Namespace training script arguments, see :py:meth:`_parse_args()` """ args.classes = ast.literal_eval(args.classes) machine_rank = args.hosts.index(args.current_host) LOGGER.info(f"Machine rank: {machine_rank}") master_addr = args.hosts[0] master_port = "55555" url = "auto" if len(args.hosts) == 1 else f"tcp://{master_addr}:{master_port}" LOGGER.info(f"Device URL: {url}") launch( _train_impl, num_gpus_per_machine=args.num_gpus, num_machines=len(args.hosts), dist_url=url, machine_rank=machine_rank, args=(args,), )
def train_main(args): print("Command Line Args:", args) num_gpus = 2 launch( trainILSVRC, num_gpus, num_machines=args.num_machines, machine_rank=args.machine_rank, dist_url=args.dist_url, args=(args, ), )
def init(): args = default_argument_parser().parse_args() print("Command Line Args:", args) launch( main, args.num_gpus, num_machines=args.num_machines, machine_rank=args.machine_rank, dist_url=args.dist_url, args=(args, ), )
def start_training(args,config_lst,): launch( main, args.num_gpus, num_machines=args.num_machines, machine_rank=args.machine_rank, dist_url=args.dist_url, args=(args,), ) config_lst.append(args.config_file) return config_lst
def run(args: Optional[argparse.Namespace] = None, trainer_class: Optional[Type] = Trainer) -> None: if args is None: args = default_argument_parser().parse_args() print("Command Line Args:", args) launch( main, args.num_gpus, num_machines=args.num_machines, machine_rank=args.machine_rank, dist_url=args.dist_url, args=(args, trainer_class), )
def main(num_gpus=1, config_file="src/config.yaml", resume=False): args = default_argument_parser().parse_args() args.config_file = config_file args.resume = resume print("Command Line Args: ", args) # launch multi-gpu or distributed training launch( run, num_gpus, num_machines=args.num_machines, machine_rank=args.machine_rank, dist_url="auto", args=(args, ), )
def run(): parser = default_argument_parser() update_parser_defaults_from_yaml(parser) args = parser.parse_args() logger = logging.getLogger('tl') logger.info(get_dict_str(vars(args))) launch( main, args.num_gpus, num_machines=args.num_machines, machine_rank=args.machine_rank, dist_url=args.dist_url, args=(args, ), )
def recover(args): not_finished = True attempt = 0 args.resume = True while not_finished and attempt < args.max_attempts: try: launch( main, args.num_gpus, num_machines=args.num_machines, machine_rank=args.machine_rank, dist_url=args.dist_url, args=(args, ), ) not_finished = False except: print("Recovering after failure, attempt = %s" % attempt) print(sys.exc_info()) print(traceback.print_exc()) attempt += 1 pass
#register_pathway_dataset(json_path, img_path, category_list) parser = default_argument_parser() # parser.add_argument("--task", choices=["train", "eval", "data"], required=True) args = parser.parse_args() assert not args.eval_only args.eval_only = True args.config_file = r'./Base-RelationRetinaNet.yaml' #args.num_gpus = 2 #print("Command Line Args:", args) # launch( # main, # args.num_gpus, # num_machines=args.num_machines, # machine_rank=args.machine_rank, # dist_url=args.dist_url, # args=(args,), # ) launch( evaluate_all_checkpoints, args.num_gpus, num_machines=args.num_machines, machine_rank=args.machine_rank, dist_url=args.dist_url, args=(args,checkpoint_folder, output_csv_file), ) # cfg = setup(args) # generate_scaled_boxes_width_height_angles(cfg.DATASETS.TRAIN[0], cfg)
setup_data(config) setup_logger(output=config.OUTPUT_DIR, distributed_rank=comm.get_rank(), name=config_name) return config def main(): config_name = "fibercnn_keypoint_order_tblr" dev_mode = False do_resume = False config = setup(config_name, dev_mode, do_resume) trainer = Trainer(config) trainer.resume_or_load() try: last_evaluation_results = trainer.train() finally: clean_up_checkpoints(config.OUTPUT_DIR, n_keep=10) return last_evaluation_results if __name__ == "__main__": active_gpu_ids = [0, 1, 2, 3] select_active_gpus(active_gpu_ids) num_gpus = len(active_gpu_ids) launch(main, num_gpus, dist_url="auto")
IMAGE_BW # remove the colors of unsegmented pixels. This option is only available for segmentation models ) out = v.draw_instance_predictions(outputs["instances"].to("cpu")) cv2.imshow('hello', out.get_image()[:, :, ::-1]) cv2.waitKey(0) cv2.destroyAllWindows() from detectron2.evaluation import COCOEvaluator, inference_on_dataset from detectron2.data import build_detection_test_loader evaluator = COCOEvaluator("car_val", None, True, output_dir="./output/car_03_10/") val_loader = build_detection_test_loader(cfg, "car_val") print('', val_loader) print(inference_on_dataset(trainer.model, val_loader, evaluator)) # another equivalent way to evaluate the model is to use `trainer.test` return if __name__ == "__main__": args = default_argument_parser().parse_args() print("Command Line Args:", args) launch( main, 1, num_machines=1, machine_rank=args.machine_rank, dist_url=args.dist_url, args=(True, ), )
cfg.SOLVER.MAX_ITER = 6000 # number of iterations, num epochs = iter*batch_size/train_set_size cfg.SOLVER.CHECKPOINT_PERIOD = 1000 # save a checkpoint every 2000 iterations cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 512 cfg.MODEL.ROI_HEADS.NUM_CLASSES = 3 cfg.INPUT.MIN_SIZE_TRAIN = (800, 1080) cfg.INPUT.MAX_SIZE_TRAIN = 1920 cfg.INPUT.MAX_SIZE_TEST = 1920 cfg.INPUT.MIN_SIZE_TEST = 1080 cfg.TEST.EVAL_PERIOD = 500 cfg.VIS_PERIOD = 500 return cfg def main(): cfg = setup() # print(cfg.INPUT.FORMAT) os.makedirs(cfg.OUTPUT_DIR, exist_ok=True) trainer = Trainer(cfg) trainer.resume_or_load(resume=False) return trainer.train() if __name__ == "__main__": # main() num_gpus = 4 launch(main, num_gpus, num_machines=1, machine_rank=0, dist_url="tcp://127.0.0.1:12312")
'./output-save/model_0017999.pth', 'MODEL.DEVICE', 'cpu', 'SOLVER.IMS_PER_BATCH', '4', 'SOLVER.BASE_LR', '0.0025', 'DATASETS.TRAIN', '("oid_train", )', 'DATASETS.TEST', '("oid_validation", )', # For Debug ____________________ # 'SOLVER.MAX_ITER', '20_000', # INPUT.FORMAT? INPUT.MASK_FORMAT? # '--opts', # 'MODEL.DEVICE', 'cpu' ] ARGS = default_argument_parser().parse_args(CLI_ARGS) if N_GPU == 0: main(ARGS) else: launch( main, ARGS.num_gpus, num_machines=ARGS.num_machines, machine_rank=ARGS.machine_rank, dist_url=ARGS.dist_url, args=(ARGS, ), )
ret = inference_on_dataset(model, instantiate(cfg.dataloader.test), instantiate(cfg.dataloader.evaluator)) print_csv_format(ret) return ret def main(): root_directory = Path("../data") images_directory = root_directory / "images" annots_directory = root_directory / "annotations" path_to_train = annots_directory / 'modanet_instance_segmentation_train.json' path_to_test = annots_directory / 'modanet_instance_segmentation_test.json' register_coco_instances('modanet_instance_segmentation_train', {}, path_to_train, images_directory) register_coco_instances('modanet_instance_segmentation_test', {}, path_to_test, images_directory) MetadataCatalog.get('modanet_instance_segmentation_train').set( thing_classes=['bag', 'dress', 'footwear', 'skirt', 'top', 'sunglasses', \ 'headwear', 'shorts', 'pants', 'belt', 'outer', 'scarf', 'boots'] ) new_model_lazy_path = 'new_baselines/mask_rcnn_R_50_FPN_50ep_LSJ.py' cfg = create_lazy_cfg(new_model_lazy_path) print(do_train(cfg)) if __name__ == "__main__": launch(main(), 2, 1)
# Load the model model: nn.Module = Trainer.build_model(cfg) # Load the latest weights DetectionCheckpointer(model, save_dir=cfg.OUTPUT_DIR).resume_or_load( cfg.MODEL.WEIGHTS, resume=parsed_args.resume) res: Dict = Trainer.test(cfg, model) if comm.is_main_process(): verify_results(cfg=cfg, results=res) return res # Training trainer: Trainer = Trainer(cfg) trainer.resume_or_load(resume=parsed_args.resume) return trainer.train() if __name__ == "__main__": PARSER: ArgumentParser = default_argument_parser() PARSED_ARGS: Namespace = PARSER.parse_args() print("Command Line Args:", PARSED_ARGS) launch(main, PARSED_ARGS.num_gpus, num_machines=PARSED_ARGS.num_machines, machine_rank=PARSED_ARGS.machine_rank, dist_url=PARSED_ARGS.dist_url, args=(PARSED_ARGS, ))
Refer to https://github.com/facebookresearch/detectron2/tree/master/configs" ) group.add_argument('--local-config-file', type=str, default=None, metavar="FILE", help="If local config file specified, then config file \ from container_training directory will be used.") parser.add_argument('--opts', default=None) sm_args = parser.parse_args() # Derive parameters of distributed training number_of_processes, number_of_machines, world_size = _get_sm_world_size( sm_args) logger.info( 'Running \'{}\' backend on {} nodes and {} processes. World size is {}.' .format(sm_args.backend, number_of_machines, number_of_processes, world_size)) machine_rank = sm_args.hosts.index(sm_args.current_host) master_addr = sm_args.hosts[0] master_port = '55555' # Launch D2 distributed training launch( main, num_gpus_per_machine=number_of_processes, num_machines=number_of_machines, machine_rank=machine_rank, dist_url=f"tcp://{master_addr}:{master_port}", args=(sm_args, ), )
if args.root is not None: register_datasets([args.root], cfg.DATASETS.TRAIN) register_datasets([args.root], cfg.DATASETS.TEST, is_train=False) if args.reduced_coco: register_dataset(dataset_name='coco_2017_train_20') register_dataset(dataset_name='coco_2017_val_20', is_train=False) trainer = Trainer(cfg) # trainer = DefaultTrainer(cfg) trainer.resume_or_load(resume=args.resume) return trainer.train() if __name__ == '__main__': parser = default_argument_parser() parser.add_argument('--root', required=False, type=str, default=None) parser.add_argument('--output_dir', required=True, type=str) parser.add_argument('--num_gpus', required=False, type=int, default=1) parser.add_argument('--weights', required=False, type=str, default=None) parser.add_argument('--reduced_coco', action='store_true', default=False) args = parser.parse_args() print(args) train = True if train: launch(main, args.num_gpus, args=(args, ), dist_url='auto') else: main(args)
cfg.freeze() default_setup( cfg, args ) # if you don't like any of the default setup, write your own setup code return cfg def main(args): cfg = setup(args) model = build_model(cfg) logger.info("Model:\n{}".format(model)) if args.eval_only: DetectionCheckpointer(model, save_dir=cfg.OUTPUT_DIR).resume_or_load( cfg.MODEL.WEIGHTS, resume=args.resume ) return do_test(cfg, model) do_train(cfg, model, resume=args.resume) return do_test(cfg, model) if __name__ == "__main__": args = default_argument_parser().parse_args() print("Command Line Args:", args) launch( main, args.num_gpus, args=(args,), )
# register each val and test set if there are more than one. register_coco_instances(cfg.DATASETS.TRAIN[0], {}, str(train_coco_instances_path), str(im_tiles_path)) register_coco_instances(cfg.DATASETS.VALIDATION[0], {}, str(val_coco_instances_path), str(val_tiles_path)) # register_coco_instances(cfg.DATASETS.TEST[0], {}, test_coco_instances_path, str(next(tiles_path.glob("*jpeg*")))) train_json = load_coco_json(str(train_coco_instances_path), str(im_tiles_path)) val_json = load_coco_json(str(val_coco_instances_path), str(val_tiles_path)) #test_json = load_coco_json(test_coco_instances_path, str(next(tiles_path.glob("*jpg*")))) def save_cfg(cfg): os.mkdir(cfg.OUTPUT_DIR) with open(Path(cfg.OUTPUT_DIR) / cfg.CONFIG_NAME, "w") as f: f.write(cfg.dump()) def main(): setup_register_load_inputs(cfg) # if this ain't here the multigpu can't find registered datasets # trainer = detectron2_reclass.Trainer(cfg) trainer = DefaultTrainer(cfg) trainer.resume_or_load(resume=False) return trainer.train() if __name__ == "__main__": args = default_argument_parser().parse_args() save_cfg(cfg) print("Command Line Args:", args) launch( main, args.num_gpus, dist_url="auto" )
# Load the latest weights DetectionCheckpointer(model, save_dir=cfg.OUTPUT_DIR).resume_or_load( cfg.MODEL.WEIGHTS, resume=args.resume) res = Trainer.test(cfg, model) if comm.is_main_process(): verify_results(cfg, res) return res # Training trainer = Trainer(cfg) trainer.resume_or_load(resume=args.resume) return trainer.train() if __name__ == "__main__": PARSER = default_argument_parser() PARSER.add_argument('--export-only', action='store_true', help="Do not compute metrics, just store the raw predictions of panel"\ "segmentation.") parsed_args: Namespace = PARSER.parse_args() launch(main, parsed_args.num_gpus, num_machines=parsed_args.num_machines, machine_rank=parsed_args.machine_rank, dist_url=parsed_args.dist_url, args=(parsed_args, ))
Refer to https://github.com/facebookresearch/detectron2/tree/master/configs" ) group.add_argument('--local-config-file', type=str, default=None, metavar="FILE", help="If local config file specified, then config file \ from container_training directory will be used.") parser.add_argument('--opts', default=None) sm_args = parser.parse_args() # Derive parameters of distributed training world = get_training_world() logger.info( f'Running "nccl" backend on {world["number_of_machines"]} machine(s), \ each with {world["number_of_processes"]} GPU device(s). World size is \ {world["size"]}. Current machine rank is {world["machine_rank"]}.' ) # Launch D2 distributed training launch( main, num_gpus_per_machine=world["number_of_processes"], num_machines=world["number_of_machines"], machine_rank=world["machine_rank"], dist_url=f"tcp://{world['master_addr']}:{world['master_port']}", args=( sm_args, world, ), )
os.makedirs(cfg.OUTPUT_DIR, exist_ok=True) trainer = myTrainer(cfg) # trainer.build_evaluator(cfg, "corrosion_val")# this is not necessary trainer.build_hooks() print("OK!") trainer.resume_or_load(resume=False) return trainer.train() if __name__ == '__main__': args = default_argument_parser().parse_args() launch( main, 2, num_machines=1, machine_rank=args.machine_rank, dist_url=args.dist_url, args=(args, ), ) # INFERENCE # cfg.MODEL.WEIGHTS = os.path.join(cfg.OUTPUT_DIR, "model_final.pth") # path to the model we just trained # cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.3 # set a custom testing threshold # predictor = DefaultPredictor(cfg) # # TEST INFERENCE # dataset_dicts = get_darwin_dataset(dataset_directory, 'val') # for d in dataset_dicts: # im = cv2.imread(d["file_name"]) # # im = Image.open(d["file_name"])
def run(self): # Core function of your process input = self.getInput(0) # Get parameters : param = self.getParam() if len(input.data["images"]) > 0: param.cfg["epochs"] = int(param.cfg["maxIter"] * param.cfg["batchSize"] / len(input.data["images"])) # complete class names if input dataset has no background class if not (input.has_bckgnd_class): tmp_dict = {0: "background"} for k, name in input.data["metadata"]["category_names"].items(): tmp_dict[k + 1] = name input.data["metadata"]["category_names"] = tmp_dict input.has_bckgnd_class = True param.cfg["classes"] = len(input.data["metadata"]["category_names"]) # Call beginTaskRun for initialization self.beginTaskRun() if param.cfg["expertModeCfg"] == "": # Get default config cfg = get_cfg() # Add specific deeplab config add_deeplab_config(cfg) cfg.merge_from_file(os.path.dirname(os.path.realpath(__file__)) + "/model/configs/deeplab_v3_plus_R_103_os16_mg124_poly_90k_bs16.yaml") # Generic dataset names that will be used cfg.DATASETS.TRAIN = ("datasetTrain",) cfg.DATASETS.TEST = ("datasetTest",) cfg.SOLVER.MAX_ITER = param.cfg["maxIter"] cfg.SOLVER.WARMUP_FACTOR = 0.001 cfg.SOLVER.WARMUP_ITERS = param.cfg["maxIter"] // 5 cfg.SOLVER.POLY_LR_FACTOR = 0.9 cfg.SOLVER.POLY_LR_CONSTANT_FACTOR = 0.0 cfg.MODEL.SEM_SEG_HEAD.NUM_CLASSES = param.cfg["classes"] cfg.SOLVER.BASE_LR = param.cfg["learningRate"] cfg.MODEL.SEM_SEG_HEAD.ASPP_CHANNELS = 256 cfg.MODEL.SEM_SEG_HEAD.COMMON_STRIDE = 4 cfg.SOLVER.IMS_PER_BATCH = param.cfg["batchSize"] cfg.DATALOADER.NUM_WORKERS = 0 cfg.INPUT_SIZE = (param.cfg["inputWidth"], param.cfg["inputHeight"]) cfg.TEST.EVAL_PERIOD = param.cfg["evalPeriod"] cfg.SPLIT_TRAIN_TEST = param.cfg["splitTrainTest"] cfg.SPLIT_TRAIN_TEST_SEED = -1 cfg.MODEL.BACKBONE.FREEZE_AT = 5 cfg.CLASS_NAMES = [name for k, name in input.data["metadata"]["category_names"].items()] if param.cfg["earlyStopping"]: cfg.PATIENCE = param.cfg["patience"] else: cfg.PATIENCE = -1 if param.cfg["outputFolder"] == "": cfg.OUTPUT_DIR = os.path.dirname(os.path.realpath(__file__)) + "/output" elif os.path.isdir(param.cfg["outputFolder"]): cfg.OUTPUT_DIR = param.cfg["outputFolder"] else: print("Incorrect output folder path") else: cfg = None with open(param.cfg["expertModeCfg"], 'r') as file: cfg_data = file.read() cfg = CfgNode.load_cfg(cfg_data) if cfg is not None: deeplabutils.register_train_test(input.data["images"], input.data["metadata"], train_ratio=cfg.SPLIT_TRAIN_TEST / 100, seed=cfg.SPLIT_TRAIN_TEST_SEED) os.makedirs(cfg.OUTPUT_DIR, exist_ok=True) str_datetime = datetime.now().strftime("%d-%m-%YT%Hh%Mm%Ss") model_folder = cfg.OUTPUT_DIR + os.path.sep + str_datetime cfg.OUTPUT_DIR = model_folder if not os.path.isdir(model_folder): os.mkdir(model_folder) cfg.OUTPUT_DIR = model_folder self.trainer = deeplabutils.MyTrainer(cfg, self) self.trainer.resume_or_load(resume=False) print("Starting training job...") launch(self.trainer.train, num_gpus_per_machine=1) print("Training job finished.") self.trainer = None gc.collect() torch.cuda.empty_cache() with open(cfg.OUTPUT_DIR+"/Detectron2_DeepLabV3Plus_Train_Config.yaml", 'w') as file: file.write(cfg.dump()) else: print("Error : can't load config file "+param.cfg["expertModeCfg"]) # Call endTaskRun to finalize process self.endTaskRun()
else: assert 0 except: os.system( "rm /home/pgding/project/LIP/detectron2_bdd/tools/output/train_out/*" ) os.system( "rm /home/pgding/project/LIP/detectron2_bdd/tools/output/infer_out/*" ) skip = False launch( pretrain, args.num_gpus, num_machines=args.num_machines, machine_rank=args.machine_rank, dist_url=args.dist_url, args=(cfg, k, resume), ) os.system("mv {} {}".format(pretrain_f, resume_f)) # Step 2: Search policies on dataset D_A if skip and os.path.isfile(policy_f): logger.info("skip search {}".format(k)) else: search = SearchTrainer(cfg, resume_f, k) if not debug: policies = search.search() else: # debug policies = search.network_debug()
verify_results(cfg, res) if cfg.TEST.AUG.ENABLED: res.update(Trainer.test_with_TTA(cfg, model)) return res """ If you'd like to do anything fancier than the standard training logic, consider writing your own training loop or subclassing the trainer. """ trainer = Trainer(cfg) trainer.resume_or_load(resume=args.resume) if cfg.TEST.AUG.ENABLED: trainer.register_hooks( [hooks.EvalHook(0, lambda: trainer.test_with_TTA(cfg, trainer.model))] ) return trainer.train() if __name__ == "__main__": output = open('output_results.txt','w').close() args = default_argument_parser().parse_args() print("Command Line Args:", args) launch( main, 1, num_machines=1, machine_rank=0, dist_url="tcp://127.0.0.1:{}", args=(args,), )
timer = Timer() with tqdm.tqdm(total=max_iter) as pbar: for idx, d in enumerate(f()): if idx == max_iter: break model(d) pbar.update() logger.info("{} iters in {} seconds.".format(max_iter, timer.seconds())) if __name__ == "__main__": parser = default_argument_parser() parser.add_argument("--task", choices=["train", "eval", "data"], required=True) args = parser.parse_args() assert not args.eval_only and not args.resume if args.task == "data": f = benchmark_data elif args.task == "train": """ Note: training speed may not be representative. The training cost of a R-CNN model varies with the content of the data and the quality of the model. """ f = benchmark_train elif args.task == "eval": f = benchmark_eval # only benchmark single-GPU inference. assert args.num_gpus == 1 and args.num_machines == 1 launch(f, args.num_gpus, args.num_machines, args.machine_rank, args.dist_url, args=(args,))
for i in range(n_instances): # Loop all instances # save information of the instance in a dictionary then append on coco_dt list pred = {} pred[ 'image_id'] = imgid # this imgid must be same as the key of test.json pred['category_id'] = int(categories[i]) + 1 # save binary mask to RLE, e.g. 512x512 -> rle pred['segmentation'] = binary_mask_to_rle(masks[i, :, :]) pred['score'] = float(scores[i]) coco_dt_train.append(pred) with open("train_result.json", "w") as f: json.dump(coco_dt_train, f) cocoDt = cocoGt.loadRes("train_result.json") imgIds = sorted(cocoGt.getImgIds()) cocoEval = COCOeval(cocoGt, cocoDt, 'segm') cocoEval.params.imgIds = imgIds cocoEval.evaluate() cocoEval.accumulate() cocoEval.summarize() if __name__ == '__main__': args = get_args() launch(main, num_gpus_per_machine=args.gpu_num, dist_url="auto", args=(args, ))
cfg = setup(args) model = build_model(cfg) logger.info("Model:\n{}".format(model)) if args.eval_only: DetectionCheckpointer(model, save_dir=cfg.OUTPUT_DIR).resume_or_load( cfg.MODEL.WEIGHTS, resume=args.resume) return do_test(cfg, model) distributed = comm.get_world_size() > 1 if distributed: model = DistributedDataParallel(model, device_ids=[comm.get_local_rank()], broadcast_buffers=False) do_train(cfg, model) return do_test(cfg, model) if __name__ == "__main__": args = default_argument_parser().parse_args() print("Command Line Args:", args) launch( main, args.num_gpus, num_machines=args.num_machines, machine_rank=args.machine_rank, dist_url=args.dist_url, args=(args, ), )
args.num_gpus = gpu_num args.config_file = 'config/' + config_name if pretrain_model is None: pretrain_path = None else: pretrain_path = 'pretrain/' + pretrain_model args.opts = { 'root_davis': root_davis, 'learning_rate': learning_rate, 'max_iter': max_iter, 'batch_size': batch_size, 'pretrain_path': pretrain_path, 'warmup_iter': warmup_iter, 'MASK_ON': MASK_ON, 'steps': steps, 'visual': visual, 'vusual_threshold': visual_threshold, 'checkpoint_period': checkpoint_period } print("Command Line Args:", args) launch( trainer, args.num_gpus, num_machines=args.num_machines, machine_rank=args.machine_rank, dist_url=args.dist_url, args=(args, visual, visual_threshold), )