def detect_pose(self, im, bbox): im_in = im cords = bbox[0:4] center, scale = self.x1y1x2y2_to_cs(cords) r=0 trans = get_affine_transform(center[0], scale[0], r, self.image_size) input_image = cv2.warpAffine(im_in, trans, (int(self.image_width), int(self.image_height)), flags=cv2.INTER_LINEAR) with torch.no_grad(): input = self.transform(input_image) input = input.unsqueeze(0) with torch.cuda.device(self.gpu_id): input = input.cuda() output = self.model(input) if cfg.TEST.FLIP_TEST: input_flipped = np.flip(input.cpu().numpy(),3).copy() input_flipped = torch.from_numpy(input_flipped).cuda() output_flipped = self.model(input_flipped) output_flipped = flip_back(output_flipped.cpu().numpy(), self.flip_pairs) output_flipped = torch.from_numpy(output_flipped.copy()).cuda() if cfg.TEST.SHIFT_HEATMAP: output_flipped[:, :, :, 1:] = output_flipped.clone()[:, :, :, 0:-1] output = (output + output_flipped) *0.5 output = output.cpu().numpy() preds, maxvals = self.get_final_preds(output, center, scale) preds, maxvals = preds.squeeze(), maxvals.squeeze() heatmaps = output.squeeze() #For posetrack dataset, the 3th and 4th channel is None preds = np.delete(preds, [3,4], axis=0) maxvals = np.delete(maxvals, [3,4], axis=0) heatmaps = np.delete(heatmaps, [3,4], axis=0) #print(heatmaps.shape,preds,maxvals) return preds, maxvals, heatmaps
def detect_pose_secway(self, im, bbox): cords = bbox[0:4] H, W, C = im.shape xmin, ymin, xmax, ymax = [int(i) for i in cords] xmax = min(xmax, W) ymax = min(ymax, H) xmin = max(xmin, 0) ymin = max(ymin, 0) w, h = xmax - xmin, ymax - ymin if w < 0 or h < 0: return np.zeros([17, 2]), np.zeros([17]), np.zeros([17, 64, 64]) im_in = im[ymin:ymax, xmin:xmax, :] scale_factor = [self.image_width / w, self.image_height / h] im_resize = cv2.resize(im_in, (int(self.image_width), int(self.image_height)), interpolation=cv2.INTER_LINEAR) with torch.no_grad(): input = self.transform(im_resize) input = input.unsqueeze(0) with torch.cuda.device(self.gpu_id): adj = self.reset_adj_no1() adj = adj.unsqueeze(0) adj = adj.type(torch.cuda.FloatTensor) input = input.cuda() output = self.model(input, adj) if cfg.TEST.FLIP_TEST: input_flipped = np.flip(input.cpu().numpy(), 3).copy() input_flipped = torch.from_numpy(input_flipped).cuda() output_flipped = self.model(input_flipped, adj) output_flipped = flip_back(output_flipped.cpu().numpy(), self.flip_pairs) output_flipped = torch.from_numpy( output_flipped.copy()).cuda() if cfg.TEST.SHIFT_HEATMAP: output_flipped[:, :, :, 1:] = output_flipped.clone()[:, :, :, 0:-1] output = (output + output_flipped) * 0.5 preds, maxvals = get_max_preds(output.clone().cpu().numpy()) preds, maxvals = preds.squeeze() * 4, maxvals.squeeze() heatmaps = output.cpu().numpy().squeeze() #For posetrack dataset, the 3th and 4th channel is None preds = np.delete(preds, [3, 4], axis=0) preds[:, 0] = preds[:, 0] / scale_factor[0] + bbox[0] preds[:, 1] = preds[:, 1] / scale_factor[1] + bbox[1] maxvals = np.delete(maxvals, [3, 4], axis=0) heatmaps = np.delete(heatmaps, [3, 4], axis=0) return preds, maxvals, heatmaps
def validate(val_loader, model, criterion, num_classes, debug=False, flip=True): batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() acces = AverageMeter() # predictions predictions = torch.Tensor(val_loader.dataset.__len__(), num_classes, 2) # switch to evaluate mode model.eval() gt_win, pred_win = None, None end = time.time() bar = Bar('Eval ', max=len(val_loader)) with torch.no_grad(): for i, (input, target, meta) in enumerate(val_loader): # measure data loading time data_time.update(time.time() - end) input = input.to(device, non_blocking=True) target = target.to(device, non_blocking=True) target_weight = meta['target_weight'].to(device, non_blocking=True) # compute output output = model(input) score_map = output[-1].cpu() if type( output) == list else output.cpu() if flip: flip_input = torch.from_numpy(fliplr( input.clone().numpy())).float().to(device) flip_output = model(flip_input) flip_output = flip_output[-1].cpu() if type( flip_output) == list else flip_output.cpu() flip_output = flip_back(flip_output) score_map += flip_output if type(output) == list: # multiple output loss = 0 for o in output: loss += criterion(o, target, target_weight) output = output[-1] else: # single output loss = criterion(output, target, target_weight) acc = accuracy(score_map, target.cpu(), idx) # generate predictions preds = final_preds(score_map, meta['center'], meta['scale'], [64, 64]) for n in range(score_map.size(0)): predictions[meta['index'][n], :, :] = preds[n, :, :] if debug: gt_batch_img = batch_with_heatmap(input, target) pred_batch_img = batch_with_heatmap(input, score_map) if not gt_win or not pred_win: plt.subplot(121) gt_win = plt.imshow(gt_batch_img) plt.subplot(122) pred_win = plt.imshow(pred_batch_img) else: gt_win.set_data(gt_batch_img) pred_win.set_data(pred_batch_img) plt.pause(.05) plt.draw() # measure accuracy and record loss losses.update(loss.item(), input.size(0)) acces.update(acc[0], input.size(0)) # measure elapsed time batch_time.update(time.time() - end) end = time.time() # plot progress bar.suffix = '({batch}/{size}) Data: {data:.6f}s | Batch: {bt:.3f}s | Total: {total:} | ETA: {eta:} | Loss: {loss:.4f} | Acc: {acc: .4f}'.format( batch=i + 1, size=len(val_loader), data=data_time.val, bt=batch_time.avg, total=bar.elapsed_td, eta=bar.eta_td, loss=losses.avg, acc=acces.avg) bar.next() bar.finish() return losses.avg, acces.avg, predictions
def validate(val_loader, model, criterion, num_classes, debug=False, flip=True, _logger=None): batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() acces = AverageMeter() # predictions predictions = torch.Tensor(val_loader.dataset.__len__(), num_classes, 2) autoloss = models.loss.UniLoss(valid=True) # switch to evaluate mode model.eval() #model.train() gt_win, pred_win = None, None end = time.time() bar = Bar('Processing', max=len(val_loader)) for i, (inputs, target, meta) in enumerate(val_loader): # measure data loading time data_time.update(time.time() - end) target = target.cuda(async=True) input_var = torch.autograd.Variable(inputs.cuda(), volatile=True) target_var = torch.autograd.Variable(target, volatile=True) # compute output output = model(input_var) score_map = output[-1].data.cpu() if flip: flip_input_var = torch.autograd.Variable( torch.from_numpy(fliplr(inputs.clone().numpy())).float().cuda(), volatile=True ) flip_output_var = model(flip_input_var) flip_output = flip_back(flip_output_var[-1].data.cpu()) score_map += flip_output loss = 0 for o in output: loss += criterion(o, target_var) #acc = accuracy(score_map, target.cpu(), idx) _, acc, _ = autoloss(output[-1], meta) # generate predictions preds = final_preds(score_map, meta['center'], meta['scale'], [64, 64]) for n in range(score_map.size(0)): predictions[meta['index'][n], :, :] = preds[n, :, :] if debug: gt_batch_img = batch_with_heatmap(inputs, target) pred_batch_img = batch_with_heatmap(inputs, score_map) if not gt_win or not pred_win: plt.subplot(121) gt_win = plt.imshow(gt_batch_img) plt.subplot(122) pred_win = plt.imshow(pred_batch_img) else: gt_win.set_data(gt_batch_img) pred_win.set_data(pred_batch_img) plt.pause(.05) plt.draw() # measure accuracy and record loss losses.update(loss.item(), inputs.size(0)) acces.update(acc.item(), inputs.size(0)) # measure elapsed time batch_time.update(time.time() - end) end = time.time() # plot progress bar.suffix = '({batch}/{size}) Data: {data:.6f}s | Batch: {bt:.3f}s | Total: {total:} | Loss: {loss:.4f} | Acc: {acc: .4f}'.format( batch=i + 1, size=len(val_loader), data=data_time.val, bt=batch_time.avg, total=bar.elapsed_td, loss=losses.avg*100, acc=acces.avg*100 ) _logger.info(bar.suffix) bar.finish() return losses.avg*100, acces.avg*100, predictions
def validate(val_loader, model, criterion, num_classes, idx, save_result_dir, meta_dir, anno_type, flip=True, evaluate=False, scales=[0.7, 0.8, 0.9, 1, 1.2, 1.4, 1.6], multi_scale=False, save_heatmap=False): anno_type = anno_type[0].lower() batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() acces = AverageMeter() num_scales = len(scales) # switch to evaluate mode model.eval() meanstd_file = '../datasets/arm/mean.pth.tar' meanstd = torch.load(meanstd_file) mean = meanstd['mean'] gt_win, pred_win = None, None end = time.time() bar = Bar('Processing', max=len(val_loader)) for i, (inputs, target, meta) in enumerate(val_loader): #print(inputs.shape) # measure data loading time data_time.update(time.time() - end) if anno_type != 'none': target = target.cuda(async=True) target_var = torch.autograd.Variable(target) input_var = torch.autograd.Variable(inputs.cuda()) with torch.no_grad(): # compute output output = model(input_var) score_map = output[-1].data.cpu() if flip: flip_input_var = torch.autograd.Variable( torch.from_numpy(fliplr( inputs.clone().numpy())).float().cuda(), ) flip_output_var = model(flip_input_var) flip_output = flip_back(flip_output_var[-1].data.cpu(), meta_dir=meta_dir[0]) score_map += flip_output score_map /= 2 if anno_type != 'none': loss = 0 for o in output: loss += criterion(o, target_var) acc = accuracy(score_map, target.cpu(), idx, pck_threshold) if multi_scale: new_scales = [] new_res = [] new_score_map = [] new_inp = [] new_meta = [] img_name = [] confidence = [] new_center = [] num_imgs = score_map.size(0) // num_scales for n in range(num_imgs): score_map_merged, res, conf = multi_scale_merge( score_map[num_scales * n:num_scales * (n + 1)].numpy(), meta['scale'][num_scales * n:num_scales * (n + 1)]) inp_merged, _, _ = multi_scale_merge( inputs[num_scales * n:num_scales * (n + 1)].numpy(), meta['scale'][num_scales * n:num_scales * (n + 1)]) new_score_map.append(score_map_merged) new_scales.append(meta['scale'][num_scales * (n + 1) - 1]) new_center.append(meta['center'][num_scales * n]) new_res.append(res) new_inp.append(inp_merged) img_name.append(meta['img_name'][num_scales * n]) confidence.append(conf) if len(new_score_map) > 1: score_map = torch.tensor( np.stack(new_score_map)) #stack back to 4-dim inputs = torch.tensor(np.stack(new_inp)) else: score_map = torch.tensor( np.expand_dims(new_score_map[0], axis=0)) inputs = torch.tensor(np.expand_dims(new_inp[0], axis=0)) else: img_name = [] confidence = [] for n in range(score_map.size(0)): img_name.append(meta['img_name'][n]) confidence.append( np.amax(score_map[n].numpy(), axis=(1, 2)).tolist()) # generate predictions if multi_scale: preds = final_preds(score_map, new_center, new_scales, new_res[0]) else: preds = final_preds(score_map, meta['center'], meta['scale'], [64, 64]) for n in range(score_map.size(0)): if evaluate: with open( os.path.join(save_result_dir, 'preds', img_name[n] + '.json'), 'w') as f: obj = { 'd2_key': preds[n].numpy().tolist(), 'score': confidence[n] } json.dump(obj, f) if evaluate: for n in range(score_map.size(0)): inp = inputs[n] pred = score_map[n] for t, m in zip(inp, mean): t.add_(m) scipy.misc.imsave( os.path.join(save_result_dir, 'visualization', '{}.jpg'.format(img_name[n])), sample_with_heatmap(inp, pred)) if save_heatmap: score_map_original_size = align_back( score_map[n], meta['center'][n], meta['scale'][len(scales) * n - 1], meta['original_size'][n]) np.save( os.path.join(save_result_dir, 'heatmaps', '{}.npy'.format(img_name[n])), score_map_original_size) if anno_type != 'none': # measure accuracy and record loss losses.update(loss.item(), inputs.size(0)) acces.update(acc[0], inputs.size(0)) # measure elapsed time batch_time.update(time.time() - end) end = time.time() # plot progress bar.suffix = '({batch}/{size}) Data: {data:.6f}s | Batch: {bt:.3f}s | Total: {total:} | ETA: {eta:} | Loss: {loss:.4f} | Acc: {acc: .4f}'.format( batch=i + 1, size=len(val_loader), data=data_time.val, bt=batch_time.avg, total=bar.elapsed_td, eta=bar.eta_td, loss=losses.avg, acc=acces.avg) bar.next() bar.finish() if anno_type != 'none': return losses.avg, acces.avg else: return 0, 0
def validate(val_loader, model, criterion, num_classes, args, flip=False, test_batch=6): batch_time = AverageMeter() data_time = AverageMeter() acces = AverageMeter() pck_score = np.zeros(num_classes) pck_count = np.zeros(num_classes) # predictions predictions = torch.Tensor(val_loader.dataset.__len__(), num_classes, 2) # switch to evaluate mode model.eval() gt_win, pred_win = None, None end = time.time() bar = Bar('Eval ', max=len(val_loader)) with torch.no_grad(): for i, (input, target, meta) in enumerate(val_loader): # measure data loading time data_time.update(time.time() - end) input = input.to(device, non_blocking=True) target = target.to(device, non_blocking=True) target_weight = meta['target_weight'].to(device, non_blocking=True) # compute output if args.arch == 'hg': output = model(input) elif args.arch == 'hg_multitask': output, _ = model(input) else: raise Exception("unspecified arch") score_map = output[-1].cpu() if type( output) == list else output.cpu() if flip: flip_input = torch.from_numpy( fliplr(input.clone().cpu().numpy())).float().to(device) flip_output = model(flip_input) flip_output = flip_output[-1].cpu() if type( flip_output) == list else flip_output.cpu() flip_output = flip_back(flip_output) score_map += flip_output acc, _ = accuracy_2animal(score_map, target.cpu(), idx1, idx2) # cal per joint [email protected] for j in range(num_classes): if acc[j + 1] > -1: pck_score[j] += acc[j + 1].numpy() pck_count[j] += 1 # generate predictions preds = final_preds(score_map, meta['center'], meta['scale'], [64, 64]) for n in range(score_map.size(0)): predictions[meta['index'][n], :, :] = preds[n, :, :] # measure accuracy and record loss acces.update(acc[0], input.size(0)) # measure elapsed time batch_time.update(time.time() - end) end = time.time() # plot progress bar.suffix = '({batch}/{size}) Data: {data:.3f}s | Batch: {bt:.3f}s | Total: {total:} | ETA: {eta:} | Acc: {acc: .8f}'.format( batch=i + 1, size=len(val_loader), data=data_time.val, bt=batch_time.avg, total=bar.elapsed_td, eta=bar.eta_td, acc=acces.avg) bar.next() bar.finish() for j in range(num_classes): pck_score[j] /= float(pck_count[j]) print("\nper joint [email protected]:") print(list(pck_score)) return _, acces.avg, predictions
def validate(val_loader, model, criterion, num_classes, debug=False, flip=True): batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() acces = AverageMeter() # predictions predictions = torch.Tensor(val_loader.dataset.__len__(), num_classes, 2) # switch to evaluate mode model.eval() gt_win, pred_win = None, None end = time.time() bar = Bar('Eval ', max=len(val_loader)) with torch.no_grad(): for i, (input, target, meta, img_path) in enumerate(val_loader): # measure data loading time data_time.update(time.time() - end) indexes = [] input = input.to(device, non_blocking=True) #print (input.shape) #image = input.cpu().permute(0,2,3,1).numpy() #image = np.squeeze(image) path = str(img_path) path = path[3:len(path) - 2] image = cv2.imread(path) # cv2.imshow("image", image) # cv2.waitKey(10) # time.sleep(1) target = target.to(device, non_blocking=True) target_weight = meta['target_weight'].to(device, non_blocking=True) # compute output #print (input.shape) output = model(input) score_map = output[-1].cpu() if type( output) == list else output.cpu() if flip: flip_input = torch.from_numpy(fliplr( input.clone().numpy())).float().to(device) flip_output = model(flip_input) flip_output = flip_output[-1].cpu() if type( flip_output) == list else flip_output.cpu() flip_output = flip_back(flip_output) score_map += flip_output if type(output) == list: # multiple output loss = 0 for o in output: loss += criterion(o, target, target_weight) output = output[-1] else: # single output loss = criterion(output, target, target_weight) #print (acc) # generate predictions preds, vals = final_preds(score_map, meta['center'], meta['scale'], [64, 64]) # for z in range(target.shape[1]): # for j in range(target.shape[2]): # for k in range(target.shape[3]): # if target[0,z,j,k]==1.0: # indexes.append(z) # coords = np.squeeze(preds) # for m in range(0,len(coords)): # val = vals[0][m].numpy() # if val>0.6: #threshold for confidence score # x,y = coords[m][0].cpu().numpy(), coords[m][1].cpu().numpy() # cv2.circle(image, (x,y), 1, (0,0,255), -1) # #indexes.append(m) acc = accuracy(score_map, target.cpu(), indexes) #print ((target.cpu()).shape[1]) for n in range(score_map.size(0)): predictions[meta['index'][n], :, :] = preds[n, :, :] #print ("scored", score_map.shape) if debug: gt_batch_img = batch_with_heatmap(input, target) pred_batch_img = batch_with_heatmap(input, score_map) if not gt_win or not pred_win: plt.subplot(121) gt_win = plt.imshow(gt_batch_img) plt.subplot(122) pred_win = plt.imshow(pred_batch_img) else: gt_win.set_data(gt_batch_img) pred_win.set_data(pred_batch_img) plt.pause(.05) plt.draw() cv2.imwrite( '/home/shantam/Documents/Programs/pytorch-pose/example/predictions/pred' + str(i) + '.png', image) #time.sleep(5) # measure accuracy and record loss losses.update(loss.item(), input.size(0)) acces.update(acc[0], input.size(0)) # measure elapsed time batch_time.update(time.time() - end) end = time.time() # plot progress bar.suffix = '({batch}/{size}) Data: {data:.6f}s | Batch: {bt:.3f}s | Total: {total:} | ETA: {eta:} | Loss: {loss:.4f} | Acc: {acc: .4f}'.format( batch=i + 1, size=len(val_loader), data=data_time.val, bt=batch_time.avg, total=bar.elapsed_td, eta=bar.eta_td, loss=losses.avg, acc=acces.avg) bar.next() bar.finish() return losses.avg, acces.avg, predictions
def validate(val_loader, model, criterion, num_classes, debug=False, flip=True): batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() acces = AverageMeter() # predictions predictions = torch.Tensor(val_loader.dataset.__len__(), num_classes, 2) # switch to evaluate mode model.eval() gt_win, pred_win = None, None end = time.time() bar = Bar('Processing', max=len(val_loader)) for i, (inputs, target, meta) in enumerate(val_loader): # measure data loading time data_time.update(time.time() - end) target = target.cuda(async=True) input_var = torch.autograd.Variable(inputs.cuda(), volatile=True) target_var = torch.autograd.Variable(target, volatile=True) # compute output output = model(input_var) score_map = output[-1].data.cpu() if flip: flip_input_var = torch.autograd.Variable( torch.from_numpy( fliplr(inputs.clone().numpy())).float().cuda(), volatile=True ) flip_output_var = model(flip_input_var) flip_output = flip_back(flip_output_var[-1].data.cpu()) score_map += flip_output loss = 0 for o in output: loss += criterion(o, target_var) acc = accuracy_segm(score_map, target.cpu()) if debug: for j in range(len(score_map)): save_im_in(inputs[j], "debug/test_in_{}.jpg".format(j)) save_im_out(score_map[j, 0, :, :], "debug/test_out_{}.jpg".format(j)) save_im_out(target[j, 0, :, :], "debug/test_target_{}.jpg".format(j)) # measure accuracy and record loss losses.update(loss.data[0], inputs.size(0)) acces.update(acc[0], inputs.size(0)) # measure elapsed time batch_time.update(time.time() - end) end = time.time() # plot progress bar.suffix = '({batch}/{size}) Data: {data:.6f}s | Batch: {bt:.3f}s | Total: {total:} | ETA: {eta:} | Loss: {loss:.4f} | Acc: {acc: .4f}'.format( batch=i + 1, size=len(val_loader), data=data_time.val, bt=batch_time.avg, total=bar.elapsed_td, eta=bar.eta_td, loss=losses.avg, acc=acces.avg ) bar.next() bar.finish() return losses.avg, acces.avg
def validate(val_loader, model, criterion, num_classes, args, flip=False, test_batch=6): batch_time = AverageMeter() data_time = AverageMeter() acces = AverageMeter() pck_score = np.zeros(num_classes) pck_count = np.zeros(num_classes) # predictions predictions = torch.Tensor(val_loader.dataset.__len__(), num_classes, 2) # switch to evaluate mode model.eval() end = time.time() bar = Bar('Eval ', max=len(val_loader)) with torch.no_grad(): for i, (input, target, meta) in enumerate(val_loader): # measure data loading time data_time.update(time.time() - end) input = input.to(device, non_blocking=True) target = target.to(device, non_blocking=True) output, output_refine = model(input, 1, return_domain=False) score_map = output_refine[0].cpu() if flip: flip_input = torch.from_numpy( fliplr(input.clone().cpu().numpy())).float().to(device) _, flip_output_refine = model(flip_input, 1, return_domain=False) flip_output = flip_output_refine[0].cpu() flip_output = flip_back(flip_output, 'real_animal') score_map += flip_output acc, _ = accuracy_2animal(score_map, target.cpu(), idx1, idx2) # cal per joint [email protected] for j in range(num_classes): if acc[j + 1] > -1: pck_score[j] += acc[j + 1].numpy() pck_count[j] += 1 # generate predictions preds = final_preds(score_map, meta['center'], meta['scale'], [64, 64]) for n in range(score_map.size(0)): predictions[meta['index'][n], :, :] = preds[n, :, :] # measure accuracy and record loss acces.update(acc[0], input.size(0)) # measure elapsed time batch_time.update(time.time() - end) end = time.time() # plot progress bar.suffix = '({batch}/{size}) Data: {data:.3f}s | Batch: {bt:.3f}s | Total: {total:} | ETA: {eta:} | Acc: {acc: .8f}'.format( batch=i + 1, size=len(val_loader), data=data_time.val, bt=batch_time.avg, total=bar.elapsed_td, eta=bar.eta_td, acc=acces.avg) bar.next() bar.finish() for j in range(num_classes): pck_score[j] /= float(pck_count[j]) print("\nper joint [email protected]:") print('Animal: {}, total number of joints: {}'.format( args.animal, pck_count.sum())) print(list(pck_score)) parts = { 'eye': [0, 1], 'chin': [2], 'hoof': [3, 4, 5, 6], 'hip': [7], 'knee': [8, 9, 10, 11], 'shoulder': [12, 13], 'elbow': [14, 15, 16, 17] } for p in parts.keys(): part = parts[p] score = 0. count = 0. for joint in part: score += pck_score[joint] * pck_count[joint] count += pck_count[joint] print('\n Joint {}: {} '.format(p, score / count)) return _, acces.avg, predictions
def validate(val_loader, model, criterion, debug=False, flip=True, test_batch=6, njoints=68): batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() acces = AverageMeter() # predictions predictions = torch.Tensor(val_loader.dataset.__len__(), njoints, 2) # switch to evaluate mode model.eval() gt_win, pred_win = None, None end = time.time() bar = Bar('Eval ', max=len(val_loader)) interocular_dists = torch.zeros((njoints, val_loader.dataset.__len__())) with torch.no_grad(): for i, (input, target, meta) in enumerate(val_loader): # measure data loading time data_time.update(time.time() - end) input = input.to(device, non_blocking=True) target = target.to(device, non_blocking=True) target_weight = meta['target_weight'].to(device, non_blocking=True) # compute output output = model(input) score_map = output[-1].cpu() if type( output) == list else output.cpu() if flip: flip_input = torch.from_numpy(fliplr( input.clone().numpy())).float().to(device) flip_output = model(flip_input) flip_output = flip_output[-1].cpu() if type( flip_output) == list else flip_output.cpu() flip_output = flip_back(flip_output) score_map += flip_output if type(output) == list: # multiple output loss = 0 for o in output: loss += criterion(o, target, target_weight, len(idx)) output = output[-1] else: # single output loss = criterion(output, target, target_weight, len(idx)) acc, batch_interocular_dists = accuracy(score_map, target.cpu(), idx) interocular_dists[:, i * test_batch:(i + 1) * test_batch] = batch_interocular_dists # generate predictions preds = final_preds(score_map, meta['center'], meta['scale'], [64, 64]) for n in range(score_map.size(0)): predictions[meta['index'][n], :, :] = preds[n, :, :] if debug: gt_batch_img = batch_with_heatmap(input, target) pred_batch_img = batch_with_heatmap(input, score_map) if not gt_win or not pred_win: plt.subplot(121) gt_win = plt.imshow(gt_batch_img) plt.subplot(122) pred_win = plt.imshow(pred_batch_img) else: gt_win.set_data(gt_batch_img) pred_win.set_data(pred_batch_img) plt.pause(.05) plt.draw() # measure accuracy and record loss losses.update(loss.item(), input.size(0)) acces.update(acc[0], input.size(0)) # measure elapsed time batch_time.update(time.time() - end) end = time.time() # plot progress bar.suffix = '({batch}/{size}) Data: {data:.3f}s | Batch: {bt:.3f}s | Total: {total:} | ETA: {eta:} | Loss: {loss:.8f} | Acc: {acc: .8f}'.format( batch=i + 1, size=len(val_loader), data=data_time.val, bt=batch_time.avg, total=bar.elapsed_td, eta=bar.eta_td, loss=losses.avg, acc=acces.avg) bar.next() bar.finish() idx_array = np.array(idx) - 1 interocular_dists_pickup = interocular_dists[idx_array, :] mean_error = torch.mean( interocular_dists_pickup[interocular_dists_pickup != -1]) auc = calc_metrics(interocular_dists, idx) # this is auc of predicted maps and target. #print("=> Mean Error: {:.8f}, [email protected]: {:.8f} based on maps".format(mean_error, auc)) return losses.avg, acces.avg, predictions, auc, mean_error
def validate(self): batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() acces = AverageMeter() predictions = torch.Tensor(self.val_loader.dataset.__len__(), self.num_classes, 2) self.netG.eval() gt_win, pred_win = None, None end = time.time() bar = Bar('Eval ', max=len(self.val_loader)) with torch.no_grad(): for i, (input, target, meta, mpii) in enumerate(self.val_loader): if mpii == False: continue data_time.update(time.time() - end) input = input.to(self.device, non_blocking=True) target = target.to(self.device, non_blocking=True) target_weight = meta['target_weight'].to(self.device, non_blocking=True) output = self.netG(input) score_map = output[-1].cpu() if type( output) == list else output.cpu() if self.flip: flip_input = torch.from_numpy flip_output = self.netG(flip_input) flip_output = flip_output[-1].cpu() if type( flip_output) == list else flip_output.cpu() flip_output = flip_back(flip_output) score_map += flip_output if type(output) == list: loss = 0 for o in output: loss += self.criterion(o, target, target_weight) output = output[-1] else: loss = self.criterion(output, target, target_weight) acc = accuracy(score_map, target.cpu(), self.idx) preds = final_preds(score_map, meta['center'], meta['scale'], [64, 64]) for n in range(score_map.size(0)): predictions[meta['index'][n], :, :] = preds[n, :, :] if self.debug: gt_batch_img = batch_with_heatmap(input, target) pred_batch_img = batch_with_heatmap(input, score_map) if not gt_win or not pred_win: plt.subplot(121) gt_win = plt.imshow(gt_batch_img) plt.subplot(122) pred_win = plt.imshow(pred_batch_img) else: gt_win.set_data(gt_batch_img) pred_win.set_data(pred_batch_img) plt.pause(.05) plt.draw() losses.update(loss.item, input.size(0)) acces.update(acc[0], input.size(0)) batch_time.update(time.time() - end) end = time.time() bar.suffix = '({batch}/{size}) Data: {data:.6f}s | Batch: {bt:.3f}s | Total: {total:} | ETA: {eta:} | Loss: {loss:.4f} | Acc: {acc: .4f}'.format( batch=i + 1, size=len(self.val_loader), data=data_time.val, bt=batch_time.avg, total=bar.elapsed_td, eta=bar.eta_td, loss=losses.avg, acc=acces.avg) bar.next() bar.finish() return losses.avg, acces.avg, predictions
def validate(val_loader, model, criterion, flip=True, test_batch=6, njoints=18): batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() acces = AverageMeter() # predictions predictions = torch.Tensor(val_loader.dataset.__len__(), njoints, 2) # switch to evaluate mode model.eval() gt_win, pred_win = None, None end = time.time() bar = Bar('Eval ', max=len(val_loader)) with torch.no_grad(): for i, (input, target, meta) in enumerate(val_loader): # measure data loading time data_time.update(time.time() - end) input = input.to(device, non_blocking=True) if global_animal == 'horse': target = target.to(device, non_blocking=True) target_weight = meta['target_weight'].to(device, non_blocking=True) elif global_animal == 'tiger': target = target.to(device, non_blocking=True) target_weight = meta['target_weight'].to(device, non_blocking=True) target = target[:, np.array([ 1, 2, 3, 4, 5, 6, 7, 8, 15, 16, 17, 18, 13, 14, 9, 10, 11, 12 ]) - 1, :, :] target_weight = target_weight[:, np.array([ 1, 2, 3, 4, 5, 6, 7, 8, 15, 16, 17, 18, 13, 14, 9, 10, 11, 12 ]) - 1, :] else: raise Exception('please add new animal category') # compute output output = model(input) score_map = output[-1].cpu() if type( output) == list else output.cpu() if flip: flip_input = torch.from_numpy(fliplr( input.clone().numpy())).float().to(device) flip_output = model(flip_input) flip_output = flip_output[-1].cpu() if type( flip_output) == list else flip_output.cpu() flip_output = flip_back(flip_output) score_map += flip_output if type(output) == list: # multiple output loss = 0 for o in output: loss += criterion(o, target, target_weight, len(idx)) output = output[-1] else: # single output loss = criterion(output, target, target_weight, len(idx)) acc, _ = accuracy(score_map, target.cpu(), idx) # generate predictions preds = final_preds(score_map, meta['center'], meta['scale'], [64, 64]) #for n in range(score_map.size(0)): # predictions[meta['index'][n], :, :] = preds[n, :, :] # measure accuracy and record loss losses.update(loss.item(), input.size(0)) acces.update(acc[0], input.size(0)) # measure elapsed time batch_time.update(time.time() - end) end = time.time() # plot progress bar.suffix = '({batch}/{size}) Data: {data:.3f}s | Batch: {bt:.3f}s | Total: {total:} | ETA: {eta:} | Loss: {loss:.8f} | Acc: {acc: .8f}'.format( batch=i + 1, size=len(val_loader), data=data_time.val, bt=batch_time.avg, total=bar.elapsed_td, eta=bar.eta_td, loss=losses.avg, acc=acces.avg) bar.next() bar.finish() return losses.avg, acces.avg
def validate(val_loader, model, criterion, criterion_seg, debug=False, flip=True, test_batch=6, njoints=68): batch_time = AverageMeter() data_time = AverageMeter() losses_kpt = AverageMeter() losses_seg = AverageMeter() acces = AverageMeter() inter_meter = AverageMeter() union_meter = AverageMeter() # predictions predictions = torch.Tensor(val_loader.dataset.__len__(), njoints, 2) # switch to evaluate mode model.eval() gt_win, pred_win = None, None end = time.time() bar = Bar('Eval ', max=len(val_loader)) interocular_dists = torch.zeros((njoints, val_loader.dataset.__len__())) with torch.no_grad(): for i, (input, target, target_seg, meta) in enumerate(val_loader): # measure data loading time data_time.update(time.time() - end) input, target, target_seg = input.to(device), target.to( device, non_blocking=True), target_seg.to(device) target_weight = meta['target_weight'].to(device, non_blocking=True) # compute output output_kpt, output_seg = model(input) score_map = output_kpt[-1].cpu() if type( output_kpt) == list else output_kpt.cpu() if flip: flip_input = torch.from_numpy(fliplr( input.clone().numpy())).float().to(device) flip_output = model(flip_input) flip_output = flip_output[-1].cpu() if type( flip_output) == list else flip_output.cpu() flip_output = flip_back(flip_output) score_map += flip_output if type(output_kpt) == list: # multiple output loss_kpt = 0 loss_seg = 0 for (o, o_seg) in zip(output_kpt, output_seg): loss_kpt += criterion(o, target, target_weight, len(idx)) loss_seg += criterion_seg(o_seg, target_seg) output = output_kpt[-1] output_seg = output_seg[-1] else: # single output loss_kpt = criterion(output_kpt, target, target_weight, len(idx)) loss_seg = criterion(output_seg, target_seg) acc, batch_interocular_dists = accuracy(score_map, target.cpu(), idx) _, pred_seg = torch.max(output_seg, 1) # generate predictions preds = final_preds(score_map, meta['center'], meta['scale'], [64, 64]) for n in range(score_map.size(0)): predictions[meta['index'][n], :, :] = preds[n, :, :] if debug: gt_batch_img = batch_with_heatmap(input, target) pred_batch_img = batch_with_heatmap(input, score_map) if not gt_win or not pred_win: plt.subplot(121) gt_win = plt.imshow(gt_batch_img) plt.subplot(122) pred_win = plt.imshow(pred_batch_img) else: gt_win.set_data(gt_batch_img) pred_win.set_data(pred_batch_img) plt.pause(.05) plt.draw() # measure accuracy and record loss losses_kpt.update(loss_kpt.item(), input.size(0)) losses_seg.update(loss_seg.item(), input.size(0)) acces.update(acc[0], input.size(0)) inter, union = inter_and_union( pred_seg.data.cpu().numpy().astype(np.uint8), target_seg.data.cpu().numpy().astype(np.uint8)) inter_meter.update(inter) union_meter.update(union) # measure elapsed time batch_time.update(time.time() - end) end = time.time() iou = inter_meter.sum / (union_meter.sum + 1e-10) # plot progress bar.suffix = '({batch}/{size}) Data: {data:.3f}s | Batch: {bt:.3f}s | Total: {total:} | ETA: {eta:} | Loss_kpt: {loss_kpt:.8f} | Loss_seg: {loss_seg:.8f} | Acc: {acc: .8f} | IOU: {iou:.2f}'.format( batch=i + 1, size=len(val_loader), data=data_time.val, bt=batch_time.avg, total=bar.elapsed_td, eta=bar.eta_td, loss_kpt=losses_kpt.avg, loss_seg=losses_seg.avg, acc=acces.avg, iou=iou.mean() * 100) bar.next() bar.finish() print(iou) return losses_kpt.avg, acces.avg, predictions, iou.mean() * 100
def validate(config, val_loader, val_dataset, model, criterion, output_dir, tb_log_dir, writer_dict=None): batch_time = AverageMeter() losses = AverageMeter() acc = AverageMeter() # switch to evaluate mode model.eval() num_samples = len(val_dataset) all_preds = np.zeros((num_samples, config.MODEL.NUM_JOINTS, 3), dtype=np.float32) all_boxes = np.zeros((num_samples, 6)) image_path = [] image_ids = [] bbox_infos = [] filenames = [] imgnums = [] idx = 0 with torch.no_grad(): end = time.time() for i, (input, target, target_weight, meta) in enumerate(val_loader): # compute output output = model(input) if config.TEST.FLIP_TEST: # this part is ugly, because pytorch has not supported negative index # input_flipped = model(input[:, :, :, ::-1]) input_flipped = np.flip(input.cpu().numpy(), 3).copy() input_flipped = torch.from_numpy(input_flipped).cuda() output_flipped = model(input_flipped) output_flipped = flip_back(output_flipped.cpu().numpy(), val_dataset.flip_pairs) output_flipped = torch.from_numpy(output_flipped.copy()).cuda() # feature is not aligned, shift flipped heatmap for higher accuracy if config.TEST.SHIFT_HEATMAP: output_flipped[:, :, :, 1:] = \ output_flipped.clone()[:, :, :, 0:-1] # output_flipped[:, :, :, 0] = 0 output = (output + output_flipped) * 0.5 target = target.cuda(non_blocking=True) target_weight = target_weight.cuda(non_blocking=True) loss = criterion(output, target, target_weight) num_images = input.size(0) # measure accuracy and record loss losses.update(loss.item(), num_images) _, avg_acc, cnt, pred = accuracy(output.cpu().numpy(), target.cpu().numpy()) acc.update(avg_acc, cnt) # measure elapsed time batch_time.update(time.time() - end) end = time.time() c = meta['center'].numpy() s = meta['scale'].numpy() score = meta['score'].numpy() preds, maxvals = get_final_preds(config, output.clone().cpu().numpy(), c, s) all_preds[idx:idx + num_images, :, 0:2] = preds[:, :, 0:2] all_preds[idx:idx + num_images, :, 2:3] = maxvals # double check this all_boxes parts all_boxes[idx:idx + num_images, 0:2] = c[:, 0:2] all_boxes[idx:idx + num_images, 2:4] = s[:, 0:2] all_boxes[idx:idx + num_images, 4] = np.prod(s * 200, 1) all_boxes[idx:idx + num_images, 5] = score image_path.extend(meta['image']) if 'image_id' in meta: image_ids.extend(meta['image_id'].numpy()) #print(meta['image_id']) # for posetrack dataset, im_bbox must be considered if 'im_bbox' in meta: now_boxes = meta['im_bbox'] bbox_infos.extend(now_boxes.numpy()) if config.DATASET.DATASET == 'posetrack': filenames.extend(meta['filename']) imgnums.extend(meta['imgnum'].numpy()) idx += num_images if i % config.PRINT_FREQ == 0: msg = 'Test: [{0}/{1}]\t' \ 'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t' \ 'Loss {loss.val:.4f} ({loss.avg:.4f})\t' \ 'Accuracy {acc.val:.3f} ({acc.avg:.3f})'.format( i, len(val_loader), batch_time=batch_time, loss=losses, acc=acc) logger.info(msg) prefix = '{}_{}'.format(os.path.join(output_dir, 'val'), i) save_debug_images(config, input, meta, target, pred * 4, output, prefix) name_values, perf_indicator = val_dataset.evaluate( config, all_preds, output_dir, all_boxes, image_path, image_ids, bbox_infos) _, full_arch_name = get_model_name(config) if isinstance(name_values, list): for name_value in name_values: _print_name_value(name_value, full_arch_name) else: _print_name_value(name_values, full_arch_name) if writer_dict: writer = writer_dict['writer'] global_steps = writer_dict['valid_global_steps'] writer.add_scalar('valid_loss', losses.avg, global_steps) writer.add_scalar('valid_acc', acc.avg, global_steps) if isinstance(name_values, list): for name_value in name_values: writer.add_scalars('valid', dict(name_value), global_steps) else: writer.add_scalars('valid', dict(name_values), global_steps) writer_dict['valid_global_steps'] = global_steps + 1 return perf_indicator
def validate(val_loader, model, criterion, debug=False, flip=True, test_batch=6, njoints=68): batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() acces_re = AverageMeter() # switch to evaluate mode model.eval() gt_win, pred_win = None, None end = time.time() bar = Bar('Eval ', max=len(val_loader)) with torch.no_grad(): for i, (input, target, meta) in enumerate(val_loader): # measure data loading time data_time.update(time.time() - end) input = input.to(device, non_blocking=True) target = target.to(device, non_blocking=True) target_weight = meta['target_weight'].to(device, non_blocking=True) # compute output output, output_refine = model(input) score_map = output[-1].cpu() if type( output) == list else output.cpu() score_map_refine = output_refine[-1].cpu() if type( output_refine) == list else output_refine.cpu() if flip: flip_input = torch.from_numpy(fliplr( input.clone().numpy())).float().to(device) flip_output, flip_output_re = model(flip_input) flip_output = flip_output[-1].cpu() if type( flip_output) == list else flip_output.cpu() flip_output_re = flip_output_re[-1].cpu() if type( flip_output_re) == list else flip_output_re.cpu() flip_output = flip_back(flip_output, 'real_animal') flip_output_re = flip_back(flip_output_re, 'real_animal') score_map += flip_output score_map_refine += flip_output_re if type(output) == list: # multiple output loss = 0 for (o, o_re) in (output, output_refine): loss = loss + criterion( o, target, target_weight, len(idx)) + criterion( o_re, target, target_weight, len(idx)) else: # single output loss = criterion( output, target, target_weight, len(idx)) + criterion( output_refine, target, target_weight, len(idx)) acc_re, _ = accuracy(score_map_refine, target.cpu(), idx) if debug: gt_batch_img = batch_with_heatmap(input, target) pred_batch_img = batch_with_heatmap(input, score_map) if not gt_win or not pred_win: plt.subplot(121) gt_win = plt.imshow(gt_batch_img) plt.subplot(122) pred_win = plt.imshow(pred_batch_img) else: gt_win.set_data(gt_batch_img) pred_win.set_data(pred_batch_img) plt.pause(.05) plt.draw() # measure accuracy and record loss losses.update(loss.item(), input.size(0)) acces_re.update(acc_re[0], input.size(0)) # measure elapsed time batch_time.update(time.time() - end) end = time.time() # plot progress bar.suffix = '({batch}/{size}) Data: {data:.3f}s | Batch: {bt:.3f}s | Total: {total:} | ETA: {eta:} ' \ '| Loss: {loss:.8f} | Acc_re: {acc_re: .8f}'.format( batch=i + 1, size=len(val_loader), data=data_time.val, bt=batch_time.avg, total=bar.elapsed_td, eta=bar.eta_td, loss=losses.avg, acc_re=acces_re.avg ) bar.next() bar.finish() return losses.avg, acces_re.avg