Operations on SO3 Lie Groups in Python

Target audience: Advanced

Estimated reading time: 5'

Posts history

Newsletter: Geometric Learning in Python 

Lie groups play a crucial role in Geometric Deep Learning by modeling symmetries such as rotation, translation, and scaling. This enables non-linear models to generalize effectively for tasks like object detection and transformations in generative models.

Table of contents

Overview

       Lie manifolds

       Why Lie groups

       Examples of Lie groups

Special Orthogonal Group

       Implementation

       Inverse rotation

       Composition

References

What you will learn:  How to implement and evaluate key operations on 3-dimension Special Orthogonal Lie Group.

Notes: 

• This post is a follow up on articles related to differential geometry and geometry learning [ref 1, 2, 3 and 4]
• Environments: Python 3.11,  Matplotlib 3.9, Geomstats 2.8.0
• Source code is available at  Github.com/patnicolas/Data_Exploration/Lie
• To enhance the readability of the algorithm implementations, we have omitted non-essential code elements like error checking, comments, exceptions, validation of class and method arguments, scoping qualifiers, and import statement.

Disclaimer : A thorough tutorial and explanation of Lie groups, Lie algebras, and geometric priors for deep learning models is beyond the scope of this article. Instead, the following sections concentrate on experiments involving key elements and operations on Lie groups using the Geomstats Python library [ref 5].

 

Overview

Let's start with some basic definitions

Lie manifolds

A smooth manifold is a topological space that locally resembles Euclidean space and allows for smooth (infinitely differentiable) transitions between local coordinate systems. This structure allows for the use of calculus on the manifold. 

The tangent space at a point on a manifold is the set of tangent vectors at that point, like a line tangent to a circle or a plane tangent to a surface.

Tangent vectors can act as directional derivatives, where you can apply specific formulas to characterize these derivatives.

Fig. 1 Manifold with tangent space and exponential/logarithm maps

In differential geometry, a Lie group is a mathematical structure that combines the properties of both a group and a smooth manifold. It allows for the application of both algebraic and geometric techniques. As a group, it has an operation (like multiplication) that satisfies certain axioms (closure, associativity, identity, and invertibility) [ref 6].

A 'real' Lie group is a set G with two structures: G is a group and G is a (smooth, real) manifold. These structures agree in the following sense: multiplication (a.k.a. product or composition) and inversion are smooth maps.
A morphism of Lie groups is a smooth map which also preserves the group operation: f(gh) = f(g)f(h) and f(1) = 1.

Fig. 2 Manifold with tangent space and identity and group element 

(Courtesy A. Kirillov Jr Department of Mathematics SUNY at Stony Brook)

Why Lie groups

Lie groups have numerous practical applications in various fields:

• Physics: They describe symmetries in classical mechanics, quantum mechanics, and relativity. 
• Robotics: Lie groups model the motion of robots, particularly in the context of rotation and translation (using groups like SO(3) and SE(3)).
• Control Theory: Lie groups are used in the analysis and design of control systems, especially in systems with rotational or symmetrical behavior.
• Computer Vision: They help in image processing and 3D vision, especially in tasks involving rotations and transformations.
• Differential Equations: Lie groups are instrumental in solving differential equations by leveraging symmetry properties.

In term of machine learning...

• Geometric Deep Learning: Lie groups help capture rotational, translational, or scaling symmetries, making models more efficient and generalizable in tasks like image recognition and 3D object detection.
• Generative Models: Lie groups allow for more structured latent spaces, enabling better control over transformations in generative models like GANs and VAEs.
• Reinforcement Learning: They are used to model continuous action spaces, improving control over robotic systems.
• Optimization: Lie groups help design efficient optimization techniques on curved spaces, like Riemannian manifolds.

Examples of Lie groups

Group of Invertible 2 x 2 matrices of real values

Group of Invertible 2 x 2 matrices of complex values

Group of Invertible 3 x 3 matrices of real values

Special Unitary group 2 x 2 matrices with determinant 1

