multipers 2.3.3b6__cp313-cp313-macosx_11_0_arm64.whl

multipers/test.pyx

@@ -0,0 +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)
+

multipers/tests/__init__.py

@@ -0,0 +1,62 @@
+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, threshold=None):
+    if not exact:
+        from multipers.distances import sm_distance
+        if threshold is not None:
+            _inf_value_fix = threshold
+            sm1[0][sm1[0] >threshold] = _inf_value_fix
+            sm2[0][sm2[0] >threshold] = _inf_value_fix
+
+        d = sm_distance(sm1, sm2, reg=reg)
+        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, threshold=None):
+    sms = tuple(args)
+    for i in range(len(sms) - 1):
+        print(i)
+        assert_sm_pair(sms[i], sms[i + 1], exact=exact, max_error=max_error, reg=reg, threshold=threshold)
+
+
+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/__init__.py

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

multipers/torch/diff_grids.py

@@ -0,0 +1,240 @@
+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":
+            return _regular_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):
+    assert r is None
+    grid = tuple(_unique_any(f) for f in filtration_values)
+    return grid
+
+
+def _regular_closest_grid(filtration_values, res):
+    grid = tuple(_regular_closest(f, r) for f,r in zip(filtration_values, res))
+    return grid
+
+def _regular_grid(filtration_values, res):
+    grid = tuple(_regular(g,r) for g,r in zip(filtration_values, res))
+    return grid
+
+def _regular(x, r:int):
+    if x.ndim != 1:
+        raise ValueError(f"Got ndim!=1. {x=}")
+    return torch.linspace(start=torch.min(x), end=torch.max(x), steps=r, dtype=x.dtype) 
+
+def _regular_left_grid(filtration_values, res):
+    grid = tuple(_regular_left(f, r) for f,r in zip(filtration_values,res))
+    return grid
+
+
+def _quantile_grid(filtration_values, res):
+    grid = tuple(_quantile(f, r) for f,r in zip(filtration_values,res))
+    return grid
+def _quantile(x, r):
+    if x.ndim != 1:
+        raise ValueError(f"Got ndim!=1. {x=}")
+    qs = torch.linspace(0, 1, r, dtype=x.dtype)
+    return _unique_any(torch.quantile(x, q=qs))
+
+
+
+
+def _unique_any(x, assume_sorted=False, remove_inf: bool = True):
+    if x.ndim != 1:
+        raise ValueError(f"Got ndim!=1. {x=}")
+    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):
+    if f.ndim != 1:
+        raise ValueError(f"Got ndim!=1. {f=}")
+    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):
+    if f.ndim != 1:
+        raise ValueError(f"Got ndim!=1. {f=}")
+    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

multipers/torch/rips_density.py

