multipers 2.2.3__cp311-cp311-win_amd64.whl → 2.3.1__cp311-cp311-win_amd64.whl

multipers/tensor.pxd

@@ -1,13 +1,13 @@
-from libc.stdint cimport uint16_t
-from libcpp.vector cimport vector
-from libcpp cimport bool, float
-
-
-ctypedef float dtype
-ctypedef uint16_t index_type
-
-cdef extern from "tensor/tensor.h" namespace "tensor":
-	cdef cppclass static_tensor_view[float, uint16_t]:
-		static_tensor_view()   except + nogil
-		static_tensor_view(dtype*,const  vector[index_type]&) except + nogil
-		const vector[index_type]& get_resolution() 
+from libc.stdint cimport uint16_t
+from libcpp.vector cimport vector
+from libcpp cimport bool, float
+
+
+ctypedef float dtype
+ctypedef uint16_t index_type
+
+cdef extern from "tensor/tensor.h" namespace "tensor":
+	cdef cppclass static_tensor_view[float, uint16_t]:
+		static_tensor_view()   except + nogil
+		static_tensor_view(dtype*,const  vector[index_type]&) except + nogil
+		const vector[index_type]& get_resolution() 

multipers/test.pyx

@@ -1,44 +1,44 @@
-# cimport multipers.tensor as mt
-from libc.stdint cimport intptr_t, uint16_t
-from libcpp.vector cimport vector
-from libcpp cimport bool, int, float
-from libcpp.utility cimport pair
-from typing import Optional,Iterable,Callable
-
-
-ctypedef float value_type 
-# ctypedef uint16_t index_type 
-
-import numpy as np
-# cimport numpy as cnp
-# cnp.import_array()
-
-# cdef extern from "multi_parameter_rank_invariant/rank_invariant.h" namespace "Gudhi::rank_invariant":
-#     void get_hilbert_surface(const intptr_t, mt.static_tensor_view, const vector[index_type], const vector[index_type], index_type, index_type, const vector[index_type], bool, bool) except + nogil
-
-
-from multipers.simplex_tree_multi import SimplexTreeMulti
-
-
-def numpy_to_tensor(array:np.ndarray):
-    cdef vector[index_type] shape = array.shape
-    cdef dtype[::1] contigus_array_view = np.ascontiguousarray(array)
-    cdef dtype* dtype_ptr = &contigus_array_view[0]
-    cdef mt.static_tensor_view tensor
-    with nogil:
-        tensor = mt.static_tensor_view(dtype_ptr, shape)
-    return tensor.get_resolution()
-
-# def hilbert2d(simplextree:SimplexTreeMulti, grid_shape:np.ndarray|list, vector[index_type] degrees, bool mobius_inversion):
-# 	# assert simplextree.num_parameters == 2
-# 	cdef intptr_t ptr = simplextree.thisptr
-# 	cdef vector[index_type] c_grid_shape = grid_shape
-# 	cdef dtype[::1] container = np.zeros(grid_shape, dtype=np.float32).flatten()
-# 	cdef dtype* container_ptr = &container[0]
-# 	cdef mt.static_tensor_view c_container = mt.static_tensor_view(container_ptr, c_grid_shape)
-# 	cdef index_type i = 0
-# 	cdef index_type j = 1
-# 	cdef vector[index_type] fixed_values = [[],[]]
-# 	# get_hilbert_surface(ptr, c_container, c_grid_shape, degrees,i,j,fixed_values, False, False)
-# 	return container.reshape(grid_shape)
-
+# cimport multipers.tensor as mt
+from libc.stdint cimport intptr_t, uint16_t
+from libcpp.vector cimport vector
+from libcpp cimport bool, int, float
+from libcpp.utility cimport pair
+from typing import Optional,Iterable,Callable
+
+
+ctypedef float value_type 
+# ctypedef uint16_t index_type 
+
+import numpy as np
+# cimport numpy as cnp
+# cnp.import_array()
+
+# cdef extern from "multi_parameter_rank_invariant/rank_invariant.h" namespace "Gudhi::rank_invariant":
+#     void get_hilbert_surface(const intptr_t, mt.static_tensor_view, const vector[index_type], const vector[index_type], index_type, index_type, const vector[index_type], bool, bool) except + nogil
+
+
+from multipers.simplex_tree_multi import SimplexTreeMulti
+
+
+def numpy_to_tensor(array:np.ndarray):
+    cdef vector[index_type] shape = array.shape
+    cdef dtype[::1] contigus_array_view = np.ascontiguousarray(array)
+    cdef dtype* dtype_ptr = &contigus_array_view[0]
+    cdef mt.static_tensor_view tensor
+    with nogil:
+        tensor = mt.static_tensor_view(dtype_ptr, shape)
+    return tensor.get_resolution()
+
+# def hilbert2d(simplextree:SimplexTreeMulti, grid_shape:np.ndarray|list, vector[index_type] degrees, bool mobius_inversion):
+# 	# assert simplextree.num_parameters == 2
+# 	cdef intptr_t ptr = simplextree.thisptr
+# 	cdef vector[index_type] c_grid_shape = grid_shape
+# 	cdef dtype[::1] container = np.zeros(grid_shape, dtype=np.float32).flatten()
+# 	cdef dtype* container_ptr = &container[0]
+# 	cdef mt.static_tensor_view c_container = mt.static_tensor_view(container_ptr, c_grid_shape)
+# 	cdef index_type i = 0
+# 	cdef index_type j = 1
+# 	cdef vector[index_type] fixed_values = [[],[]]
+# 	# get_hilbert_surface(ptr, c_container, c_grid_shape, degrees,i,j,fixed_values, False, False)
+# 	return container.reshape(grid_shape)
+

