def test_with_TTA(cls, cfg, model):
logger = logging.getLogger("detectron2.trainer")
# In the end of training, run an evaluation with TTA
# Only support some R-CNN models.
logger.info("Running inference with test-time augmentation ...")
model = GeneralizedRCNNWithTTA(cfg, model)
evaluators = [
cls.build_evaluator(
cfg, name, output_folder=os.path.join(cfg.OUTPUT_DIR, "inference_TTA")
)
for name in cfg.DATASETS.TEST
]
res = cls.test(cfg, model, evaluators)
res = OrderedDict({k + "_TTA": v for k, v in res.items()})
return res
def main(args):
cfg = get_cfg()
datasets = dataset_register()
add_lod_config(cfg)
args.config = args.config if args.config is not None else "./outputs/LOD_R_101_RPN_1x_p100_abs_intop/config.yaml"
args.weights = args.weights if args.weights is not None else "./outputs/LOD_R_101_RPN_1x_p100_abs_intop/model_final.pth"
args.output_path = args.output_path if args.output_path is not None else "./outputs/seman/LOD_R_101_RPN_1x_p100_abs_intop/"
cfg.merge_from_file(args.config)
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.5 # set threshold for this model
cfg.MODEL.WEIGHTS = args.weights
base_path = args.output_path
cfg.SOLVER.IMS_PER_BATCH = 1
#multi-scale test
cfg.TEST.AUG.ENABLED = True
predictor = DefaultPredictor(cfg)
model = predictor.model
if cfg.TEST.AUG.ENABLED:
from detectron2.modeling import GeneralizedRCNNWithTTA
model = GeneralizedRCNNWithTTA(cfg, model)
for dataset in datasets:
print("\n######################{}#################\n".format(dataset))
visPath = os.path.join(base_path, dataset)
if not os.path.isdir(visPath):
os.makedirs(visPath)
data_loader = build_detection_test_loader(cfg, dataset)
for idx, inputs in tqdm(enumerate(data_loader)):
file_name = inputs[0]['file_name']
base_name = file_name.split("/")[-1]
with torch.no_grad():
outputs = model(inputs)[0]
seman_mask = outputs['instances'].pred_masks
seman_mask = seman_mask.sum(dim=0)
seman_mask = (seman_mask >= 1) + 0
matplotlib.image.imsave(os.path.join(visPath, base_name),
seman_mask.cpu().numpy(),
cmap='gray')
def test_with_TTA(cls, cfg, model):
"""
This is test during training procedure.
Temperaroly use Standard Tests
"""
print("test with test dataset")
logger = logging.getLogger("detectron2.trainer")
#TODO define Training procedure
logger.info("Running inference with test-time augmentation ...")
model = GeneralizedRCNNWithTTA(cfg, model)
evaluators = [
cls.build_evaluator(cfg,
name,
output_folder=os.path.join(
cfg.OUTPUT_DIR, "inference_TTA"))
for name in cfg.DATASETS.TEST
]
res = cls.test(cfg, model, evaluators)
res = OrderedDict({k + "_TTA": v for k, v in res.items()})
return res
def get_pred_img(dir):
dataset = get_img_dicts(dir)
if DEBUG:
dataset = dataset[:500]
cfg = get_cfg()
add_vovnet_config(cfg)
cfg.merge_from_file('/myspace/one_cls_faster_rcnn_V_99_FPN/config.yaml')
cfg.MODEL.WEIGHTS = '/myspace/one_cls_faster_rcnn_V_99_FPN/model_0099999.pth'
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.9
cfg.TEST.AUG.ENABLED = True
cfg.TEST.AUG.MIN_SIZES = (800, )
cfg.TEST.AUG.MAX_SIZE = 4000
cfg.TEST.AUG.FLIP = False
bbox_net = build_model(cfg)
DetectionCheckpointer(bbox_net).load(cfg.MODEL.WEIGHTS)
bbox_net = GeneralizedRCNNWithTTA(cfg, bbox_net)
inst_ds = infer_img(bbox_net, dataset)
return inst_ds
def _do_test(self, cfg, model, train_iter=None, model_tag="default"):
"""train_iter: Current iteration of the model, None means final iteration"""
assert len(cfg.DATASETS.TEST)
assert cfg.OUTPUT_DIR
is_final = (train_iter is None) or (train_iter
== cfg.SOLVER.MAX_ITER - 1)
logger.info(
f"Running evaluation for model tag {model_tag} at iter {train_iter}..."
)
def _get_inference_dir_name(base_dir, inference_type, dataset_name):
return os.path.join(
base_dir,
inference_type,
model_tag,
str(train_iter) if train_iter is not None else "final",
dataset_name,
)
add_print_flops_callback(cfg, model, disable_after_callback=True)
results = OrderedDict()
results[model_tag] = OrderedDict()
for dataset_name in cfg.DATASETS.TEST:
# Evaluator will create output folder, no need to create here
output_folder = _get_inference_dir_name(cfg.OUTPUT_DIR,
"inference", dataset_name)
# NOTE: creating evaluator after dataset is loaded as there might be dependency. # noqa
data_loader = self.build_detection_test_loader(cfg, dataset_name)
evaluator = self.get_evaluator(cfg,
dataset_name,
output_folder=output_folder)
if not isinstance(evaluator, DatasetEvaluators):
evaluator = DatasetEvaluators([evaluator])
if comm.is_main_process():
tbx_writer = _get_tbx_writer(
get_tensorboard_log_dir(cfg.OUTPUT_DIR))
logger.info("Adding visualization evaluator ...")
mapper = self.get_mapper(cfg, is_train=False)
evaluator._evaluators.append(
self.get_visualization_evaluator()(
cfg,
tbx_writer,
mapper,
dataset_name,
train_iter=train_iter,
tag_postfix=model_tag,
))
results_per_dataset = inference_on_dataset(model, data_loader,
evaluator)
if comm.is_main_process():
results[model_tag][dataset_name] = results_per_dataset
if is_final:
print_csv_format(results_per_dataset)
if is_final and cfg.TEST.AUG.ENABLED:
# In the end of training, run an evaluation with TTA
# Only support some R-CNN models.
output_folder = _get_inference_dir_name(
cfg.OUTPUT_DIR, "inference_TTA", dataset_name)
logger.info(
"Running inference with test-time augmentation ...")
data_loader = self.build_detection_test_loader(
cfg, dataset_name, mapper=lambda x: x)
evaluator = self.get_evaluator(cfg,
dataset_name,
output_folder=output_folder)
inference_on_dataset(GeneralizedRCNNWithTTA(cfg, model),
data_loader, evaluator)
if is_final and cfg.TEST.EXPECTED_RESULTS and comm.is_main_process():
assert len(
results
) == 1, "Results verification only supports one dataset!"
verify_results(cfg, results[model_tag][cfg.DATASETS.TEST[0]])
# write results to tensorboard
if comm.is_main_process() and results:
from detectron2.evaluation.testing import flatten_results_dict
flattened_results = flatten_results_dict(results)
for k, v in flattened_results.items():
tbx_writer = _get_tbx_writer(
get_tensorboard_log_dir(cfg.OUTPUT_DIR))
tbx_writer._writer.add_scalar("eval_{}".format(k), v,
train_iter)
if comm.is_main_process():
tbx_writer = _get_tbx_writer(
get_tensorboard_log_dir(cfg.OUTPUT_DIR))
tbx_writer._writer.flush()
return results
