multipers 2.3.1__cp310-cp310-win_amd64.whl → 2.3.2__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/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,10 +175,17 @@ 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):
@@ -291,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
@@ -303,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.")
@@ -521,7 +532,7 @@ class KNNmean:
 
         # Symbolic distance matrix:
         if self.metric == "euclidean":
-            D_ij = ((X_i - X_j) ** 2).sum(-1)
+            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":

multipers/filtrations/filtrations.py

@@ -1,13 +1,15 @@
 from collections.abc import Sequence
 from typing import Optional
+from warnings import warn
 
 import gudhi as gd
 import numpy as np
 from numpy.typing import ArrayLike
 from scipy.spatial import KDTree
-from scipy.spatial.distance import cdist
 
+from multipers.array_api import api_from_tensor, api_from_tensors
 from multipers.filtrations.density import DTM, available_kernels
+from multipers.grids import compute_grid
 from multipers.simplex_tree_multi import SimplexTreeMulti, SimplexTreeMulti_type
 
 try:
@@ -15,8 +17,9 @@ try:
 
     from multipers.filtrations.density import KDE
 except ImportError:
+
     from sklearn.neighbors import KernelDensity
-    from warnings import warn
+
     warn("pykeops not found. Falling back to sklearn.")
 
     def KDE(bandwidth, kernel, return_log):
@@ -28,8 +31,8 @@ def RipsLowerstar(
     *,
     points: Optional[ArrayLike] = None,
     distance_matrix: Optional[ArrayLike] = None,
-    function=None,
-    threshold_radius=None,
+    function: Optional[ArrayLike] = None,
+    threshold_radius: Optional[float] = None,
 ):
     """
     Computes the Rips complex, with the usual rips filtration as a first parameter,
@@ -44,22 +47,37 @@ def RipsLowerstar(
         points is not None or distance_matrix is not None
     ), "`points` or `distance_matrix` has to be given."
     if distance_matrix is None:
-        distance_matrix = cdist(points, points)  # this may be slow...
+        api = api_from_tensor(points)
+        points = api.astensor(points)
+        D = api.cdist(points, points)  # this may be slow...
+    else:
+        api = api_from_tensor(distance_matrix)
+        D = api.astensor(distance_matrix)
+
     if threshold_radius is None:
-        threshold_radius = np.min(np.max(distance_matrix, axis=1))
+        threshold_radius = api.min(api.maxvalues(D, axis=1))
     st = gd.SimplexTree.create_from_array(
-        distance_matrix, max_filtration=threshold_radius
+        api.asnumpy(D), max_filtration=threshold_radius
     )
     if function is None:
         return SimplexTreeMulti(st, num_parameters=1)
 
-    function = np.asarray(function)
+    function = api.astensor(function)
     if function.ndim == 1:
         function = function[:, None]
+    if function.ndim != 2:
+        raise ValueError(
+            f"`function.ndim` should be 0 or 1 . Got {function.ndim=}.{function=}"
+        )
     num_parameters = function.shape[1] + 1
     st = SimplexTreeMulti(st, num_parameters=num_parameters)
     for i in range(function.shape[1]):
-        st.fill_lowerstar(function[:, i], parameter=1 + i)
+        st.fill_lowerstar(api.asnumpy(function[:, i]), parameter=1 + i)
+    if api.has_grad(D) or api.has_grad(function):
+        from multipers.grids import compute_grid
+
+        grid = compute_grid([D.ravel(), *[f for f in function.T]])
+        st = st.grid_squeeze(grid)
     return st
 
 
@@ -99,6 +117,7 @@ def DelaunayLowerstar(
     dtype=np.float64,
     verbose: bool = False,
     clear: bool = True,
+    flagify: bool = False,
 ):
     """
     Computes the Function Delaunay bifiltration. Similar to RipsLowerstar, but most suited for low-dimensional euclidean data.
@@ -110,23 +129,44 @@ def DelaunayLowerstar(
      - threshold_radius:  max edge length of the rips. Defaults at min(max(distance_matrix, axis=1)).
     """
     from multipers.slicer import from_function_delaunay
+
+    if flagify and reduce_degree >= 0:
+        raise ValueError(
+            "Got {reduce_degree=} and {flagify=}. Cannot flagify with reduce degree."
+        )
     assert distance_matrix is None, "Delaunay cannot be built from distance matrices"
     if threshold_radius is not None:
         raise NotImplementedError("Delaunay with threshold not implemented yet.")
-    points = np.asarray(points)
-    function = np.asarray(function).squeeze()
+    api = api_from_tensors(points, function)
+    if not flagify and (api.has_grad(points) or api.has_grad(function)):
+        warn("Cannot keep points gradient unless using `flagify=True`.")
+    points = api.astensor(points)
+    function = api.astensor(function).squeeze()
     assert (
         function.ndim == 1
     ), "Delaunay Lowerstar is only compatible with 1 additional parameter."
-    return from_function_delaunay(
-        points,
-        function,
+    slicer = from_function_delaunay(
+        api.asnumpy(points),
+        api.asnumpy(function),
         degree=reduce_degree,
         vineyard=vineyard,
         dtype=dtype,
         verbose=verbose,
         clear=clear,
     )
+    if flagify:
+        from multipers.slicer import to_simplextree
+
+        slicer = to_simplextree(slicer)
+        slicer.flagify(2)
+
+        if api.has_grad(points) or api.has_grad(function):
+            distances = api.cdist(points, points) / 2
+            grid = compute_grid([distances.ravel(), function])
+            slicer = slicer.grid_squeeze(grid)
+            slicer = slicer._clean_filtration_grid()
+
+    return slicer
 
 
 def DelaunayCodensity(
@@ -142,6 +182,7 @@ def DelaunayCodensity(
     dtype=np.float64,
     verbose: bool = False,
     clear: bool = True,
+    flagify: bool = False,
 ):
     """
     TODO
@@ -165,6 +206,7 @@ def DelaunayCodensity(
         dtype=dtype,
         verbose=verbose,
         clear=clear,
+        flagify=flagify,
     )
 
 
@@ -178,6 +220,23 @@ def Cubical(image: ArrayLike, **slicer_kwargs):
      - ** args : specify non-default slicer parameters
     """
     from multipers.slicer import from_bitmap
+
+    api = api_from_tensor(image)
+    image = api.astensor(image)
+    if api.has_grad(image):
+        img2 = image.reshape(-1, image.shape[-1]).T
+        grid = compute_grid(img2)
+        coord_img = np.empty(image.shape, dtype=np.int32)
+        slice_shape = image.shape[:-1]
+        for i in range(image.shape[-1]):
+            coord_img[..., i] = np.searchsorted(
+                api.asnumpy(grid[i]),
+                api.asnumpy(image[..., i]).reshape(-1),
+            ).reshape(slice_shape)
+        slicer = from_bitmap(coord_img, **slicer_kwargs)
+        slicer.filtration_grid = grid
+        return slicer
+
     return from_bitmap(image, **slicer_kwargs)
 
 
@@ -214,7 +273,7 @@ def CoreDelaunay(
         ks = np.arange(1, len(points) + 1)
     else:
         ks = np.asarray(ks, dtype=int)
-    ks:np.ndarray
+    ks: np.ndarray
 
     assert len(ks) > 0, "The parameter ks must contain at least one value."
     assert np.all(ks > 0), "All values in ks must be positive."