class HypersphereMetric(RiemannianMetric):
"""Class for the Hypersphere Metric.
Parameters
----------
dim : int
Dimension of the hypersphere.
"""
def __init__(self, dim):
super(HypersphereMetric, self).__init__(
dim=dim,
signature=(dim, 0))
self.embedding_metric = EuclideanMetric(dim + 1)
self._space = _Hypersphere(dim=dim)
def inner_product(self, tangent_vec_a, tangent_vec_b, base_point=None):
"""Compute the inner-product of two tangent vectors at a base point.
Parameters
----------
tangent_vec_a : array-like, shape=[..., dim + 1]
First tangent vector at base point.
tangent_vec_b : array-like, shape=[..., dim + 1]
Second tangent vector at base point.
base_point : array-like, shape=[..., dim + 1], optional
Point on the hypersphere.
Returns
-------
inner_prod : array-like, shape=[...,]
Inner-product of the two tangent vectors.
"""
inner_prod = self.embedding_metric.inner_product(
tangent_vec_a, tangent_vec_b, base_point)
return inner_prod
def squared_norm(self, vector, base_point=None):
"""Compute the squared norm of a vector.
Squared norm of a vector associated with the inner-product
at the tangent space at a base point.
Parameters
----------
vector : array-like, shape=[..., dim + 1]
Vector on the tangent space of the hypersphere at base point.
base_point : array-like, shape=[..., dim + 1], optional
Point on the hypersphere.
Returns
-------
sq_norm : array-like, shape=[..., 1]
Squared norm of the vector.
"""
sq_norm = self.embedding_metric.squared_norm(vector)
return sq_norm
def exp(self, tangent_vec, base_point):
"""Compute the Riemannian exponential of a tangent vector.
Parameters
----------
tangent_vec : array-like, shape=[..., dim + 1]
Tangent vector at a base point.
base_point : array-like, shape=[..., dim + 1]
Point on the hypersphere.
Returns
-------
exp : array-like, shape=[..., dim + 1]
Point on the hypersphere equal to the Riemannian exponential
of tangent_vec at the base point.
"""
hypersphere = Hypersphere(dim=self.dim)
proj_tangent_vec = hypersphere.to_tangent(tangent_vec, base_point)
norm2 = self.embedding_metric.squared_norm(proj_tangent_vec)
coef_1 = utils.taylor_exp_even_func(
norm2, utils.cos_close_0, order=4)
coef_2 = utils.taylor_exp_even_func(
norm2, utils.sinc_close_0, order=4)
exp = (gs.einsum('...,...j->...j', coef_1, base_point)
+ gs.einsum('...,...j->...j', coef_2, proj_tangent_vec))
return exp
def log(self, point, base_point, **kwargs):
"""Compute the Riemannian logarithm of a point.
Parameters
----------
point : array-like, shape=[..., dim + 1]
Point on the hypersphere.
base_point : array-like, shape=[..., dim + 1]
Point on the hypersphere.
Returns
-------
log : array-like, shape=[..., dim + 1]
Tangent vector at the base point equal to the Riemannian logarithm
of point at the base point.
"""
inner_prod = self.embedding_metric.inner_product(base_point, point)
cos_angle = gs.clip(inner_prod, -1., 1.)
squared_angle = gs.arccos(cos_angle) ** 2
coef_1_ = utils.taylor_exp_even_func(
squared_angle, utils.inv_sinc_close_0, order=5)
coef_2_ = utils.taylor_exp_even_func(
squared_angle, utils.inv_tanc_close_0, order=5)
log = (gs.einsum('...,...j->...j', coef_1_, point)
- gs.einsum('...,...j->...j', coef_2_, base_point))
return log
def dist(self, point_a, point_b):
"""Compute the geodesic distance between two points.
Parameters
----------
point_a : array-like, shape=[..., dim + 1]
First point on the hypersphere.
point_b : array-like, shape=[..., dim + 1]
Second point on the hypersphere.
Returns
-------
dist : array-like, shape=[..., 1]
Geodesic distance between the two points.
"""
norm_a = self.embedding_metric.norm(point_a)
norm_b = self.embedding_metric.norm(point_b)
inner_prod = self.embedding_metric.inner_product(point_a, point_b)
cos_angle = inner_prod / (norm_a * norm_b)
cos_angle = gs.clip(cos_angle, -1, 1)
dist = gs.arccos(cos_angle)
return dist
def squared_dist(self, point_a, point_b):
"""Squared geodesic distance between two points.
Parameters
----------
point_a : array-like, shape=[..., dim]
Point on the hypersphere.
point_b : array-like, shape=[..., dim]
Point on the hypersphere.
Returns
-------
sq_dist : array-like, shape=[...,]
"""
return self.dist(point_a, point_b) ** 2
@staticmethod
def parallel_transport(tangent_vec_a, tangent_vec_b, base_point):
r"""Compute the parallel transport of a tangent vector.
Closed-form solution for the parallel transport of a tangent vector a
along the geodesic defined by :math: `t \mapsto exp_(base_point)(t*
tangent_vec_b)`.
Parameters
----------
tangent_vec_a : array-like, shape=[..., dim + 1]
Tangent vector at base point to be transported.
tangent_vec_b : array-like, shape=[..., dim + 1]
Tangent vector at base point, along which the parallel transport
is computed.
base_point : array-like, shape=[..., dim + 1]
Point on the hypersphere.
Returns
-------
transported_tangent_vec: array-like, shape=[..., dim + 1]
Transported tangent vector at `exp_(base_point)(tangent_vec_b)`.
"""
theta = gs.linalg.norm(tangent_vec_b, axis=-1)
normalized_b = gs.einsum('...,...i->...i', 1 / theta, tangent_vec_b)
pb = gs.einsum('...i,...i->...', tangent_vec_a, normalized_b)
p_orth = tangent_vec_a - gs.einsum('...,...i->...i', pb, normalized_b)
transported = \
- gs.einsum('...,...i->...i', gs.sin(theta) * pb, base_point)\
+ gs.einsum('...,...i->...i', gs.cos(theta) * pb, normalized_b)\
+ p_orth
return transported
def christoffels(self, point, point_type='spherical'):
"""Compute the Christoffel symbols at a point.
Only implemented in dimension 2 and for spherical coordinates.
Parameters
----------
point : array-like, shape=[..., dim]
Point on hypersphere where the Christoffel symbols are computed.
point_type: str, {'spherical', 'intrinsic', 'extrinsic'}
Coordinates in which to express the Christoffel symbols.
Optional, default: 'spherical'.
Returns
-------
christoffel : array-like, shape=[..., contravariant index, 1st
covariant index, 2nd covariant index]
Christoffel symbols at point.
"""
if self.dim != 2 or point_type != 'spherical':
raise NotImplementedError(
'The Christoffel symbols are only implemented'
' for spherical coordinates in the 2-sphere')
point = gs.to_ndarray(point, to_ndim=2)
christoffel = []
for sample in point:
gamma_0 = gs.array(
[[0, 0], [0, - gs.sin(sample[0]) * gs.cos(sample[0])]])
gamma_1 = gs.array([[0, gs.cos(sample[0]) / gs.sin(sample[0])],
[gs.cos(sample[0]) / gs.sin(sample[0]), 0]])
christoffel.append(gs.stack([gamma_0, gamma_1]))
christoffel = gs.stack(christoffel)
if gs.ndim(christoffel) == 4 and gs.shape(christoffel)[0] == 1:
christoffel = gs.squeeze(christoffel, axis=0)
return christoffel
def curvature(
self, tangent_vec_a, tangent_vec_b, tangent_vec_c,
base_point):
r"""Compute the curvature.
For three tangent vectors at a base point :math: `x,y,z`,
the curvature is defined by
:math: `R(x, y)z = \nabla_{[x,y]}z
- \nabla_z\nabla_y z + \nabla_y\nabla_x z`, where :math: `\nabla`
is the Levi-Civita connection. In the case of the hypersphere,
we have the closed formula
:math: `R(x,y)z = \langle x, z \rangle y - \langle y,z \rangle x`.
Parameters
----------
tangent_vec_a : array-like, shape=[..., dim]
Tangent vector at `base_point`.
tangent_vec_b : array-like, shape=[..., dim]
Tangent vector at `base_point`.
tangent_vec_c : array-like, shape=[..., dim]
Tangent vector at `base_point`.
base_point : array-like, shape=[..., dim]
Point on the group. Optional, default is the identity.
Returns
-------
curvature : array-like, shape=[..., dim]
Tangent vector at `base_point`.
"""
inner_ac = self.inner_product(tangent_vec_a, tangent_vec_c)
inner_bc = self.inner_product(tangent_vec_b, tangent_vec_c)
first_term = gs.einsum('...,...i->...i', inner_bc, tangent_vec_a)
second_term = gs.einsum('...,...i->...i', inner_ac, tangent_vec_b)
return - first_term + second_term
class HypersphereMetric(RiemannianMetric):
"""Class for the Hypersphere Metric.
Parameters
----------
dim : int
Dimension of the hypersphere.
"""
def __init__(self, dim):
super(HypersphereMetric, self).__init__(dim=dim, signature=(dim, 0))
self.embedding_metric = EuclideanMetric(dim + 1)
self._space = _Hypersphere(dim=dim)
def metric_matrix(self, base_point=None):
"""Metric matrix at the tangent space at a base point.
Parameters
----------
base_point : array-like, shape=[..., dim + 1]
Base point.
Optional, default: None.
Returns
-------
mat : array-like, shape=[..., dim + 1, dim + 1]
Inner-product matrix.
"""
return gs.eye(self.dim + 1)
def inner_product(self, tangent_vec_a, tangent_vec_b, base_point=None):
"""Compute the inner-product of two tangent vectors at a base point.
Parameters
----------
tangent_vec_a : array-like, shape=[..., dim + 1]
First tangent vector at base point.
tangent_vec_b : array-like, shape=[..., dim + 1]
Second tangent vector at base point.
base_point : array-like, shape=[..., dim + 1], optional
Point on the hypersphere.
Returns
-------
inner_prod : array-like, shape=[...,]
Inner-product of the two tangent vectors.
"""
inner_prod = self.embedding_metric.inner_product(
tangent_vec_a, tangent_vec_b, base_point)
return inner_prod
def squared_norm(self, vector, base_point=None):
"""Compute the squared norm of a vector.
Squared norm of a vector associated with the inner-product
at the tangent space at a base point.
Parameters
----------
vector : array-like, shape=[..., dim + 1]
Vector on the tangent space of the hypersphere at base point.
base_point : array-like, shape=[..., dim + 1], optional
Point on the hypersphere.
Returns
-------
sq_norm : array-like, shape=[..., 1]
Squared norm of the vector.
"""
sq_norm = self.embedding_metric.squared_norm(vector)
return sq_norm
def exp(self, tangent_vec, base_point, **kwargs):
"""Compute the Riemannian exponential of a tangent vector.
Parameters
----------
tangent_vec : array-like, shape=[..., dim + 1]
Tangent vector at a base point.
base_point : array-like, shape=[..., dim + 1]
Point on the hypersphere.
Returns
-------
exp : array-like, shape=[..., dim + 1]
Point on the hypersphere equal to the Riemannian exponential
of tangent_vec at the base point.
"""
hypersphere = Hypersphere(dim=self.dim)
proj_tangent_vec = hypersphere.to_tangent(tangent_vec, base_point)
norm2 = self.embedding_metric.squared_norm(proj_tangent_vec)
coef_1 = utils.taylor_exp_even_func(norm2, utils.cos_close_0, order=4)
coef_2 = utils.taylor_exp_even_func(norm2, utils.sinc_close_0, order=4)
exp = gs.einsum("...,...j->...j", coef_1, base_point) + gs.einsum(
"...,...j->...j", coef_2, proj_tangent_vec)
return exp
def log(self, point, base_point, **kwargs):
"""Compute the Riemannian logarithm of a point.
Parameters
----------
point : array-like, shape=[..., dim + 1]
Point on the hypersphere.
base_point : array-like, shape=[..., dim + 1]
Point on the hypersphere.
Returns
-------
log : array-like, shape=[..., dim + 1]
Tangent vector at the base point equal to the Riemannian logarithm
of point at the base point.
"""
inner_prod = self.embedding_metric.inner_product(base_point, point)
cos_angle = gs.clip(inner_prod, -1.0, 1.0)
squared_angle = gs.arccos(cos_angle)**2
coef_1_ = utils.taylor_exp_even_func(squared_angle,
utils.inv_sinc_close_0,
order=5)
coef_2_ = utils.taylor_exp_even_func(squared_angle,
utils.inv_tanc_close_0,
order=5)
log = gs.einsum("...,...j->...j", coef_1_, point) - gs.einsum(
"...,...j->...j", coef_2_, base_point)
return log
def dist(self, point_a, point_b):
"""Compute the geodesic distance between two points.
Parameters
----------
point_a : array-like, shape=[..., dim + 1]
First point on the hypersphere.
point_b : array-like, shape=[..., dim + 1]
Second point on the hypersphere.
Returns
-------
dist : array-like, shape=[..., 1]
Geodesic distance between the two points.
"""
norm_a = self.embedding_metric.norm(point_a)
norm_b = self.embedding_metric.norm(point_b)
inner_prod = self.embedding_metric.inner_product(point_a, point_b)
cos_angle = inner_prod / (norm_a * norm_b)
cos_angle = gs.clip(cos_angle, -1, 1)
dist = gs.arccos(cos_angle)
return dist
def squared_dist(self, point_a, point_b, **kwargs):
"""Squared geodesic distance between two points.
Parameters
----------
point_a : array-like, shape=[..., dim]
Point on the hypersphere.
point_b : array-like, shape=[..., dim]
Point on the hypersphere.
Returns
-------
sq_dist : array-like, shape=[...,]
"""
return self.dist(point_a, point_b)**2
@staticmethod
def parallel_transport(tangent_vec_a, tangent_vec_b, base_point, **kwargs):
r"""Compute the parallel transport of a tangent vector.
Closed-form solution for the parallel transport of a tangent vector a
along the geodesic defined by :math:`t \mapsto exp_(base_point)(t*
tangent_vec_b)`.
Parameters
----------
tangent_vec_a : array-like, shape=[..., dim + 1]
Tangent vector at base point to be transported.
tangent_vec_b : array-like, shape=[..., dim + 1]
Tangent vector at base point, along which the parallel transport
is computed.
base_point : array-like, shape=[..., dim + 1]
Point on the hypersphere.
Returns
-------
transported_tangent_vec: array-like, shape=[..., dim + 1]
Transported tangent vector at `exp_(base_point)(tangent_vec_b)`.
"""
theta = gs.linalg.norm(tangent_vec_b, axis=-1)
eps = gs.where(theta == 0.0, 1.0, theta)
normalized_b = gs.einsum("...,...i->...i", 1 / eps, tangent_vec_b)
pb = gs.einsum("...i,...i->...", tangent_vec_a, normalized_b)
p_orth = tangent_vec_a - gs.einsum("...,...i->...i", pb, normalized_b)
transported = (-gs.einsum("...,...i->...i",
gs.sin(theta) * pb, base_point) +
gs.einsum("...,...i->...i",
gs.cos(theta) * pb, normalized_b) + p_orth)
return transported
def christoffels(self, point, point_type="spherical"):
"""Compute the Christoffel symbols at a point.
Only implemented in dimension 2 and for spherical coordinates.
Parameters
----------
point : array-like, shape=[..., dim]
Point on hypersphere where the Christoffel symbols are computed.
point_type: str, {'spherical', 'intrinsic', 'extrinsic'}
Coordinates in which to express the Christoffel symbols.
Optional, default: 'spherical'.
Returns
-------
christoffel : array-like, shape=[..., contravariant index, 1st
covariant index, 2nd covariant index]
Christoffel symbols at point.
"""
if self.dim != 2 or point_type != "spherical":
raise NotImplementedError(
"The Christoffel symbols are only implemented"
" for spherical coordinates in the 2-sphere")
point = gs.to_ndarray(point, to_ndim=2)
christoffel = []
for sample in point:
gamma_0 = gs.array([[0, 0],
[0, -gs.sin(sample[0]) * gs.cos(sample[0])]])
gamma_1 = gs.array([
[0, gs.cos(sample[0]) / gs.sin(sample[0])],
[gs.cos(sample[0]) / gs.sin(sample[0]), 0],
])
christoffel.append(gs.stack([gamma_0, gamma_1]))
christoffel = gs.stack(christoffel)
if gs.ndim(christoffel) == 4 and gs.shape(christoffel)[0] == 1:
christoffel = gs.squeeze(christoffel, axis=0)
return christoffel
def curvature(self, tangent_vec_a, tangent_vec_b, tangent_vec_c,
base_point):
r"""Compute the curvature.
For three tangent vectors at a base point :math:`x,y,z`,
the curvature is defined by
:math:`R(x, y)z = \nabla_{[x,y]}z
- \nabla_z\nabla_y z + \nabla_y\nabla_x z`, where :math:`\nabla`
is the Levi-Civita connection. In the case of the hypersphere,
we have the closed formula
:math:`R(x,y)z = \langle x, z \rangle y - \langle y,z \rangle x`.
Parameters
----------
tangent_vec_a : array-like, shape=[..., dim]
Tangent vector at `base_point`.
tangent_vec_b : array-like, shape=[..., dim]
Tangent vector at `base_point`.
tangent_vec_c : array-like, shape=[..., dim]
Tangent vector at `base_point`.
base_point : array-like, shape=[..., dim]
Point on the hypersphere.
Returns
-------
curvature : array-like, shape=[..., dim]
Tangent vector at `base_point`.
"""
inner_ac = self.inner_product(tangent_vec_a, tangent_vec_c)
inner_bc = self.inner_product(tangent_vec_b, tangent_vec_c)
first_term = gs.einsum("...,...i->...i", inner_bc, tangent_vec_a)
second_term = gs.einsum("...,...i->...i", inner_ac, tangent_vec_b)
return -first_term + second_term
def _normalization_factor_odd_dim(self, variances):
"""Compute the normalization factor - odd dimension."""
dim = self.dim
half_dim = int((dim + 1) / 2)
area = 2 * gs.pi**half_dim / math.factorial(half_dim - 1)
comb = gs.comb(dim - 1, half_dim - 1)
erf_arg = gs.sqrt(variances / 2) * gs.pi
first_term = (area / (2**dim - 1) * comb *
gs.sqrt(gs.pi / (2 * variances)) * gs.erf(erf_arg))
def summand(k):
exp_arg = -((dim - 1 - 2 * k)**2) / 2 / variances
erf_arg_2 = (gs.pi * variances -
(dim - 1 - 2 * k) * 1j) / gs.sqrt(2 * variances)
sign = (-1.0)**k
comb_2 = gs.comb(k, dim - 1)
return sign * comb_2 * gs.exp(exp_arg) * gs.real(gs.erf(erf_arg_2))
if half_dim > 2:
sum_term = gs.sum(
gs.stack([summand(k)] for k in range(half_dim - 2)))
else:
sum_term = summand(0)
coef = area / 2 / erf_arg * gs.pi**0.5 * (-1.0)**(half_dim - 1)
return first_term + coef / 2**(dim - 2) * sum_term
def _normalization_factor_even_dim(self, variances):
"""Compute the normalization factor - even dimension."""
dim = self.dim
half_dim = (dim + 1) / 2
area = 2 * gs.pi**half_dim / math.gamma(half_dim)
def summand(k):
exp_arg = -((dim - 1 - 2 * k)**2) / 2 / variances
erf_arg_1 = (dim - 1 - 2 * k) * 1j / gs.sqrt(2 * variances)
erf_arg_2 = (gs.pi * variances -
(dim - 1 - 2 * k) * 1j) / gs.sqrt(2 * variances)
sign = (-1.0)**k
comb = gs.comb(dim - 1, k)
erf_terms = gs.imag(gs.erf(erf_arg_2) + gs.erf(erf_arg_1))
return sign * comb * gs.exp(exp_arg) * erf_terms
half_dim_2 = int((dim - 2) / 2)
if half_dim_2 > 0:
sum_term = gs.sum(gs.stack([summand(k)]
for k in range(half_dim_2)))
else:
sum_term = summand(0)
coef = (area * (-1.0)**half_dim_2 / 2**(dim - 2) *
gs.sqrt(gs.pi / 2 / variances))
return coef * sum_term
def normalization_factor(self, variances):
"""Return normalization factor of the Gaussian distribution.
Parameters
----------
variances : array-like, shape=[n,]
Variance of the distribution.
Returns
-------
norm_func : array-like, shape=[n,]
Normalisation factor for all given variances.
"""
if self.dim % 2 == 0:
return self._normalization_factor_even_dim(variances)
return self._normalization_factor_odd_dim(variances)
def norm_factor_gradient(self, variances):
"""Compute the gradient of the normalization factor.
Parameters
----------
variances : array-like, shape=[n,]
Variance of the distribution.
Returns
-------
norm_func : array-like, shape=[n,]
Normalisation factor for all given variances.
"""
def func(var):
return gs.sum(self.normalization_factor(var))
_, grad = gs.autodiff.value_and_grad(func)(variances)
return _, grad
def curvature_derivative(
self,
tangent_vec_a,
tangent_vec_b=None,
tangent_vec_c=None,
tangent_vec_d=None,
base_point=None,
):
r"""Compute the covariant derivative of the curvature.
The derivative of the curvature vanishes since the hypersphere is a
constant curvature space.
Parameters
----------
tangent_vec_a : array-like, shape=[..., dim]
Tangent vector at `base_point` along which the curvature is
derived.
tangent_vec_b : array-like, shape=[..., dim]
Unused tangent vector at `base_point` (since curvature derivative
vanishes).
tangent_vec_c : array-like, shape=[..., dim]
Unused tangent vector at `base_point` (since curvature derivative
vanishes).
tangent_vec_d : array-like, shape=[..., dim]
Unused tangent vector at `base_point` (since curvature derivative
vanishes).
base_point : array-like, shape=[..., dim]
Unused point on the hypersphere.
Returns
-------
curvature_derivative : array-like, shape=[..., dim]
Tangent vector at base point.
"""
return gs.zeros_like(tangent_vec_a)
class HypersphereMetric(RiemannianMetric):
"""Class for the Hypersphere Metric.
Parameters
----------
dim : int
Dimension of the hypersphere.
"""
def __init__(self, dim):
super(HypersphereMetric, self).__init__(dim=dim, signature=(dim, 0, 0))
self.embedding_metric = EuclideanMetric(dim + 1)
self._space = _Hypersphere(dim=dim)
def inner_product(self, tangent_vec_a, tangent_vec_b, base_point=None):
"""Compute the inner-product of two tangent vectors at a base point.
Parameters
----------
tangent_vec_a : array-like, shape=[..., dim + 1]
First tangent vector at base point.
tangent_vec_b : array-like, shape=[..., dim + 1]
Second tangent vector at base point.
base_point : array-like, shape=[..., dim + 1], optional
Point on the hypersphere.
Returns
-------
inner_prod : array-like, shape=[..., 1]
Inner-product of the two tangent vectors.
"""
inner_prod = self.embedding_metric.inner_product(
tangent_vec_a, tangent_vec_b, base_point)
return inner_prod
def squared_norm(self, vector, base_point=None):
"""Compute the squared norm of a vector.
Squared norm of a vector associated with the inner-product
at the tangent space at a base point.
Parameters
----------
vector : array-like, shape=[..., dim + 1]
Vector on the tangent space of the hypersphere at base point.
base_point : array-like, shape=[..., dim + 1], optional
Point on the hypersphere.
Returns
-------
sq_norm : array-like, shape=[..., 1]
Squared norm of the vector.
"""
sq_norm = self.embedding_metric.squared_norm(vector)
return sq_norm
@geomstats.vectorization.decorator(['else', 'vector', 'vector'])
def exp(self, tangent_vec, base_point):
"""Compute the Riemannian exponential of a tangent vector.
Parameters
----------
tangent_vec : array-like, shape=[..., dim + 1]
Tangent vector at a base point.
base_point : array-like, shape=[..., dim + 1]
Point on the hypersphere.
Returns
-------
exp : array-like, shape=[..., dim + 1]
Point on the hypersphere equal to the Riemannian exponential
of tangent_vec at the base point.
"""
# TODO (ninamiolane): Raise error when vector is not tangent
_, extrinsic_dim = base_point.shape
n_tangent_vecs, _ = tangent_vec.shape
hypersphere = Hypersphere(dim=extrinsic_dim - 1)
proj_tangent_vec = hypersphere.to_tangent(tangent_vec, base_point)
norm_tangent_vec = self.embedding_metric.norm(proj_tangent_vec)
norm_tangent_vec = gs.to_ndarray(norm_tangent_vec, to_ndim=1)
mask_0 = gs.isclose(norm_tangent_vec, 0.)
mask_non0 = ~mask_0
coef_1 = gs.zeros((n_tangent_vecs, ))
coef_2 = gs.zeros((n_tangent_vecs, ))
norm2 = norm_tangent_vec[mask_0]**2
norm4 = norm2**2
norm6 = norm2**3
coef_1 = gs.assignment(coef_1,
1. - norm2 / 2. + norm4 / 24. - norm6 / 720.,
mask_0)
coef_2 = gs.assignment(coef_2,
1. - norm2 / 6. + norm4 / 120. - norm6 / 5040.,
mask_0)
coef_1 = gs.assignment(coef_1, gs.cos(norm_tangent_vec[mask_non0]),
mask_non0)
coef_2 = gs.assignment(
coef_2,
gs.sin(norm_tangent_vec[mask_non0]) / norm_tangent_vec[mask_non0],
mask_non0)
exp = (gs.einsum('...,...j->...j', coef_1, base_point) +
gs.einsum('...,...j->...j', coef_2, proj_tangent_vec))
return exp
@geomstats.vectorization.decorator(['else', 'vector', 'vector'])
def log(self, point, base_point):
"""Compute the Riemannian logarithm of a point.
Parameters
----------
point : array-like, shape=[..., dim + 1]
Point on the hypersphere.
base_point : array-like, shape=[..., dim + 1]
Point on the hypersphere.
Returns
-------
log : array-like, shape=[..., dim + 1]
Tangent vector at the base point equal to the Riemannian logarithm
of point at the base point.
"""
norm_base_point = self.embedding_metric.norm(base_point)
norm_point = self.embedding_metric.norm(point)
inner_prod = self.embedding_metric.inner_product(base_point, point)
cos_angle = inner_prod / (norm_base_point * norm_point)
cos_angle = gs.clip(cos_angle, -1., 1.)
angle = gs.arccos(cos_angle)
angle = gs.to_ndarray(angle, to_ndim=1)
angle = gs.to_ndarray(angle, to_ndim=2, axis=1)
mask_0 = gs.isclose(angle, 0.)
mask_else = gs.equal(mask_0, gs.array(False))
mask_0_float = gs.cast(mask_0, gs.float32)
mask_else_float = gs.cast(mask_else, gs.float32)
coef_1 = gs.zeros_like(angle)
coef_2 = gs.zeros_like(angle)
coef_1 += mask_0_float * (1. + INV_SIN_TAYLOR_COEFFS[1] * angle**2 +
INV_SIN_TAYLOR_COEFFS[3] * angle**4 +
INV_SIN_TAYLOR_COEFFS[5] * angle**6 +
INV_SIN_TAYLOR_COEFFS[7] * angle**8)
coef_2 += mask_0_float * (1. + INV_TAN_TAYLOR_COEFFS[1] * angle**2 +
INV_TAN_TAYLOR_COEFFS[3] * angle**4 +
INV_TAN_TAYLOR_COEFFS[5] * angle**6 +
INV_TAN_TAYLOR_COEFFS[7] * angle**8)
# This avoids division by 0.
angle += mask_0_float * 1.
coef_1 += mask_else_float * angle / gs.sin(angle)
coef_2 += mask_else_float * angle / gs.tan(angle)
log = (gs.einsum('...i,...j->...j', coef_1, point) -
gs.einsum('...i,...j->...j', coef_2, base_point))
mask_same_values = gs.isclose(point, base_point)
mask_else = gs.equal(mask_same_values, gs.array(False))
mask_else_float = gs.cast(mask_else, gs.float32)
mask_else_float = gs.to_ndarray(mask_else_float, to_ndim=1)
mask_else_float = gs.to_ndarray(mask_else_float, to_ndim=2)
mask_not_same_points = gs.sum(mask_else_float, axis=1)
mask_same_points = gs.isclose(mask_not_same_points, 0.)
mask_same_points = gs.cast(mask_same_points, gs.float32)
mask_same_points = gs.to_ndarray(mask_same_points, to_ndim=2, axis=1)
mask_same_points_float = gs.cast(mask_same_points, gs.float32)
log -= mask_same_points_float * log
return log
def dist(self, point_a, point_b):
"""Compute the geodesic distance between two points.
Parameters
----------
point_a : array-like, shape=[..., dim + 1]
First point on the hypersphere.
point_b : array-like, shape=[..., dim + 1]
Second point on the hypersphere.
Returns
-------
dist : array-like, shape=[..., 1]
Geodesic distance between the two points.
"""
norm_a = self.embedding_metric.norm(point_a)
norm_b = self.embedding_metric.norm(point_b)
inner_prod = self.embedding_metric.inner_product(point_a, point_b)
cos_angle = gs.einsum('...,...->...', inner_prod,
1. / (norm_a * norm_b))
cos_angle = gs.clip(cos_angle, -1, 1)
dist = gs.arccos(cos_angle)
return dist
def squared_dist(self, point_a, point_b):
"""Squared geodesic distance between two points.
Parameters
----------
point_a : array-like, shape=[..., dim]
Point on the hypersphere.
point_b : array-like, shape=[..., dim]
Point on the hypersphere.
Returns
-------
sq_dist : array-like, shape=[...,]
"""
return self.dist(point_a, point_b)**2
@staticmethod
def parallel_transport(tangent_vec_a, tangent_vec_b, base_point):
"""Compute the parallel transport of a tangent vector.
Closed-form solution for the parallel transport of a tangent vector a
along the geodesic defined by exp_(base_point)(tangent_vec_b).
Parameters
----------
tangent_vec_a : array-like, shape=[..., dim + 1]
Tangent vector at base point to be transported.
tangent_vec_b : array-like, shape=[..., dim + 1]
Tangent vector at base point, along which the parallel transport
is computed.
base_point : array-like, shape=[..., dim + 1]
Point on the hypersphere.
Returns
-------
transported_tangent_vec: array-like, shape=[..., dim + 1]
Transported tangent vector at exp_(base_point)(tangent_vec_b).
"""
tangent_vec_a = gs.to_ndarray(tangent_vec_a, to_ndim=2)
tangent_vec_b = gs.to_ndarray(tangent_vec_b, to_ndim=2)
base_point = gs.to_ndarray(base_point, to_ndim=2)
# TODO (nguigs): work around this condition:
# assert len(base_point) == len(tangent_vec_a) == len(tangent_vec_b)
theta = gs.linalg.norm(tangent_vec_b, axis=1)
normalized_b = gs.einsum('n, ni->ni', 1 / theta, tangent_vec_b)
pb = gs.einsum('ni,ni->n', tangent_vec_a, normalized_b)
p_orth = tangent_vec_a - gs.einsum('n,ni->ni', pb, normalized_b)
transported = - gs.einsum('n,ni->ni', gs.sin(theta) * pb, base_point)\
+ gs.einsum('n,ni->ni', gs.cos(theta) * pb, normalized_b)\
+ p_orth
return transported
def christoffels(self, point, point_type='spherical'):
"""Compute the Christoffel symbols at a point.
Only implemented in dimension 2 and for spherical coordinates.
Parameters
----------
point : array-like, shape=[..., dim]
Point on hypersphere where the Christoffel symbols are computed.
point_type: str, {'spherical', 'intrinsic', 'extrinsic'}
Coordinates in which to express the Christoffel symbols.
Returns
-------
christoffel : array-like, shape=[..., contravariant index, 1st
covariant index, 2nd covariant index]
Christoffel symbols at point.
"""
if self.dim != 2 or point_type != 'spherical':
raise NotImplementedError(
'The Christoffel symbols are only implemented'
' for spherical coordinates in the 2-sphere')
point = gs.to_ndarray(point, to_ndim=2)
christoffel = []
for sample in point:
gamma_0 = gs.array([[0, 0],
[0, -gs.sin(sample[0]) * gs.cos(sample[0])]])
gamma_1 = gs.array([[0, gs.cos(sample[0]) / gs.sin(sample[0])],
[gs.cos(sample[0]) / gs.sin(sample[0]), 0]])
christoffel.append(gs.stack([gamma_0, gamma_1]))
christoffel = gs.stack(christoffel)
if gs.ndim(christoffel) == 4 and gs.shape(christoffel)[0] == 1:
christoffel = gs.squeeze(christoffel, axis=0)
return christoffel
class HypersphereMetric(RiemannianMetric):
"""Class for the Hypersphere Metric."""
def __init__(self, dimension):
super(HypersphereMetric, self).__init__(dimension=dimension,
signature=(dimension, 0, 0))
self.embedding_metric = EuclideanMetric(dimension + 1)
def inner_product(self, tangent_vec_a, tangent_vec_b, base_point=None):
"""Compute the inner product of two tangent vectors at a base point.
Parameters
----------
tangent_vec_a : array-like, shape=[n_samples, dimension + 1]
or shape=[1, dimension + 1]
tangent_vec_b : array-like, shape=[n_samples, dimension + 1]
or shape=[1, dimension + 1]
base_point : array-like, shape=[n_samples, dimension + 1]
or shape=[1, dimension + 1]
Returns
-------
inner_prod : array-like, shape=[n_samples, 1]
or shape=[1, 1]
"""
inner_prod = self.embedding_metric.inner_product(
tangent_vec_a, tangent_vec_b, base_point)
return inner_prod
def squared_norm(self, vector, base_point=None):
"""Compute squared norm of a vector.
Squared norm of a vector associated to the inner product
at the tangent space at a base point.
Parameters
----------
vector : array-like, shape=[n_samples, dimension + 1]
or shape=[1, dimension + 1]
base_point : array-like, shape=[n_samples, dimension + 1]
or shape=[1, dimension + 1]
Returns
-------
sq_norm : array-like, shape=[n_samples, 1]
or shape=[1, 1]
"""
sq_norm = self.embedding_metric.squared_norm(vector)
return sq_norm
def exp(self, tangent_vec, base_point):
"""Riemannian exponential of a tangent vector wrt to a base point.
Parameters
----------
tangent_vec : array-like, shape=[n_samples, dimension + 1]
or shape=[1, dimension + 1]
base_point : array-like, shape=[n_samples, dimension + 1]
or shape=[1, dimension + 1]
Returns
-------
exp : array-like, shape=[n_samples, dimension + 1]
or shape=[1, dimension + 1]
"""
tangent_vec = gs.to_ndarray(tangent_vec, to_ndim=2)
base_point = gs.to_ndarray(base_point, to_ndim=2)
# TODO(nina): Decide on metric.space or space.metric
# for the hypersphere
# TODO(nina): Raise error when vector is not tangent
n_base_points, extrinsic_dim = base_point.shape
n_tangent_vecs, _ = tangent_vec.shape
hypersphere = Hypersphere(dimension=extrinsic_dim - 1)
proj_tangent_vec = hypersphere.projection_to_tangent_space(
tangent_vec, base_point)
norm_tangent_vec = self.embedding_metric.norm(proj_tangent_vec)
mask_0 = gs.isclose(norm_tangent_vec, 0.)
mask_non0 = ~mask_0
coef_1 = gs.zeros((n_tangent_vecs, 1))
coef_2 = gs.zeros((n_tangent_vecs, 1))
norm2 = norm_tangent_vec[mask_0]**2
norm4 = norm2**2
norm6 = norm2**3
coef_1[mask_0] = 1. - norm2 / 2. + norm4 / 24. - norm6 / 720.
coef_2[mask_0] = 1. - norm2 / 6. + norm4 / 120. - norm6 / 5040.
coef_1[mask_non0] = gs.cos(norm_tangent_vec[mask_non0])
coef_2[mask_non0] = gs.sin(norm_tangent_vec[mask_non0]) / \
norm_tangent_vec[mask_non0]
n_coef_1 = n_tangent_vecs
if n_coef_1 != n_base_points:
if n_coef_1 == 1:
coef_1 = gs.squeeze(coef_1, axis=0)
einsum_str = 'i,nj->nj'
elif n_base_points == 1:
base_point = gs.squeeze(base_point, axis=0)
einsum_str = 'ni,j->nj'
else:
raise ValueError('Shape mismatch in einsum.')
else:
einsum_str = 'ni,nj->nj'
exp = (gs.einsum(einsum_str, coef_1, base_point) +
gs.einsum('ni,nj->nj', coef_2, proj_tangent_vec))
return exp
def log(self, point, base_point):
"""Compute Riemannian logarithm of a point wrt a base point.
Parameters
----------
point : array-like, shape=[n_samples, dimension + 1]
or shape=[1, dimension + 1]
base_point : array-like, shape=[n_samples, dimension + 1]
or shape=[1, dimension + 1]
Returns
-------
log : array-like, shape=[n_samples, dimension + 1]
or shape=[1, dimension + 1]
"""
point = gs.to_ndarray(point, to_ndim=2)
base_point = gs.to_ndarray(base_point, to_ndim=2)
norm_base_point = self.embedding_metric.norm(base_point)
norm_point = self.embedding_metric.norm(point)
inner_prod = self.embedding_metric.inner_product(base_point, point)
cos_angle = inner_prod / (norm_base_point * norm_point)
cos_angle = gs.clip(cos_angle, -1., 1.)
angle = gs.arccos(cos_angle)
angle = gs.to_ndarray(angle, to_ndim=1)
angle = gs.to_ndarray(angle, to_ndim=2, axis=1)
mask_0 = gs.isclose(angle, 0.)
mask_else = gs.equal(mask_0, gs.array(False))
mask_0_float = gs.cast(mask_0, gs.float32)
mask_else_float = gs.cast(mask_else, gs.float32)
coef_1 = gs.zeros_like(angle)
coef_2 = gs.zeros_like(angle)
coef_1 += mask_0_float * (1. + INV_SIN_TAYLOR_COEFFS[1] * angle**2 +
INV_SIN_TAYLOR_COEFFS[3] * angle**4 +
INV_SIN_TAYLOR_COEFFS[5] * angle**6 +
INV_SIN_TAYLOR_COEFFS[7] * angle**8)
coef_2 += mask_0_float * (1. + INV_TAN_TAYLOR_COEFFS[1] * angle**2 +
INV_TAN_TAYLOR_COEFFS[3] * angle**4 +
INV_TAN_TAYLOR_COEFFS[5] * angle**6 +
INV_TAN_TAYLOR_COEFFS[7] * angle**8)
# This avoids division by 0.
angle += mask_0_float * 1.
coef_1 += mask_else_float * angle / gs.sin(angle)
coef_2 += mask_else_float * angle / gs.tan(angle)
log = (gs.einsum('ni,nj->nj', coef_1, point) -
gs.einsum('ni,nj->nj', coef_2, base_point))
mask_same_values = gs.isclose(point, base_point)
mask_else = gs.equal(mask_same_values, gs.array(False))
mask_else_float = gs.cast(mask_else, gs.float32)
mask_else_float = gs.to_ndarray(mask_else_float, to_ndim=1)
mask_else_float = gs.to_ndarray(mask_else_float, to_ndim=2)
mask_not_same_points = gs.sum(mask_else_float, axis=1)
mask_same_points = gs.isclose(mask_not_same_points, 0.)
mask_same_points = gs.cast(mask_same_points, gs.float32)
mask_same_points = gs.to_ndarray(mask_same_points, to_ndim=2, axis=1)
mask_same_points_float = gs.cast(mask_same_points, gs.float32)
log -= mask_same_points_float * log
return log
def dist(self, point_a, point_b):
"""Compute geodesic distance between two points.
Parameters
----------
point_a : array-like, shape=[n_samples, dimension + 1]
or shape=[1, dimension + 1]
point_b : array-like, shape=[n_samples, dimension + 1]
or shape=[1, dimension + 1]
Returns
-------
dist : array-like, shape=[n_samples, 1]
or shape=[1, 1]
"""
norm_a = self.embedding_metric.norm(point_a)
norm_b = self.embedding_metric.norm(point_b)
inner_prod = self.embedding_metric.inner_product(point_a, point_b)
cos_angle = inner_prod / (norm_a * norm_b)
cos_angle = gs.clip(cos_angle, -1, 1)
dist = gs.arccos(cos_angle)
return dist
def parallel_transport(self, tangent_vec_a, tangent_vec_b, base_point):
"""Parallel transport of a tangent vector.
Closed-form solution for the parallel transport of a tangent vector a
along the geodesic defined by exp_(base_point)(tangent_vec_b)
Parameters
----------
tangent_vec_a : array-like, shape=[n_samples, dimension + 1]
tangent_vec_b : array-like, shape=[n_samples, dimension + 1]
base_point : array-like, shape=[n_samples, dimension + 1]
Returns
-------
transported_tangent_vec: array-like, shape=[n_samples, dimension + 1]
"""
tangent_vec_a = gs.to_ndarray(tangent_vec_a, to_ndim=2)
tangent_vec_b = gs.to_ndarray(tangent_vec_b, to_ndim=2)
base_point = gs.to_ndarray(base_point, to_ndim=2)
# TODO @nguigs: work around this condition
assert len(base_point) == len(tangent_vec_a) == len(tangent_vec_b)
theta = gs.linalg.norm(tangent_vec_b, axis=1)
normalized_b = gs.einsum('n, ni->ni', 1 / theta, tangent_vec_b)
pb = gs.einsum('ni,ni->n', tangent_vec_a, normalized_b)
p_orth = tangent_vec_a - gs.einsum('n,ni->ni', pb, normalized_b)
transported = - gs.einsum('n,ni->ni', gs.sin(theta) * pb, base_point)\
+ gs.einsum('n,ni->ni', gs.cos(theta) * pb, normalized_b)\
+ p_orth
return transported
def christoffels(self, point, point_type='spherical'):
"""Compute Christoffel symbols.
Only implemented in dimension 2 and for spherical coordinates.
Parameters
----------
point : array-like, shape=[n_samples, dimension]
point_type: str
Returns
-------
christoffel : array-like, shape=[n_samples,
contravariant index,
first covariant index,
second covariant index]
"""
if self.dimension != 2 or point_type != 'spherical':
raise NotImplementedError(
'The Christoffel symbols are only implemented'
' for spherical coordinates in the 2-sphere')
point = gs.to_ndarray(point, to_ndim=2)
christoffel = []
for sample in point:
gamma_0 = gs.array([[0, 0],
[0, -gs.sin(sample[0]) * gs.cos(sample[0])]])
gamma_1 = gs.array([[0, gs.cos(sample[0]) / gs.sin(sample[0])],
[gs.cos(sample[0]) / gs.sin(sample[0]), 0]])
christoffel.append(gs.stack([gamma_0, gamma_1]))
return gs.stack(christoffel)
def test_norm(self, dim, vec, expected):
metric = EuclideanMetric(dim)
self.assertAllClose(metric.norm(gs.array(vec)), gs.array(expected))