def validate(args,
net,
val_data_loader,
val_dataset,
iteration_num,
iou_thresh=0.5):
"""Test a SSD network on an image database."""
print('Validating at ', iteration_num)
num_images = len(val_dataset)
num_classes = args.num_classes
det_boxes = [[] for _ in range(len(CLASSES))]
gt_boxes = []
print_time = True
batch_iterator = None
val_step = 100
count = 0
torch.cuda.synchronize()
ts = time.perf_counter()
for val_itr in range(len(val_data_loader)):
if not batch_iterator:
batch_iterator = iter(val_data_loader)
torch.cuda.synchronize()
t1 = time.perf_counter()
images, targets, img_indexs = next(batch_iterator)
batch_size = images.size(0)
height, width = images.size(2), images.size(3)
if args.cuda:
images = Variable(images.cuda(), volatile=True)
output = net(images)
loc_data = output[0]
conf_preds = output[1]
prior_data = output[2]
if print_time and val_itr % val_step == 0:
torch.cuda.synchronize()
tf = time.perf_counter()
print('Forward Time {:0.3f}'.format(tf - t1))
for b in range(batch_size):
gt = targets[b].numpy()
gt[:, 0] *= width
gt[:, 2] *= width
gt[:, 1] *= height
gt[:, 3] *= height
gt_boxes.append(gt)
decoded_boxes = decode(loc_data[b].data, prior_data.data,
args.cfg['variance']).clone()
conf_scores = net.softmax(conf_preds[b]).data.clone()
for cl_ind in range(1, num_classes):
scores = conf_scores[:, cl_ind].squeeze()
c_mask = scores.gt(
args.conf_thresh) # greater than minmum threshold
scores = scores[c_mask].squeeze()
# print('scores size',scores.size())
if scores.dim() == 0:
# print(len(''), ' dim ==0 ')
det_boxes[cl_ind - 1].append(np.asarray([]))
continue
boxes = decoded_boxes.clone()
l_mask = c_mask.unsqueeze(1).expand_as(boxes)
boxes = boxes[l_mask].view(-1, 4)
# idx of highest scoring and non-overlapping boxes per class
ids, counts = nms(boxes, scores, args.nms_thresh,
args.topk) # idsn - ids after nms
scores = scores[ids[:counts]].cpu().numpy()
boxes = boxes[ids[:counts]].cpu().numpy()
# print('boxes sahpe',boxes.shape)
boxes[:, 0] *= width
boxes[:, 2] *= width
boxes[:, 1] *= height
boxes[:, 3] *= height
for ik in range(boxes.shape[0]):
boxes[ik, 0] = max(0, boxes[ik, 0])
boxes[ik, 2] = min(width, boxes[ik, 2])
boxes[ik, 1] = max(0, boxes[ik, 1])
boxes[ik, 3] = min(height, boxes[ik, 3])
cls_dets = np.hstack(
(boxes, scores[:, np.newaxis])).astype(np.float32,
copy=True)
det_boxes[cl_ind - 1].append(cls_dets)
count += 1
if val_itr % val_step == 0:
torch.cuda.synchronize()
te = time.perf_counter()
print('im_detect: {:d}/{:d} time taken {:0.3f}'.format(
count, num_images, te - ts))
torch.cuda.synchronize()
ts = time.perf_counter()
if print_time and val_itr % val_step == 0:
torch.cuda.synchronize()
te = time.perf_counter()
print('NMS stuff Time {:0.3f}'.format(te - tf))
print('Evaluating detections for itration number ', iteration_num)
return evaluate_detections(gt_boxes,
det_boxes,
CLASSES,
iou_thresh=iou_thresh)
def test_net(net,
save_root,
exp_name,
input_type,
dataset,
iteration,
num_classes,
thresh=0.5):
""" Test a SSD network on an Action image database. """
val_data_loader = data.DataLoader(dataset,
args.batch_size,
num_workers=args.num_workers,
shuffle=False,
collate_fn=detection_collate,
pin_memory=True)
image_ids = dataset.ids
save_ids = []
val_step = 250
num_images = len(dataset)
video_list = dataset.video_list
det_boxes = [[] for _ in range(len(CLASSES))]
gt_boxes = []
print_time = True
batch_iterator = None
count = 0
torch.cuda.synchronize()
ts = time.perf_counter()
num_batches = len(val_data_loader)
det_file = save_root + 'cache/' + exp_name + '/detection-' + str(
iteration).zfill(6) + '.pkl'
print('Number of images ', len(dataset), ' number of batchs', num_batches)
frame_save_dir = save_root + 'detections/CONV-' + input_type + '-' + args.listid + '-' + str(
iteration).zfill(6) + '/'
print('\n\n\nDetections will be store in ', frame_save_dir, '\n\n')
for val_itr in range(len(val_data_loader)):
if not batch_iterator:
batch_iterator = iter(val_data_loader)
torch.cuda.synchronize()
t1 = time.perf_counter()
images, targets, img_indexs = next(batch_iterator)
batch_size = images.size(0)
height, width = images.size(2), images.size(3)
if args.cuda:
images = Variable(images.cuda(), volatile=True)
output = net(images)
loc_data = output[0]
conf_preds = output[1]
prior_data = output[2]
if print_time and val_itr % val_step == 0:
torch.cuda.synchronize()
tf = time.perf_counter()
print('Forward Time {:0.3f}'.format(tf - t1))
for b in range(batch_size):
gt = targets[b].numpy()
gt[:, 0] *= width
gt[:, 2] *= width
gt[:, 1] *= height
gt[:, 3] *= height
gt_boxes.append(gt)
decoded_boxes = decode(loc_data[b].data, prior_data.data,
cfg['variance']).clone()
conf_scores = net.softmax(conf_preds[b]).data.clone()
index = img_indexs[b]
annot_info = image_ids[index]
frame_num = annot_info[1]
video_id = annot_info[0]
videoname = video_list[video_id]
# output_dir = frame_save_dir+videoname
# if not os.path.isdir(output_dir):
# os.makedirs(output_dir)
#
# output_file_name = output_dir+'/{:05d}.mat'.format(int(frame_num))
# save_ids.append(output_file_name)
# sio.savemat(output_file_name, mdict={'scores':conf_scores.cpu().numpy(),'loc':decoded_boxes.cpu().numpy()})
for cl_ind in range(1, num_classes):
scores = conf_scores[:, cl_ind].squeeze()
c_mask = scores.gt(
args.conf_thresh) # greater than minmum threshold
scores = scores[c_mask].squeeze()
# print('scores size',scores.size())
if scores.dim() == 0:
# print(len(''), ' dim ==0 ')
det_boxes[cl_ind - 1].append(np.asarray([]))
continue
boxes = decoded_boxes.clone()
l_mask = c_mask.unsqueeze(1).expand_as(boxes)
boxes = boxes[l_mask].view(-1, 4)
# idx of highest scoring and non-overlapping boxes per class
ids, counts = nms(boxes, scores, args.nms_thresh,
args.topk) # idsn - ids after nms
scores = scores[ids[:counts]].cpu().numpy()
boxes = boxes[ids[:counts]].cpu().numpy()
# print('boxes sahpe',boxes.shape)
boxes[:, 0] *= width
boxes[:, 2] *= width
boxes[:, 1] *= height
boxes[:, 3] *= height
for ik in range(boxes.shape[0]):
boxes[ik, 0] = max(0, boxes[ik, 0])
boxes[ik, 2] = min(width, boxes[ik, 2])
boxes[ik, 1] = max(0, boxes[ik, 1])
boxes[ik, 3] = min(height, boxes[ik, 3])
cls_dets = np.hstack(
(boxes, scores[:, np.newaxis])).astype(np.float32,
copy=True)
det_boxes[cl_ind - 1].append(cls_dets)
count += 1
if val_itr % val_step == 0:
torch.cuda.synchronize()
te = time.perf_counter()
print('im_detect: {:d}/{:d} time taken {:0.3f}'.format(
count, num_images, te - ts))
torch.cuda.synchronize()
ts = time.perf_counter()
if print_time and val_itr % val_step == 0:
torch.cuda.synchronize()
te = time.perf_counter()
print('NMS stuff Time {:0.3f}'.format(te - tf))
print('Evaluating detections for itration number ', iteration)
# #Save detection after NMS along with GT
# with open(det_file, 'wb') as f:
# pickle.dump([gt_boxes, det_boxes, save_ids], f, pickle.HIGHEST_PROTOCOL)
return evaluate_detections(gt_boxes, det_boxes, CLASSES, iou_thresh=thresh)
def validate(args,
net,
val_data_loader,
val_dataset,
epoch,
iou_thresh=0.5,
num_gpu=1):
"""Test a SSD network on an image database."""
print('Validating at ', epoch)
num_images = len(val_dataset)
num_classes = args.num_classes
det_boxes = [[] for _ in range(len(CLASSES))]
gt_boxes = []
print_time = True
val_step = 100
count = 0
net.eval() # switch net to evaluation modelen(val_data_loader)-2,
torch.cuda.synchronize()
ts = time.perf_counter()
# create batch iterator
batch_iterator = [[] for i in range(num_gpu)]
max_x_y = 0
min_x_y = []
for i in range(num_gpu):
batch_iterator[i] = iter(val_data_loader[i])
min_x_y.append(len(val_data_loader[i]))
max_x_y = max(max_x_y, len(val_data_loader[i]))
# print("len: ", len(train_data_loader[i]))
iter_count = 0
t0 = time.perf_counter()
dtype = torch.cuda.FloatTensor
for val_itr in range(max_x_y):
img_indexs = []
for ii in range(num_gpu):
if val_itr >= min_x_y[ii]:
batch_iterator[ii] = iter(val_data_loader[ii])
torch.cuda.synchronize()
t1 = time.perf_counter()
img_indexs = []
images, targets, img_in = next(batch_iterator[0])
img_indexs.append(img_in)
img = torch.zeros([1, 3, 300, 300])
images = torch.cat((images, img.type_as(images)), 0)
for ii in range(num_gpu - 1):
img, targ, img_in = next(batch_iterator[ii + 1])
images = torch.cat((images, img), 0)
img = (torch.ones([1, 3, 300, 300]) + ii)
images = torch.cat((images, img.type_as(images)), 0)
for iii in range(len(targ)):
targets.append(targ[iii])
img_indexs.append(img_in)
batch_size = images.size(0) - num_gpu
height, width = images.size(2), images.size(3)
if args.cuda:
images = Variable(images.cuda(), volatile=True)
output = net(images, img_indexs)
loc_data = output[0]
conf_preds = output[1]
prior_data = output[2]
prior_data = prior_data[:loc_data.size(1), :]
if print_time and val_itr % val_step == 0:
torch.cuda.synchronize()
tf = time.perf_counter()
print('Forward Time {:0.3f}'.format(tf - t1))
for b in range(batch_size):
gt = targets[b].numpy()
gt[:, 0] *= width
gt[:, 2] *= width
gt[:, 1] *= height
gt[:, 3] *= height
gt_boxes.append(gt)
decoded_boxes = decode(loc_data[b].data, prior_data.data,
args.cfg['variance']).clone()
conf_scores = net.module.softmax(conf_preds[b]).data.clone()
for cl_ind in range(1, num_classes):
scores = conf_scores[:, cl_ind].squeeze()
c_mask = scores.gt(
args.conf_thresh) # greater than minmum threshold
scores = scores[c_mask].squeeze()
# print('scores size',scores.size())
if scores.dim() == 0:
# print(len(''), ' dim ==0 ')
det_boxes[cl_ind - 1].append(np.asarray([]))
continue
boxes = decoded_boxes.clone()
l_mask = c_mask.unsqueeze(1).expand_as(boxes)
boxes = boxes[l_mask].view(-1, 4)
# idx of highest scoring and non-overlapping boxes per class
ids, counts = nms(boxes, scores, args.nms_thresh,
args.topk) # idsn - ids after nms
scores = scores[ids[:counts]].cpu().numpy()
boxes = boxes[ids[:counts]].cpu().numpy()
# print('boxes sahpe',boxes.shape)
boxes[:, 0] *= width
boxes[:, 2] *= width
boxes[:, 1] *= height
boxes[:, 3] *= height
for ik in range(boxes.shape[0]):
boxes[ik, 0] = max(0, boxes[ik, 0])
boxes[ik, 2] = min(width, boxes[ik, 2])
boxes[ik, 1] = max(0, boxes[ik, 1])
boxes[ik, 3] = min(height, boxes[ik, 3])
cls_dets = np.hstack(
(boxes, scores[:, np.newaxis])).astype(np.float32,
copy=True)
det_boxes[cl_ind - 1].append(cls_dets)
count += 1
if val_itr % val_step == 0:
torch.cuda.synchronize()
te = time.perf_counter()
print('im_detect: {:d}/{:d} time taken {:0.3f}'.format(
count, num_images, te - ts))
torch.cuda.synchronize()
ts = time.perf_counter()
if print_time and val_itr % val_step == 0:
torch.cuda.synchronize()
te = time.perf_counter()
print('NMS stuff Time {:0.3f}'.format(te - tf))
print('Evaluating detections for epoch number ', epoch)
return evaluate_detections(gt_boxes,
det_boxes,
CLASSES,
iou_thresh=iou_thresh)
def test_net(net, save_root, exp_name, input_type, dataset, iteration,
li_color_class, means_bgr, n_record_per_class, th_iou):
""" Test a SSD network on an Action image database. """
'''
print('type(means) : ', type(means))
print('means : ', means)
'''
#li_color_class = make_class_color_list(num_classes)
shall_record = n_record_per_class > 0
th_conf = args.conf_thresh
th_nms = args.nms_thresh
top_k = args.topk
t3 = np.asarray(means_bgr)
means_rgb = np.flipud(t3)
#means_rgb_2 = np.fliplr(t3)
#print('t3 : ', t3); print('means_rgb_1 : ', means_rgb_1); exit(); #print('means_rgb_2 : ', means_bgr_2); exit()
#val_data_loader = data.DataLoader(dataset, args.batch_size, num_workers=args.num_workers, shuffle=False, collate_fn=detection_collate, pin_memory=True)
val_data_loader = data.DataLoader(dataset,
args.batch_size,
num_workers=args.num_workers,
shuffle=True,
collate_fn=detection_collate,
pin_memory=True)
image_ids = dataset.ids
save_ids = []
val_step = 250
num_images = len(dataset)
video_list = dataset.video_list
'''
print('type(dataset) : ', type(dataset));
print('num_images : ', num_images);
print('len(video_list) : ', len(video_list)); exit()
'''
det_boxes = [[] for _ in range(len(CLASSES))]
gt_boxes = []
print_time = True
batch_iterator = None
count = 0
torch.cuda.synchronize()
ts = time.perf_counter()
num_batches = len(val_data_loader)
det_file = save_root + 'cache/' + exp_name + '/detection-' + input_type + '_' + str(
iteration).zfill(6) + '.pkl'
print('det_file : ', det_file)
#exit()
print('Number of images ', len(dataset), ' number of batchs', num_batches)
frame_save_dir = save_root + 'detections/CONV-' + input_type + '-' + args.listid + '-' + str(
iteration).zfill(6) + '/'
print('\n\n\nDetections will be store in ', frame_save_dir, '\n\n')
if shall_record:
di_class_num_processed = {}
fn_record = 'action_recognition_images_conf_thres_{:.2f}_nms_thres_{:.1f}_fpc_{}.avi'.format(
th_conf, th_nms, n_record_per_class)
writer = make_video_recorder(fn_record, (300, 300), 20)
shall_stop = False
for val_itr in range(len(val_data_loader)):
print('\nval_itr : {} / {}'.format(val_itr, len(val_data_loader)))
if not batch_iterator:
batch_iterator = iter(val_data_loader)
torch.cuda.synchronize()
t1 = time.perf_counter()
images_rgb, targets, img_indexs = next(batch_iterator)
batch_size = images_rgb.size(0)
if shall_record:
skip_this_batch = False
for b in range(batch_size):
img_idx = img_indexs[b]
annot_info = dataset.ids[img_idx]
video_id = annot_info[0]
video_name = dataset.video_list[video_id].split("/")[0]
if video_name in di_class_num_processed:
if di_class_num_processed[video_name] > n_record_per_class:
skip_this_batch = True
break
di_class_num_processed[video_name] += 1
else:
di_class_num_processed[video_name] = 1
if skip_this_batch:
continue
height, width = images_rgb.size(2), images_rgb.size(3)
li_margin_ratio_l_r_t_b = [0, 0, 0, 0]
if args.cuda:
images_rgb = Variable(images_rgb.cuda(), volatile=True)
#exit()
#print('images_rgb.shape : ', images_rgb.shape)
######## networking forwarding ######################################################
output = net(images_rgb)
######################################################################################
loc_data = output[0]
conf_preds = output[1]
prior_data = output[2]
if print_time and val_itr % val_step == 0:
torch.cuda.synchronize()
tf = time.perf_counter()
print('Forward Time {:0.3f}'.format(tf - t1))
# for each image in this batch
for b in range(batch_size):
#print('b : {} / {}'.format(b, batch_size))
img_idx = img_indexs[b]
annot_info = dataset.ids[img_idx]
#print('annot_info : ', annot_info)
video_id = annot_info[0]
frame_num = annot_info[1]
#print('video_id : ', video_id)
video_name = dataset.video_list[video_id]
video_class = video_name.split("/")[0]
img_name = dataset._imgpath + '/{:s}/{:05d}.jpg'.format(
video_name, frame_num)
#print('video_name : ', video_name)
#print('video_class : ', video_class)
print('img_name : ', img_name)
#t1_rgb = np.transpose(images_rgb[b].cpu().numpy(), (1, 2, 0))
#exit()
t1_rgb = np.transpose(images_rgb[b].cpu().data.numpy(), (1, 2, 0))
t2_rgb = t1_rgb + means_rgb
t3_bgr = cv2.cvtColor(t2_rgb.astype(np.uint8), cv2.COLOR_RGB2BGR)
gt = targets[b].numpy()
gt[:, 0] *= width
gt[:, 2] *= width
gt[:, 1] *= height
gt[:, 3] *= height
#print('type(gt) : ', type(gt)); exit()
#cv2.putText(t3_bgr, video_name, (60, 20), cv2.FONT_HERSHEY_DUPLEX, 0.6, (0, 0, 255))
id_vid = dataset.CLASSES.index(video_class)
cv2.putText(t3_bgr, video_class,
(X_OFFSET_GT_VID, Y_OFFSET_GT_VID),
cv2.FONT_HERSHEY_DUPLEX, FONT_SCALE_GT_VID,
li_color_class[id_vid])
cv2.putText(t3_bgr, "conf. thres. : {:.2f}".format(th_conf),
(int(width * 0.5 - 85), int(height - 10)),
cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255))
if not shall_record:
t3_bgr = mark_ground_truth(t3_bgr, gt, dataset.CLASSES,
li_color_class)
gt_boxes.append(gt)
decoded_boxes = decode(loc_data[b].data, prior_data.data,
cfg['variance']).clone()
conf_scores = net.softmax(conf_preds[b]).data.clone()
t3_bgr, det_boxes = mark_detections(t3_bgr, conf_scores,
dataset.CLASSES, decoded_boxes,
(width, height),
li_margin_ratio_l_r_t_b,
li_color_class, top_k, th_conf,
th_nms, det_boxes)
#index = img_indexs[b]
annot_info = image_ids[img_idx]
#exit()
frame_num = annot_info[1]
video_id = annot_info[0]
videoname = video_list[video_id]
output_dir = frame_save_dir + videoname
if not os.path.isdir(output_dir):
os.makedirs(output_dir)
output_file_name = output_dir + '/{:05d}.mat'.format(
int(frame_num))
save_ids.append(output_file_name)
sio.savemat(output_file_name,
mdict={
'scores': conf_scores.cpu().numpy(),
'loc': decoded_boxes.cpu().numpy()
})
if shall_record:
writer.write(t3_bgr)
count += 1
cv2.imshow('t3_bgr', t3_bgr)
#cv2.waitKey(1)
k = cv2.waitKey() & 0xFF
#k = cv2.waitKey(1)
'''
if 255 != k:
print('k : ', k)
'''
if 27 == k:
shall_stop = True
if val_itr % val_step == 0:
torch.cuda.synchronize()
te = time.perf_counter()
print('im_detect: {:d}/{:d} time taken {:0.3f}'.format(
count, num_images, te - ts))
torch.cuda.synchronize()
ts = time.perf_counter()
if print_time and val_itr % val_step == 0:
torch.cuda.synchronize()
te = time.perf_counter()
print('NMS stuff Time {:0.3f}'.format(te - tf))
if shall_stop:
break
print('Evaluating detections for itration number ', iteration)
#Save detection after NMS along with GT
with open(det_file, 'wb') as f:
pickle.dump([gt_boxes, det_boxes, save_ids], f,
pickle.HIGHEST_PROTOCOL)
if shall_record:
writer.release()
convert_vid_2_animated_gif(fn_record)
return evaluate_detections(gt_boxes, det_boxes, CLASSES, iou_thresh=th_iou)
def test_net(net, priors, args, dataset, iteration, thresh=0.5 ):
""" Test a SSD network on an Action image database. """
print('Test a SSD network on an Action image database')
val_data_loader = data.DataLoader(dataset, args.batch_size, num_workers=args.num_workers,
shuffle=False, collate_fn=detection_collate, pin_memory=True)
print('Done making val dataset')
image_ids = dataset.ids
save_ids = []
val_step = 250
num_images = len(dataset)
video_list = dataset.video_list
det_boxes = [[] for _ in range(len(CLASSES[args.dataset]))]
gt_boxes = []
print_time = True
batch_iterator = None
count = 0
torch.cuda.synchronize()
ts = time.perf_counter()
num_batches = len(val_data_loader)
frame_save_dir = '{}detections/{:s}-eg{:02d}/'.format(args.save_root, args.exp_name, args.eval_gap)
softmax = nn.Softmax(dim=2).cuda()
for val_itr in range(len(val_data_loader)):
if not batch_iterator:
batch_iterator = iter(val_data_loader)
torch.cuda.synchronize()
t1 = time.perf_counter()
images, ground_truths, _ , _, num_mt, img_indexs = next(batch_iterator)
batch_size = images[0].size(0)
#images = images.permute(1, 0, 2, 3, 4)
height, width = images[0].size(3), images[0].size(4)
images = [img.cuda(0, non_blocking=True) for img in images if not isinstance(img, list)]
conf_preds, loc_data = net(images)
# pdb.set_trace()
conf_scores_all = softmax(conf_preds).clone()
if print_time and val_itr%val_step == 0:
torch.cuda.synchronize()
tf = time.perf_counter()
print('Forward Time {:0.3f}'.format(tf - t1))
for b in range(batch_size):
inds = np.asarray([m * args.seq_len for m in range(num_mt[b])])
gt = ground_truths[b].numpy()
gt = gt[inds]
gt[:, 0] *= width
gt[:, 2] *= width
gt[:, 1] *= height
gt[:, 3] *= height
gt_boxes.append(gt)
bloc_data = loc_data[b]
#print(bloc_data.size(), prior_data.size())
decoded_boxes = decode_seq(bloc_data, priors, args.cfg['variance'], args.seq_len)
decoded_boxes = decoded_boxes.cpu()
conf_scores = conf_scores_all[b].cpu().clone()
index = img_indexs[b]
annot_info = image_ids[index]
frame_num = annot_info[1][0]+1; video_id = annot_info[0]; videoname = video_list[video_id]
output_dir = frame_save_dir+videoname
if not os.path.isdir(output_dir):
os.makedirs(output_dir)
# for s in range(args.seq_len):
output_file_name_tmp = output_dir + '/{:06d}.mat'.format(int(frame_num))
# save_ids.append(output_file_name_tmp)
decoded_boxes_tmp = decoded_boxes.numpy()
#print(output_file_name_tmp)
sio.savemat(output_file_name_tmp,
mdict={'scores': conf_scores.numpy(), 'loc': decoded_boxes_tmp})
decoded_boxes = decoded_boxes[:, :4].clone()
for cl_ind in range(1, args.num_classes):
scores = conf_scores[:, cl_ind].squeeze()
c_mask = scores.gt(args.conf_thresh) # greater than minmum threshold
scores = scores[c_mask].squeeze()
# print('scores size',scores.size())
if scores.dim() == 0:
# print(len(''), ' dim ==0 ')
det_boxes[cl_ind - 1].append(np.asarray([]))
continue
boxes = decoded_boxes.clone()
l_mask = c_mask.unsqueeze(1).expand_as(boxes)
boxes = boxes[l_mask].view(-1, 4)
# idx of highest scoring and non-overlapping boxes per class
ids, counts = nms(boxes, scores, args.nms_thresh, args.topk) # idsn - ids after nms
scores = scores[ids[:counts]].numpy()
boxes = boxes[ids[:counts]].numpy()
# print('boxes sahpe',boxes.shape)
boxes[:, 0] *= width
boxes[:, 2] *= width
boxes[:, 1] *= height
boxes[:, 3] *= height
for ik in range(boxes.shape[0]):
boxes[ik, 0] = max(0, boxes[ik, 0])
boxes[ik, 2] = min(width, boxes[ik, 2])
boxes[ik, 1] = max(0, boxes[ik, 1])
boxes[ik, 3] = min(height, boxes[ik, 3])
cls_dets = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32, copy=True)
det_boxes[cl_ind - 1].append(cls_dets)
count += 1
if val_itr%val_step == 0:
torch.cuda.synchronize()
te = time.perf_counter()
print('im_detect: {:d}/{:d} time taken {:0.3f}'.format(count, num_images, te - ts))
torch.cuda.synchronize()
ts = time.perf_counter()
if print_time and val_itr%val_step == 0:
torch.cuda.synchronize()
te = time.perf_counter()
print('NMS stuff Time {:0.3f}'.format(te - tf))
print('Evaluating detections for itration number ', iteration)
#Save detection after NMS along with GT
# with open(det_file, 'wb') as f:
# pickle.dump([gt_boxes, det_boxes, save_ids], f, pickle.HIGHEST_PROTOCOL)
# if args.dataset != 'daly00000000000000000000000000':
# return 0, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], '\n\n\n AP is not COMPUTED for any of the classes in dataset \n\n\n'
# else:
return evaluate_detections(gt_boxes, det_boxes, CLASSES[args.dataset], iou_thresh=thresh)
def validate(args, net, priors, val_data_loader, val_dataset, iteration_num, iou_thresh=0.5):
"""Test a SSD network on an image database."""
print('Validating at ', iteration_num)
num_images = len(val_dataset)
num_classes = args.num_classes
priors = priors.cuda()
det_boxes = [[] for _ in range(len(CLASSES[args.dataset]))]
gt_boxes = []
print_time = True
batch_iterator = None
val_step = 100
count = 0
torch.cuda.synchronize()
ts = time.perf_counter()
softmax = nn.Softmax(dim=2).cuda()
with torch.no_grad():
for val_itr in range(len(val_data_loader)):
if not batch_iterator:
batch_iterator = iter(val_data_loader)
torch.cuda.synchronize()
t1 = time.perf_counter()
images, ground_truths, _ , _, num_mt, img_indexs = next(batch_iterator)
batch_size = images[0].size(0)
#images = images.permute(1, 0, 2, 3, 4)
height, width = images[0].size(3), images[0].size(4)
images = [img.cuda(0, non_blocking=True) for img in images if not isinstance(img, list)]
conf_preds, loc_data = net(images)
# pdb.set_trace()
conf_scores_all = softmax(conf_preds).clone()
if print_time and val_itr%val_step == 0:
torch.cuda.synchronize()
tf = time.perf_counter()
print('Forward Time {:0.3f}'.format(tf-t1))
for b in range(batch_size):
# pdb.set_trace()
inds = np.asarray([m*args.seq_len for m in range(num_mt[b])])
# pdb.set_trace()
gt = ground_truths[b].numpy()
gt = gt[inds]
gt[:,0] *= width
gt[:,2] *= width
gt[:,1] *= height
gt[:,3] *= height
gt_boxes.append(gt)
decoded_boxes = decode_seq(loc_data[b], priors, args.cfg['variance'], args.seq_len)
decoded_boxes = decoded_boxes[:,:4].clone()
conf_scores = conf_scores_all[b].clone()
#Apply nms per class and obtain the results
for cl_ind in range(1, num_classes):
# pdb.set_trace()
scores = conf_scores[:, cl_ind].squeeze()
c_mask = scores.gt(args.conf_thresh) # greater than minmum threshold
scores = scores[c_mask].squeeze() # reduce the dimension so if no element then # of dim is 0
if scores.dim() == 0:
det_boxes[cl_ind - 1].append(np.asarray([]))
continue
boxes = decoded_boxes.clone()
l_mask = c_mask.unsqueeze(1).expand_as(boxes)
boxes = boxes[l_mask].view(-1, 4)
# idx of highest scoring and non-overlapping boxes per class
ids, counts = nms(boxes, scores, args.nms_thresh, args.topk) # idsn - ids after nms
scores = scores[ids[:counts]].cpu().numpy()
boxes = boxes[ids[:counts]].cpu().numpy()
# print('boxes sahpe',boxes.shape)
boxes[:,0] *= width
boxes[:,2] *= width
boxes[:,1] *= height
boxes[:,3] *= height
for ik in range(boxes.shape[0]):
boxes[ik, 0] = max(0, boxes[ik, 0])
boxes[ik, 2] = min(width, boxes[ik, 2])
boxes[ik, 1] = max(0, boxes[ik, 1])
boxes[ik, 3] = min(height, boxes[ik, 3])
cls_dets = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32, copy=True)
det_boxes[cl_ind-1].append(cls_dets)
count += 1
if val_itr%val_step == 0:
torch.cuda.synchronize()
te = time.perf_counter()
print('im_detect: {:d}/{:d} time taken {:0.3f}'.format(count, num_images, te-ts))
torch.cuda.synchronize()
ts = time.perf_counter()
if print_time and val_itr%val_step == 0:
torch.cuda.synchronize()
te = time.perf_counter()
print('NMS stuff Time {:0.3f}'.format(te - tf))
print('Evaluating detections for itration number ', iteration_num)
return evaluate_detections(gt_boxes, det_boxes, CLASSES[args.dataset], iou_thresh=iou_thresh)
