def struct2ply(filename, struct_data, dist_threshold): branch_data = struct_data['branches'] cyl_data = struct_data['cylinders'] vt = [] ft = [] ids = [] for k, v in branch_data.iteritems(): for vi in v['cylinder_ids']: cyl = cyl_data[vi] if cyl['length'] <= dist_threshold: vertices, facets = cylinder_from_spheres( cyl['p1'], cyl['p2'], cyl['rad'], 10) vt.append(vertices) ft.append(facets) ids.append(np.full(vertices.shape[0], k)) new_vv = np.concatenate(vt) new_ids = np.concatenate(ids) new_ft = np.array(ft[0]) for ff in ft[1:]: tf = np.array(ff) new_ft = np.vstack((new_ft, (tf + np.max(new_ft) + 1))) save_ply(filename, new_vv, new_ft, scalar_array=new_ids) return
def export_ply_monolithic_with_RGB_labels(batched_data, data_num, filepath_pred, batched_labels, setting): assert len(batched_data) == len(data_num) assert batched_data.shape[0:2] == batched_labels.shape # Take the the predefined valid number of points out of the batches and create a contiguous arrays. tmp_data = [] tmp_labels = [] for idx, (data_batch, label_batch) in enumerate(zip(batched_data, batched_labels)): num_points = data_num[idx] tmp_data.append(data_batch[:num_points]) tmp_labels.append(label_batch[:num_points]) data = np.concatenate(tmp_data) labels = np.concatenate(tmp_labels) # Create a lookup table (LUT) for efficient label-to-color mapping cmap = cm.get_cmap('tab20') label_max = setting.num_class cmap_LUT = np.array( [cmap(label / label_max)[:3] for label in range(label_max)]) cmap_LUT[0] = (0.0, 0.0, 0.0) # Create segment colors according to the labels, using the color LUT rgb_labels = cmap_LUT[labels] folder = Path(filepath_pred).parent / 'PLY' filename = Path(filepath_pred).with_suffix('.ply').name filepath_label_ply = folder / filename data_utils.save_ply(data, str(filepath_label_ply), colors=rgb_labels)
def export_ply_monolithic(batched_data, data_num, filepath_pred, batched_labels, setting): assert len(batched_data) == len(data_num) assert batched_data.shape[0:2] == batched_labels.shape # Take the the predefined valid number of points out of the batches and create a contiguous arrays. tmp_data = [] tmp_labels = [] for idx, (data_batch, label_batch) in enumerate(zip(batched_data, batched_labels)): num_points = data_num[idx] tmp_data.append(data_batch[:num_points]) tmp_labels.append(label_batch[:num_points]) data = np.concatenate(tmp_data) labels = np.concatenate(tmp_labels).reshape(-1, 1) folder = Path(filepath_pred).parent / 'PLY' filename = Path(filepath_pred).with_suffix('.ply').name filepath_label_ply = folder / filename data_utils.save_ply(data, str(filepath_label_ply), labels=labels)
def eval_one_epoch(sess, ops, num_votes=1, topk=1): error_cnt = 0 is_training = False total_correct = 0 total_seen = 0 loss_sum = 0 total_seen_class = [0 for _ in range(NUM_CLASSES)] total_correct_class = [0 for _ in range(NUM_CLASSES)] fout = open(os.path.join(DUMP_DIR, 'pred_label.txt'), 'w') # data_utils.shuffle_points(TEST_DATA) # current_data, current_label = data_utils.get_current_data(TEST_DATA, TEST_LABELS, NUM_POINT) # current_data, current_label = data_utils.get_current_data_h5(TEST_DATA, TEST_LABELS, NUM_POINT) if (".h5" in TEST_FILE): current_data, current_label = data_utils.get_current_data_h5( TEST_DATA, TEST_LABELS, NUM_POINT) else: current_data, current_label = data_utils.get_current_data( TEST_DATA, TEST_LABELS, NUM_POINT) current_label = np.squeeze(current_label) num_batches = current_data.shape[0] // BATCH_SIZE for batch_idx in range(num_batches): start_idx = batch_idx * BATCH_SIZE end_idx = (batch_idx + 1) * BATCH_SIZE cur_batch_size = end_idx - start_idx # Aggregating BEG batch_loss_sum = 0 # sum of losses for the batch batch_pred_sum = np.zeros( (cur_batch_size, NUM_CLASSES)) # score for classes batch_pred_classes = np.zeros( (cur_batch_size, NUM_CLASSES)) # 0/1 for classes for vote_idx in range(num_votes): rotated_data = provider.rotate_point_cloud_by_angle( current_data[start_idx:end_idx, :, :], vote_idx / float(num_votes) * np.pi * 2) xforms_np, rotations_np = pf.get_xforms( BATCH_SIZE, rotation_range=rotation_range_val, scaling_range=scaling_range_val, order=setting.rotation_order) # Augment batched point clouds by rotation and jittering feed_dict = { ops['pointclouds_pl']: rotated_data, ops['labels_pl']: current_label[start_idx:end_idx], ops['is_training_pl']: is_training, ops['xforms']: xforms_np, ops['rotations']: rotations_np, ops['jitter_range']: np.array([jitter_val]) } loss_val, pred_val = sess.run([ops['loss'], ops['pred']], feed_dict=feed_dict) pred_val = np.sum(pred_val, axis=1) # pred_val = np.argmax(pred_val, 1) batch_pred_sum += pred_val batch_pred_val = np.argmax(pred_val, 1) for el_idx in range(cur_batch_size): batch_pred_classes[el_idx, batch_pred_val[el_idx]] += 1 batch_loss_sum += (loss_val * cur_batch_size / float(num_votes)) # pred_val_topk = np.argsort(batch_pred_sum, axis=-1)[:,-1*np.array(range(topk))-1] # pred_val = np.argmax(batch_pred_classes, 1) pred_val = np.argmax(batch_pred_sum, 1) # Aggregating END correct = np.sum(pred_val == current_label[start_idx:end_idx]) # correct = np.sum(pred_val_topk[:,0:topk] == label_val) total_correct += correct total_seen += cur_batch_size loss_sum += batch_loss_sum for i in range(start_idx, end_idx): l = current_label[i] total_seen_class[l] += 1 total_correct_class[l] += (pred_val[i - start_idx] == l) fout.write('%s, %s\n' % (SHAPE_NAMES[pred_val[i - start_idx]], SHAPE_NAMES[l])) if pred_val[i - start_idx] != l and FLAGS.visu: # ERROR CASE, DUMP! img_filename = '%d_label_%s_pred_%s.jpg' % ( error_cnt, SHAPE_NAMES[l], SHAPE_NAMES[pred_val[i - start_idx]]) img_filename = os.path.join(DUMP_DIR, img_filename) output_img = pc_util.point_cloud_three_views( np.squeeze(current_data[i, :, :])) scipy.misc.imsave(img_filename, output_img) #save ply ply_filename = '%d_label_%s_pred_%s.ply' % ( error_cnt, SHAPE_NAMES[l], SHAPE_NAMES[pred_val[i - start_idx]]) ply_filename = os.path.join(DUMP_DIR, ply_filename) data_utils.save_ply(np.squeeze(current_data[i, :, :]), ply_filename) error_cnt += 1 log_string('total seen: %d' % (total_seen)) log_string('eval mean loss: %f' % (loss_sum / float(total_seen))) log_string('eval accuracy: %f' % (total_correct / float(total_seen))) log_string('eval avg class acc: %f' % (np.mean( np.array(total_correct_class) / np.array(total_seen_class, dtype=np.float)))) class_accuracies = np.array(total_correct_class) / np.array( total_seen_class, dtype=np.float) for i, name in enumerate(SHAPE_NAMES): log_string('%10s:\t%0.3f' % (name, class_accuracies[i]))
def eval_one_epoch(sess, ops, num_votes=1, topk=1): error_cnt = 0 is_training = False total_correct = 0 total_seen = 0 loss_sum = 0 total_seen_class = [0 for _ in range(NUM_C)] total_correct_class = [0 for _ in range(NUM_C)] fout = open(os.path.join(DUMP_DIR, 'pred_label.txt'), 'w') # data_utils.shuffle_points(TEST_DATA) # current_data, current_label = data_utils.get_current_data(TEST_DATA, TEST_LABELS, NUM_POINT) # current_data, current_label = data_utils.get_current_data_h5(TEST_DATA, TEST_LABELS, NUM_POINT) if (".h5" in TEST_FILE): current_data, current_label = data_utils.get_current_data_h5( TEST_DATA, TEST_LABELS, NUM_POINT) else: current_data, current_label = data_utils.get_current_data( TEST_DATA, TEST_LABELS, NUM_POINT) current_label = np.squeeze(current_label) #################################################### print(current_data.shape) print(current_label.shape) filtered_data = [] filtered_label = [] for i in range(current_label.shape[0]): if (current_label[i] in OBJECTDATASET_TO_MODELNET.keys()): filtered_label.append(current_label[i]) filtered_data.append(current_data[i, :]) filtered_data = np.array(filtered_data) filtered_label = np.array(filtered_label) print(filtered_data.shape) print(filtered_label.shape) current_data = filtered_data current_label = filtered_label ################################################### num_batches = current_data.shape[0] // BATCH_SIZE for batch_idx in range(num_batches): start_idx = batch_idx * BATCH_SIZE end_idx = (batch_idx + 1) * BATCH_SIZE cur_batch_size = end_idx - start_idx # Aggregating BEG batch_loss_sum = 0 # sum of losses for the batch batch_pred_sum = np.zeros((cur_batch_size, 40)) # score for classes batch_pred_classes = np.zeros((cur_batch_size, 40)) # 0/1 for classes for vote_idx in range(num_votes): rotated_data = provider.rotate_point_cloud_by_angle( current_data[start_idx:end_idx, :, :], vote_idx / float(num_votes) * np.pi * 2) feed_dict = { ops['pointclouds_pl']: rotated_data, ops['labels_pl']: current_label[start_idx:end_idx], ops['is_training_pl']: is_training } loss_val, pred_val = sess.run([ops['loss'], ops['pred']], feed_dict=feed_dict) batch_pred_sum += pred_val batch_pred_val = np.argmax(pred_val, 1) for el_idx in range(cur_batch_size): batch_pred_classes[el_idx, batch_pred_val[el_idx]] += 1 batch_loss_sum += (loss_val * cur_batch_size / float(num_votes)) # pred_val_topk = np.argsort(batch_pred_sum, axis=-1)[:,-1*np.array(range(topk))-1] # pred_val = np.argmax(batch_pred_classes, 1) pred_val = np.argmax(batch_pred_sum, 1) # Aggregating END for i in range(start_idx, end_idx): total_seen += 1 if (pred_val[i - start_idx] not in MODELNET_TO_OBJECTDATASET.keys()): continue pred = MODELNET_TO_OBJECTDATASET[pred_val[i - start_idx]] # if (pred_val[i-start_idx] == current_label[i]): if (pred == current_label[i]): total_correct += 1 for i in range(start_idx, end_idx): l = current_label[i] total_seen_class[l] += 1 if pred_val[i - start_idx] not in MODELNET_TO_OBJECTDATASET: pred_label = "NA" else: pred = MODELNET_TO_OBJECTDATASET[pred_val[i - start_idx]] total_correct_class[l] += (pred == l) pred_label = SHAPE_NAMES[pred] # groundtruth_label = SHAPE_NAMES[MODELNET_TO_OBJECTDATASET[l]] groundtruth_label = SHAPE_NAMES[l] fout.write('%s, %s\n' % (pred_label, groundtruth_label)) if pred_val[i - start_idx] != l and FLAGS.visu: # ERROR CASE, DUMP! img_filename = '%d_label_%s_pred_%s.jpg' % ( error_cnt, groundtruth_label, pred_label) img_filename = os.path.join(DUMP_DIR, img_filename) output_img = pc_util.point_cloud_three_views( np.squeeze(current_data[i, :, :])) scipy.misc.imsave(img_filename, output_img) #save ply ply_filename = '%d_label_%s_pred_%s.ply' % ( error_cnt, groundtruth_label, pred_label) data_utils.save_ply(np.squeeze(current_data[i, :, :]), ply_filename) error_cnt += 1 log_string('total seen: %d' % (total_seen)) # log_string('eval mean loss: %f' % (loss_sum / float(total_seen))) log_string('eval accuracy: %f' % (total_correct / float(total_seen))) seen_class_accuracies = [] seen_correct_class = [] for i in range(len(total_seen_class)): if total_seen_class[i] != 0: seen_class_accuracies.append(total_seen_class[i]) seen_correct_class.append(total_correct_class[i]) log_string('eval avg class acc: %f' % (np.mean( np.array(seen_correct_class) / np.array(seen_class_accuracies, dtype=np.float)))) for i, name in enumerate(SHAPE_NAMES): if (total_seen_class[i] == 0): accuracy = -1 else: accuracy = total_correct_class[i] / float(total_seen_class[i]) log_string('%10s:\t%0.3f' % (name, accuracy))
def main(): parser = argparse.ArgumentParser() parser.add_argument('--folder', '-f', help='Path to data folder') parser.add_argument('--save_ply', '-s', help='Convert .pts to .ply', action='store_true') args = parser.parse_args() print(args) batch_size = 2048 folder_cifar10 = args.folder if args.folder else '../../data/cifar10/cifar-10-batches-py' folder_pts = os.path.join(os.path.dirname(folder_cifar10), 'pts') train_test_files = [('train', ['data_batch_%d' % (idx + 1) for idx in range(5)]), ('test', ['test_batch'])] data = np.zeros((batch_size, 1024, 6)) label = np.zeros((batch_size), dtype=np.int32) for tag, filelist in train_test_files: data_list = [] labels_list = [] for filename in filelist: batch = unpickle(os.path.join(folder_cifar10, filename)) data_list.append(np.reshape(batch[b'data'], (10000, 3, 32, 32))) labels_list.append(batch[b'labels']) images = np.concatenate(data_list, axis=0) labels = np.concatenate(labels_list, axis=0) idx_h5 = 0 filename_filelist_h5 = os.path.join(os.path.dirname(folder_cifar10), '%s_files.txt' % tag) with open(filename_filelist_h5, 'w') as filelist_h5: for idx_img, image in enumerate(images): points = [] pixels = [] for x in range(32): for z in range(32): points.append((x, random.random() * 1e-6, z)) pixels.append((image[0, x, z], image[1, x, z], image[2, x, z])) points_array = np.array(points) pixels_array = (np.array(pixels).astype(np.float32) / 255)-0.5 points_min = np.amin(points_array, axis=0) points_max = np.amax(points_array, axis=0) points_center = (points_min + points_max) / 2 scale = np.amax(points_max - points_min) / 2 points_array = (points_array - points_center) * (0.8 / scale) if args.save_ply: filename_pts = os.path.join(folder_pts, tag, '{:06d}.ply'.format(idx_img)) data_utils.save_ply(points_array, filename_pts, colors=pixels_array+0.5) idx_in_batch = idx_img % batch_size data[idx_in_batch, ...] = np.concatenate((points_array, pixels_array), axis=-1) label[idx_in_batch] = labels[idx_img] if ((idx_img + 1) % batch_size == 0) or idx_img == len(images) - 1: item_num = idx_in_batch + 1 filename_h5 = os.path.join(os.path.dirname(folder_cifar10), '%s_%d.h5' % (tag, idx_h5)) print('{}-Saving {}...'.format(datetime.now(), filename_h5)) filelist_h5.write('./%s_%d.h5\n' % (tag, idx_h5)) file = h5py.File(filename_h5, 'w') file.create_dataset('data', data=data[0:item_num, ...]) file.create_dataset('label', data=label[0:item_num, ...]) file.close() idx_h5 = idx_h5 + 1
def main(): parser = argparse.ArgumentParser() parser.add_argument('--folder', '-f', help='Path to data folder') parser.add_argument('--point_num', '-p', help='Point number for each sample', type=int, default=1024) parser.add_argument('--save_ply', '-s', help='Convert .pts to .ply', action='store_true') parser.add_argument('--augment', '-a', help='Data augmentation', action='store_true') args = parser.parse_args() print(args) batch_size = 2048 fold_num = 3 tag_aug = '_ag' if args.augment else '' folder_svg = args.folder if args.folder else '../../data/tu_berlin/svg' root_folder = os.path.dirname(folder_svg) folder_pts = os.path.join(root_folder, 'pts' + tag_aug) filelist_svg = [line.strip() for line in open(os.path.join(folder_svg, 'filelist.txt'))] category_label = dict() with open(os.path.join(os.path.dirname(folder_svg), 'categories.txt'), 'w') as file_categories: for filename in filelist_svg: category = os.path.split(filename)[0] if category not in category_label: file_categories.write('%s %d\n' % (category, len(category_label))) category_label[category] = len(category_label) filelist_svg_failed = [] data = np.zeros((batch_size, args.point_num, 6)) label = np.zeros((batch_size), dtype=np.int32) for idx_fold in range(fold_num): filelist_svg_fold = [filename for i, filename in enumerate(filelist_svg) if i % fold_num == idx_fold] random.seed(idx_fold) random.shuffle(filelist_svg_fold) filename_filelist_svg_fold = os.path.join(root_folder, 'filelist_fold_%d.txt' % (idx_fold)) with open(filename_filelist_svg_fold, 'w') as filelist_svg_fold_file: for filename in filelist_svg_fold: filelist_svg_fold_file.write('%s\n' % (filename)) idx_h5 = 0 idx = 0 filename_filelist_h5 = os.path.join(root_folder, 'fold_%d_files%s.txt' % (idx_fold, tag_aug)) with open(filename_filelist_h5, 'w') as filelist_h5_file: for idx_file, filename in enumerate(filelist_svg_fold): filename_svg = os.path.join(folder_svg, filename) try: paths, attributes = svg2paths(filename_svg) except: filelist_svg_failed.append(filename_svg) print('{}-Failed to parse {}!'.format(datetime.now(), filename_svg)) continue points_array = np.zeros(shape=(args.point_num, 3), dtype=np.float32) normals_array = np.zeros(shape=(args.point_num, 3), dtype=np.float32) path = Path() for p in paths: p_non_empty = Path() for segment in p: if segment.length() > 0: p_non_empty.append(segment) if len(p_non_empty) != 0: path.append(p_non_empty) path_list = [] if args.augment: for removal_idx in range(6): path_with_removal = Path() for p in path[:math.ceil((0.4 + removal_idx * 0.1) * len(paths))]: path_with_removal.append(p) path_list.append(path_with_removal) path_list = path_list + augment(path, 6) else: path_list.append(path) for path_idx, path in enumerate(path_list): for sample_idx in range(args.point_num): sample_idx_float = (sample_idx + random.random()) / (args.point_num - 1) while True: try: point = path.point(sample_idx_float) normal = path.normal(sample_idx_float) break except: sample_idx_float = random.random() continue points_array[sample_idx] = (point.real, sample_idx_float, point.imag) normals_array[sample_idx] = (normal.real, random.random() * 1e-6, normal.imag) points_min = np.amin(points_array, axis=0) points_max = np.amax(points_array, axis=0) points_center = (points_min + points_max) / 2 scale = np.amax(points_max - points_min) / 2 points_array = (points_array - points_center) * (0.8 / scale, 0.4, 0.8 / scale) if args.save_ply: tag_aug_idx = tag_aug + '_' + str(path_idx) if args.augment else tag_aug filename_pts = os.path.join(folder_pts, filename[:-4] + tag_aug_idx + '.ply') data_utils.save_ply(points_array, filename_pts, normals=normals_array) idx_in_batch = idx % batch_size data[idx_in_batch, ...] = np.concatenate((points_array, normals_array), axis=-1).astype(np.float32) label[idx_in_batch] = category_label[os.path.split(filename)[0]] if ((idx + 1) % batch_size == 0) \ or (idx_file == len(filelist_svg_fold) - 1 and path_idx == len(path_list) - 1): item_num = idx_in_batch + 1 filename_h5 = 'fold_%d_%d%s.h5' % (idx_fold, idx_h5, tag_aug) print('{}-Saving {}...'.format(datetime.now(), os.path.join(root_folder, filename_h5))) filelist_h5_file.write('./%s\n' % (filename_h5)) file = h5py.File(os.path.join(root_folder, filename_h5), 'w') file.create_dataset('data', data=data[0:item_num, ...]) file.create_dataset('label', data=label[0:item_num, ...]) file.close() idx_h5 = idx_h5 + 1 idx = idx + 1 if len(filelist_svg_failed) != 0: print('{}-Failed to parse {} sketches!'.format(datetime.now(), len(filelist_svg_failed)))
def main(): parser = argparse.ArgumentParser() parser.add_argument('--folder', '-f', help='Path to data folder') parser.add_argument('--point_num', '-p', help='Point number for each sample', type=int, default=256) parser.add_argument('--save_ply', '-s', help='Convert .pts to .ply', action='store_true') args = parser.parse_args() print(args) batch_size = 2048 folder_mnist = args.folder if args.folder else '../../data/mnist/zips' folder_pts = os.path.join(os.path.dirname(folder_mnist), 'pts') mnist_data = MNIST(folder_mnist) mnist_train_test = [(mnist_data.load_training(), 'train'), (mnist_data.load_testing(), 'test')] data = np.zeros((batch_size, args.point_num, 4)) label = np.zeros((batch_size), dtype=np.int32) for ((images, labels), tag) in mnist_train_test: idx_h5 = 0 filename_filelist_h5 = os.path.join(os.path.dirname(folder_mnist), '%s_files.txt' % tag) point_num_total = 0 with open(filename_filelist_h5, 'w') as filelist_h5: for idx_img, image in enumerate(images): points = [] pixels = [] for idx_pixel, pixel in enumerate(image): if pixel == 0: continue x = idx_pixel // 28 z = idx_pixel % 28 points.append((x, random.random() * 1e-6, z)) pixels.append(pixel) point_num_total = point_num_total + len(points) pixels_sum = sum(pixels) probs = [pixel / pixels_sum for pixel in pixels] indices = np.random.choice(list(range(len(points))), size=args.point_num, replace=(len(points) < args.point_num), p=probs) points_array = np.array(points)[indices] pixels_array_1d = (np.array(pixels)[indices].astype(np.float32) / 255) - 0.5 pixels_array = np.expand_dims(pixels_array_1d, axis=-1) points_min = np.amin(points_array, axis=0) points_max = np.amax(points_array, axis=0) points_center = (points_min + points_max) / 2 scale = np.amax(points_max - points_min) / 2 points_array = (points_array - points_center) * (0.8 / scale) if args.save_ply: filename_pts = os.path.join(folder_pts, tag, '{:06d}.ply'.format(idx_img)) data_utils.save_ply(points_array, filename_pts, colors=np.tile(pixels_array, (1, 3)) + 0.5) idx_in_batch = idx_img % batch_size data[idx_in_batch, ...] = np.concatenate((points_array, pixels_array), axis=-1) label[idx_in_batch] = labels[idx_img] if ((idx_img + 1) % batch_size == 0) or idx_img == len(images) - 1: item_num = idx_in_batch + 1 filename_h5 = os.path.join(os.path.dirname(folder_mnist), '%s_%d.h5' % (tag, idx_h5)) print('{}-Saving {}...'.format(datetime.now(), filename_h5)) filelist_h5.write('./%s_%d.h5\n' % (tag, idx_h5)) file = h5py.File(filename_h5, 'w') file.create_dataset('data', data=data[0:item_num, ...]) file.create_dataset('label', data=label[0:item_num, ...]) file.close() idx_h5 = idx_h5 + 1 print('Average point number in each sample is : %f!' % (point_num_total / len(images)))
def eval_one_epoch(sess, ops, gmm, num_votes): """ ops: dict mapping from string to tf ops """ error_cnt = 0 is_training = False total_correct = 0 total_seen = 0 loss_sum = 0 total_seen_class = [0 for _ in range(NUM_CLASSES)] total_correct_class = [0 for _ in range(NUM_CLASSES)] fout = open(os.path.join(DUMP_DIR, 'pred_label.txt'), 'w') if (".h5" in TEST_FILE): current_data, current_label = data_utils.get_current_data_h5( TEST_DATA, TEST_LABELS, NUM_POINT) else: current_data, current_label = data_utils.get_current_data( TEST_DATA, TEST_LABELS, NUM_POINT) current_label = np.squeeze(current_label) num_batches = current_data.shape[0] // BATCH_SIZE for batch_idx in range(num_batches): start_idx = batch_idx * BATCH_SIZE end_idx = (batch_idx + 1) * BATCH_SIZE cur_batch_size = end_idx - start_idx # Aggregating BEG batch_loss_sum = 0 # sum of losses for the batch batch_pred_sum = np.zeros( (cur_batch_size, NUM_CLASSES)) # score for classes batch_pred_classes = np.zeros( (cur_batch_size, NUM_CLASSES)) # 0/1 for classes for vote_idx in range(num_votes): rotated_data = provider.rotate_point_cloud_by_angle( current_data[start_idx:end_idx, :, :], vote_idx / float(num_votes) * np.pi * 2) feed_dict = { ops['pointclouds_pl']: rotated_data, ops['labels_pl']: current_label[start_idx:end_idx], ops['w_pl']: gmm.weights_, ops['mu_pl']: gmm.means_, ops['sigma_pl']: np.sqrt(gmm.covariances_), ops['is_training_pl']: is_training } loss_val, pred_val = sess.run([ops['loss'], ops['pred']], feed_dict=feed_dict) batch_pred_sum += pred_val batch_pred_val = np.argmax(pred_val, 1) for el_idx in range(cur_batch_size): batch_pred_classes[el_idx, batch_pred_val[el_idx]] += 1 batch_loss_sum += (loss_val * cur_batch_size / float(num_votes)) pred_val = np.argmax(batch_pred_sum, 1) # Aggregating END correct = np.sum(pred_val == current_label[start_idx:end_idx]) # correct = np.sum(pred_val_topk[:,0:topk] == label_val) total_correct += correct total_seen += cur_batch_size loss_sum += batch_loss_sum for i in range(start_idx, end_idx): l = current_label[i] total_seen_class[l] += 1 total_correct_class[l] += (pred_val[i - start_idx] == l) fout.write('%s, %s\n' % (SHAPE_NAMES[pred_val[i - start_idx]], SHAPE_NAMES[l])) if pred_val[i - start_idx] != l and FLAGS.visu: # ERROR CASE, DUMP! img_filename = '%d_label_%s_pred_%s.jpg' % ( error_cnt, SHAPE_NAMES[l], SHAPE_NAMES[pred_val[i - start_idx]]) img_filename = os.path.join(DUMP_DIR, img_filename) output_img = pc_util.point_cloud_three_views( np.squeeze(current_data[i, :, :])) scipy.misc.imsave(img_filename, output_img) #save ply ply_filename = '%d_label_%s_pred_%s.ply' % ( error_cnt, SHAPE_NAMES[l], SHAPE_NAMES[pred_val[i - start_idx]]) data_utils.save_ply(np.squeeze(current_data[i, :, :]), ply_filename) error_cnt += 1 log_string('total seen: %d' % (total_seen)) log_string('eval mean loss: %f' % (loss_sum / float(total_seen))) log_string('eval accuracy: %f' % (total_correct / float(total_seen))) log_string('eval avg class acc: %f' % (np.mean( np.array(total_correct_class) / np.array(total_seen_class, dtype=np.float)))) class_accuracies = np.array(total_correct_class) / np.array( total_seen_class, dtype=np.float) for i, name in enumerate(SHAPE_NAMES): log_string('%10s:\t%0.3f' % (name, class_accuracies[i]))
import pickle with open( os.path.join(os.path.dirname(args.load_ckpt), os.pardir, 'data.pickle'), 'rb') as f: data = pickle.load(f) with open( os.path.join(os.path.dirname(args.load_ckpt), os.pardir, 'labels_pred.pickle'), 'rb') as f: labels_pred = pickle.load(f) print('{}-Saving ply of {}...'.format(datetime.now(), args.file_name)) scene_name = os.path.splitext(os.path.basename( args.file_name))[0] # Get filename without extension # Create subfolder predictions_folder = os.path.join(os.path.dirname(args.load_ckpt), os.pardir, 'predictions', 'test') if not os.path.exists(os.path.dirname(predictions_folder)): os.makedirs(predictions_folder) # Create point colors according to labels cmap = cm.get_cmap('tab20') label_max = setting.num_class cmap_LUT = [cmap(label / label_max)[:3] for label in range(label_max)] cmap_LUT[0] = (0.0, 0.0, 0.0) colors = np.array([cmap_LUT[label] for label in labels_pred.ravel()]) filename = os.path.join(predictions_folder, scene_name + '_nudelholz.ply') data_utils.save_ply(data.reshape(-1, 3), filename, colors) print('{}-Done!'.format(datetime.now()))