def validate(self, phase):
btime_rec = utils.AverageMeter(0)
dtime_rec = utils.AverageMeter(0)
npts_rec = utils.AverageMeter(0)
recorder = {}
for rec in self.args.trainer['loss_record']:
recorder[rec] = utils.AverageMeter(10)
self.model.switch_to('eval')
end = time.time()
all_together = []
for i, (image, sparse, mask, flow_target, rgb_target) in enumerate(self.val_loader):
if 'val_iter' in self.args.trainer and self.args.trainer['val_iter'] != -1 and i == self.args.trainer['val_iter']:
break
assert image.shape[0] > 0
dtime_rec.update(time.time() - end)
npts_rec.update(int(torch.sum(mask) / mask.size(0) / mask.size(1)))
image = image.cuda()
sparse = sparse.cuda()
mask = mask.cuda()
flow_target = flow_target.cuda()
rgb_target = rgb_target.cuda()
self.model.set_input(image, torch.cat([sparse, mask], dim=1), flow_target, rgb_target)
tensor_dict, loss_dict = self.model.eval()
for k in loss_dict.keys():
recorder[k].update(utils.reduce_tensors(loss_dict[k]).item())
btime_rec.update(time.time() - end)
end = time.time()
# tb visualize
if self.rank == 0:
if i >= self.args.trainer['val_disp_start_iter'] and i < self.args.trainer['val_disp_end_iter']:
all_together.append(utils.visualize_tensor(image, mask, tensor_dict['flow_tensors'], tensor_dict['common_tensors'], tensor_dict['rgb_tensors'], self.args.data['data_mean'], self.args.data['data_div']))
if i == self.args.trainer['val_disp_end_iter'] and self.args.trainer['val_disp_end_iter'] > self.args.trainer['val_disp_start_iter']:
all_together = torch.cat(all_together, dim=2)
grid = vutils.make_grid(all_together, nrow=1, normalize=True, range=(0, 255), scale_each=False)
if self.tb_logger is not None:
self.tb_logger.add_image('Image_' + phase, grid, self.curr_step + 1)
# logging
if self.rank == 0:
loss_str = ""
for k in recorder.keys():
if self.tb_logger is not None:
self.tb_logger.add_scalar('val_{}'.format(k), recorder[k].avg, self.curr_step + 1)
loss_str += '{}: {loss.val:.4g} ({loss.avg:.4g})\t'.format(k, loss=recorder[k])
self.logger.info('Validation Iter: [{0}]\t'.format(self.curr_step) +
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'.format(batch_time=btime_rec) +
'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'.format(data_time=dtime_rec) +
loss_str +
'NPts {num_pts.val} ({num_pts.avg:.1f})\t'.format(num_pts=npts_rec))
self.model.switch_to("train")
def classify_random_image(model: Optional[Db_vae] = None,
path_to_model: Optional[str] = None,
z_dim: Optional[int] = None,
device: Optional[str] = None,
batch_size: int = 10):
"""Classify a random image from the data directory."""
path_to_data = 'data/**/*.jpg'
images = list(Path().glob(path_to_data))
idx = np.random.choice(len(images))
path_to_img = images[idx]
img = utils.read_image(path_to_img)
utils.visualize_tensor(img)
classify_image(path_to_img,
path_to_model=path_to_model,
z_dim=z_dim,
device=device,
batch_size=batch_size)
def validate(self, phase):
btime_rec = utils.AverageMeter(0)
dtime_rec = utils.AverageMeter(0)
recorder = {}
for rec in self.args.trainer['loss_record']:
recorder[rec] = utils.AverageMeter(10)
self.model.switch_to('eval')
end = time.time()
all_together = []
for i, inputs in enumerate(self.val_loader):
if ('val_iter' in self.args.trainer
and self.args.trainer['val_iter'] != -1
and i == self.args.trainer['val_iter']):
break
dtime_rec.update(time.time() - end)
self.model.set_input(*inputs)
tensor_dict, loss_dict = self.model.forward()
for k in loss_dict.keys():
recorder[k].update(
utils.reduce_tensors(loss_dict[k]).item() /
self.world_size)
btime_rec.update(time.time() - end)
end = time.time()
# tb visualize
if self.rank == 0:
disp_start = max(self.args.trainer['val_disp_start_iter'], 0)
disp_end = min(self.args.trainer['val_disp_end_iter'],
len(self.val_loader))
if (i >= disp_start and i < disp_end):
all_together.append(
utils.visualize_tensor(tensor_dict['common_tensors'],
self.args.data['data_mean'],
self.args.data['data_div']))
if (i == disp_end - 1 and disp_end > disp_start):
all_together = torch.cat(all_together, dim=2)
grid = vutils.make_grid(all_together,
nrow=1,
normalize=True,
range=(0, 255),
scale_each=False)
if self.tb_logger is not None:
self.tb_logger.add_image('Image_' + phase, grid,
self.curr_step)
cv2.imwrite(
"{}/images/{}_{}.png".format(self.args.exp_path, phase,
self.curr_step),
grid.permute(1, 2, 0).numpy())
# logging
if self.rank == 0:
loss_str = ""
for k in recorder.keys():
if self.tb_logger is not None and phase == 'on_val':
self.tb_logger.add_scalar('val_{}'.format(k),
recorder[k].avg, self.curr_step)
loss_str += '{}: {loss.val:.4g} ({loss.avg:.4g})\t'.format(
k, loss=recorder[k])
self.logger.info(
'Validation Iter: [{0}]\t'.format(self.curr_step) +
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'.format(
batch_time=btime_rec) +
'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'.format(
data_time=dtime_rec) + loss_str)
self.model.switch_to('train')