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),
)
