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))
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)
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)
parser.add_argument('--bsz', type=int, default=8)
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)
Objective.initialize(args.selection, args.alpha)
strategy = sup.WeakSupStrategy(
) if args.supervision == 'weak' else sup.StrongSupStrategy()
optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=0.5)
# Dataset download & initialization
download.download_dataset(args.datapath, args.benchmark)
trn_ds = download.load_dataset(args.benchmark, args.datapath, args.thres,
device, 'trn')
val_ds = download.load_dataset(args.benchmark, args.datapath, args.thres,
device, 'val')
trn_dl = DataLoader(trn_ds, batch_size=args.bsz, shuffle=True)
val_dl = DataLoader(val_ds, batch_size=args.bsz, shuffle=False)
Evaluator.initialize(args.benchmark, args.alpha)
# Train DHPF
best_val_pck = float('-inf')
for epoch in range(args.niter):
trn_loss, trn_pck = train(epoch,
model,
trn_dl,
strategy,
optimizer,