dbname=dbname,
sal_input=conf.sal_input,
use_depth=conf.use_depth,
has_grad=conf.has_grad,
use_dist=conf.use_dist,
return_forest=conf.test_forest,
need_caption=conf.captioning,
gcn_caption=conf.gcn_captioning,
)
detector.cuda()
ckpt = torch.load(conf.ckpt)
optimistic_restore(detector, ckpt['state_dict'])
for n, param in detector.named_parameters():
param.requires_grad = False
detector.eval()
print(print_para(detector), flush=True)
##########################################################################
def get_optim(model, lr):
params = model.parameters()
optimizer = optim.Adam(params, weight_decay=0, lr=lr)
return optimizer
def to_contiguous(tensor):
if tensor.is_contiguous():
return tensor
def main():
args = 'X -m predcls -model motifnet -order leftright -nl_obj 2 -nl_edge 4 -b 6 -clip 5 -p 100 -hidden_dim 512 -pooling_dim 4096 -lr 1e-3 -ngpu 1 -test -ckpt checkpoints/vgrel-motifnet-sgcls.tar -nepoch 50 -use_bias -multipred -cache motifnet_predcls1'
sys.argv = args.split(' ')
conf = ModelConfig()
if conf.model == 'motifnet':
from lib.rel_model import RelModel
elif conf.model == 'stanford':
from lib.rel_model_stanford import RelModelStanford as RelModel
else:
raise ValueError()
train, val, test = VG.splits(
num_val_im=conf.val_size, filter_duplicate_rels=True,
use_proposals=conf.use_proposals,
filter_non_overlap=conf.mode == 'sgdet',
)
if conf.test:
val = test
train_loader, val_loader = VGDataLoader.splits(
train, val, mode='rel', batch_size=conf.batch_size,
num_workers=conf.num_workers, num_gpus=conf.num_gpus
)
detector = RelModel(
classes=train.ind_to_classes, rel_classes=train.ind_to_predicates,
num_gpus=conf.num_gpus, mode=conf.mode, require_overlap_det=True,
use_resnet=conf.use_resnet, order=conf.order,
nl_edge=conf.nl_edge, nl_obj=conf.nl_obj, hidden_dim=conf.hidden_dim,
use_proposals=conf.use_proposals,
pass_in_obj_feats_to_decoder=conf.pass_in_obj_feats_to_decoder,
pass_in_obj_feats_to_edge=conf.pass_in_obj_feats_to_edge,
pooling_dim=conf.pooling_dim,
rec_dropout=conf.rec_dropout,
use_bias=conf.use_bias,
use_tanh=conf.use_tanh,
limit_vision=conf.limit_vision
)
detector.cuda()
ckpt = torch.load(conf.ckpt)
optimistic_restore(detector, ckpt['state_dict'])
evaluator = BasicSceneGraphEvaluator.all_modes(
multiple_preds=conf.multi_pred)
mode, N = 'test.multi_pred', 20
recs = pkl.load(open('{}.{}.pkl'.format(mode, N), 'rb'))
np.random.seed(0)
# sorted_idxs = np.argsort(recs)
selected_idxs = np.random.choice(range(len(recs)), size=100, replace=False)
sorted_idxs = selected_idxs[np.argsort(np.array(recs)[selected_idxs])]
print('Sorted idxs: {}'.format(sorted_idxs.tolist()))
save_dir = '/nethome/bamos/2018-intel/data/2018-07-31/sgs.multi'
for idx in selected_idxs:
gt_entry = {
'gt_classes': val.gt_classes[idx].copy(),
'gt_relations': val.relationships[idx].copy(),
'gt_boxes': val.gt_boxes[idx].copy(),
}
detector.eval()
det_res = detector[vg_collate([test[idx]], num_gpus=1)]
boxes_i, objs_i, obj_scores_i, rels_i, pred_scores_i = det_res
pred_entry = {
'pred_boxes': boxes_i * BOX_SCALE/IM_SCALE,
'pred_classes': objs_i,
'pred_rel_inds': rels_i,
'obj_scores': obj_scores_i,
'rel_scores': pred_scores_i,
}
unique_cnames = get_unique_cnames(gt_entry, test)
save_img(idx, recs, test, gt_entry, det_res, unique_cnames, save_dir)
save_gt_graph(idx, test, gt_entry, det_res, unique_cnames, save_dir)
save_pred_graph(idx, test, pred_entry, det_res,
unique_cnames, save_dir,
multi_pred=conf.multi_pred, n_pred=20)