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