Special Unitary group 3 x 3 matrices with determinant 1

Special Orthogonal (3D rotation, 2x2 matrices) group

Special Orthogonal (3D rotation, 3x3 matrices) group

Special Euclidean group

Special Orthogonal Group

The Special Orthogonal Group in 3 dimensions, SO(3) is the group of all rotation matrices in 3 spatial dimensions.

It can be defined by 3 rotation elements for each of the axis of rotation x, y, and z.

Implementation

Geomstats is a free, open-source Python library designed for conducting machine learning on data situated on nonlinear manifolds, an area known as Geometric Learning. This library offers object-oriented, thoroughly unit-tested features for fundamental manifolds, operations, and learning algorithms, compatible with various execution environments, including NumPy, PyTorch, and TensorFlow (Overview Geomstats library).

The library is structured into two principal components:

• geometry: This part provides an object-oriented framework for crucial concepts in differential geometry, such as exponential and logarithm maps, parallel transport, tangent vectors, geodesics, and Riemannian metrics.
• learning: This section includes statistics and machine learning algorithms tailored for manifold data, building upon the scikit-learn framework.

First let's wrap the element of a point or matrix into a class, SO3Point with the following attributes:

• group_element Point on the manifold
• base_point on the manifold (Identity if undefined)
• description which describes the rotation matrix

from dataclasses import dataclass

@dataclass
class SO3Point:
    group_element: np.array
    base_point: np.array                # Default identity matrix
    descriptor: AnyStr

Secondly, let's build a class ,LieSO3Group, that encapsulates the definition of the Special orthogonal group of dimension 3 and its related operations.

We specify two constructors:

• __init__: Default constructor that create a new element in the SO3 manifold, group_element, using a tangent vector (3x3 rotation matrix) tgt_vector and identity, base_point.
• build: Alternative constructor for which the tangent vector is a 9- element list and a tuple as base point.

import geomstats.backend as gs
from geomstats.geometry.special_orthogonal import SpecialOrthogonal

class LieSO3Group(object):
    dim = 3
    # Lie group as defined in Geomstats library
    lie_group =  SpecialOrthogonal(n=dim, point_type='vector', equip=False)

    identity = gs.eye(dim)     # Define identity

    def __init__(self, tgt_vector: np.array, base_point: np.array = identity) -> None

        self.tangent_vec = gs.array(tgt_vector)

        # Exp. a left-invariant vector field from a base point
        self.group_element = LieSO3Group.lie_group.exp(self.tangent_vec, base_point)
        self.base_point = base_point

    @classmethod
    def build(cls, tgt_vector: List[float], base_point: List[float] = None) -> Self:
        np_input = np.reshape(tgt_vector, (3, 3))

        np_point = np.reshape(base_point, (3, 3)) if base_point is not None 

                          else LieSO3Group.identity

        return cls(tgt_vector=np_input, base_point=np_point)

We use the constructors of the LieSO3Group class to generate two points on the SO3 manifold, so3_point1 and so3_point2. These points are represented as vectors in 3-dimensional Euclidean space for visualization purposes.

The first point use the identity as base point for the tangent space of rotation of 90 degrees around X axis:

[[ 1.  0.  0.]

 [ 0.  0. -1.]

 [ 0.  1.  0.]]

The second SO3 point used the same tangent vector with a base 

[[ 0.  -1.  0.]

 [ 1.   0.  0.]

 [ 0.   0.  1.]]

so3_tangent_vec = [1.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, 1.0, 0.0]

# First rotation matrix +90 degrees around X-axis with identity as base point
so3_group = LieSO3Group.build(so3_tangent_vec)
so3_point1 = SO3Point(
     group_element=so3_group.group_element,
     base_point=LieSO3Group.identity,
     descriptor='SO3 point from tangent vector\n[1 0 0]\n[0 0 -1]\n[0 1 0]\nBase point: Identity')

# Same rotation matrix with another rotation matrix 90 degrees around

