def run_inference(args,
ind_range=None,
multi_gpu_testing=False,
gpu_id=0,
check_expected_results=False,
tb_logger=None,
cur_iter=-1):
global tblogger
global curiter
tblogger = tb_logger
curiter = cur_iter
parent_func, child_func = get_eval_functions()
is_parent = ind_range is None
def result_getter():
if is_parent:
# Parent case:
# In this case we're either running inference on the entire dataset in a
# single process or (if multi_gpu_testing is True) using this process to
# launch subprocesses that each run inference on a range of the dataset
all_results = {}
for i in range(len(cfg.TEST.DATASETS)):
dataset_name, proposal_file = get_inference_dataset(
i, cfg.TEST.DATASETS[i])
output_dir = args.output_dir
results = parent_func(args,
dataset_name,
proposal_file,
output_dir,
multi_gpu=multi_gpu_testing)
all_results.update(results)
return all_results
else:
# Subprocess child case:
# In this case test_net was called via subprocess.Popen to execute on a
# range of inputs on a single dataset
dataset_name, proposal_file = \
get_inference_dataset(0, cfg.TEST.DATASETS[0], is_parent=False)
output_dir = args.output_dir
return child_func(args,
dataset_name,
proposal_file,
output_dir,
ind_range=ind_range,
gpu_id=gpu_id)
all_results = result_getter()
if check_expected_results and is_parent:
task_evaluation.check_expected_results(all_results,
atol=cfg.EXPECTED_RESULTS_ATOL,
rtol=cfg.EXPECTED_RESULTS_RTOL)
task_evaluation.log_copy_paste_friendly_results(all_results)
return all_results
def main(ind_range=None, multi_gpu_testing=False):
output_dir = get_output_dir(training=False)
all_results = run_inference(output_dir,
ind_range=ind_range,
multi_gpu_testing=multi_gpu_testing)
if not ind_range:
task_evaluation.check_expected_results(all_results,
atol=cfg.EXPECTED_RESULTS_ATOL,
rtol=cfg.EXPECTED_RESULTS_RTOL)
task_evaluation.log_copy_paste_friendly_results(all_results)
def run_inference(args,
ind_range=None,
multi_gpu_testing=False,
gpu_id=0,
check_expected_results=False,
use_matlab=False,
early_stop=False):
parent_func, child_func = get_eval_functions()
is_parent = ind_range is None
def result_getter():
if is_parent:
print("is parent")
# Parent case:
# In this case we're either running inference on the entire dataset in a
# single process or (if multi_gpu_testing is True) using this process to
# launch subprocesses that each run inference on a range of the dataset
all_results = {}
for i in range(len(cfg.TEST.DATASETS)):
dataset_name, proposal_file = get_inference_dataset(i)
output_dir = args.output_dir
results = parent_func(args,
dataset_name,
proposal_file,
output_dir,
multi_gpu=multi_gpu_testing,
use_matlab=use_matlab,
early_stop=early_stop)
all_results.update(results)
return all_results
else:
print("is child")
# Subprocess child case:
# In this case test_net was called via subprocess.Popen to execute on a
# range of inputs on a single dataset
dataset_name, proposal_file = get_inference_dataset(
0, is_parent=False)
output_dir = args.output_dir
return child_func(args,
dataset_name,
proposal_file,
output_dir,
ind_range=ind_range,
gpu_id=gpu_id)
all_results = result_getter()
if check_expected_results and is_parent:
task_evaluation.check_expected_results(all_results,
atol=cfg.EXPECTED_RESULTS_ATOL,
rtol=cfg.EXPECTED_RESULTS_RTOL)
return all_results
def run_inference(args,
ind_range=None,
multi_gpu_testing=False,
gpu_id=0,
check_expected_results=False):
parent_func, child_func = get_eval_functions()
is_parent = ind_range is None
def result_getter():
if is_parent:
# Parent case:
# In this case we're either running inference on the entire dataset in a
# single process or (if multi_gpu_testing is True) using this process to
# launch subprocesses that each run inference on a range of the dataset
print('test_engine.py result_getter() parent start')
print('multi gpu test: ', multi_gpu_testing)
print('range(len(cfg.TEST.DATASETS): ',
range(len(cfg.TEST.DATASETS)))
print(cfg.TEST.DATASETS)
all_results = {}
for i in range(len(cfg.TEST.DATASETS)):
dataset_name, proposal_file = get_inference_dataset(i)
output_dir = args.output_dir
results = parent_func(args,
dataset_name,
proposal_file,
output_dir,
multi_gpu=multi_gpu_testing)
all_results.update(results)
print('all results update check: ', len(all_results))
return all_results
else:
# Subprocess child case:
# In this case test_net was called via subprocess.Popen to execute on a
# range of inputs on a single dataset
print('test_engine.py result_getter() child start')
dataset_name, proposal_file = get_inference_dataset(
0, is_parent=False)
output_dir = args.output_dir
return child_func(args,
dataset_name,
proposal_file,
output_dir,
ind_range=ind_range,
gpu_id=gpu_id)
all_results = result_getter()
if check_expected_results and is_parent:
task_evaluation.check_expected_results(all_results,
atol=cfg.EXPECTED_RESULTS_ATOL,
rtol=cfg.EXPECTED_RESULTS_RTOL)
task_evaluation.log_copy_paste_friendly_results(all_results)
return all_results
def main(ind_range=None, multi_gpu_testing=False):
all_results = run_inference(
ind_range=ind_range, multi_gpu_testing=multi_gpu_testing
)
if not ind_range:
task_evaluation.check_expected_results(
all_results,
atol=cfg.EXPECTED_RESULTS_ATOL,
rtol=cfg.EXPECTED_RESULTS_RTOL
)
task_evaluation.log_copy_paste_friendly_results(all_results)
def run_inference(
args, ind_range=None,
multi_gpu_testing=False, gpu_id=0,
check_expected_results=False):
parent_func, child_func = get_eval_functions()
is_parent = ind_range is None
def result_getter():
if is_parent:
# Parent case:
# In this case we're either running inference on the entire dataset in a
# single process or (if multi_gpu_testing is True) using this process to
# launch subprocesses that each run inference on a range of the dataset
all_results = {}
for i in range(len(cfg.TEST.DATASETS)):
dataset_name, proposal_file = get_inference_dataset(i)
output_dir = args.output_dir
results = parent_func(
args,
dataset_name,
proposal_file,
output_dir,
multi_gpu=multi_gpu_testing
)
all_results.update(results)
return all_results
else:
# Subprocess child case:
# In this case test_net was called via subprocess.Popen to execute on a
# range of inputs on a single dataset
dataset_name, proposal_file = get_inference_dataset(0, is_parent=False)
output_dir = args.output_dir
return child_func(
args,
dataset_name,
proposal_file,
output_dir,
ind_range=ind_range,
gpu_id=gpu_id
)
all_results = result_getter()
if check_expected_results and is_parent:
task_evaluation.check_expected_results(
all_results,
atol=cfg.EXPECTED_RESULTS_ATOL,
rtol=cfg.EXPECTED_RESULTS_RTOL
)
task_evaluation.log_copy_paste_friendly_results(all_results)
return all_results
def main(ind_range=None, multi_gpu_testing=False):
output_dir = get_output_dir(training=False)
all_results = run_inference(output_dir,
ind_range=ind_range,
multi_gpu_testing=multi_gpu_testing)
if not ind_range:
task_evaluation.check_expected_results(all_results,
atol=cfg.EXPECTED_RESULTS_ATOL,
rtol=cfg.EXPECTED_RESULTS_RTOL)
import json
json.dump(all_results,
open(os.path.join(output_dir, 'bbox_results_all.json'), 'w'))
task_evaluation.log_copy_paste_friendly_results(all_results)
def main(weights_file, ind_range=None, multi_gpu_testing=False):
all_results = run_inference(
weights_file,
ind_range=ind_range,
multi_gpu_testing=multi_gpu_testing,
)
if not ind_range:
task_evaluation.check_expected_results(
all_results,
atol=cfg.EXPECTED_RESULTS_ATOL,
rtol=cfg.EXPECTED_RESULTS_RTOL
)
task_evaluation.log_copy_paste_friendly_results(all_results)
def main(ind_range=None, multi_gpu_testing=False):
# Determine which parent or child function should handle inference
if cfg.MODEL.RPN_ONLY:
child_func = generate_rpn_on_range
parent_func = generate_rpn_on_dataset
elif cfg.RETINANET.RETINANET_ON:
child_func = test_retinanet
parent_func = test_retinanet_on_dataset
else:
# Generic case that handles all network types other than RPN-only nets
# and RetinaNet
child_func = test_net
parent_func = test_net_on_dataset
is_parent = ind_range is None
if is_parent:
# Parent case:
# In this case we're either running inference on the entire dataset in a
# single process or (if multi_gpu_testing is True) using this process to
# launch subprocesses that each run inference on a range of the dataset
if len(cfg.TEST.DATASETS) == 0:
cfg.TEST.DATASETS = (cfg.TEST.DATASET, )
cfg.TEST.PROPOSAL_FILES = (cfg.TEST.PROPOSAL_FILE, )
all_results = {}
for i in range(len(cfg.TEST.DATASETS)):
cfg.TEST.DATASET = cfg.TEST.DATASETS[i]
if cfg.TEST.PRECOMPUTED_PROPOSALS:
cfg.TEST.PROPOSAL_FILE = cfg.TEST.PROPOSAL_FILES[i]
results = parent_func(multi_gpu=multi_gpu_testing)
all_results.update(results)
task_evaluation.check_expected_results(
all_results,
atol=cfg.EXPECTED_RESULTS_ATOL,
rtol=cfg.EXPECTED_RESULTS_RTOL
)
task_evaluation.log_copy_paste_friendly_results(all_results)
else:
# Subprocess child case:
# In this case test_net was called via subprocess.Popen to execute on a
# range of inputs on a single dataset (i.e., use cfg.TEST.DATASET and
# don't loop over cfg.TEST.DATASETS)
child_func(ind_range=ind_range)
def main(ind_range=None, multi_gpu_testing=False):
# Determine which parent or child function should handle inference
if cfg.MODEL.RPN_ONLY:
child_func = generate_rpn_on_range
parent_func = generate_rpn_on_dataset
elif cfg.RETINANET.RETINANET_ON:
child_func = test_retinanet
parent_func = test_retinanet_on_dataset
else:
# Generic case that handles all network types other than RPN-only nets
# and RetinaNet
child_func = test_net
parent_func = test_net_on_dataset
is_parent = ind_range is None
if is_parent:
# Parent case:
# In this case we're either running inference on the entire dataset in a
# single process or (if multi_gpu_testing is True) using this process to
# launch subprocesses that each run inference on a range of the dataset
if len(cfg.TEST.DATASETS) == 0:
cfg.TEST.DATASETS = (cfg.TEST.DATASET, )
cfg.TEST.PROPOSAL_FILES = (cfg.TEST.PROPOSAL_FILE, )
all_results = {}
for i in range(len(cfg.TEST.DATASETS)):
cfg.TEST.DATASET = cfg.TEST.DATASETS[i]
if cfg.TEST.PRECOMPUTED_PROPOSALS:
cfg.TEST.PROPOSAL_FILE = cfg.TEST.PROPOSAL_FILES[i]
results = parent_func(multi_gpu=multi_gpu_testing)
all_results.update(results)
task_evaluation.check_expected_results(all_results,
atol=cfg.EXPECTED_RESULTS_ATOL,
rtol=cfg.EXPECTED_RESULTS_RTOL)
task_evaluation.log_copy_paste_friendly_results(all_results)
else:
# Subprocess child case:
# In this case test_net was called via subprocess.Popen to execute on a
# range of inputs on a single dataset (i.e., use cfg.TEST.DATASET and
# don't loop over cfg.TEST.DATASETS)
child_func(ind_range=ind_range)
def run_inference(args,
ind_range=None,
multi_gpu_testing=False,
gpu_id=0,
check_expected_results=False):
'''
child_func = test_net
parent_func = test_net_on_dataset
'''
parent_func, child_func = get_eval_functions()
'''
now it's clear. only workers are allocated with the range jobs, and thus
if some process is calling the script with a range, them it is a worker, how smart
'''
is_parent = ind_range is None
''' FROM test_net.py:
run_inference(
args,
ind_range=args.range, (None)
multi_gpu_testing=args.multi_gpu_testing, (True)
check_expected_results=True)'''
def result_getter():
'''for chile processes, they are called from the beginning of test_net script'''
if is_parent:
# Parent case:
# In this case we're either running inference on the entire dataset in a
# single process or (if multi_gpu_testing is True) using this process to
# launch subprocesses that each run inference on a range of the dataset
all_results = {}
for i in range(len(cfg.TEST.DATASETS)):
'''get the dataset, I think proposal_file is None'''
dataset_name, proposal_file = get_inference_dataset(i)
output_dir = args.output_dir
results = parent_func(args,
dataset_name,
proposal_file,
output_dir,
multi_gpu=multi_gpu_testing)
all_results.update(results)
return all_results
else:
# Subprocess child case:
# In this case test_net was called via subprocess.Popen to execute on a
# range of inputs on a single dataset
'''a cmd is writen in main process, and Popen used to execute the subprocess'''
dataset_name, proposal_file = get_inference_dataset(
0, is_parent=False)
output_dir = args.output_dir
return child_func(args,
dataset_name,
proposal_file,
output_dir,
ind_range=ind_range,
gpu_id=gpu_id)
all_results = result_getter()
if check_expected_results and is_parent:
task_evaluation.check_expected_results(all_results,
atol=cfg.EXPECTED_RESULTS_ATOL,
rtol=cfg.EXPECTED_RESULTS_RTOL)
task_evaluation.log_copy_paste_friendly_results(all_results)
return all_results
def main():
"""Main function"""
if not torch.cuda.is_available():
sys.exit("Need a CUDA device to run the code.")
logger = utils.logging.setup_logging(__name__)
args = parse_args()
logger.info('Called with args:')
logger.info(args)
assert (torch.cuda.device_count() == 1) ^ bool(args.multi_gpu_testing)
assert bool(args.load_ckpt) ^ bool(args.load_detectron), \
'Exactly one of --load_ckpt and --load_detectron should be specified.'
if args.output_dir is None:
ckpt_path = args.load_ckpt if args.load_ckpt else args.load_detectron
args.output_dir = os.path.join(
os.path.dirname(os.path.dirname(ckpt_path)), 'test')
logger.info('Automatically set output directory to %s', args.output_dir)
if not os.path.exists(args.output_dir):
os.makedirs(args.output_dir)
if args.close_fpn:
args.cfg_file = "configs/few_shot/e2e_mask_rcnn_R-50-C4_1x_{}.yaml".format(args.group)
else:
args.cfg_file = "configs/few_shot/e2e_mask_rcnn_R-50-FPN_1x_{}.yaml".format(args.group)
if args.cfg_file is not None:
merge_cfg_from_file(args.cfg_file)
if args.set_cfgs is not None:
merge_cfg_from_list(args.set_cfgs)
cfg.VIS = args.vis
cfg.SEEN = args.seen
if args.close_co_atten:
cfg.CO_ATTEN = False
if args.close_relation_rcnn:
cfg.RELATION_RCNN = False
if not args.close_fpn:
cfg.FAST_RCNN.ROI_BOX_HEAD = 'fast_rcnn_heads.roi_2mlp_head'
cfg.MRCNN.ROI_MASK_HEAD = 'mask_rcnn_heads.mask_rcnn_fcn_head_v1up4convs'
else:
cfg.FAST_RCNN.ROI_BOX_HEAD = 'torchResNet.ResNet_roi_conv5_head'
cfg.MRCNN.ROI_MASK_HEAD = 'mask_rcnn_heads.mask_rcnn_fcn_head_v0upshare'
if args.deform_conv:
cfg.MODEL.USE_DEFORM = True
if args.dataset == "fis_cell":
cfg.TEST.DATASETS = ('fis_cell_test',)
cfg.MODEL.NUM_CLASSES = 2
elif args.dataset == "coco2017":
cfg.TEST.DATASETS = ('coco_2017_val',)
cfg.MODEL.NUM_CLASSES = 81
elif args.dataset == "keypoints_coco2017":
cfg.TEST.DATASETS = ('keypoints_coco_2017_val',)
cfg.MODEL.NUM_CLASSES = 2
else: # For subprocess call
assert cfg.TEST.DATASETS, 'cfg.TEST.DATASETS shouldn\'t be empty'
assert_and_infer_cfg()
#logger.info('Testing with config:')
#logger.info(pprint.pformat(cfg))
# manually set args.cuda
args.cuda = True
timer_for_ds = defaultdict(Timer)
### Dataset ###
timer_for_ds['roidb'].tic()
imdb, roidb, ratio_list, ratio_index, query, cat_list = combined_roidb(
cfg.TEST.DATASETS, False)
timer_for_ds['roidb'].toc()
roidb_size = len(roidb)
logger.info('{:d} roidb entries'.format(roidb_size))
logger.info('Takes %.2f sec(s) to construct roidb', timer_for_ds['roidb'].average_time)
batchSampler = BatchSampler(
sampler=MinibatchSampler(ratio_list, ratio_index, shuffle=False),
batch_size=1,
drop_last=False
)
dataset = RoiDataLoader(
roidb, ratio_list, ratio_index, query,
cfg.MODEL.NUM_CLASSES,
training=False, cat_list=cat_list, shot=args.checkshot)
### Model ###
model = initialize_model_from_cfg(args, gpu_id=0)
all_results = OrderedDict({
'box':
OrderedDict(
[
('AP', []),
('AP50', []),
('AP75', []),
('APs', []),
('APm', []),
('APl', []),
]
),
'mask':
OrderedDict(
[
('AP', []),
('AP50', []),
('AP75', []),
('APs', []),
('APm', []),
('APl', []),
]
)
})
timer_for_total = defaultdict(Timer)
timer_for_total['total_test_time'].tic()
for avg in range(args.average):
dataset.query_position = avg
dataloader = torch.utils.data.DataLoader(
dataset,
batch_sampler=batchSampler,
num_workers=cfg.DATA_LOADER.NUM_THREADS,
collate_fn=collate_minibatch
)
dataiterator = iter(dataloader)
num_images = len(ratio_index)
num_cats = imdb.num_classes
all_boxes, all_segms, all_keyps = empty_results(num_cats, num_images)
# total quantity of testing images
num_detect = len(ratio_index)
timers = defaultdict(Timer)
post_fix = '%dshot_g%d_seen%d_%d'%(args.checkshot, args.group, args.seen, avg)
for i, index in enumerate(ratio_index):
input_data = next(dataiterator)
catgory = input_data['choice']
entry = dataset._roidb[dataset.ratio_index[i]]
if cfg.TEST.PRECOMPUTED_PROPOSALS:
# The roidb may contain ground-truth rois (for example, if the roidb
# comes from the training or val split). We only want to evaluate
# detection on the *non*-ground-truth rois. We select only the rois
# that have the gt_classes field set to 0, which means there's no
# ground truth.
box_proposals = entry['boxes'][entry['gt_classes'] == 0]
if len(box_proposals) == 0:
continue
else:
# Faster R-CNN type models generate proposals on-the-fly with an
# in-network RPN; 1-stage models don't require proposals.
box_proposals = None
#im = cv2.imread(entry['image'])
im = imread(entry['image'])
if len(im.shape) == 2:
im = im[:,:,np.newaxis]
im = np.concatenate((im,im,im), axis=2)
alpha = 2.2 # Simple contrast control
beta = 0.5 # Simple brightness control
im_colored = im.copy()
if catgory[0].item() == 7:
im_colored[:,:,0] = 0
im_colored[:,:,1] = 0
im_colored = cv2.convertScaleAbs(im_colored, alpha=alpha, beta=beta)
elif catgory[0].item() == 8:
im_colored[:,:,1] = 0
im_colored[:,:,2] = 0
im_colored = cv2.convertScaleAbs(im_colored, alpha=alpha, beta=beta)
elif catgory[0].item() == 6:
im_colored[:,:,0] = 0
im_colored[:,:,2] = 0
im_colored = cv2.convertScaleAbs(im_colored, alpha=alpha, beta=beta)
cls_boxes_i, cls_segms_i, cls_keyps_i = im_detect_all(model, im, input_data['query'], input_data['query_type'], catgory, num_cats, box_proposals, timers)
im = im_colored
extend_results(i, all_boxes, cls_boxes_i)
if cls_segms_i is not None:
extend_results(i, all_segms, cls_segms_i)
if cls_keyps_i is not None:
extend_results(i, all_keyps, cls_keyps_i)
if i % 10 == 0: # Reduce log file size
ave_total_time = np.sum([t.average_time for t in timers.values()])
eta_seconds = ave_total_time * (num_images - i - 1)
eta = str(datetime.timedelta(seconds=int(eta_seconds)))
det_time = (
timers['im_detect_bbox'].average_time +
timers['im_detect_mask'].average_time +
timers['im_detect_keypoints'].average_time
)
misc_time = (
timers['misc_bbox'].average_time +
timers['misc_mask'].average_time +
timers['misc_keypoints'].average_time
)
logger.info(
(
'im_detect: range [{:d}, {:d}] of {:d}: '
'{:d}/{:d} {:.3f}s + {:.3f}s (eta: {})'
).format(
1, num_detect, num_detect, i + 1,
num_detect, det_time, misc_time, eta
)
)
if cfg.VIS:
im_name = entry['image']
class_name = im_name.split('/')[-4]
file_name = im_name.split('/')[-3]
im_target = im.copy()
to_tensor = transforms.ToTensor()
o_querys=[]
for i in range(args.checkshot):
o_query = input_data['query'][0][i][0].permute(1, 2,0).contiguous().cpu().numpy()
o_query *= [0.229, 0.224, 0.225]
o_query += [0.485, 0.456, 0.406]
o_query *= 255
o_query_colored = o_query.copy()
if catgory[0].item() == 7:
o_query_colored[:,:,0] = 0
o_query_colored[:,:,1] = 0
o_query_colored = cv2.convertScaleAbs(o_query_colored, alpha=alpha, beta=beta)
elif catgory[0].item() == 8:
o_query_colored[:,:,1] = 0
o_query_colored[:,:,2] = 0
o_query_colored = cv2.convertScaleAbs(o_query_colored, alpha=alpha, beta=beta)
elif catgory[0].item() == 6:
o_query_colored[:,:,0] = 0
o_query_colored[:,:,2] = 0
o_query_colored = cv2.convertScaleAbs(o_query_colored, alpha=alpha, beta=beta)
o_query = o_query_colored
o_query = Image.fromarray(o_query.astype(np.uint8))
o_querys.append(to_tensor(o_query))
o_querys_grid = make_grid(o_querys, nrow=args.checkshot//2, normalize=True, scale_each=True, pad_value=1)
o_querys_grid = transforms.ToPILImage()(o_querys_grid).convert("RGB")
query_w, query_h = o_querys_grid.size
query_bg = Image.new('RGB', (im_target.shape[1], im_target.shape[0]), (255, 255, 255))
bg_w, bg_h = query_bg.size
offset = ((bg_w - query_w) // 2, (bg_h - query_h) // 2)
query_bg.paste(o_querys_grid, offset)
query = np.asarray(query_bg)
im_pair = np.concatenate((im_target, query), axis=1)
im_output_dir = os.path.join(args.output_dir, 'vis', post_fix, class_name)
if not os.path.exists(im_output_dir):
os.makedirs(im_output_dir)
sample_output_dir = os.path.join(im_output_dir, os.path.basename('{:d}_{:s}'.format(i, file_name)))
if not os.path.exists(sample_output_dir):
os.makedirs(sample_output_dir)
target_save_name = os.path.join(sample_output_dir, os.path.basename('{:d}_{:s}'.format(i, file_name)) + '_target.pdf')
target = Image.fromarray(im_target.astype(np.uint8))
target.save(target_save_name,"pdf")
query_save_name = os.path.join(sample_output_dir, os.path.basename('{:d}_{:s}'.format(i, file_name)) + '_query.pdf')
query = Image.fromarray(query.astype(np.uint8))
query.save(query_save_name,"pdf")
pred_save_name = os.path.join(sample_output_dir, os.path.basename('{:d}_{:s}'.format(i, file_name)) + '_pred.pdf')
vis_utils.save_one_image(
im,
pred_save_name,
cls_boxes_i,
segms = cls_segms_i,
keypoints = cls_keyps_i,
thresh = cfg.VIS_TH,
box_alpha = 0.6,
dataset = imdb,
show_class = False
)
im_det = vis_utils.vis_one_image(
im,
'{:d}_det_{:s}'.format(i, file_name),
os.path.join(args.output_dir, 'vis', post_fix),
cls_boxes_i,
segms = cls_segms_i,
keypoints = cls_keyps_i,
thresh = cfg.VIS_TH,
box_alpha = 0.6,
dataset = imdb,
show_class = False,
class_name = class_name,
draw_bbox = False
)
gt_save_name = os.path.join(sample_output_dir, os.path.basename('{:d}_{:s}'.format(i, file_name)) + '_gt.pdf')
vis_utils.save_one_image_gt(
im, entry['id'],
gt_save_name,
dataset = imdb)
im_gt = vis_utils.vis_one_image_gt(
im, entry['id'],
'{:d}_gt_{:s}'.format(i, file_name),
os.path.join(args.output_dir, 'vis', post_fix),
dataset = imdb,
class_name = class_name)
im_det = np.asarray(im_det)
im_gt = np.asarray(im_gt)
im2draw = np.concatenate((im_gt, im_det), axis=1)
im2show = np.concatenate((im_pair, im2draw), axis=0)
im_save_name = os.path.basename('{:d}_{:s}'.format(i, file_name)) + '.png'
cv2.imwrite(os.path.join(im_output_dir, '{}'.format(im_save_name)), cv2.cvtColor(im2show, cv2.COLOR_RGB2BGR))
"""
if cfg.VIS:
im_name = dataset._roidb[dataset.ratio_index[i]]['image']
class_name = im_name.split('/')[-4]
file_name = im_name.split('/')[-3]
im2show = Image.open(im_name).convert("RGB")
o_query = input_data['query'][0][0][0].permute(1, 2, 0).contiguous().cpu().numpy()
o_query *= [0.229, 0.224, 0.225]
o_query += [0.485, 0.456, 0.406]
o_query *= 255
o_query = o_query[:,:,::-1]
o_query = Image.fromarray(o_query.astype(np.uint8))
query_w, query_h = o_query.size
query_bg = Image.new('RGB', (im2show.size), (255, 255, 255))
bg_w, bg_h = query_bg.size
offset = ((bg_w - query_w) // 2, (bg_h - query_h) // 2)
query_bg.paste(o_query, offset)
im2show = np.asarray(im2show)
o_query = np.asarray(query_bg)
im2show = np.concatenate((im2show, o_query), axis=1)
output_dir = os.path.join(args.output_dir, 'vis')
if not os.path.exists(output_dir):
os.makedirs(output_dir)
im_save_dir = os.path.join(output_dir, class_name)
if not os.path.exists(im_save_dir):
os.makedirs(im_save_dir)
im_save_name = os.path.join(im_save_dir, file_name + '_%d_d.png'%(i))
cv2.imwrite(im_save_name, cv2.cvtColor(im2show, cv2.COLOR_RGB2BGR))
"""
cfg_yaml = yaml.dump(cfg)
#det_name = 'detections.pkl'
det_file = os.path.join(args.output_dir, 'detections_' + post_fix + '.pkl')
save_object(
dict(
all_boxes=all_boxes,
all_segms=all_segms,
all_keyps=all_keyps,
cfg=cfg_yaml
), det_file
)
logger.info('Wrote detections to: {}'.format(os.path.abspath(det_file)))
results = task_evaluation.evaluate_all(
imdb, all_boxes, all_segms, all_keyps, args.output_dir
)
task_evaluation.check_expected_results(
results,
atol=cfg.EXPECTED_RESULTS_ATOL,
rtol=cfg.EXPECTED_RESULTS_RTOL
)
for task, metrics in all_results.items():
metric_names = metrics.keys()
for metric_name in metric_names:
all_results[task][metric_name].append(results[imdb.name][task][metric_name])
#task_evaluation.log_copy_paste_friendly_results(results)
for task, metrics in all_results.items():
metric_names = metrics.keys()
for metric_name in metric_names:
values = all_results[task][metric_name]
all_results[task][metric_name] = sum(values) / len(values)
post_fix = '%dshot_g%d_seen%d'%(args.checkshot, args.group, args.seen)
avg_results_path = os.path.join(args.output_dir, ('avg_cocoeval_' + post_fix + '_results.json'))
with open(avg_results_path, 'w') as f:
f.write(json.dumps(all_results))
timer_for_total['total_test_time'].toc()
logger.info('Total inference time: {:.3f}s'.format(timer_for_total['total_test_time'].average_time))
