def setup_method(self):
"""Define the parameters of the tests."""
warnings.simplefilter("ignore", category=UserWarning)
self.beta = BetaDistributions()
self.metric = BetaMetric()
self.n_samples = 10
self.dim = self.beta.dim
def test_point_to_pdf_vectorization(self, x):
point = BetaDistributions().random_point(n_samples=2)
pdf = BetaDistributions().point_to_pdf(point)
result = pdf(x)
pdf1 = beta.pdf(x, a=point[0, 0], b=point[0, 1])
pdf2 = beta.pdf(x, a=point[1, 0], b=point[1, 1])
expected = gs.stack([gs.array(pdf1), gs.array(pdf2)], axis=1)
self.assertAllClose(result, expected)
def test_christoffels_shape(self, n_samples):
"""Test Christoffel synbols.
Check vectorization of Christoffel symbols.
"""
points = BetaDistributions().random_point(n_samples)
dim = BetaDistributions().dim
christoffel = self.metric().christoffels(points)
result = christoffel.shape
expected = gs.array([n_samples, dim, dim, dim])
self.assertAllClose(result, expected)
def test_leaves(self):
"""Test that leaves data are beta distribution parameters."""
beta = BetaDistributions()
beta_param, distrib_type = data_utils.load_leaves()
result = beta.belongs(beta_param)
self.assertTrue(gs.all(result))
result = len(distrib_type)
expected = beta_param.shape[0]
self.assertAllClose(result, expected)
def test_exp(self, n_samples):
"""Test Exp.
Test that the Riemannian exponential at points on the first
bisector computed in the direction of the first bisector stays
on the first bisector.
"""
points = BetaDistributions().random_point(n_samples)
vectors = BetaDistributions().random_point(n_samples)
initial_vectors = gs.array([[vec_x, vec_x] for vec_x in vectors[:, 0]])
points = gs.array([[param_a, param_a] for param_a in points[:, 0]])
result_points = self.metric().exp(initial_vectors, points)
result = gs.isclose(result_points[:, 0], result_points[:, 1]).all()
expected = gs.array([True] * n_samples)
self.assertAllClose(expected, result)
class TestBetaDistributions(geomstats.tests.TestCase):
"""Class defining the beta distributions tests."""
def setup_method(self):
"""Define the parameters of the tests."""
warnings.simplefilter("ignore", category=UserWarning)
self.beta = BetaDistributions()
self.metric = BetaMetric()
self.n_samples = 10
self.dim = self.beta.dim
def test_random_uniform_and_belongs(self):
"""Test random_uniform and belongs.
Test that the random uniform method samples
on the beta distribution space.
"""
point = self.beta.random_point()
result = self.beta.belongs(point)
expected = True
self.assertAllClose(expected, result)
def test_random_uniform_and_belongs_vectorization(self):
"""Test random_uniform and belongs.
Test that the random uniform method samples
on the beta distribution space.
"""
n_samples = self.n_samples
point = self.beta.random_point(n_samples)
result = self.beta.belongs(point)
expected = gs.array([True] * n_samples)
self.assertAllClose(expected, result)
def test_random_uniform(self):
"""Test random_uniform.
Test that the random uniform method samples points of the right shape
"""
point = self.beta.random_point(self.n_samples)
self.assertAllClose(gs.shape(point), (self.n_samples, self.dim))
def test_sample(self):
"""Test samples.
Test that the sample method samples variates from beta distributions
with the specified parameters, using the law of large numbers
"""
n_samples = self.n_samples
tol = (n_samples * 10)**(-0.5)
point = self.beta.random_point(n_samples)
samples = self.beta.sample(point, n_samples * 10)
result = gs.mean(samples, axis=1)
expected = point[:, 0] / gs.sum(point, axis=1)
self.assertAllClose(result, expected, rtol=tol, atol=tol)
def test_maximum_likelihood_fit(self):
"""Test maximum likelihood.
Test that the maximum likelihood fit method recovers
parameters of beta distribution.
"""
n_samples = self.n_samples
point = self.beta.random_point(n_samples)
samples = self.beta.sample(point, n_samples * 10)
fits = self.beta.maximum_likelihood_fit(samples)
expected = self.beta.belongs(fits)
result = gs.array([True] * n_samples)
self.assertAllClose(result, expected)
@geomstats.tests.np_and_autograd_only
def test_exp(self):
"""Test Exp.
Test that the Riemannian exponential at points on the first
bisector computed in the direction of the first bisector stays
on the first bisector.
"""
gs.random.seed(123)
n_samples = self.n_samples
points = self.beta.random_point(n_samples)
vectors = self.beta.random_point(n_samples)
initial_vectors = gs.array([[vec_x, vec_x] for vec_x in vectors[:, 0]])
points = gs.array([[param_a, param_a] for param_a in points[:, 0]])
result_points = self.metric.exp(initial_vectors, points)
result = gs.isclose(result_points[:, 0], result_points[:, 1]).all()
expected = gs.array([True] * n_samples)
self.assertAllClose(expected, result)
@geomstats.tests.np_and_autograd_only
def test_log_and_exp(self):
"""Test Log and Exp.
Test that the Riemannian exponential
and the Riemannian logarithm are inverse.
Expect their composition to give the identity function.
"""
n_samples = self.n_samples
gs.random.seed(123)
base_point = self.beta.random_point(n_samples=n_samples, bound=5)
point = self.beta.random_point(n_samples=n_samples, bound=5)
log = self.metric.log(point, base_point, n_steps=500)
expected = point
result = self.metric.exp(tangent_vec=log, base_point=base_point)
self.assertAllClose(result, expected, rtol=1e-2)
@geomstats.tests.np_and_autograd_only
def test_exp_vectorization(self):
"""Test vectorization of Exp.
Test the case with one initial point and several tangent vectors.
"""
point = self.beta.random_point()
tangent_vec = gs.array([1.0, 2.0])
n_tangent_vecs = 10
t = gs.linspace(0.0, 1.0, n_tangent_vecs)
tangent_vecs = gs.einsum("i,...k->...ik", t, tangent_vec)
end_points = self.metric.exp(tangent_vec=tangent_vecs,
base_point=point)
result = end_points.shape
expected = (n_tangent_vecs, 2)
self.assertAllClose(result, expected)
@geomstats.tests.np_and_autograd_only
def test_log_vectorization(self):
"""Test vectorization of Log.
Test the case with several base points and one end point.
"""
n_points = 10
base_points = self.beta.random_point(n_samples=n_points)
point = self.beta.random_point()
tangent_vecs = self.metric.log(base_point=base_points, point=point)
result = tangent_vecs.shape
expected = (n_points, 2)
self.assertAllClose(result, expected)
@geomstats.tests.np_autograd_and_tf_only
def test_christoffels_vectorization(self):
"""Test Christoffel synbols.
Check vectorization of Christoffel symbols.
"""
points = self.beta.random_point(self.n_samples)
christoffel = self.metric.christoffels(points)
result = christoffel.shape
expected = gs.array([self.n_samples, self.dim, self.dim, self.dim])
self.assertAllClose(result, expected)
def test_metric_matrix(self):
"""Test metric matrix.
Check the value of the metric matrix for a particular
point in the space of beta distributions.
"""
point = gs.array([1.0, 1.0])
result = self.beta.metric.metric_matrix(point)
expected = gs.array([[1.0, -0.644934066], [-0.644934066, 1.0]])
self.assertAllClose(result, expected)
with pytest.raises(ValueError):
self.beta.metric.metric_matrix()
def test_point_to_pdf(self):
"""Test point_to_pdf.
Check vectorization of the computation of the pdf.
"""
point = self.beta.random_point(n_samples=2)
pdf = self.beta.point_to_pdf(point)
x = gs.linspace(0.0, 1.0, 10)
result = pdf(x)
pdf1 = beta.pdf(x, a=point[0, 0], b=point[0, 1])
pdf2 = beta.pdf(x, a=point[1, 0], b=point[1, 1])
expected = gs.stack([gs.array(pdf1), gs.array(pdf2)], axis=1)
self.assertAllClose(result, expected)
def test_point_to_pdf(self, x):
point = BetaDistributions().random_point()
pdf = BetaDistributions().point_to_pdf(point)
result = pdf(x)
expected = beta.pdf(x, a=point[0], b=point[1])
self.assertAllClose(result, expected)
class BetaMetricTestData(_RiemannianMetricTestData):
space = BetaDistributions
metric = BetaMetric
metric_args_list = [()]
shape_list = [(2, )]
space_list = [BetaDistributions()]
n_samples_list = random.sample(range(2, 5), 2)
n_points_list = random.sample(range(1, 5), 2)
n_vecs_list = random.sample(range(2, 5), 2)
def exp_shape_test_data(self):
return self._exp_shape_data(
self.metric_args_list,
self.space_list,
self.shape_list,
self.n_samples_list,
)
def log_shape_test_data(self):
return self._log_shape_test_data(
self.metric_args_list,
self.space_list,
)
def exp_belongs_test_data(self):
return self._exp_belongs_test_data(
self.metric_args_list,
self.space_list,
self.shape_list,
self.n_samples_list,
)
def log_is_tangent_test_data(self):
return self._log_is_tangent_test_data(
self.metric_args_list,
self.space_list,
self.n_samples_list,
)
def log_after_exp_test_data(self):
return self._log_after_exp_test_data(
self.metric_args_list,
self.space_list,
self.n_samples_list,
rtol=0.1,
atol=0.0,
)
def exp_after_log_test_data(self):
return self._exp_after_log_test_data(
self.metric_args_list,
self.space_list,
self.n_samples_list,
self.n_vecs_list,
rtol=0.1,
atol=0.0,
)
def squared_dist_is_symmetric_test_data(self):
return self._squared_dist_is_symmetric_test_data(
self.metric_args_list,
self.space_list,
self.n_points_list,
self.n_points_list,
0.1,
0.1,
)
def squared_dist_is_positive_test_data(self):
return self._squared_dist_is_positive_test_data(
self.metric_args_list,
self.space_list,
self.n_points_list,
self.n_points_list,
is_positive_atol=gs.atol,
)
def dist_is_symmetric_test_data(self):
return self._dist_is_symmetric_test_data(
self.metric_args_list,
self.space_list,
self.n_points_list,
self.n_points_list,
rtol=0.1,
atol=gs.atol,
)
def dist_is_positive_test_data(self):
return self._dist_is_positive_test_data(
self.metric_args_list,
self.space_list,
self.n_points_list,
self.n_points_list,
is_positive_atol=gs.atol,
)
def dist_is_norm_of_log_test_data(self):
return self._dist_is_norm_of_log_test_data(
self.metric_args_list,
self.space_list,
self.n_points_list,
self.n_points_list,
rtol=0.1,
atol=gs.atol,
)
def dist_point_to_itself_is_zero_test_data(self):
return self._dist_point_to_itself_is_zero_test_data(
self.metric_args_list,
self.space_list,
self.n_points_list,
rtol=gs.rtol,
atol=1e-5,
)
def inner_product_is_symmetric_test_data(self):
return self._inner_product_is_symmetric_test_data(
self.metric_args_list,
self.space_list,
self.shape_list,
self.n_vecs_list,
rtol=gs.rtol,
atol=gs.atol,
)
def triangle_inequality_of_dist_test_data(self):
return self._triangle_inequality_of_dist_test_data(
self.metric_args_list,
self.space_list,
self.n_points_list,
atol=gs.atol * 10000,
)
def metric_matrix_test_data(self):
smoke_data = [
dict(
point=gs.array([1.0, 1.0]),
expected=gs.array([[1.0, -0.644934066], [-0.644934066, 1.0]]),
)
]
return self.generate_tests(smoke_data)
def exp_test_data(self):
smoke_data = [dict(n_samples=10)]
return self.generate_tests(smoke_data)
def christoffels_shape_test_data(self):
smoke_data = [dict(n_samples=10)]
return self.generate_tests(smoke_data)