multipers 2.0.0__cp311-cp311-macosx_13_0_arm64.whl

multipers/tests/test_signed_betti.py

@@ -0,0 +1,181 @@
+import numpy as np 
+from multipers.ml.signed_betti import signed_betti, rank_decomposition_by_rectangles
+
+
+# only tests rank functions with 1 and 2 parameters
+def test_rank_decomposition():
+    # rank of an interval module in 1D on a grid with 2 elements
+    ri = np.array(
+        [
+            [
+                1,  # 0,0
+                1,  # 0,1
+            ],
+            [0, 1],  # 1,0  # 1,1
+        ]
+    )
+    expected_rd = np.array(
+        [
+            [
+                0,  # 0,0
+                1,  # 0,1
+            ],
+            [0, 0],  # 1,0  # 1,1
+        ]
+    )
+    rd = rank_decomposition_by_rectangles(ri)
+    for i in range(2):
+        for i_ in range(i, 2):
+            assert rd[i, i_] == expected_rd[i, i_]
+
+    # rank of a sum of two rectangles in 2D on a grid of 2 elements
+    ri = np.array(
+        [
+            [
+                [
+                    [1, 1],  # (0,0), (0,0)  # (0,0), (0,1)
+                    [1, 1],  # (0,0), (1,0)  # (0,0), (1,1)
+                ],
+                [
+                    [0, 1],  # (0,1), (0,0)  # (0,1), (0,1)
+                    [0, 1],  # (0,1), (1,0)  # (0,1), (1,1)
+                ],
+            ],
+            [
+                [
+                    [0, 0],  # (1,0), (0,0)  # (1,0), (0,1)
+                    [2, 2],  # (1,0), (1,0)  # (1,0), (1,1)
+                ],
+                [
+                    [0, 0],  # (1,1), (0,0)  # (1,1), (0,1)
+                    [0, 2],  # (1,1), (1,0)  # (1,1), (1,1)
+                ],
+            ],
+        ]
+    )
+    expected_rd = np.array(
+        [
+            [
+                [
+                    [0, 0],  # (0,0), (0,0)  # (0,0), (0,1)
+                    [0, 1],  # (0,0), (1,0)  # (0,0), (1,1)
+                ],
+                [
+                    [0, 0],  # (0,1), (0,0)  # (0,1), (0,1)
+                    [0, 0],  # (0,1), (1,0)  # (0,1), (1,1)
+                ],
+            ],
+            [
+                [
+                    [0, 0],  # (1,0), (0,0)  # (1,0), (0,1)
+                    [0, 1],  # (1,0), (1,0)  # (1,0), (1,1)
+                ],
+                [
+                    [0, 0],  # (1,1), (0,0)  # (1,1), (0,1)
+                    [0, 0],  # (1,1), (1,0)  # (1,1), (1,1)
+                ],
+            ],
+        ]
+    )
+
+    rd = rank_decomposition_by_rectangles(ri)
+    for i in range(2):
+        for i_ in range(i, 2):
+            for j in range(2):
+                for j_ in range(j, 2):
+                    assert rd[i, j, i_, j_] == expected_rd[i, j, i_, j_]
+
+
+# only tests Hilbert functions with 1, 2, 3, and 4 parameters
+def _test_signed_betti():
+    np.random.seed(0)
+    N = 4
+
+    # test 1D
+    for _ in range(N):
+        a = np.random.randint(10, 30)
+
+        f = np.random.randint(0, 40, size=(a))
+        sb = signed_betti(f)
+
+        check = np.zeros(f.shape)
+        for i in range(f.shape[0]):
+            for i_ in range(0, i + 1):
+                check[i] += sb[i_]
+
+        assert np.allclose(check, f)
+
+    # test 2D
+    for _ in range(N):
+        a = np.random.randint(10, 30)
+        b = np.random.randint(10, 30)
+
+        f = np.random.randint(0, 40, size=(a, b))
+        sb = signed_betti(f)
+
+        check = np.zeros(f.shape)
+        for i in range(f.shape[0]):
+            for j in range(f.shape[1]):
+                for i_ in range(0, i + 1):
+                    for j_ in range(0, j + 1):
+                        check[i, j] += sb[i_, j_]
+
+        assert np.allclose(check, f)
+
+    # test 3D
+    for _ in range(N):
+        a = np.random.randint(10, 20)
+        b = np.random.randint(10, 20)
+        c = np.random.randint(10, 20)
+
+        f = np.random.randint(0, 40, size=(a, b, c))
+        sb = signed_betti(f)
+
+        check = np.zeros(f.shape)
+        for i in range(f.shape[0]):
+            for j in range(f.shape[1]):
+                for k in range(f.shape[2]):
+                    for i_ in range(0, i + 1):
+                        for j_ in range(0, j + 1):
+                            for k_ in range(0, k + 1):
+                                check[i, j, k] += sb[i_, j_, k_]
+
+        assert np.allclose(check, f)
+
+    # test 4D
+    for _ in range(N):
+        a = np.random.randint(5, 10)
+        b = np.random.randint(5, 10)
+        c = np.random.randint(5, 10)
+        d = np.random.randint(5, 10)
+
+        f = np.random.randint(0, 40, size=(a, b, c, d))
+        sb = signed_betti(f)
+
+        check = np.zeros(f.shape)
+        for i in range(f.shape[0]):
+            for j in range(f.shape[1]):
+                for k in range(f.shape[2]):
+                    for l in range(f.shape[3]):
+                        for i_ in range(0, i + 1):
+                            for j_ in range(0, j + 1):
+                                for k_ in range(0, k + 1):
+                                    for l_ in range(0, l + 1):
+                                        check[i, j, k, l] += sb[i_, j_, k_, l_]
+
+        assert np.allclose(check, f)
+
+    for threshold in [True, False]:
+        for _ in range(N):
+            a = np.random.randint(5, 10)
+            b = np.random.randint(5, 10)
+            c = np.random.randint(5, 10)
+            d = np.random.randint(5, 10)
+            e = np.random.randint(5, 10)
+            f = np.random.randint(5, 10)
+
+            f = np.random.randint(0, 40, size=(a, b, c, d,e,f))
+            sb = signed_betti(f, threshold=threshold)
+            sb_ = signed_betti(f, threshold=threshold)
+
+            assert np.allclose(sb, sb_)

