morphomatics 4.1__tar.gz → 4.1.2__tar.gz

{morphomatics-4.1 → morphomatics-4.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: morphomatics
-Version: 4.1
+Version: 4.1.2
 Summary: Geometric morphometrics in non-Euclidean shape spaces
 Home-page: https://morphomatics.github.io/
 Author: Christoph von Tycowicz et al.

{morphomatics-4.1 → morphomatics-4.1.2}/morphomatics/__init__.py

@@ -3,11 +3,11 @@
 #   This file is part of the Morphomatics library                              #
 #       see https://github.com/morphomatics/morphomatics                       #
 #                                                                              #
-#   Copyright (C) 2024 Zuse Institute Berlin                                   #
+#   Copyright (C) 2025 Zuse Institute Berlin                                   #
 #                                                                              #
 #   Morphomatics is distributed under the terms of the MIT License.            #
 #       see $MORPHOMATICS/LICENSE                                              #
 #                                                                              #
 ################################################################################
 
-__version__ = '4.1'
+__version__ = '4.1.2'

morphomatics-4.1.2/morphomatics/manifold/diffeomorphism.py

@@ -0,0 +1,167 @@
+################################################################################
+#                                                                              #
+#   This file is part of the Morphomatics library                              #
+#       see https://github.com/morphomatics/morphomatics                       #
+#                                                                              #
+#   Copyright (C) 2025 Zuse Institute Berlin                                   #
+#                                                                              #
+#   Morphomatics is distributed under the terms of the MIT License.            #
+#       see $MORPHOMATICS/LICENSE                                              #
+#                                                                              #
+################################################################################
+
+import numpy as np
+import jax
+import jax.numpy as jnp
+
+from jax.experimental.ode import odeint
+
+from morphomatics.manifold import Manifold, LieGroup
+from .util import LazyKernel
+
+
+class Diffeomorphism(Manifold):
+    """The diffeomorphism group, i.e. manifold of smooth invertible automorphisms of ambient space.
+
+    Diffeomorphisms model plausible deformations of the ambiant space
+    and, hence, any objects embedded therein. The parameter is a
+    discrete vector field (referred to as the momentum). The diffeomorhism is
+    given by integrating the smooth vector field obtained from the momentum by (kernel) smoothing.
+    """
+
+    def __init__(self, control_pts: jax.Array, scale: float = 0.1, structure="Group"):
+        """Initialize the Diffeomorphism manifold.
+        Args:
+            control_pts (jax.Array): Control points defining the diffeomorphism.
+            scale (float): Scale of the kernel.
+        """
+
+        if control_pts.ndim != 2:
+            raise ValueError("Control points must be a 2D array (shape: [n_points, n_features]).")
+        self._control_pts = control_pts
+        self._scale = scale
+        dim = np.prod(control_pts.shape)
+
+        name = 'Diffeomorphism group'
+        dimension = None
+        super().__init__(name, dim, point_shape=control_pts.shape)
+
+        if structure:
+            getattr(self, f'init{structure}Structure')()
+
+    def tree_flatten(self):
+        children, aux = super().tree_flatten()
+        return children + (self._control_pts, self._scale), aux
+
+    @classmethod
+    def tree_unflatten(cls, aux_data, children):
+        """Specifies an unflattening recipe for PyTree registration."""
+        *children, pts, scale = children
+        obj = cls(pts, scale, structure=None)
+        obj.tree_unflatten_instance(aux_data, children)
+        return obj
+
+    def initGroupStructure(self):
+        """Initialize the group structure of the diffeomorphism manifold."""
+        self._group = Diffeomorphism.GroupStructure(self)
+
+    def proj(self, p, X):
+        return X
+
+    def rand(self, key: jax.Array):
+        return jax.random.normal(key, self.point_shape)
+
+    def randvec(self, X, key: jax.Array):
+        return jax.random.normal(key, self.point_shape)
+
+    def zerovec(self, X):
+        return jnp.zeros_like(X)
+
+    class GroupStructure(LieGroup):
+        """Group structure for the diffeomorphism manifold."""
+
+        def __init__(self, M: 'Diffeomorphism'):
+            super().__init__(M)
+
+        def __str__(self):
+            return "Group structure on diffeomorphism manifold"
+
+        @property
+        def identity(self):
+            return jnp.zeros_like(self._M._control_pts)
+
+        def coords(self, X):
+            return X
+
+        def coords_inv(self, X):
+            return X
+
+        def bracket(self, X, Y):
+            raise NotImplementedError("Bracket operation is not implemented for diffeomorphisms.")
+
+        def lefttrans(self, g, f):
+            raise NotImplementedError("Left translation is not implemented for diffeomorphisms.")
+
+        def righttrans(self, g, f):
+            raise NotImplementedError("Right translation is not implemented for diffeomorphisms.")
+
+        def inverse(self, g):
+            raise NotImplementedError("Inverse is not implemented for diffeomorphisms.")
+
+        def exp(self, *argv):
+            if len(argv) == 2:
+                raise NotImplementedError("CCS connection exponential map is not implemented for diffeomorphisms.")
+            # we represent diffeomorphisms via momenta, so just return input momentum
+            return argv[0]
+
+        def log(self, *argv):
+            if len(argv) == 2:
+                raise NotImplementedError("CCS connection logarithmic map is not implemented for diffeomorphisms.")
+            # we represent diffeomorphisms via momenta, so just return input diffeomorphism
+            return argv[0]
+
+        def retr(self, p, X):
+            raise NotImplementedError("Retraction is not implemented for diffeomorphisms.")
+
+        def curvature_tensor(self, f, X, Y, Z):
+            raise NotImplementedError("Curvature tensor is not implemented for diffeomorphisms.")
+
+        def transp(self, f, g, X):
+            raise NotImplementedError("Parallel transport is not implemented for diffeomorphisms.")
+
+        def adjrep(self, g, X):
+            raise NotImplementedError("Adjoint representation is not implemented for diffeomorphisms.")
+
+        def jacobiField(self, p, q, t, X):
+            raise NotImplementedError("Jacobi field is not implemented for diffeomorphisms.")
+
+        def action(self, g, x, t = jnp.linspace(0, 1, 2)):
+            """Apply the diffeomorphism to a point set x in the ambient space.
+            Args:
+                g (jax.Array): Diffeomorphism (represented by a momentum).
+                x (jax.Array): Points in the ambient space to be transformed.
+                t (jax.Array): Time points for the integration (strictly increasing).
+                NOTE: First entry in t will be ignored and assumed to be 0!
+            Returns:
+                jax.Array: Transformed points at times t."""
+
+            # kernel matrix
+            h = 1 / (2 * self._M._scale**2)  # inverse kernel bandwidth
+            gaussian = lambda a, b: jnp.exp(-jnp.sum((a - b) ** 2) * h)
+
+            def F(y, t, *args):
+                """ODE function."""
+                v, c, p = y
+
+                p_dot = LazyKernel(p, c, gaussian) @ v
+
+                # Hamiltonian function
+                H = lambda v, c: .5 * jnp.sum(v * (LazyKernel(c, c, gaussian) @ v))
+                Gv, Gc = jax.grad(H, argnums=(0,1))(v, c)
+
+                return -Gc, Gv, p_dot
+
+            # integrate F
+            _, _, x_morphed = odeint(F, (g, self._M._control_pts, x), t)
+
+            return x_morphed

{morphomatics-4.1 → morphomatics-4.1.2}/morphomatics/stats/biinvariant_dissimilarity_measures.py

@@ -12,12 +12,13 @@
 
 # postponed evaluation of annotations to circumvent cyclic dependencies (will be default behavior in Python 4.0)
 from __future__ import annotations
+from typing import Tuple
+
+import jax
 
 import jax.numpy as jnp
 import jax.numpy.linalg as jla
-from jax import random
 
-# from morphomatics.manifold import LieGroup
 from morphomatics.stats import ExponentialBarycenter as Mean
 
 
@@ -27,7 +28,7 @@ class BiinvariantDissimilarityMeasures(object):
     Hanik, Hege, and von Tycowicz (2020): Bi-invariant Two-Sample Tests in Lie Groups for Shape Analysis
     """
 
-    def __init__(self, G: Manifold, variant='left'):
+    def __init__(self, G: Manifold, variant: str ='left'):
         """
         :param G: Lie group
         :param variant: indicate whether all tangent vectors are left (variants='left') or right (variants='right')
@@ -36,9 +37,17 @@ class BiinvariantDissimilarityMeasures(object):
 
         self.G = G
 
-        self.variant = variant
-
-    def two_sample_test(self, data_A, data_B, measure, n_permutations=10000):
+        if variant == 'left':
+            self.translation = G.group.lefttrans
+        else:
+            self.translation = G.group.righttrans
+
+    def two_sample_test(self,
+                        data_A: jnp.array,
+                        data_B: jnp.array,
+                        measure: str,
+                        n_permutations: int,
+                        key: jax.random.key) -> Tuple[jnp.array, jnp.array, jnp.array]:
         """Bi-invariant two-sample permutation test for data in G.
         Null hypothesis: 'Means of distributions underlying the 2 data sets are equal' if Hotelling T2 statistic is used
                          'Means and covariance underlying the 2 data sets are equal' if Bhattacharyya distance is used
@@ -46,6 +55,7 @@ class BiinvariantDissimilarityMeasures(object):
         :param data_B: data array of second set; data is sorted along first axis
         :param measure: indicate which measure to use; 'hotelling' and 'bhattacharyya' are possible
         :param n_permutations: number of permutations performed for the test
+        :param key: random key
         :return: p-value, original distance d_orig between data, vector d-perm of distances between permuted data sets
         """
         if measure == 'hotelling':
@@ -59,82 +69,73 @@ class BiinvariantDissimilarityMeasures(object):
         d_orig = distMeasure(data_A, data_B)
 
         D = jnp.concatenate((data_A, data_B), axis=0)
-        d_perm = []
-        # count how often d_orig is smaller than distance between randomly shuffled groups
-        counter = 0
-
-        # def shuffle(A):
-        #     A_perm = np.random.permutation(A)
-        #     return distMeasure(A_perm[:n], A_perm[n:])
-        #
-        # with Parallel(n_jobs=-1, prefer='threads', verbose=0) as parallel:
-        #     d_perm = parallel(delayed(shuffle)(D) for _ in range(n_permutations))
-
-        key = random.PRNGKey(0)
-        # permute and recompute
-        for i in range(n_permutations):
-            key, subkey = random.split(key)
-            # permute along first axis
-            D_perm = random.permutation(key, D)
+
+        def permute_and_recompute(key_):
+            # mix data
+            D_perm = jax.random.permutation(key_, D)
             # distance between shuffled groups
-            d_perm_i = distMeasure(D_perm[:n], D_perm[n:])
-            d_perm.append(d_perm_i)
+            return distMeasure(D_perm[:n], D_perm[n:])
 
-            # increase count if d_orig < d_perm_i
-            if d_orig < d_perm_i:
-                counter += 1
+        # vectorize
+        random_keys = jax.random.split(key, n_permutations)
+        d_perm = jax.vmap(permute_and_recompute)(random_keys)
 
-        for d_perm_i in d_perm:
-            if d_orig < d_perm_i:
-                counter = counter + 1
+        # p-value, i.e., approximate probability of observing d_orig under the null hypothesis
+        p_value = jnp.count_nonzero(d_perm > d_orig) / (n_permutations + 1)
 
-        return counter / (n_permutations + 1), d_orig, d_perm
+        return p_value, d_orig, d_perm
 
-    def groupmean(self, data):
+    def groupmean(self, data: jnp.array) -> jnp.array:
         """
-        :param data: array of elements in G (sufficiently close)
+        :param data: array of (sufficiently close) elements in G
         :return: group mean of data points
         """
-        return Mean.compute(self.G, data)
+        return Mean.compute(self.G, data, max_iter=100)
 
-    def mahalanobisdist(self, A, g):
+    def mahalanobisdist(self, A: jnp.array, g: jnp.array) -> jnp.array:
         """ Bi-invariant Mahalanobis distance in G
         :param A: array of data points in G
-        :param g: element of G
+        :param g: element in G
         :return: Mahalanobis distance of g to the distribution of the data points in A
         """
 
-        C, mean = self.centralized_sample_covariance(A)
-        x = self.G.group.coords(self.diff_at_e(mean, g))
+        S, mean = self.centralized_sample_covariance(A)
+        c = self.G.group.coords(self.diff_at_e(mean, g))
 
-        return float(jnp.sqrt(x.transpose() @ jla.inv(C) @ x).squeeze())
+        x = jla.solve(S, c)
+        return jnp.sqrt(jnp.inner(c.squeeze(), x.squeeze()))
 
-    def hotellingT2(self, A, B):
+    def hotellingT2(self, A: jnp.array, B: jnp.array) -> jnp.array:
         """ Bi-invariant Hotelling T^2 statistic in G
         :param A: array of data points in G
         :param B: array of data points in G
         :return: Hotelling T^2 statistic between the distribution of the samples in A and B
         """
         m, n = len(A), len(B)
-        C_pool, _, _, mean_A, mean_B = self.pooled_sample_covariance(A, B)
-        x = self.G.group.coords(self.diff_at_e(mean_A, mean_B))
+        S_pool, _, _, mean_A, mean_B = self.pooled_sample_covariance(A, B)
+
+        c = self.G.group.coords(self.diff_at_e(mean_A, mean_B))
+        x = jla.solve(S_pool, c)
 
-        return m*n/(m+n) * float((x.transpose() @ jla.inv(C_pool) @ x).squeeze())
+        return m*n/(m+n) * jnp.inner(c.squeeze(), x.squeeze())
 
-    def bhattacharyya(self, A, B):
+    def bhattacharyya(self, A: jnp.array, B: jnp.array) -> jnp.array:
         """ Bi-invariant Bhattacharyya distance in G
         :param A: array of data points in G
         :param B: array of data points in G
         :return: Bhattacharyya distance between the distribution of the samples in A and B
         """
-        C_avg, C_A, C_B, mean_A, mean_B = self.averaged_sample_covariance(A, B)
-        x = self.G.group.coords(self.diff_at_e(mean_A, mean_B))
-        D_B = 1/8 * x.transpose() @ jla.inv(C_avg) @ x \
-              + 1/2 * jnp.log(jla.det(C_avg) / jnp.sqrt(jla.det(C_A) * jla.det(C_B)))
+        S_avg, S_A, S_B, mean_A, mean_B = self.averaged_sample_covariance(A, B)
 
-        return float(D_B.squeeze())
+        c = self.G.group.coords(self.diff_at_e(mean_A, mean_B))
+        x = jla.solve(S_avg, c)
 
-    def centralized_sample_covariance(self, A):
+        D_B = 1 / 8 * jnp.inner(c.squeeze(), x.squeeze()) \
+              + 1 / 2 * jnp.log(jla.det(S_avg) / jnp.sqrt(jla.det(S_A) * jla.det(S_B)))
+
+        return D_B
+
+    def centralized_sample_covariance(self, A: jnp.array) -> jnp.array:
         """ Centralized sample covariance of G–valued data
         :param A: array of data points in G
         :return: covariance matrix defined on (coordinate representations of) tangent vectors at the identity
@@ -142,18 +143,22 @@ class BiinvariantDissimilarityMeasures(object):
         m = len(A)
         # mean of data
         mean = self.groupmean(A)
-        # inverse only once
+        # compute the inverse only once
         mean_inv = self.G.group.inverse(mean)
-        # set up covariance matrix
-        C = jnp.zeros((self.G.dim, self.G.dim))
 
-        for a in A:
-            x = self.G.group.coords(self.diff_at_e(mean, a))
-            C = C + x @ x.transpose()
+        def outer_prod(a):
+            x = self.translation(a, mean_inv)
+            x = self.G.group.coords(self.G.group.log(x))
+            return jnp.outer(x, x)
+
+        # covariance matrix
+        S = jax.vmap(outer_prod)(A)
+        S = S.sum(axis=0) / m
 
-        return 1/m * C, mean
+        return S, mean
 
-    def pooled_sample_covariance(self, A, B):
+    def pooled_sample_covariance(self, A: jnp.array, B: jnp.array) \
+            -> Tuple[jnp.array, jnp.array, jnp.array, jnp.array, jnp.array]:
         """Pooled sample covariance of two data sets in G.
         :param A: array of data points
         :param B: array of data points
@@ -161,33 +166,31 @@ class BiinvariantDissimilarityMeasures(object):
         """
         m, n = len(A), len(B)
 
-        C_A, mean_A = self.centralized_sample_covariance(A)
-        C_B, mean_B = self.centralized_sample_covariance(B)
+        S_A, mean_A = self.centralized_sample_covariance(A)
+        S_B, mean_B = self.centralized_sample_covariance(B)
 
-        C_pool = 1/(m+n-2) * (m * C_A + n * C_B)
-        return C_pool, C_A, C_B, mean_A, mean_B
+        S_pool = 1 / (m + n - 2) * (m * S_A + n * S_B)
+        return S_pool, S_A, S_B, mean_A, mean_B
 
-    def averaged_sample_covariance(self, A, B):
+    def averaged_sample_covariance(self, A: jnp.array, B: jnp.array) \
+            -> Tuple[jnp.array, jnp.array, jnp.array, jnp.array, jnp.array]:
         """Averaged sample covariance of two data sets in G.
         :param A: array of data points
         :param B: array of data points
         :return: covariance operator acting on vectors in the tangent space at the identity
         """
-        C_A, mean_A = self.centralized_sample_covariance(A)
-        C_B, mean_B = self.centralized_sample_covariance(B)
+        S_A, mean_A = self.centralized_sample_covariance(A)
+        S_B, mean_B = self.centralized_sample_covariance(B)
 
-        C_avg = 1/2 * (C_A + C_B)
-        return C_avg, C_A, C_B, mean_A, mean_B
+        S_avg = 1 / 2 * (S_A + S_B)
+        return S_avg, S_A, S_B, mean_A, mean_B
 
-    def diff_at_e(self, a, b):
+    def diff_at_e(self, f: jnp.array, g: jnp.array) -> jnp.array:
         """ "Difference vector" between two elements in G after translating to a neighborhood of the
         identity e.
-        :param a: element of G
-        :param b: element of G
-        :return: group logarithm after translating with a^(-1).
+        :param f: element of G
+        :param g: element of G
+        :return: group logarithm after translating with f^(-1).
         """
-        if self.variant == 'left':
-            x = self.G.group.log(self.G.group.lefttrans(b, self.G.group.inverse(a)))
-        else:
-            x = self.G.group.log(self.G.group.righttrans(b, self.G.group.inverse(a)))
-        return x
+        f_inv = self.G.group.inverse(f)
+        return self.G.group.log(self.translation(g, f_inv))

{morphomatics-4.1 → morphomatics-4.1.2}/morphomatics.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: morphomatics
-Version: 4.1
+Version: 4.1.2
 Summary: Geometric morphometrics in non-Euclidean shape spaces
 Home-page: https://morphomatics.github.io/
 Author: Christoph von Tycowicz et al.

{morphomatics-4.1 → morphomatics-4.1.2}/morphomatics.egg-info/SOURCES.txt

@@ -22,6 +22,7 @@ morphomatics/manifold/__init__.py
 morphomatics/manifold/bezierfold.py
 morphomatics/manifold/connection.py
 morphomatics/manifold/cubic_bezierfold.py
+morphomatics/manifold/diffeomorphism.py
 morphomatics/manifold/differential_coords.py
 morphomatics/manifold/discrete_ops.py
 morphomatics/manifold/euclidean.py

{morphomatics-4.1 → morphomatics-4.1.2}/setup.py

@@ -27,7 +27,7 @@ setup(
               'morphomatics.nn',
               'morphomatics.opt',
               'morphomatics.stats'],
-  version = '4.1',
+  version = '4.1.2',
   version_name = 'Trained Tiberius',
   license='MIT License',
   description = 'Geometric morphometrics in non-Euclidean shape spaces',