def train(n_epochs, learning_rate_G, learning_rate_D, batch_size, mid_flag, check_num, discriminative): beta_G = cfg.TRAIN.ADAM_BETA_G beta_D = cfg.TRAIN.ADAM_BETA_D n_vox = cfg.CONST.N_VOX dim = cfg.NET.DIM vox_shape = [n_vox[0], n_vox[1], n_vox[2], dim[-1]] com_shape = [n_vox[0], n_vox[1], n_vox[2], 2] dim_z = cfg.NET.DIM_Z start_vox_size = cfg.NET.START_VOX kernel = cfg.NET.KERNEL stride = cfg.NET.STRIDE dilations = cfg.NET.DILATIONS freq = cfg.CHECK_FREQ record_vox_num = cfg.RECORD_VOX_NUM depvox_gan_model = depvox_gan(batch_size=batch_size, vox_shape=vox_shape, com_shape=com_shape, dim_z=dim_z, dim=dim, start_vox_size=start_vox_size, kernel=kernel, stride=stride, dilations=dilations, discriminative=discriminative, is_train=True) Z_tf, z_part_enc_tf, surf_tf, full_tf, full_gen_tf, surf_dec_tf, full_dec_tf,\ gen_loss_tf, discrim_loss_tf, recons_ssc_loss_tf, recons_com_loss_tf, recons_sem_loss_tf, encode_loss_tf, refine_loss_tf, summary_tf,\ part_tf, part_dec_tf, complete_gt_tf, complete_gen_tf, complete_dec_tf, sscnet_tf, scores_tf = depvox_gan_model.build_model() global_step = tf.Variable(0, name='global_step', trainable=False) config_gpu = tf.ConfigProto() config_gpu.gpu_options.allow_growth = True sess = tf.Session(config=config_gpu) saver = tf.train.Saver(max_to_keep=cfg.SAVER_MAX) data_paths = scene_model_id_pair(dataset_portion=cfg.TRAIN.DATASET_PORTION) print('---amount of data:', str(len(data_paths))) data_process = DataProcess(data_paths, batch_size, repeat=True) enc_sscnet_vars = list( filter(lambda x: x.name.startswith('enc_ssc'), tf.trainable_variables())) enc_sdf_vars = list( filter(lambda x: x.name.startswith('enc_x'), tf.trainable_variables())) dis_sdf_vars = list( filter(lambda x: x.name.startswith('dis_x'), tf.trainable_variables())) dis_com_vars = list( filter(lambda x: x.name.startswith('dis_g'), tf.trainable_variables())) dis_sem_vars = list( filter(lambda x: x.name.startswith('dis_y'), tf.trainable_variables())) gen_com_vars = list( filter(lambda x: x.name.startswith('gen_x'), tf.trainable_variables())) gen_sem_vars = list( filter(lambda x: x.name.startswith('gen_y'), tf.trainable_variables())) gen_sdf_vars = list( filter(lambda x: x.name.startswith('gen_z'), tf.trainable_variables())) refine_vars = list( filter(lambda x: x.name.startswith('gen_y_ref'), tf.trainable_variables())) lr_VAE = tf.placeholder(tf.float32, shape=[]) # main optimiser train_op_pred_sscnet = tf.train.AdamOptimizer(learning_rate_G, beta1=beta_G, beta2=0.9).minimize( recons_ssc_loss_tf, var_list=enc_sscnet_vars) train_op_pred_com = tf.train.AdamOptimizer( learning_rate_G, beta1=beta_G, beta2=0.9).minimize( recons_com_loss_tf, var_list=enc_sdf_vars + gen_com_vars + gen_sdf_vars) train_op_pred_sem = tf.train.AdamOptimizer( learning_rate_G, beta1=beta_G, beta2=0.9).minimize( recons_sem_loss_tf, var_list=enc_sdf_vars + gen_sem_vars + gen_sdf_vars) # refine optimiser train_op_refine = tf.train.AdamOptimizer(learning_rate_G, beta1=beta_G, beta2=0.9).minimize( refine_loss_tf, var_list=refine_vars) if discriminative is True: train_op_gen_sdf = tf.train.AdamOptimizer(learning_rate_G, beta1=beta_G, beta2=0.9).minimize( gen_loss_tf, var_list=gen_sdf_vars) train_op_gen_com = tf.train.AdamOptimizer(learning_rate_G, beta1=beta_G, beta2=0.9).minimize( gen_loss_tf, var_list=gen_com_vars) train_op_gen_sem = tf.train.AdamOptimizer( learning_rate_G, beta1=beta_G, beta2=0.9).minimize(gen_loss_tf, var_list=gen_sem_vars + gen_com_vars) train_op_dis_sdf = tf.train.AdamOptimizer(learning_rate_D, beta1=beta_D, beta2=0.9).minimize( discrim_loss_tf, var_list=dis_sdf_vars) train_op_dis_com = tf.train.AdamOptimizer(learning_rate_D, beta1=beta_D, beta2=0.9).minimize( discrim_loss_tf, var_list=dis_com_vars) train_op_dis_sem = tf.train.AdamOptimizer(learning_rate_D, beta1=beta_D, beta2=0.9).minimize( discrim_loss_tf, var_list=dis_sem_vars, global_step=global_step) Z_tf_sample, comp_tf_sample, full_tf_sample, full_ref_tf_sample, part_tf_sample, scores_tf_sample = depvox_gan_model.samples_generator( visual_size=batch_size) model_path = cfg.DIR.CHECK_POINT_PATH + '-d' else: model_path = cfg.DIR.CHECK_POINT_PATH writer = tf.summary.FileWriter(cfg.DIR.LOG_PATH, sess.graph_def) tf.initialize_all_variables().run(session=sess) if mid_flag: chckpt_path = model_path + '/checkpoint' + str(check_num) saver.restore(sess, chckpt_path) Z_var_np_sample = np.load(cfg.DIR.TRAIN_OBJ_PATH + '/sample_z.npy').astype(np.float32) Z_var_np_sample = Z_var_np_sample[:batch_size] print('---weights restored') else: Z_var_np_sample = np.random.normal(size=(batch_size, start_vox_size[0], start_vox_size[1], start_vox_size[2], dim_z)).astype(np.float32) np.save(cfg.DIR.TRAIN_OBJ_PATH + '/sample_z.npy', Z_var_np_sample) ite = check_num * freq + 1 cur_epochs = int(ite / int(len(data_paths) / batch_size)) #training for epoch in np.arange(cur_epochs, n_epochs): epoch_flag = True while epoch_flag: print(colored('---Iteration:%d, epoch:%d', 'blue') % (ite, epoch)) db_inds, epoch_flag = data_process.get_next_minibatch() batch_tsdf = data_process.get_tsdf(db_inds) batch_surf = data_process.get_surf(db_inds) batch_voxel = data_process.get_voxel(db_inds) # Evaluation masks # NOTICE that the target should never have negative values, # otherwise the one-hot coding never works for that region if cfg.TYPE_TASK == 'scene': """ space_effective = np.where(batch_voxel > -1, 1, 0) * np.where(batch_tsdf > -1, 1, 0) batch_voxel *= space_effective batch_tsdf *= space_effective # occluded region """ batch_tsdf[batch_tsdf < -1] = 0 batch_surf[batch_surf < 0] = 0 batch_voxel[batch_voxel < 0] = 0 lr = learning_rate(cfg.LEARNING_RATE_V, ite) batch_z_var = np.random.normal(size=(batch_size, start_vox_size[0], start_vox_size[1], start_vox_size[2], dim_z)).astype(np.float32) # updating for the main network is_supervised = True if is_supervised is True: _ = sess.run( train_op_pred_sscnet, feed_dict={ Z_tf: batch_z_var, part_tf: batch_tsdf, surf_tf: batch_surf, full_tf: batch_voxel, lr_VAE: lr }, ) _, _, _ = sess.run( [train_op_pred_com, train_op_pred_sem, train_op_refine], feed_dict={ Z_tf: batch_z_var, part_tf: batch_tsdf, surf_tf: batch_surf, full_tf: batch_voxel, lr_VAE: lr }, ) gen_com_loss_val, gen_sem_loss_val, z_part_enc_val = sess.run( [recons_com_loss_tf, recons_sem_loss_tf, z_part_enc_tf], feed_dict={ Z_tf: batch_z_var, part_tf: batch_tsdf, surf_tf: batch_surf, full_tf: batch_voxel, lr_VAE: lr }, ) if discriminative is True: discrim_loss_val, gen_loss_val, scores_discrim = sess.run( [discrim_loss_tf, gen_loss_tf, scores_tf], feed_dict={ Z_tf: batch_z_var, part_tf: batch_tsdf, surf_tf: batch_surf, full_tf: batch_voxel, }, ) if scores_discrim[0] - scores_discrim[1] > 0.3: _ = sess.run( train_op_gen_sdf, feed_dict={ Z_tf: batch_z_var, part_tf: batch_tsdf, surf_tf: batch_surf, full_tf: batch_voxel, lr_VAE: lr }, ) if scores_discrim[2] - scores_discrim[3] > 0.3: _ = sess.run( train_op_gen_com, feed_dict={ Z_tf: batch_z_var, part_tf: batch_tsdf, surf_tf: batch_surf, full_tf: batch_voxel, lr_VAE: lr }, ) if scores_discrim[4] - scores_discrim[5] > 0.3: _ = sess.run( train_op_gen_sem, feed_dict={ Z_tf: batch_z_var, part_tf: batch_tsdf, surf_tf: batch_surf, full_tf: batch_voxel, lr_VAE: lr }, ) _ = sess.run( train_op_dis_sdf, feed_dict={ Z_tf: batch_z_var, part_tf: batch_tsdf, surf_tf: batch_surf, full_tf: batch_voxel, }, ) _ = sess.run( train_op_dis_com, feed_dict={ Z_tf: batch_z_var, part_tf: batch_tsdf, surf_tf: batch_surf, full_tf: batch_voxel, }, ) _ = sess.run( train_op_dis_sem, feed_dict={ Z_tf: batch_z_var, part_tf: batch_tsdf, surf_tf: batch_surf, full_tf: batch_voxel, }, ) print('GAN') np.set_printoptions(precision=2) print('reconstruct-com loss:', gen_com_loss_val) print('reconstruct-sem loss:', gen_sem_loss_val) if discriminative is True: print( ' gen loss:', "%.2f" % gen_loss_val if ('gen_loss_val' in locals()) else 'None') print( ' output discrim:', "%.2f" % discrim_loss_val if ('discrim_loss_val' in locals()) else 'None') print( ' scores discrim:', colored("%.2f" % scores_discrim[0], 'green'), colored("%.2f" % scores_discrim[1], 'magenta'), colored("%.2f" % scores_discrim[2], 'green'), colored("%.2f" % scores_discrim[3], 'magenta'), colored("%.2f" % scores_discrim[4], 'green'), colored("%.2f" % scores_discrim[5], 'magenta') if ('scores_discrim' in locals()) else 'None') print( ' avarage of code:', np.mean(np.mean(z_part_enc_val, 4)) if ('z_part_enc_val' in locals()) else 'None') print( ' std of code:', np.mean(np.std(z_part_enc_val, 4)) if ('z_part_enc_val' in locals()) else 'None') if np.mod(ite, freq) == 0: if discriminative is True: full_models = sess.run( full_tf_sample, feed_dict={Z_tf_sample: Z_var_np_sample}, ) full_models_cat = np.argmax(full_models, axis=4) record_vox = full_models_cat[:record_vox_num] np.save( cfg.DIR.TRAIN_OBJ_PATH + '/' + str(ite // freq) + '.npy', record_vox) save_path = saver.save(sess, model_path + '/checkpoint' + str(ite // freq), global_step=None) ite += 1
def evaluate(batch_size, checknum, mode, discriminative): n_vox = cfg.CONST.N_VOX dim = cfg.NET.DIM vox_shape = [n_vox[0], n_vox[1], n_vox[2], dim[4]] complete_shape = [n_vox[0], n_vox[1], n_vox[2], 2] dim_z = cfg.NET.DIM_Z start_vox_size = cfg.NET.START_VOX kernel = cfg.NET.KERNEL stride = cfg.NET.STRIDE dilations = cfg.NET.DILATIONS freq = cfg.CHECK_FREQ save_path = cfg.DIR.EVAL_PATH if discriminative is True: model_path = cfg.DIR.CHECK_POINT_PATH + '-d' else: model_path = cfg.DIR.CHECK_POINT_PATH chckpt_path = model_path + '/checkpoint' + str(checknum) depvox_gan_model = depvox_gan(batch_size=batch_size, vox_shape=vox_shape, complete_shape=complete_shape, dim_z=dim_z, dim=dim, start_vox_size=start_vox_size, kernel=kernel, stride=stride, dilations=dilations, discriminative=discriminative, is_train=False) Z_tf, z_enc_tf, surf_tf, full_tf, full_gen_tf, surf_dec_tf, full_dec_tf,\ gen_loss_tf, discrim_loss_tf, recons_ssc_loss_tf, recons_com_loss_tf, recons_sem_loss_tf, encode_loss_tf, refine_loss_tf, summary_tf,\ part_tf, part_dec_tf, complete_gt_tf, complete_gen_tf, complete_dec_tf, ssc_tf, scores_tf = depvox_gan_model.build_model() if discriminative is True: Z_tf_sample, comp_tf_sample, surf_tf_sample, full_tf_sample, part_tf_sample, scores_tf_sample = depvox_gan_model.samples_generator( visual_size=batch_size) sess = tf.InteractiveSession() saver = tf.train.Saver() # Restore variables from disk. saver.restore(sess, chckpt_path) print("...Weights restored.") if mode == 'recons': # evaluation for reconstruction voxel_test, surf_test, part_test, num, data_paths = scene_model_id_pair_test( dataset_portion=cfg.TRAIN.DATASET_PORTION) # Evaluation masks if cfg.TYPE_TASK == 'scene': # occluded region """ space_effective = np.where(voxel_test > -1, 1, 0) * np.where( part_test > -1, 1, 0) voxel_test *= space_effective part_test *= space_effective """ # occluded region part_test[part_test < -1] = 0 surf_test[surf_test < 0] = 0 voxel_test[voxel_test < 0] = 0 num = voxel_test.shape[0] print("test voxels loaded") for i in np.arange(int(num / batch_size)): batch_tsdf = part_test[i * batch_size:i * batch_size + batch_size] batch_surf = surf_test[i * batch_size:i * batch_size + batch_size] batch_voxel = voxel_test[i * batch_size:i * batch_size + batch_size] batch_pred_surf, batch_pred_full, batch_pred_part, batch_part_enc_Z, batch_complete_gt, batch_pred_complete, batch_ssc = sess.run( [ surf_dec_tf, full_dec_tf, part_dec_tf, z_enc_tf, complete_gt_tf, complete_dec_tf, ssc_tf ], feed_dict={ part_tf: batch_tsdf, surf_tf: batch_surf, full_tf: batch_voxel }) if i == 0: pred_part = batch_pred_part pred_surf = batch_pred_surf pred_full = batch_pred_full pred_ssc = batch_ssc part_enc_Z = batch_part_enc_Z complete_gt = batch_complete_gt pred_complete = batch_pred_complete else: pred_part = np.concatenate((pred_part, batch_pred_part), axis=0) pred_surf = np.concatenate((pred_surf, batch_pred_surf), axis=0) pred_full = np.concatenate((pred_full, batch_pred_full), axis=0) pred_ssc = np.concatenate((pred_ssc, batch_ssc), axis=0) part_enc_Z = np.concatenate((part_enc_Z, batch_part_enc_Z), axis=0) complete_gt = np.concatenate((complete_gt, batch_complete_gt), axis=0) pred_complete = np.concatenate( (pred_complete, batch_pred_complete), axis=0) print("forwarded") # For visualization bin_file = np.uint8(voxel_test) bin_file.tofile(save_path + '/scene.bin') surface = np.array(part_test) if cfg.TYPE_TASK == 'scene': surface = np.abs(surface) surface *= 10 pred_part = np.abs(pred_part) pred_part *= 10 elif cfg.TYPE_TASK == 'object': surface = np.clip(surface, 0, 1) pred_part = np.clip(pred_part, 0, 1) surface.astype('uint8').tofile(save_path + '/surface.bin') pred_part.astype('uint8').tofile(save_path + '/dec_part.bin') depsem_gt = np.multiply(voxel_test, np.clip(surface, 0, 1)) if cfg.TYPE_TASK == 'scene': depsem_gt[depsem_gt < 0] = 0 depsem_gt.astype('uint8').tofile(save_path + '/depth_seg_scene.bin') # decoded np.argmax(pred_ssc, axis=4).astype('uint8').tofile(save_path + '/dec_ssc.bin') error = np.array( np.clip(np.argmax(pred_ssc, axis=4), 0, 1) + np.argmax(complete_gt, axis=4) * 2) error.astype('uint8').tofile(save_path + '/dec_ssc_error.bin') np.argmax(pred_surf, axis=4).astype('uint8').tofile(save_path + '/dec_surf.bin') error = np.array( np.clip(np.argmax(pred_surf, axis=4), 0, 1) + np.argmax(complete_gt, axis=4) * 2) error.astype('uint8').tofile(save_path + '/dec_surf_error.bin') np.argmax(pred_full, axis=4).astype('uint8').tofile(save_path + '/dec_full.bin') error = np.array( np.clip(np.argmax(pred_full, axis=4), 0, 1) + np.argmax(complete_gt, axis=4) * 2) error.astype('uint8').tofile(save_path + '/dec_full_error.bin') np.argmax(pred_complete, axis=4).astype('uint8').tofile(save_path + '/dec_complete.bin') np.argmax(complete_gt, axis=4).astype('uint8').tofile(save_path + '/complete_gt.bin') # reconstruction and generation from normal distribution evaluation # generator from random distribution if discriminative is True: np.save(save_path + '/decode_z.npy', part_enc_Z) sample_times = 10 for j in np.arange(sample_times): Z_var_np_sample = np.random.normal( size=(batch_size, start_vox_size[0], start_vox_size[1], start_vox_size[2], dim_z)).astype(np.float32) z_comp_rand, z_surf_rand, z_full_rand, z_part_rand, scores_sample = sess.run( [ comp_tf_sample, surf_tf_sample, full_tf_sample, part_tf_sample, scores_tf_sample ], feed_dict={Z_tf_sample: Z_var_np_sample}) if j == 0: z_comp_rand_all = z_comp_rand z_part_rand_all = z_part_rand z_surf_rand_all = z_surf_rand z_full_rand_all = z_full_rand else: z_comp_rand_all = np.concatenate( [z_comp_rand_all, z_comp_rand], axis=0) z_part_rand_all = np.concatenate( [z_part_rand_all, z_part_rand], axis=0) z_surf_rand_all = np.concatenate( [z_surf_rand_all, z_surf_rand], axis=0) z_full_rand_all = np.concatenate( [z_full_rand_all, z_full_rand], axis=0) print(scores_sample) Z_var_np_sample.astype('float32').tofile(save_path + '/sample_z.bin') np.argmax(z_comp_rand_all, axis=4).astype('uint8').tofile(save_path + '/gen_comp.bin') np.argmax(z_surf_rand_all, axis=4).astype('uint8').tofile(save_path + '/gen_surf.bin') np.argmax(z_full_rand_all, axis=4).astype('uint8').tofile(save_path + '/gen_full.bin') if cfg.TYPE_TASK == 'scene': z_part_rand_all = np.abs(z_part_rand_all) z_part_rand_all *= 10 elif cfg.TYPE_TASK == 'object': z_part_rand_all[z_part_rand_all <= 0.4] = 0 z_part_rand_all[z_part_rand_all > 0.4] = 1 z_part_rand = np.squeeze(z_part_rand) z_part_rand_all.astype('uint8').tofile(save_path + '/gen_part.bin') eigen_shape = False if eigen_shape: z_U, z_V = pca(np.reshape(part_enc_Z, [ 200, start_vox_size[0] * start_vox_size[1] * start_vox_size[2] * dim_z ]), dim_remain=200) z_V = np.reshape(np.transpose(z_V[:, 0:8]), [ 8, start_vox_size[0], start_vox_size[1], start_vox_size[2], dim_z ]) z_surf_rand, z_full_rand, z_part_rand = sess.run( [surf_tf_sample, full_tf_sample, part_tf_sample], feed_dict={Z_tf_sample: z_V}) np.argmax(z_surf_rand, axis=4).astype('uint8').tofile(save_path + '/gen_surf.bin') if cfg.TYPE_TASK == 'scene': z_part_rand = np.abs(z_part_rand) z_part_rand *= 10 elif cfg.TYPE_TASK == 'object': z_part_rand[z_part_rand <= 0.4] = 0 z_part_rand[z_part_rand > 0.4] = 1 z_part_rand = np.squeeze(z_part_rand) z_part_rand.astype('uint8').tofile(save_path + '/gen_sdf.bin') print("voxels saved") # numerical evalutation # calc_IoU # completion on_complete_gt = complete_gt complete_gen = np.argmax(pred_complete, axis=4) on_complete_gen = onehot(complete_gen, 2) IoU_comp = np.zeros([2 + 1]) AP_comp = np.zeros([2 + 1]) print(colored("Completion", 'cyan')) IoU_comp = IoU(on_complete_gt, on_complete_gen, IoU_comp, [vox_shape[0], vox_shape[1], vox_shape[2], 2]) # depth segmentation on_depsem_gt = onehot(depsem_gt, vox_shape[3]) on_depsem_ssc = np.multiply( onehot(np.argmax(pred_ssc, axis=4), vox_shape[3]), np.expand_dims(np.clip(surface, 0, 1), -1)) on_depsem_dec = np.multiply( onehot(np.argmax(pred_full, axis=4), vox_shape[3]), np.expand_dims(np.clip(surface, 0, 1), -1)) print(colored("Geometric segmentation", 'cyan')) IoU_class = np.zeros([vox_shape[3] + 1]) IoU_class = IoU(on_depsem_gt, on_depsem_ssc, IoU_class, vox_shape) IoU_all = np.expand_dims(IoU_class, axis=1) print(colored("Generative segmentation", 'cyan')) IoU_class = np.zeros([vox_shape[3] + 1]) IoU_class = IoU(on_depsem_gt, on_depsem_dec, IoU_class, vox_shape) IoU_all = np.expand_dims(IoU_class, axis=1) # volume segmentation on_surf_gt = onehot(surf_test, vox_shape[3]) on_full_gt = onehot(voxel_test, vox_shape[3]) print(colored("Geometric semantic completion", 'cyan')) on_pred = onehot(np.argmax(pred_ssc, axis=4), vox_shape[3]) IoU_class = IoU(on_full_gt, on_pred, IoU_class, vox_shape) IoU_all = np.concatenate((IoU_all, np.expand_dims(IoU_class, axis=1)), axis=1) print(colored("Generative semantic completion", 'cyan')) on_pred = onehot(np.argmax(pred_surf, axis=4), vox_shape[3]) IoU_class = IoU(on_full_gt, on_pred, IoU_class, vox_shape) IoU_all = np.concatenate((IoU_all, np.expand_dims(IoU_class, axis=1)), axis=1) print(colored("Solid generative semantic completion", 'cyan')) on_pred = onehot(np.argmax(pred_full, axis=4), vox_shape[3]) IoU_class = IoU(on_full_gt, on_pred, IoU_class, vox_shape) IoU_all = np.concatenate((IoU_all, np.expand_dims(IoU_class, axis=1)), axis=1) np.savetxt(save_path + '/IoU.csv', np.transpose(IoU_all[1:] * 100), delimiter=" & ", fmt='%2.1f') # interpolation evaluation if mode == 'interpolate': interpolate_num = 8 #interpolatioin latent vectores decode_z = np.load(save_path + '/decode_z.npy') print(save_path) decode_z = decode_z[20:20 + batch_size] for l in np.arange(batch_size): for r in np.arange(batch_size): if l != r: print l, r base_num_left = l base_num_right = r left = np.reshape(decode_z[base_num_left], [ 1, start_vox_size[0], start_vox_size[1], start_vox_size[2], dim_z ]) right = np.reshape(decode_z[base_num_right], [ 1, start_vox_size[0], start_vox_size[1], start_vox_size[2], dim_z ]) duration = (right - left) / (interpolate_num - 1) # left is the reference sample and Z_np_sample is the remaining samples if base_num_left == 0: Z_np_sample = decode_z[1:] elif base_num_left == batch_size - 1: Z_np_sample = decode_z[:batch_size - 1] else: Z_np_sample_before = np.reshape( decode_z[:base_num_left], [ base_num_left, start_vox_size[0], start_vox_size[1], start_vox_size[2], dim_z ]) Z_np_sample_after = np.reshape( decode_z[base_num_left + 1:], [ batch_size - base_num_left - 1, start_vox_size[0], start_vox_size[1], start_vox_size[2], dim_z ]) Z_np_sample = np.concatenate( [Z_np_sample_before, Z_np_sample_after], axis=0) for i in np.arange(interpolate_num): if i == 0: Z = copy.copy(left) interpolate_z = copy.copy(Z) else: Z = Z + duration interpolate_z = np.concatenate([interpolate_z, Z], axis=0) # Z_np_sample is used to fill up the batch Z_var_np_sample = np.concatenate([Z, Z_np_sample], axis=0) pred_full_rand, pred_part_rand = sess.run( [full_tf_sample, part_tf_sample], feed_dict={Z_tf_sample: Z_var_np_sample}) interpolate_vox = np.reshape(pred_full_rand[0], [ 1, vox_shape[0], vox_shape[1], vox_shape[2], vox_shape[3] ]) interpolate_part = np.reshape(pred_part_rand[0], [ 1, vox_shape[0], vox_shape[1], vox_shape[2], complete_shape[3] ]) if i == 0: pred_full = interpolate_vox pred_part = interpolate_part else: pred_full = np.concatenate( [pred_full, interpolate_vox], axis=0) pred_part = np.concatenate( [pred_part, interpolate_part], axis=0) interpolate_z.astype('uint8').tofile( save_path + '/interpolate/interpolation_z' + str(l) + '-' + str(r) + '.bin') full_models_cat = np.argmax(pred_full, axis=4) full_models_cat.astype('uint8').tofile( save_path + '/interpolate/interpolation_f' + str(l) + '-' + str(r) + '.bin') if cfg.TYPE_TASK == 'scene': pred_part = np.abs(pred_part) pred_part[pred_part < 0.2] = 0 pred_part[pred_part >= 0.2] = 1 elif cfg.TYPE_TASK == 'object': pred_part = np.argmax(pred_part, axis=4) pred_part.astype('uint8').tofile( save_path + '/interpolate/interpolation_p' + str(l) + '-' + str(r) + '.bin') print("voxels saved") # add noise evaluation if mode == 'noise': decode_z = np.load(save_path + '/decode_z.npy') decode_z = decode_z[:batch_size] noise_num = 10 for base_num in np.arange(batch_size): print base_num base = np.reshape(decode_z[base_num], [ 1, start_vox_size[0], start_vox_size[1], start_vox_size[2], dim_z ]) eps = np.random.normal(size=(noise_num - 1, dim_z)).astype(np.float32) if base_num == 0: Z_np_sample = decode_z[1:] elif base_num == batch_size - 1: Z_np_sample = decode_z[:batch_size - 1] else: Z_np_sample_before = np.reshape(decode_z[:base_num], [ base_num, start_vox_size[0], start_vox_size[1], start_vox_size[2], dim_z ]) Z_np_sample_after = np.reshape(decode_z[base_num + 1:], [ batch_size - base_num - 1, start_vox_size[0], start_vox_size[1], start_vox_size[2], dim_z ]) Z_np_sample = np.concatenate( [Z_np_sample_before, Z_np_sample_after], axis=0) for c in np.arange(start_vox_size[0]): for l in np.arange(start_vox_size[1]): for d in np.arange(start_vox_size[2]): for i in np.arange(noise_num): if i == 0: Z = copy.copy(base) noise_z = copy.copy(Z) else: Z = copy.copy(base) Z[0, c, l, d, :] += eps[i - 1] noise_z = np.concatenate([noise_z, Z], axis=0) Z_var_np_sample = np.concatenate([Z, Z_np_sample], axis=0) pred_full_rand = sess.run( full_tf_sample, feed_dict={Z_tf_sample: Z_var_np_sample}) """ refined_voxs_rand = sess.run( sample_refine_full_tf, feed_dict={ sample_full_tf: pred_full_rand }) """ noise_vox = np.reshape(pred_full_rand[0], [ 1, vox_shape[0], vox_shape[1], vox_shape[2], vox_shape[3] ]) if i == 0: pred_full = noise_vox else: pred_full = np.concatenate( [pred_full, noise_vox], axis=0) np.save( save_path + '/noise_z' + str(base_num) + '_' + str(c) + str(l) + str(d) + '.npy', noise_z) full_models_cat = np.argmax(pred_full, axis=4) np.save( save_path + '/noise' + str(base_num) + '_' + str(c) + str(l) + str(d) + '.npy', full_models_cat) print("voxels saved")
def byproduct(batch_size, checknum): n_vox = cfg.CONST.N_VOX dim = cfg.NET.DIM vox_shape = [n_vox[0], n_vox[1], n_vox[2], dim[4]] tsdf_shape = [n_vox[0], n_vox[1], n_vox[2], 3] dim_z = cfg.NET.DIM_Z start_vox_size = cfg.NET.START_VOX kernel = cfg.NET.KERNEL stride = cfg.NET.STRIDE dilations = cfg.NET.DILATIONS freq = cfg.CHECK_FREQ discriminative = cfg.NET.DISCRIMINATIVE generative = cfg.NET.GENERATIVE save_path = cfg.DIR.EVAL_PATH chckpt_path = cfg.DIR.CHECK_PT_PATH + str(checknum) depvox_gan_model = depvox_gan( batch_size=batch_size, vox_shape=vox_shape, tsdf_shape=tsdf_shape, dim_z=dim_z, dim=dim, start_vox_size=start_vox_size, kernel=kernel, stride=stride, dilations=dilations, generative=generative) Z_tf, z_tsdf_enc_tf, z_vox_enc_tf, vox_tf, vox_gen_tf, vox_gen_decode_tf, vox_vae_decode_tf, vox_cc_decode_tf,\ recon_vae_loss_tf, recon_cc_loss_tf, recon_gen_loss_tf, code_encode_loss_tf, gen_loss_tf, discrim_loss_tf,\ cost_enc_tf, cost_code_tf, cost_gen_tf, cost_discrim_tf, summary_tf,\ tsdf_tf, tsdf_gen_tf, tsdf_gen_decode_tf, tsdf_vae_decode_tf, tsdf_cc_decode_tf = depvox_gan_model.build_model() sess = tf.InteractiveSession() saver = tf.train.Saver() # Restore variables from disk. saver.restore(sess, chckpt_path) print("...Weights restored.") model_path = cfg.DIR.ROOT_PATH models = os.listdir(model_path) scene_name_pair = [] # full path of the objs files scene_name_pair.extend([(model_path, model_id) for model_id in models]) num_models = len(scene_name_pair) batch_tsdf = np.zeros((batch_size, n_vox[0], n_vox[1], n_vox[2]), dtype=np.float32) batch_voxel = np.zeros((batch_size, n_vox[0], n_vox[1], n_vox[2]), dtype=np.float32) for i in np.arange(num_models): sceneId, model_id = scene_name_pair[i] voxel_fn = cfg.DIR.VOXEL_PATH % (model_id) voxel_data = np.load(voxel_fn) batch_voxel[0, :, :, :] = voxel_data tsdf_fn = cfg.DIR.TSDF_PATH % (model_id) tsdf_data = np.load(tsdf_fn) batch_tsdf[0, :, :, :] = tsdf_data # Evaluation masks if cfg.TYPE_TASK is 'scene': volume_effective = np.clip( np.where(batch_voxel > 0, 1, 0) + np.where( batch_tsdf > 0, 1, 0), 0, 1) batch_voxel *= volume_effective batch_tsdf *= volume_effective # batch_tsdf[batch_tsdf > 1] = 0 # batch_tsdf_test[np.where(batch_voxel_test == 10)] = 1 batch_pred_voxs, batch_vae_voxs, batch_cc_voxs,\ batch_pred_tsdf, batch_vae_tsdf, batch_cc_tsdf = sess.run( [ vox_gen_decode_tf, vox_vae_decode_tf, vox_cc_decode_tf, tsdf_gen_decode_tf, tsdf_vae_decode_tf, tsdf_cc_decode_tf ], feed_dict={ tsdf_tf: batch_tsdf, vox_tf: batch_voxel }) batch_pred_tsdf = np.argmax(batch_pred_tsdf, axis=4).astype('float32') import ipdb ipdb.set_trace() # batch_pred_tsdf[batch_tsdf == -1] = -1 np.save( '/media/wangyida/SSD2T/database/SUNCG_Yida/test/depth_tsdf_vae_npy/' + models[i], batch_pred_tsdf[0])
def evaluate(batch_size, checknum, mode, discriminative): n_vox = cfg.CONST.N_VOX dim = cfg.NET.DIM vox_shape = [n_vox[0], n_vox[1], n_vox[2], dim[4]] com_shape = [n_vox[0], n_vox[1], n_vox[2], 2] dim_z = cfg.NET.DIM_Z start_vox_size = cfg.NET.START_VOX kernel = cfg.NET.KERNEL stride = cfg.NET.STRIDE dilations = cfg.NET.DILATIONS freq = cfg.CHECK_FREQ save_path = cfg.DIR.EVAL_PATH if discriminative is True: model_path = cfg.DIR.CHECK_POINT_PATH + '-d' else: model_path = cfg.DIR.CHECK_POINT_PATH chckpt_path = model_path + '/checkpoint' + str(checknum) depvox_gan_model = depvox_gan(batch_size=batch_size, vox_shape=vox_shape, com_shape=com_shape, dim_z=dim_z, dim=dim, start_vox_size=start_vox_size, kernel=kernel, stride=stride, dilations=dilations, discriminative=discriminative, is_train=False) Z_tf, z_enc_tf, surf_tf, full_tf, full_gen_tf, surf_dec_tf, full_dec_tf,\ gen_loss_tf, discrim_loss_tf, recons_ssc_loss_tf, recons_com_loss_tf, recons_sem_loss_tf, encode_loss_tf, refine_loss_tf, summary_tf,\ part_tf, part_dec_tf, comp_gt_tf, comp_gen_tf, comp_dec_tf, ssc_tf, scores_tf = depvox_gan_model.build_model() if discriminative is True: Z_tf_samp, comp_tf_samp, surf_tf_samp, full_tf_samp, part_tf_samp, scores_tf_samp = depvox_gan_model.samples_generator( visual_size=batch_size) sess = tf.InteractiveSession() saver = tf.train.Saver() # Restore variables from disk. saver.restore(sess, chckpt_path) print("...Weights restored.") if mode == 'recons': # evaluation for reconstruction voxel_test, surf_test, part_test, num, data_paths = scene_model_id_pair_test( dataset_portion=cfg.TRAIN.DATASET_PORTION) # Evaluation masks if cfg.TYPE_TASK == 'scene': # occluded region """ space_effective = np.where(voxel_test > -1, 1, 0) * np.where( part_test > -1, 1, 0) voxel_test *= space_effective part_test *= space_effective """ # occluded region part_test[part_test < -1] = 0 surf_test[surf_test < 0] = 0 voxel_test[voxel_test < 0] = 0 num = voxel_test.shape[0] print("test voxels loaded") from progressbar import ProgressBar pbar = ProgressBar() for i in pbar(np.arange(int(num / batch_size))): bth_tsdf = part_test[i * batch_size:i * batch_size + batch_size] bth_surf = surf_test[i * batch_size:i * batch_size + batch_size] bth_voxel = voxel_test[i * batch_size:i * batch_size + batch_size] bth_pd_surf, bth_pd_full, bth_pd_part, bth_part_enc_Z, bth_comp_gt, bth_pd_comp, bth_ssc = sess.run( [ surf_dec_tf, full_dec_tf, part_dec_tf, z_enc_tf, comp_gt_tf, comp_dec_tf, ssc_tf ], feed_dict={ part_tf: bth_tsdf, surf_tf: bth_surf, full_tf: bth_voxel }) if i == 0: pd_part = bth_pd_part pd_surf = bth_pd_surf pd_full = bth_pd_full pd_ssc = bth_ssc part_enc_Z = bth_part_enc_Z comp_gt = bth_comp_gt pd_comp = bth_pd_comp else: pd_part = np.concatenate((pd_part, bth_pd_part), axis=0) pd_surf = np.concatenate((pd_surf, bth_pd_surf), axis=0) pd_full = np.concatenate((pd_full, bth_pd_full), axis=0) pd_ssc = np.concatenate((pd_ssc, bth_ssc), axis=0) part_enc_Z = np.concatenate((part_enc_Z, bth_part_enc_Z), axis=0) comp_gt = np.concatenate((comp_gt, bth_comp_gt), axis=0) pd_comp = np.concatenate((pd_comp, bth_pd_comp), axis=0) print("forwarded") # For visualization bin_file = np.uint8(voxel_test) bin_file.tofile(save_path + '/scene.bin') sdf_volume = np.round(10 * np.abs(np.array(part_test))) observed = np.array(part_test) if cfg.TYPE_TASK == 'scene': observed = np.abs(observed) observed *= 10 observed -= 7 observed = np.round(observed) pd_part = np.abs(pd_part) pd_part *= 10 pd_part -= 7 elif cfg.TYPE_TASK == 'object': observed = np.clip(observed, 0, 1) pd_part = np.clip(pd_part, 0, 1) sdf_volume.astype('uint8').tofile(save_path + '/surface.bin') pd_part.astype('uint8').tofile(save_path + '/dec_part.bin') depsem_gt = np.multiply(voxel_test, np.clip(observed, 0, 1)) if cfg.TYPE_TASK == 'scene': depsem_gt[depsem_gt < 0] = 0 depsem_gt.astype('uint8').tofile(save_path + '/depth_seg_scene.bin') # decoded do_save_pcd = True if do_save_pcd is True: results_pcds = np.argmax(pd_ssc, axis=4) for i in range(np.shape(results_pcds)[0]): pcd_idx = np.where(results_pcds[i] > 0) pts_coord = np.float32(np.transpose(pcd_idx)) / 80 - 0.5 pts_color = matplotlib.cm.Paired( np.float32(results_pcds[i][pcd_idx]) / 11 - 0.5 / 11) output_name = os.path.join('results_pcds', '%s.pcd' % data_paths[i][1][:-4]) output_pcds = np.concatenate((pts_coord, pts_color[:, 0:3]), -1) save_pcd(output_name, output_pcds) np.argmax(pd_ssc, axis=4).astype('uint8').tofile(save_path + '/dec_ssc.bin') error = np.array( np.clip(np.argmax(pd_ssc, axis=4), 0, 1) + np.argmax(comp_gt, axis=4) * 2) error.astype('uint8').tofile(save_path + '/dec_ssc_error.bin') np.argmax(pd_surf, axis=4).astype('uint8').tofile(save_path + '/dec_surf.bin') error = np.array( np.clip(np.argmax(pd_surf, axis=4), 0, 1) + np.argmax(comp_gt, axis=4) * 2) error.astype('uint8').tofile(save_path + '/dec_surf_error.bin') np.argmax(pd_full, axis=4).astype('uint8').tofile(save_path + '/dec_full.bin') error = np.array( np.clip(np.argmax(pd_full, axis=4), 0, 1) + np.argmax(comp_gt, axis=4) * 2) error.astype('uint8').tofile(save_path + '/dec_full_error.bin') np.argmax(pd_comp, axis=4).astype('uint8').tofile(save_path + '/dec_complete.bin') np.argmax(comp_gt, axis=4).astype('uint8').tofile(save_path + '/complete_gt.bin') # reconstruction and generation from normal distribution evaluation # generator from random distribution if discriminative is True: np.save(save_path + '/decode_z.npy', part_enc_Z) sample_times = 10 for j in np.arange(sample_times): gaussian_samp = np.random.normal( size=(batch_size, start_vox_size[0], start_vox_size[1], start_vox_size[2], dim_z)).astype(np.float32) z_comp_rnd, z_surf_rnd, z_full_rnd, z_part_rnd, scores_samp = sess.run( [ comp_tf_samp, surf_tf_samp, full_tf_samp, part_tf_samp, scores_tf_samp ], feed_dict={Z_tf_samp: gaussian_samp}) if j == 0: z_comp_rnd_all = z_comp_rnd z_part_rnd_all = z_part_rnd z_surf_rnd_all = z_surf_rnd z_full_rnd_all = z_full_rnd else: z_comp_rnd_all = np.concatenate( [z_comp_rnd_all, z_comp_rnd], axis=0) z_part_rnd_all = np.concatenate( [z_part_rnd_all, z_part_rnd], axis=0) z_surf_rnd_all = np.concatenate( [z_surf_rnd_all, z_surf_rnd], axis=0) z_full_rnd_all = np.concatenate( [z_full_rnd_all, z_full_rnd], axis=0) print('Discrim score: ' + colored(np.mean(scores_samp), 'blue')) gaussian_samp.astype('float32').tofile(save_path + '/sample_z.bin') np.argmax(z_comp_rnd_all, axis=4).astype('uint8').tofile(save_path + '/gen_comp.bin') np.argmax(z_surf_rnd_all, axis=4).astype('uint8').tofile(save_path + '/gen_surf.bin') np.argmax(z_full_rnd_all, axis=4).astype('uint8').tofile(save_path + '/gen_full.bin') if cfg.TYPE_TASK == 'scene': z_part_rnd_all = np.abs(z_part_rnd_all) z_part_rnd_all *= 10 z_part_rnd_all -= 7 elif cfg.TYPE_TASK == 'object': z_part_rnd_all[z_part_rnd_all <= 0.4] = 0 z_part_rnd_all[z_part_rnd_all > 0.4] = 1 z_part_rnd = np.squeeze(z_part_rnd) z_part_rnd_all.astype('uint8').tofile(save_path + '/gen_part.bin') print("voxels saved") # numerical evalutation iou_eval = True if iou_eval is True: # completion print(colored("Completion:", 'red')) on_gt = comp_gt pd_max = np.argmax(pd_comp, axis=4) on_pd = onehot(pd_max, 2) IoU_comp = np.zeros([2 + 1]) AP_comp = np.zeros([2 + 1]) IoU_comp = IoU(on_gt, on_pd, [vox_shape[0], vox_shape[1], vox_shape[2], 2]) # depth segmentation print(colored("Segmentation:", 'red')) print(colored("encoded", 'cyan')) on_gt = onehot(depsem_gt, vox_shape[3]) on_pd = np.multiply( onehot(np.argmax(pd_ssc, axis=4), vox_shape[3]), np.expand_dims(np.clip(observed, 0, 1), -1)) # IoUs = np.zeros([vox_shape[3] + 1]) IoU_temp = IoU(on_gt, on_pd, vox_shape) IoU_all = np.expand_dims(IoU_temp, axis=1) print(colored("decoded", 'cyan')) on_pd = np.multiply( onehot(np.argmax(pd_surf, axis=4), vox_shape[3]), np.expand_dims(np.clip(observed, 0, 1), -1)) IoU_temp = IoU(on_gt, on_pd, vox_shape, IoU_compared=IoU_all[:, -1]) IoU_all = np.concatenate( (IoU_all, np.expand_dims(IoU_temp, axis=1)), axis=1) print(colored("solidly decoded", 'cyan')) on_pd = np.multiply( onehot(np.argmax(pd_full, axis=4), vox_shape[3]), np.expand_dims(np.clip(observed, 0, 1), -1)) IoU_temp = IoU(on_gt, on_pd, vox_shape, IoU_compared=IoU_all[:, -1]) IoU_all = np.concatenate( (IoU_all, np.expand_dims(IoU_temp, axis=1)), axis=1) # volume segmentation print(colored("Semantic Completion:", 'red')) on_surf_gt = onehot(surf_test, vox_shape[3]) on_gt = onehot(voxel_test, vox_shape[3]) print(colored("encoded", 'cyan')) on_pd = onehot(np.argmax(pd_ssc, axis=4), vox_shape[3]) IoU_temp = IoU(on_gt, on_pd, vox_shape) IoU_all = np.concatenate( (IoU_all, np.expand_dims(IoU_temp, axis=1)), axis=1) print(colored("decoded", 'cyan')) on_pd = onehot(np.argmax(pd_surf, axis=4), vox_shape[3]) IoU_temp = IoU(on_gt, on_pd, vox_shape, IoU_compared=IoU_all[:, -1]) IoU_all = np.concatenate( (IoU_all, np.expand_dims(IoU_temp, axis=1)), axis=1) print(colored("solidly decoded", 'cyan')) on_pd = onehot(np.argmax(pd_full, axis=4), vox_shape[3]) IoU_temp = IoU(on_gt, on_pd, vox_shape, IoU_compared=IoU_all[:, -1]) IoU_all = np.concatenate( (IoU_all, np.expand_dims(IoU_temp, axis=1)), axis=1) np.savetxt(save_path + '/IoU.csv', np.transpose(IoU_all[1:] * 100), delimiter=" & ", fmt='%2.1f') # interpolation evaluation if mode == 'interpolate': interpolate_num = 8 #interpolatioin latent vectores decode_z = np.load(save_path + '/decode_z.npy') print(save_path) decode_z = decode_z[20:20 + batch_size] for l in np.arange(batch_size): for r in np.arange(batch_size): if l != r: print l, r base_num_left = l base_num_right = r left = np.reshape(decode_z[base_num_left], [ 1, start_vox_size[0], start_vox_size[1], start_vox_size[2], dim_z ]) right = np.reshape(decode_z[base_num_right], [ 1, start_vox_size[0], start_vox_size[1], start_vox_size[2], dim_z ]) duration = (right - left) / (interpolate_num - 1) # left is the reference sample and Z_np_samp is the remaining samples if base_num_left == 0: Z_np_samp = decode_z[1:] elif base_num_left == batch_size - 1: Z_np_samp = decode_z[:batch_size - 1] else: Z_np_samp_before = np.reshape( decode_z[:base_num_left], [ base_num_left, start_vox_size[0], start_vox_size[1], start_vox_size[2], dim_z ]) Z_np_samp_after = np.reshape( decode_z[base_num_left + 1:], [ batch_size - base_num_left - 1, start_vox_size[0], start_vox_size[1], start_vox_size[2], dim_z ]) Z_np_samp = np.concatenate( [Z_np_samp_before, Z_np_samp_after], axis=0) for i in np.arange(interpolate_num): if i == 0: Z = copy.copy(left) interpolate_z = copy.copy(Z) else: Z = Z + duration interpolate_z = np.concatenate([interpolate_z, Z], axis=0) # Z_np_samp is used to fill up the batch gaussian_samp = np.concatenate([Z, Z_np_samp], axis=0) pd_full_rnd, pd_part_rnd = sess.run( [full_tf_samp, part_tf_samp], feed_dict={Z_tf_samp: gaussian_samp}) interpolate_vox = np.reshape(pd_full_rnd[0], [ 1, vox_shape[0], vox_shape[1], vox_shape[2], vox_shape[3] ]) interpolate_part = np.reshape(pd_part_rnd[0], [ 1, vox_shape[0], vox_shape[1], vox_shape[2], com_shape[3] ]) if i == 0: pd_full = interpolate_vox pd_part = interpolate_part else: pd_full = np.concatenate( [pd_full, interpolate_vox], axis=0) pd_part = np.concatenate( [pd_part, interpolate_part], axis=0) interpolate_z.astype('uint8').tofile( save_path + '/interpolate/interpolation_z' + str(l) + '-' + str(r) + '.bin') full_models_cat = np.argmax(pd_full, axis=4) full_models_cat.astype('uint8').tofile( save_path + '/interpolate/interpolation_f' + str(l) + '-' + str(r) + '.bin') if cfg.TYPE_TASK == 'scene': pd_part = np.abs(pd_part) pd_part *= 10 pd_part -= 7 elif cfg.TYPE_TASK == 'object': pd_part = np.argmax(pd_part, axis=4) pd_part.astype('uint8').tofile( save_path + '/interpolate/interpolation_p' + str(l) + '-' + str(r) + '.bin') print("voxels saved") # add noise evaluation if mode == 'noise': decode_z = np.load(save_path + '/decode_z.npy') decode_z = decode_z[:batch_size] noise_num = 10 for base_num in np.arange(batch_size): print base_num base = np.reshape(decode_z[base_num], [ 1, start_vox_size[0], start_vox_size[1], start_vox_size[2], dim_z ]) eps = np.random.normal(size=(noise_num - 1, dim_z)).astype(np.float32) if base_num == 0: Z_np_samp = decode_z[1:] elif base_num == batch_size - 1: Z_np_samp = decode_z[:batch_size - 1] else: Z_np_samp_before = np.reshape(decode_z[:base_num], [ base_num, start_vox_size[0], start_vox_size[1], start_vox_size[2], dim_z ]) Z_np_samp_after = np.reshape(decode_z[base_num + 1:], [ batch_size - base_num - 1, start_vox_size[0], start_vox_size[1], start_vox_size[2], dim_z ]) Z_np_samp = np.concatenate([Z_np_samp_before, Z_np_samp_after], axis=0) for c in np.arange(start_vox_size[0]): for l in np.arange(start_vox_size[1]): for d in np.arange(start_vox_size[2]): for i in np.arange(noise_num): if i == 0: Z = copy.copy(base) noise_z = copy.copy(Z) else: Z = copy.copy(base) Z[0, c, l, d, :] += eps[i - 1] noise_z = np.concatenate([noise_z, Z], axis=0) gaussian_samp = np.concatenate([Z, Z_np_samp], axis=0) pd_full_rnd = sess.run( full_tf_samp, feed_dict={Z_tf_samp: gaussian_samp}) """ refined_voxs_rnd = sess.run( sample_refine_full_tf, feed_dict={ sample_full_tf: pd_full_rnd }) """ noise_vox = np.reshape(pd_full_rnd[0], [ 1, vox_shape[0], vox_shape[1], vox_shape[2], vox_shape[3] ]) if i == 0: pd_full = noise_vox else: pd_full = np.concatenate([pd_full, noise_vox], axis=0) np.save( save_path + '/noise_z' + str(base_num) + '_' + str(c) + str(l) + str(d) + '.npy', noise_z) full_models_cat = np.argmax(pd_full, axis=4) np.save( save_path + '/noise' + str(base_num) + '_' + str(c) + str(l) + str(d) + '.npy', full_models_cat) print("voxels saved")