multipers/tests/test_simplextreemulti.py

@@ -0,0 +1,98 @@
+import gudhi as gd
+import numpy as np
+from numpy import array
+
+import multipers as mp
+from multipers.tests import assert_st_simplices
+
+mp.simplex_tree_multi.SAFE_CONVERSION = True
+
+
+def test_1():
+    st = mp.SimplexTreeMulti(num_parameters=2)
+    st.insert([0], [0, 1])
+    st.insert([1], [1, 0])
+    st.insert([0, 1], [1, 1])
+    it = [([0, 1], [1.0, 1.0]), ([0], [0.0, 1.0]), ([1], [1.0, 0.0])]
+    assert_st_simplices(st, it)
+
+
+def test_2():
+    from gudhi.rips_complex import RipsComplex
+
+    st2 = RipsComplex(points=[[0, 1], [1, 0], [0, 0]]).create_simplex_tree()
+    st2 = mp.SimplexTreeMulti(
+        st2, num_parameters=3, default_values=[1, 2]
+    )  # the gudhi filtration is placed on axis 0
+
+    it = (
+        ([0, 1], [np.sqrt(2), 1.0, 2.0]),
+        ([0, 2], [1.0, 1.0, 2.0]),
+        ([0], [0.0, 1.0, 2.0]),
+        ([1, 2], [1.0, 1.0, 2.0]),
+        ([1], [0.0, 1.0, 2.0]),
+        ([2], [0.0, 1.0, 2.0]),
+    )
+    assert_st_simplices(st2, it)
+
+
+def test_3():
+    st = gd.SimplexTree()  # usual gudhi simplextree
+    st.insert([0, 1], 1)
+    st.insert([1], 0)
+    # converts the simplextree into a multiparameter simplextree
+    for dtype in [np.int32, np.int64, np.float32, np.float64]:
+        try:
+            st_multi = mp.SimplexTreeMulti(st, num_parameters=4, dtype=dtype)
+        except KeyError:
+            import sys
+
+            print(f"type {dtype} not compiled, skipping.", file=sys.stderr)
+            continue  ## dtype not compiled
+        minf = -np.inf if isinstance(dtype(1), np.floating) else np.iinfo(dtype).min
+        it = [
+            (array([0, 1]), array([1.0, minf, minf, minf])),
+            (array([0]), array([1.0, minf, minf, minf])),
+            (array([1]), array([0.0, minf, minf, minf])),
+        ]
+        assert_st_simplices(st_multi, it)
+
+
+def test_4():
+    st = mp.SimplexTreeMulti(num_parameters=2, kcritical=True, dtype = np.float64)
+    st.insert([0,1,2], [0,1])
+    st.insert([0,1,2], [1,0])
+    st.remove_maximal_simplex([0,1,2])
+    st.insert([0,1,2], [1,2])
+    st.insert([0,1,2], [2,1])
+    st.insert([0,1,2],[1.5,1.5])
+    st.insert([0,1,2], [2.5,.5])
+    st.insert([0,1,2], [.5,2.5])
+
+    s = mp.Slicer(st, is_kcritical=True)
+
+    assert np.array_equal(s.get_filtrations_values(),    array([[0. , 1. ],
+       [1. , 0. ],
+       [0. , 1. ],
+       [1. , 0. ],
+       [0. , 1. ],
+       [1. , 0. ],
+       [0. , 1. ],
+       [1. , 0. ],
+       [0. , 1. ],
+       [1. , 0. ],
+       [0. , 1. ],
+       [1. , 0. ],
+       [1. , 2. ],
+       [2. , 1. ],
+       [1.5, 1.5],
+       [2.5, 0.5],
+       [0.5, 2.5]])), "Invalid conversion from kcritical st to kcritical slicer."
+    death_curve = np.asarray(mp.module_approximation(s, box = [[0,0],[3,3]]).get_module_of_degree(1)[0].get_death_list())
+    assert np.array_equal(death_curve, array([[2. , 1.5],
+       [2.5, 1. ],
+       [np.inf, 0.5],
+       [1.5, 2. ],
+       [1. , 2.5],
+       [0.5, np.inf]]))
+

