def detect(opt): model = opt.model result_path = opt.rp file_list = opt.filelist filepath = opt.filepath if not os.path.exists(result_path): os.makedirs(result_path) devices = [int(item) for item in opt.devices.split(',')] ngpu = len(devices) #net = DispNetC(ngpu, True) #net = DispNetCSRes(ngpu, False, True) #net = DispNetCSResWithMono(ngpu, False, True, input_channel=3) if opt.net == "psmnet" or opt.net == "ganet": net = build_net(opt.net)(maxdisp=192) elif opt.net == "dispnetc": net = build_net(opt.net)(batchNorm=False, lastRelu=True, resBlock=False) else: net = build_net(opt.net)(batchNorm=False, lastRelu=True) net = torch.nn.DataParallel(net, device_ids=devices).cuda() model_data = torch.load(model) print(model_data.keys()) if 'state_dict' in model_data.keys(): net.load_state_dict(model_data['state_dict']) else: net.load_state_dict(model_data) num_of_parameters = count_parameters(net) print('Model: %s, # of parameters: %d' % (opt.net, num_of_parameters)) net.eval() batch_size = int(opt.batchSize) test_dataset = DispDataset(txt_file=file_list, root_dir=filepath, phase='detect') test_loader = DataLoader(test_dataset, batch_size = batch_size, \ shuffle = False, num_workers = 1, \ pin_memory = True) s = time.time() #high_res_EPE = multiscaleloss(scales=1, downscale=1, weights=(1), loss='L1', sparse=False) avg_time = [] display = 100 warmup = 10 for i, sample_batched in enumerate(test_loader): input = torch.cat((sample_batched['img_left'], sample_batched['img_right']), 1) # print('input Shape: {}'.format(input.size())) num_of_samples = input.size(0) target = sample_batched['gt_disp'] #print('disp Shape: {}'.format(target.size())) #original_size = (1, target.size()[2], target.size()[3]) target = target.cuda() input = input.cuda() input_var = torch.autograd.Variable(input, volatile=True) target_var = torch.autograd.Variable(target, volatile=True) if i > warmup: ss = time.time() if opt.net == "psmnet" or opt.net == "ganet": output = net(input_var) elif opt.net == "dispnetc": output = net(input_var)[0] else: output = net(input_var)[-1] if i > warmup: avg_time.append((time.time() - ss)) if (i - warmup) % display == 0: print('Average inference time: %f' % np.mean(avg_time)) mbytes = 1024.*1024 print('GPU memory usage memory_allocated: %d MBytes, max_memory_allocated: %d MBytes, memory_cached: %d MBytes, max_memory_cached: %d MBytes, CPU memory usage: %d MBytes' % \ (ct.memory_allocated()/mbytes, ct.max_memory_allocated()/mbytes, ct.memory_cached()/mbytes, ct.max_memory_cached()/mbytes, process.memory_info().rss/mbytes)) avg_time = [] # output = net(input_var)[1] output[output > 192] = 0 output = scale_disp(output, (output.size()[0], 540, 960)) for j in range(num_of_samples): # scale back depth np_depth = output[j][0].data.cpu().numpy() gt_depth = target_var[j, 0, :, :].data.cpu().numpy() #print(np.min(np_depth), np.max(np_depth)) #cuda_depth = torch.from_numpy(np_depth).cuda() #cuda_depth = torch.autograd.Variable(cuda_depth, volatile=True) # flow2_EPE = high_res_EPE(output[j], target_var[j]) * 1.0 #flow2_EPE = high_res_EPE(cuda_depth, target_var[j]) * 1.0 #print('Shape: {}'.format(output[j].size())) print('Batch[{}]: {}, average disp: {}'.format(i, j, np.mean(np_depth))) #print('Batch[{}]: {}, Flow2_EPE: {}'.format(i, sample_batched['img_names'][0][j], flow2_EPE.data.cpu().numpy())) name_items = sample_batched['img_names'][0][j].split('/') #save_name = '_'.join(name_items).replace('.png', '.pfm')# for girl02 dataset #save_name = 'predict_{}_{}_{}.pfm'.format(name_items[-4], name_items[-3], name_items[-1].split('.')[0]) #save_name = 'predict_{}_{}.pfm'.format(name_items[-1].split('.')[0], name_items[-1].split('.')[1]) #save_name = 'predict_{}.pfm'.format(name_items[-1]) #img = np.flip(np_depth[0], axis=0) save_name = '_'.join(name_items)# for girl02 dataset img = np_depth print('Name: {}'.format(save_name)) print('') #save_pfm('{}/{}'.format(result_path, save_name), img) skimage.io.imsave(os.path.join(result_path, save_name),(img*256).astype('uint16')) save_name = '_'.join(name_items).replace(".png", "_gt.png")# for girl02 dataset img = gt_depth print('Name: {}'.format(save_name)) print('') #save_pfm('{}/{}'.format(result_path, save_name), img) skimage.io.imsave(os.path.join(result_path, save_name),(img*256).astype('uint16')) print('Evaluation time used: {}'.format(time.time()-s))
def detect(opt): net_name = opt.net model = opt.model result_path = opt.rp file_list = opt.filelist filepath = opt.filepath if not os.path.exists(result_path): os.makedirs(result_path) devices = [int(item) for item in opt.devices.split(',')] ngpu = len(devices) # build net according to the net name if net_name == "psmnet" or net_name == "ganet": net = build_net(net_name)(192) elif net_name in ["fadnet", "dispnetc"]: net = build_net(net_name)(batchNorm=False, lastRelu=True) net = torch.nn.DataParallel(net, device_ids=devices).cuda() model_data = torch.load(model) print(model_data.keys()) if 'state_dict' in model_data.keys(): net.load_state_dict(model_data['state_dict']) else: net.load_state_dict(model_data) num_of_parameters = count_parameters(net) print('Model: %s, # of parameters: %d' % (net_name, num_of_parameters)) net.eval() batch_size = int(opt.batchSize) test_dataset = StereoDataset(txt_file=file_list, root_dir=filepath, phase='detect') test_loader = DataLoader(test_dataset, batch_size = batch_size, \ shuffle = False, num_workers = 1, \ pin_memory = True) s = time.time() avg_time = [] display = 50 warmup = 10 for i, sample_batched in enumerate(test_loader): #if i > 215: # break input = torch.cat( (sample_batched['img_left'], sample_batched['img_right']), 1) # print('input Shape: {}'.format(input.size())) num_of_samples = input.size(0) #output, input_var = detect_batch(net, sample_batched, opt.net, (540, 960)) input = input.cuda() input_var = torch.autograd.Variable(input, volatile=True) if i > warmup: ss = time.time() with torch.no_grad(): if opt.net == "psmnet" or opt.net == "ganet": output = net(input_var) output = output.unsqueeze(1) elif opt.net == "dispnetc": output = net(input_var)[0] else: output = net(input_var)[-1] if i > warmup: avg_time.append((time.time() - ss)) if (i - warmup) % display == 0: print('Average inference time: %f' % np.mean(avg_time)) mbytes = 1024. * 1024 print('GPU memory usage memory_allocated: %d MBytes, max_memory_allocated: %d MBytes, memory_cached: %d MBytes, max_memory_cached: %d MBytes, CPU memory usage: %d MBytes' % \ (ct.memory_allocated()/mbytes, ct.max_memory_allocated()/mbytes, ct.memory_cached()/mbytes, ct.max_memory_cached()/mbytes, process.memory_info().rss/mbytes)) avg_time = [] output = scale_disp(output, (output.size()[0], 540, 960)) disp = output[:, 0, :, :] for j in range(num_of_samples): name_items = sample_batched['img_names'][0][j].split('/') # write disparity to file output_disp = disp[j] np_disp = disp[j].data.cpu().numpy() print('Batch[{}]: {}, average disp: {}({}-{}).'.format( i, j, np.mean(np_disp), np.min(np_disp), np.max(np_disp))) save_name = '_'.join(name_items).replace( ".png", "_d.png") # for girl02 dataset print('Name: {}'.format(save_name)) skimage.io.imsave(os.path.join(result_path, save_name), (np_disp * 256).astype('uint16')) #save_name = '_'.join(name_items).replace("png", "pfm")# for girl02 dataset #print('Name: {}'.format(save_name)) #np_disp = np.flip(np_disp, axis=0) #save_pfm('{}/{}'.format(result_path, save_name), np_disp) print('Evaluation time used: {}'.format(time.time() - s))
def validate(self): batch_time = AverageMeter() flow2_EPEs = AverageMeter() losses = AverageMeter() # switch to evaluate mode self.net.eval() end = time.time() #scale_width = 960 #scale_height = 540 #scale_width = 3130 #scale_height = 960 for i, sample_batched in enumerate(self.test_loader): left_input = torch.autograd.Variable(sample_batched['img_left'].cuda(), requires_grad=False) right_input = torch.autograd.Variable(sample_batched['img_right'].cuda(), requires_grad=False) target = sample_batched['gt_disp'] #left_input = torch.autograd.Variable(sample_batched[0].cuda(), requires_grad=False) #right_input = torch.autograd.Variable(sample_batched[1].cuda(), requires_grad=False) #target = sample_batched[2] input = torch.cat((left_input, right_input), 1) target = target.cuda() input_var = torch.autograd.Variable(input, requires_grad=False) target_var = torch.autograd.Variable(target, requires_grad=False) if self.net_name == 'dispnetcres': output_net1, output_net2 = self.net(input_var) output_net1 = scale_disp(output_net1, (output_net1.size()[0], 540, 960)) output_net2 = scale_disp(output_net2, (output_net2.size()[0], 540, 960)) loss_net1 = self.epe(output_net1, target_var) loss_net2 = self.epe(output_net2, target_var) loss = loss_net1 + loss_net2 flow2_EPE = self.epe(output_net2, target_var) elif self.net_name == "psmnet" or self.net_name == "ganet": output_net3 = self.net(input_var) output_net3 = scale_disp(output_net3, (output_net3.size()[0], 540, 960)) loss = self.epe(output_net3, target_var) flow2_EPE = loss elif self.net_name == 'dispnetcss': output_net1, output_net2, output_net3 = self.net(input_var) output_net1 = scale_disp(output_net1, (output_net1.size()[0], 540, 960)) output_net2 = scale_disp(output_net2, (output_net2.size()[0], 540, 960)) output_net3 = scale_disp(output_net3, (output_net3.size()[0], 540, 960)) loss_net1 = self.epe(output_net1, target_var) loss_net2 = self.epe(output_net2, target_var) loss_net3 = self.epe(output_net3, target_var) loss = loss_net1 + loss_net2 + loss_net3 flow2_EPE = self.epe(output_net3, target_var) else: output = self.net(input_var) output_net1 = output[0] #output_net1 = output_net1.squeeze(1) #print(output_net1.size()) output_net1 = scale_disp(output_net1, (output_net1.size()[0], 540, 960)) #output_net1 = torch.from_numpy(output_net1).unsqueeze(1).cuda() loss = self.epe(output_net1, target_var) flow2_EPE = self.epe(output_net1, target_var) #if type(loss) is list or type(loss) is tuple: # loss = loss[0] #if type(output) is list or type(output_net1) : # flow2_EPE = self.epe(output[0], target_var) #else: # flow2_EPE = self.epe(output, target_var) # record loss and EPE if loss.data.item() == loss.data.item(): losses.update(loss.data.item(), target.size(0)) if flow2_EPE.data.item() == flow2_EPE.data.item(): flow2_EPEs.update(flow2_EPE.data.item(), target.size(0)) # measure elapsed time batch_time.update(time.time() - end) end = time.time() if i % 10 == 0: logger.info('Test: [{0}/{1}]\t Time {2}\t EPE {3}' .format(i, len(self.test_loader), batch_time.val, flow2_EPEs.val)) logger.info(' * EPE {:.3f}'.format(flow2_EPEs.avg)) return flow2_EPEs.avg
def validate(self): batch_time = AverageMeter() flow2_EPEs = AverageMeter() norm_EPEs = AverageMeter() angle_EPEs = AverageMeter() losses = AverageMeter() # switch to evaluate mode end = time.time() valid_norm = 0 angle_lt = 0 angle_thres = 11.25 self.net.eval() for i, sample_batched in enumerate(self.test_loader): left_input = sample_batched['img_left'].cuda() right_input = sample_batched['img_right'].cuda() left_input = F.interpolate(left_input, self.scale_size, mode='bilinear') right_input = F.interpolate(right_input, self.scale_size, mode='bilinear') input_var = torch.cat((left_input, right_input), 1) #input_var = torch.autograd.Variable(inputs, requires_grad=False) if self.disp_on: target_disp = sample_batched['gt_disp'] target_disp = target_disp.cuda() target_disp = torch.autograd.Variable(target_disp, requires_grad=False) if self.norm_on: if self.angle_on: target_angle = sample_batched['gt_angle'] target_angle = target_angle.cuda() target_angle = torch.autograd.Variable(target_angle, requires_grad=False) else: target_norm = sample_batched['gt_norm'] target_norm = target_norm.cuda() target_norm = torch.autograd.Variable(target_norm, requires_grad=False) if self.net_name in ['dnfusionnet', 'dtonnet']: with torch.no_grad(): disp, normal = self.net(input_var) # scale the result disp_norm = torch.cat((normal, disp), 1) # upsampling the predicted disparity map size = target_disp.size() disp_norm = scale_norm(disp_norm, (size[0], 4, size[-2], size[-1]), True) disp = disp_norm[:, 3, :, :].unsqueeze(1) normal = disp_norm[:, :3, :, :] valid_norm_idx = (target_norm >= -1.0) & (target_norm <= 1.0) norm_EPE = F.mse_loss(normal[valid_norm_idx], target_norm[valid_norm_idx], size_average=True) * 3.0 flow2_EPE = self.epe(disp, target_disp) norm_angle = angle_diff_norm(normal, target_norm).squeeze() valid_angle_idx = valid_norm_idx[:, 0, :, :] & valid_norm_idx[:, 1, :, :] & valid_norm_idx[:, 2, :, :] valid_angle_idx = valid_angle_idx.squeeze() angle_EPE = torch.mean(norm_angle[valid_angle_idx]) valid_norm += float(torch.sum(valid_angle_idx)) angle_lt += float( torch.sum(norm_angle[valid_angle_idx] < angle_thres)) logger.info('percent of < {}: {}.'.format( angle_thres, angle_lt * 1.0 / valid_norm)) angle_EPE = torch.mean(norm_angle) loss = norm_EPE + flow2_EPE elif self.net_name in ["normnets"]: normal = self.net(input_var) size = normal.size() # scale the result normal = scale_norm( normal, (size[0], 3, self.img_height, self.img_width), True) valid_norm_idx = (target_norm >= -1.0) & (target_norm <= 1.0) norm_EPE = F.mse_loss(normal[valid_norm_idx], target_norm[valid_norm_idx], size_average=True) * 3.0 norm_angle = angle_diff_norm(normal, target_norm).squeeze() valid_angle_idx = valid_norm_idx[:, 0, :, :] & valid_norm_idx[:, 1, :, :] & valid_norm_idx[:, 2, :, :] valid_angle_idx = valid_angle_idx.squeeze() angle_EPE = torch.mean(norm_angle[valid_angle_idx]) valid_norm += float(torch.sum(valid_angle_idx)) angle_lt += float( torch.sum(norm_angle[valid_angle_idx] < angle_thres)) logger.info('percent of < {}: {}.'.format( angle_thres, angle_lt * 1.0 / valid_norm)) loss = norm_EPE elif self.net_name == 'fadnet': output_net1, output_net2 = self.net(input_var) output_net1 = scale_disp(output_net1, (output_net1.size()[0], self.img_size[0], self.img_size[1])) output_net2 = scale_disp(output_net2, (output_net2.size()[0], self.img_size[0], self.img_size[1])) loss_net1 = self.epe(output_net1, target_disp) loss_net2 = self.epe(output_net2, target_disp) loss = loss_net1 + loss_net2 flow2_EPE = self.epe(output_net2, target_disp) elif self.net_name == "psmnet" or self.net_name == "gwcnet": with torch.no_grad(): output_net3 = self.net(input_var) if output_net3.dim == 3: output_net3 = output_net3.unsqueeze(1) output_net3 = scale_disp(output_net3, (output_net3.size()[0], self.img_size[0], self.img_size[1])) loss = self.epe(output_net3, target_disp) flow2_EPE = loss elif self.net_name == 'dispnetcss': output_net1, output_net2, output_net3 = self.net(input_var) output_net1 = scale_disp(output_net1, (output_net1.size()[0], self.img_size[0], self.img_size[1])) output_net2 = scale_disp(output_net2, (output_net2.size()[0], self.img_size[0], self.img_size[1])) output_net3 = scale_disp(output_net3, (output_net3.size()[0], self.img_size[0], self.img_size[1])) loss_net1 = self.epe(output_net1, target_disp) loss_net2 = self.epe(output_net2, target_disp) loss_net3 = self.epe(output_net3, target_disp) loss = loss_net1 + loss_net2 + loss_net3 flow2_EPE = self.epe(output_net3, target_disp) else: output = self.net(input_var)[0] output = scale_disp( output, (output.size()[0], self.img_size[0], self.img_size[1])) loss = self.epe(output, target_disp) flow2_EPE = loss # record loss and EPE if loss.data.item() == loss.data.item(): losses.update(loss.data.item(), input_var.size(0)) if self.disp_on and (flow2_EPE.data.item() == flow2_EPE.data.item()): flow2_EPEs.update(flow2_EPE.data.item(), input_var.size(0)) if self.norm_on: if self.angle_on: if (angle_EPE.data.item() == angle_EPE.data.item()): angle_EPEs.update(angle_EPE.data.item(), input_var.size(0)) else: if (norm_EPE.data.item() == norm_EPE.data.item()): norm_EPEs.update(norm_EPE.data.item(), input_var.size(0)) if (angle_EPE.data.item() == angle_EPE.data.item()): angle_EPEs.update(angle_EPE.data.item(), input_var.size(0)) # measure elapsed time batch_time.update(time.time() - end) end = time.time() if i % 1 == 0: logger.info( 'Test: [{0}/{1}]\t Time {2}\t EPE {3}\t norm_EPE {4}\t angle_EPE {5}' .format(i, len(self.test_loader), batch_time.val, flow2_EPEs.val, norm_EPEs.val, angle_EPEs.val)) logger.info(' * EPE {:.3f}'.format(flow2_EPEs.avg)) logger.info(' * normal EPE {:.3f}'.format(norm_EPEs.avg)) logger.info(' * angle EPE {:.3f}'.format(angle_EPEs.avg)) return flow2_EPEs.avg
def detect(opt): net_name = opt.net model = opt.model result_path = opt.rp file_list = opt.filelist filepath = opt.filepath if not os.path.exists(result_path): os.makedirs(result_path) devices = [int(item) for item in opt.devices.split(',')] ngpu = len(devices) # build net according to the net name if net_name in ["dispnetcres", "dispnetc"]: net = build_net(net_name)(batchNorm=False, lastRelu=True) else: net = build_net(net_name)(batchNorm=False, lastRelu=True) net.set_focal_length(1050.0, 1050.0) net = torch.nn.DataParallel(net, device_ids=devices).cuda() #net.cuda() model_data = torch.load(model) print(model_data.keys()) if 'state_dict' in model_data.keys(): net.load_state_dict(model_data['state_dict']) else: net.load_state_dict(model_data) num_of_parameters = count_parameters(net) print('Model: %s, # of parameters: %d' % (net_name, num_of_parameters)) net.eval() batch_size = int(opt.batchSize) #test_dataset = StereoDataset(txt_file=file_list, root_dir=filepath, phase='detect') test_dataset = SceneFlowDataset(txt_file=file_list, root_dir=filepath, phase='detect') test_loader = DataLoader(test_dataset, batch_size = batch_size, \ shuffle = False, num_workers = 1, \ pin_memory = True) s = time.time() #high_res_EPE = multiscaleloss(scales=1, downscale=1, weights=(1), loss='L1', sparse=False) avg_time = [] display = 100 warmup = 10 for i, sample_batched in enumerate(test_loader): input = torch.cat( (sample_batched['img_left'], sample_batched['img_right']), 1) if opt.disp_on: target_disp = sample_batched['gt_disp'] target_disp = target_disp.cuda() if opt.norm_on: target_norm = sample_batched['gt_norm'] target_norm = target_norm.cuda() # print('input Shape: {}'.format(input.size())) num_of_samples = input.size(0) #output, input_var = detect_batch(net, sample_batched, opt.net, (540, 960)) input = input.cuda() input_var = torch.autograd.Variable(input, volatile=True) if i > warmup: ss = time.time() if opt.net == "psmnet" or opt.net == "ganet": output = net(input_var) elif opt.net == "dispnetc": output = net(input_var)[0] elif opt.net in ["dispnormnet", "dtonnet", "dnfusionnet"]: output = net(input_var) disp = output[0] normal = output[1] output = torch.cat((normal, disp), 1) else: output = net(input_var)[-1] if i > warmup: avg_time.append((time.time() - ss)) if (i - warmup) % display == 0: print('Average inference time: %f' % np.mean(avg_time)) mbytes = 1024. * 1024 print('GPU memory usage memory_allocated: %d MBytes, max_memory_allocated: %d MBytes, memory_cached: %d MBytes, max_memory_cached: %d MBytes, CPU memory usage: %d MBytes' % \ (ct.memory_allocated()/mbytes, ct.max_memory_allocated()/mbytes, ct.memory_cached()/mbytes, ct.max_memory_cached()/mbytes, process.memory_info().rss/mbytes)) avg_time = [] # output = net(input_var)[1] if opt.disp_on and not opt.norm_on: output = scale_disp(output, (output.size()[0], 540, 960)) disp = output[:, 0, :, :] elif opt.disp_on and opt.norm_on: output = scale_norm(output, (output.size()[0], 4, 540, 960)) disp = output[:, 3, :, :] normal = output[:, :3, :, :] print('disp shape:', disp.shape) for j in range(num_of_samples): name_items = sample_batched['img_names'][0][j].split('/') # write disparity to file if opt.disp_on: output_disp = disp[j] _target_disp = target_disp[j, 0] target_valid = _target_disp < 192 print('target size', _target_disp.size()) print('output size', output_disp.size()) epe = F.smooth_l1_loss(output_disp[target_valid], _target_disp[target_valid], size_average=True) print('EPE: {}'.format(epe)) np_disp = disp[j].data.cpu().numpy() print('Batch[{}]: {}, average disp: {}({}-{}).'.format( i, j, np.mean(np_disp), np.min(np_disp), np.max(np_disp))) save_name = '_'.join(name_items).replace(".png", "_d.png") print('Name: {}'.format(save_name)) skimage.io.imsave(os.path.join(result_path, save_name), (np_disp * 256).astype('uint16')) #save_name = '_'.join(name_items).replace(".png", "_d.pfm") #print('Name: {}'.format(save_name)) #np_disp = np.flip(np_disp, axis=0) #save_pfm('{}/{}'.format(result_path, save_name), np_disp) if opt.norm_on: normal[j] = (normal[j] + 1.0) * 0.5 #np_normal = normal[j].data.cpu().numpy().transpose([1, 2, 0]) np_normal = normal[j].data.cpu().numpy() #save_name = '_'.join(name_items).replace('.png', '_n.png') save_name = '_'.join(name_items).replace('.png', '_n.exr') print('Name: {}'.format(save_name)) #skimage.io.imsave(os.path.join(result_path, save_name),(normal*256).astype('uint16')) #save_pfm('{}/{}'.format(result_path, save_name), img) save_exr(np_normal, '{}/{}'.format(result_path, save_name)) print('') #save_name = '_'.join(name_items).replace(".png", "_left.png") #img = input_var[0].detach().cpu().numpy()[:3,:,:] #img = np.transpose(img, (1, 2, 0)) #print('Name: {}'.format(save_name)) #print('') ##save_pfm('{}/{}'.format(result_path, save_name), img) #skimage.io.imsave(os.path.join(result_path, save_name),img) print('Evaluation time used: {}'.format(time.time() - s))
def validate(self): batch_time = AverageMeter() flow2_EPEs = AverageMeter() norm_EPEs = AverageMeter() angle_EPEs = AverageMeter() losses = AverageMeter() # switch to evaluate mode self.net.eval() end = time.time() for i, sample_batched in enumerate(self.test_loader): left_input = torch.autograd.Variable( sample_batched['img_left'].cuda(), requires_grad=False) right_input = torch.autograd.Variable( sample_batched['img_right'].cuda(), requires_grad=False) input = torch.cat((left_input, right_input), 1) input_var = torch.autograd.Variable(input, requires_grad=False) if self.disp_on: target_disp = sample_batched['gt_disp'] target_disp = target_disp.cuda() target_disp = torch.autograd.Variable(target_disp, requires_grad=False) if self.norm_on: if self.angle_on: target_angle = sample_batched['gt_angle'] target_angle = target_angle.cuda() target_angle = torch.autograd.Variable(target_angle, requires_grad=False) else: target_norm = sample_batched['gt_norm'] target_norm = target_norm.cuda() target_norm = torch.autograd.Variable(target_norm, requires_grad=False) if self.net_name in ["dispnormnet"]: disp, normal = self.net(input_var) size = disp.size() # scale the result disp_norm = torch.cat((normal, disp), 1) disp_norm = scale_norm( disp_norm, (size[0], 4, self.img_height, self.img_width), True) disp = disp_norm[:, 3, :, :].unsqueeze(1) normal = disp_norm[:, :3, :, :] # normalize the surface normal #normal = normal / torch.norm(normal, 2, dim=1, keepdim=True) valid_norm_idx = (target_norm >= -1.0) & (target_norm <= 1.0) norm_EPE = F.mse_loss(normal[valid_norm_idx], target_norm[valid_norm_idx], size_average=True) * 3.0 flow2_EPE = self.epe(disp, target_disp) norm_angle = angle_diff_norm(normal, target_norm).squeeze() valid_angle_idx = valid_norm_idx[:, 0, :, :] & valid_norm_idx[:, 1, :, :] & valid_norm_idx[:, 2, :, :] valid_angle_idx = valid_angle_idx.squeeze() angle_EPE = torch.mean(norm_angle[valid_angle_idx]) loss = norm_EPE + flow2_EPE elif self.net_name == 'dispnetcres': output_net1, output_net2 = self.net(input_var) output_net1 = scale_disp(output_net1, (output_net1.size()[0], 540, 960)) output_net2 = scale_disp(output_net2, (output_net2.size()[0], 540, 960)) loss_net1 = self.epe(output_net1, target_disp) loss_net2 = self.epe(output_net2, target_disp) loss = loss_net1 + loss_net2 flow2_EPE = self.epe(output_net2, target_disp) elif self.net_name == 'dispnetcss': output_net1, output_net2, output_net3 = self.net(input_var) output_net1 = scale_disp(output_net1, (output_net1.size()[0], 540, 960)) output_net2 = scale_disp(output_net2, (output_net2.size()[0], 540, 960)) output_net3 = scale_disp(output_net3, (output_net3.size()[0], 540, 960)) loss_net1 = self.epe(output_net1, target_disp) loss_net2 = self.epe(output_net2, target_disp) loss_net3 = self.epe(output_net3, target_disp) loss = loss_net1 + loss_net2 + loss_net3 flow2_EPE = self.epe(output_net3, target_disp) else: output = self.net(input_var) output_net1 = output[0] output_net1 = scale_disp( output_net1, (output_net1.size()[0], self.img_height, self.img_width)) loss = self.epe(output_net1, target_disp) flow2_EPE = self.epe(output_net1, target_disp) # record loss and EPE if loss.data.item() == loss.data.item(): losses.update(loss.data.item(), input_var.size(0)) if self.disp_on and (flow2_EPE.data.item() == flow2_EPE.data.item()): flow2_EPEs.update(flow2_EPE.data.item(), input_var.size(0)) if self.norm_on: if self.angle_on: if (angle_EPE.data.item() == angle_EPE.data.item()): angle_EPEs.update(angle_EPE.data.item(), input_var.size(0)) else: if (norm_EPE.data.item() == norm_EPE.data.item()): norm_EPEs.update(norm_EPE.data.item(), input_var.size(0)) if (angle_EPE.data.item() == angle_EPE.data.item()): angle_EPEs.update(angle_EPE.data.item(), input_var.size(0)) # measure elapsed time batch_time.update(time.time() - end) end = time.time() if i % 10 == 0: logger.info( 'Test: [{0}/{1}]\t Time {2}\t EPE {3}\t norm_EPE {4}\t angle_EPE {5}' .format(i, len(self.test_loader), batch_time.val, flow2_EPEs.val, norm_EPEs.val, angle_EPEs.val)) logger.info(' * EPE {:.3f}'.format(flow2_EPEs.avg)) logger.info(' * normal EPE {:.3f}'.format(norm_EPEs.avg)) logger.info(' * angle EPE {:.3f}'.format(angle_EPEs.avg)) return flow2_EPEs.avg