morphomatics 4.1.1__tar.gz → 4.1.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: morphomatics
-Version: 4.1.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.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.1 → morphomatics-4.1.2}/morphomatics/manifold/diffeomorphism.py

@@ -1,3 +1,15 @@
+################################################################################
+#                                                                              #
+#   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
@@ -153,4 +165,3 @@ class Diffeomorphism(Manifold):
             _, _, x_morphed = odeint(F, (g, self._M._control_pts, x), t)
 
             return x_morphed
-

{morphomatics-4.1.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.1 → morphomatics-4.1.2}/morphomatics.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: morphomatics
-Version: 4.1.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.1 → morphomatics-4.1.2}/setup.py

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