multipers 2.3.0__cp310-cp310-win_amd64.whl → 2.3.2b1__cp310-cp310-win_amd64.whl

multipers/_signed_measure_meta.py

@@ -31,11 +31,10 @@ def signed_measure(
     verbose: bool = False,
     n_jobs: int = -1,
     expand_collapse: bool = False,
-    backend: Optional[str] = None,
-    thread_id: str = "",
+    backend: Optional[str] = None, # deprecated
     grid: Optional[Iterable] = None,
     coordinate_measure: bool = False,
-    num_collapses: int = 0,
+    num_collapses: int = 0,  # TODO : deprecate
     clean: Optional[bool] = None,
     vineyard: bool = False,
     grid_conversion: Optional[Iterable] = None,
@@ -99,7 +98,13 @@ def signed_measure(
            It is usually faster to use this backend if not in a parallel context.
      - Rank: Same as Hilbert.
     """
+    if backend is not None:
+        raise ValueError("backend is deprecated. reduce the complex before this function.")
+    if num_collapses >0:
+        raise ValueError("num_collapses is deprecated. reduce the complex before this function.")
     ## TODO : add timings in verbose
+    if len(filtered_complex) == 0:
+        return [(np.empty((0,2), dtype=filtered_complex.dtype), np.empty(shape=(0,), dtype=int))]
     if grid_conversion is not None:
         grid = tuple(f for f in grid_conversion)
         raise DeprecationWarning(
@@ -133,7 +138,7 @@ def signed_measure(
 
     assert (
         not plot or filtered_complex.num_parameters == 2
-    ), "Can only plot 2d measures."
+    ), f"Can only plot 2d measures. Got {filtered_complex.num_parameters=}."
 
     if grid is None:
         if not filtered_complex.is_squeezed:
@@ -141,7 +146,7 @@ def signed_measure(
                 filtered_complex, strategy=grid_strategy, **infer_grid_kwargs
             )
         else:
-            grid = tuple(np.asarray(f) for f in filtered_complex.filtration_grid)
+            grid = filtered_complex.filtration_grid
 
     if mass_default is None:
         mass_default = mass_default
@@ -186,69 +191,70 @@ def signed_measure(
         grid
     ), f"Number of parameter do not coincide. Got (grid) {len(grid)} and (filtered complex) {num_parameters}."
 
-    if is_simplextree_multi(filtered_complex_):
-        if num_collapses != 0:
-            if verbose:
-                print("Collapsing edges...", end="")
-            filtered_complex_.collapse_edges(num_collapses)
-            if verbose:
-                print("Done.")
-        if backend is not None:
-            filtered_complex_ = mp.Slicer(filtered_complex_, vineyard=vineyard)
+    # if is_simplextree_multi(filtered_complex_):
+    #     # if num_collapses != 0:
+    #     #     if verbose:
+    #     #         print("Collapsing edges...", end="")
+    #     #     filtered_complex_.collapse_edges(num_collapses)
+    #     #     if verbose:
+    #     #         print("Done.")
+    #     # if backend is not None:
+    #     #     filtered_complex_ = mp.Slicer(filtered_complex_, vineyard=vineyard)
 
     fix_mass_default = mass_default is not None
     if is_slicer(filtered_complex_):
         if verbose:
             print("Input is a slicer.")
         if backend is not None and not filtered_complex_.is_minpres:
-            from multipers.slicer import minimal_presentation
-
-            assert (
-                invariant != "euler"
-            ), "Euler Characteristic cannot be speed up by a backend"
-            # This returns a list of reduced complexes
-            if verbose:
-                print("Reducing complex...", end="")
-            reduced_complex = minimal_presentation(
-                filtered_complex_,
-                degrees=degrees,
-                backend=backend,
-                vineyard=vineyard,
-                verbose=verbose,
-            )
-            if verbose:
-                print("Done.")
-            if invariant is not None and "rank" in invariant:
-                if verbose:
-                    print("Computing rank...", end="")
-                sms = [
-                    _rank_from_slicer(
-                        s,
-                        degrees=[d],
-                        n_jobs=n_jobs,
-                        # grid_shape=tuple(len(g) for g in grid),
-                        zero_pad=fix_mass_default,
-                        ignore_inf=ignore_infinite_filtration_values,
-                    )[0]
-                    for s, d in zip(reduced_complex, degrees)
-                ]
-                fix_mass_default = False
-                if verbose:
-                    print("Done.")
-            else:
-                if verbose:
-                    print("Reduced slicer. Retrieving measure from it...", end="")
-                sms = [
-                    _signed_measure_from_slicer(
-                        s,
-                        shift=(
-                            reduced_complex.minpres_degree % 2 if d is None else d % 2
-                        ),
-                    )[0]
-                    for s, d in zip(reduced_complex, degrees)
-                ]
-                if verbose:
-                    print("Done.")
+            raise ValueError("giving a backend to this function is deprecated")
+        #     from multipers.slicer import minimal_presentation
+        #
+        #     assert (
+        #         invariant != "euler"
+        #     ), "Euler Characteristic cannot be speed up by a backend"
+        #     # This returns a list of reduced complexes
+        #     if verbose:
+        #         print("Reducing complex...", end="")
+        #     reduced_complex = minimal_presentation(
+        #         filtered_complex_,
+        #         degrees=degrees,
+        #         backend=backend,
+        #         vineyard=vineyard,
+        #         verbose=verbose,
+        #     )
+        #     if verbose:
+        #         print("Done.")
+        #     if invariant is not None and "rank" in invariant:
+        #         if verbose:
+        #             print("Computing rank...", end="")
+        #         sms = [
+        #             _rank_from_slicer(
+        #                 s,
+        #                 degrees=[d],
+        #                 n_jobs=n_jobs,
+        #                 # grid_shape=tuple(len(g) for g in grid),
+        #                 zero_pad=fix_mass_default,
+        #                 ignore_inf=ignore_infinite_filtration_values,
+        #             )[0]
+        #             for s, d in zip(reduced_complex, degrees)
+        #         ]
+        #         fix_mass_default = False
+        #         if verbose:
+        #             print("Done.")
+        #     else:
+        #         if verbose:
+        #             print("Reduced slicer. Retrieving measure from it...", end="")
+        #         sms = [
+        #             _signed_measure_from_slicer(
+        #                 s,
+        #                 shift=(
+        #                     reduced_complex.minpres_degree & 1 if d is None else d & 1
+        #                 ),
+        #             )[0]
+        #             for s, d in zip(reduced_complex, degrees)
+        #         ]
+        #         if verbose:
+        #             print("Done.")
         else:  # No backend
             if invariant is not None and "rank" in invariant:
                 degrees = np.asarray(degrees, dtype=int)
@@ -272,7 +278,7 @@ def signed_measure(
                     _signed_measure_from_slicer(
                         filtered_complex_,
                         shift=(
-                            filtered_complex_.minpres_degree % 2 if d is None else d % 2
+                            filtered_complex_.minpres_degree & 1 if d is None else d & 1
                         ),
                     )[0]
                     for d in degrees
@@ -385,7 +391,7 @@ def signed_measure(
             sms,
             grid=grid,
             mass_default=mass_default,
-            num_parameters=num_parameters,
+            # num_parameters=num_parameters,
         )
         if verbose:
             print("Done.")
@@ -408,7 +414,7 @@ def _signed_measure_from_scc(
     pts = np.concatenate([b[0] for b in minimal_presentation])
     weights = np.concatenate(
         [
-            (1 - 2 * (i % 2)) * np.ones(len(b[0]))
+            (1 - 2 * (i & 1)) * np.ones(len(b[0]))
             for i, b in enumerate(minimal_presentation)
         ]
     )

multipers/array_api/__init__.py

@@ -0,0 +1,39 @@
+def api_from_tensor(x, *, verbose: bool = False):
+    import multipers.array_api.numpy as npapi
+
+    if npapi.is_promotable(x):
+        if verbose:
+            print("using numpy backend")
+        return npapi
+    import multipers.array_api.torch as torchapi
+
+    if torchapi.is_promotable(x):
+        if verbose:
+            print("using torch backend")
+        return torchapi
+    raise ValueError(f"Unsupported type {type(x)=}")
+
+
+def api_from_tensors(*args):
+    assert len(args) > 0, "no tensor given"
+    import multipers.array_api.numpy as npapi
+
+    is_numpy = True
+    for x in args:
+        if not npapi.is_promotable(x):
+            is_numpy = False
+            break
+    if is_numpy:
+        return npapi
+
+    # only torch for now
+    import multipers.array_api.torch as torchapi
+
+    is_torch = True
+    for x in args:
+        if not torchapi.is_promotable(x):
+            is_torch = False
+            break
+    if is_torch:
+        return torchapi
+    raise ValueError(f"Incompatible types got {[type(x) for x in args]=}.")

multipers/array_api/numpy.py

@@ -0,0 +1,34 @@
+from contextlib import nullcontext
+
+import numpy as _np
+from scipy.spatial.distance import cdist
+
+backend = _np
+cat = _np.concatenate
+norm = _np.linalg.norm
+astensor = _np.asarray
+asnumpy = _np.asarray
+tensor = _np.array
+stack = _np.stack
+empty = _np.empty
+where = _np.where
+no_grad = nullcontext
+zeros = _np.zeros
+min = _np.min
+max = _np.max
+
+
+def minvalues(x: _np.ndarray, **kwargs):
+    return _np.min(x, **kwargs)
+
+
+def maxvalues(x: _np.ndarray, **kwargs):
+    return _np.max(x, **kwargs)
+
+
+def is_promotable(x):
+    return isinstance(x, _np.ndarray | list | tuple)
+
+
+def has_grad(_):
+    return False

multipers/array_api/torch.py

@@ -0,0 +1,35 @@
+import torch as _t
+
+backend = _t
+cat = _t.cat
+norm = _t.norm
+astensor = _t.as_tensor
+tensor = _t.tensor
+stack = _t.stack
+empty = _t.empty
+where = _t.where
+no_grad = _t.no_grad
+cdist = _t.cdist
+zeros = _t.zeros
+min = _t.min
+max = _t.max
+
+
+def minvalues(x: _t.Tensor, **kwargs):
+    return _t.min(x, **kwargs).values
+
+
+def maxvalues(x: _t.Tensor, **kwargs):
+    return _t.max(x, **kwargs).values
+
+
+def asnumpy(x):
+    return x.detach().numpy()
+
+
+def is_promotable(x):
+    return isinstance(x, _t.Tensor)
+
+
+def has_grad(x):
+    return x.requires_grad

multipers/distances.py

@@ -6,7 +6,7 @@ from multipers.multiparameter_module_approximation import PyModule_type
 from multipers.simplex_tree_multi import SimplexTreeMulti_type
 
 
-def sm2diff(sm1, sm2):
+def sm2diff(sm1, sm2, threshold=None):
     pts = sm1[0]
     dtype = pts.dtype
     if isinstance(pts, np.ndarray):
@@ -45,6 +45,9 @@ def sm2diff(sm1, sm2):
     )
     x = backend_concatenate(pts1[pos_indices1], pts2[neg_indices2])
     y = backend_concatenate(pts1[neg_indices1], pts2[pos_indices2])
+    if threshold is not None:
+        x[x>threshold]=threshold
+        y[y>threshold]=threshold
     return x, y
 
 
@@ -55,6 +58,7 @@ def sm_distance(
     reg_m: float = 0,
     numItermax: int = 10000,
     p: float = 1,
+    threshold=None,
 ):
     """
     Computes the wasserstein distances between two signed measures,
@@ -68,7 +72,7 @@ def sm_distance(
      - sinkhorn if reg != 0
      - sinkhorn unbalanced if reg_m != 0
     """
-    x, y = sm2diff(sm1, sm2)
+    x, y = sm2diff(sm1, sm2, threshold=threshold)
     loss = ot.dist(
         x, y, metric="sqeuclidean", p=p
     )  # only euc + sqeuclidian are implemented in pot for the moment with torch backend # TODO : check later

multipers/{ml/convolutions.py → filtrations/density.py}

@@ -1,8 +1,9 @@
 from collections.abc import Callable, Iterable
 from typing import Any, Literal, Union
-
 import numpy as np
 
+
+from multipers.array_api import api_from_tensor
 global available_kernels
 available_kernels = Union[
     Literal[
@@ -41,13 +42,14 @@ def convolution_signed_measures(
     from multipers.grids import todense
 
     grid_iterator = todense(filtrations, product_order=True)
+    api = api_from_tensor(iterable_of_signed_measures[0][0][0])
     match backend:
         case "sklearn":
 
             def convolution_signed_measures_on_grid(
-                signed_measures: Iterable[tuple[np.ndarray, np.ndarray]],
+                signed_measures,
             ):
-                return np.concatenate(
+                return api.cat(
                     [
                         _pts_convolution_sparse_old(
                             pts=pts,
@@ -67,7 +69,7 @@ def convolution_signed_measures(
             def convolution_signed_measures_on_grid(
                 signed_measures: Iterable[tuple[np.ndarray, np.ndarray]],
             ) -> np.ndarray:
-                return np.concatenate(
+                return api.cat(
                     [
                         _pts_convolution_pykeops(
                             pts=pts,
@@ -111,7 +113,7 @@ def convolution_signed_measures(
     if not flatten:
         out_shape = [-1] + [len(f) for f in filtrations]  # Degree
         convolutions = [x.reshape(out_shape) for x in convolutions]
-    return np.asarray(convolutions)
+    return api.cat([x[None] for x in convolutions])
 
 
 # def _test(r=1000, b=0.5, plot=True, kernel=0):
@@ -173,16 +175,24 @@ def _pts_convolution_pykeops(
     """
     Pykeops convolution
     """
+    if isinstance(pts, np.ndarray):
+        _asarray_weights = lambda x : np.asarray(x, dtype=pts.dtype)
+        _asarray_grid = _asarray_weights
+    else:
+        import torch
+        _asarray_weights = lambda x : torch.from_numpy(x).type(pts.dtype)
+        _asarray_grid = lambda x : x.type(pts.dtype)
     kde = KDE(kernel=kernel, bandwidth=bandwidth, **more_kde_args)
     return kde.fit(
-        pts, sample_weights=np.asarray(pts_weights, dtype=pts.dtype)
-    ).score_samples(np.asarray(grid_iterator, dtype=pts.dtype))
+        pts, sample_weights=_asarray_weights(pts_weights)
+    ).score_samples(_asarray_grid(grid_iterator))
 
 
 def gaussian_kernel(x_i, y_j, bandwidth):
+    D = x_i.shape[-1]
     exponent = -(((x_i - y_j) / bandwidth) ** 2).sum(dim=-1) / 2
     # float is necessary for some reason (pykeops fails)
-    kernel = (exponent).exp() / (bandwidth * float(np.sqrt(2 * np.pi)))
+    kernel = (exponent).exp() / float((bandwidth*np.sqrt(2 * np.pi))**D) 
     return kernel
 
 
@@ -290,10 +300,10 @@ class KDE:
                 X.reshape((X.shape[0], 1, X.shape[1]))
             )  # numpts, 1, dim
             lazy_y = LazyTensor(
-                Y.reshape((1, Y.shape[0], Y.shape[1]))
+                Y.reshape((1, Y.shape[0], Y.shape[1])).astype(X.dtype)
             )  # 1, numpts, dim
             if x_weights is not None:
-                w = LazyTensor(x_weights[:, None], axis=0)
+                w = LazyTensor(np.asarray(x_weights, dtype=X.dtype)[:, None], axis=0)
                 return lazy_x, lazy_y, w
             return lazy_x, lazy_y, None
         import torch
@@ -302,9 +312,11 @@ class KDE:
             from pykeops.torch import LazyTensor
 
             lazy_x = LazyTensor(X.view(X.shape[0], 1, X.shape[1]))
-            lazy_y = LazyTensor(Y.view(1, Y.shape[0], Y.shape[1]))
+            lazy_y = LazyTensor(Y.type(X.dtype).view(1, Y.shape[0], Y.shape[1]))
             if x_weights is not None:
-                w = LazyTensor(x_weights[:, None], axis=0)
+                if isinstance(x_weights, np.ndarray):
+                    x_weights = torch.from_numpy(x_weights)
+                w = LazyTensor(x_weights[:, None].type(X.dtype), axis=0)
                 return lazy_x, lazy_y, w
             return lazy_x, lazy_y, None
         raise Exception("Bad tensor type.")
@@ -339,7 +351,7 @@ class KDE:
             kernel *= w
         if return_kernel:
             return kernel
-        density_estimation = kernel.sum(dim=0).ravel() / kernel.shape[0]  # mean
+        density_estimation = kernel.sum(dim=0).squeeze() / kernel.shape[0]  # mean
         return (
             self._backend.log(density_estimation)
             if self.return_log
@@ -497,6 +509,48 @@ class DTM:
         return DTMs
 
 
+## code taken from pykeops doc (https://www.kernel-operations.io/keops/_auto_benchmarks/benchmark_KNN.html)
+class KNNmean:
+    def __init__(self, k: int, metric: str = "euclidean"):
+        self.k = k
+        self.metric = metric
+        self._KNN_fun = None
+        self._x = None
+
+    def fit(self, x):
+        if isinstance(x, np.ndarray):
+            from pykeops.numpy import Vi, Vj
+        else:
+            import torch
+
+            assert isinstance(x, torch.Tensor), "Backend has to be numpy or torch"
+            from pykeops.torch import Vi, Vj
+
+        D = x.shape[1]
+        X_i = Vi(0, D)
+        X_j = Vj(1, D)
+
+        # Symbolic distance matrix:
+        if self.metric == "euclidean":
+            D_ij = ((X_i - X_j) ** 2).sum(-1) ** (1/2)
+        elif self.metric == "manhattan":
+            D_ij = (X_i - X_j).abs().sum(-1)
+        elif self.metric == "angular":
+            D_ij = -(X_i | X_j)
+        elif self.metric == "hyperbolic":
+            D_ij = ((X_i - X_j) ** 2).sum(-1) / (X_i[0] * X_j[0])
+        else:
+            raise NotImplementedError(f"The '{self.metric}' distance is not supported.")
+
+        self._x = x
+        self._KNN_fun = D_ij.Kmin(self.k, dim=1)
+        return self
+
+    def score_samples(self, x):
+        assert self._x is not None and self._KNN_fun is not None, "Fit first."
+        return self._KNN_fun(x, self._x).sum(axis=1) / self.k
+
+
 # def _pts_convolution_sparse(pts:np.ndarray, pts_weights:np.ndarray, filtration_grid:Iterable[np.ndarray], kernel="gaussian", bandwidth=0.1, **more_kde_args):
 # 	"""
 # 	Old version of `convolution_signed_measures`. Scikitlearn's convolution is slower than the code above.