multipers 2.3.2b1__cp313-cp313-win_amd64.whl → 2.3.3__cp313-cp313-win_amd64.whl

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;
   }

multipers/ml/mma.py

@@ -478,7 +478,7 @@ class MMAFormatter(BaseEstimator, TransformerMixin):
                 if self.weights is None
                 else np.asarray(self.weights)
             )
-            standard_box = PyBox_f64([0] * self._num_parameters, w)
+            standard_box = np.array([[0] * self._num_parameters, w])
 
             X_copy = [
                 [

multipers/ml/signed_measures.py

@@ -9,12 +9,107 @@ from sklearn.base import BaseEstimator, TransformerMixin
 from tqdm import tqdm
 
 import multipers as mp
-from multipers.array_api import api_from_tensor
+from multipers.array_api import api_from_tensor, api_from_tensors
 from multipers.filtrations.density import available_kernels, convolution_signed_measures
-from multipers.grids import compute_grid
+from multipers.grids import compute_grid, todense
 from multipers.point_measure import rank_decomposition_by_rectangles, signed_betti
 
 
+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,
+    api=None,
+):
+    """
+    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)
+    """
+    from multipers.filtrations.density import _kernel
+
+    if api is None:
+        api = api_from_tensors(signed_measures, x)
+    if signed_measures.ndim == 2:
+        signed_measures = signed_measures[None, :, :]
+    sms = signed_measures[..., :-1]
+    weights = signed_measures[..., -1]
+    _sms = api.LazyTensor(api.ascontiguous(sms[..., None, :]))
+    _x = api.ascontiguous(x[..., None, :, :])
+
+    sms_kernel = _kernel(kernel)(_sms, _x, bandwidth)
+    out = (sms_kernel * api.ascontiguous(weights[..., None, None])).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
+
+
+def sm2deep(signed_measure, api=None):
+    if api is None:
+        api = api_from_tensor(signed_measure[0])
+    dirac_positions, dirac_signs = signed_measure
+    dtype = dirac_positions.dtype
+    new_shape = list(dirac_positions.shape)
+    new_shape[1] += 1
+    c = api.empty(new_shape, dtype=dtype)
+    c[:, :-1] = dirac_positions
+    c[:, -1] = api.astensor(dirac_signs)
+    return c
+
+
+def deep_unrag(sms, api=None):
+    if api is None:
+        api = api_from_tensor(sms[0][0])
+    num_sm = len(sms)
+    if num_sm == 0:
+        return api.tensor([])
+    first = sms[0][0]
+    num_parameters = first.shape[1]
+    dtype = first.dtype
+    deep_sms = tuple(sm2deep(sm, api=api) for sm in sms)
+    max_num_pts = np.max([sm[0].shape[0] for sm in sms])
+    unragged_sms = api.zeros((num_sm, max_num_pts, num_parameters + 1), dtype=dtype)
+
+    for data in range(num_sm):
+        sm = deep_sms[data]
+        a, b = sm.shape
+        unragged_sms[data, :a, :b] = sm
+    return unragged_sms
+
+
+def sm_convolution(
+    sms,
+    grid,
+    bandwidth,
+    kernel: available_kernels = "gaussian",
+    plot: bool = False,
+    **plt_kwargs,
+):
+    dense_grid = todense(grid)
+    api = api_from_tensors(sms[0][0], dense_grid)
+    sms = deep_unrag(sms, api=api)
+    convs = batch_signed_measure_convolutions(
+        sms, dense_grid, bandwidth, kernel, api=api
+    ).reshape(sms.shape[0], *(len(g) for g in grid))
+    if plot:
+        from multipers.plots import plot_surfaces
+        plot_surfaces((grid, convs), **plt_kwargs)
+    return convs
+
+
 class FilteredComplex2SignedMeasure(BaseEstimator, TransformerMixin):
     """
     Input
@@ -547,27 +642,6 @@ def rescale_sparse_signed_measure(
     return out
 
 
-def sm2deep(signed_measure):
-    dirac_positions, dirac_signs = signed_measure
-    dtype = dirac_positions.dtype
-    new_shape = list(dirac_positions.shape)
-    new_shape[1] += 1
-    if isinstance(dirac_positions, np.ndarray):
-        c = np.empty(new_shape, dtype=dtype)
-        c[:, :-1] = dirac_positions
-        c[:, -1] = dirac_signs
-
-    else:
-        import torch
-
-        c = torch.empty(new_shape, dtype=dtype)
-        c[:, :-1] = dirac_positions
-        if isinstance(dirac_signs, np.ndarray):
-            dirac_signs = torch.from_numpy(dirac_signs)
-        c[:, -1] = dirac_signs
-    return c
-
-
 class SignedMeasureFormatter(BaseEstimator, TransformerMixin):
     """
     Input
@@ -758,6 +832,10 @@ class SignedMeasureFormatter(BaseEstimator, TransformerMixin):
                 ) = self._get_filtration_bounds(X, axis=ax)
                 self._filtrations_bounds.append(filtration_bounds)
                 self._normalization_factors.append(normalization_factors)
