def updatefig(*args): rval, frame = vc.read() frame = cv2.resize(frame, (256, 256)) # BGR img = im_to_torch(frame) inp = color_normalize(img, (0.4404, 0.4440, 0.4327), (0.2458, 0.2410, 0.2468)) input_var = torch.autograd.Variable(inp.cuda()) output = model(input_var.unsqueeze(0)) score_map = output[-1].data.cpu() pred_batch_img = batch_with_heatmap(inp.unsqueeze(0), score_map) ax.clear() ax.imshow(pred_batch_img) # oframe = np.array(image) # oframe = oframe[:, :, ::-1].copy() # outvideo.write(oframe) return ax
def train(train_loader, model, criterion, optimizer, debug=False, flip=True): batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() acces = AverageMeter() # switch to train mode model.train() end = time.time() gt_win, pred_win = None, None bar = Bar('Processing', max=len(train_loader)) for i, (inputs, target, meta) in enumerate(train_loader): # measure data loading time data_time.update(time.time() - end) input_var = torch.autograd.Variable(inputs.cuda()) target_var = torch.autograd.Variable(target.cuda(async=True)) # compute output output = model(input_var) score_map = output[-1].data.cpu() loss = criterion(output[0], target_var) for j in range(1, len(output)): loss += criterion(output[j], target_var) acc = accuracy(score_map, target, idx) if debug: # visualize groundtruth and predictions 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: ax1 = plt.subplot(121) ax1.title.set_text('Groundtruth') gt_win = plt.imshow(gt_batch_img) ax2 = plt.subplot(122) ax2.title.set_text('Prediction') 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.data[0], inputs.size(0)) acces.update(acc[0], inputs.size(0)) # compute gradient and do SGD step optimizer.zero_grad() loss.backward() optimizer.step() # 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(train_loader), data=data_time.val, bt=batch_time.val, 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, 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, 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 train(train_loader, model, tmodel, criterion, optimizer, kdloss_alpha, debug=False, flip=True): batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() kdlosses = AverageMeter() unkdlosses = AverageMeter() tslosses = AverageMeter() gtlosses = AverageMeter() acces = AverageMeter() # switch to train mode model.train() end = time.time() gt_win, pred_win = None, None bar = Bar('Processing', max=len(train_loader)) for i, (inputs, target, meta) in enumerate(train_loader): # measure data loading time data_time.update(time.time() - end) input_var = torch.autograd.Variable(inputs.cuda()) target_var = torch.autograd.Variable(target.cuda(async=True)) # compute output output = model(input_var) score_map = output[-1].data.cpu() # compute teacher network output toutput = tmodel(input_var) toutput = toutput[-1].detach() # lmse : student vs ground truth # gtmask will filter out the samples without ground truth gtloss = torch.tensor(0.0).cuda() kdloss = torch.tensor(0.0).cuda() kdloss_unlabeled = torch.tensor(0.0).cuda() unkdloss_alpha = 1.0 gtmask = meta['gtmask'] train_batch = score_map.shape[0] for j in range(0, len(output)): _output = output[j] for i in range(gtmask.shape[0]): if gtmask[i] < 0.1: # unlabeled data, gtmask=0.0, kdloss only # need to dividen train_batch to keep number equal kdloss_unlabeled += criterion(_output[i,:,:,:], toutput[i, :,:,:])/train_batch else: # labeled data: kdloss + gtloss gtloss += criterion(_output[i,:,:,:], target_var[i, :,:,:])/train_batch kdloss += criterion(_output[i,:,:,:], toutput[i,:,:,:])/train_batch loss_labeled = kdloss_alpha * (kdloss) + (1 - kdloss_alpha)*gtloss total_loss = loss_labeled + unkdloss_alpha * kdloss_unlabeled acc = accuracy(score_map, target, idx) if debug: # visualize groundtruth and predictions gt_batch_img = batch_with_heatmap(inputs, target) pred_batch_img = batch_with_heatmap(inputs, score_map) teacher_batch_img = batch_with_heatmap(inputs, toutput) if not gt_win or not pred_win or not pred_teacher: ax1 = plt.subplot(131) ax1.title.set_text('Groundtruth') gt_win = plt.imshow(gt_batch_img) ax2 = plt.subplot(132) ax2.title.set_text('Prediction') pred_win = plt.imshow(pred_batch_img) ax2 = plt.subplot(133) ax2.title.set_text('teacher') pred_teacher = plt.imshow(teacher_batch_img) else: gt_win.set_data(gt_batch_img) pred_win.set_data(pred_batch_img) pred_teacher.set_data(teacher_batch_img) plt.pause(.05) plt.draw() # measure accuracy and record loss gtlosses.update(gtloss.item(), inputs.size(0)) kdlosses.update(kdloss.item(), inputs.size(0)) unkdlosses.update(kdloss_unlabeled.item(), inputs.size(0)) losses.update(total_loss.item(), inputs.size(0)) acces.update(acc[0], inputs.size(0)) # compute gradient and do SGD step optimizer.zero_grad() total_loss.backward() optimizer.step() # 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:.6f} | KdLoss:{kdloss:.6f}| unKdLoss:{unkdloss:.6f}| GtLoss:{gtloss:.6f} | Acc: {acc: .4f}'.format( batch=i + 1, size=len(train_loader), data=data_time.val, bt=batch_time.val, total=bar.elapsed_td, eta=bar.eta_td, loss=losses.avg, kdloss=kdlosses.avg, unkdloss=unkdlosses.avg, tsloss=tslosses.avg, gtloss=gtlosses.avg, acc=acces.avg ) bar.next() bar.finish() return losses.avg, acces.avg
def myvalidate( model, criterion, num_classes, debug=False, flip=True): batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() acces = AverageMeter() img_folder = '/data3/wzwu/dataset/my' img_num = 1 r = 0 center1 = torch.Tensor([1281,2169]) center2 = torch.Tensor([[1281,2169]]) scale = torch.Tensor([10.0]) inp_res = 256 meanstd_file = './data/mpii/mean.pth.tar' if isfile(meanstd_file): meanstd = torch.load(meanstd_file) mean = meanstd['mean'] std = meanstd['std'] input_list = [] for i in range(img_num): img_name = str(i)+'.jpg' img_path = os.path.join(img_folder,img_name) print('img_path') print(img_path) set_trace() img = load_image(img_path) inp = crop(img, center1, scale, [inp_res, inp_res], rot=r) inp = color_normalize(inp, mean, std) input_list.append(inp) # predictions predictions = torch.Tensor(img_num, num_classes, 2) # switch to evaluate mode model.eval() gt_win, pred_win = None, None end = time.time() bar = Bar('Eval ', max=img_num) with torch.no_grad(): for i, input in enumerate(input_list): # measure data loading time s0, s1, s2 = input.size() input = input.view(1, s0, s1, s2) data_time.update(time.time() - end) input = input.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 # generate predictions set_trace() preds = final_preds(score_map, center2, scale, [64, 64]) set_trace() print('preds') print(preds) print('predictions') print(predictions) for n in range(score_map.size(0)): predictions[i, :, :] = preds[n, :, :] if debug: pred_batch_img = batch_with_heatmap(input, score_map) if not gt_win or not pred_win: #plt.subplot(121) #plt.subplot(122) pred_win = plt.imshow(pred_batch_img) else: pred_win.set_data(pred_batch_img) plt.pause(.05) plt.draw() plt.savefig('/data3/wzwu/test/'+str(i)+'.png') # 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=img_num, 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 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 train(self, gen_iterations, start_t, epoch, lr): batch_time = AverageMeter() data_time = AverageMeter() self.netG.train() end = time.time() gt_win, pred_win = None, None bar = Bar('Train', max=len(self.train_loader)) step = 0 errD_total = None errG_total = None for i, (input, target, meta, mpii) in enumerate(self.train_loader): data_time.update(time.time() - end) ###################################################### # (1) Prepare training data and Compute text embeddings ###################################################### input, target = input.to(self.device), target.to(self.device, non_blocking=True) target_weight = meta['target_weight'].to(self.device, non_blocking=True) ####################################################### # (2) Generate fake heatmaps ###################################################### output = self.netG(input) ####################################################### # (3) Update D network ###################################################### errD_total = 0 D_logs = '' for i in range(self.num_stacks): self.netsD[i].zero_grad() errD = discriminator_loss(self.netsD[i], target, target_weight, output[i], input, self.real_labels, self.fake_labels, mpii) errD.backword() self.optimizersD[i].step() errD_total += errD D_logs += 'errD%d: %d.2f ' % (i, errD.data[0]) ####################################################### # (4) Update G network: maximize log(D(G(z))) ###################################################### step += 1 gen_iterations += 1 self.netG.zero_grad() errG_total, G_logs = \ generator_loss(self.netsD, self.domainD, output, self.real_labels, input, target_weight, mpii) if self.debug: gt_batch_img = batch_with_heatmap(input, target) pred_batch_img = batch_with_heatmap(input, output) if not gt_win or not pred_win: ax1 = plt.subplot(121) ax1.title.set_text('Groundtruth') gt_win = plt.imshow(gt_batch_img) ax2 = plt.subplot(122) ax2.title.set_text('Prediction') 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() errG_total.backward() self.optimizerG.step() 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:}'.format( batch=i + 1, size=len(self.train_loader), data=data_time.val, bt=batch_time.val, total=bar.elapsed_td, eta=bar.eta_td) bar.next() if gen_iterations % 100 == 0: print(D_logs + '\n' + G_logs) end_t = time.time() print('''[%d/%d] Loss_D: %.2f Loss_G: %.2f Time: %.2fs''' % (epoch, self.epochs, errD_total.data[0], errG_total.data[0], end_t - start_t)) if epoch % cfg.TRAIN.SNAPSHOT_INTERVAL == 0: self.save_model(self.netsD, lr, epoch) bar.finish()
def train(train_loader, model, criterion, optimizer, debug=False, flip=True, train_iters=0): print("Train iters: {}".format(train_iters)) batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() acces = AverageMeter() # switch to train mode model.train() debug_count = 0 end = time.time() gt_win, pred_win = None, None bar_len = [train_iters if train_iters != 0 else len(train_loader)][0] train_iters = [train_iters if train_iters != 0 else len(train_loader)][0] bar = Bar('Train', max=bar_len) curr_iter = 0 while curr_iter < train_iters: for i, (input, target, meta) in enumerate(train_loader): # measure data loading time data_time.update(time.time() - end) input, target = input.to(device), target.to(device, non_blocking=True) target_weight = meta['target_weight'].to(device, non_blocking=True) # compute output output = model(input) 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(output, target, idx) if debug: # visualize groundtruth and predictions gt_batch_img = batch_with_heatmap(input, target) pred_batch_img = batch_with_heatmap(input, output) fig = plt.figure() ax1 = fig.add_subplot(121) ax1.title.set_text('Groundtruth') gt_win = plt.imshow(gt_batch_img) ax2 = fig.add_subplot(122) ax2.title.set_text('Prediction') pred_win = plt.imshow(pred_batch_img) plt.pause(.05) plt.draw() fig.savefig('debug/debug_{}.png'.format(str(debug_count)), dpi=500) debug_count += 1 # measure accuracy and record loss losses.update(loss.item(), input.size(0)) acces.update(acc[0], input.size(0)) # compute gradient and do SGD step optimizer.zero_grad() loss.backward() optimizer.step() # 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(train_loader) if train_iters == 0 else train_iters ][0], data=data_time.val, bt=batch_time.val, total=bar.elapsed_td, eta=bar.eta_td, loss=losses.avg, acc=acces.avg) bar.next() curr_iter += 1 if curr_iter >= train_iters - 1: break bar.finish() return losses.avg, acces.avg
def train(inqueues, outqueues, train_loader, model, criterion, optimizer, debug=False, flip=True, clip=1, _logger=None): batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() acces = AverageMeter() sum_losses = AverageMeter() # switch to train mode model.train() criterion.valid = False end = time.time() gt_win, pred_win = None, None bar = Bar('Processing', max=len(train_loader)) for i, (inputs, target, meta) in enumerate(train_loader): # measure data loading time data_time.update(time.time() - end) if True: input_var = torch.autograd.Variable(inputs.cuda()) target_var = torch.autograd.Variable(target.cuda(async=True)) # compute output output = model(input_var) if len(inqueues) > 0: loss = [] acc = [] sum_loss = [] for j in range(len(output)): grad = [] for ii in range(output[0].size(0)): data = {} data['output'] = output[j][ii] data['meta'] = {} data['meta']['bi_target'] = meta['bi_target'][ii] data['meta']['pck'] = meta['pck'][ii] data['meta']['points'] = meta['points'][ii] data['meta']['tpts'] = meta['tpts'][ii] inqueues[ii].send(data) for ii in range(output[0].size(0)): _loss, _acc, _sum_loss, _grad = outqueues[ii].recv() loss.append(_loss) grad.append(_grad) if j == len(output) - 1: acc.append(_acc) sum_loss.append(_sum_loss) optimizer.zero_grad() output[0].backward(torch.stack(grad, 0)) torch.nn.utils.clip_grad_norm_(model.parameters(), clip) optimizer.step() loss = sum(loss) / output[0].size(0) acc = sum(acc) / output[0].size(0) sum_loss = sum(sum_loss) / output[0].size(0) else: optimizer.zero_grad() loss, acc, sum_loss = criterion(output[0], meta) for j in range(1, len(output)): _loss, acc, sum_loss = criterion(output[j], meta) loss += _loss loss.backward() optimizer.step() if debug: # visualize groundtruth and predictions 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: ax1 = plt.subplot(121) ax1.title.set_text('Groundtruth') gt_win = plt.imshow(gt_batch_img) ax2 = plt.subplot(122) ax2.title.set_text('Prediction') 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.data.item(), inputs.size(0)) acces.update(acc.item(), inputs.size(0)) sum_losses.update(sum_loss) loss = None torch.cuda.empty_cache() # 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} | Sum_Loss: {sum_loss:.4f} | Acc: {acc: .4f}'.format( batch=i + 1, size=len(train_loader), data=data_time.val, bt=batch_time.val, total=bar.elapsed_td, loss=losses.avg * 100, sum_loss=sum_losses.avg * 100, acc=acces.avg * 100) _logger.info(bar.suffix) bar.finish() return losses.avg * 100, acces.avg * 100
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 train(train_loader, model, criterion, criterion_seg, optimizer, debug=False, flip=True, train_batch=6, epoch=0, njoints=68): batch_time = AverageMeter() data_time = AverageMeter() losses_kpt = AverageMeter() losses_seg = AverageMeter() acces = AverageMeter() inter_meter = AverageMeter() union_meter = AverageMeter() # switch to train mode model.train() end = time.time() gt_win, pred_win = None, None bar = Bar('Train', max=len(train_loader)) for i, (input, target, target_seg, meta) in enumerate(train_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) 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_kpt = output_kpt[-1] output_seg = output_seg[-1] else: # single output loss_kpt = criterion(output_kpt, target, target_weight, len(idx)) loss_seg = criterion_seg(output_seg, target_seg) acc, batch_interocular_dists = accuracy(output_kpt, target, idx) _, pred_seg = torch.max(output_seg, 1) if debug: # visualize groundtruth and predictions gt_batch_img = batch_with_heatmap(input, target) pred_batch_img = batch_with_heatmap(input, output) if not gt_win or not pred_win: ax1 = plt.subplot(121) ax1.title.set_text('Groundtruth') gt_win = plt.imshow(gt_batch_img) ax2 = plt.subplot(122) ax2.title.set_text('Prediction') 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() loss = loss_kpt + (0.01 / (epoch + 1)) * loss_seg # 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) # compute gradient and do SGD step optimizer.zero_grad() loss.backward() optimizer.step() # 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: .4f} | IOU: {iou: .2f}'.format( batch=i + 1, size=len(train_loader), data=data_time.val, bt=batch_time.val, 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
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, target2, meta) in enumerate(val_loader): # measure data loading time data_time.update(time.time() - end) target = target.cuda(async=True) target2 = target2.cuda(async=True) input_var = torch.autograd.Variable(inputs.cuda(), volatile=True) target_var = torch.autograd.Variable(target, volatile=True) target2_var = torch.autograd.Variable(target2, volatile=True) # compute output output = model(input_var) score_map_hg = output[-2].data.cpu() score_map_emb = output[-1].data.cpu() score_map_emb2 = score_map_emb.cuda(async=True) loss = criterion(output[0], target_var) for j in range(1, (len(output) - 1)): loss += criterion(output[j], target_var) loss += criterion(output[-1], target2_var) acc = accuracy(score_map_emb2, target2, idx) # generate predictions #print(np.shape(predictions)) preds = final_preds(score_map_emb, meta['center'], meta['scale'], [64, 64]) for n in range(score_map_emb.size(0)): predictions[meta['index'][n], :, :] = preds[n, ::2, :] #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_emb) 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.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, predictions
def train(train_loader, model, criterion, optimizer, debug=False, flip=True): batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() acces = AverageMeter() # switch to train mode model.train() end = time.time() gt_win, pred_win = None, None bar = Bar('Train', max=len(train_loader)) for i, (input, target, meta) in enumerate(train_loader): # measure data loading time data_time.update(time.time() - end) input, target = input.to(device), target.to(device, non_blocking=True) target_weight = meta['target_weight'].to(device, non_blocking=True) # compute output output = model(input) 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(output, target, idx) if debug: # visualize groundtruth and predictions gt_batch_img = batch_with_heatmap(input, target) pred_batch_img = batch_with_heatmap(input, output) if not gt_win or not pred_win: ax1 = plt.subplot(121) ax1.title.set_text('Groundtruth') gt_win = plt.imshow(gt_batch_img) ax2 = plt.subplot(122) ax2.title.set_text('Prediction') 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)) # compute gradient and do SGD step optimizer.zero_grad() loss.backward() optimizer.step() # 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(train_loader), data=data_time.val, bt=batch_time.val, total=bar.elapsed_td, eta=bar.eta_td, loss=losses.avg, acc=acces.avg) bar.next() bar.finish() return losses.avg, acces.avg
def train(train_loader, model, criterion, optimizer, debug=False, flip=True, train_batch=6, epoch=0, njoints=68): batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() acces = AverageMeter() # switch to train mode model.train() end = time.time() gt_win, pred_win = None, None bar = Bar('Train', max=len(train_loader)) interocular_dists = torch.zeros((njoints, train_loader.dataset.__len__())) for i, (input, target, meta) in enumerate(train_loader): # measure data loading time data_time.update(time.time() - end) input, target = input.to(device), target.to(device, non_blocking=True) target_weight = meta['target_weight'].to(device, non_blocking=True) # compute output output = model(input) 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(output, target, idx) interocular_dists[:, i * train_batch:(i + 1) * train_batch] = batch_interocular_dists if debug: # visualize groundtruth and predictions gt_batch_img = batch_with_heatmap(input, target) pred_batch_img = batch_with_heatmap(input, output) if not gt_win or not pred_win: ax1 = plt.subplot(121) ax1.title.set_text('Groundtruth') gt_win = plt.imshow(gt_batch_img) ax2 = plt.subplot(122) ax2.title.set_text('Prediction') 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)) # compute gradient and do SGD step optimizer.zero_grad() loss.backward() optimizer.step() # 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(train_loader), data=data_time.val, bt=batch_time.val, 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
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, 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