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

multipers/_signed_measure_meta.py

@@ -3,7 +3,6 @@ from typing import Optional, Union
 
 import numpy as np
 
-import multipers as mp
 from multipers.grids import compute_grid, sms_in_grid
 from multipers.plots import plot_signed_measures
 from multipers.point_measure import clean_sms, zero_out_sms
@@ -31,7 +30,7 @@ def signed_measure(
     verbose: bool = False,
     n_jobs: int = -1,
     expand_collapse: bool = False,
-    backend: Optional[str] = None, # deprecated
+    backend: Optional[str] = None,  # deprecated
     grid: Optional[Iterable] = None,
     coordinate_measure: bool = False,
     num_collapses: int = 0,  # TODO : deprecate
@@ -99,12 +98,21 @@ def signed_measure(
      - 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.")
+        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))]
+        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(
@@ -134,6 +142,8 @@ def signed_measure(
         "rank",
         "euler_characteristic",
         "hilbert_function",
+        "rectangle",
+        "hook",
     ]
 
     assert (
@@ -256,7 +266,7 @@ def signed_measure(
         #         if verbose:
         #             print("Done.")
         else:  # No backend
-            if invariant is not None and "rank" in invariant:
+            if invariant is not None and ("rank" in invariant or "hook" in invariant or "rectangle" in invariant):
                 degrees = np.asarray(degrees, dtype=int)
                 if verbose:
                     print("Computing rank...", end="")
@@ -315,7 +325,7 @@ def signed_measure(
         if verbose:
             print("Input is a simplextree.")
         ## we still have a simplextree here
-        if invariant in ["rank_invariant", "rank"]:
+        if invariant in ["rank_invariant", "rank", "hook", "rectangle"]:
             if verbose:
                 print("Computing rank invariant...", end="")
             assert (
@@ -403,6 +413,10 @@ def signed_measure(
         sms = zero_out_sms(sms, mass_default=mass_default)
         if verbose:
             print("Done.")
+
+    if invariant == "hook":
+        from multipers.point_measure import rectangle_to_hook_minimal_signed_barcode
+        sms = [rectangle_to_hook_minimal_signed_barcode(pts,w) for pts,w in sms]
     if plot:
         plot_signed_measures(sms)
     return sms

multipers/array_api/__init__.py

@@ -1,6 +1,15 @@
-def api_from_tensor(x, *, verbose: bool = False):
-    import multipers.array_api.numpy as npapi
+import multipers.array_api.numpy as npapi
+
 
+def api_from_tensor(x, *, verbose: bool = False, strict=False):
+    if strict:
+        if npapi.is_tensor(x):
+            return npapi
+        import multipers.array_api.torch as torchapi
+
+        if torchapi.is_tensor(x):
+            return torchapi
+        raise ValueError(f"Unsupported (strict) type {type(x)=}")
     if npapi.is_promotable(x):
         if verbose:
             print("using numpy backend")
@@ -37,3 +46,17 @@ def api_from_tensors(*args):
     if is_torch:
         return torchapi
     raise ValueError(f"Incompatible types got {[type(x) for x in args]=}.")
+
+
+def to_numpy(x):
+    api = api_from_tensor(x)
+    return api.asnumpy(x)
+
+
+def check_keops():
+    import os
+
+    if os.name == "nt":
+        # see https://github.com/getkeops/keops/pull/421
+        return False
+    return npapi.check_keops()

multipers/array_api/numpy.py

@@ -16,6 +16,72 @@ no_grad = nullcontext
 zeros = _np.zeros
 min = _np.min
 max = _np.max
+repeat_interleave = _np.repeat
+cdist = cdist  # type: ignore[no-redef]
+unique = _np.unique
+inf = _np.inf
+searchsorted = _np.searchsorted
+LazyTensor = None
+
+# Test keops
+_is_keops_available = None
+
+
+def check_keops():
+    global _is_keops_available, LazyTensor
+    if _is_keops_available is not None:
+        return _is_keops_available
+    import pykeops.numpy as pknp
+    from pykeops.numpy import LazyTensor as LT
+
+    formula = "SqNorm2(x - y)"
+    var = ["x = Vi(3)", "y = Vj(3)"]
+    expected_res = _np.array([63.0, 90.0])
+    x = _np.arange(1, 10).reshape(-1, 3).astype("float32")
+    y = _np.arange(3, 9).reshape(-1, 3).astype("float32")
+
+    my_conv = pknp.Genred(formula, var)
+    try:
+        _is_keops_available = _np.allclose(my_conv(x, y).flatten(), expected_res)
+        LazyTensor = LT
+    except:
+        from warnings import warn
+
+        warn("Could not initialize keops (numpy). using workarounds")
+        _is_keops_available = False
+
+    return _is_keops_available
+
+
+def from_numpy(x):
+    return _np.asarray(x)
+
+
+def ascontiguous(x):
+    return _np.ascontiguousarray(x)
+
+
+def sort(x, axis=-1):
+    return _np.sort(x, axis=axis)
+
+
+def device(x):  # type: ignore[no-unused-arg]
+    return None
+
+
+# type: ignore[no-unused-arg]
+def linspace(low, high, r, device=None, dtype=None):
+    return _np.linspace(low, high, r, dtype=dtype)
+
+
+def cartesian_product(*arrays, dtype=None):
+    mesh = _np.meshgrid(*arrays, indexing="ij")
+    coordinates = _np.stack(mesh, axis=-1).reshape(-1, len(arrays)).astype(dtype)
+    return coordinates
+
+
+def quantile_closest(x, q, axis=None):
+    return _np.quantile(x, q, axis=axis, method="closest_observation")
 
 
 def minvalues(x: _np.ndarray, **kwargs):
@@ -26,6 +92,10 @@ def maxvalues(x: _np.ndarray, **kwargs):
     return _np.max(x, **kwargs)
 
 
+def is_tensor(x):
+    return isinstance(x, _np.ndarray)
+
+
 def is_promotable(x):
     return isinstance(x, _np.ndarray | list | tuple)
 

multipers/array_api/torch.py

@@ -1,3 +1,4 @@
+import numpy as _np
 import torch as _t
 
 backend = _t
@@ -13,6 +14,83 @@ cdist = _t.cdist
 zeros = _t.zeros
 min = _t.min
 max = _t.max
+repeat_interleave = _t.repeat_interleave
+linspace = _t.linspace
+cartesian_product = _t.cartesian_prod
+inf = _t.inf
+searchsorted = _t.searchsorted
+LazyTensor = None
+
+
+_is_keops_available = None
+
+
+def check_keops():
+    global _is_keops_available, LazyTensor
+    if _is_keops_available is not None:
+        return _is_keops_available
+    try:
+        import pykeops.torch as pknp
+        from pykeops.torch import LazyTensor as LT
+
+        formula = "SqNorm2(x - y)"
+        var = ["x = Vi(3)", "y = Vj(3)"]
+        expected_res = _t.tensor([63.0, 90.0])
+        x = _t.arange(1, 10, dtype=_t.float32).view(-1, 3)
+        y = _t.arange(3, 9, dtype=_t.float32).view(-1, 3)
+
+        my_conv = pknp.Genred(formula, var)
+        _is_keops_available = _t.allclose(
+            my_conv(x, y).view(-1), expected_res.type(_t.float32)
+        )
+        LazyTensor = LT
+
+    except:
+        from warnings import warn
+
+        warn("Could not initialize keops (torch). using workarounds")
+
+        _is_keops_available = False
+
+    return _is_keops_available
+check_keops()
+
+
+def from_numpy(x):
+    return _t.from_numpy(x)
+
+
+def ascontiguous(x):
+    return _t.as_tensor(x).contiguous()
+
+
+def device(x):
+    return x.device
+
+
+def sort(x, axis=-1):
+    return _t.sort(x, dim=axis).values
+
+
+# in our context, this allows to get a correct gradient.
+def unique(x, assume_sorted=False, _mean=True):
+    if not x.requires_grad:
+        return x.unique(sorted=assume_sorted)
+    if x.ndim != 1:
+        raise ValueError(f"Got ndim!=1. {x=}")
+    if not assume_sorted:
+        x = x.sort().values
+    _, c = _t.unique(x, sorted=True, return_counts=True)
+    if _mean:
+        x = _t.segment_reduce(data=x, reduce="mean", lengths=c, unsafe=True, axis=0)
+    else:
+        c = _np.concatenate([[0], _np.cumsum(c[:-1])])
+        x = x[c]
+    return x
+
+
+def quantile_closest(x, q, axis=None):
+    return _t.quantile(x, q, dim=axis, interpolation="nearest")
 
 
 def minvalues(x: _t.Tensor, **kwargs):
@@ -27,6 +105,10 @@ def asnumpy(x):
     return x.detach().numpy()
 
 
+def is_tensor(x):
+    return isinstance(x, _t.Tensor)
+
+
 def is_promotable(x):
     return isinstance(x, _t.Tensor)
 

multipers/filtrations/density.py

@@ -1,9 +1,10 @@
 from collections.abc import Callable, Iterable
 from typing import Any, Literal, Union
+
 import numpy as np
 
+from multipers.array_api import api_from_tensor, api_from_tensors
 
-from multipers.array_api import api_from_tensor
 global available_kernels
 available_kernels = Union[
     Literal[
@@ -176,23 +177,24 @@ def _pts_convolution_pykeops(
     Pykeops convolution
     """
     if isinstance(pts, np.ndarray):
-        _asarray_weights = lambda x : np.asarray(x, dtype=pts.dtype)
+        _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)
+
+        _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=_asarray_weights(pts_weights)
-    ).score_samples(_asarray_grid(grid_iterator))
+    return kde.fit(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() / float((bandwidth*np.sqrt(2 * np.pi))**D) 
+    kernel = (exponent).exp() / float((bandwidth * np.sqrt(2 * np.pi)) ** D)
     return kernel
 
 
@@ -359,49 +361,6 @@ class KDE:
         )
 
 
-def batch_signed_measure_convolutions(
-    signed_measures,  # array of shape (num_data,num_pts,D)
-    x,  # array of shape (num_x, D) or (num_data, num_x, D)
-    bandwidth,  # either float or matrix if multivariate kernel
-    kernel: available_kernels,
-):
-    """
-    Input
-    -----
-     - signed_measures: unragged, of shape (num_data, num_pts, D+1)
-       where last coord is weights, (0 for dummy points)
-     - x : the points to convolve (num_x,D)
-     - bandwidth : the bandwidths or covariance matrix inverse or ... of the kernel
-     - kernel : "gaussian", "multivariate_gaussian", "exponential", or Callable (x_i, y_i, bandwidth)->float
-
-    Output
-    ------
-    Array of shape (num_convolutions, (num_axis), num_data,
-    Array of shape (num_convolutions, (num_axis), num_data, max_x_size)
-    """
-    if signed_measures.ndim == 2:
-        signed_measures = signed_measures[None, :, :]
-    sms = signed_measures[..., :-1]
-    weights = signed_measures[..., -1]
-    if isinstance(signed_measures, np.ndarray):
-        from pykeops.numpy import LazyTensor
-    else:
-        import torch
-
-        assert isinstance(signed_measures, torch.Tensor)
-        from pykeops.torch import LazyTensor
-
-    _sms = LazyTensor(sms[..., None, :].contiguous())
-    _x = x[..., None, :, :].contiguous()
-
-    sms_kernel = _kernel(kernel)(_sms, _x, bandwidth)
-    out = (sms_kernel * weights[..., None, None].contiguous()).sum(
-        signed_measures.ndim - 2
-    )
-    assert out.shape[-1] == 1, "Pykeops bug fixed, TODO : refix this "
-    out = out[..., 0]  ## pykeops bug + ensures its a tensor
-    # assert out.shape == (x.shape[0], x.shape[1]), f"{x.shape=}, {out.shape=}"
-    return out
 
 
 class DTM:
@@ -532,7 +491,7 @@ class KNNmean:
 
         # Symbolic distance matrix:
         if self.metric == "euclidean":
-            D_ij = ((X_i - X_j) ** 2).sum(-1) ** (1/2)
+            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

@@ -17,7 +17,6 @@ try:
 
     from multipers.filtrations.density import KDE
 except ImportError:
-
     from sklearn.neighbors import KernelDensity
 
     warn("pykeops not found. Falling back to sklearn.")
@@ -67,7 +66,9 @@ def RipsLowerstar(
         function = function[:, None]
     if function.ndim != 2:
         raise ValueError(
-            f"`function.ndim` should be 0 or 1 . Got {function.ndim=}.{function=}"
+            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)
@@ -75,8 +76,8 @@ def RipsLowerstar(
         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]])
+        filtration_values = [D.ravel(), *[f for f in function.T]]
+        grid = compute_grid(filtration_values)
         st = st.grid_squeeze(grid)
     return st
 
@@ -154,6 +155,9 @@ def DelaunayLowerstar(
         verbose=verbose,
         clear=clear,
     )
+    if reduce_degree >= 0:
+        # Force resolution to avoid confusion with hilbert.
+        slicer = slicer.minpres(degree=reduce_degree, force=True)
     if flagify:
         from multipers.slicer import to_simplextree
 
@@ -192,7 +196,7 @@ def DelaunayCodensity(
     ), "Density estimation is either via kernels or dtm."
     if bandwidth is not None:
         kde = KDE(bandwidth=bandwidth, kernel=kernel, return_log=return_log)
-        f = kde.fit(points).score_samples(points)
+        f = -kde.fit(points).score_samples(points)
     elif dtm_mass is not None:
         f = DTM(masses=[dtm_mass]).fit(points).score_samples(points)[0]
     else:
@@ -287,11 +291,17 @@ def CoreDelaunay(
         "safe",
         "exact",
         "fast",
-    ], f"The parameter precision must be one of ['safe', 'exact', 'fast'], got {precision}."
+    ], f"""
+    The parameter precision must be one of ['safe', 'exact', 'fast'],
+    got {precision}.
+    """
 
     if verbose:
         print(
-            f"Computing the Delaunay Core Bifiltration of {len(points)} points in dimension {points.shape[1]} with parameters:"
+            f"""Computing the Delaunay Core Bifiltration
+            of {len(points)} points in dimension {points.shape[1]}
+            with parameters:
+            """
         )
         print(f"\tbeta = {beta}")
         print(f"\tks = {ks}")
@@ -333,7 +343,10 @@ def CoreDelaunay(
         num_simplices = len(vertex_array)
         if verbose:
             print(
-                f"Inserting {num_simplices} simplices of dimension {dim} ({num_simplices * len(ks)} birth values)..."
+                f"""
+                Inserting {num_simplices} simplices of dimension {dim}
+                ({num_simplices * len(ks)} birth values)...
+                """
             )
         max_knn_distances = np.max(knn_distances[vertex_array], axis=1)
         critical_radii = np.maximum(alphas[:, None], beta * max_knn_distances)