multipers 2.3.3b6__cp311-cp311-win_amd64.whl → 2.3.4__cp311-cp311-win_amd64.whl

multipers/_signed_measure_meta.py

@@ -279,10 +279,6 @@ def signed_measure(
                     ignore_inf=ignore_infinite_filtration_values,
                 )
                 fix_mass_default = False
-
-                if "hook" in invariant:
-                    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 verbose:
                     print("Done.")
             elif filtered_complex_.is_minpres:
@@ -345,9 +341,6 @@ def signed_measure(
                 expand_collapse=expand_collapse,
             )
             fix_mass_default = False
-            if "hook" in invariant:
-                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 verbose:
                 print("Done.")
         elif len(degrees) == 1 and degrees[0] is None:
@@ -420,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,7 +1,15 @@
 import multipers.array_api.numpy as npapi
 
 
-def api_from_tensor(x, *, verbose: bool = False):
+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")
@@ -43,3 +51,12 @@ def api_from_tensors(*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

@@ -19,10 +19,71 @@ 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
+    try:
+        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)
+        _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, interpolation="closest_observation")
+    return _np.quantile(x, q, axis=axis, method="closest_observation")
 
 
 def minvalues(x: _np.ndarray, **kwargs):
@@ -33,6 +94,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

@@ -15,6 +15,61 @@ 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.
@@ -28,10 +83,10 @@ def unique(x, assume_sorted=False, _mean=True):
     _, 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)
-        return x
-
-    c = _np.concatenate([[0], _np.cumsum(c[:-1])])
-    return x[c]
+    else:
+        c = _np.concatenate([[0], _np.cumsum(c[:-1])])
+        x = x[c]
+    return x
 
 
 def quantile_closest(x, q, axis=None):
@@ -50,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

@@ -76,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
 

multipers/grids.pyx

@@ -11,6 +11,7 @@ from typing import Iterable,Literal,Optional
 from itertools import product
 from multipers.array_api import api_from_tensor, api_from_tensors
 from multipers.array_api import numpy as npapi
+from multipers.array_api import check_keops
 
 available_strategies = ["regular","regular_closest", "regular_left", "partition", "quantile", "precomputed"]
 Lstrategies = Literal["regular","regular_closest", "regular_left", "partition", "quantile", "precomputed"]
