def main(): params = parse_args() conf = get_conf(params) ckpt_path = os.path.join('./data/', params['experiment_name'], params['class_name']) epoch = conf.training_epochs reset_tf_graph() ae = PointNetAutoEncoder(conf.experiment_name, conf) ae.restore_model(ckpt_path, epoch, verbose=True) test_dir = './s3dis/Area_6/*/Annotations/{}_*.txt' all_pc_data = load_all_point_clouds_under_folder(test_dir, params['class_name'], n_points=conf.n_input[0], with_color=conf.input_color, n_threads=20, verbose=True) all_pc_data.shuffle_data() feed_pc, feed_model_names, _ = all_pc_data.next_batch(10) feed_pc_v, feed_pc_v_org = np.split(np.array([get_visible_points(x, org=True) for x in feed_pc]), 2, axis=1) # [normalized_pcs, original_pcs] feed_pc_v = np.array([x[0] for x in feed_pc_v]) feed_pc_v_org = np.array([x[0] for x in feed_pc_v_org]) ae_reconstructions, v_reconstructions, _ = ae.reconstruct([feed_pc, feed_pc_v], compute_loss=False) print('finish inference') visualize(params['experiment_name'], params['class_name'], feed_pc[:, :, :3], ae_reconstructions, feed_pc_v_org[:, :, :3], v_reconstructions)
'chamfer_nn_complete': 'chamfer_nn_idx_complete_test_set' } nn_idx = load_data(data_path, files, [nn_idx_dict[conf.target_pc_idx_type]]) correct_pred = None if conf.correct_pred_only: pc_labels, pc_pred_labels = load_data( data_path, files, ['pc_label_test_set', 'pc_pred_labels_test_set']) correct_pred = (pc_labels == pc_pred_labels) # load indices for attack attack_pc_idx = np.load(osp.join(top_out_dir, flags.attack_pc_idx)) attack_pc_idx = attack_pc_idx[:, :conf.num_pc_for_attack] # build classifier model and reload a saved model reset_tf_graph() classifier = PointNetClassifier(classifier_path, flags.classifier_restore_epoch, num_points=flags.num_points, batch_size=10, num_classes=flags.num_classes) classes_for_attack = conf.class_names classes_for_target = conf.class_names for i in range(len(pc_classes)): pc_class_name = pc_classes[i] if pc_class_name not in classes_for_attack: continue save_dir = create_dir(osp.join(output_path, pc_class_name))
def main(): args, params = parse_args() conf = get_conf(params) print(conf) if args.tiny: train_dir = './s3dis/Area_4/*/Annotations/{}_*.txt' else: train_dir = './s3dis/Area_[1-5]/*/Annotations/{}_*.txt' test_dir = './s3dis/Area_6/*/Annotations/{}_*.txt' reset_tf_graph() ae = PointNetAutoEncoder(conf.experiment_name, conf) buf_size = 1 # Make 'training_stats' file to flush each output line regarding training. fout = open(osp.join(conf.train_dir, 'train_stats.txt'), 'a', buf_size) all_pc_data = load_all_point_clouds_under_folder( train_dir, params['class_name'], n_points=conf.n_input[0], with_color=conf.input_color, n_threads=20, verbose=True) print('Start training') train_stats = ae.train(all_pc_data, conf, log_file=fout) fout.close() print('Finish training') if visualize: print('Start visualizing') conf.z_rotate = False conf.gauss_augment = None ckpt_path = os.path.join('./data/', params['experiment_name'], params['class_name']) epoch = conf.training_epochs reset_tf_graph() ae = PointNetAutoEncoder(conf.experiment_name, conf) ae.restore_model(ckpt_path, epoch, verbose=True) all_pc_data = load_all_point_clouds_under_folder( test_dir, params['class_name'], n_points=conf.n_input[0], with_color=conf.input_color, n_threads=20, verbose=True) all_pc_data.shuffle_data() feed_pc, feed_model_names, _ = all_pc_data.next_batch(10) feed_pc_v, feed_pc_v_org = np.split( np.array([get_visible_points(x, org=True) for x in feed_pc]), 2, axis=1) # [normalized_pcs, original_pcs] feed_pc_v = np.array([x[0] for x in feed_pc_v]) feed_pc_v_org = np.array([x[0] for x in feed_pc_v_org]) ae_reconstructions, v_reconstructions, _ = ae.reconstruct( [feed_pc, feed_pc_v], compute_loss=False) visualize(params['experiment_name'], params['class_name'], feed_pc[:, :, :3], ae_reconstructions, feed_pc_v_org[:, :, :3], v_reconstructions, 3) print('Finish visualize')
def main(): params = parse_args() conf = get_conf(params) conf.gauss_augment = False conf.z_rotate = False ckpt_path = os.path.join('./data/', params['experiment_name'], params['class_name']) epoch = conf.training_epochs reset_tf_graph() ae = PointNetAutoEncoder(conf.experiment_name, conf) ae.restore_model(ckpt_path, epoch, verbose=True) test_dir = './s3dis/Area_6/*/Annotations/{}_*.txt' all_pc_data = load_all_point_clouds_under_folder( test_dir, params['class_name'], n_points=conf.n_input[0], with_color=conf.input_color, n_threads=20, verbose=True) ae_recon, tl_recon, data_loss, labels, gt, gt_tl = ae.evaluate( all_pc_data, conf) # gt_tl is not normalized to compare with gt if conf.input_color: gt = gt[:, :, :3] ae_loss = conf.loss # Which distance to use for the matchings. assert ae_loss in ['emd', 'chamfer'] if ae_loss == 'emd': use_EMD = True else: use_EMD = False # Will use Chamfer instead. batch_size = 100 # Find appropriate number that fits in GPU. normalize = True # Matched distances are divided by the number of points of thepoint-clouds. ae_mmd, ae_matched_dists = minimum_mathing_distance(ae_recon, gt, batch_size, normalize=normalize, use_EMD=use_EMD) tl_mmd, tl_matched_dists = minimum_mathing_distance(tl_recon, gt, batch_size, normalize=normalize, use_EMD=use_EMD) ae_cov, ae_matched_ids = coverage(ae_recon, gt, batch_size, normalize=normalize, use_EMD=use_EMD) tl_cov, tl_matched_ids = coverage(tl_recon, gt, batch_size, normalize=normalize, use_EMD=use_EMD) ae_jsd = jsd_between_point_cloud_sets(ae_recon, gt, resolution=28) tl_jsd = jsd_between_point_cloud_sets(tl_recon, gt, resolution=28) result_file = os.path.join( 'result', params['experiment_name'] + '_' + params['class_name'] + '.txt') with open(result_file, 'w') as f: f.write('ae_mmd' + str(ae_mmd) + '\n') f.write('tl_mmd' + str(tl_mmd) + '\n') # f.write('ae_matched_dists' + str(ae_matched_dists) + '\n') f.write('ae_cov' + str(ae_cov) + '\n') f.write('tl_cov' + str(tl_cov) + '\n') # f.write('ae_matched_ids' + str(ae_matched_ids) + '\n') f.write('ae_jsd' + str(ae_jsd) + '\n') f.write('tl_jsd' + str(tl_jsd) + '\n')
def get_chamfer_nn(): start_time = time.time() num_examples_all, num_points, _ = point_clouds.shape chamfer_batch_size = 10 # build chamfer graph reset_tf_graph() source_pc_pl = tf.placeholder(tf.float32, shape=[None, num_points, 3]) target_pc_pl = tf.placeholder(tf.float32, shape=[None, num_points, 3]) dists_s_t, _, dists_t_s, _ = nn_distance(source_pc_pl, target_pc_pl) chamfer_dist = tf.reduce_mean(dists_s_t, axis=1) + tf.reduce_mean( dists_t_s, axis=1) sess = tf.Session('') # compute chamfer distance matrix point_clouds_curr = point_clouds[flags.pc_start_idx:flags.pc_start_idx + flags.pc_batch_size] num_examples_curr = len(point_clouds_curr) chamfer_dist_mat_curr = -1 * np.ones([num_examples_all, num_examples_curr], dtype=np.float32) source_pc = np.tile(np.expand_dims(point_clouds_curr, axis=0), [num_examples_all, 1, 1, 1]) target_pc = np.tile(np.expand_dims(point_clouds, axis=1), [1, num_examples_curr, 1, 1]) for i in range(0, num_examples_all, chamfer_batch_size): for j in range(0, num_examples_curr, chamfer_batch_size): #print('i %d out of %d, j %d out of %d' % # (min(i + chamfer_batch_size, num_examples_all), num_examples_all, min(j + chamfer_batch_size, num_examples_curr), num_examples_curr)) sources = source_pc[i:i + chamfer_batch_size, j:j + chamfer_batch_size] targets = target_pc[i:i + chamfer_batch_size, j:j + chamfer_batch_size] s_batch = np.reshape(sources, [-1, num_points, 3]) t_batch = np.reshape(targets, [-1, num_points, 3]) feed_dict = {source_pc_pl: s_batch, target_pc_pl: t_batch} dist_batch = sess.run(chamfer_dist, feed_dict=feed_dict) dist_batch_reshape = np.reshape(dist_batch, sources.shape[:2]) chamfer_dist_mat_curr[i:i + chamfer_batch_size, j:j + chamfer_batch_size] = dist_batch_reshape assert chamfer_dist_mat_curr.min( ) >= 0, 'the chamfer_dist_mat_curr matrix was not filled correctly' # save current chamfer distance data chamfer_dist_mat_file_name = '_'.join(['chamfer_dist_mat_complete'] + file_name_parts[-3:]) chamfer_dist_mat_file_path = osp.join(data_path, chamfer_dist_mat_file_name) if osp.exists(chamfer_dist_mat_file_path): chamfer_dist_mat = np.load(chamfer_dist_mat_file_path) else: chamfer_dist_mat = -1 * np.ones([num_examples_all, num_examples_all], dtype=np.float32) chamfer_dist_mat[:, flags.pc_start_idx:flags.pc_start_idx + flags.pc_batch_size] = chamfer_dist_mat_curr np.save(chamfer_dist_mat_file_path, chamfer_dist_mat) duration = time.time() - start_time print( 'start index %d end index %d, out of size %d, duration (minutes): %.2f' % (flags.pc_start_idx, min(flags.pc_start_idx + flags.pc_batch_size, num_examples_all), num_examples_all, duration / 60.0)) if chamfer_dist_mat.min() >= 0: # nearest neighbors indices chamfer_nn_idx = sort_dist_mat(chamfer_dist_mat) chamfer_nn_idx_file_name = '_'.join(['chamfer_nn_idx_complete'] + file_name_parts[-3:]) chamfer_nn_idx_file_path = osp.join(data_path, chamfer_nn_idx_file_name) np.save(chamfer_nn_idx_file_path, chamfer_nn_idx)