multipers 2.4.1__tar.gz → 2.4.2b1__tar.gz

{multipers-2.4.1 → multipers-2.4.2b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multipers
-Version: 2.4.1
+Version: 2.4.2b1
 Summary: Multiparameter Topological Persistence for Machine Learning
 Author-email: David Loiseaux <david.lapous@proton.me>, Hannah Schreiber <hannah.schreiber@inria.fr>
 Maintainer-email: David Loiseaux <david.lapous@proton.me>

{multipers-2.4.1 → multipers-2.4.2b1}/multipers/_signed_measure_meta.py

@@ -162,7 +162,7 @@ def signed_measure(
             grid = filtered_complex.filtration_grid
 
     if mass_default is None:
-        mass_default = mass_default
+        pass
     elif isinstance(mass_default, str):
         if mass_default == "auto":
             mass_default = np.array([1.1 * np.max(f) - 0.1 * np.min(f) for f in grid])
@@ -228,7 +228,7 @@ def signed_measure(
                     zero_pad=fix_mass_default,
                     # grid_shape=tuple(len(g) for g in grid),
                     ignore_inf=ignore_infinite_filtration_values,
-                    verbose=verbose
+                    verbose=verbose,
                 )
                 fix_mass_default = False
                 if verbose:

{multipers-2.4.1 → multipers-2.4.2b1}/multipers/_slicer_meta.py

@@ -52,8 +52,7 @@ def _blocks2boundary_dimension_grades(
                 b[0] if len(b[0]) > 0 else np.empty((0, num_parameters))
                 for b in rblocks
             ),
-            dtype=filtration_type,
-        )
+        ).astype(filtration_type)
     boundary = tuple(x + S[i] for i, b in enumerate(rblocks) for x in b[1])
     dimensions = np.fromiter(
         (i for i, b in enumerate(rblocks) for _ in range(len(b[0]))), dtype=int
@@ -62,6 +61,7 @@ def _blocks2boundary_dimension_grades(
 
 
 def _slicer_from_simplextree(st, backend, vineyard):
+    backend = backend.lower() if isinstance(backend, str) else backend
     if vineyard:
         if backend == "matrix":
             slicer = mps._SlicerVineSimplicial(st)
@@ -172,7 +172,7 @@ def Slicer(
     else:
         vineyard = False if vineyard is None else vineyard
         column_type = "INTRUSIVE_SET" if column_type is None else column_type
-        backend = "Matrix" if backend is None else backend
+        backend = "matrix" if backend is None else backend
 
     _Slicer = mps.get_matrix_slicer(
         is_vineyard=vineyard,
@@ -189,7 +189,7 @@ def Slicer(
         return _Slicer()
     elif mps.is_slicer(st):
         slicer = _Slicer(st)
-    elif is_simplextree_multi(st) and backend == "Graph":
+    elif is_simplextree_multi(st) and backend == "graph":
         slicer = _slicer_from_simplextree(st, backend, vineyard)
         if st.is_squeezed:
             slicer.filtration_grid = st.filtration_grid
@@ -219,6 +219,7 @@ You can try using `multipers.slicer.to_simplextree`."""
         )
     if reduce:
         from multipers.ops import minimal_presentation
+
         slicer = minimal_presentation(
             slicer,
             backend=reduce_backend,

{multipers-2.4.1 → multipers-2.4.2b1}/multipers/array_api/__init__.py

@@ -1,5 +1,5 @@
 import multipers.array_api.numpy as npapi
-
+available_api = [npapi]
 
 def api_from_tensor(x, *, verbose: bool = False, strict=False):
     if strict:

{multipers-2.4.1 → multipers-2.4.2b1}/multipers/array_api/numpy.py

@@ -24,8 +24,19 @@ searchsorted = _np.searchsorted
 LazyTensor = None
 abs = _np.abs
 exp = _np.exp
+log = _np.log
 sin = _np.sin
 cos = _np.cos
+matmul = _np.matmul
+einsum = _np.einsum
+
+
+def argsort(x, axis=-1):
+    return _np.argsort(x, axis=axis)
+
+
+def astype(x, dtype):
+    return astensor(x).astype(dtype=dtype)
 
 
 def clip(x, min=None, max=None):
@@ -122,3 +133,26 @@ def is_promotable(x):
 
 def has_grad(_):
     return False
+
+
+def to_device(x, device):
+    if device is None or str(device) in {"None", "cpu"}:
+        return x
+    raise ValueError(
+        f"NumPy backend only supports CPU tensors, requested device {device!r}."
+    )
+
+
+def size(x):
+    return int(_np.size(x))
+
+
+def dtype_is_float(dtype):
+    try:
+        return _np.issubdtype(_np.dtype(dtype), _np.floating)
+    except TypeError:
+        return False
+
+
+def dtype_default():
+    return _np.array(0.0).dtype

{multipers-2.4.1 → multipers-2.4.2b1}/multipers/array_api/torch.py

@@ -1,5 +1,9 @@
 import numpy as _np
 import torch as _t
+import multipers.array_api as _mpapi
+import sys
+
+_mpapi.available_api.append(sys.modules[__name__])
 
 backend = _t
 cat = _t.cat
@@ -23,8 +27,19 @@ LazyTensor = None
 relu = _t.relu
 abs = _t.abs
 exp = _t.exp
+log = _t.log
 sin = _t.sin
 cos = _t.cos
+matmul = _t.matmul
+einsum = _t.einsum
+
+
+def argsort(x, axis=-1):
+    return _t.argsort(x, dim=axis)
+
+
+def astype(x, dtype):
+    return astensor(x).type(dtype)
 
 
 _is_keops_available = None
@@ -34,7 +49,6 @@ def clip(x, min=None, max=None):
     return _t.clamp(x, min, max)
 
 
-
 def split_with_sizes(arr, sizes):
     return arr.split_with_sizes(sizes)
 
@@ -131,3 +145,21 @@ def is_promotable(x):
 
 def has_grad(x):
     return x.requires_grad
+
+
+def to_device(x, device):
+    if device is None:
+        return x
+    return x.to(device)
+
+
+def size(x):
+    return x.numel()
+
+
+def dtype_is_float(dtype):
+    return getattr(dtype, "is_floating_point", False)
+
+
+def dtype_default():
+    return _t.get_default_dtype()

{multipers-2.4.1 → multipers-2.4.2b1}/multipers/filtrations/density.py

@@ -2,8 +2,8 @@ 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
+import multipers.array_api.numpy as _npapi
+from multipers.array_api import api_from_tensor
 
 global available_kernels
 available_kernels = Union[
@@ -30,7 +30,7 @@ def convolution_signed_measures(
     Parameters
     ----------
 
-     - iterable_of_signed_measures : (num_signed_measure) x [ (npts) x (num_parameters), (npts)]
+     - iterable_of_signed_measures : (num_signed_measure) x [ (npts,num_parameters), (npts)]
      - filtrations : (num_parameter) x (filtration values)
      - flatten : bool
      - n_jobs : int
@@ -42,10 +42,14 @@ def convolution_signed_measures(
     """
     from multipers.grids import todense
 
-    grid_iterator = todense(filtrations, product_order=True)
+    grid_iterator = todense(filtrations)
     api = api_from_tensor(iterable_of_signed_measures[0][0][0])
     match backend:
         case "sklearn":
+            if api is not _npapi:
+                raise ValueError(
+                    f"The sklearn backend only supports numpy. Got {api=}."
+                )
 
             def convolution_signed_measures_on_grid(
                 signed_measures,
@@ -78,6 +82,7 @@ def convolution_signed_measures(
                             grid_iterator=grid_iterator,
                             bandwidth=bandwidth,
                             kernel=kernel,
+                            api=api,
                             **kwargs,
                         )
                         for pts, weights in signed_measures
@@ -95,6 +100,7 @@ def convolution_signed_measures(
                 grid_iterator=grid_iterator,
                 bandwidth=bandwidth,
                 kernel=kernel,
+                api=api,
                 **kwargs,
             )
 
@@ -143,8 +149,12 @@ def _pts_convolution_sparse_old(
     if len(pts) == 0:
         # warn("Found a trivial signed measure !")
         return np.zeros(len(grid_iterator))
+    if kernel == "multivariate_gaussian":
+        kernel = "gaussian"
+    if kernel == "sinc":
+        raise ValueError("Sinc kernel is not supported by sklearn backend.")
     kde = KernelDensity(
-        kernel=kernel, bandwidth=bandwidth, rtol=1e-4, **more_kde_args
+        kernel=kernel, bandwidth=bandwidth, **more_kde_args
     )  # TODO : check rtol
     pos_indices = pts_weights > 0
     neg_indices = pts_weights < 0
@@ -166,31 +176,36 @@ def _pts_convolution_sparse_old(
 
 
 def _pts_convolution_pykeops(
-    pts: np.ndarray,
-    pts_weights: np.ndarray,
+    pts,
+    pts_weights,
     grid_iterator,
     kernel: available_kernels = "gaussian",
     bandwidth=0.1,
+    api=None,
     **more_kde_args,
 ):
     """
     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)
+    if api is None:
+        api = api_from_tensor(pts)
+    # 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)
+    pts = api.astensor(pts)
+    dtype=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=api.astype(pts_weights, dtype),api=api).score_samples(
+        api.astype(grid_iterator, dtype)
     )
 
 
-def gaussian_kernel(x_i, y_j, bandwidth):
+def gaussian_kernel(x_i, y_j, bandwidth, **kwargs):
     D = x_i.shape[-1]
     exponent = -(((x_i - y_j) / bandwidth) ** 2).sum(dim=-1) / 2
     # float is necessary for some reason (pykeops fails)
@@ -207,14 +222,14 @@ def multivariate_gaussian_kernel(x_i, y_j, covariance_matrix_inverse):
     exponent = -(z.weightedsqnorm(covariance_matrix_inverse.flatten()) / 2)
     return (
         float((2 * np.pi) ** (-dim / 2))
-        * (covariance_matrix_inverse.det().sqrt())
+        * (np.sqrt(np.linalg.det(covariance_matrix_inverse)))
         * exponent.exp()
     )
 
 
-def exponential_kernel(x_i, y_j, bandwidth):
+def exponential_kernel(x_i, y_j, bandwidth, **kwargs):
     # 1 / \sigma * exp( norm(x-y, dim=-1))
-    exponent = -((((x_i - y_j) ** 2).sum(dim=-1) ** 1 / 2) / bandwidth)
+    exponent = -((((x_i - y_j) ** 2).sum(dim=-1) ** 0.5) / bandwidth)
     kernel = exponent.exp() / bandwidth
     return kernel
 
@@ -263,6 +278,7 @@ class KDE:
         bandwidth: Any = 1,
         kernel: available_kernels = "gaussian",
         return_log: bool = False,
+        **kwargs,
     ):
         """
         bandwidth : numeric
@@ -272,22 +288,15 @@ class KDE:
         self.bandwidth = bandwidth
         self.kernel: available_kernels = kernel
         self._kernel = None
-        self._backend = None
+        self.api = None
         self._sample_weights = None
         self.return_log = return_log
+        self.kwargs = kwargs
 
-    def fit(self, X, sample_weights=None, y=None):
+    def fit(self, X, sample_weights=None, y=None, api=None):
         self.X = X
         self._sample_weights = sample_weights
-        if isinstance(X, np.ndarray):
-            self._backend = np
-        else:
-            import torch
-
-            if isinstance(X, torch.Tensor):
-                self._backend = torch
-            else:
-                raise Exception("Unsupported backend.")
+        self.api = api_from_tensor(X) if api is None else api
         self._kernel = _kernel(self.kernel)
         return self
 
@@ -340,22 +349,20 @@ class KDE:
         log_probs : tensor (m)
                 log probability densities for each of the queried points in `Y`
         """
-        assert self._backend is not None and self._kernel is not None, "Fit first."
+        assert self.api is not None and self._kernel is not None, "Fit first."
         X = self.X if X is None else X
         if X.shape[0] == 0:
-            return self._backend.zeros((Y.shape[0]))
+            return self.api.zeros((Y.shape[0]))
         assert Y.shape[1] == X.shape[1] and X.ndim == Y.ndim == 2
         lazy_x, lazy_y, w = self.to_lazy(X, Y, x_weights=self._sample_weights)
-        kernel = self._kernel(lazy_x, lazy_y, self.bandwidth)
+        kernel = self._kernel(lazy_x, lazy_y, self.bandwidth, **self.kwargs)
         if w is not None:
             kernel *= w
         if return_kernel:
             return kernel
         density_estimation = kernel.sum(dim=0).squeeze() / kernel.shape[0]  # mean
         return (
-            self._backend.log(density_estimation)
-            if self.return_log
-            else density_estimation
+            self.api.log(density_estimation) if self.return_log else density_estimation
         )
 
 
@@ -377,7 +384,7 @@ class DTM:
         self._ks = None
         self._kdtree = None
         self._X = None
-        self._backend = None
+        self.api = None
 
     def fit(self, X, sample_weights=None, y=None):
         if len(self.masses) == 0:
@@ -385,15 +392,8 @@ class DTM:
         assert np.max(self.masses) <= 1, "All masses should be in (0,1]."
         from sklearn.neighbors import KDTree
 
-        if not isinstance(X, np.ndarray):
-            import torch
-
-            assert isinstance(X, torch.Tensor), "Backend has to be numpy of torch"
-            _X = X.detach()
-            self._backend = "torch"
-        else:
-            _X = X
-            self._backend = "numpy"
+        self.api = api_from_tensor(X)
+        _X = self.api.asnumpy(X)
         self._ks = np.array([int(mass * X.shape[0]) + 1 for mass in self.masses])
         self._kdtree = KDTree(_X, metric=self.metric, **self._kdtree_kwargs)
         self._X = X
@@ -413,19 +413,21 @@ class DTM:
         -------
         the DTMs of Y, for each mass in masses.
         """
+        if self.api is None:
+            raise ValueError("Fit first")
         if len(self.masses) == 0:
-            return np.empty((0, len(Y)))
+            return self.api.empty((0, len(Y)))
         assert (
             self._ks is not None and self._kdtree is not None and self._X is not None
         ), f"Fit first. Got {self._ks=}, {self._kdtree=}, {self._X=}."
         assert Y.ndim == 2
-        if self._backend == "torch":
-            _Y = Y.detach().numpy()
-        else:
+        if self.api is _npapi:
             _Y = Y
+        else:
+            _Y = self.api.asnumpy(Y)
         NN_Dist, NN = self._kdtree.query(_Y, self._ks.max(), return_distance=True)
         DTMs = np.array([((NN_Dist**2)[:, :k].mean(1)) ** 0.5 for k in self._ks])
-        return DTMs
+        return self.api.astensor(DTMs)
 
     def score_samples_diff(self, Y):
         """Returns the kernel density estimates of each point in `Y`.
@@ -447,12 +449,13 @@ class DTM:
                 log probability densities for each of the queried points in `Y`
         """
         import torch
+        from multipers.array_api import torch
 
         if len(self.masses) == 0:
             return torch.empty(0, len(Y))
 
         assert Y.ndim == 2
-        assert self._backend == "torch", "Use the non-diff version with numpy."
+        assert self.api is torch, "Use the non-diff version with numpy."
         assert (
             self._ks is not None and self._kdtree is not None and self._X is not None
         ), f"Fit first. Got {self._ks=}, {self._kdtree=}, {self._X=}."

{multipers-2.4.1 → multipers-2.4.2b1}/multipers/function_rips.pyx

@@ -43,17 +43,6 @@ def get_degree_rips(st, vector[int] degrees):
 	with nogil:
 		get_degree_rips_st_python(simplextree_ptr, st_multi_ptr, degrees)
 	return degree_rips_st
-	# cdef int max_degree = out.second
-	# cdef bool inf_flag = filtrations[-1] == np.inf
-	# if inf_flag:
-	# 	filtrations = filtrations[:-1]
-	# filtrations, = mpg.compute_grid([filtrations],strategy=grid_strategy,resolution=resolution)
-	# if inf_flag:
-	# 	filtrations = np.concatenate([filtrations, [np.inf]])
-	# degree_rips_st.grid_squeeze([filtrations, degrees], inplace=True, coordinate_values=True)
-	# degree_rips_st.filtration_grid = mpg.sanitize_grid([filtrations, np.asarray(degrees)])
-	# # degree_rips_st._is_function_simplextree=True
-	# return degree_rips_st,max_degree
 
 def function_rips_surface(st_multi, vector[indices_type] homological_degrees, bool mobius_inversion=True, bool zero_pad=False, indices_type n_jobs=0):
 	assert st_multi.is_squeezed, "Squeeze first !"