multipers/tests/test_slicer.py

@@ -0,0 +1,63 @@
+import numpy as np
+from numpy import array
+
+import multipers as mp
+import multipers.slicer as mps
+from multipers.tests import assert_sm
+
+
+def test_1():
+    st = mp.SimplexTreeMulti(num_parameters=2)
+    st.insert([0], [0, 1])
+    st.insert([1], [1, 0])
+    st.insert([0, 1], [1, 1])
+    for S in mps.available_slicers:
+        if not S().is_vine or not S().col_type or S().is_kcritical:
+            continue
+        from multipers._slicer_meta import _blocks2boundary_dimension_grades
+
+        generator_maps, generator_dimensions, filtration_values = (
+            _blocks2boundary_dimension_grades(
+                st._to_scc(),
+                inplace=False,
+            )
+        )
+        it = S(
+            generator_maps, generator_dimensions, filtration_values
+        ).persistence_on_line([0, 0])
+        assert (
+            len(it) == 2
+        ), "There are simplices of dim 0 and 1, but no pers ? got {}".format(len(it))
+        assert len(it[1]) == 0, "Pers of dim 1 is not empty ? got {}".format(it[1])
+        for x in it[0]:
+            if np.any(np.asarray(x)):
+                continue
+            assert x[0] == 1 and x[1] > 45, "pers should be [1,inf], got {}".format(x)
+
+
+def test_2():
+    st = mp.SimplexTreeMulti(num_parameters=2)
+    st.insert([0], [0, 1])
+    st.insert([1], [1, 0])
+    st.insert([0, 1], [1, 1])
+    st.insert([0, 1, 2], [2, 2])
+    assert mp.slicer.to_simplextree(mp.Slicer(st, dtype=st.dtype)) == st
+
+
+def test_3():
+    st = mp.SimplexTreeMulti(num_parameters=2)
+    st.insert([0], [0, 1])
+    st.insert([1], [1, 0])
+    st.insert([0, 1], [1, 1])
+    sm = mp.signed_measure(st, invariant="rank", degree=0)
+    sm2 = mp.signed_measure(mp.Slicer(st, dtype=np.int32), invariant="rank", degree=0)
+    sm3 = mp.signed_measure(mp.Slicer(st, dtype=np.float64), invariant="rank", degree=0)
+    it = [
+        (
+            array([[0.0, 1.0, 1.0, 1.0], [1.0, 0.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]),
+            array([1, 1, -1]),
+        )
+    ]
+    assert_sm(sm, it)
+    assert_sm(sm2, it)
+    assert_sm(sm3, it)

multipers/torch/__init__.py

@@ -0,0 +1 @@
+from .rips_density import *

multipers/torch/diff_grids.py

@@ -0,0 +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_product(*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