def setUp(self): self.n_samples = 10 self.SO3_GROUP = SpecialOrthogonalGroup(n=3) self.SE3_GROUP = SpecialEuclideanGroup(n=3) self.S1 = Hypersphere(dimension=1) self.S2 = Hypersphere(dimension=2) self.H2 = HyperbolicSpace(dimension=2) plt.figure()
class TestVisualizationMethods(unittest.TestCase): _multiprocess_can_split_ = True def setUp(self): self.n_samples = 10 self.SO3_GROUP = SpecialOrthogonalGroup(n=3) self.SE3_GROUP = SpecialEuclideanGroup(n=3) self.S2 = Hypersphere(dimension=2) self.H2 = HyperbolicSpace(dimension=2) def test_plot_points_so3(self): points = self.SO3_GROUP.random_uniform(self.n_samples) visualization.plot(points, space='SO3_GROUP') def test_plot_points_se3(self): points = self.SE3_GROUP.random_uniform(self.n_samples) visualization.plot(points, space='SE3_GROUP') def test_plot_points_s2(self): points = self.S2.random_uniform(self.n_samples) visualization.plot(points, space='S2') def test_plot_points_h2_poincare_disk(self): points = self.H2.random_uniform(self.n_samples) visualization.plot(points, space='H2_poincare_disk') def test_plot_points_h2_poincare_half_plane(self): points = self.H2.random_uniform(self.n_samples) visualization.plot(points, space='H2_poincare_half_plane') def test_plot_points_h2_klein_disk(self): points = self.H2.random_uniform(self.n_samples) visualization.plot(points, space='H2_klein_disk')
def setUp(self): gs.random.seed(1234) n = 3 group = SpecialEuclideanGroup(n=n) # Diagonal left and right invariant metrics diag_mat_at_identity = gs.zeros([group.dimension, group.dimension]) diag_mat_at_identity[0:3, 0:3] = 1 * gs.eye(3) diag_mat_at_identity[3:6, 3:6] = 1 * gs.eye(3) left_diag_metric = InvariantMetric( group=group, inner_product_mat_at_identity=diag_mat_at_identity, left_or_right='left') right_diag_metric = InvariantMetric( group=group, inner_product_mat_at_identity=diag_mat_at_identity, left_or_right='right') # General left and right invariant metrics # TODO(xxx): replace by general SPD matrix sym_mat_at_identity = gs.eye(group.dimension) left_metric = InvariantMetric( group=group, inner_product_mat_at_identity=sym_mat_at_identity, left_or_right='left') right_metric = InvariantMetric( group=group, inner_product_mat_at_identity=sym_mat_at_identity, left_or_right='right') metrics = { 'left_diag': left_diag_metric, 'right_diag_metric': right_diag_metric, 'left': left_metric, 'right': right_metric } # General case for the point point_1 = gs.array([-0.2, 0.9, 0.5, 5., 5., 5.]) point_2 = gs.array([0., 2., -0.1, 30., 400., 2.]) # Edge case for the point, angle < epsilon, point_small = gs.array([-1e-7, 0., -7 * 1e-8, 6., 5., 9.]) self.group = group self.metrics = metrics self.left_diag_metric = left_diag_metric self.right_diag_metric = right_diag_metric self.left_metric = left_metric self.right_metric = right_metric self.point_1 = point_1 self.point_2 = point_2 self.point_small = point_small
def setUp(self): warnings.simplefilter('ignore', category=ImportWarning) gs.random.seed(1234) n = 3 group = SpecialEuclideanGroup(n=n) # Diagonal left and right invariant metrics diag_mat_at_identity = gs.eye(group.dimension) left_diag_metric = InvariantMetric( group=group, inner_product_mat_at_identity=diag_mat_at_identity, left_or_right='left') right_diag_metric = InvariantMetric( group=group, inner_product_mat_at_identity=diag_mat_at_identity, left_or_right='right') # General left and right invariant metrics # TODO(nina): Replace the matrix below by a general SPD matrix. sym_mat_at_identity = gs.eye(group.dimension) left_metric = InvariantMetric( group=group, inner_product_mat_at_identity=sym_mat_at_identity, left_or_right='left') right_metric = InvariantMetric( group=group, inner_product_mat_at_identity=sym_mat_at_identity, left_or_right='right') metrics = { 'left_diag': left_diag_metric, 'right_diag_metric': right_diag_metric, 'left': left_metric, 'right': right_metric } # General case for the point point_1 = gs.array([[-0.2, 0.9, 0.5, 5., 5., 5.]]) point_2 = gs.array([[0., 2., -0.1, 30., 400., 2.]]) # Edge case for the point, angle < epsilon, point_small = gs.array([[-1e-7, 0., -7 * 1e-8, 6., 5., 9.]]) self.group = group self.metrics = metrics self.left_diag_metric = left_diag_metric self.right_diag_metric = right_diag_metric self.left_metric = left_metric self.right_metric = right_metric self.point_1 = point_1 self.point_2 = point_2 self.point_small = point_small
def __init__(self, weight): assert weight.shape != SE3_DIM, 'Weight vector must be of shape [6]' self.weight = weight self.SE3_GROUP = SpecialEuclideanGroup(N) self.metric = InvariantMetric( group=self.SE3_GROUP, inner_product_mat_at_identity=np.eye(SE3_DIM) * self.weight, left_or_right='left')
def define_loss(self): with tf.name_scope('Loss'): print("Loss ===============================================Start") with tf.variable_scope('Resize_for_VAE'): y_hat_dm_resize = tf.image.resize_bilinear( self.y_hat_dm[:, :, :, 3:5], size=(self.hyper_params.vae_h, self.hyper_params.vae_w), align_corners=False, half_pixel_centers=False, name='y_hat_dm_resize') y_cam_resize = tf.image.resize_bilinear( self.x_cam_train, size=(self.hyper_params.vae_h, self.hyper_params.vae_w), align_corners=False, half_pixel_centers=False, name='y_cam_resize') vae_inputs = tf.concat([y_cam_resize, y_hat_dm_resize], -1, name='vae_input') print(" [vae inputs] {}".format(vae_inputs)) self.tolerance_regularization, _ = tolerance_regularizer( inputs=vae_inputs, vae_latent_dim=self.hyper_params.vae_latent_dim, is_training=self.is_training) self.frozen_vars = tf.get_collection( tf.GraphKeys.TRAINABLE_VARIABLES, 'Tolerance_Regularization') with tf.variable_scope('SE3_Loss'): print( " [SE3 Loss] ##################################" ) # TODO: Hard coded batch number!!! BAD!!! se3_pred = tf.reshape(self.y_hat_se3param, (self.batch_size, 6)) se3_true = tf.reshape(self.y_se3param, (self.batch_size, 6)) print(" [y_hat_se3param] {}".format( self.y_hat_se3param)) print(" [y_se3param ] {}".format( self.y_se3param)) print(" [se3_pred ] {}".format(se3_pred)) print(" [se3_true ] {}".format(se3_true)) # Consider implementing a native one instead of using 3rd party lib SE3_GROUP = SpecialEuclideanGroup(3, epsilon=np.finfo( np.float32).eps) metric = SE3_GROUP.left_canonical_metric self.loss_geodesic = tf.reduce_mean( lie_group.loss(se3_pred, se3_true, SE3_GROUP, metric)) with tf.name_scope('Loss'): self.loss = tf.identity(self.loss_geodesic + self.hyper_params.regularizer_factor * self.tolerance_regularization, name='loss')
def test_se3(): # rpy <--> xyz convention # http://web.mit.edu/2.05/www/Handout/HO2.PDF # examples: # [r, p, y, x, y, z] SE3_GROUP = SpecialEuclideanGroup(3, epsilon=np.finfo(np.float32).eps) metric = SE3_GROUP.left_canonical_metric identity = tf.constant(np.array([0., 0, 0, 0, 0, 0], dtype=np.float32), name='identity') r90 = tf.constant(np.array([1.5707963, 0., 0, 0, 0, 0], dtype=np.float32), name='r90') x10 =tf.constant(np.array([0., 0, 0, 10, 0, 0], dtype=np.float32), name='x10') r90_x10 = tf.constant(np.array([1.5707963, 0, 0, 10, 0, 0], dtype=np.float32), name='r90_x10') test_se3s = tf.constant(np.array([[1.5707963, 0, 0, 0, 0, 0], [0, 0, 0, 10, 0, 0], [1.5707963, 0, 0, 10, 0, 0]], dtype=np.float32), name='test_se3s') test_identities = tf.constant(np.array([[0., 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]], dtype=np.float32), name='test_se3s') dist_r90_to_identity = lie_group.loss(r90, identity, SE3_GROUP, metric) dist_x10_to_identity = lie_group.loss(x10, identity, SE3_GROUP, metric) dist_x10_to_r90 = lie_group.loss(x10, r90, SE3_GROUP, metric) psudo_riemannian_log_dist_x10_to_r90 = dist_r90_to_identity + dist_x10_to_identity # Decoupled dist_r90_to_x10 = lie_group.loss(r90, x10, SE3_GROUP, metric) dist_r90_x10_to_identity = lie_group.loss(r90_x10, identity, SE3_GROUP, metric) dist_batch = lie_group.loss(test_se3s, test_identities, SE3_GROUP, metric) mean_dist_batch = tf.reduce_mean(dist_batch) test_dict = { 'dist_r90_to_identity': dist_r90_to_identity, 'dist_x10_to_identity': dist_x10_to_identity, 'dist_x10_to_r90': dist_x10_to_r90, 'psudo_riemannian_log_dist_x10_to_r90': psudo_riemannian_log_dist_x10_to_r90, 'dist_r90_to_x10': dist_r90_to_x10, 'dist_r90_x10_to_identity': dist_r90_x10_to_identity, 'dist_batch': dist_batch, 'mean_dist_batch': mean_dist_batch } _compare_dict = get_compares_dict() for _k, _v in _compare_dict.items(): test_dict['dist_{}_to_identity'.format(_k)] = lie_group.loss(tf.constant(_v['se3'], name=_k), identity, SE3_GROUP, metric) with tf.Session() as sess: for _k, _v in test_dict.items(): print("{} : {}".format(_k, sess.run(_v))) """
"""Unit tests for visualization module.""" import matplotlib matplotlib.use('Agg') # NOQA import unittest import geomstats.visualization as visualization from geomstats.hypersphere import Hypersphere from geomstats.special_euclidean_group import SpecialEuclideanGroup from geomstats.special_orthogonal_group import SpecialOrthogonalGroup SO3_GROUP = SpecialOrthogonalGroup(n=3) SE3_GROUP = SpecialEuclideanGroup(n=3) S2 = Hypersphere(dimension=2) # TODO(nina): add tests for examples class TestVisualizationMethods(unittest.TestCase): _multiprocess_can_split_ = True def setUp(self): self.n_samples = 10 def test_plot_points_so3(self): points = SO3_GROUP.random_uniform(self.n_samples) visualization.plot(points, space='SO3_GROUP') def test_plot_points_se3(self): points = SE3_GROUP.random_uniform(self.n_samples) visualization.plot(points, space='SE3_GROUP')
""" Predict on SE3: losses. """ import numpy as np import geomstats.lie_group as lie_group from geomstats.special_euclidean_group import SpecialEuclideanGroup from geomstats.special_orthogonal_group import SpecialOrthogonalGroup SE3 = SpecialEuclideanGroup(n=3) SO3 = SpecialOrthogonalGroup(n=3) def loss(y_pred, y_true, metric=SE3.left_canonical_metric, representation='vector'): """ Loss function given by a riemannian metric on a Lie group, by default the left-invariant canonical metric. """ if y_pred.ndim == 1: y_pred = np.expand_dims(y_pred, axis=0) if y_true.ndim == 1: y_true = np.expand_dims(y_true, axis=0) if representation == 'quaternion': y_pred_rot_vec = SO3.rotation_vector_from_quaternion(y_pred[:, :4]) y_pred = np.hstack([y_pred_rot_vec, y_pred[:, 4:]]) y_true_rot_vec = SO3.rotation_vector_from_quaternion(y_true[:, :4]) y_true = np.hstack([y_true_rot_vec, y_true[:, 4:]])
def main(args): SE3_GROUP = SpecialEuclideanGroup(3) metric = SE3_GROUP.left_canonical_metric reader_train = PoseNetReader([FLAGS.dataset]) # Get Input Tensors image, y_true = reader_train.read_and_decode() # Construct model and encapsulating all ops into scopes, making # Tensorboard's Graph visualization more convenient print('Making Model') with tf.name_scope('Model'): py_x, _ = inception.inception_v1(tf.cast(image, tf.float32), num_classes=6, is_training=False) # tanh(pred_angle) required to prevent infinite spins on rotation axis y_pred = tf.concat((tf.nn.tanh(py_x[:, :3]), py_x[:, 3:]), axis=1) loss = tf.reduce_mean(lie_group.loss(y_pred, y_true, SE3_GROUP, metric)) print('Initializing Variables...') init_op = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer()) # Main Testing Routine with tf.Session() as sess: # Run the initializer sess.run(init_op) # Start Queue Threads coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(coord=coord) # Load saved weights print('Loading Trained Weights') saver = tf.train.Saver() latest_checkpoint = tf.train.latest_checkpoint(FLAGS.model_dir) saver.restore(sess, latest_checkpoint) i = 0 # Inference cycle try: while True: _y_pred, _y_true, _loss = sess.run([y_pred, y_true, loss]) print('Iteration:', i, 'loss:', _loss) print('_y_pred:', _y_pred) print('_y_true:', _y_true) print('\n') i = i + 1 except tf.errors.OutOfRangeError: print('End of Testing Data') except KeyboardInterrupt: print('KeyboardInterrupt!') finally: print('Stopping Threads') coord.request_stop() coord.join(threads)
def main(argv): # TF Record datafiles = FLAGS.data_dir + '/test/' + FLAGS.subject_id + '.tfrecord' dataset = tf.data.TFRecordDataset(datafiles) dataset = dataset.map(_parse_function_ifind) # dataset = dataset.repeat() # dataset = dataset.shuffle(FLAGS.queue_buffer) dataset = dataset.batch(1) image, vec, qt, AP1, AP2, AP3 = dataset.make_one_shot_iterator().get_next() # Nifti Volume subject_path = FLAGS.scan_dir + '/test/' + FLAGS.subject_id + '.nii.gz' fixed_image_sitk_tmp = sitk.ReadImage(subject_path, sitk.sitkFloat32) fixed_image_sitk = sitk.GetImageFromArray( sitk.GetArrayFromImage(fixed_image_sitk_tmp)) fixed_image_sitk = sitk.RescaleIntensity(fixed_image_sitk, 0, 1) * 255. # Network Definition image_resized = tf.image.resize_images(image, size=[224, 224]) # Measurements cc = [] mse = [] psnr = [] ssim = [] if FLAGS.loss == 'PoseNet': y_pred, _ = inception.inception_v3(image_resized, num_classes=7, is_training=False) quaternion_pred, translation_pred = tf.split(y_pred, [4, 3], axis=1) sess = tf.Session() ckpt_file = tf.train.latest_checkpoint(FLAGS.model_dir) tf.train.Saver().restore(sess, ckpt_file) print('restoring parameters from', ckpt_file) SO3_GROUP = SpecialOrthogonalGroup(3) for i in tqdm.tqdm(range(FLAGS.n_iter)): _image, _quaternion_true, _translation_true, _quaternion_pred, _translation_pred = \ sess.run([image, qt, AP2, quaternion_pred, translation_pred]) rx = SO3_GROUP.matrix_from_quaternion(_quaternion_pred)[0] tx = _translation_pred[0] * 60. image_true = np.squeeze(_image) image_pred = resample_sitk(fixed_image_sitk, rx, tx) imageio.imsave('imgdump/image_{}_true.png'.format(i), np.uint8(_image[0, ...])) imageio.imsave('imgdump/image_{}_pred.png'.format(i), np.uint8(image_pred)) cc.append(calc_correlation(image_pred, image_true)) mse.append(calc_mse(image_pred, image_true)) psnr.append(calc_psnr(image_pred, image_true)) ssim.append(calc_ssim(image_pred, image_true)) elif FLAGS.loss == 'AP': y_pred, _ = inception.inception_v3(image_resized, num_classes=9, is_training=False) AP1_pred, AP2_pred, AP3_pred = tf.split(y_pred, 3, axis=1) sess = tf.Session() ckpt_file = tf.train.latest_checkpoint(FLAGS.model_dir) tf.train.Saver().restore(sess, ckpt_file) print('restoring parameters from', ckpt_file) for i in tqdm.tqdm(range(FLAGS.n_iter)): _image, _AP1, _AP2, _AP3, _AP1_pred, _AP2_pred, _AP3_pred = \ sess.run([image, AP1, AP2, AP3, AP1_pred, AP2_pred, AP3_pred]) dist_ap1 = np.linalg.norm(_AP1 - _AP1_pred) dist_ap2 = np.linalg.norm(_AP2 - _AP2_pred) dist_ap3 = np.linalg.norm(_AP3 - _AP3_pred) rx = matrix_from_anchor_points(_AP1_pred[0], _AP2_pred[0], _AP3_pred[0]) tx = _AP2_pred[0] * 60. image_true = np.squeeze(_image) image_pred = resample_sitk(fixed_image_sitk, rx, tx) imageio.imsave('imgdump/image_{}_true.png'.format(i), np.uint8(_image[0, ...])) imageio.imsave('imgdump/image_{}_pred.png'.format(i), np.uint8(image_pred)) cc.append(calc_correlation(image_pred, image_true)) mse.append(calc_mse(image_pred, image_true)) psnr.append(calc_psnr(image_pred, image_true)) ssim.append(calc_ssim(image_pred, image_true)) elif FLAGS.loss == 'SE3': y_pred, _ = inception.inception_v3(image_resized, num_classes=6, is_training=False) sess = tf.Session() ckpt_file = tf.train.latest_checkpoint(FLAGS.model_dir) tf.train.Saver().restore(sess, ckpt_file) print('restoring parameters from', ckpt_file) SO3_GROUP = SpecialOrthogonalGroup(3) SE3_GROUP = SpecialEuclideanGroup(3) _se3_err_i = [] for i in tqdm.tqdm(range(FLAGS.n_iter)): _image, _rvec, _tvec, _y_pred = \ sess.run([image, vec, AP2, y_pred]) rx = SO3_GROUP.matrix_from_rotation_vector(_y_pred[0, :3])[0] tx = _y_pred[0, 3:] * 60. image_true = np.squeeze(_image) image_pred = resample_sitk(fixed_image_sitk, rx, tx) imageio.imsave('imgdump/image_{}_true.png'.format(i), np.uint8(_image[0, ...])) imageio.imsave('imgdump/image_{}_pred.png'.format(i), np.uint8(image_pred)) cc.append(calc_correlation(image_pred, image_true)) mse.append(calc_mse(image_pred, image_true)) psnr.append(calc_psnr(image_pred, image_true)) ssim.append(calc_ssim(image_pred, image_true)) _y_true = np.concatenate((_rvec, _tvec), axis=-1) _se3_err_i.append( SE3_GROUP.compose(SE3_GROUP.inverse(_y_true), _y_pred)) err_vec = np.vstack(_se3_err_i) err_weights = np.diag(np.linalg.inv(np.cov(err_vec.T))) err_weights = err_weights / np.linalg.norm(err_weights) print(err_weights) else: print('Invalid Option:', FLAGS.loss) raise SystemExit cc = np.stack(cc) mse = np.stack(mse) psnr = np.stack(psnr) ssim = np.stack(ssim) print('CC:', np.median(cc)) print('MSE:', np.median(mse)) print('PSNR:', np.median(psnr)) print('SSIM:', np.median(ssim))
def main(args): SE3_GROUP = SpecialEuclideanGroup(3, epsilon=FLAGS.epsilon) metric = SE3_GROUP.left_canonical_metric reader_train = PoseNetReader([FLAGS.dataset]) # Get Input Tensors image, y_true = reader_train.read_and_decode(FLAGS.batch_size) # Construct model and encapsulating all ops into scopes, making # Tensorboard's Graph visualization more convenient print('Making Model') with tf.name_scope('Model'): py_x, _ = inception.inception_v1(tf.cast(image, tf.float32), num_classes=6) # tanh(pred_angle) required to prevent infinite spins on rotation axis y_pred = tf.concat((tf.nn.tanh(py_x[:, :3]), py_x[:, 3:]), axis=1) loss = tf.reduce_mean(lie_group.loss(y_pred, y_true, SE3_GROUP, metric)) print('Making Optimizer') with tf.name_scope('Adam'): # Adam Optimizer train_op = tf.train.AdamOptimizer(FLAGS.init_lr).minimize(loss) # Initialize the variables (i.e. assign their default value) print('Initializing Variables...') init_op = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer()) # Create a summary to monitor cost tensor tf.summary.scalar('loss', loss) # Merge all summaries into a single op merged_summary_op = tf.summary.merge_all() # Main Training Routine with tf.Session() as sess: # Run the initializer sess.run(init_op) # Start Queue Threads coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(coord=coord) # op to write logs to Tensorboard summary_writer = tf.summary.FileWriter(FLAGS.logs_path, graph=tf.get_default_graph()) saver = tf.train.Saver() if FLAGS.resume: print('Resuming training.') latest_checkpoint = tf.train.latest_checkpoint(FLAGS.model_dir) saver.restore(sess, latest_checkpoint) # Training cycle try: train_range = tqdm(range(FLAGS.max_iter)) for i in train_range: _, _cost, summary = sess.run([train_op, loss, merged_summary_op]) # Write logs at every iteration train_range.set_description('Training: (loss=%g)' % _cost) summary_writer.add_summary(summary, i) if i % FLAGS.snapshot == 0: save_path = saver.save(sess, '{}/chkpt{}.ckpt'.format(FLAGS.model_dir, i)) except KeyboardInterrupt: print('KeyboardInterrupt!') finally: print('Stopping Threads') coord.request_stop() coord.join(threads) print('Saving iter: ', i) save_path = saver.save(sess, FLAGS.model_dir + str(i) + '.ckpt')
def process(self, config_fp, model_name, res_fp): # Loading Config config_abs_fp = os.path.join(os.path.dirname(__file__), config_fp) config = Box(yaml.load(open(config_abs_fp, 'r').read())) config = config[model_name] print("Evaluating {}.".format(model_name)) print("Config is {}".format(config)) # Loading Inference Server inference_server = PBServer(config=config) with inference_server.graph.as_default(): # Loading TFRecords batch_iterator, batch_init_op = get_iterator_from_tfrecords( config=config, test=True) batch_next_op = batch_iterator.get_next() assert len(config.data.tfrecords_test_dirs ) == 1, "Testing data larger than two :{}".format( config.data.tfrecords_test_dirs) test_name = config.data.tfrecords_test_dirs[0].split('/')[-1] print("Testing data name: {}".format(test_name)) # Config metrics SE3_GROUP = SpecialEuclideanGroup(3, epsilon=np.finfo(np.float32).eps) metric = SE3_GROUP.left_canonical_metric # Loading Data Configurations cnt = 0 se3_errors = [] se3_noises = [] se3_preds = [] se3_gts = [] RRs = [] with inference_server.session as sess: sess.run(batch_init_op) try: while True: _x_dm_batch, _x_cam_batch, _gt_se3param = sess.run([ batch_next_op['x_dm'], batch_next_op['x_cam'], batch_next_op['y_se3param'] ]) _x_cam_batch = _x_cam_batch / 255. _y_hat_se3param = inference_server.inference( data=[_x_dm_batch, _x_cam_batch]) se3_error = self.cal_metrics( se3_pred=np.squeeze(np.array(_y_hat_se3param), 0), se3_true=np.array(_gt_se3param), group=SE3_GROUP, metric=metric) se3_noise = self.cal_metrics( se3_pred=np.zeros_like(np.array(_gt_se3param)), se3_true=np.array(_gt_se3param), group=SE3_GROUP, metric=metric) RR = np.array(se3_error) / np.array(se3_noise) RRs.append(RR) MRR = 1 - np.mean(np.array(RRs)) if cnt == 1: print("MRR Explain:") print("RR = np.array(se3_error) / np.array(se3_noise)") print("np.array(se3_error) = {}".format( np.array(se3_error))) print("np.array(se3_noise) = {}".format( np.array(se3_noise))) print("RR = {}".format(RR)) print("{} / {} = {}".format( np.array(se3_error)[0], np.array(se3_noise)[0], RR[0])) se3_gts.append(np.array(_gt_se3param)) se3_preds.append(np.array(_y_hat_se3param)) se3_noises.append(se3_noise) se3_noises_mean = np.mean(np.array(se3_noises)) se3_errors.append(se3_error) se3_errors_mean = np.mean(np.array(se3_errors)) print("{} ~ {} Test --> {} | {} | {}%".format( cnt * config.train.batch_size, (1 + cnt) * config.train.batch_size, se3_errors_mean, se3_noises_mean, MRR * 100.)) cnt += 1 except tf.errors.OutOfRangeError as e: print("End of data .") print("Final: {} ({}%)".format(np.round(se3_errors_mean, 4), np.round(MRR * 100., 4))) if not os.path.isdir(res_fp): print("{} does not exits, creating one.".format(res_fp)) pathlib.Path(res_fp).mkdir(parents=True, exist_ok=True) np.save( '{}/{}_{}_se3_errors.npy'.format(res_fp, test_name, model_name), np.array(se3_errors)) np.save( '{}/{}_{}_se3_noises.npy'.format(res_fp, test_name, model_name), np.array(se3_noises)) np.save('{}/{}_{}_se3_gt.npy'.format(res_fp, test_name, model_name), np.array(se3_gts)) np.save('{}/{}_{}_se3_preds.npy'.format(res_fp, test_name, model_name), np.array(se3_preds))
def main(argv): # TF Record datafiles = FLAGS.data_dir + '/test/' + FLAGS.subject_id + '.tfrecord' dataset = tf.data.TFRecordDataset(datafiles) dataset = dataset.map(_parse_function_ifind) # dataset = dataset.repeat() # dataset = dataset.shuffle(FLAGS.queue_buffer) dataset = dataset.batch(1) image, vec, qt, AP1, AP2, AP3 = dataset.make_one_shot_iterator().get_next() # Nifti Volume subject_path = FLAGS.scan_dir + '/test/' + FLAGS.subject_id + '.nii.gz' fixed_image_sitk_tmp = sitk.ReadImage(subject_path, sitk.sitkFloat32) fixed_image_sitk = sitk.GetImageFromArray( sitk.GetArrayFromImage(fixed_image_sitk_tmp)) fixed_image_sitk = sitk.RescaleIntensity(fixed_image_sitk, 0, 1) # * 255. # Network Definition image_input = tf.placeholder(shape=[1, 224, 224, 1], dtype=tf.float32) image_resized = tf.image.resize_images(image, size=[224, 224]) if FLAGS.loss == 'PoseNet': y_pred, _ = inception.inception_v3(image_input, num_classes=7) quaternion_pred, translation_pred = tf.split(y_pred, [4, 3], axis=1) sess = tf.Session() ckpt_file = tf.train.latest_checkpoint(FLAGS.model_dir) tf.train.Saver().restore(sess, ckpt_file) print('restoring parameters from', ckpt_file) SO3_GROUP = SpecialOrthogonalGroup(3) for i in range(FLAGS.n_iter): _image, _image_resized, _quaternion_true, _translation_true = \ sess.run([image, image_resized, qt, AP2], ) _quaternion_pred_sample = [] _translation_pred_sample = [] for j in range(FLAGS.n_samples): _quaternion_pred_i, _translation_pred_i = \ sess.run([quaternion_pred, translation_pred], feed_dict={image_input: _image_resized}) _quaternion_pred_sample.append(_quaternion_pred_i) _translation_pred_sample.append(_translation_pred_i) print(_quaternion_pred_i, _translation_pred_i) _quaternion_pred_sample = np.vstack(_quaternion_pred_sample) _rotvec_pred_sample = SO3_GROUP.rotation_vector_from_quaternion( _quaternion_pred_sample) _rotvec_pred = SO3_GROUP.left_canonical_metric.mean( _rotvec_pred_sample) _quaternion_pred = SO3_GROUP.quaternion_from_rotation_vector( _rotvec_pred) _translation_pred = np.mean(np.vstack(_translation_pred_sample), axis=0) # _quaternion_pred_variance = SO3_GROUP.left_canonical_metric.variance(_rotvec_pred_sample) _translation_pred_variance = np.var( np.vstack(_translation_pred_sample), axis=0) rx = SO3_GROUP.matrix_from_quaternion(_quaternion_pred)[0] tx = _translation_pred[0] * 60. image_true = np.squeeze(_image) image_pred = resample_sitk(fixed_image_sitk, rx, tx) imageio.imsave('imgdump/image_{}_true.png'.format(i), _image[0, ...]) imageio.imsave('imgdump/image_{}_pred.png'.format(i), image_pred) calc_psnr(image_pred, image_true) calc_mse(image_pred, image_true) calc_ssim(image_pred, image_true) calc_correlation(image_pred, image_true) elif FLAGS.loss == 'AP': y_pred, _ = inception.inception_v3(image_input, num_classes=9) AP1_pred, AP2_pred, AP3_pred = tf.split(y_pred, 3, axis=1) sess = tf.Session() ckpt_file = tf.train.latest_checkpoint(FLAGS.model_dir) tf.train.Saver().restore(sess, ckpt_file) print('restoring parameters from', ckpt_file) for i in range(FLAGS.n_iter): _image, _image_resized, _AP1, _AP2, _AP3 = \ sess.run([image, image_resized, AP1, AP2, AP3]) _AP1_sample = [] _AP2_sample = [] _AP3_sample = [] for j in range(FLAGS.n_samples): _AP1_pred_i, _AP2_pred_i, _AP3_pred_i = \ sess.run([AP1_pred, AP2_pred, AP3_pred], feed_dict={image_input: _image_resized}) _AP1_sample.append(_AP1_pred_i) _AP2_sample.append(_AP2_pred_i) _AP3_sample.append(_AP3_pred_i) _AP1_pred = np.mean(np.vstack(_AP1_sample), axis=0) _AP2_pred = np.mean(np.vstack(_AP2_sample), axis=0) _AP3_pred = np.mean(np.vstack(_AP3_sample), axis=0) _AP1_pred_variance = np.var(np.vstack(_AP1_sample), axis=0) _AP2_pred_variance = np.var(np.vstack(_AP2_sample), axis=0) _AP3_pred_variance = np.var(np.vstack(_AP3_sample), axis=0) dist_ap1 = np.linalg.norm(_AP1 - _AP1_pred) dist_ap2 = np.linalg.norm(_AP2 - _AP2_pred) dist_ap3 = np.linalg.norm(_AP3 - _AP3_pred) rx = matrix_from_anchor_points(_AP1_pred[0], _AP2_pred[0], _AP3_pred[0]) tx = _AP2_pred[0] * 60. image_true = np.squeeze(_image) image_pred = resample_sitk(fixed_image_sitk, rx, tx) imageio.imsave('imgdump/image_{}_true.png'.format(i), _image[0, ...]) imageio.imsave('imgdump/image_{}_pred.png'.format(i), image_pred) calc_psnr(image_pred, image_true) calc_mse(image_pred, image_true) calc_ssim(image_pred, image_true) calc_correlation(image_pred, image_true) elif FLAGS.loss == 'SE3': y_pred, _ = inception.inception_v3(image_input, num_classes=6) sess = tf.Session() ckpt_file = tf.train.latest_checkpoint(FLAGS.model_dir) tf.train.Saver().restore(sess, ckpt_file) print('restoring parameters from', ckpt_file) SO3_GROUP = SpecialOrthogonalGroup(3) SE3_GROUP = SpecialEuclideanGroup(3) for i in range(FLAGS.n_iter): print(i) _image, _image_resized, _rvec, _tvec = \ sess.run([image, image_resized, vec, AP2]) _y_pred_sample = [] for j in range(FLAGS.n_samples): _y_pred_i = sess.run([y_pred], feed_dict={image_input: _image_resized}) _y_pred_sample.append(_y_pred_i[0]) _y_pred_sample = np.vstack(_y_pred_sample) _y_pred = SE3_GROUP.left_canonical_metric.mean(_y_pred_sample) _y_pred_variance = SE3_GROUP.left_canonical_metric.variance( _y_pred_sample) rx = SO3_GROUP.matrix_from_rotation_vector(_y_pred[0, :3])[0] tx = _y_pred[0, 3:] * 60. image_true = np.squeeze(_image) image_pred = resample_sitk(fixed_image_sitk, rx, tx) imageio.imsave('imgdump/image_{}_true.png'.format(i), _image[0, ...]) imageio.imsave('imgdump/image_{}_pred.png'.format(i), image_pred) calc_psnr(image_pred, image_true) calc_mse(image_pred, image_true) calc_ssim(image_pred, image_true) calc_correlation(image_pred, image_true) else: print('Invalid Option:', FLAGS.loss) raise SystemExit
import os import yaml import numpy as np from box import Box import geomstats.lie_group as lie_group from geomstats.special_euclidean_group import SpecialEuclideanGroup import liegroups SE3_GROUP = SpecialEuclideanGroup(3, epsilon=np.finfo(np.float32).eps) metric = SE3_GROUP.left_canonical_metric def load_config(config_fp): config_abs_fp = os.path.join(os.path.dirname(__file__), config_fp) config = Box(yaml.load(open(config_abs_fp, 'r').read())) return config def cal_se3_error(se3_pred, se3_true): se3_error = lie_group.loss(se3_pred, se3_true, SE3_GROUP, metric) return se3_error def SE3_to_se3(SE3_matrix): # This liegroups lib represent se3 with first 3 element as translation, which is different than us se3_rot_last = liegroups.SE3.log( liegroups.SE3.from_matrix(SE3_matrix, normalize=True)) se3 = np.zeros_like(se3_rot_last) se3[:3] = se3_rot_last[3:] se3[3:] = se3_rot_last[:3] return se3
def main(argv): # TF Record dataset = tf.data.TFRecordDataset(FLAGS.data_dir + '/dataset_test.tfrecords') dataset = dataset.map(_parse_function_kingscollege) # dataset = dataset.repeat() # dataset = dataset.shuffle(FLAGS.queue_buffer) dataset = dataset.batch(1) image, vec, pose_q, pose_x = dataset.make_one_shot_iterator().get_next() # Network Definition image_resized = tf.image.resize_images(image, size=[224, 224]) if FLAGS.loss == 'PoseNet': y_pred, _ = inception.inception_v3(image_resized, num_classes=7, is_training=False) quaternion_pred, translation_pred = tf.split(y_pred, [4, 3], axis=1) sess = tf.Session() ckpt_file = tf.train.latest_checkpoint(FLAGS.model_dir) tf.train.Saver().restore(sess, ckpt_file) print('restoring parameters from', ckpt_file) i = 0 results = [] try: while True: _image, _quaternion_true, _translation_true, _quaternion_pred, _translation_pred = \ sess.run([image, pose_q, pose_x, quaternion_pred, translation_pred]) # Compute Individual Sample Error q1 = _quaternion_true / np.linalg.norm(_quaternion_true) q2 = _quaternion_pred / np.linalg.norm(_quaternion_pred) d = abs(np.sum(np.multiply(q1, q2))) theta = 2. * np.arccos(d) * 180. / np.pi error_x = np.linalg.norm(_translation_true - _translation_pred) results.append([error_x, theta]) print('Iteration:', i, 'Error XYZ (m):', error_x, 'Error Q (degrees):', theta) i = i + 1 except tf.errors.OutOfRangeError: print('End of Test Data') results = np.stack(results) results = np.median(results, axis=0) print('Error XYZ (m):', results[0], 'Error Q (degrees):', results[1]) elif FLAGS.loss == 'SE3': y_pred, _ = inception.inception_v3(image_resized, num_classes=6, is_training=False) sess = tf.Session() ckpt_file = tf.train.latest_checkpoint(FLAGS.model_dir) tf.train.Saver().restore(sess, ckpt_file) print('restoring parameters from', ckpt_file) SO3_GROUP = SpecialOrthogonalGroup(3) SE3_GROUP = SpecialEuclideanGroup(3) metric = InvariantMetric(group=SE3_GROUP, inner_product_mat_at_identity=np.eye(6), left_or_right='left') i = 0 results = [] _y_pred_i = [] _y_true_i = [] _se3_err_i = [] try: while True: _image, _rvec, _qvec, _tvec, _y_pred = \ sess.run([image, vec, pose_q, pose_x, y_pred]) _quaternion_true = _qvec _quaternion_pred = SO3_GROUP.quaternion_from_rotation_vector( _y_pred[0, :3])[0] # Compute Individual Sample Error q1 = _quaternion_true / np.linalg.norm(_quaternion_true) q2 = _quaternion_pred / np.linalg.norm(_quaternion_pred) d = abs(np.sum(np.multiply(q1, q2))) theta = 2. * np.arccos(d) * 180. / np.pi error_x = np.linalg.norm(_tvec - _y_pred[0, 3:]) results.append([error_x, theta]) # SE3 compute _y_true = np.concatenate((_rvec, _tvec), axis=-1) se3_dist = metric.squared_dist(_y_pred, _y_true)[0] _y_pred_i.append(_y_pred) _y_true_i.append(_y_true) _se3_err_i.append( SE3_GROUP.compose(SE3_GROUP.inverse(_y_true), _y_pred)) print('Iteration:', i, 'Error XYZ (m):', error_x, 'Error Q (degrees):', theta, 'SE3 dist:', se3_dist) i = i + 1 except tf.errors.OutOfRangeError: print('End of Test Data') # Calculate SE3 Error Weights err_vec = np.vstack(_se3_err_i) err_weights = np.diag(np.linalg.inv(np.cov(err_vec.T))) err_weights = err_weights / np.linalg.norm(err_weights) print(err_weights) results = np.stack(results) results = np.median(results, axis=0) print('Error XYZ (m):', results[0], 'Error Q (degrees):', results[1]) else: print('Invalid Option:', FLAGS.loss) raise SystemExit