+            self._filtrations_bounds = self._backend.astensor(self._filtrations_bounds)
+            self._normalization_factors = self._backend.astensor(
+                self._normalization_factors
+            )
             # else:
             #     (
             #         self._filtrations_bounds,
@@ -782,8 +860,10 @@ class SignedMeasureFormatter(BaseEstimator, TransformerMixin):
             ]
             # axis, filtration_values
             filtration_values = [
-                compute_grid(
-                    f_ax.T, resolution=self.resolution, strategy=self.grid_strategy
+                self._backend.astensor(
+                    compute_grid(
+                        f_ax.T, resolution=self.resolution, strategy=self.grid_strategy
+                    )
                 )
                 for f_ax in filtration_values
             ]
@@ -848,7 +928,7 @@ class SignedMeasureFormatter(BaseEstimator, TransformerMixin):
 
         if self.flatten:
             out = np.concatenate(out).flatten()
-        if self.axis == -1:
+        elif self.axis == -1:
             return np.asarray(out)
         else:
             return np.asarray(out)[0]

multipers/mma_structures.pyx

@@ -751,7 +751,7 @@ cdef class PyModule_f64:
               axs = [plt.gca()]
             for image, degree, i in zip(image_vector, degrees, range(num_degrees)):
                 ax = axs[i]
-                temp = multipers.plots.plot_surface(grid, image.T, ax=ax)
+                temp = multipers.plots.plot_surface(grid, image, ax=ax)
                 plt.colorbar(temp, ax = ax)
                 if degree < 0 :
                     ax.set_title(rf"$H_{i}$ $2$-persistence image")
@@ -1712,7 +1712,7 @@ cdef class PyModule_f32:
               axs = [plt.gca()]
             for image, degree, i in zip(image_vector, degrees, range(num_degrees)):
                 ax = axs[i]
-                temp = multipers.plots.plot_surface(grid, image.T, ax=ax)
+                temp = multipers.plots.plot_surface(grid, image, ax=ax)
                 plt.colorbar(temp, ax = ax)
                 if degree < 0 :
                     ax.set_title(rf"$H_{i}$ $2$-persistence image")

multipers/mma_structures.pyx.tp

@@ -773,7 +773,7 @@ cdef class PyModule_{{SHORT}}:
               axs = [plt.gca()]
             for image, degree, i in zip(image_vector, degrees, range(num_degrees)):
                 ax = axs[i]
-                temp = multipers.plots.plot_surface(grid, image.T, ax=ax)
+                temp = multipers.plots.plot_surface(grid, image, ax=ax)
                 plt.colorbar(temp, ax = ax)
                 if degree < 0 :
                     ax.set_title(rf"$H_{i}$ $2$-persistence image")

multipers/multiparameter_module_approximation.pyx

@@ -168,7 +168,8 @@ def module_approximation(
                 delayed(module_approximation)(slicer, box, max_error, nlines, slicer_backend, minpres, degree, complete, threshold, verbose, ignore_warnings, id, direction, swap_box_coords)
                 for slicer in input
             ))
-        mod = PyModule_f64().set_box(PyBox_f64(*modules[0].get_box()))
+        box = modules[0].get_box()
+        mod = PyModule_f64().set_box(box)
         for i,m in enumerate(modules):
             mod.merge(m, input[i].minpres_degree)
         return mod