multipers/tests/__init__.py

@@ -1,57 +1,57 @@
-import numpy as np
-
-
-def assert_st_simplices(st, dump):
-    """
-    Checks that the simplextree has the same
-    filtration as the dump.
-    """
-
-    assert np.all(
-        [
-            np.isclose(a, b).all()
-            for x, y in zip(st.get_simplices(), dump, strict=True)
-            for a, b in zip(x, y, strict=True)
-        ]
-    )
-
-
-def sort_sm(sms):
-    idx = np.argsort([sm[0][:, 0] for sm in sms])
-    return tuple((sm[0][idx], sm[1][idx]) for sm in sms)
-
-
-def assert_sm_pair(sm1, sm2, exact=True, max_error=1e-3, reg=0.1):
-    if not exact:
-        from multipers.distances import sm_distance
-
-        d = sm_distance(sm1, sm2, reg=0.1)
-        assert d < max_error, f"Failed comparison:\n{sm1}\n{sm2},\n with distance {d}."
-        return
-    assert np.all(
-        [
-            np.isclose(a, b).all()
-            for x, y in zip(sm1, sm2, strict=True)
-            for a, b in zip(x, y, strict=True)
-        ]
-    ), f"Failed comparison:\n-----------------\n{sm1}\n-----------------\n{sm2}"
-
-
-def assert_sm(*args, exact=True, max_error=1e-5, reg=0.1):
-    sms = tuple(args)
-    for i in range(len(sms) - 1):
-        assert_sm_pair(sms[i], sms[i + 1], exact=exact, max_error=max_error, reg=reg)
-
-
-def random_st(npts=100, num_parameters=2, max_dim=2):
-    import gudhi as gd
-
-    import multipers as mp
-    from multipers.data import noisy_annulus
-
-    x = noisy_annulus(npts // 2, npts - npts // 2, dim=max_dim)
-    st = gd.AlphaComplex(points=x).create_simplex_tree()
-    st = mp.SimplexTreeMulti(st, num_parameters=num_parameters)
-    for p in range(num_parameters):
-        st.fill_lowerstar(np.random.uniform(size=npts), p)
-    return st
+import numpy as np
+
+
+def assert_st_simplices(st, dump):
+    """
+    Checks that the simplextree has the same
+    filtration as the dump.
+    """
+
+    assert np.all(
+        [
+            np.isclose(a, b).all()
+            for x, y in zip(st.get_simplices(), dump, strict=True)
+            for a, b in zip(x, y, strict=True)
+        ]
+    )
+
+
+def sort_sm(sms):
+    idx = np.argsort([sm[0][:, 0] for sm in sms])
+    return tuple((sm[0][idx], sm[1][idx]) for sm in sms)
+
+
+def assert_sm_pair(sm1, sm2, exact=True, max_error=1e-3, reg=0.1):
+    if not exact:
+        from multipers.distances import sm_distance
+
+        d = sm_distance(sm1, sm2, reg=0.1)
+        assert d < max_error, f"Failed comparison:\n{sm1}\n{sm2},\n with distance {d}."
+        return
+    assert np.all(
+        [
+            np.isclose(a, b).all()
+            for x, y in zip(sm1, sm2, strict=True)
+            for a, b in zip(x, y, strict=True)
+        ]
+    ), f"Failed comparison:\n-----------------\n{sm1}\n-----------------\n{sm2}"
+
+
+def assert_sm(*args, exact=True, max_error=1e-5, reg=0.1):
+    sms = tuple(args)
+    for i in range(len(sms) - 1):
+        assert_sm_pair(sms[i], sms[i + 1], exact=exact, max_error=max_error, reg=reg)
+
+
+def random_st(npts=100, num_parameters=2, max_dim=2):
+    import gudhi as gd
+
+    import multipers as mp
+    from multipers.data import noisy_annulus
+
+    x = noisy_annulus(npts // 2, npts - npts // 2, dim=max_dim)
+    st = gd.AlphaComplex(points=x).create_simplex_tree()
+    st = mp.SimplexTreeMulti(st, num_parameters=num_parameters)
+    for p in range(num_parameters):
+        st.fill_lowerstar(np.random.uniform(size=npts), p)
+    return st

multipers/torch/diff_grids.py

@@ -1,217 +1,217 @@
-from typing import Literal
-
-import numpy as np
-import torch
-from pykeops.torch import LazyTensor
-
-
-def get_grid(strategy: Literal["exact", "regular_closest", "regular_left", "quantile"]):
-    """
-    Given a strategy, returns a function of signature
-    `(num_pts, num_parameter), int --> Iterable[1d array]`
-    that generates a torch-differentiable grid from a set of points,
-    and a resolution.
-    """
-    match strategy:
-        case "exact":
-            return _exact_grid
-        case "regular_closest":
-            return _regular_closest_grid
-        case "regular_left":
-            return _regular_left_grid
-        case "quantile":
-            return _quantile_grid
-        case _:
-            raise ValueError(
-                f"""
-Unimplemented strategy {strategy}.
-Available ones : exact, regular_closest, regular_left, quantile.
-"""
-            )
-
-
-def todense(grid: list[torch.Tensor]):
-    return torch.cartesian_prod(*grid)
-
-
-def _exact_grid(filtration_values, r=None):
-    grid = tuple(_unique_any(f) for f in filtration_values)
-    return grid
-
-
-def _regular_closest_grid(filtration_values, r: int):
-    grid = tuple(_regular_closest(f, r) for f in filtration_values)
-    return grid
-
-
-def _regular_left_grid(filtration_values, r: int):
-    grid = tuple(_regular_left(f, r) for f in filtration_values)
-    return grid
-
-
-def _quantile_grid(filtration_values, r: int):
-    qs = torch.linspace(0, 1, r)
-    grid = tuple(_unique_any(torch.quantile(f, q=qs)) for f in filtration_values)
-    return grid
-
-
-def _unique_any(x, assume_sorted=False, remove_inf: bool = True):
-    if not assume_sorted:
-        x, _ = x.sort()
-    if remove_inf and x[-1] == torch.inf:
-        x = x[:-1]
-    with torch.no_grad():
-        y = x.unique()
-        idx = torch.searchsorted(x, y)
-    x = torch.cat([x, torch.tensor([torch.inf])])
-    return x[idx]
-
-
-def _regular_left(f, r: int, unique: bool = True):
-    f = _unique_any(f)
-    with torch.no_grad():
-        f_regular = torch.linspace(f[0].item(), f[-1].item(), r, device=f.device)
-        idx = torch.searchsorted(f, f_regular)
-    f = torch.cat([f, torch.tensor([torch.inf])])
-    if unique:
-        return _unique_any(f[idx])
-    return f[idx]
-
-
-def _regular_closest(f, r: int, unique: bool = True):
-    f = _unique_any(f)
-    with torch.no_grad():
-        f_reg = torch.linspace(
-            f[0].item(), f[-1].item(), steps=r, dtype=f.dtype, device=f.device
-        )
-        _f = LazyTensor(f[:, None, None])
-        _f_reg = LazyTensor(f_reg[None, :, None])
-        indices = (_f - _f_reg).abs().argmin(0).ravel()
-    f = torch.cat([f, torch.tensor([torch.inf])])
-    f_regular_closest = f[indices]
-    if unique:
-        f_regular_closest = _unique_any(f_regular_closest)
-    return f_regular_closest
-
-
-def evaluate_in_grid(pts, grid):
-    """Evaluates points (assumed to be coordinates) in this grid.
-    Input
-    -----
-     - pts: (num_points, num_parameters) array
-     - grid: Iterable of 1-d array, for each parameter
-
-    Returns
-    -------
-     - array of shape like points of dtype like grid.
-    """
-    # grid = [torch.cat([g, torch.tensor([torch.inf])]) for g in grid]
-    # new_pts = torch.empty(pts.shape, dtype=grid[0].dtype, device=grid[0].device)
-    # for parameter, pt_of_parameter in enumerate(pts.T):
-    #     new_pts[:, parameter] = grid[parameter][pt_of_parameter]
-    return torch.cat(
-        [
-            grid[parameter][pt_of_parameter][:, None]
-            for parameter, pt_of_parameter in enumerate(pts.T)
-        ],
-        dim=1,
-    )
-
-
-def evaluate_mod_in_grid(mod, grid, box=None):
-    """Given an MMA module, pushes it into the specified grid.
-    Useful for e.g., make it differentiable.
-
-    Input
-    -----
-     - mod: PyModule
-     - grid: Iterable of 1d array, for num_parameters
-    Ouput
-    -----
-    torch-compatible module in the format:
-    (num_degrees) x (num_interval of degree) x ((num_birth, num_parameter), (num_death, num_parameters))
-
-    """
-    if box is not None:
-        grid = tuple(
-            torch.cat(
-                [
-                    box[0][[i]],
-                    _unique_any(
-                        grid[i].clamp(min=box[0][i], max=box[1][i]), assume_sorted=True
-                    ),
-                    box[1][[i]],
-                ]
-            )
-            for i in range(len(grid))
-        )
-    (birth_sizes, death_sizes), births, deaths = mod.to_flat_idx(grid)
-    births = evaluate_in_grid(births, grid)
-    deaths = evaluate_in_grid(deaths, grid)
-    diff_mod = tuple(
-        zip(
-            births.split_with_sizes(birth_sizes.tolist()),
-            deaths.split_with_sizes(death_sizes.tolist()),
-        )
-    )
-    return diff_mod
-
-
-def evaluate_mod_in_grid__old(mod, grid, box=None):
-    """Given an MMA module, pushes it into the specified grid.
-    Useful for e.g., make it differentiable.
-
-    Input
-    -----
-     - mod: PyModule
-     - grid: Iterable of 1d array, for num_parameters
-    Ouput
-    -----
-    torch-compatible module in the format:
-    (num_degrees) x (num_interval of degree) x ((num_birth, num_parameter), (num_death, num_parameters))
-
-    """
-    from pykeops.numpy import LazyTensor
-
-    with torch.no_grad():
-        if box is None:
-            # box = mod.get_box()
-            box = np.asarray([[g[0] for g in grid], [g[-1] for g in grid]])
-        S = mod.dump()[1]
-
-        def get_idx_parameter(A, G, p):
-            g = G[p].numpy() if isinstance(G[p], torch.Tensor) else np.asarray(G[p])
-            la = LazyTensor(np.asarray(A, dtype=g.dtype)[None, :, [p]])
-            lg = LazyTensor(g[:, None, None])
-            return (la - lg).abs().argmin(0)
-
-        Bdump = np.concatenate([s[0] for s in S], axis=0).clip(box[[0]], box[[1]])
-        B = np.concatenate(
-            [get_idx_parameter(Bdump, grid, p) for p in range(mod.num_parameters)],
-            axis=1,
-            dtype=np.int64,
-        )
-        Ddump = np.concatenate([s[1] for s in S], axis=0, dtype=np.float32).clip(
-            box[[0]], box[[1]]
-        )
-        D = np.concatenate(
-            [get_idx_parameter(Ddump, grid, p) for p in range(mod.num_parameters)],
-            axis=1,
-            dtype=np.int64,
-        )
-
-    BB = evaluate_in_grid(B, grid)
-    DD = evaluate_in_grid(D, grid)
-
-    b_idx = tuple((len(s[0]) for s in S))
-    d_idx = tuple((len(s[1]) for s in S))
-    BBB = BB.split_with_sizes(b_idx)
-    DDD = DD.split_with_sizes(d_idx)
-
-    splits = np.concatenate([[0], mod.degree_splits(), [len(BBB)]])
-    splits = torch.from_numpy(splits)
-    out = [
-        list(zip(BBB[splits[i] : splits[i + 1]], DDD[splits[i] : splits[i + 1]]))
-        for i in range(len(splits) - 1)
-    ]  ## For some reasons this kills the gradient ???? pytorch bug
-    return out
+from typing import Literal
+
+import numpy as np
+import torch
+from pykeops.torch import LazyTensor
+
+
+def get_grid(strategy: Literal["exact", "regular_closest", "regular_left", "quantile"]):
+    """
+    Given a strategy, returns a function of signature
+    `(num_pts, num_parameter), int --> Iterable[1d array]`
+    that generates a torch-differentiable grid from a set of points,
+    and a resolution.
+    """
+    match strategy:
+        case "exact":
+            return _exact_grid
+        case "regular_closest":
+            return _regular_closest_grid
+        case "regular_left":
+            return _regular_left_grid
+        case "quantile":
+            return _quantile_grid
+        case _:
+            raise ValueError(
+                f"""
+Unimplemented strategy {strategy}.
+Available ones : exact, regular_closest, regular_left, quantile.
+"""
+            )
+
+
+def todense(grid: list[torch.Tensor]):
+    return torch.cartesian_prod(*grid)
+
+
+def _exact_grid(filtration_values, r=None):
+    grid = tuple(_unique_any(f) for f in filtration_values)
+    return grid
+
+
+def _regular_closest_grid(filtration_values, r: int):
+    grid = tuple(_regular_closest(f, r) for f in filtration_values)
+    return grid
+
+
+def _regular_left_grid(filtration_values, r: int):
+    grid = tuple(_regular_left(f, r) for f in filtration_values)
+    return grid
+
+
+def _quantile_grid(filtration_values, r: int):
+    qs = torch.linspace(0, 1, r)
+    grid = tuple(_unique_any(torch.quantile(f, q=qs)) for f in filtration_values)
+    return grid
+
+
+def _unique_any(x, assume_sorted=False, remove_inf: bool = True):
+    if not assume_sorted:
+        x, _ = x.sort()
+    if remove_inf and x[-1] == torch.inf:
+        x = x[:-1]
+    with torch.no_grad():
+        y = x.unique()
+        idx = torch.searchsorted(x, y)
+    x = torch.cat([x, torch.tensor([torch.inf])])
+    return x[idx]
+
+
+def _regular_left(f, r: int, unique: bool = True):
+    f = _unique_any(f)
+    with torch.no_grad():
+        f_regular = torch.linspace(f[0].item(), f[-1].item(), r, device=f.device)
+        idx = torch.searchsorted(f, f_regular)
+    f = torch.cat([f, torch.tensor([torch.inf])])
+    if unique:
+        return _unique_any(f[idx])
+    return f[idx]
+
+
+def _regular_closest(f, r: int, unique: bool = True):
+    f = _unique_any(f)
+    with torch.no_grad():
+        f_reg = torch.linspace(
+            f[0].item(), f[-1].item(), steps=r, dtype=f.dtype, device=f.device
+        )
+        _f = LazyTensor(f[:, None, None])
+        _f_reg = LazyTensor(f_reg[None, :, None])
+        indices = (_f - _f_reg).abs().argmin(0).ravel()
+    f = torch.cat([f, torch.tensor([torch.inf])])
+    f_regular_closest = f[indices]
+    if unique:
+        f_regular_closest = _unique_any(f_regular_closest)
+    return f_regular_closest
+
+
+def evaluate_in_grid(pts, grid):
+    """Evaluates points (assumed to be coordinates) in this grid.
+    Input
+    -----
+     - pts: (num_points, num_parameters) array
+     - grid: Iterable of 1-d array, for each parameter
+
+    Returns
+    -------
+     - array of shape like points of dtype like grid.
+    """
+    # grid = [torch.cat([g, torch.tensor([torch.inf])]) for g in grid]
+    # new_pts = torch.empty(pts.shape, dtype=grid[0].dtype, device=grid[0].device)
+    # for parameter, pt_of_parameter in enumerate(pts.T):
+    #     new_pts[:, parameter] = grid[parameter][pt_of_parameter]
+    return torch.cat(
+        [
+            grid[parameter][pt_of_parameter][:, None]
+            for parameter, pt_of_parameter in enumerate(pts.T)
+        ],
+        dim=1,
+    )
+
+
+def evaluate_mod_in_grid(mod, grid, box=None):
+    """Given an MMA module, pushes it into the specified grid.
+    Useful for e.g., make it differentiable.
+
+    Input
+    -----
+     - mod: PyModule
+     - grid: Iterable of 1d array, for num_parameters
+    Ouput
+    -----
+    torch-compatible module in the format:
+    (num_degrees) x (num_interval of degree) x ((num_birth, num_parameter), (num_death, num_parameters))
+
+    """
+    if box is not None:
+        grid = tuple(
+            torch.cat(
+                [
+                    box[0][[i]],
+                    _unique_any(
+                        grid[i].clamp(min=box[0][i], max=box[1][i]), assume_sorted=True
+                    ),
+                    box[1][[i]],
+                ]
+            )
+            for i in range(len(grid))
+        )
+    (birth_sizes, death_sizes), births, deaths = mod.to_flat_idx(grid)
+    births = evaluate_in_grid(births, grid)
+    deaths = evaluate_in_grid(deaths, grid)
+    diff_mod = tuple(
+        zip(
+            births.split_with_sizes(birth_sizes.tolist()),
+            deaths.split_with_sizes(death_sizes.tolist()),
+        )
+    )
+    return diff_mod
+
+
+def evaluate_mod_in_grid__old(mod, grid, box=None):
+    """Given an MMA module, pushes it into the specified grid.
+    Useful for e.g., make it differentiable.
+
+    Input
+    -----
+     - mod: PyModule
+     - grid: Iterable of 1d array, for num_parameters
+    Ouput
+    -----
+    torch-compatible module in the format:
+    (num_degrees) x (num_interval of degree) x ((num_birth, num_parameter), (num_death, num_parameters))
+
+    """
+    from pykeops.numpy import LazyTensor
+
+    with torch.no_grad():
+        if box is None:
+            # box = mod.get_box()
+            box = np.asarray([[g[0] for g in grid], [g[-1] for g in grid]])
+        S = mod.dump()[1]
+
+        def get_idx_parameter(A, G, p):
+            g = G[p].numpy() if isinstance(G[p], torch.Tensor) else np.asarray(G[p])
+            la = LazyTensor(np.asarray(A, dtype=g.dtype)[None, :, [p]])
+            lg = LazyTensor(g[:, None, None])
+            return (la - lg).abs().argmin(0)
+
+        Bdump = np.concatenate([s[0] for s in S], axis=0).clip(box[[0]], box[[1]])
+        B = np.concatenate(
+            [get_idx_parameter(Bdump, grid, p) for p in range(mod.num_parameters)],
+            axis=1,
+            dtype=np.int64,
+        )
+        Ddump = np.concatenate([s[1] for s in S], axis=0, dtype=np.float32).clip(
+            box[[0]], box[[1]]
+        )
+        D = np.concatenate(
+            [get_idx_parameter(Ddump, grid, p) for p in range(mod.num_parameters)],
+            axis=1,
+            dtype=np.int64,
+        )
+
+    BB = evaluate_in_grid(B, grid)
+    DD = evaluate_in_grid(D, grid)
+
+    b_idx = tuple((len(s[0]) for s in S))
+    d_idx = tuple((len(s[1]) for s in S))
+    BBB = BB.split_with_sizes(b_idx)
+    DDD = DD.split_with_sizes(d_idx)
+
+    splits = np.concatenate([[0], mod.degree_splits(), [len(BBB)]])
+    splits = torch.from_numpy(splits)
+    out = [
+        list(zip(BBB[splits[i] : splits[i + 1]], DDD[splits[i] : splits[i + 1]]))
+        for i in range(len(splits) - 1)
+    ]  ## For some reasons this kills the gradient ???? pytorch bug
+    return out