@@ -0,0 +1,310 @@
+from typing import Callable, Literal, Optional
+
+import numpy as np
+import torch
+import gudhi as gd
+
+import multipers as mp
+from multipers.filtrations.density import DTM, KDE
+from multipers.simplex_tree_multi import _available_strategies
+from multipers.torch.diff_grids import get_grid
+
+
+def function_rips_signed_measure_old(
+    x,
+    theta: Optional[float] = None,
+    function: Literal["dtm", "gaussian", "exponential"] | Callable = "dtm",
+    threshold: float = np.inf,
+    grid_strategy: _available_strategies = "regular_closest",
+    resolution: int = 100,
+    return_original: bool = False,
+    return_st: bool = False,
+    safe_conversion: bool = False,
+    num_collapses: int = -1,
+    expand_collapse: bool = False,
+    dtype=torch.float32,
+    **sm_kwargs,
+):
+    """
+    Computes a torch-differentiable function-rips signed measure.
+
+    Input
+    -----
+     - x (num_pts, dim) : The point cloud
+     - theta: For density-like functions : the bandwidth
+     - threshold : rips threshold
+     - function : Either "dtm", "gaussian", or "exponenetial" or Callable.
+       Function to compute the second parameter.
+     - grid_strategy: grid coarsenning strategy.
+     - resolution : when coarsenning, the target resolution,
+     - return_original : Also returns the non-differentiable signed measure.
+     - safe_conversion : Activate this if you encounter crashes.
+     - **kwargs : for the signed measure computation.
+    """
+    assert isinstance(x, torch.Tensor)
+    if function == "dtm":
+        assert theta is not None, "Provide a theta to compute DTM"
+        codensity = DTM(masses=[theta]).fit(x).score_samples_diff(x)[0].type(dtype)
+    elif function in ["gaussian", "exponential"]:
+        assert theta is not None, "Provide a theta to compute density estimation"
+        codensity = (
+            -KDE(
+                bandwidth=theta,
+                kernel=function,
+                return_log=True,
+            )
+            .fit(x)
+            .score_samples(x)
+            .type(dtype)
+        )
+    else:
+        assert callable(function), "Function has to be callable"
+        if theta is None:
+            codensity = function(x).type(dtype)
+        else:
+            codensity = function(x, theta=theta).type(dtype)
+
+    distance_matrix = torch.cdist(x, x).type(dtype)
+    if threshold < np.inf:
+        distance_matrix[distance_matrix > threshold] = np.inf
+
+    # st = RipsComplex(
+    #     distance_matrix=distance_matrix.detach(), max_edge_length=threshold
+    # ).create_simplex_tree()
+    st = gd.SimplexTree.create_from_array(
+        distance_matrix.detach(), max_filtration=threshold
+    )
+    # detach makes a new (reference) tensor, without tracking the gradient
+    st = mp.SimplexTreeMulti(st, num_parameters=2, safe_conversion=safe_conversion)
+    st.fill_lowerstar(
+        codensity.detach(), parameter=1
+    )  # fills the codensity in the second parameter of the simplextree
+
+    # simplificates the simplextree for computation, the signed measure will be recovered from the copy afterward
+    st_copy = st.grid_squeeze(
+        grid_strategy=grid_strategy, resolution=resolution, coordinate_values=True
+    )
+    if sm_kwargs.get("degree", None) is None and sm_kwargs.get("degrees", [None]) == [
+        None
+    ]:
+        expansion_degree = st.num_vertices
+    else:
+        expansion_degree = (
+            max(np.max(sm_kwargs.get("degrees", 1)), sm_kwargs.get("degree", 1)) + 1
+        )
+    st.collapse_edges(num=num_collapses)
+    if not expand_collapse:
+        st.expansion(expansion_degree)  # edge collapse
+    sms = mp.signed_measure(st, **sm_kwargs)  # computes the signed measure
+    del st
+
+    simplices_list = tuple(
+        s for s, _ in st_copy.get_simplices()
+    )  # not optimal, we may want to do that in cython to get edges and nodes
+    sms_diff = []
+    for sm, weights in sms:
+        indices, not_found_indices = st_copy.pts_to_indices(
+            sm, simplices_dimensions=[1, 0]
+        )
+        if sm_kwargs.get("verbose", False):
+            print(
+                f"Found {(1-(indices == -1).mean()).round(2)} indices. \
+                Out : {(indices == -1).sum()}, {len(not_found_indices)}"
+            )
+        sm_diff = torch.empty(sm.shape).type(dtype)
+        # sim_dim = sm_diff.shape[1] // 2
+
+        # fills the Rips-filtrations of the signed measure.
+        # the loop is for the rank invariant
+        for i in range(0, sm_diff.shape[1], 2):
+            idxs = indices[:, i]
+            if (idxs == -1).all():
+                continue
+            useful_idxs = idxs != -1
+            # Retrieves the differentiable values from the distance_matrix
+            if useful_idxs.size > 0:
+                edges_filtrations = torch.cat(
+                    [
+                        distance_matrix[*simplices_list[idx], None]
+                        for idx in idxs[useful_idxs]
+                    ]
+                )
+                # fills theses values into the signed measure
+                sm_diff[:, i][useful_idxs] = edges_filtrations
+        # same for the other axis
+        for i in range(1, sm_diff.shape[1], 2):
+            idxs = indices[:, i]
+            if (idxs == -1).all():
+                continue
+            useful_idxs = idxs != -1
+            if useful_idxs.size > 0:
+                nodes_filtrations = torch.cat(
+                    [codensity[simplices_list[idx]] for idx in idxs[useful_idxs]]
+                )
+                sm_diff[:, i][useful_idxs] = nodes_filtrations
+
+        # fills not-found values as constants
+        if len(not_found_indices) > 0:
+            not_found_indices = indices == -1
+            sm_diff[indices == -1] = torch.from_numpy(sm[indices == -1]).type(dtype)
+
+        sms_diff.append((sm_diff, torch.from_numpy(weights)))
+    flags = [True, return_original, return_st]
+    if np.sum(flags) == 1:
+        return sms_diff
+    return tuple(stuff for stuff, flag in zip([sms_diff, sms, st_copy], flags) if flag)
+
+
+def function_rips_signed_measure(
+    x,
+    theta: Optional[float] = None,
+    function: Literal["dtm", "gaussian", "exponential"] | Callable = "gaussian",
+    threshold: Optional[float] = None,
+    grid_strategy: Literal[
+        "regular_closest", "exact", "quantile", "regular_left"
+    ] = "exact",
+    complex: Literal["rips", "delaunay", "weak_delaunay"] = "rips",
+    resolution: int = 100,
+    safe_conversion: bool = False,
+    num_collapses: Optional[int] = None,
+    expand_collapse: bool = False,
+    dtype=torch.float32,
+    plot=False,
+    # return_st: bool = False,
+    *,
+    log_density: bool = True,
+    vineyard: bool = False,
+    pers_backend=None,
+    **sm_kwargs,
+):
+    """
+    Computes a torch-differentiable function-rips signed measure.
+
+    Input
+    -----
+     - x (num_pts, dim) : The point cloud
+     - theta: For density-like functions : the bandwidth
+     - threshold : rips threshold
+     - function : Either "dtm", "gaussian", or "exponenetial" or Callable.
+       Function to compute the second parameter.
+     - grid_strategy: grid coarsenning strategy.
+     - resolution : when coarsenning, the target resolution,
+     - return_original : Also returns the non-differentiable signed measure.
+     - safe_conversion : Activate this if you encounter crashes.
+     - **kwargs : for the signed measure computation.
+    """
+    if num_collapses is None:
+        num_collapses = -1 if complex == "rips" else None
+    assert isinstance(x, torch.Tensor)
+    if function == "dtm":
+        assert theta is not None, "Provide a theta to compute DTM"
+        codensity = DTM(masses=[theta]).fit(x).score_samples_diff(x)[0].type(dtype)
+    elif function in ["gaussian", "exponential"]:
+        assert theta is not None, "Provide a theta to compute density estimation"
+        codensity = (
+            -KDE(
+                bandwidth=theta,
+                kernel=function,
+                return_log=log_density,
+            )
+            .fit(x)
+            .score_samples(x)
+            .type(dtype)
+        )
+    elif isinstance(function, torch.Tensor):
+        assert (
+            function.ndim == 1 and codensity.shape[0] == x.shape[0]
+        ), """
+        When function is a tensor, it is interpreted as the value of some function over x. 
+        """
+        codensity = function
+    else:
+        assert callable(function), "Function has to be callable"
+        if theta is None:
+            codensity = function(x).type(dtype)
+        else:
+            codensity = function(x, theta=theta).type(dtype)
+
+    distance_matrix = torch.cdist(x, x).type(dtype)
+    distances = distance_matrix.ravel()
+    if complex == "rips":
+        threshold = (
+            distance_matrix.max(axis=1).values.min() if threshold is None else threshold
+        )
+        distances = distances[distances <= threshold]
+    elif complex in ["delaunay", "weak_delaunay"]:
+        complex = "delaunay"
+        distances /= 2
+    else:
+        raise ValueError(
+            f"Unimplemented with complex {complex}. You can use rips or delaunay ftm."
+        )
+
+    # simplificates the simplextree for computation, the signed measure will be recovered from the copy afterward
+    reduced_grid = get_grid(strategy=grid_strategy)((distances, codensity), resolution)
+
+    degrees = sm_kwargs.pop("degrees", [])
+    if sm_kwargs.get("degree", None) is not None:
+        degrees = [sm_kwargs.pop("degree", None)] + degrees
+    if complex == "rips":
+        # st = RipsComplex(
+        #     distance_matrix=distance_matrix.detach(), max_edge_length=threshold
+        # ).create_simplex_tree()
+        st = gd.SimplexTree.create_from_array(
+            distance_matrix.detach(), max_filtration=threshold
+        )
+        # detach makes a new (reference) tensor, without tracking the gradient
+        st = mp.SimplexTreeMulti(st, num_parameters=2, safe_conversion=safe_conversion)
+        st.fill_lowerstar(
+            codensity.detach(), parameter=1
+        )  # fills the codensity in the second parameter of the simplextree
+        st = st.grid_squeeze(reduced_grid)
+        st.filtration_grid = []
+        if None in degrees:
+            expansion_degree = st.num_vertices
+        else:
+            expansion_degree = max(degrees) + 1
+        st.collapse_edges(num=num_collapses)
+        if not expand_collapse:
+            st.expansion(expansion_degree)  # edge collapse
+
+        s = mp.Slicer(st, vineyard=vineyard, backend=pers_backend)
+    elif complex == "delaunay":
+        s = mp.slicer.from_function_delaunay(
+            x.detach().numpy(), codensity.detach().numpy()
+        )
+        st = mp.slicer.to_simplextree(s)
+        st.flagify(2)
+        s = mp.Slicer(st, vineyard=vineyard, backend=pers_backend).grid_squeeze(
+            reduced_grid
+        )
+
+    s.filtration_grid = []  ## To enforce minpres to be reasonable
+    if None not in degrees:
+        s = s.minpres(degrees=degrees)
+    else:
+        from joblib import Parallel, delayed
+
+        s = tuple(
+            Parallel(n_jobs=-1, backend="threading")(
+                delayed(lambda d: s if d is None else s.minpres(degree=d))(d)
+                for d in degrees
+            )
+        )
+    ## fix previous hack
+    for stuff in s:
+        # stuff.filtration_grid = reduced_grid ## not necessary
+        stuff.filtration_grid = [[1]] * stuff.num_parameters
+
+    sms = tuple(
+        sm
+        for slicer_of_degree, degree in zip(s, degrees)
+        for sm in mp.signed_measure(
+            slicer_of_degree, grid=reduced_grid, degree=degree, **sm_kwargs
+        )
+    )  # computes the signed measure
+    if plot:
+        mp.plots.plot_signed_measures(
+            tuple((sm.detach().numpy(), w.detach().numpy()) for sm, w in sms)
+        )
+    return sms