def test(params): """Test function.""" args.mode = 'online_eval' dataloader = BtsDataLoader(args, 'online_eval') model = BtsModel(params=args) model = torch.nn.DataParallel(model) checkpoint = torch.load(args.checkpoint_path) model.load_state_dict(checkpoint['model']) model.eval() model.cuda() num_test_samples = get_num_lines(args.filenames_file) with open(args.filenames_file) as f: lines = f.readlines() print('now testing {} files with {}'.format(num_test_samples, args.checkpoint_path)) pred_depths = [] pred_8x8s = [] pred_4x4s = [] pred_2x2s = [] pred_1x1s = [] save_name = 'result_' + args.model_name if not os.path.exists(os.path.dirname(save_name)): try: os.mkdir(save_name) os.mkdir(save_name + '/raw') os.mkdir(save_name + '/cmap') os.mkdir(save_name + '/rgb') os.mkdir(save_name + '/gt') os.mkdir(save_name + '/nd') except OSError as e: if e.errno != errno.EEXIST: raise start_time = time.time() with torch.no_grad(): for s, sample in enumerate(tqdm(dataloader.data)): image = Variable(sample['image'].cuda()) focal = Variable(sample['focal'].cuda()) depth_gt = Variable(sample['depth'].cuda()) depth_gt = depth_gt.transpose(2, 3).transpose(1, 2) # Predict lpg8x8, lpg4x4, lpg2x2, reduc1x1, depth_est = model(image, focal) pred_depths.append(depth_est.cpu().numpy().squeeze()) pred_8x8s.append(lpg8x8[0].cpu().numpy().squeeze()) pred_4x4s.append(lpg4x4[0].cpu().numpy().squeeze()) pred_2x2s.append(lpg2x2[0].cpu().numpy().squeeze()) pred_1x1s.append(reduc1x1[0].cpu().numpy().squeeze()) depth_est[:, :, 0, 0] = 0. nd_gt, diff_gt, invd_bmask = nd_model(depth_gt) nd_est, diff_est, _ = nd_model(depth_est) ### with nd paint scene_name = lines[s].split()[0].split('/')[0] filename_nd_png = save_name + '/nd/' + scene_name + '_' + lines[ s].split()[0].split('/')[1].replace('.jpg', '.png') paint_multiple(image[0].cpu().detach(), depth_est[0].cpu().detach(), depth_gt[0].cpu().detach(), None, nd_est[0].cpu().detach(), nd_gt[0].cpu().detach(), None, diff_est[0].cpu().detach(), diff_gt[0].cpu().detach(), images_per_row=3, to_screen=False, to_file=filename_nd_png) elapsed_time = time.time() - start_time print('Elapesed time: %s' % str(elapsed_time)) print('Done.') print('Saving result pngs..') for s in tqdm(range(num_test_samples)): if args.dataset == 'kitti': date_drive = lines[s].split('/')[1] filename_pred_png = save_name + '/raw/' + date_drive + '_' + lines[ s].split()[0].split('/')[-1].replace('.jpg', '.png') filename_cmap_png = save_name + '/cmap/' + date_drive + '_' + lines[ s].split()[0].split('/')[-1].replace('.jpg', '.png') filename_image_png = save_name + '/rgb/' + date_drive + '_' + lines[ s].split()[0].split('/')[-1] elif args.dataset == 'kitti_benchmark': filename_pred_png = save_name + '/raw/' + lines[s].split( )[0].split('/')[-1].replace('.jpg', '.png') filename_cmap_png = save_name + '/cmap/' + lines[s].split( )[0].split('/')[-1].replace('.jpg', '.png') filename_image_png = save_name + '/rgb/' + lines[s].split( )[0].split('/')[-1] else: # nyu scene_name = lines[s].split()[0].split('/')[0] filename_pred_png = save_name + '/raw/' + scene_name + '_' + lines[ s].split()[0].split('/')[1].replace('.jpg', '.png') filename_cmap_png = save_name + '/cmap/' + scene_name + '_' + lines[ s].split()[0].split('/')[1].replace('.jpg', '.png') filename_gt_png = save_name + '/gt/' + scene_name + '_' + lines[ s].split()[0].split('/')[1].replace('.jpg', '.png') filename_image_png = save_name + '/rgb/' + scene_name + '_' + lines[ s].split()[0].split('/')[1] rgb_path = os.path.join(args.data_path, './' + lines[s].split()[0]) image = cv2.imread(rgb_path) if args.dataset == 'nyu': gt_path = os.path.join(args.data_path, './' + lines[s].split()[1]) gt = cv2.imread(gt_path, -1).astype( np.float32) / 1000.0 # Visualization purpose only gt[gt == 0] = np.amax(gt) pred_depth = pred_depths[s] pred_8x8 = pred_8x8s[s] pred_4x4 = pred_4x4s[s] pred_2x2 = pred_2x2s[s] pred_1x1 = pred_1x1s[s] if args.dataset == 'kitti' or args.dataset == 'kitti_benchmark': pred_depth_scaled = pred_depth * 256.0 else: pred_depth_scaled = pred_depth * 1000.0 #print(pred_depth_scaled.shape) pred_depth_scaled = pred_depth_scaled.astype(np.uint16) cv2.imwrite(filename_pred_png, pred_depth_scaled, [cv2.IMWRITE_PNG_COMPRESSION, 0]) if args.save_lpg: cv2.imwrite(filename_image_png, image[10:-1 - 9, 10:-1 - 9, :]) if args.dataset == 'nyu': plt.imsave(filename_gt_png, np.log10(gt[10:-1 - 9, 10:-1 - 9]), cmap='Greys') pred_depth_cropped = pred_depth[10:-1 - 9, 10:-1 - 9] plt.imsave(filename_cmap_png, np.log10(pred_depth_cropped), cmap='Greys') pred_8x8_cropped = pred_8x8[10:-1 - 9, 10:-1 - 9] filename_lpg_cmap_png = filename_cmap_png.replace( '.png', '_8x8.png') plt.imsave(filename_lpg_cmap_png, np.log10(pred_8x8_cropped), cmap='Greys') pred_4x4_cropped = pred_4x4[10:-1 - 9, 10:-1 - 9] filename_lpg_cmap_png = filename_cmap_png.replace( '.png', '_4x4.png') plt.imsave(filename_lpg_cmap_png, np.log10(pred_4x4_cropped), cmap='Greys') pred_2x2_cropped = pred_2x2[10:-1 - 9, 10:-1 - 9] filename_lpg_cmap_png = filename_cmap_png.replace( '.png', '_2x2.png') plt.imsave(filename_lpg_cmap_png, np.log10(pred_2x2_cropped), cmap='Greys') pred_1x1_cropped = pred_1x1[10:-1 - 9, 10:-1 - 9] filename_lpg_cmap_png = filename_cmap_png.replace( '.png', '_1x1.png') plt.imsave(filename_lpg_cmap_png, np.log10(pred_1x1_cropped), cmap='Greys') else: plt.imsave(filename_cmap_png, np.log10(pred_depth), cmap='Greys') filename_lpg_cmap_png = filename_cmap_png.replace( '.png', '_8x8.png') plt.imsave(filename_lpg_cmap_png, np.log10(pred_8x8), cmap='Greys') filename_lpg_cmap_png = filename_cmap_png.replace( '.png', '_4x4.png') plt.imsave(filename_lpg_cmap_png, np.log10(pred_4x4), cmap='Greys') filename_lpg_cmap_png = filename_cmap_png.replace( '.png', '_2x2.png') plt.imsave(filename_lpg_cmap_png, np.log10(pred_2x2), cmap='Greys') filename_lpg_cmap_png = filename_cmap_png.replace( '.png', '_1x1.png') plt.imsave(filename_lpg_cmap_png, np.log10(pred_1x1), cmap='Greys') return
def main_worker(gpu, ngpus_per_node, args): args.gpu = gpu if args.gpu is not None: print("Use GPU: {} for training".format(args.gpu)) if args.distributed: if args.dist_url == "env://" and args.rank == -1: args.rank = int(os.environ["RANK"]) if args.multiprocessing_distributed: args.rank = args.rank * ngpus_per_node + gpu dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url, world_size=args.world_size, rank=args.rank) # Create model model = BtsModel(args) nd_model = NormDiff(5e-4) model.train() model.decoder.apply(weights_init_xavier) set_misc(model) num_params = sum([np.prod(p.size()) for p in model.parameters()]) print("Total number of parameters: {}".format(num_params)) num_params_update = sum( [np.prod(p.shape) for p in model.parameters() if p.requires_grad]) print("Total number of learning parameters: {}".format(num_params_update)) if args.distributed: if args.gpu is not None: torch.cuda.set_device(args.gpu) model.cuda(args.gpu) nd_model.cuda(args.gpu) args.batch_size = int(args.batch_size / ngpus_per_node) model = torch.nn.parallel.DistributedDataParallel( model, device_ids=[args.gpu], find_unused_parameters=True) nd_model = torch.nn.parallel.DistributedDataParallel( nd_model, device_ids=[args.gpu], find_unused_parameters=True) else: model.cuda() model = torch.nn.parallel.DistributedDataParallel( model, find_unused_parameters=True) else: model = torch.nn.DataParallel(model) model.cuda() nd_model = torch.nn.DataParallel(nd_model) nd_model.cuda() if args.distributed: print("Model Initialized on GPU: {}".format(args.gpu)) else: print("Model Initialized") global_step = 0 best_eval_measures_lower_better = torch.zeros(6).cpu() + 1e3 best_eval_measures_higher_better = torch.zeros(3).cpu() best_eval_steps = np.zeros(9, dtype=np.int32) # Training parameters optimizer = torch.optim.AdamW([{ 'params': model.module.encoder.parameters(), 'weight_decay': args.weight_decay }, { 'params': model.module.decoder.parameters(), 'weight_decay': 0 }], lr=args.learning_rate, eps=args.adam_eps) model_just_loaded = False if args.checkpoint_path != '': if os.path.isfile(args.checkpoint_path): print("Loading checkpoint '{}'".format(args.checkpoint_path)) if args.gpu is None: checkpoint = torch.load(args.checkpoint_path) else: loc = 'cuda:{}'.format(args.gpu) checkpoint = torch.load(args.checkpoint_path, map_location=loc) global_step = checkpoint['global_step'] model.load_state_dict(checkpoint['model']) optimizer.load_state_dict(checkpoint['optimizer']) try: best_eval_measures_higher_better = checkpoint[ 'best_eval_measures_higher_better'].cpu() best_eval_measures_lower_better = checkpoint[ 'best_eval_measures_lower_better'].cpu() best_eval_steps = checkpoint['best_eval_steps'] except KeyError: print("Could not load values for online evaluation") print("Loaded checkpoint '{}' (global_step {})".format( args.checkpoint_path, checkpoint['global_step'])) else: print("No checkpoint found at '{}'".format(args.checkpoint_path)) model_just_loaded = True if args.retrain: global_step = 0 cudnn.benchmark = True dataloader = BtsDataLoader(args, 'train') dataloader_eval = BtsDataLoader(args, 'online_eval') # Logging if not args.multiprocessing_distributed or ( args.multiprocessing_distributed and args.rank % ngpus_per_node == 0): writer = SummaryWriter(args.log_directory + '/' + args.model_name + '/summaries', flush_secs=30) if args.do_online_eval: if args.eval_summary_directory != '': eval_summary_path = os.path.join(args.eval_summary_directory, args.model_name) else: eval_summary_path = os.path.join(args.log_directory, 'eval') eval_summary_writer = SummaryWriter(eval_summary_path, flush_secs=30) silog_criterion = silog_loss(variance_focus=args.variance_focus) mse_criterion = nn.MSELoss() start_time = time.time() duration = 0 num_log_images = args.batch_size end_learning_rate = args.end_learning_rate if args.end_learning_rate != -1 else 0.1 * args.learning_rate var_sum = [var.sum() for var in model.parameters() if var.requires_grad] var_cnt = len(var_sum) var_sum = np.sum(var_sum) print("Initial variables' sum: {:.3f}, avg: {:.3f}".format( var_sum, var_sum / var_cnt)) steps_per_epoch = len(dataloader.data) num_total_steps = args.num_epochs * steps_per_epoch epoch = global_step // steps_per_epoch while epoch < args.num_epochs: if args.distributed: dataloader.train_sampler.set_epoch(epoch) for step, sample_batched in enumerate(dataloader.data): optimizer.zero_grad() before_op_time = time.time() image = torch.autograd.Variable(sample_batched['image'].cuda( args.gpu, non_blocking=True)) focal = torch.autograd.Variable(sample_batched['focal'].cuda( args.gpu, non_blocking=True)) depth_gt = torch.autograd.Variable(sample_batched['depth'].cuda( args.gpu, non_blocking=True)) lpg8x8, lpg4x4, lpg2x2, reduc1x1, depth_est = model(image, focal) if args.dataset == 'nyu': mask = depth_gt > 0.1 else: mask = depth_gt > 1.0 valid_bmask_gt = mask & (depth_gt != 0) disp_gt = 1 / depth_gt disp_gt[~valid_bmask_gt] = 0. disp_est = torch.zeros_like(depth_est, device=depth_est.device) disp_est[depth_est > 0] = (1 / depth_est)[depth_est > 0] loss_silog = silog_criterion.forward(depth_est, depth_gt, mask.to(torch.bool)) nd_gt, diff_gt, invd_bmask = nd_model(disp_gt) nd_est, diff_est, _ = nd_model(disp_est) current_coef = (1 - .6) * (1 - global_step / num_total_steps)**.9 + .5 loss_nd = current_coef * 10 * mse_criterion( nd_est[~invd_bmask.expand(-1, 3, -1, -1)], nd_gt[~invd_bmask.expand(-1, 3, -1, -1)]) loss_diff = current_coef * 1e3 * mse_criterion( diff_gt[~invd_bmask.expand(-1, 2, -1, -1)], diff_est[~invd_bmask.expand(-1, 2, -1, -1)]) loss = loss_silog + loss_nd + loss_diff loss.backward() if global_step % 200 == 0: paint_multiple( image[0].cpu().detach(), depth_est[0].cpu().detach(), depth_gt[0].cpu().detach(), None, nd_est[0].cpu().detach(), nd_gt[0].cpu().detach(), None, diff_est[0].cpu().detach(), diff_gt[0].cpu().detach(), images_per_row=3, to_screen=False, to_file=(args.log_directory + '/' + args.model_name + '/images_save/' + 'img_%d.png' % global_step)) for param_group in optimizer.param_groups: current_lr = (args.learning_rate - end_learning_rate) * ( 1 - global_step / num_total_steps)**0.9 + end_learning_rate param_group['lr'] = current_lr optimizer.step() if not args.multiprocessing_distributed or ( args.multiprocessing_distributed and args.rank % ngpus_per_node == 0): print( '[epoch][s/s_per_e/gs]: [{}][{}/{}/{}], lr: {:.12f}, loss_silog: {:.8f}, loss_nd: {:.8f}, loss_diff: {:.8f}, cur_coef: {:.8f}' .format(epoch, step, steps_per_epoch, global_step, current_lr, loss_silog, loss_nd, loss_diff, current_coef)) if np.isnan(loss.cpu().item()): print('NaN in loss occurred. Aborting training.') return -1 duration += time.time() - before_op_time if global_step and global_step % args.log_freq == 0 and not model_just_loaded: var_sum = [ var.sum() for var in model.parameters() if var.requires_grad ] var_cnt = len(var_sum) var_sum = np.sum(var_sum) examples_per_sec = args.batch_size / duration * args.log_freq duration = 0 time_sofar = (time.time() - start_time) / 3600 training_time_left = (num_total_steps / global_step - 1.0) * time_sofar if not args.multiprocessing_distributed or ( args.multiprocessing_distributed and args.rank % ngpus_per_node == 0): print("{}".format(args.model_name)) print_string = 'GPU: {} | examples/s: {:4.2f} | loss_silog: {:.5f} | loss_nd: {:.5f} | loss_diff: {:.5f} | var sum: {:.3f} avg: {:.3f} | time elapsed: {:.2f}h | time left: {:.2f}h' print( print_string.format(args.gpu, examples_per_sec, loss_silog, loss_nd, loss_diff, var_sum.item(), var_sum.item() / var_cnt, time_sofar, training_time_left)) if not args.multiprocessing_distributed or ( args.multiprocessing_distributed and args.rank % ngpus_per_node == 0): writer.add_scalar('silog_loss', loss_silog, global_step) writer.add_scalar('nd_loss', loss_nd, global_step) writer.add_scalar('diff_loss', loss_diff, global_step) writer.add_scalar('learning_rate', current_lr, global_step) writer.add_scalar('var average', var_sum.item() / var_cnt, global_step) depth_gt = torch.where(depth_gt < 1e-3, depth_gt * 0 + 1e3, depth_gt) for i in range(num_log_images): writer.add_image( 'depth_gt/image/{}'.format(i), normalize_result(1 / depth_gt[i, :, :, :].data), global_step) writer.add_image( 'depth_est/image/{}'.format(i), normalize_result(1 / depth_est[i, :, :, :].data), global_step) writer.add_image( 'reduc1x1/image/{}'.format(i), normalize_result(1 / reduc1x1[i, :, :, :].data), global_step) writer.add_image( 'lpg2x2/image/{}'.format(i), normalize_result(1 / lpg2x2[i, :, :, :].data), global_step) writer.add_image( 'lpg4x4/image/{}'.format(i), normalize_result(1 / lpg4x4[i, :, :, :].data), global_step) writer.add_image( 'lpg8x8/image/{}'.format(i), normalize_result(1 / lpg8x8[i, :, :, :].data), global_step) writer.add_image('image/image/{}'.format(i), inv_normalize(image[i, :, :, :]).data, global_step) writer.flush() if not args.do_online_eval and global_step and global_step % args.save_freq == 0: if not args.multiprocessing_distributed or ( args.multiprocessing_distributed and args.rank % ngpus_per_node == 0): checkpoint = { 'global_step': global_step, 'model': model.state_dict(), 'optimizer': optimizer.state_dict() } torch.save( checkpoint, args.log_directory + '/' + args.model_name + '/model-{}'.format(global_step)) if args.do_online_eval and global_step and global_step % args.eval_freq == 0 and not model_just_loaded: time.sleep(0.1) model.eval() eval_measures = online_eval(model, dataloader_eval, gpu, ngpus_per_node) if eval_measures is not None: for i in range(9): eval_summary_writer.add_scalar(eval_metrics[i], eval_measures[i].cpu(), int(global_step)) measure = eval_measures[i] is_best = False if i < 6 and measure < best_eval_measures_lower_better[ i]: old_best = best_eval_measures_lower_better[i].item( ) best_eval_measures_lower_better[i] = measure.item() is_best = True elif i >= 6 and measure > best_eval_measures_higher_better[ i - 6]: old_best = best_eval_measures_higher_better[ i - 6].item() best_eval_measures_higher_better[ i - 6] = measure.item() is_best = True if is_best: old_best_step = best_eval_steps[i] old_best_name = '/model-{}-best_{}_{:.5f}'.format( old_best_step, eval_metrics[i], old_best) model_path = args.log_directory + '/' + args.model_name + old_best_name if os.path.exists(model_path): command = 'rm {}'.format(model_path) os.system(command) best_eval_steps[i] = global_step model_save_name = '/model-{}-best_{}_{:.5f}'.format( global_step, eval_metrics[i], measure) print('New best for {}. Saving model: {}'.format( eval_metrics[i], model_save_name)) checkpoint = { 'global_step': global_step, 'model': model.state_dict(), 'optimizer': optimizer.state_dict(), 'best_eval_measures_higher_better': best_eval_measures_higher_better, 'best_eval_measures_lower_better': best_eval_measures_lower_better, 'best_eval_steps': best_eval_steps } torch.save( checkpoint, args.log_directory + '/' + args.model_name + model_save_name) eval_summary_writer.flush() model.train() block_print() set_misc(model) enable_print() model_just_loaded = False global_step += 1 epoch += 1
def main_worker(gpu, ngpus_per_node, args): args.gpu = gpu if args.gpu is not None: print("Use GPU: {} for training".format(args.gpu)) # Create model nd_model = NormDiff(2e-4).cuda() cs_model = ChannelWiseSoftmax().cuda() global_step = 0 cudnn.benchmark = True dataloader = BtsDataLoader(args, 'online_eval') steps_per_epoch = len(dataloader.data) epoch = global_step // steps_per_epoch while epoch < args.num_epochs: for step, sample_batched in enumerate(dataloader.data): image = torch.autograd.Variable(sample_batched['image'].cuda( args.gpu, non_blocking=True)) focal = torch.autograd.Variable(sample_batched['focal'].cuda( args.gpu, non_blocking=True)) depth_gt = torch.autograd.Variable(sample_batched['depth'].cuda( args.gpu, non_blocking=True)) depth_gt = depth_gt.transpose(3, 2).transpose(2, 1) print('depth_gt shape =', depth_gt.shape) #lpg8x8, lpg4x4, lpg2x2, reduc1x1, depth_est = model(image, focal) if args.dataset == 'nyu': mask = depth_gt > 0.1 else: mask = depth_gt > 1.0 real_bmask = mask & (depth_gt != 0) disp_gt = 1 / depth_gt disp_gt[~real_bmask] = 0. #loss_silog = silog_criterion.forward(depth_est, depth_gt, mask.to(torch.bool)) nd_gt, diff_gt, invd_bmask = nd_model(disp_gt) #nd_gt = F.avg_pool2d(nd_gt, kernel_size=5, stride=1, padding=2) #nd_gt = F.avg_pool2d(nd_gt, kernel_size=5, stride=1, padding=2) #nd_est, diff_est, _ = nd_model(depth_est) paint_multiple(image[0].cpu().detach(), depth_gt[0].cpu().detach(), nd_gt[0].cpu().detach(), nd_gt[0, 0:2].cpu().detach(), nd_gt[0, 1:3].cpu().detach(), torch.cat((nd_gt[0, 0:1].cpu().detach(), nd_gt[0, 2:3].cpu().detach()), dim=0), images_per_row=2, to_screen=True) diff_xy_len = (diff_gt[:, 0:1, :, :].cpu().detach()**2 + diff_gt[:, 1:2, :, :].cpu().detach()**2).sqrt() diff_xy_len[invd_bmask[:, 0:1]] = 0. mean_val = diff_xy_len[~invd_bmask[:, 0:1]].mean() diff_xy_len_list = diff_xy_len.reshape(-1) N, _, H, W = diff_xy_len.shape print('max = %.8f' % diff_xy_len_list.max()) print('mean = %.8f' % mean_val) #mean_plane = mean_val.reshape(1, 1, 1, 1).expand(N, 1, H, W) nd_cls = cs_model(nd_gt, dim=1, scaling=10) N, _, H, W = nd_cls.shape cls_map = torch.zeros(N, 3, H, W, device=nd_cls.device) up_thresh = .98 # all classes tegether cls_map[:, 0:1][nd_cls[:, 0:1] > up_thresh] = 1. cls_map[:, 1:2][nd_cls[:, 0:1] > up_thresh] = 1. cls_map[:, 0:1][nd_cls[:, 1:2] > up_thresh] = 1. cls_map[:, 2:3][nd_cls[:, 1:2] > up_thresh] = 1. cls_map[:, 1:2][nd_cls[:, 2:3] > up_thresh] = 1. cls_map[:, 2:3][nd_cls[:, 2:3] > up_thresh] = 1. cls_map[:, 0:1][nd_cls[:, 3:4] > up_thresh] = 1. cls_map[:, 1:2][nd_cls[:, 4:5] > up_thresh] = 1. # different planes cls_l = torch.zeros(N, 3, H, W, device=nd_cls.device) cls_r = cls_l.clone() cls_d = cls_l.clone() cls_u = cls_l.clone() cls_b = cls_l.clone() cls_r[:, 0:1][nd_cls[:, 0:1] > up_thresh] = 1. # channel 0 is for 'sure' cls_r[:, 2:3][nd_cls[:, 0:1] < 1 - up_thresh] = 1. # channel 2 is for 'surely not' # channel 1 is for 'not sure' cls_l[:, 0:1][nd_cls[:, 1:2] > up_thresh] = 1. cls_l[:, 2:3][nd_cls[:, 1:2] < 1 - up_thresh] = 1. cls_u[:, 0:1][nd_cls[:, 2:3] > up_thresh] = 1. # channel 1 cls_u[:, 2:3][nd_cls[:, 2:3] < 1 - up_thresh] = 1. # channel 1 cls_d[:, 0:1][nd_cls[:, 3:4] > up_thresh] = 1. # channel 1 cls_d[:, 2:3][nd_cls[:, 3:4] < 1 - up_thresh] = 1. # channel 1 cls_b[:, 0:1][nd_cls[:, 4:5] > up_thresh] = 1. # channel 1 cls_b[:, 2:3][nd_cls[:, 4:5] < 1 - up_thresh] = 1. # channel 1 paint_multiple(nd_gt[0], cls_map[0], cls_l[0], cls_r[0], depth_gt[0], cls_u[0], cls_d[0], cls_b[0], images_per_row=4) #img2pcd(nd_gt[0,0:1]) #img2pcd(nd_gt[0,1:2]) #img2pcd(nd_gt[0,2:3]) #img2pcd(nd_gt[0,3:4]) #img2pcd(nd_gt[0,4:5]) #img2pcd(nd_gt[0,5:6]) #img2pcd(diff_xy_len[0], mean_plane[0]) #plt.scatter(range(len(diff_xy_len_list)), diff_xy_len_list) #plt.scatter(range(len(diff_xy_len_list)), mean_plane.reshape(-1)) #plt.show() #plt.clf() global_step += 1 epoch += 1