def beamsearch_hp(datapath, benchmark, backbone, thres, alpha, logpath, candidate_base, candidate_layers, beamsize, maxdepth, args): r"""Implementation of beam search for hyperpixel layers""" # 1. Model, and dataset initialization device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") model = scot_CAM.SCOT_CAM(backbone, '0', benchmark, device, args.cam) download.download_dataset(os.path.abspath(datapath), benchmark) dset = download.load_dataset(benchmark, datapath, thres, device, 'val') dataloader = DataLoader(dset, batch_size=1, num_workers=0) # 2. Search for the k-best base layers membuf_cand = [] for base in candidate_base: start = time.time() hyperpixel = parse_layers(base) score = evaluate_map_CAM.run(datapath, benchmark, backbone, thres, alpha, hyperpixel, logpath, args, True, model, dataloader) log_evaluation(base, score, time.time() - start) membuf_cand.append((score, base)) membuf_topk = find_topk(membuf_cand, beamsize) score_sel, layer_sel = find_topk(membuf_cand, 1)[0] log_selected(0, membuf_topk) # 3. Proceed iterative search for depth in range(1, maxdepth): membuf_cand = [] for _, test_layer in membuf_topk: for cand_layer in candidate_layers: if cand_layer not in test_layer and cand_layer > min(test_layer): start = time.time() test_layers = sorted(test_layer + [cand_layer]) if test_layers in list(map(lambda x: x[1], membuf_cand)): break hyperpixel = parse_layers(test_layers) score = evaluate_map_CAM.run(datapath, benchmark, backbone, thres, alpha, hyperpixel, logpath, args, True, model, dataloader) log_evaluation(test_layers, score, time.time() - start) membuf_cand.append((score, test_layers)) membuf_topk = find_topk(membuf_cand, beamsize) score_tmp, layer_tmp = find_topk(membuf_cand, 1)[0] if score_tmp > score_sel: layer_sel = layer_tmp score_sel = score_tmp log_selected(depth, membuf_topk) # 4. Log best layer combination and validation performance logging.info('\nBest layers, score: %s %5.3f' % (layer_sel, score_sel)) return layer_sel
def run(datapath, benchmark, backbone, thres, alpha, hyperpixel, logpath, args, beamsearch=False, model=None, dataloader=None): r"""Runs Semantic Correspondence as an Optimal Transport Problem""" # 1. Logging initialization if not os.path.isdir('logs'): os.mkdir('logs') if not beamsearch: logfile = 'logs/{}_{}_{}_{}_exp{}-{}_e{}_m{}_{}_{}'.format( benchmark, backbone, args.split, args.sim, args.exp1, args.exp2, args.eps, args.classmap, args.cam, args.hyperpixel) print(logfile) util.init_logger(logfile) util.log_args(args) # 2. Evaluation benchmark initialization device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") if dataloader is None: download.download_dataset(os.path.abspath(datapath), benchmark) #split = 'val' if beamsearch else 'test' split = args.split dset = download.load_dataset(benchmark, datapath, thres, device, split, args.cam) dataloader = DataLoader(dset, batch_size=1, num_workers=0) # 3. Model initialization if model is None: model = scot_CAM.SCOT_CAM(backbone, hyperpixel, benchmark, device, args.cam) else: model.hyperpixel_ids = util.parse_hyperpixel(hyperpixel) # 4. Evaluator initialization evaluator = evaluation.Evaluator(benchmark, device) zero_pcks = 0 srcpt_list = [] trgpt_list = [] time_list = [] PCK_list = [] for idx, data in enumerate(dataloader): threshold = 0.0 # a) Retrieve images and adjust their sizes to avoid large numbers of hyperpixels data['src_img'], data['src_kps'], data['src_intratio'] = util.resize( data['src_img'], data['src_kps'][0]) data['trg_img'], data['trg_kps'], data['trg_intratio'] = util.resize( data['trg_img'], data['trg_kps'][0]) src_size = data['src_img'].size() trg_size = data['trg_img'].size() if len(args.cam) > 0: data['src_mask'] = util.resize_mask(data['src_mask'], src_size) data['trg_mask'] = util.resize_mask(data['trg_mask'], trg_size) data['src_bbox'] = util.get_bbox_mask(data['src_mask'], thres=threshold).to(device) data['trg_bbox'] = util.get_bbox_mask(data['trg_mask'], thres=threshold).to(device) else: data['src_mask'] = None data['trg_mask'] = None data['alpha'] = alpha tic = time.time() # b) Feed a pair of images to Hyperpixel Flow model with torch.no_grad(): confidence_ts, src_box, trg_box = model( data['src_img'], data['trg_img'], args.sim, args.exp1, args.exp2, args.eps, args.classmap, data['src_bbox'], data['trg_bbox'], data['src_mask'], data['trg_mask'], backbone) conf, trg_indices = torch.max(confidence_ts, dim=1) unique, inv = torch.unique(trg_indices, sorted=False, return_inverse=True) trgpt_list.append(len(unique)) srcpt_list.append(len(confidence_ts)) # c) Predict key-points & evaluate performance prd_kps = geometry.predict_kps(src_box, trg_box, data['src_kps'], confidence_ts) toc = time.time() #print(toc-tic) time_list.append(toc - tic) pair_pck = evaluator.evaluate(prd_kps, data) PCK_list.append(pair_pck) if pair_pck == 0: zero_pcks += 1 # d) Log results if not beamsearch: evaluator.log_result(idx, data=data) #save_file = logfile.replace('logs/','') #np.save('PCK_{}.npy'.format(save_file), PCK_list) if beamsearch: return (sum(evaluator.eval_buf['pck']) / len(evaluator.eval_buf['pck'])) * 100. else: logging.info('source points:' + str(sum(srcpt_list) * 1.0 / len(srcpt_list))) logging.info('target points:' + str(sum(trgpt_list) * 1.0 / len(trgpt_list))) logging.info('avg running time:' + str(sum(time_list) / len(time_list))) evaluator.log_result(len(dset), data=None, average=True) logging.info('Total Number of 0.00 pck images:' + str(zero_pcks))
def run(datapath, benchmark, backbone, thres, alpha, hyperpixel, logpath, beamsearch, model=None, dataloader=None, visualize=False): r"""Runs Hyperpixel Flow framework""" # 1. Logging initialization if not os.path.isdir('logs'): os.mkdir('logs') if not beamsearch: cur_datetime = datetime.datetime.now().__format__('_%m%d_%H%M%S') logfile = os.path.join('logs', logpath + cur_datetime + '.log') util.init_logger(logfile) util.log_args(args) if visualize: os.mkdir(logfile + 'vis') # 2. Evaluation benchmark initialization device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") if dataloader is None: download.download_dataset(os.path.abspath(datapath), benchmark) split = 'val' if beamsearch else 'test' dset = download.load_dataset(benchmark, datapath, thres, device, split) dataloader = DataLoader(dset, batch_size=1, num_workers=0) # 3. Model initialization if model is None: model = hpflow.HyperpixelFlow(backbone, hyperpixel, benchmark, device) else: model.hyperpixel_ids = util.parse_hyperpixel(hyperpixel) # 4. Evaluator initialization evaluator = evaluation.Evaluator(benchmark, device) for idx, data in enumerate(dataloader): # a) Retrieve images and adjust their sizes to avoid large numbers of hyperpixels data['src_img'], data['src_kps'], data['src_intratio'] = util.resize( data['src_img'], data['src_kps'][0]) data['trg_img'], data['trg_kps'], data['trg_intratio'] = util.resize( data['trg_img'], data['trg_kps'][0]) data['alpha'] = alpha # b) Feed a pair of images to Hyperpixel Flow model with torch.no_grad(): confidence_ts, src_box, trg_box = model(data['src_img'], data['trg_img']) # c) Predict key-points & evaluate performance prd_kps = geometry.predict_kps(src_box, trg_box, data['src_kps'], confidence_ts) evaluator.evaluate(prd_kps, data) # d) Log results if not beamsearch: evaluator.log_result(idx, data=data) if visualize: vispath = os.path.join( logfile + 'vis', '%03d_%s_%s' % (idx, data['src_imname'][0], data['trg_imname'][0])) util.visualize_prediction(data['src_kps'].t().cpu(), prd_kps.t().cpu(), data['src_img'], data['trg_img'], vispath) if beamsearch: return (sum(evaluator.eval_buf['pck']) / len(evaluator.eval_buf['pck'])) * 100. else: evaluator.log_result(len(dset), data=None, average=True)
if __name__ == '__main__': # Arguments parsing parser = argparse.ArgumentParser(description='Dynamic Hyperpixel Flow Pytorch Implementation') parser.add_argument('--datapath', type=str, default='../Datasets_DHPF') parser.add_argument('--backbone', type=str, default='resnet101', choices=['resnet50', 'resnet101']) parser.add_argument('--benchmark', type=str, default='pfpascal', choices=['pfpascal', 'pfwillow', 'caltech', 'spair']) parser.add_argument('--thres', type=str, default='auto', choices=['auto', 'img', 'bbox']) parser.add_argument('--alpha', type=float, default=0.1) parser.add_argument('--logpath', type=str, default='') parser.add_argument('--bsz', type=int, default=16) parser.add_argument('--load', type=str, default='') args = parser.parse_args() Logger.initialize(args) utils.fix_randseed(seed=0) # Model initialization device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") model = dhpf.DynamicHPF(args.backbone, device) model.load_state_dict(torch.load(args.load)) model.eval() # Dataset download & initialization download.download_dataset(args.datapath, args.benchmark) test_ds = download.load_dataset(args.benchmark, args.datapath, args.thres, device, 'test') test_dl = DataLoader(test_ds, batch_size=args.bsz, shuffle=False) Evaluator.initialize(args.benchmark, args.alpha) # Test DHPF with torch.no_grad(): test(model, test_dl)