# Y-axis for base point
base_point = [0.0, -1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0]
so3_group2 = LieSO3Group.build(so3_tangent_vec, base_point)
so3_point2 = SO3Point(
     group_element=so3_group2.group_element,
     base_point=base_point,
     descriptor='Same SO3 point\nBase point:\n[0 -1 0]\n[0 0 0]\n[0 0 1]')

LieSO3Group.visualize_all([so3_point1, so3_point2])

so3_point1:

[[ 2.00   0.00   0.00]                                      [[2  0   0]

 [ 0.00   0.93 -0.99]       approximation of      [0  1  -1]

 [ 0.00   0.99  0.93]]                                       [0  1   1]]

so3_point2:

[[ 0.99  -0.93  0.00]                                       [[1 -1   0]

 [ 0.93   0.00 -0.99]        approximation of     [1   0  -1]

 [ 0.00   0.99  0.93]]                                       [0   1   1]

The code for the visualization methods are available on Github at LieSO3Group

Fig. 3 Visualization of SO3 group element at identity vs. arbitrary base point

Inverse rotation

The first operation to illustrate is the inverse rotation using Geomstats library. It is implemented by the LieSO3Group method inverse.

def inverse(self) -> Self:
    inverse_group_element = LieSO3Group.lie_group.inverse(self.group_element)
    return LieSO3Group(inverse_group_element)

For simplicity sake, we create a SO3 group element at identity and visualize its inverse on the same base point.

# Original rotation matrix +90 degrees around X-axis with identity as base point
\so3_tangent_vec = [1.0 0.0,0.0, 0.0, 0.0, -1.0, 0.0, 1.0, 0.0]

so3_group = LieSO3Group.build(so3_tangent_vec)
so3_point = SO3Point(
     group_element=so3_group.group_element,
     base_point=LieSO3Group.identity,
     descriptor='SO3 point from tangent vector\n[1 0 0]\n[0 0 -1]\n[0 1 0]\nBase point: Identity')

 # Inverse SO3 rotation matrix

so3_inv_group = so3_group.inverse()

inv_so3_point = SO3Point(
     group_element=so3_inv_group.group_element,
     base_point=LieSO3Group.identity,

     descriptor='SO3 inverse point')

As expected, the inverse of an SO3 group element represents the inverse rotation in 3-dimensional space. This would not hold true if the base point were not the identity element.

Original SO3 point

[[ 2.00    0.00     0.00]

 [ 0.00    0.93   -0.99]

 [ 0.00    0.99    0.93]]

SO3 Inverse point:

[[-1.00  0.00  0.00]

 [ 0.00  0.00  0.93]

 [ 0.00 -0.93  0.00]]

Fig. 4 Visualization of the inverse of SO3 element at identity

Composition

As previously mentioned, a smooth manifold with the structure of a Lie group ensures that the product (or composition) of two elements also belongs to the manifold. The following LieSO3Group method, product, utilizes the `compose method of Geomstats library.

def product(self, lie_so3_group: Self) -> Self:
     composed_group_point = LieSO3Group.lie_group.compose(self.group_element lie_so3_group.group_element)
     return LieSO3Group(composed_group_element)

In this initial test, we use the rotation matrix of 90 degrees around Z-axes as the second component for the composition.

# Second SO3 rotation matrix +90 degree along Z-axis
so3_tangent_vec2 = [0.0, -1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0]

so3_group2 = LieSO3Group.build(tgt_vector=so3_tangent_vec2)
so3_point2 = SO3Point(
      group_element=so3_group2.group_element,
      base_point=LieSO3Group.identity

      descriptor='SO3 point from tangent vector\n[0 -1 0]\n[1  0 0]\n[0  0 1]\nBase point: Identity')

# Composition of two rotation matrices SO3 group
so3_group_product = so3_group.product(so3_group2)
    

Composition of rotation matrix +90 degrees along X-axis with  rotation matrix +90 degrees along Z-axis:

[[-2.11   0.62   0.96]

 [ 1.52   1.74 -1.52 ]

 [-0.96  -0.62 -2.11 ]]

As expected, the composition produces an anti-symmetric matrix

Fig. 5 Visualization of the composition of a SO3 group element with its inverse at identity

The second evaluation consists of composing the initial SO3 group element (90 degrees rotation along X axis) with identity matrix.

[[-1.28   0.00    0.00 ]

 [-0.96  -2.11    0.62]

 [-0.96  -0.62  -2.11]]

Fig. 6  Visualization of the composition of two SO3 group elements at identity

References

[1] Foundation of Geometric Learning

[2] Differentiable Manifolds for Geometric Learning

[3] Intrinsic Representation in Geometric Learning

[4] Riemann Metric and Connection

[5] Introduction to Geometric Learning in Python with Geomstats

[6] Introduction to Lie Groups and Lie Algebras - A. Kirillov, Jr - SUNY at Stony Brook

----------------------------------

Patrick Nicolas has over 25 years of experience in software and data engineering, architecture design and end-to-end deployment and support with extensive knowledge in machine learning. 
He has been director of data engineering at Aideo Technologies since 2017 and he is the author of "Scala for Machine Learning", Packt Publishing ISBN 978-1-78712-238-3 and Geometric Learning in Python Newsletter on LinkedIn.

Fisher Information Matrix

Target audience: Advanced

Estimated reading time: 7'

Posts history

Newsletter: Geometric Learning in Python        

The Fisher Information Matrix plays a crucial role in various aspects of machine learning and statistics. Its primary significance lies in providing a measure of the amount of information that an observable random variable carries about an unknown parameter upon which the probability depends.

Table of contents

Introduction

Information Geometry

       Key elements

       Use cases

Fisher information matrix

Implementation

       Normal distribution

       Beta distribution

References

Appendix

What you will learn: How to estimate and visualize the Fisher information matrix for Normal and Beta distributions on a hypersphere.

Notes: 

• Environments: Python  3.10.10, Geomstats 2.7.0
• This article assumes that the reader is somewhat familiar with differential and tensor calculus [ref 1]. Please refer to our previous articles related to geometric learning listed on Appendix.
• Source code is available at  Github.com/patnicolas/Data_Exploration/Information Geometry
• To enhance the readability of the algorithm implementations, we have omitted non-essential code elements like error checking, comments, exceptions, validation of class and method arguments, scoping qualifiers, and import statements.

Introduction

This article is the 10th installments of our ongoing series focused on geometric learning. It introduces some basic elements of information geometry as an extension of differential geometry. As with previous articles, we utilize the Geomstats Python library [ref. 2] to implement concepts associated with geometric learning. 

Note: Summaries of my earlier articles on this topic can be found in the Appendix

As a reminder, the primary goal of learning Riemannian geometry is to understand and analyze the properties of curved spaces that cannot be described adequately using Euclidean geometry alone. 

Here is a synapsis of this article

1. Brief introduction to information geometry
2. Overview and mathematical formulation of the Fisher information matrix
3. Computation of the Fisher metric to Normal and Beta distributions
4. Implementation in Python using the Geomstats library

Information geometry

Information geometry applies the principles and methods of differential geometry to problems in probability theory and statistics [ref 3]. It studies the manifold of probability distributions and provides a natural framework for understanding and analyzing statistical models.

Key elements

• Statistical manifolds: Families of probability distributions are considered as a manifold, with each distribution representing a point on this manifold.
• Riemannian metrics: The Fisher information metric is commonly used to define a Riemannian metric on the statistical manifold. This metric measures the amount of information that an observable random variable carries about an unknown parameter.
• Divergence measures: Divergence measures like the Kullback-Leibler (KL) divergence, which quantify the difference between two probability distributions.
• Connections and curvature: Differential geometry concepts such as affine connections and curvature are used to describe the geometric properties of statistical models (i.e. α-connection family).
• Dualistic inference: Exponential and mixture connections provide a rich structure for statistical inference.

Use cases

Here is a non-exclusive list of application of information geometry

• Statistical Inference: Parameter estimation, hypothesis testing, and model selection (i.e. Bayesian posterior distributions and in the development of efficient sampling algorithms like Hamiltonian Monte Carlo)
• Optimization: Natural gradient descent method uses the Fisher information matrix to adjust the learning rate dynamically, leading to faster convergence compared to traditional gradient descent.
• Finance: Modeling uncertainties and analyzing statistical properties of financial models.
• Machine Learning: Optimization of learning algorithms (i.e. Understanding the EM algorithm used in statistical estimation for latent variable model)
• Neuroscience: Neural coding and information processing in the brain by modeling neural responses as probability distributions.
• Robotics: Development of probabilistic robotics, where uncertainty and sensor noise are modeled using probability distributions.
• Information Theory: Concepts for encoding, compression, and transmission of information.

Fisher information matrix

The Fisher information matrix is a type of Riemannian metric that can be applied to a smooth statistical manifold [ref 4]. It serves to quantify the informational difference between measurements. The points on this manifold represent probability measures defined within a Euclidean probability space, such as the Normal distribution. Mathematically, it is represented by the Hessian of the Kullback-Leibler divergence.

Let's consider a statistical manifold with coordinates (or parameters) θ and its probability density functions over an interval X as follow:\[P= \left \{ p(x, \theta); \ x \in X \ \int_{R}^{} p(x, \theta) dx = 1\right \}\]The Fisher metric is a Riemann metric tensor defined as the expectation of the partial derivative of the negative log likelihood over two coordinates θ.\[g_{ij}(\theta) = -E\left [ \frac{\partial^2\ log\ p(x,\theta) }{\partial \theta_{i}\partial\theta_{j}} \right ] = - \int_{R}^{}{\frac{\partial^2\ log\ p(x,\theta)) }{\partial \theta_{i}\partial\theta_{j}}}p(x, \theta)dx\]

The Fisher information or Fisher-Rao metric quantifies the amount of information in the data regarding a parameter θ. The Fisher-Rao metric, an intrinsic measure, enables the analysis of a finite, n-dimensional statistical manifold M.\[ds=\sum_{i=1}^{p}{\sum_{j=1}^{p}}g_{ij}\theta^{i}\theta^{j}\]

The Fisher metric for the normal distribution θ = {μ, σ} is computed as:\[\mathfrak{I}(\mu, \sigma)=-\textit{E}_{x-p}\begin{bmatrix} \frac{\partial ^2\ log\ p(\theta)}{\partial \mu^2} & \frac{\partial ^2\ log\ p(\theta)}{\partial \mu \partial \sigma} \\ \frac{\partial ^2\ log\ p(\theta)}{\partial \sigma \partial \mu} & \frac{\partial ^2\ log\ p(\theta)}{\partial \sigma^2} \end{bmatrix} = \begin{bmatrix} \sigma^{-2} & 0\\ 0 & 2\sigma^{-2} \end{bmatrix}\]

The Fisher metric for the beta distribution  θ = {α, β} is computed as:\[\varphi (z)=\frac{d^2}{dz^2}\ log \ \Gamma (z)\]

\[\mathfrak{I(\alpha,\beta)}=-\textit{E}_{x-p}\begin{bmatrix} \frac{\partial ^2\ log\ p(\theta)}{\partial \alpha^2} & \frac{\partial ^2\ log\ p(\theta)}{\partial \alpha \partial \beta} \\ \frac{\partial ^2\ log\ p(\theta)}{\partial \beta \partial \alpha} & \frac{\partial ^2\ log\ p(\theta)}{\partial \beta^2} \end{bmatrix}\]

\[\mathfrak{I(\alpha,\beta)}=\begin{bmatrix} \varphi(\alpha)-\varphi(\alpha+\beta) & -\varphi(\alpha+\beta)\\ -\varphi(\alpha+\beta) & \varphi(\beta)-\varphi(\alpha+\beta) \end{bmatrix}\]

Implementation

We leverage the following classes defined in the previous articles:

• ManifoldPoint in Riemann Metric & Connection for Geometric Learning - Setup
• HypersphereSpace in Differentiable Manifolds for Geometric Learning - Hypersphere
  

Let's first define a base class for all distributions to be defined on a hypersphere [ref 5].

class GeometricDistribution(object):
    _ZERO_TGT_VECTOR = [0.0, 0.0, 0.0]

    def __init__(self) -> None:
        self.manifold = HypersphereSpace(True)

    def show_points(self, num_pts: int, tgt_vector: List[float] = _ZERO_TGT_VECTOR) -> NoReturn:
        # Random point generated on the hypersphere

        manifold_pts = self._random_manifold_points(num_pts, tgt_vector)
        

        # Exponential map used to project the tgt vector on the hypersphere

        exp_map = self.manifold.tangent_vectors(manifold_pts)

        for v, end_pt in exp_map:
            print(f'Tangent vector: {v} End point: {end_pt}')
        self.manifold.show_manifold(manifold_pts)

The purpose of the method show_points is to display the various data point with optional tangent vector on the hypersphere. The argument num_pts specifies the number of random points to be defined in the hypersphere. The tangent vector is displayed if the argument tgt_vector not defined as the origin (_ZERO_TGT_VECTOR).

Normal distribution

The class NormalHypersphere encapsulates the display of the normal distribution on the hypersphere. The constructor initialized the normal distribution implemented in the Geomstats library.

The method show_distribution display num_pdfs probability density function over a set of num_manifold_pts, manifold points on the hypersphere. This specific implementation uses only two points. The Fisher-Rao metric is computed using the metric.geodesic Geomstats method.

The metric is applied to 100 points along the geodesic between the two points A and B. Finally, the density functions, pdfs are computed by converting the metric values to the NormalDistribution.point_to_pdf Geomstats method.

class NormalHypersphere(GeometricDistribution):

    def __init__(self) -> None:
        from geomstats.information_geometry.normal import NormalDistributions

        super(NormalHypersphere, self).__init__()
        self.normal = NormalDistributions(sample_dim=1)

    def show_distribution(self, num_pdfs: int, num_manifold_pts: int) -> NoReturn:
        manifold_pts = self._random_manifold_points(num_manifold_pts)

        A = manifold_pts[0]

        B = manifold_pts[1]

        # Apply the Fisher metric for the two manifold points on a Hypersphere
        geodesic_ab_fisher = self.normal.metric.geodesic(A.location, B.location)
        t = gs.linspace(0, 1, 100)

        # Generate the various density functions associated to the Fisher metric between the
        # two points on the hypersphere
        pdfs = self.normal.point_to_pdf(geodesic_ab_fisher(t))
        x = gs.linspace(0.2, 0.7, num_pdfs)

        for i in range(num_pdfs):
            plt.plot(x, pdfs(x)[i, :]/20.0)   # Normalization factor
        plt.title(f'Normal distribution on Hypersphere')
        plt.show()

Let's plot 2 randomly sampled data points associated with a tangent_vector on Hypersphere (1) then visualize 40 normalized normal probability density distributions (2).

normal_dist = NormalHypersphere()
num_points = 2
tangent_vector = [0.4, 0.7, 0.2]

         # 1. Display the 2 data points on the hypersphere
num_manifold_pts = normal_dist.show_points(num_points, tangent_vector)

        # 2. Visualize the 40 normal probabilities density functions
num_pdfs = 40
succeeded = normal_dist.show_distribution(num_pdfs, num_points)

Fig. 1 Two random data points on a Hypersphere with their tangent vectors 

Fig. 2 Visualization of Normal distribution between two random points on a hypersphere

Beta distribution

Let's wrap the evaluation of the Beta distribution on a hypersphere into the class BetaHypersphere that inherits GeometriDistribution. It leverages the BetaDistributions class in Geomstats. 

class BetaHypersphere(GeometricDistribution):

    def __init__(self) -> None:

        from geomstats.information_geometry.beta import BetaDistributions

        super(BetaHypersphere, self).__init__()

        self.beta = BetaDistributions()

    def show_distribution(self, num_manifold_pts: int, num_interpolations: int) -> NoReturn:

        # 1. Generate random points on Hypersphere using Von Mises algorithm
        manifold_pts = self._random_manifold_points(num_manifold_pts)
        t = gs.linspace(0, 1.1, num_interpolations)[1:]
        # 2. Define the beta pdfs associated with each
        beta_values_pdfs = [self.beta.point_to_pdf(manifold_pt.location)(t) for manifold_pt in manifold_pts]

        # 3. Generate, normalize and display each Beta distribution
        for beta_values in beta_values_pdfs:
            min_beta = min(beta_values)
            delta_beta = max(beta_values) - min_beta
            y = [(beta_value - min_beta)/delta_beta  for beta_value in beta_values]
            plt.plot(t, y)
        plt.title(f'Beta distribution on Hypersphere')
        plt.show()

The method show_distribution generates random points on the Hypersphere (1)  and compute the beta density function at these points using the Geomstats BetaDistributions.point_to_pdf (2).

The values generated by the pdfs are normalized then plotted (3)

Let's plot 10 randomly sampled data points on Hypersphere (1) then visualize 200 normalized beta probability density distributions (2).

beta_dist = BetaHypersphere()
        
num_interpolations = 200
num_manifold_pts = 10

    # 1. Display the 10 data points on the hypersphere
beta_dist.show_points(num_manifold_pts)

   # 2. Visualize the probabilities density functions with interpolation points

succeeded = beta_dist.show_distribution(num_manifold_pts, num_interpolations)

Fig. 3  10 random data points with on a Hypersphere

Fig. 4 Visualization of Beta distributions associated with 10 data points on hypersphere

References

[1] Tensor Calculus - Eigenchris

[2] Introduction to Geometric Learning in Python with Geomstats

[3] An elementary introduction to information geometry - F. Nielsen

[4] Information Geometry - Near Randomness and Near Independence  K. Arwini, CTJ Dobson - Springer-Verlag 2008

[5] Differentiable Manifolds for Geometric Learning: Hypersphere

--------------------------------------
Patrick Nicolas has over 25 years of experience in software and data engineering, architecture design and end-to-end deployment and support with extensive knowledge in machine learning. 
He has been director of data engineering at Aideo Technologies since 2017 and he is the author of "Scala for Machine Learning", Packt Publishing ISBN 978-1-78712-238-3 and Geometric Learning in Python Newsletter on LinkedIn.

Appendix

Here is the list of published articles related to geometric learning:

• Foundation of Geometric Learning introduces differential geometry as an applied to machine learning and its basic components.
• Differentiable Manifolds for Geometric Learning describes manifold components such as tangent vectors, geodesics with implementation in Python for Hypersphere using the Geomstats library.
• Intrinsic Representation in Geometric learning reviews the various coordinates system using extrinsic and intrinsic representation.
• Vector and Covector fields in Python describes vector and co-vector fields with Python implementation in 2 and 3-dimension spaces.
• Geometric Learning in Python: Vector Operators illustrates the differential operators, gradient, divergence, curl and laplacian using SymPy library.
• Functional Data Analysis in Python describes the key elements of non-linear functional data analysis to analysis curves, images, or functions in very  high-dimensional spaces
• Riemann Metric & Connection for Geometric Learning reviews Riemannian metric tensor, Levi-Civita connection and parallel transport for hypersphere.
• Riemann Curvature in Python describes the intricacies of Riemannian metric curvature tensor and its implementation in Python using Geomstats library.
• K-means on Riemann Manifolds compares the implementation of k-means algorithm on Euclidean space using Scikit-learn and hypersphere using Geomstats
• Logistic Regression on Riemann Manifolds describes the implementation of the logistic regression on Hypersphere.