def test_inner_product_vectorization(self):
n_samples = 3
one_point_a = gs.array([[-1., 0.]])
one_point_b = gs.array([[1.0, 0.]])
n_points_a = gs.array([[-1., 0.], [1., 0.], [2., math.sqrt(3)]])
n_points_b = gs.array([[2., -math.sqrt(3)], [4.0, math.sqrt(15)],
[-4.0, math.sqrt(15)]])
result = self.metric.inner_product(one_point_a, one_point_b)
expected = gs.dot(one_point_a, gs.transpose(one_point_b))
expected -= (2 * one_point_a[:, self.time_like_dim] *
one_point_b[:, self.time_like_dim])
expected = helper.to_scalar(expected)
result_no = self.metric.inner_product(n_points_a, one_point_b)
result_on = self.metric.inner_product(one_point_a, n_points_b)
result_nn = self.metric.inner_product(n_points_a, n_points_b)
self.assertAllClose(result, expected)
self.assertAllClose(gs.shape(result_no), (n_samples, 1))
self.assertAllClose(gs.shape(result_on), (n_samples, 1))
self.assertAllClose(gs.shape(result_nn), (n_samples, 1))
with self.session():
expected = np.zeros(n_samples)
for i in range(n_samples):
expected[i] = gs.eval(gs.dot(n_points_a[i], n_points_b[i]))
expected[i] -= (2 *
gs.eval(n_points_a[i, self.time_like_dim]) *
gs.eval(n_points_b[i, self.time_like_dim]))
expected = helper.to_scalar(gs.array(expected))
self.assertAllClose(result_nn, expected)
def test_dist_vectorization(self):
n_samples = self.n_samples
one_point_a = self.space.random_uniform(n_samples=1)
one_point_b = self.space.random_uniform(n_samples=1)
n_points_a = self.space.random_uniform(n_samples=n_samples)
n_points_b = self.space.random_uniform(n_samples=n_samples)
result = self.metric.dist(one_point_a, one_point_b)
vec = one_point_a - one_point_b
expected = gs.sqrt(gs.dot(vec, vec.transpose()))
expected = helper.to_scalar(expected)
gs.testing.assert_allclose(result, expected)
result = self.metric.dist(n_points_a, one_point_b)
gs.testing.assert_allclose(result.shape, (n_samples, 1))
result = self.metric.dist(one_point_a, n_points_b)
gs.testing.assert_allclose(result.shape, (n_samples, 1))
result = self.metric.dist(n_points_a, n_points_b)
expected = gs.zeros(n_samples)
for i in range(n_samples):
vec = n_points_a[i] - n_points_b[i]
expected[i] = gs.sqrt(gs.dot(vec, vec.transpose()))
expected = helper.to_scalar(expected)
gs.testing.assert_allclose(result.shape, (n_samples, 1))
gs.testing.assert_allclose(result, expected)
def test_inner_product_vectorization(self):
n_samples = self.n_samples
one_point_a = self.space.random_uniform(n_samples=1)
one_point_b = self.space.random_uniform(n_samples=1)
n_points_a = self.space.random_uniform(n_samples=n_samples)
n_points_b = self.space.random_uniform(n_samples=n_samples)
result = self.metric.inner_product(one_point_a, one_point_b)
expected = gs.dot(one_point_a, one_point_b.transpose())
expected = helper.to_scalar(expected)
gs.testing.assert_allclose(result, expected)
result = self.metric.inner_product(n_points_a, one_point_b)
expected = gs.dot(n_points_a, one_point_b.transpose())
expected = helper.to_scalar(expected)
gs.testing.assert_allclose(result.shape, (n_samples, 1))
gs.testing.assert_allclose(result, expected)
result = self.metric.inner_product(one_point_a, n_points_b)
expected = gs.dot(one_point_a, n_points_b.transpose()).transpose()
expected = helper.to_scalar(expected)
gs.testing.assert_allclose(result.shape, (n_samples, 1))
gs.testing.assert_allclose(result, expected)
result = self.metric.inner_product(n_points_a, n_points_b)
expected = gs.zeros(n_samples)
for i in range(n_samples):
expected[i] = gs.dot(n_points_a[i], n_points_b[i])
expected = helper.to_scalar(expected)
gs.testing.assert_allclose(result.shape, (n_samples, 1))
gs.testing.assert_allclose(result, expected)
def test_variance(self):
points = gs.array([[1., 0.], [2., math.sqrt(3)], [3., math.sqrt(8)],
[4., math.sqrt(24)]])
weights = gs.array([1., 2., 1., 2.])
base_point = gs.array([-1., 0.])
variance = self.metric.variance(points, weights, base_point)
result = helper.to_scalar(variance != 0)
# we expect the average of the points' Minkowski sq norms.
expected = helper.to_scalar(gs.array([True]))
self.assertAllClose(result, expected)
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)
def test_inner_product(self):
base_point = gs.array([
[1., 2., 3.],
[0., 0., 0.],
[3., 1., 1.]])
tangent_vector_1 = gs.array([
[1., 2., 3.],
[0., -10., 0.],
[30., 1., 1.]])
tangent_vector_2 = gs.array([
[1., 4., 3.],
[5., 0., 0.],
[3., 1., 1.]])
result = self.metric.inner_product(
tangent_vector_1,
tangent_vector_2,
base_point=base_point)
expected = gs.trace(
gs.matmul(
gs.transpose(tangent_vector_1),
tangent_vector_2))
expected = helper.to_scalar(expected)
self.assertAllClose(result, expected)
def test_exp_and_dist_and_projection_to_tangent_space_vec(self):
base_point = gs.array([
[16., -2., -2.5, 84., 3.],
[16., -2., -2.5, 84., 3.]])
base_single_point = gs.array([16., -2., -2.5, 84., 3.])
scalar_norm = gs.linalg.norm(base_single_point)
base_point = base_point / scalar_norm
vector = gs.array(
[[9., 0., -1., -2., 1.],
[9., 0., -1., -2., 1]])
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)
expected = gs.linalg.norm(tangent_vec, axis=-1) % (2 * gs.pi)
expected = helper.to_scalar(expected)
self.assertAllClose(result, expected)
def test_inner_product_vectorization(self):
n_samples = 3
one_point_a = tf.convert_to_tensor([0., 1.])
one_point_b = tf.convert_to_tensor([2., 10.])
n_points_a = tf.convert_to_tensor([[2., 1.], [-2., -4.], [-5., 1.]])
n_points_b = tf.convert_to_tensor([[2., 10.], [8., -1.], [-3., 6.]])
result = self.metric.inner_product(one_point_a, one_point_b)
expected = gs.dot(one_point_a, gs.transpose(one_point_b))
expected = helper.to_scalar(expected)
with self.test_session():
self.assertAllClose(gs.eval(result), gs.eval(expected))
result = self.metric.inner_product(n_points_a, one_point_b)
point_numpy = np.random.uniform(size=(n_samples, 1))
# TODO(nina): Fix this test with assertShapeEqual
with self.test_session():
self.assertAllClose(point_numpy.shape, gs.eval(gs.shape(result)))
result = self.metric.inner_product(one_point_a, n_points_b)
point_numpy = np.random.uniform(size=(n_samples, 1))
# TODO(nina): Fix this test with assertShapeEqual
with self.test_session():
self.assertAllClose(point_numpy.shape, gs.eval(gs.shape(result)))
result = self.metric.inner_product(n_points_a, n_points_b)
point_numpy = np.random.uniform(size=(n_samples, 1))
# TODO(nina): Fix this test with assertShapeEqual
with self.test_session():
self.assertAllClose(point_numpy.shape, gs.eval(gs.shape(result)))
def test_belongs(self):
point = self.space.random_uniform()
bool_belongs = self.space.belongs(point)
expected = helper.to_scalar(tf.convert_to_tensor([[True]]))
with self.test_session():
self.assertAllClose(gs.eval(expected), gs.eval(bool_belongs))
def test_dist_vectorization(self):
n_samples = self.n_samples
one_point_a = gs.array([0., 1.])
one_point_b = gs.array([2., 10.])
n_points_a = gs.array([[2., 1.], [-2., -4.], [-5., 1.]])
n_points_b = gs.array([[2., 10.], [8., -1.], [-3., 6.]])
result = self.metric.dist(one_point_a, one_point_b)
vec = one_point_a - one_point_b
expected = gs.sqrt(gs.dot(vec, gs.transpose(vec)))
expected = helper.to_scalar(expected)
self.assertAllClose(result, expected)
result = self.metric.dist(n_points_a, one_point_b)
self.assertAllClose(gs.shape(result), (n_samples, 1))
result = self.metric.dist(one_point_a, n_points_b)
self.assertAllClose(gs.shape(result), (n_samples, 1))
result = self.metric.dist(n_points_a, n_points_b)
expected = gs.array([[9.], [gs.sqrt(109.)], [gs.sqrt(29.)]])
self.assertAllClose(gs.shape(result), (n_samples, 1))
self.assertAllClose(result, expected)
def test_squared_norm(self):
point = gs.array([-2, 4])
result = self.metric.squared_norm(point)
expected = gs.linalg.norm(point) ** 2
expected = helper.to_scalar(expected)
gs.testing.assert_allclose(result, expected)
def foo_optional_input(tangent_vec_a, tangent_vec_b, in_scalar=None):
if in_scalar is None:
in_scalar = gs.array([[1]])
aux = gs.einsum('ni,ni->n', tangent_vec_a, tangent_vec_b)
result = gs.einsum('n,nk->n', aux, in_scalar)
result = helper.to_scalar(result)
return result
def test_dist_orthogonal_points(self):
# Distance between two orthogonal points is pi / 2.
point_a = gs.array([10., -2., -.5, 0., 0.])
point_a = point_a / gs.linalg.norm(point_a)
point_b = gs.array([2., 10, 0., 0., 0.])
point_b = point_b / gs.linalg.norm(point_b)
result = gs.dot(point_a, point_b)
result = helper.to_scalar(result)
expected = 0
expected = helper.to_scalar(expected)
self.assertAllClose(result, expected)
result = self.metric.dist(point_a, point_b)
expected = gs.pi / 2
expected = helper.to_scalar(expected)
self.assertAllClose(result, expected)
def test_dist(self):
point_a = gs.array([0, 1])
point_b = gs.array([2, 10])
result = self.metric.dist(point_a, point_b)
expected = gs.linalg.norm(point_b - point_a)
expected = helper.to_scalar(expected)
gs.testing.assert_allclose(result, expected)
def test_squared_dist(self):
point_a = gs.array([-1, 4])
point_b = gs.array([1, 1])
result = self.metric.squared_dist(point_a, point_b)
vec = point_b - point_a
expected = gs.dot(vec, vec)
expected = helper.to_scalar(expected)
gs.testing.assert_allclose(result, expected)
def test_norm(self):
point = tf.convert_to_tensor([-2., 4.])
result = self.metric.norm(point)
expected = gs.linalg.norm(point)
expected = helper.to_scalar(expected)
with self.test_session():
self.assertAllClose(gs.eval(result), gs.eval(expected))
def test_inner_product(self):
point_a = gs.array([0, 1])
point_b = gs.array([2, 10])
result = self.metric.inner_product(point_a, point_b)
expected = gs.dot(point_a, point_b)
expected = helper.to_scalar(expected)
gs.testing.assert_allclose(result, expected)
def test_variance(self):
points = gs.array([[1, 2], [2, 3], [3, 4], [4, 5]])
weights = gs.array([1, 2, 1, 2])
base_point = gs.zeros(2)
result = self.metric.variance(points, weights, base_point)
# we expect the average of the points' Minkowski sq norms.
expected = (1 * 3. + 2 * 5. + 1 * 7. + 2 * 9.) / 6.
expected = helper.to_scalar(expected)
gs.testing.assert_allclose(result, expected)
def test_norm_vectorization(self):
n_samples = self.n_samples
n_points = self.space.random_uniform(n_samples=n_samples)
result = self.metric.norm(n_points)
expected = gs.linalg.norm(n_points, axis=1)
expected = helper.to_scalar(expected)
gs.testing.assert_allclose(result.shape, (n_samples, 1))
gs.testing.assert_allclose(result, expected)
def test_variance_hyperbolic(self):
point = gs.array([2., 1., 1., 1.])
points = gs.array([point, point])
result = variance(points,
base_point=point,
metric=self.hyperbolic.metric)
expected = helper.to_scalar(0.)
self.assertAllClose(result, expected)
def test_dist_point_and_itself(self):
# Distance between a point and itself is 0.
point_a = gs.array([10., -2., -.5, 2., 3.])
point_b = point_a
result = self.metric.dist(point_a, point_b)
expected = 0.
expected = helper.to_scalar(expected)
gs.testing.assert_allclose(result, expected)
def test_variance(self):
point = gs.array([0., 0., 0., 0., 1.])
points = gs.zeros((2, point.shape[0]))
points[0, :] = point
points[1, :] = point
result = self.metric.variance(points)
expected = helper.to_scalar(0.)
self.assertAllClose(expected, result)
def test_squared_norm(self):
point = tf.convert_to_tensor([-2., 4.])
result = self.metric.squared_norm(point)
expected = gs.dot(point, point)
expected -= 2 * point[self.time_like_dim] * point[self.time_like_dim]
expected = helper.to_scalar(expected)
with self.test_session():
self.assertAllClose(gs.eval(result), gs.eval(expected))
def test_dist_point_and_itself(self):
# Distance between a point and itself is 0
point_a = (1. / gs.sqrt(129.) * gs.array([10., -2., -5., 0., 0.]))
point_b = point_a
result = self.metric.dist(point_a, point_b)
expected = 0.
expected = helper.to_scalar(expected)
self.assertAllClose(result, expected)
def test_dist(self):
point_a = gs.array([0., 1.])
point_b = gs.array([2., 10.])
result = self.metric.dist(point_a, point_b)
expected = gs.linalg.norm(point_b - point_a)
expected = helper.to_scalar(expected)
self.assertAllClose(result, expected)
def test_inner_product(self):
point_a = tf.convert_to_tensor([0., 1.])
point_b = tf.convert_to_tensor([2., 10.])
result = self.metric.inner_product(point_a, point_b)
expected = gs.dot(point_a, point_b)
expected = helper.to_scalar(expected)
with self.test_session():
self.assertAllClose(gs.eval(result), gs.eval(expected))
def test_variance(self):
points = gs.array([[1., 2.], [2., 3.], [3., 4.], [4., 5.]])
weights = gs.array([1., 2., 1., 2.])
base_point = gs.zeros(2)
result = self.metric.variance(points, weights, base_point)
# we expect the average of the points' sq norms.
expected = (1 * 5. + 2 * 13. + 1 * 25. + 2 * 41.) / 6.
expected = helper.to_scalar(expected)
self.assertAllClose(result, expected)
def test_squared_dist(self):
point_a = gs.array([-1., 4.])
point_b = gs.array([1., 1.])
result = self.metric.squared_dist(point_a, point_b)
vec = point_b - point_a
expected = gs.dot(vec, vec)
expected = helper.to_scalar(expected)
self.assertAllClose(result, expected)
def test_squared_dist(self):
point_a = gs.array([2., -math.sqrt(3)])
point_b = gs.array([4.0, math.sqrt(15)])
result = self.metric.squared_dist(point_a, point_b)
vec = point_b - point_a
expected = gs.dot(vec, vec)
expected -= 2 * vec[self.time_like_dim] * vec[self.time_like_dim]
expected = helper.to_scalar(expected)
self.assertAllClose(result, expected)
def test_inner_product(self):
point_a = gs.array([0., 1.])
point_b = gs.array([2., 10.])
result = self.metric.inner_product(point_a, point_b)
expected = helper.to_scalar(gs.dot(point_a, point_b))
expected -= (2 * point_a[self.time_like_dim]
* point_b[self.time_like_dim])
self.assertAllClose(result, expected)
