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()
def main(): fig = plt.figure(figsize=(15, 5)) hyperbolic_plane = HyperbolicSpace(dimension=2) data = hyperbolic_plane.random_uniform(n_samples=140) mean = hyperbolic_plane.metric.mean(data) tpca = TangentPCA(metric=hyperbolic_plane.metric, n_components=2) tpca = tpca.fit(data, base_point=mean) tangent_projected_data = tpca.transform(data) geodesic_0 = hyperbolic_plane.metric.geodesic( initial_point=mean, initial_tangent_vec=tpca.components_[0]) geodesic_1 = hyperbolic_plane.metric.geodesic( initial_point=mean, initial_tangent_vec=tpca.components_[1]) n_steps = 100 t = np.linspace(-1, 1, n_steps) geodesic_points_0 = geodesic_0(t) geodesic_points_1 = geodesic_1(t) print('Coordinates of the Log of the first 5 data points at the mean, ' 'projected on the principal components:') print(tangent_projected_data[:5]) ax_var = fig.add_subplot(121) xticks = np.arange(1, 2 + 1, 1) ax_var.xaxis.set_ticks(xticks) ax_var.set_title('Explained variance') ax_var.set_xlabel('Number of Principal Components') ax_var.set_ylim((0, 1)) ax_var.plot(xticks, tpca.explained_variance_ratio_) ax = fig.add_subplot(122) visualization.plot(mean, ax, space='H2_poincare_disk', color='darkgreen', s=10) visualization.plot(geodesic_points_0, ax, space='H2_poincare_disk', linewidth=2) visualization.plot(geodesic_points_1, ax, space='H2_poincare_disk', linewidth=2) visualization.plot(data, ax, space='H2_poincare_disk', color='black', alpha=0.7) plt.show()
def test_scaled_distance(self): point_a_intrinsic = gs.array([1, 2, 3]) point_b_intrinsic = gs.array([4, 5, 6]) point_a = self.space.intrinsic_to_extrinsic_coords(point_a_intrinsic) point_b = self.space.intrinsic_to_extrinsic_coords(point_b_intrinsic) scale = 2 default_space = HyperbolicSpace(dimension=self.dimension) scaled_space = HyperbolicSpace(dimension=self.dimension, scale=2) distance_default_metric = default_space.metric.dist(point_a, point_b) distance_scaled_metric = scaled_space.metric.dist(point_a, point_b) result = distance_scaled_metric expected = scale * distance_default_metric self.assertAllClose(result, expected)
def test_exp_and_belongs(self): H2 = HyperbolicSpace(dimension=2) METRIC = H2.metric base_point = gs.array([1., 0., 0.]) with self.session(): self.assertTrue(gs.eval(H2.belongs(base_point))) tangent_vec = H2.projection_to_tangent_space(vector=gs.array( [1., 2., 1.]), base_point=base_point) exp = METRIC.exp(tangent_vec=tangent_vec, base_point=base_point) with self.session(): self.assertTrue(gs.eval(H2.belongs(exp)))
def test_scaled_squared_norm(self): base_point_intrinsic = gs.array([1, 1, 1]) base_point = self.space.intrinsic_to_extrinsic_coords( base_point_intrinsic) tangent_vec = gs.array([1, 2, 3, 4]) tangent_vec = self.space.projection_to_tangent_space( tangent_vec, base_point) scale = 2 default_space = HyperbolicSpace(dimension=self.dimension) scaled_space = HyperbolicSpace(dimension=self.dimension, scale=2) squared_norm_default_metric = default_space.metric.squared_norm( tangent_vec, base_point) squared_norm_scaled_metric = scaled_space.metric.squared_norm( tangent_vec, base_point) result = squared_norm_scaled_metric expected = scale**2 * squared_norm_default_metric self.assertAllClose(result, expected)
class TestVisualizationMethods(geomstats.tests.TestCase): 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() @geomstats.tests.np_only def test_plot_points_so3(self): points = self.SO3_GROUP.random_uniform(self.n_samples) visualization.plot(points, space='SO3_GROUP') @geomstats.tests.np_only def test_plot_points_se3(self): points = self.SE3_GROUP.random_uniform(self.n_samples) visualization.plot(points, space='SE3_GROUP') @geomstats.tests.np_only def test_plot_points_s1(self): points = self.S1.random_uniform(self.n_samples) visualization.plot(points, space='S1') @geomstats.tests.np_only def test_plot_points_s2(self): points = self.S2.random_uniform(self.n_samples) visualization.plot(points, space='S2') @geomstats.tests.np_only def test_plot_points_h2_poincare_disk(self): points = self.H2.random_uniform(self.n_samples) visualization.plot(points, space='H2_poincare_disk') @geomstats.tests.np_only 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') @geomstats.tests.np_only def test_plot_points_h2_klein_disk(self): points = self.H2.random_uniform(self.n_samples) visualization.plot(points, space='H2_klein_disk')
def __init__(self, n_disks, point_type='ball'): self.n_disks = n_disks self.point_type = point_type disk = HyperbolicSpace(dimension=2, point_type=point_type) list_disks = [ disk, ] * n_disks super(PoincarePolydisk, self).__init__(manifolds=list_disks) self.metric = PoincarePolydiskMetric(n_disks=n_disks, point_type=point_type)
def test_scaled_inner_product(self): base_point_intrinsic = gs.array([1, 1, 1]) base_point = self.space.intrinsic_to_extrinsic_coords( base_point_intrinsic) tangent_vec_a = gs.array([1, 2, 3, 4]) tangent_vec_b = gs.array([5, 6, 7, 8]) tangent_vec_a = self.space.projection_to_tangent_space( tangent_vec_a, base_point) tangent_vec_b = self.space.projection_to_tangent_space( tangent_vec_b, base_point) scale = 2 default_space = HyperbolicSpace(dimension=self.dimension) scaled_space = HyperbolicSpace(dimension=self.dimension, scale=2) inner_product_default_metric = default_space.metric.inner_product( tangent_vec_a, tangent_vec_b, base_point) inner_product_scaled_metric = scaled_space.metric.inner_product( tangent_vec_a, tangent_vec_b, base_point) result = inner_product_scaled_metric expected = scale**2 * inner_product_default_metric self.assertAllClose(result, expected)
def test_product_distance_extrinsic_representation(self): point_type = 'extrinsic' point_a_intrinsic = gs.array([0.01, 0.0]) point_b_intrinsic = gs.array([0.0, 0.0]) hyperbolic_space = HyperbolicSpace(dimension=2, point_type=point_type) point_a = hyperbolic_space.intrinsic_to_extrinsic_coords( point_a_intrinsic) point_b = hyperbolic_space.intrinsic_to_extrinsic_coords( point_b_intrinsic) duplicate_point_a = gs.zeros((2,) + point_a.shape) duplicate_point_a[0] = point_a duplicate_point_a[1] = point_a duplicate_point_b = gs.zeros((2,) + point_b.shape) duplicate_point_b[0] = point_b duplicate_point_b[1] = point_b single_disk = PoincarePolydisk(n_disks=1, point_type=point_type) two_disks = PoincarePolydisk(n_disks=2, point_type=point_type) distance_single_disk = single_disk.metric.dist(point_a, point_b) distance_two_disks = two_disks.metric.dist( duplicate_point_a, duplicate_point_b) result = distance_two_disks expected = 3 ** 0.5 * distance_single_disk self.assertAllClose(result, expected)
def setUp(self): gs.random.seed(1234) self.dimension = 2 self.extrinsic_manifold = HyperbolicSpace(dimension=self.dimension) self.ball_manifold = HyperbolicSpace(dimension=self.dimension, point_type='ball') self.intrinsic_manifold = HyperbolicSpace(dimension=self.dimension, point_type='intrinsic') self.half_plane_manifold = HyperbolicSpace(dimension=self.dimension, point_type='half-plane') self.ball_metric = HyperbolicMetric(dimension=self.dimension, point_type='ball') self.extrinsic_metric = HyperbolicMetric(dimension=self.dimension, point_type='extrinsic') self.n_samples = 10
def intrinsic_to_extrinsic_coords(self, point_intrinsic): """ Convert the parameterization of a point on the Hyperbolic space from its intrinsic coordinates, to its extrinsic coordinates in Minkowski space. Parameters ---------- point_intrinsic : array-like, shape=[n_diskx, n_samples, dimension] Returns ------- point_extrinsic : array-like, shape=[n_disks, n_samples, dimension + 1] """ n_disks = point_intrinsic.shape[0] return gs.array([ HyperbolicSpace._intrinsic_to_extrinsic_coordinates( point_intrinsic[i_disks, ...]) for i_disks in range(n_disks) ])
def test_distance_ball_extrinsic_from_extr_5_dim(self): x_int = gs.array([[10, 0.2, 3, 4]]) y_int = gs.array([[1, 6, 2., 1]]) extrinsic_manifold = HyperbolicSpace(4, point_type='extrinsic') ball_metric = HyperbolicMetric(4, point_type='ball') extrinsic_metric = HyperbolicMetric(4, point_type='extrinsic') x_extr = extrinsic_manifold.from_coordinates( x_int, from_point_type='intrinsic') y_extr = extrinsic_manifold.from_coordinates( y_int, from_point_type='intrinsic') x_ball = extrinsic_manifold.to_coordinates(x_extr, to_point_type='ball') y_ball = extrinsic_manifold.to_coordinates(y_extr, to_point_type='ball') dst_ball = ball_metric.dist(x_ball, y_ball) dst_extr = extrinsic_metric.dist(x_extr, y_extr) self.assertAllClose(dst_ball, dst_extr)
def main(): cluster_1 = gs.random.uniform(low=0.5, high=0.6, size=(20, 2)) cluster_2 = gs.random.uniform(low=0, high=-0.2, size=(20, 2)) ax = plt.gca() merged_clusters = gs.concatenate((cluster_1, cluster_2), axis=0) manifold = HyperbolicSpace(dimension=2, point_type='ball') metric = HyperbolicMetric(dimension=2, point_type='ball') visualization.plot(merged_clusters, ax=ax, space='H2_poincare_disk', marker='.', color='black', point_type=manifold.point_type) kmeans = RiemannianKMeans( riemannian_metric=metric, n_clusters=2, init='random', ) centroids = kmeans.fit(X=merged_clusters, max_iter=1) labels = kmeans.predict(X=merged_clusters) visualization.plot(centroids, ax=ax, space='H2_poincare_disk', marker='.', color='red', point_type=manifold.point_type) print('Data_labels', labels) plt.show()
"""Plot geodesics in H2. Plot a geodesic on the Hyperbolic space H2. With Poincare Disk visualization. """ import os import matplotlib.pyplot as plt import numpy as np import geomstats.visualization as visualization from geomstats.geometry.hyperbolic_space import HyperbolicSpace H2 = HyperbolicSpace(dimension=2) METRIC = H2.metric def plot_geodesic_between_two_points(initial_point, end_point, n_steps=10, ax=None): assert H2.belongs(initial_point) assert H2.belongs(end_point) geodesic = METRIC.geodesic(initial_point=initial_point, end_point=end_point) t = np.linspace(0, 1, n_steps) points = geodesic(t) visualization.plot(points, ax=ax, space='H2_poincare_disk')
class TestHyperbolicSpaceMethods(geomstats.tests.TestCase): _multiprocess_can_split_ = True def setUp(self): gs.random.seed(1234) self.dimension = 3 self.space = HyperbolicSpace(dimension=self.dimension) self.metric = self.space.metric self.n_samples = 10 def test_random_uniform_and_belongs(self): point = self.space.random_uniform() result = self.space.belongs(point) expected = gs.array([[True]]) self.assertAllClose(result, expected) def test_random_uniform(self): result = self.space.random_uniform() self.assertAllClose(gs.shape(result), (1, self.dimension + 1)) def test_intrinsic_and_extrinsic_coords(self): """ Test that the composition of intrinsic_to_extrinsic_coords and extrinsic_to_intrinsic_coords gives the identity. """ point_int = gs.ones(self.dimension) point_ext = self.space.intrinsic_to_extrinsic_coords(point_int) result = self.space.extrinsic_to_intrinsic_coords(point_ext) expected = point_int expected = helper.to_vector(expected) self.assertAllClose(result, expected) point_ext = gs.array([2.0, 1.0, 1.0, 1.0]) point_int = self.space.extrinsic_to_intrinsic_coords(point_ext) result = self.space.intrinsic_to_extrinsic_coords(point_int) expected = point_ext expected = helper.to_vector(expected) self.assertAllClose(result, expected) def test_intrinsic_and_extrinsic_coords_vectorization(self): """ Test that the composition of intrinsic_to_extrinsic_coords and extrinsic_to_intrinsic_coords gives the identity. """ point_int = gs.array([[.1, 0., 0., .1, 0., 0.], [.1, .1, .1, .4, .1, 0.], [.1, .3, 0., .1, 0., 0.], [-0.1, .1, -.4, .1, -.01, 0.], [0., 0., .1, .1, -0.08, -0.1], [.1, .1, .1, .1, 0., -0.5]]) point_ext = self.space.intrinsic_to_extrinsic_coords(point_int) result = self.space.extrinsic_to_intrinsic_coords(point_ext) expected = point_int expected = helper.to_vector(expected) self.assertAllClose(result, expected) point_ext = gs.array([[2., 1., 1., 1.], [4., 1., 3., math.sqrt(5.)], [3., 2., 0., 2.]]) point_int = self.space.extrinsic_to_intrinsic_coords(point_ext) result = self.space.intrinsic_to_extrinsic_coords(point_int) expected = point_ext expected = helper.to_vector(expected) self.assertAllClose(result, expected) def test_log_and_exp_general_case(self): """ Test that the riemannian exponential and the riemannian logarithm are inverse. Expect their composition to give the identity function. """ # Riemannian Log then Riemannian Exp # General case base_point = gs.array([4.0, 1., 3.0, math.sqrt(5.)]) point = gs.array([2.0, 1.0, 1.0, 1.0]) log = self.metric.log(point=point, base_point=base_point) result = self.metric.exp(tangent_vec=log, base_point=base_point) expected = helper.to_vector(point) self.assertAllClose(result, expected) def test_exp_and_belongs(self): H2 = HyperbolicSpace(dimension=2) METRIC = H2.metric base_point = gs.array([1., 0., 0.]) with self.session(): self.assertTrue(gs.eval(H2.belongs(base_point))) tangent_vec = H2.projection_to_tangent_space(vector=gs.array( [1., 2., 1.]), base_point=base_point) exp = METRIC.exp(tangent_vec=tangent_vec, base_point=base_point) with self.session(): self.assertTrue(gs.eval(H2.belongs(exp))) def test_exp_vectorization(self): n_samples = 3 dim = self.dimension + 1 one_vec = gs.array([2.0, 1.0, 1.0, 1.0]) one_base_point = gs.array([4.0, 3., 1.0, math.sqrt(5)]) n_vecs = gs.array([[2., 1., 1., 1.], [4., 1., 3., math.sqrt(5.)], [3., 2., 0., 2.]]) n_base_points = gs.array( [[2.0, 0.0, 1.0, math.sqrt(2)], [5.0, math.sqrt(8), math.sqrt(8), math.sqrt(8)], [1.0, 0.0, 0.0, 0.0]]) one_tangent_vec = self.space.projection_to_tangent_space( one_vec, base_point=one_base_point) result = self.metric.exp(one_tangent_vec, one_base_point) self.assertAllClose(gs.shape(result), (1, dim)) n_tangent_vecs = self.space.projection_to_tangent_space( n_vecs, base_point=one_base_point) result = self.metric.exp(n_tangent_vecs, one_base_point) self.assertAllClose(gs.shape(result), (n_samples, dim)) expected = np.zeros((n_samples, dim)) with self.session(): for i in range(n_samples): expected[i] = gs.eval( self.metric.exp(n_tangent_vecs[i], one_base_point)) expected = helper.to_vector(gs.array(expected)) self.assertAllClose(result, expected) one_tangent_vec = self.space.projection_to_tangent_space( one_vec, base_point=n_base_points) result = self.metric.exp(one_tangent_vec, n_base_points) self.assertAllClose(gs.shape(result), (n_samples, dim)) expected = np.zeros((n_samples, dim)) with self.session(): for i in range(n_samples): expected[i] = gs.eval( self.metric.exp(one_tangent_vec[i], n_base_points[i])) expected = helper.to_vector(gs.array(expected)) self.assertAllClose(result, expected) n_tangent_vecs = self.space.projection_to_tangent_space( n_vecs, base_point=n_base_points) result = self.metric.exp(n_tangent_vecs, n_base_points) self.assertAllClose(gs.shape(result), (n_samples, dim)) expected = np.zeros((n_samples, dim)) with self.session(): for i in range(n_samples): expected[i] = gs.eval( self.metric.exp(n_tangent_vecs[i], n_base_points[i])) expected = helper.to_vector(gs.array(expected)) self.assertAllClose(result, expected) def test_log_vectorization(self): n_samples = 3 dim = self.dimension + 1 one_point = gs.array([2.0, 1.0, 1.0, 1.0]) one_base_point = gs.array([4.0, 3., 1.0, math.sqrt(5)]) n_points = gs.array([[2.0, 1.0, 1.0, 1.0], [4.0, 1., 3.0, math.sqrt(5)], [3.0, 2.0, 0.0, 2.0]]) n_base_points = gs.array( [[2.0, 0.0, 1.0, math.sqrt(2)], [5.0, math.sqrt(8), math.sqrt(8), math.sqrt(8)], [1.0, 0.0, 0.0, 0.0]]) result = self.metric.log(one_point, one_base_point) self.assertAllClose(gs.shape(result), (1, dim)) result = self.metric.log(n_points, one_base_point) self.assertAllClose(gs.shape(result), (n_samples, dim)) result = self.metric.log(one_point, n_base_points) self.assertAllClose(gs.shape(result), (n_samples, dim)) result = self.metric.log(n_points, n_base_points) self.assertAllClose(gs.shape(result), (n_samples, dim)) def test_inner_product(self): """ Test that the inner product between two tangent vectors is the Minkowski inner product. """ minkowski_space = MinkowskiSpace(self.dimension + 1) base_point = gs.array( [1.16563816, 0.36381045, -0.47000603, 0.07381469]) tangent_vec_a = self.space.projection_to_tangent_space( vector=gs.array([10., 200., 1., 1.]), base_point=base_point) tangent_vec_b = self.space.projection_to_tangent_space( vector=gs.array([11., 20., -21., 0.]), base_point=base_point) result = self.metric.inner_product(tangent_vec_a, tangent_vec_b, base_point) expected = minkowski_space.metric.inner_product( tangent_vec_a, tangent_vec_b, base_point) with self.session(): self.assertAllClose(result, expected) def test_squared_norm_and_squared_dist(self): """ Test that the squared distance between two points is the squared norm of their logarithm. """ point_a = gs.array([2.0, 1.0, 1.0, 1.0]) point_b = gs.array([4.0, 1., 3.0, math.sqrt(5)]) log = self.metric.log(point=point_a, base_point=point_b) result = self.metric.squared_norm(vector=log) expected = self.metric.squared_dist(point_a, point_b) with self.session(): self.assertAllClose(result, expected) def test_norm_and_dist(self): """ Test that the distance between two points is the norm of their logarithm. """ point_a = gs.array([2.0, 1.0, 1.0, 1.0]) point_b = gs.array([4.0, 1., 3.0, math.sqrt(5)]) log = self.metric.log(point=point_a, base_point=point_b) result = self.metric.norm(vector=log) expected = self.metric.dist(point_a, point_b) with self.session(): self.assertAllClose(result, expected) def test_log_and_exp_edge_case(self): """ Test that the riemannian exponential and the riemannian logarithm are inverse. Expect their composition to give the identity function. """ # Riemannian Log then Riemannian Exp # Edge case: two very close points, base_point_2 and point_2, # form an angle < epsilon base_point_intrinsic = gs.array([1., 2., 3.]) base_point = self.space.intrinsic_to_extrinsic_coords( base_point_intrinsic) point_intrinsic = (base_point_intrinsic + 1e-12 * gs.array([-1., -2., 1.])) point = self.space.intrinsic_to_extrinsic_coords(point_intrinsic) log = self.metric.log(point=point, base_point=base_point) result = self.metric.exp(tangent_vec=log, base_point=base_point) expected = point with self.session(): self.assertAllClose(result, expected) @geomstats.tests.np_and_tf_only def test_exp_and_log_and_projection_to_tangent_space_general_case(self): """ Test that the riemannian exponential and the riemannian logarithm are inverse. Expect their composition to give the identity function. """ # Riemannian Exp then Riemannian Log # General case base_point = gs.array([4.0, 1., 3.0, math.sqrt(5)]) vector = gs.array([2.0, 1.0, 1.0, 1.0]) vector = self.space.projection_to_tangent_space(vector=vector, base_point=base_point) exp = self.metric.exp(tangent_vec=vector, base_point=base_point) result = self.metric.log(point=exp, base_point=base_point) expected = vector with self.session(): self.assertAllClose(result, expected) def test_dist(self): # Distance between a point and itself is 0. point_a = gs.array([4.0, 1., 3.0, math.sqrt(5)]) point_b = point_a result = self.metric.dist(point_a, point_b) expected = gs.array([[0]]) with self.session(): self.assertAllClose(result, expected) def test_exp_and_dist_and_projection_to_tangent_space(self): base_point = gs.array([4.0, 1., 3.0, math.sqrt(5)]) vector = gs.array([0.001, 0., -.00001, -.00003]) tangent_vec = self.space.projection_to_tangent_space( vector=vector, base_point=base_point) exp = self.metric.exp(tangent_vec=tangent_vec, base_point=base_point) result = self.metric.dist(base_point, exp) sq_norm = self.metric.embedding_metric.squared_norm(tangent_vec) expected = sq_norm with self.session(): self.assertAllClose(result, expected, atol=1e-2) def test_geodesic_and_belongs(self): # TODO(nina): Fix this tests, as it fails when geodesic goes "too far" initial_point = gs.array([4.0, 1., 3.0, math.sqrt(5)]) n_geodesic_points = 100 vector = gs.array([1., 0., 0., 0.]) initial_tangent_vec = self.space.projection_to_tangent_space( vector=vector, base_point=initial_point) geodesic = self.metric.geodesic( initial_point=initial_point, initial_tangent_vec=initial_tangent_vec) t = gs.linspace(start=0., stop=1., num=n_geodesic_points) points = geodesic(t) result = self.space.belongs(points) expected = gs.array(n_geodesic_points * [[True]]) with self.session(): self.assertAllClose(expected, result) def test_exp_and_log_and_projection_to_tangent_space_edge_case(self): """ Test that the riemannian exponential and the riemannian logarithm are inverse. Expect their composition to give the identity function. """ # Riemannian Exp then Riemannian Log # Edge case: tangent vector has norm < epsilon base_point = gs.array([2., 1., 1., 1.]) vector = 1e-10 * gs.array([.06, -51., 6., 5.]) exp = self.metric.exp(tangent_vec=vector, base_point=base_point) result = self.metric.log(point=exp, base_point=base_point) expected = self.space.projection_to_tangent_space( vector=vector, base_point=base_point) self.assertAllClose(result, expected, atol=1e-8) @geomstats.tests.np_and_tf_only def test_variance(self): point = gs.array([2., 1., 1., 1.]) points = gs.array([point, point]) result = self.metric.variance(points) expected = helper.to_scalar(0.) self.assertAllClose(result, expected) @geomstats.tests.np_and_tf_only def test_mean(self): point = gs.array([2., 1., 1., 1.]) points = gs.array([point, point]) result = self.metric.mean(points) expected = helper.to_vector(point) self.assertAllClose(result, expected) @geomstats.tests.np_and_tf_only def test_mean_and_belongs(self): point_a = self.space.random_uniform() point_b = self.space.random_uniform() point_c = self.space.random_uniform() points = gs.concatenate([point_a, point_b, point_c], axis=0) mean = self.metric.mean(points) result = self.space.belongs(mean) expected = gs.array([[True]]) self.assertAllClose(result, expected)
class TestHyperbolicSpaceMethods(geomstats.tests.TestCase): def setUp(self): gs.random.seed(1234) self.dimension = 2 self.extrinsic_manifold = HyperbolicSpace(dimension=self.dimension) self.ball_manifold = HyperbolicSpace(dimension=self.dimension, point_type='ball') self.intrinsic_manifold = HyperbolicSpace(dimension=self.dimension, point_type='intrinsic') self.half_plane_manifold = HyperbolicSpace(dimension=self.dimension, point_type='half-plane') self.ball_metric = HyperbolicMetric(dimension=self.dimension, point_type='ball') self.extrinsic_metric = HyperbolicMetric(dimension=self.dimension, point_type='extrinsic') self.n_samples = 10 def test_extrinsic_ball_extrinsic(self): x_in = gs.array([[0.5, 7]]) x = self.intrinsic_manifold.to_coordinates(x_in, to_point_type='extrinsic') x_b = self.extrinsic_manifold.to_coordinates(x, to_point_type='ball') x2 = self.ball_manifold.to_coordinates(x_b, to_point_type='extrinsic') self.assertAllClose(x, x2, atol=1e-8) def test_extrinsic_half_plane_extrinsic(self): x_in = gs.array([[0.5, 7]]) x = self.intrinsic_manifold.to_coordinates(x_in, to_point_type='extrinsic') x_up = self.extrinsic_manifold.to_coordinates( x, to_point_type='half-plane') x2 = self.half_plane_manifold.to_coordinates(x_up, to_point_type='extrinsic') self.assertAllClose(x, x2, atol=1e-8) def test_intrinsic_extrinsic_intrinsic(self): x_intr = gs.array([[0.5, 7]]) x_extr = self.intrinsic_manifold.to_coordinates( x_intr, to_point_type='extrinsic') x_intr2 = self.extrinsic_manifold.to_coordinates( x_extr, to_point_type='intrinsic') self.assertAllClose(x_intr, x_intr2, atol=1e-8) def test_ball_extrinsic_ball(self): x = gs.array([[0.5, 0.2]]) x_e = self.ball_manifold.to_coordinates(x, to_point_type='extrinsic') x2 = self.extrinsic_manifold.to_coordinates(x_e, to_point_type='ball') self.assertAllClose(x, x2, atol=1e-10) def test_belongs_ball(self): x = gs.array([[0.5, 0.2]]) belong = self.ball_manifold.belongs(x) assert (belong[0]) def test_distance_ball_extrinsic_from_ball(self): x_ball = gs.array([[0.7, 0.2]]) y_ball = gs.array([[0.2, 0.2]]) x_extr = self.ball_manifold.to_coordinates(x_ball, to_point_type='extrinsic') y_extr = self.ball_manifold.to_coordinates(y_ball, to_point_type='extrinsic') dst_ball = self.ball_metric.dist(x_ball, y_ball) dst_extr = self.extrinsic_metric.dist(x_extr, y_extr) self.assertAllClose(dst_ball, dst_extr) def test_distance_ball_extrinsic_from_extr(self): x_int = gs.array([[10, 0.2]]) y_int = gs.array([[1, 6.]]) x_extr = self.intrinsic_manifold.to_coordinates( x_int, to_point_type='extrinsic') y_extr = self.intrinsic_manifold.to_coordinates( y_int, to_point_type='extrinsic') x_ball = self.extrinsic_manifold.to_coordinates(x_extr, to_point_type='ball') y_ball = self.extrinsic_manifold.to_coordinates(y_extr, to_point_type='ball') dst_ball = self.ball_metric.dist(x_ball, y_ball) dst_extr = self.extrinsic_metric.dist(x_extr, y_extr) self.assertAllClose(dst_ball, dst_extr) def test_distance_ball_extrinsic_from_extr_5_dim(self): x_int = gs.array([[10, 0.2, 3, 4]]) y_int = gs.array([[1, 6, 2., 1]]) extrinsic_manifold = HyperbolicSpace(4, point_type='extrinsic') ball_metric = HyperbolicMetric(4, point_type='ball') extrinsic_metric = HyperbolicMetric(4, point_type='extrinsic') x_extr = extrinsic_manifold.from_coordinates( x_int, from_point_type='intrinsic') y_extr = extrinsic_manifold.from_coordinates( y_int, from_point_type='intrinsic') x_ball = extrinsic_manifold.to_coordinates(x_extr, to_point_type='ball') y_ball = extrinsic_manifold.to_coordinates(y_extr, to_point_type='ball') dst_ball = ball_metric.dist(x_ball, y_ball) dst_extr = extrinsic_metric.dist(x_extr, y_extr) self.assertAllClose(dst_ball, dst_extr) def test_log_exp_ball_extrinsic_from_extr(self): x_int = gs.array([[4., 0.2]]) y_int = gs.array([[3., 3]]) x_extr = self.intrinsic_manifold.to_coordinates( x_int, to_point_type='extrinsic') y_extr = self.intrinsic_manifold.to_coordinates( y_int, to_point_type='extrinsic') x_ball = self.extrinsic_manifold.to_coordinates(x_extr, to_point_type='ball') y_ball = self.extrinsic_manifold.to_coordinates(y_extr, to_point_type='ball') x_ball_log_exp = self.ball_metric.exp( self.ball_metric.log(y_ball, x_ball), x_ball) x_extr_a = self.extrinsic_metric.exp( self.extrinsic_metric.log(y_extr, x_extr), x_extr) x_extr_b = self.extrinsic_manifold.from_coordinates( x_ball_log_exp, from_point_type='ball') self.assertAllClose(x_extr_a, x_extr_b, atol=1e-4) def test_log_exp_ball(self): x = gs.array([[0.1, 0.2]]) y = gs.array([[0.2, 0.5]]) log = self.ball_metric.log(y, x) exp = self.ball_metric.exp(log, x) self.assertAllClose(exp, y) def test_log_exp_ball_batch(self): x = gs.array([[0.1, 0.2]]) y = gs.array([[0.2, 0.5], [0.1, 0.7]]) log = self.ball_metric.log(y, x) exp = self.ball_metric.exp(log, x) self.assertAllClose(exp, y)
def setUp(self): gs.random.seed(1234) self.dimension = 3 self.space = HyperbolicSpace(dimension=self.dimension) self.metric = self.space.metric self.n_samples = 10