@@ -123,8 +124,7 @@ def compute_grid(
     except TypeError:
         pass
 
-    if api is npapi:
-        return _compute_grid_numpy(
+    grid = _compute_grid_numpy(
         initial_grid,
         resolution=resolution, 
         strategy = strategy, 
@@ -132,9 +132,9 @@ def compute_grid(
         _q_factor=_q_factor, 
         drop_quantiles=drop_quantiles,
         dense = dense,
-        )
-    from multipers.torch.diff_grids import get_grid
-    grid = get_grid(strategy)(initial_grid,resolution)
+    )
+    # from multipers.torch.diff_grids import get_grid
+    # grid = get_grid(strategy)(initial_grid,resolution)
     if dense:
         grid = todense(grid)
     return grid
@@ -168,41 +168,41 @@ def _compute_grid_numpy(
     Iterable[array[float, ndim=1]] : the 1d-grid for each parameter.
     """
     num_parameters = len(filtrations_values)
+    api = api_from_tensors(*filtrations_values)
     try:
         a,b=drop_quantiles
     except:
         a,b=drop_quantiles,drop_quantiles
 
     if a != 0 or b != 0:
-        boxes = np.asarray([np.quantile(filtration, [a, b], axis=1, method='closest_observation') for filtration in filtrations_values])
-        min_filtration, max_filtration = np.min(boxes, axis=(0,1)), np.max(boxes, axis=(0,1)) # box, birth/death, filtration
+        boxes = api.astensor([api.quantile_closest(filtration, [a, b], axis=1) for filtration in filtrations_values])
+        min_filtration, max_filtration = api.minvalues(boxes, axis=(0,1)), api.maxvalues(boxes, axis=(0,1)) # box, birth/death, filtration
         filtrations_values = [
                 filtration[(m<filtration) * (filtration <M)] 
                 for filtration, m,M in zip(filtrations_values, min_filtration, max_filtration)
                 ]
 
-    to_unique = lambda f : np.unique(f) if isinstance(f,np.ndarray) else f.unique()
     ## match doesn't work with cython BUG
     if strategy == "exact":
-        F=tuple(to_unique(f) for f in filtrations_values)
+        F=tuple(api.unique(f) for f in filtrations_values)
     elif strategy == "quantile":
-        F = tuple(to_unique(f) for f in filtrations_values)
+        F = tuple(api.unique(f) for f in filtrations_values)
         max_resolution = [min(len(f),r) for f,r in zip(F,resolution)]
-        F = tuple( np.quantile(f, q=np.linspace(0,1,num=int(r*_q_factor)), axis=0, method='closest_observation') for f,r in zip(F, resolution) )
+        F = tuple( api.quantile_closest(f, q=api.linspace(0,1,int(r*_q_factor)), axis=0) for f,r in zip(F, resolution) )
         if unique:
-            F = tuple(to_unique(f) for f in F)
+            F = tuple(api.unique(f) for f in F)
             if np.all(np.asarray(max_resolution) > np.asarray([len(f) for f in F])):
                 return _compute_grid_numpy(filtrations_values=filtrations_values, resolution=resolution, strategy="quantile",_q_factor=1.5*_q_factor)
     elif strategy == "regular":
-        F = tuple(np.linspace(np.min(f),np.max(f),num=r, dtype=np.asarray(f).dtype) for f,r in zip(filtrations_values, resolution))
+        F = tuple(_todo_regular(f,r,api) for f,r in zip(filtrations_values, resolution))
     elif strategy == "regular_closest":
-        F = tuple(_todo_regular_closest(f,r, unique) for f,r in zip(filtrations_values, resolution))
+        F = tuple(_todo_regular_closest(f,r, unique,api) for f,r in zip(filtrations_values, resolution))
     elif strategy == "regular_left":
-        F = tuple(_todo_regular_left(f,r, unique) for f,r in zip(filtrations_values, resolution))
-    elif strategy == "torch_regular_closest":
-        F = tuple(_torch_regular_closest(f,r, unique) for f,r in zip(filtrations_values, resolution))
+        F = tuple(_todo_regular_left(f,r, unique,api) for f,r in zip(filtrations_values, resolution))
+    # elif strategy == "torch_regular_closest":
+    #     F = tuple(_torch_regular_closest(f,r, unique) for f,r in zip(filtrations_values, resolution))
     elif strategy == "partition":
-        F = tuple(_todo_partition(f,r, unique) for f,r in zip(filtrations_values, resolution))
+        F = tuple(_todo_partition(f,r, unique, api) for f,r in zip(filtrations_values, resolution))
     elif strategy == "precomputed":
         F=filtrations_values
     else:
@@ -214,43 +214,85 @@ def _compute_grid_numpy(
 def todense(grid, bool product_order=False):
     if len(grid) == 0:
         return np.empty(0)
-    if not isinstance(grid[0], np.ndarray):
-        import torch
-        assert isinstance(grid[0], torch.Tensor)
-        from multipers.torch.diff_grids import todense
-        return todense(grid)
-    dtype = grid[0].dtype
-    if product_order:
-        return np.fromiter(product(*grid), dtype=np.dtype((dtype, len(grid))), count=np.prod([len(f) for f in grid]))
-    mesh = np.meshgrid(*grid)
-    coordinates = np.concatenate(tuple(stuff.ravel()[:,None] for stuff in mesh), axis=1, dtype=dtype)
-    return coordinates
-
-
-
-## TODO : optimize. Pykeops ?
-def _todo_regular_closest(some_float[:] f, int r, bool unique):
+    api = api_from_tensors(*grid)
+    # if product_order:
+    #     if not api.backend ==np:
+    #         raise NotImplementedError("only numpy here.")
+    #     return np.fromiter(product(*grid), dtype=np.dtype((dtype, len(grid))), count=np.prod([len(f) for f in grid]))
+    return api.cartesian_product(*grid)
+    # if not isinstance(grid[0], np.ndarray):
+    #     import torch
+    #     assert isinstance(grid[0], torch.Tensor)
+    #     from multipers.torch.diff_grids import todense
+    #     return todense(grid)
+    # dtype = grid[0].dtype
+    # if product_order:
+    #     return np.fromiter(product(*grid), dtype=np.dtype((dtype, len(grid))), count=np.prod([len(f) for f in grid]))
+    # mesh = np.meshgrid(*grid)
+    # coordinates = np.stack(mesh, axis=-1).reshape(-1, len(grid)).astype(dtype)
+    # return coordinates
+
+
+
+def _todo_regular(f, int r, api):
+    if api.has_grad(f):
+        from warnings import warn
+        warn("`strategy=regular` is not differentiable. Removing grad.")
+    with api.no_grad():
+        return api.linspace(api.min(f), api.max(f), r)
+
+def _project_on_1d_grid(f,grid, bool unique, api):
+    # api=api_from_tensors(f,grid)
+    if f.ndim != 1:
+        raise ValueError(f"Got ndim!=1. {f=}")
+    f = api.unique(f)
+    with api.no_grad():
+        _f = api.LazyTensor(f[:, None, None])
+        _f_reg = api.LazyTensor(grid[None, :, None])
+        indices = (_f - _f_reg).abs().argmin(0).ravel()
+    f = api.cat([f, api.tensor([api.inf], dtype=f.dtype)])
+    f_proj = f[indices]
+    if unique:
+        f_proj = api.unique(f_proj)
+    return f_proj
+
+def _todo_regular_closest_keops(f, int r, bool unique, api):
+    f = api.astensor(f)
+    with api.no_grad():
+        f_regular = api.linspace(api.min(f), api.max(f), r, device = api.device(f),dtype=f.dtype)
+    return _project_on_1d_grid(f,f_regular,unique,api)
+
+def _todo_regular_closest_old(some_float[:] f, int r, bool unique, api=None):
     f_array = np.asarray(f)
     f_regular = np.linspace(np.min(f), np.max(f),num=r, dtype=f_array.dtype)
-    f_regular_closest = np.asarray([f[<int64_t>np.argmin(np.abs(f_array-f_regular[i]))] for i in range(r)])
+    f_regular_closest = np.asarray([f[<int64_t>np.argmin(np.abs(f_array-f_regular[i]))] for i in range(r)], dtype=f_array.dtype)
     if unique: f_regular_closest = np.unique(f_regular_closest)
     return f_regular_closest
 
-def _todo_regular_left(some_float[:] f, int r, bool unique):
+def _todo_regular_left(f, int r, bool unique,api):
+    sorted_f = api.sort(f)
+    with api.no_grad():
+        f_regular = api.linspace(sorted_f[0],sorted_f[-1],r, dtype=sorted_f.dtype, device=api.device(sorted_f))
+        idx=api.searchsorted(sorted_f,f_regular)
+    f_regular_closest = sorted_f[idx]
+    if unique: f_regular_closest = api.unique(f_regular_closest)
+    return f_regular_closest
+
+def _todo_regular_left_old(some_float[:] f, int r, bool unique):
     sorted_f = np.sort(f)
     f_regular = np.linspace(sorted_f[0],sorted_f[-1],num=r, dtype=sorted_f.dtype)
     f_regular_closest = sorted_f[np.searchsorted(sorted_f,f_regular)]
     if unique: f_regular_closest = np.unique(f_regular_closest)
     return f_regular_closest
 
-def _torch_regular_closest(f, int r, bool unique=True):
-    import torch
-    f_regular = torch.linspace(f.min(),f.max(), r, dtype=f.dtype)
-    f_regular_closest =torch.tensor([f[(f-x).abs().argmin()] for x in f_regular]) 
-    if unique: f_regular_closest = f_regular_closest.unique()
-    return f_regular_closest
+def _todo_partition(x, int resolution, bool unique, api):
+    if api.has_grad(x):
+        from warnings import warn
+        warn("`strategy=partition` is not differentiable. Removing grad.")
+    out = _todo_partition_(api.asnumpy(x), resolution, unique)
+    return api.from_numpy(out)
 
-def _todo_partition(some_float[:] data,int resolution, bool unique):
+def _todo_partition_(some_float[:] data,int resolution, bool unique):
     if data.shape[0] < resolution: resolution=data.shape[0]
     k = data.shape[0] // resolution
     partitions = np.partition(data, k)
@@ -259,6 +301,12 @@ def _todo_partition(some_float[:] data,int resolution, bool unique):
     return f
 
 
+if check_keops():
+    _todo_regular_closest = _todo_regular_closest_keops
+else:
+    _todo_regular_closest = _todo_regular_closest_old
+
+
 def compute_bounding_box(stuff, inflate = 0.):
     r"""
     Returns a array of shape (2, num_parameters)

multipers/gudhi/gudhi/Multi_critical_filtration.h

@@ -805,7 +805,7 @@ class Multi_critical_filtration {
         res.add_generator(nf);
       }
     }
-    swap(f1, res);
+    std::swap(f1, res);
 
     return f1 != res;
   }