def test_cells(self):
"""Test that cells belong to space of planar curves."""
cells, cell_lines, treatments = data_utils.load_cells()
expected = 650
result = len(cells)
self.assertAllClose(result, expected)
result = len(cell_lines)
self.assertAllClose(result, expected)
result = len(treatments)
self.assertAllClose(result, expected)
planar_curves_space = DiscreteCurves(R2)
result = planar_curves_space.belongs(cells)
self.assertTrue(gs.all(result))
result = [line in ["dlm8", "dunn"] for line in cell_lines]
self.assertTrue(gs.all(result))
result = [
treatment in ["control", "cytd", "jasp"]
for treatment in treatments
]
self.assertTrue(gs.all(result))
class TestDiscreteCurves(geomstats.tests.TestCase):
def setup_method(self):
s2 = Hypersphere(dim=2)
r2 = Euclidean(dim=2)
r3 = s2.embedding_space
initial_point = [0.0, 0.0, 1.0]
initial_tangent_vec_a = [1.0, 0.0, 0.0]
initial_tangent_vec_b = [0.0, 1.0, 0.0]
initial_tangent_vec_c = [-1.0, 0.0, 0.0]
curve_fun_a = s2.metric.geodesic(
initial_point=initial_point, initial_tangent_vec=initial_tangent_vec_a
)
curve_fun_b = s2.metric.geodesic(
initial_point=initial_point, initial_tangent_vec=initial_tangent_vec_b
)
curve_fun_c = s2.metric.geodesic(
initial_point=initial_point, initial_tangent_vec=initial_tangent_vec_c
)
self.curve_fun_a = curve_fun_a
self.n_sampling_points = 10
self.sampling_times = gs.linspace(0.0, 1.0, self.n_sampling_points)
self.curve_a = curve_fun_a(self.sampling_times)
self.curve_b = curve_fun_b(self.sampling_times)
self.curve_c = curve_fun_c(self.sampling_times)
self.space_curves_in_euclidean_3d = DiscreteCurves(ambient_manifold=r3)
self.space_curves_in_sphere_2d = DiscreteCurves(ambient_manifold=s2)
self.space_closed_curves_in_euclidean_2d = ClosedDiscreteCurves(
ambient_manifold=r2
)
self.l2_metric_s2 = L2CurvesMetric(ambient_manifold=s2)
self.l2_metric_r3 = L2CurvesMetric(ambient_manifold=r3)
self.srv_metric_r3 = (
self.space_curves_in_euclidean_3d.square_root_velocity_metric
)
self.quotient_srv_metric_r3 = (
self.space_curves_in_euclidean_3d.quotient_square_root_velocity_metric
)
self.a = 1
self.b = 1
self.elastic_metric = ElasticMetric(self.a, self.b)
self.n_discretized_curves = 5
self.times = gs.linspace(0.0, 1.0, self.n_discretized_curves)
gs.random.seed(1234)
def test_belongs(self):
result = self.space_curves_in_sphere_2d.belongs(self.curve_a)
self.assertTrue(result)
curve_ab = [self.curve_a[:-1], self.curve_b]
result = self.space_curves_in_sphere_2d.belongs(curve_ab)
self.assertTrue(gs.all(result))
curve_ab = gs.array([self.curve_a, self.curve_b])
result = self.space_curves_in_sphere_2d.belongs(curve_ab)
self.assertTrue(gs.all(result))
@geomstats.tests.np_autograd_and_torch_only
def test_l2_metric_log_and_squared_norm_and_dist(self):
"""Test that squared norm of logarithm is squared dist."""
tangent_vec = self.l2_metric_s2.log(point=self.curve_b, base_point=self.curve_a)
log_ab = tangent_vec
result = self.l2_metric_s2.squared_norm(vector=log_ab, base_point=self.curve_a)
expected = self.l2_metric_s2.dist(self.curve_a, self.curve_b) ** 2
self.assertAllClose(result, expected)
def test_l2_metric_log_and_exp(self):
"""Test that exp and log are inverse maps."""
tangent_vec = self.l2_metric_s2.log(point=self.curve_b, base_point=self.curve_a)
result = self.l2_metric_s2.exp(tangent_vec=tangent_vec, base_point=self.curve_a)
expected = self.curve_b
self.assertAllClose(result, expected)
def test_l2_metric_inner_product_vectorization(self):
"""Test the vectorization inner_product."""
n_samples = self.n_discretized_curves
curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b)
curves_bc = self.l2_metric_s2.geodesic(self.curve_b, self.curve_c)
curves_ab = curves_ab(self.times)
curves_bc = curves_bc(self.times)
tangent_vecs = self.l2_metric_s2.log(point=curves_bc, base_point=curves_ab)
result = self.l2_metric_s2.inner_product(tangent_vecs, tangent_vecs, curves_ab)
self.assertAllClose(gs.shape(result), (n_samples,))
def test_l2_metric_dist_vectorization(self):
"""Test the vectorization of dist."""
n_samples = self.n_discretized_curves
curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b)
curves_bc = self.l2_metric_s2.geodesic(self.curve_b, self.curve_c)
curves_ab = curves_ab(self.times)
curves_bc = curves_bc(self.times)
result = self.l2_metric_s2.dist(curves_ab, curves_bc)
self.assertAllClose(gs.shape(result), (n_samples,))
def test_l2_metric_exp_vectorization(self):
"""Test the vectorization of exp."""
curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b)
curves_bc = self.l2_metric_s2.geodesic(self.curve_b, self.curve_c)
curves_ab = curves_ab(self.times)
curves_bc = curves_bc(self.times)
tangent_vecs = self.l2_metric_s2.log(point=curves_bc, base_point=curves_ab)
result = self.l2_metric_s2.exp(tangent_vec=tangent_vecs, base_point=curves_ab)
self.assertAllClose(gs.shape(result), gs.shape(curves_ab))
def test_l2_metric_log_vectorization(self):
"""Test the vectorization of log."""
curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b)
curves_bc = self.l2_metric_s2.geodesic(self.curve_b, self.curve_c)
curves_ab = curves_ab(self.times)
curves_bc = curves_bc(self.times)
tangent_vecs = self.l2_metric_s2.log(point=curves_bc, base_point=curves_ab)
result = tangent_vecs
self.assertAllClose(gs.shape(result), gs.shape(curves_ab))
def test_l2_metric_geodesic(self):
"""Test the geodesic method of L2Metric."""
curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b)
curves_ab = curves_ab(self.times)
result = curves_ab
expected = []
for k in range(self.n_sampling_points):
geod = self.l2_metric_s2.ambient_metric.geodesic(
initial_point=self.curve_a[k, :], end_point=self.curve_b[k, :]
)
expected.append(geod(self.times))
expected = gs.stack(expected, axis=1)
self.assertAllClose(result, expected)
def test_srv_metric_pointwise_inner_products(self):
curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b)
curves_bc = self.l2_metric_s2.geodesic(self.curve_b, self.curve_c)
curves_ab = curves_ab(self.times)
curves_bc = curves_bc(self.times)
tangent_vecs = self.l2_metric_s2.log(point=curves_bc, base_point=curves_ab)
result = self.srv_metric_r3.l2_metric.pointwise_inner_products(
tangent_vec_a=tangent_vecs, tangent_vec_b=tangent_vecs, base_curve=curves_ab
)
expected_shape = (self.n_discretized_curves, self.n_sampling_points)
self.assertAllClose(gs.shape(result), expected_shape)
result = self.srv_metric_r3.l2_metric.pointwise_inner_products(
tangent_vec_a=tangent_vecs[0],
tangent_vec_b=tangent_vecs[0],
base_curve=curves_ab[0],
)
expected_shape = (self.n_sampling_points,)
self.assertAllClose(gs.shape(result), expected_shape)
def test_srv_transform_and_inverse(self):
"""Test of SRVT and its inverse.
N.B: Here curves_ab are seen as curves in R3 and not S2.
"""
curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b)
curves_ab = curves_ab(self.times)
curves = curves_ab
srv_curves = self.srv_metric_r3.srv_transform(curves)
starting_points = curves[:, 0, :]
result = self.srv_metric_r3.srv_transform_inverse(srv_curves, starting_points)
expected = curves
self.assertAllClose(result, expected)
def test_srv_metric_exp_and_log(self):
"""Test that exp and log are inverse maps and vectorized.
N.B: Here curves_ab and curves_bc are seen as curves in R3 and not S2.
"""
curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b)
curves_bc = self.l2_metric_s2.geodesic(self.curve_b, self.curve_c)
curves_ab = curves_ab(self.times)
curves_bc = curves_bc(self.times)
log = self.srv_metric_r3.log(point=curves_bc, base_point=curves_ab)
result = self.srv_metric_r3.exp(tangent_vec=log, base_point=curves_ab)
expected = curves_bc
self.assertAllClose(gs.squeeze(result), expected)
def test_srv_metric_geodesic(self):
"""Test that the geodesic between two curves in a Euclidean space.
for the srv metric is the L2 geodesic betweeen the curves srvs.
N.B: Here curve_a and curve_b are seen as curves in R3 and not S2.
"""
geod = self.srv_metric_r3.geodesic(
initial_curve=self.curve_a, end_curve=self.curve_b
)
result = geod(self.times)
srv_a = self.srv_metric_r3.srv_transform(self.curve_a)
srv_b = self.srv_metric_r3.srv_transform(self.curve_b)
geod_srv = self.l2_metric_r3.geodesic(initial_point=srv_a, end_point=srv_b)
geod_srv = geod_srv(self.times)
starting_points = self.srv_metric_r3.ambient_metric.geodesic(
initial_point=self.curve_a[0, :], end_point=self.curve_b[0, :]
)
starting_points = starting_points(self.times)
expected = self.srv_metric_r3.srv_transform_inverse(geod_srv, starting_points)
self.assertAllClose(result, expected)
def test_srv_metric_dist_and_geod(self):
"""Test that the length of the geodesic gives the distance.
N.B: Here curve_a and curve_b are seen as curves in R3 and not S2.
"""
geod = self.srv_metric_r3.geodesic(
initial_curve=self.curve_a, end_curve=self.curve_b
)
geod = geod(self.times)
srv = self.srv_metric_r3.srv_transform(geod)
srv_derivative = self.n_discretized_curves * (srv[1:, :] - srv[:-1, :])
norms = self.srv_metric_r3.l2_metric.norm(srv_derivative)
result = gs.sum(norms, 0) / self.n_discretized_curves
expected = self.srv_metric_r3.dist(self.curve_a, self.curve_b)
self.assertAllClose(result, expected)
def test_random_and_belongs(self):
random = self.space_curves_in_sphere_2d.random_point()
result = self.space_curves_in_sphere_2d.belongs(random)
self.assertTrue(result)
self.assertAllClose(random.shape, (10, 3))
random = self.space_curves_in_sphere_2d.random_point(2)
result = self.space_curves_in_sphere_2d.belongs(random)
self.assertTrue(gs.all(result))
def test_is_tangent_to_tangent(self):
point = self.space_curves_in_sphere_2d.random_point()
vector = self.space_curves_in_sphere_2d.random_point()
tangent_vec = self.space_curves_in_sphere_2d.to_tangent(vector, point)
result = self.space_curves_in_sphere_2d.is_tangent(tangent_vec, point)
self.assertTrue(result)
point = self.space_curves_in_sphere_2d.random_point(2)
vector = self.space_curves_in_sphere_2d.random_point(2)
tangent_vec = self.space_curves_in_sphere_2d.to_tangent(vector, point)
result = self.space_curves_in_sphere_2d.is_tangent(tangent_vec, point)
self.assertTrue(gs.all(result))
@geomstats.tests.np_and_autograd_only
def test_projection_closed_curves(self):
"""Test that projecting the projection returns projection.
Also test that the projection is a closed curve.
"""
planar_closed_curves = self.space_closed_curves_in_euclidean_2d
cells, _, _ = data_utils.load_cells()
curves = [cell[:-10] for cell in cells[:5]]
for curve in curves:
proj = planar_closed_curves.project(curve)
expected = proj
result = planar_closed_curves.project(proj)
self.assertAllClose(result, expected)
result = proj[-1, :]
expected = proj[0, :]
self.assertAllClose(result, expected, rtol=10 * gs.rtol)
def test_srv_inner_product(self):
"""Test that srv_inner_product works as expected.
Also test that the resulting shape is right.
"""
curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b)
curves_bc = self.l2_metric_s2.geodesic(self.curve_b, self.curve_c)
curves_ab = curves_ab(self.times)
curves_bc = curves_bc(self.times)
srvs_ab = self.srv_metric_r3.srv_transform(curves_ab)
srvs_bc = self.srv_metric_r3.srv_transform(curves_bc)
result = self.srv_metric_r3.l2_metric.inner_product(srvs_ab, srvs_bc)
products = srvs_ab * srvs_bc
expected = [gs.sum(product) for product in products]
expected = gs.array(expected) / (srvs_ab.shape[-2] + 1)
self.assertAllClose(result, expected)
result = result.shape
expected = [srvs_ab.shape[0]]
self.assertAllClose(result, expected)
def test_srv_norm(self):
"""Test that srv_norm works as expected.
Also test that the resulting shape is right.
"""
curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b)
curves_ab = curves_ab(self.times)
srvs_ab = self.srv_metric_r3.srv_transform(curves_ab)
result = self.srv_metric_r3.l2_metric.norm(srvs_ab)
products = srvs_ab * srvs_ab
sums = [gs.sum(product) for product in products]
squared_norm = gs.array(sums) / (srvs_ab.shape[-2] + 1)
expected = gs.sqrt(squared_norm)
self.assertAllClose(result, expected)
result = result.shape
expected = [srvs_ab.shape[0]]
self.assertAllClose(result, expected)
def test_f_transform(self):
"""Test that the f transform coincides with the SRVF.
With the parameters: a=1, b=1/2.
"""
r2 = Euclidean(dim=2)
elastic_metric = ElasticMetric(a=1.0, b=0.5)
curves_r2 = DiscreteCurves(ambient_manifold=r2)
curve_a_projected = gs.stack((self.curve_a[:, 0], self.curve_a[:, 2]), axis=-1)
result = elastic_metric.f_transform(curve_a_projected)
expected = gs.squeeze(
curves_r2.square_root_velocity_metric.srv_transform(curve_a_projected)
)
self.assertAllClose(result, expected)
@geomstats.tests.np_autograd_and_tf_only
def test_f_transform_and_inverse(self):
"""Test that the inverse is right."""
cells, _, _ = data_utils.load_cells()
curve = cells[0]
metric = self.elastic_metric
f = metric.f_transform(curve)
f_inverse = metric.f_transform_inverse(f, curve[0])
result = f.shape
expected = (curve.shape[0] - 1, 2)
self.assertAllClose(result, expected)
result = f_inverse
expected = curve
self.assertAllClose(result, expected)
@geomstats.tests.np_autograd_and_torch_only
def test_elastic_dist(self):
"""Test shape and positivity."""
cells, _, _ = data_utils.load_cells()
curve_1, curve_2 = cells[0][:10], cells[1][:10]
metric = self.elastic_metric
dist = metric.dist(curve_1, curve_2)
result = dist.shape
expected = ()
self.assertAllClose(result, expected)
result = dist > 0
self.assertTrue(result)
@geomstats.tests.np_autograd_and_torch_only
def test_elastic_and_srv_dist(self):
"""Test that SRV dist and elastic dist coincide.
For a=1 and b=1/2.
"""
r2 = Euclidean(dim=2)
elastic_metric = ElasticMetric(a=1.0, b=0.5)
curves_r2 = DiscreteCurves(ambient_manifold=r2)
curve_a_projected = gs.stack((self.curve_a[:, 0], self.curve_a[:, 2]), axis=-1)
curve_b_projected = gs.stack((self.curve_b[:, 0], self.curve_b[:, 2]), axis=-1)
result = elastic_metric.dist(curve_a_projected, curve_b_projected)
expected = curves_r2.square_root_velocity_metric.dist(
curve_a_projected, curve_b_projected
)
print(result / expected)
self.assertAllClose(result, expected)
def test_cartesian_to_polar_and_inverse(self):
"""Test that going back to cartesian works."""
cells, _, _ = data_utils.load_cells()
curve = cells[0]
metric = self.elastic_metric
norms, args = metric.cartesian_to_polar(curve)
result = metric.polar_to_cartesian(norms, args)
expected = curve
self.assertAllClose(result, expected, rtol=10000 * gs.rtol)
@geomstats.tests.np_and_autograd_only
def test_aux_differential_srv_transform(self):
"""Test differential of square root velocity transform.
Check that its value at (curve, tangent_vec) coincides
with the derivative at zero of the square root velocity
transform of a path of curves starting at curve with
initial derivative tangent_vec.
"""
dim = 3
n_sampling_points = 2000
sampling_times = gs.linspace(0.0, 1.0, n_sampling_points)
curve_a = self.curve_fun_a(sampling_times)
tangent_vec = gs.transpose(
gs.tile(gs.linspace(1.0, 2.0, n_sampling_points), (dim, 1))
)
result = self.srv_metric_r3.aux_differential_srv_transform(tangent_vec, curve_a)
n_curves = 2000
times = gs.linspace(0.0, 1.0, n_curves)
path_of_curves = curve_a + gs.einsum("i,jk->ijk", times, tangent_vec)
srv_path = self.srv_metric_r3.srv_transform(path_of_curves)
expected = n_curves * (srv_path[1] - srv_path[0])
self.assertAllClose(result, expected, atol=1e-3, rtol=1e-3)
@geomstats.tests.np_and_autograd_only
def test_aux_differential_srv_transform_inverse(self):
"""Test inverse of differential of square root velocity transform.
Check that it is the inverse of aux_differential_srv_transform.
"""
dim = 3
tangent_vec = gs.transpose(
gs.tile(gs.linspace(0.0, 1.0, self.n_sampling_points), (dim, 1))
)
d_srv = self.srv_metric_r3.aux_differential_srv_transform(
tangent_vec, self.curve_a
)
result = self.srv_metric_r3.aux_differential_srv_transform_inverse(
d_srv, self.curve_a
)
expected = tangent_vec
self.assertAllClose(result, expected, atol=1e-3, rtol=1e-3)
def test_aux_differential_srv_transform_vectorization(self):
"""Test differential of square root velocity transform.
Check vectorization.
"""
dim = 3
curves = gs.stack((self.curve_a, self.curve_b))
tangent_vecs = gs.random.rand(2, self.n_sampling_points, dim)
result = self.srv_metric_r3.aux_differential_srv_transform(tangent_vecs, curves)
res_a = self.srv_metric_r3.aux_differential_srv_transform(
tangent_vecs[0], self.curve_a
)
res_b = self.srv_metric_r3.aux_differential_srv_transform(
tangent_vecs[1], self.curve_b
)
expected = gs.stack([res_a, res_b])
self.assertAllClose(result, expected)
def test_srv_inner_product_elastic(self):
"""Test inner product of SRVMetric.
Check that the pullback metric gives an elastic metric
with parameters a=1, b=1/2.
"""
tangent_vec_a = gs.random.rand(self.n_sampling_points, 3)
tangent_vec_b = gs.random.rand(self.n_sampling_points, 3)
result = self.srv_metric_r3.inner_product(
tangent_vec_a, tangent_vec_b, self.curve_a
)
r3 = Euclidean(3)
d_vec_a = (self.n_sampling_points - 1) * (
tangent_vec_a[1:, :] - tangent_vec_a[:-1, :]
)
d_vec_b = (self.n_sampling_points - 1) * (
tangent_vec_b[1:, :] - tangent_vec_b[:-1, :]
)
velocity_vec = (self.n_sampling_points - 1) * (
self.curve_a[1:, :] - self.curve_a[:-1, :]
)
velocity_norm = r3.metric.norm(velocity_vec)
unit_velocity_vec = gs.einsum("ij,i->ij", velocity_vec, 1 / velocity_norm)
a_param = 1
b_param = 1 / 2
integrand = (
a_param**2 * gs.sum(d_vec_a * d_vec_b, axis=1)
- (a_param**2 - b_param**2)
* gs.sum(d_vec_a * unit_velocity_vec, axis=1)
* gs.sum(d_vec_b * unit_velocity_vec, axis=1)
) / velocity_norm
expected = gs.sum(integrand) / self.n_sampling_points
self.assertAllClose(result, expected)
def test_srv_inner_product_and_dist(self):
"""Test that norm of log and dist coincide
for curves with same / different starting points, and for
the translation invariant / non invariant SRV metric.
"""
r3 = Euclidean(dim=3)
curve_b_transl = self.curve_b + gs.array([1.0, 0.0, 0.0])
curve_b = [self.curve_b, curve_b_transl]
translation_invariant = [True, False]
for curve in curve_b:
for param in translation_invariant:
srv_metric = SRVMetric(ambient_manifold=r3, translation_invariant=param)
log = srv_metric.log(point=curve, base_point=self.curve_a)
result = srv_metric.norm(vector=log, base_point=self.curve_a)
expected = srv_metric.dist(self.curve_a, curve)
self.assertAllClose(result, expected)
def test_srv_inner_product_vectorization(self):
"""Test inner product of SRVMetric.
Check vectorization.
"""
dim = 3
curves = gs.stack((self.curve_a, self.curve_b))
tangent_vecs_1 = gs.random.rand(2, self.n_sampling_points, dim)
tangent_vecs_2 = gs.random.rand(2, self.n_sampling_points, dim)
result = self.srv_metric_r3.inner_product(
tangent_vecs_1, tangent_vecs_2, curves
)
res_a = self.srv_metric_r3.inner_product(
tangent_vecs_1[0], tangent_vecs_2[0], self.curve_a
)
res_b = self.srv_metric_r3.inner_product(
tangent_vecs_1[1], tangent_vecs_2[1], self.curve_b
)
expected = gs.stack((res_a, res_b))
self.assertAllClose(result, expected)
@geomstats.tests.np_autograd_and_torch_only
def test_split_horizontal_vertical(self):
"""Test split horizontal vertical.
Check that horizontal and vertical parts of any tangent
vector are othogonal with respect to the SRVMetric inner
product, and check vectorization.
"""
geod = self.srv_metric_r3.geodesic(
initial_curve=self.curve_a, end_curve=self.curve_b
)
geod = geod(self.times)
tangent_vec = self.n_discretized_curves * (geod[1, :, :] - geod[0, :, :])
(
tangent_vec_hor,
tangent_vec_ver,
_,
) = self.quotient_srv_metric_r3.split_horizontal_vertical(
tangent_vec, self.curve_a
)
result = self.srv_metric_r3.inner_product(
tangent_vec_hor, tangent_vec_ver, self.curve_a
)
expected = 0.0
self.assertAllClose(result, expected, atol=1e-4)
tangent_vecs = self.n_discretized_curves * (geod[1:] - geod[:-1])
_, _, result = self.quotient_srv_metric_r3.split_horizontal_vertical(
tangent_vecs, geod[:-1]
)
expected = []
for i in range(self.n_discretized_curves - 1):
_, _, res = self.quotient_srv_metric_r3.split_horizontal_vertical(
tangent_vecs[i], geod[i]
)
expected.append(res)
expected = gs.stack(expected)
self.assertAllClose(result, expected)
def test_space_derivative(self):
"""Test space derivative.
Check result on an example and vectorization.
"""
n_points = 3
dim = 3
curve = gs.random.rand(n_points, dim)
result = self.srv_metric_r3.space_derivative(curve)
delta = 1 / n_points
d_curve_1 = (curve[1] - curve[0]) / delta
d_curve_2 = (curve[2] - curve[0]) / (2 * delta)
d_curve_3 = (curve[2] - curve[1]) / delta
expected = gs.squeeze(
gs.vstack(
(
gs.to_ndarray(d_curve_1, 2),
gs.to_ndarray(d_curve_2, 2),
gs.to_ndarray(d_curve_3, 2),
)
)
)
self.assertAllClose(result, expected)
path_of_curves = gs.random.rand(
self.n_discretized_curves, self.n_sampling_points, dim
)
result = self.srv_metric_r3.space_derivative(path_of_curves)
expected = []
for i in range(self.n_discretized_curves):
expected.append(self.srv_metric_r3.space_derivative(path_of_curves[i]))
expected = gs.stack(expected)
self.assertAllClose(result, expected)
@geomstats.tests.np_autograd_and_torch_only
def test_horizontal_geodesic(self):
"""Test horizontal geodesic.
Check that the time derivative of the geodesic is
horizontal at all time.
"""
curve_b = gs.transpose(
gs.stack(
(
gs.zeros(self.n_sampling_points),
gs.zeros(self.n_sampling_points),
gs.linspace(1.0, 0.5, self.n_sampling_points),
)
)
)
horizontal_geod_fun = self.quotient_srv_metric_r3.horizontal_geodesic(
self.curve_a, curve_b
)
n_times = 20
times = gs.linspace(0.0, 1.0, n_times)
horizontal_geod = horizontal_geod_fun(times)
velocity_vec = n_times * (horizontal_geod[1:] - horizontal_geod[:-1])
_, _, vertical_norms = self.quotient_srv_metric_r3.split_horizontal_vertical(
velocity_vec, horizontal_geod[:-1]
)
result = gs.sum(vertical_norms**2, axis=1) ** (1 / 2)
expected = gs.zeros(n_times - 1)
self.assertAllClose(result, expected, atol=1e-3)
@geomstats.tests.np_autograd_and_torch_only
def test_quotient_dist(self):
"""Test quotient distance.
Check that the quotient distance is the same as the distance
between the end points of the horizontal geodesic.
"""
curve_a_resampled = self.curve_fun_a(self.sampling_times**2)
curve_b = gs.transpose(
gs.stack(
(
gs.zeros(self.n_sampling_points),
gs.zeros(self.n_sampling_points),
gs.linspace(1.0, 0.5, self.n_sampling_points),
)
)
)
result = self.quotient_srv_metric_r3.dist(curve_a_resampled, curve_b)
expected = self.quotient_srv_metric_r3.dist(self.curve_a, curve_b)
self.assertAllClose(result, expected, atol=1e-3, rtol=1e-3)
class TestFrechetMean(geomstats.tests.TestCase):
_multiprocess_can_split_ = True
def setup_method(self):
gs.random.seed(123)
self.sphere = Hypersphere(dim=4)
self.hyperbolic = Hyperboloid(dim=3)
self.euclidean = Euclidean(dim=2)
self.minkowski = Minkowski(dim=2)
self.so3 = SpecialOrthogonal(n=3, point_type="vector")
self.so_matrix = SpecialOrthogonal(n=3)
self.curves_2d = DiscreteCurves(R2)
self.elastic_metric = ElasticMetric(a=1, b=1, ambient_manifold=R2)
def test_logs_at_mean_curves_2d(self):
n_tests = 10
metric = self.curves_2d.srv_metric
estimator = FrechetMean(metric=metric, init_step_size=1.0)
result = []
for _ in range(n_tests):
# take 2 random points, compute their mean, and verify that
# log of each at the mean is opposite
points = self.curves_2d.random_point(n_samples=2)
estimator.fit(points)
mean = estimator.estimate_
# Expand and tile are added because of GitHub issue 1575
mean = gs.expand_dims(mean, axis=0)
mean = gs.tile(mean, (2, 1, 1))
logs = metric.log(point=points, base_point=mean)
logs_srv = metric.aux_differential_srv_transform(logs, curve=mean)
# Note that the logs are NOT inverse, only the logs_srv are.
result.append(gs.linalg.norm(logs_srv[1, :] + logs_srv[0, :]))
result = gs.stack(result)
expected = gs.zeros(n_tests)
self.assertAllClose(expected, result, atol=1e-5)
def test_logs_at_mean_default_gradient_descent_sphere(self):
n_tests = 10
estimator = FrechetMean(metric=self.sphere.metric,
method="default",
init_step_size=1.0)
result = []
for _ in range(n_tests):
# take 2 random points, compute their mean, and verify that
# log of each at the mean is opposite
points = self.sphere.random_uniform(n_samples=2)
estimator.fit(points)
mean = estimator.estimate_
logs = self.sphere.metric.log(point=points, base_point=mean)
result.append(gs.linalg.norm(logs[1, :] + logs[0, :]))
result = gs.stack(result)
expected = gs.zeros(n_tests)
self.assertAllClose(expected, result)
def test_logs_at_mean_adaptive_gradient_descent_sphere(self):
n_tests = 10
estimator = FrechetMean(metric=self.sphere.metric, method="adaptive")
result = []
for _ in range(n_tests):
# take 2 random points, compute their mean, and verify that
# log of each at the mean is opposite
points = self.sphere.random_uniform(n_samples=2)
estimator.fit(points)
mean = estimator.estimate_
logs = self.sphere.metric.log(point=points, base_point=mean)
result.append(gs.linalg.norm(logs[1, :] + logs[0, :]))
result = gs.stack(result)
expected = gs.zeros(n_tests)
self.assertAllClose(expected, result)
def test_estimate_shape_default_gradient_descent_sphere(self):
dim = 5
point_a = gs.array([1.0, 0.0, 0.0, 0.0, 0.0])
point_b = gs.array([0.0, 1.0, 0.0, 0.0, 0.0])
points = gs.array([point_a, point_b])
mean = FrechetMean(metric=self.sphere.metric,
method="default",
verbose=True)
mean.fit(points)
result = mean.estimate_
self.assertAllClose(gs.shape(result), (dim, ))
def test_estimate_shape_adaptive_gradient_descent_sphere(self):
dim = 5
point_a = gs.array([1.0, 0.0, 0.0, 0.0, 0.0])
point_b = gs.array([0.0, 1.0, 0.0, 0.0, 0.0])
points = gs.array([point_a, point_b])
mean = FrechetMean(metric=self.sphere.metric, method="adaptive")
mean.fit(points)
result = mean.estimate_
self.assertAllClose(gs.shape(result), (dim, ))
def test_estimate_shape_elastic_metric(self):
points = self.curves_2d.random_point(n_samples=2)
mean = FrechetMean(metric=self.elastic_metric)
mean.fit(points)
result = mean.estimate_
self.assertAllClose(gs.shape(result), (points.shape[1:]))
def test_estimate_shape_metric(self):
points = self.curves_2d.random_point(n_samples=2)
mean = FrechetMean(metric=self.curves_2d.srv_metric)
mean.fit(points)
result = mean.estimate_
self.assertAllClose(gs.shape(result), (points.shape[1:]))
def test_estimate_and_belongs_default_gradient_descent_sphere(self):
point_a = gs.array([1.0, 0.0, 0.0, 0.0, 0.0])
point_b = gs.array([0.0, 1.0, 0.0, 0.0, 0.0])
points = gs.array([point_a, point_b])
mean = FrechetMean(metric=self.sphere.metric, method="default")
mean.fit(points)
result = self.sphere.belongs(mean.estimate_)
expected = True
self.assertAllClose(result, expected)
def test_estimate_and_belongs_curves_2d(self):
points = self.curves_2d.random_point(n_samples=2)
mean = FrechetMean(metric=self.curves_2d.srv_metric)
mean.fit(points)
result = self.curves_2d.belongs(mean.estimate_)
expected = True
self.assertAllClose(result, expected)
def test_estimate_default_gradient_descent_so3(self):
points = self.so3.random_uniform(2)
mean_vec = FrechetMean(metric=self.so3.bi_invariant_metric,
method="default",
init_step_size=1.0)
mean_vec.fit(points)
logs = self.so3.bi_invariant_metric.log(points, mean_vec.estimate_)
result = gs.sum(logs, axis=0)
expected = gs.zeros_like(points[0])
self.assertAllClose(result, expected)
def test_estimate_and_belongs_default_gradient_descent_so3(self):
point = self.so3.random_uniform(10)
mean_vec = FrechetMean(metric=self.so3.bi_invariant_metric,
method="default")
mean_vec.fit(point)
result = self.so3.belongs(mean_vec.estimate_)
expected = True
self.assertAllClose(result, expected)
@geomstats.tests.np_autograd_and_tf_only
def test_estimate_default_gradient_descent_so_matrix(self):
points = self.so_matrix.random_uniform(2)
mean_vec = FrechetMean(
metric=self.so_matrix.bi_invariant_metric,
method="default",
init_step_size=1.0,
)
mean_vec.fit(points)
logs = self.so_matrix.bi_invariant_metric.log(points,
mean_vec.estimate_)
result = gs.sum(logs, axis=0)
expected = gs.zeros_like(points[0])
self.assertAllClose(result, expected, atol=1e-5)
@geomstats.tests.np_autograd_and_tf_only
def test_estimate_and_belongs_default_gradient_descent_so_matrix(self):
point = self.so_matrix.random_uniform(10)
mean = FrechetMean(metric=self.so_matrix.bi_invariant_metric,
method="default")
mean.fit(point)
result = self.so_matrix.belongs(mean.estimate_)
expected = True
self.assertAllClose(result, expected)
@geomstats.tests.np_autograd_and_tf_only
def test_estimate_and_belongs_adaptive_gradient_descent_so_matrix(self):
point = self.so_matrix.random_uniform(10)
mean = FrechetMean(
metric=self.so_matrix.bi_invariant_metric,
method="adaptive",
init_step_size=0.5,
verbose=True,
)
mean.fit(point)
result = self.so_matrix.belongs(mean.estimate_)
self.assertTrue(result)
@geomstats.tests.np_autograd_and_tf_only
def test_estimate_and_coincide_default_so_vec_and_mat(self):
point = self.so_matrix.random_uniform(3)
mean = FrechetMean(metric=self.so_matrix.bi_invariant_metric,
method="default")
mean.fit(point)
expected = mean.estimate_
mean_vec = FrechetMean(metric=self.so3.bi_invariant_metric,
method="default")
point_vec = self.so3.rotation_vector_from_matrix(point)
mean_vec.fit(point_vec)
result_vec = mean_vec.estimate_
result = self.so3.matrix_from_rotation_vector(result_vec)
self.assertAllClose(result, expected)
def test_estimate_and_belongs_adaptive_gradient_descent_sphere(self):
point_a = gs.array([1.0, 0.0, 0.0, 0.0, 0.0])
point_b = gs.array([0.0, 1.0, 0.0, 0.0, 0.0])
points = gs.array([point_a, point_b])
mean = FrechetMean(metric=self.sphere.metric, method="adaptive")
mean.fit(points)
result = self.sphere.belongs(mean.estimate_)
expected = True
self.assertAllClose(result, expected)
def test_variance_sphere(self):
point = gs.array([0.0, 0.0, 0.0, 0.0, 1.0])
points = gs.array([point, point])
result = variance(points, base_point=point, metric=self.sphere.metric)
expected = gs.array(0.0)
self.assertAllClose(expected, result)
def test_estimate_default_gradient_descent_sphere(self):
point = gs.array([0.0, 0.0, 0.0, 0.0, 1.0])
points = gs.array([point, point])
mean = FrechetMean(metric=self.sphere.metric, method="default")
mean.fit(X=points)
result = mean.estimate_
expected = point
self.assertAllClose(expected, result)
def test_estimate_elastic_metric(self):
point = self.curves_2d.random_point(n_samples=1)
points = gs.array([point, point])
mean = FrechetMean(metric=self.elastic_metric)
mean.fit(X=points)
result = mean.estimate_
expected = point
self.assertAllClose(expected, result)
def test_estimate_curves_2d(self):
point = self.curves_2d.random_point(n_samples=1)
points = gs.array([point, point])
mean = FrechetMean(metric=self.curves_2d.srv_metric)
mean.fit(X=points)
result = mean.estimate_
expected = point
self.assertAllClose(expected, result)
def test_estimate_adaptive_gradient_descent_sphere(self):
point = gs.array([0.0, 0.0, 0.0, 0.0, 1.0])
points = gs.array([point, point])
mean = FrechetMean(metric=self.sphere.metric, method="adaptive")
mean.fit(X=points)
result = mean.estimate_
expected = point
self.assertAllClose(expected, result)
def test_estimate_spd(self):
point = SPDMatrices(3).random_point()
points = gs.array([point, point])
mean = FrechetMean(metric=SPDMetricAffine(3), point_type="matrix")
mean.fit(X=points)
result = mean.estimate_
expected = point
self.assertAllClose(expected, result)
def test_estimate_spd_two_samples(self):
space = SPDMatrices(3)
metric = SPDMetricAffine(3)
point = space.random_point(2)
mean = FrechetMean(metric)
mean.fit(point)
result = mean.estimate_
expected = metric.exp(metric.log(point[0], point[1]) / 2, point[1])
self.assertAllClose(expected, result)
def test_variance_hyperbolic(self):
point = gs.array([2.0, 1.0, 1.0, 1.0])
points = gs.array([point, point])
result = variance(points,
base_point=point,
metric=self.hyperbolic.metric)
expected = gs.array(0.0)
self.assertAllClose(result, expected)
def test_estimate_hyperbolic(self):
point = gs.array([2.0, 1.0, 1.0, 1.0])
points = gs.array([point, point])
mean = FrechetMean(metric=self.hyperbolic.metric)
mean.fit(X=points)
expected = point
result = mean.estimate_
self.assertAllClose(result, expected)
def test_estimate_and_belongs_hyperbolic(self):
point_a = self.hyperbolic.random_point()
point_b = self.hyperbolic.random_point()
point_c = self.hyperbolic.random_point()
points = gs.stack([point_a, point_b, point_c], axis=0)
mean = FrechetMean(metric=self.hyperbolic.metric)
mean.fit(X=points)
result = self.hyperbolic.belongs(mean.estimate_)
expected = True
self.assertAllClose(result, expected)
def test_mean_euclidean_shape(self):
dim = 2
point = gs.array([1.0, 4.0])
mean = FrechetMean(metric=self.euclidean.metric)
points = [point, point, point]
mean.fit(points)
result = mean.estimate_
self.assertAllClose(gs.shape(result), (dim, ))
def test_mean_euclidean(self):
point = gs.array([1.0, 4.0])
mean = FrechetMean(metric=self.euclidean.metric)
points = [point, point, point]
mean.fit(points)
result = mean.estimate_
expected = point
self.assertAllClose(result, expected)
points = gs.array([[1.0, 2.0], [2.0, 3.0], [3.0, 4.0], [4.0, 5.0]])
weights = [1.0, 2.0, 1.0, 2.0]
mean = FrechetMean(metric=self.euclidean.metric)
mean.fit(points, weights=weights)
result = mean.estimate_
expected = gs.array([16.0 / 6.0, 22.0 / 6.0])
self.assertAllClose(result, expected)
def test_variance_euclidean(self):
points = gs.array([[1.0, 2.0], [2.0, 3.0], [3.0, 4.0], [4.0, 5.0]])
weights = gs.array([1.0, 2.0, 1.0, 2.0])
base_point = gs.zeros(2)
result = variance(points,
weights=weights,
base_point=base_point,
metric=self.euclidean.metric)
# we expect the average of the points' sq norms.
expected = gs.array((1 * 5.0 + 2 * 13.0 + 1 * 25.0 + 2 * 41.0) / 6.0)
self.assertAllClose(result, expected)
def test_mean_matrices_shape(self):
m, n = (2, 2)
point = gs.array([[1.0, 4.0], [2.0, 3.0]])
metric = MatricesMetric(m, n)
mean = FrechetMean(metric=metric, point_type="matrix")
points = [point, point, point]
mean.fit(points)
result = mean.estimate_
self.assertAllClose(gs.shape(result), (m, n))
def test_mean_matrices(self):
m, n = (2, 2)
point = gs.array([[1.0, 4.0], [2.0, 3.0]])
metric = MatricesMetric(m, n)
mean = FrechetMean(metric=metric, point_type="matrix")
points = [point, point, point]
mean.fit(points)
result = mean.estimate_
expected = point
self.assertAllClose(result, expected)
def test_mean_minkowski_shape(self):
dim = 2
point = gs.array([2.0, -math.sqrt(3)])
points = [point, point, point]
mean = FrechetMean(metric=self.minkowski.metric)
mean.fit(points)
result = mean.estimate_
self.assertAllClose(gs.shape(result), (dim, ))
def test_mean_minkowski(self):
point = gs.array([2.0, -math.sqrt(3)])
points = [point, point, point]
mean = FrechetMean(metric=self.minkowski.metric)
mean.fit(points)
result = mean.estimate_
expected = point
self.assertAllClose(result, expected)
points = gs.array([[1.0, 0.0], [2.0, math.sqrt(3)],
[3.0, math.sqrt(8)], [4.0, math.sqrt(24)]])
weights = gs.array([1.0, 2.0, 1.0, 2.0])
mean = FrechetMean(metric=self.minkowski.metric)
mean.fit(points, weights=weights)
result = self.minkowski.belongs(mean.estimate_)
self.assertTrue(result)
def test_variance_minkowski(self):
points = gs.array([[1.0, 0.0], [2.0, math.sqrt(3)],
[3.0, math.sqrt(8)], [4.0, math.sqrt(24)]])
weights = gs.array([1.0, 2.0, 1.0, 2.0])
base_point = gs.array([-1.0, 0.0])
var = variance(points,
weights=weights,
base_point=base_point,
metric=self.minkowski.metric)
result = var != 0
# we expect the average of the points' Minkowski sq norms.
expected = True
self.assertAllClose(result, expected)
def test_one_point(self):
point = gs.array([0.0, 0.0, 0.0, 0.0, 1.0])
mean = FrechetMean(metric=self.sphere.metric, method="default")
mean.fit(X=point)
result = mean.estimate_
expected = point
self.assertAllClose(expected, result)
mean = FrechetMean(metric=self.sphere.metric, method="default")
mean.fit(X=point)
result = mean.estimate_
expected = point
self.assertAllClose(expected, result)
def test_batched(self):
space = SPDMatrices(3)
metric = SPDMetricAffine(3)
point = space.random_point(4)
mean_batch = FrechetMean(metric, method="batch", verbose=True)
data = gs.stack([point[:2], point[2:]], axis=1)
mean_batch.fit(data)
result = mean_batch.estimate_
mean = FrechetMean(metric)
mean.fit(data[:, 0])
expected_1 = mean.estimate_
mean.fit(data[:, 1])
expected_2 = mean.estimate_
expected = gs.stack([expected_1, expected_2])
self.assertAllClose(expected, result)
@geomstats.tests.np_and_autograd_only
def test_stiefel_two_samples(self):
space = Stiefel(3, 2)
metric = space.metric
point = space.random_point(2)
mean = FrechetMean(metric)
mean.fit(point)
result = mean.estimate_
expected = metric.exp(metric.log(point[0], point[1]) / 2, point[1])
self.assertAllClose(expected, result)
@geomstats.tests.np_and_autograd_only
def test_stiefel_n_samples(self):
space = Stiefel(3, 2)
metric = space.metric
point = space.random_point(2)
mean = FrechetMean(metric,
method="default",
init_step_size=0.5,
verbose=True)
mean.fit(point)
result = space.belongs(mean.estimate_)
self.assertTrue(result)
def test_circle_mean(self):
space = Hypersphere(1)
points = space.random_uniform(10)
mean_circle = FrechetMean(space.metric)
mean_circle.fit(points)
estimate_circle = mean_circle.estimate_
# set a wrong dimension so that the extrinsic coordinates are used
metric = space.metric
metric.dim = 2
mean_extrinsic = FrechetMean(metric)
mean_extrinsic.fit(points)
estimate_extrinsic = mean_extrinsic.estimate_
self.assertAllClose(estimate_circle, estimate_extrinsic)
class TestDiscreteCurves(geomstats.tests.TestCase):
def setUp(self):
s2 = Hypersphere(dim=2)
r3 = s2.embedding_space
initial_point = [0., 0., 1.]
initial_tangent_vec_a = [1., 0., 0.]
initial_tangent_vec_b = [0., 1., 0.]
initial_tangent_vec_c = [-1., 0., 0.]
curve_a = s2.metric.geodesic(initial_point=initial_point,
initial_tangent_vec=initial_tangent_vec_a)
curve_b = s2.metric.geodesic(initial_point=initial_point,
initial_tangent_vec=initial_tangent_vec_b)
curve_c = s2.metric.geodesic(initial_point=initial_point,
initial_tangent_vec=initial_tangent_vec_c)
self.n_sampling_points = 10
sampling_times = gs.linspace(0., 1., self.n_sampling_points)
discretized_curve_a = curve_a(sampling_times)
discretized_curve_b = curve_b(sampling_times)
discretized_curve_c = curve_c(sampling_times)
self.n_discretized_curves = 5
self.times = gs.linspace(0., 1., self.n_discretized_curves)
gs.random.seed(1234)
self.space_curves_in_euclidean_3d = DiscreteCurves(ambient_manifold=r3)
self.space_curves_in_sphere_2d = DiscreteCurves(ambient_manifold=s2)
self.l2_metric_s2 = self.space_curves_in_sphere_2d.l2_metric(
self.n_sampling_points)
self.l2_metric_r3 = self.space_curves_in_euclidean_3d.l2_metric(
self.n_sampling_points)
self.srv_metric_r3 = self.space_curves_in_euclidean_3d.\
square_root_velocity_metric
self.curve_a = discretized_curve_a
self.curve_b = discretized_curve_b
self.curve_c = discretized_curve_c
def test_belongs(self):
result = self.space_curves_in_sphere_2d.belongs(self.curve_a)
self.assertTrue(result)
curve_ab = [self.curve_a[:-1], self.curve_b]
result = self.space_curves_in_sphere_2d.belongs(curve_ab)
self.assertTrue(gs.all(result))
curve_ab = gs.array([self.curve_a, self.curve_b])
result = self.space_curves_in_sphere_2d.belongs(curve_ab)
self.assertTrue(gs.all(result))
def test_l2_metric_log_and_squared_norm_and_dist(self):
"""Test that squared norm of logarithm is squared dist."""
tangent_vec = self.l2_metric_s2.log(point=self.curve_b,
base_point=self.curve_a)
log_ab = tangent_vec
result = self.l2_metric_s2.squared_norm(vector=log_ab,
base_point=self.curve_a)
expected = self.l2_metric_s2.dist(self.curve_a, self.curve_b)**2
self.assertAllClose(result, expected)
def test_l2_metric_log_and_exp(self):
"""Test that exp and log are inverse maps."""
tangent_vec = self.l2_metric_s2.log(point=self.curve_b,
base_point=self.curve_a)
result = self.l2_metric_s2.exp(tangent_vec=tangent_vec,
base_point=self.curve_a)
expected = self.curve_b
self.assertAllClose(result, expected)
def test_l2_metric_inner_product_vectorization(self):
"""Test the vectorization inner_product."""
n_samples = self.n_discretized_curves
curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b)
curves_bc = self.l2_metric_s2.geodesic(self.curve_b, self.curve_c)
curves_ab = curves_ab(self.times)
curves_bc = curves_bc(self.times)
tangent_vecs = self.l2_metric_s2.log(point=curves_bc,
base_point=curves_ab)
result = self.l2_metric_s2.inner_product(tangent_vecs, tangent_vecs,
curves_ab)
self.assertAllClose(gs.shape(result), (n_samples, ))
def test_l2_metric_dist_vectorization(self):
"""Test the vectorization of dist."""
n_samples = self.n_discretized_curves
curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b)
curves_bc = self.l2_metric_s2.geodesic(self.curve_b, self.curve_c)
curves_ab = curves_ab(self.times)
curves_bc = curves_bc(self.times)
result = self.l2_metric_s2.dist(curves_ab, curves_bc)
self.assertAllClose(gs.shape(result), (n_samples, ))
def test_l2_metric_exp_vectorization(self):
"""Test the vectorization of exp."""
curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b)
curves_bc = self.l2_metric_s2.geodesic(self.curve_b, self.curve_c)
curves_ab = curves_ab(self.times)
curves_bc = curves_bc(self.times)
tangent_vecs = self.l2_metric_s2.log(point=curves_bc,
base_point=curves_ab)
result = self.l2_metric_s2.exp(tangent_vec=tangent_vecs,
base_point=curves_ab)
self.assertAllClose(gs.shape(result), gs.shape(curves_ab))
def test_l2_metric_log_vectorization(self):
"""Test the vectorization of log."""
curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b)
curves_bc = self.l2_metric_s2.geodesic(self.curve_b, self.curve_c)
curves_ab = curves_ab(self.times)
curves_bc = curves_bc(self.times)
tangent_vecs = self.l2_metric_s2.log(point=curves_bc,
base_point=curves_ab)
result = tangent_vecs
self.assertAllClose(gs.shape(result), gs.shape(curves_ab))
def test_l2_metric_geodesic(self):
"""Test the geodesic method of L2Metric."""
curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b)
curves_ab = curves_ab(self.times)
result = curves_ab
expected = []
for k in range(self.n_sampling_points):
geod = self.l2_metric_s2.ambient_metric.geodesic(
initial_point=self.curve_a[k, :], end_point=self.curve_b[k, :])
expected.append(geod(self.times))
expected = gs.stack(expected, axis=1)
self.assertAllClose(result, expected)
def test_srv_metric_pointwise_inner_product(self):
curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b)
curves_bc = self.l2_metric_s2.geodesic(self.curve_b, self.curve_c)
curves_ab = curves_ab(self.times)
curves_bc = curves_bc(self.times)
tangent_vecs = self.l2_metric_s2.log(point=curves_bc,
base_point=curves_ab)
result = self.srv_metric_r3.pointwise_inner_product(
tangent_vec_a=tangent_vecs,
tangent_vec_b=tangent_vecs,
base_curve=curves_ab)
expected_shape = (self.n_discretized_curves, self.n_sampling_points)
self.assertAllClose(gs.shape(result), expected_shape)
result = self.srv_metric_r3.pointwise_inner_product(
tangent_vec_a=tangent_vecs[0],
tangent_vec_b=tangent_vecs[0],
base_curve=curves_ab[0])
expected_shape = (self.n_sampling_points, )
self.assertAllClose(gs.shape(result), expected_shape)
def test_square_root_velocity_and_inverse(self):
"""Test of square_root_velocity and its inverse.
N.B: Here curves_ab are seen as curves in R3 and not S2.
"""
curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b)
curves_ab = curves_ab(self.times)
curves = curves_ab
srv_curves = self.srv_metric_r3.square_root_velocity(curves)
starting_points = curves[:, 0, :]
result = self.srv_metric_r3.square_root_velocity_inverse(
srv_curves, starting_points)
expected = curves
self.assertAllClose(result, expected)
def test_srv_metric_exp_and_log(self):
"""Test that exp and log are inverse maps and vectorized.
N.B: Here curves_ab and curves_bc are seen as curves in R3 and not S2.
"""
curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b)
curves_bc = self.l2_metric_s2.geodesic(self.curve_b, self.curve_c)
curves_ab = curves_ab(self.times)
curves_bc = curves_bc(self.times)
log = self.srv_metric_r3.log(point=curves_bc, base_point=curves_ab)
result = self.srv_metric_r3.exp(tangent_vec=log, base_point=curves_ab)
expected = curves_bc
self.assertAllClose(gs.squeeze(result), expected)
def test_srv_metric_geodesic(self):
"""Test that the geodesic between two curves in a Euclidean space.
for the srv metric is the L2 geodesic betweeen the curves srvs.
N.B: Here curve_a and curve_b are seen as curves in R3 and not S2.
"""
geod = self.srv_metric_r3.geodesic(initial_curve=self.curve_a,
end_curve=self.curve_b)
result = geod(self.times)
srv_a = self.srv_metric_r3.square_root_velocity(self.curve_a)
srv_b = self.srv_metric_r3.square_root_velocity(self.curve_b)
l2_metric = self.space_curves_in_euclidean_3d.l2_metric(
self.n_sampling_points - 1)
geod_srv = l2_metric.geodesic(initial_point=srv_a, end_point=srv_b)
geod_srv = geod_srv(self.times)
starting_points = self.srv_metric_r3.ambient_metric.geodesic(
initial_point=self.curve_a[0, :], end_point=self.curve_b[0, :])
starting_points = starting_points(self.times)
expected = self.srv_metric_r3.square_root_velocity_inverse(
geod_srv, starting_points)
self.assertAllClose(result, expected)
def test_srv_metric_dist_and_geod(self):
"""Test that the length of the geodesic gives the distance.
N.B: Here curve_a and curve_b are seen as curves in R3 and not S2.
"""
geod = self.srv_metric_r3.geodesic(initial_curve=self.curve_a,
end_curve=self.curve_b)
geod = geod(self.times)
srv = self.srv_metric_r3.square_root_velocity(geod)
srv_derivative = self.n_discretized_curves * (srv[1:, :] - srv[:-1, :])
l2_metric = self.space_curves_in_euclidean_3d.l2_metric(
self.n_sampling_points - 1)
norms = l2_metric.norm(srv_derivative, geod[:-1, :-1, :])
result = gs.sum(norms, 0) / self.n_discretized_curves
expected = self.srv_metric_r3.dist(self.curve_a, self.curve_b)[0]
self.assertAllClose(result, expected)
def test_random_and_belongs(self):
random = self.space_curves_in_sphere_2d.random_point()
result = self.space_curves_in_sphere_2d.belongs(random)
self.assertTrue(result)
self.assertAllClose(random.shape, (10, 3))
random = self.space_curves_in_sphere_2d.random_point(2)
result = self.space_curves_in_sphere_2d.belongs(random)
self.assertTrue(gs.all(result))
def test_is_tangent_to_tangent(self):
point = self.space_curves_in_sphere_2d.random_point()
vector = self.space_curves_in_sphere_2d.random_point()
tangent_vec = self.space_curves_in_sphere_2d.to_tangent(vector, point)
result = self.space_curves_in_sphere_2d.is_tangent(tangent_vec, point)
self.assertTrue(result)
point = self.space_curves_in_sphere_2d.random_point(2)
vector = self.space_curves_in_sphere_2d.random_point(2)
tangent_vec = self.space_curves_in_sphere_2d.to_tangent(vector, point)
result = self.space_curves_in_sphere_2d.is_tangent(tangent_vec, point)
self.assertTrue(gs.all(result))