multipers 2.4.0b1__cp312-cp312-macosx_11_0_arm64.whl

multipers/data/synthetic.py

@@ -0,0 +1,113 @@
+import numpy as np
+
+
+def noisy_annulus(
+    n1: int = 1000,
+    n2: int = 200,
+    r1: float = 1,
+    r2: float = 2,
+    dim: int = 2,
+    center: np.ndarray | list | None = None,
+    **kwargs,
+) -> np.ndarray:
+    """Generates a noisy annulus dataset.
+
+    Parameters
+    ----------
+    r1 : float.
+            Lower radius of the annulus.
+    r2 : float.
+            Upper radius of the annulus.
+    n1 : int
+            Number of points in the annulus.
+    n2 : int
+            Number of points in the square.
+    dim : int
+            Dimension of the annulus.
+    center: list or array
+            center of the annulus.
+
+    Returns
+    -------
+    numpy array
+            Dataset. size : (n1+n2) x dim
+
+    """
+    theta = np.random.normal(size=(n1, dim))
+    theta /= np.linalg.norm(theta, axis=1)[:, None]
+    rs = np.sqrt(np.random.uniform(low=r1**2, high=r2**2, size=n1))
+    annulus = rs[:, None] * theta
+    if center is not None:
+        annulus += np.array(center)
+    diffuse_noise = np.random.uniform(size=(n2, dim), low=-1.1 * r2, high=1.1 * r2)
+    if center is not None:
+        diffuse_noise += np.array(center)
+    return np.vstack([annulus, diffuse_noise])
+
+
+def three_annulus(num_pts: int = 500, num_outliers: int = 500):
+    q, r = divmod(num_pts, 3)
+    num_pts_1, num_pts_2, num_pts_3 = q, q + (r > 0), q + (r > 1)
+    X = np.block(
+        [
+            [np.random.uniform(low=-2, high=2, size=(num_outliers, 2))],
+            [
+                np.array(
+                    noisy_annulus(
+                        r1=0.6,
+                        r2=0.9,
+                        n1=num_pts_1,
+                        n2=0,
+                        center=[1, -0.2],
+                    )
+                )
+            ],
+            [
+                np.array(
+                    noisy_annulus(
+                        r1=0.4,
+                        r2=0.55,
+                        n1=num_pts_2,
+                        n2=0,
+                        center=[-1.2, -1],
+                    )
+                )
+            ],
+            [
+                np.array(
+                    noisy_annulus(
+                        r1=0.3,
+                        r2=0.4,
+                        n1=num_pts_3,
+                        n2=0,
+                        center=[-0.7, 1.1],
+                    )
+                )
+            ],
+        ]
+    )
+    return X
+
+
+def orbit(n: int = 1000, r: float = 1.0, x0=[]):
+    point_list = []
+    if len(x0) != 2:
+        x, y = np.random.uniform(size=2)
+    else:
+        x, y = x0
+    point_list.append([x, y])
+    for _ in range(n - 1):
+        x = (x + r * y * (1 - y)) % 1
+        y = (y + r * x * (1 - x)) % 1
+        point_list.append([x, y])
+    return np.asarray(point_list, dtype=float)
+
+
+def get_orbit5k(num_pts=1000, num_data=5000):
+    from sklearn.preprocessing import LabelEncoder
+
+    rs = [2.5, 3.5, 4, 4.1, 4.3]
+    labels = np.random.choice(rs, size=num_data, replace=True)
+    X = [orbit(n=num_pts, r=r) for r in labels]
+    labels = LabelEncoder().fit_transform(labels)
+    return X, labels

multipers/distances.py

@@ -0,0 +1,202 @@
+import numpy as np
+import ot
+
+from multipers.mma_structures import PyMultiDiagrams_type
+from multipers.multiparameter_module_approximation import PyModule_type
+from multipers.simplex_tree_multi import SimplexTreeMulti_type
+
+
+def sm2diff(sm1, sm2, threshold=None):
+    pts = sm1[0]
+    dtype = pts.dtype
+    if isinstance(pts, np.ndarray):
+
+        def backend_concatenate(a, b):
+            return np.concatenate([a, b], axis=0, dtype=dtype)
+
+        def backend_tensor(x):
+            return np.asarray(x, dtype=int)
+
+    else:
+        import torch
+
+        assert isinstance(pts, torch.Tensor), "Invalid backend. Numpy or torch."
+
+        def backend_concatenate(a, b):
+            return torch.concatenate([a, b], dim=0)
+
+        def backend_tensor(x):
+            return torch.tensor(x).type(torch.int)
+
+    pts1, w1 = sm1
+    pts2, w2 = sm2
+    ## TODO: optimize this
+    pos_indices1 = backend_tensor(
+        [i for i, w in enumerate(w1) for _ in range(w) if w > 0]
+    )
+    pos_indices2 = backend_tensor(
+        [i for i, w in enumerate(w2) for _ in range(w) if w > 0]
+    )
+    neg_indices1 = backend_tensor(
+        [i for i, w in enumerate(w1) for _ in range(-w) if w < 0]
+    )
+    neg_indices2 = backend_tensor(
+        [i for i, w in enumerate(w2) for _ in range(-w) if w < 0]
+    )
+    x = backend_concatenate(pts1[pos_indices1], pts2[neg_indices2])
+    y = backend_concatenate(pts1[neg_indices1], pts2[pos_indices2])
+    if threshold is not None:
+        x[x > threshold] = threshold
+        y[y > threshold] = threshold
+    return x, y
+
+
+def sm_distance(
+    sm1: tuple,
+    sm2: tuple,
+    reg: float = 0,
+    reg_m: float = 0,
+    numItermax: int = 10000,
+    p: float = 1,
+    threshold=None,
+):
+    """
+    Computes the wasserstein distances between two signed measures,
+    of the form
+     - (pts,weights)
+    with
+     - pts : (num_pts, dim) float array
+     - weights : (num_pts,) int array
+
+    Regularisation:
+     - sinkhorn if reg != 0
+     - sinkhorn unbalanced if reg_m != 0
+    """
+    x, y = sm2diff(sm1, sm2, threshold=threshold)
+    loss = ot.dist(
+        x, y, metric="sqeuclidean", p=p
+    )  # only euc + sqeuclidian are implemented in pot for the moment with torch backend # TODO : check later
+    if isinstance(x, np.ndarray):
+        empty_tensor = np.array([])  # uniform weights
+    else:
+        import torch
+
+        assert isinstance(x, torch.Tensor), "Unimplemented backend."
+        empty_tensor = torch.tensor([])  # uniform weights
+
+    if reg == 0:
+        return ot.lp.emd2(empty_tensor, empty_tensor, M=loss) * len(x)
+    if reg_m == 0:
+        return ot.sinkhorn2(
+            a=empty_tensor, b=empty_tensor, M=loss, reg=reg, numItermax=numItermax
+        )
+    return ot.sinkhorn_unbalanced2(
+        a=empty_tensor,
+        b=empty_tensor,
+        M=loss,
+        reg=reg,
+        reg_m=reg_m,
+        numItermax=numItermax,
+    )
+    # return ot.sinkhorn2(a=onesx,b=onesy,M=loss,reg=reg, numItermax=numItermax)
+    # return ot.bregman.empirical_sinkhorn2(x,y,reg=reg)
+
+
+def estimate_matching(b1: PyMultiDiagrams_type, b2: PyMultiDiagrams_type):
+    assert len(b1) == len(b2)
+    from gudhi.bottleneck import bottleneck_distance
+
+    def get_bc(b: PyMultiDiagrams_type, i: int) -> np.ndarray:
+        temp = b[i].get_points()
+        out = (
+            np.array(temp)[:, :, 0] if len(temp) > 0 else np.empty((0, 2))
+        )  # GUDHI FIX
+        return out
+
+    return max(
+        (bottleneck_distance(get_bc(b1, i), get_bc(b2, i)) for i in range(len(b1)))
+    )
+
+
+# Functions to estimate precision
+def estimate_error(
+    st: SimplexTreeMulti_type,
+    module: PyModule_type,
+    degree: int,
+    nlines: int = 100,
+    verbose: bool = False,
+):
+    """
+    Given an MMA SimplexTree and PyModule, estimates the bottleneck distance using barcodes given by gudhi.
+
+    Parameters
+    ----------
+     - st:SimplexTree
+        The simplextree representing the n-filtered complex. Used to define the gudhi simplextrees on different lines.
+     - module:PyModule
+        The module on which to estimate approximation error, w.r.t. the original simplextree st.
+     - degree:int
+        The homology degree to consider
+
+    Returns
+    -------
+     - float:The estimation of the matching distance, i.e., the maximum of the sampled bottleneck distances.
+
+    """
+    from time import perf_counter
+
+    parameter = 0
+
+    def _get_bc_ST(st, basepoint, degree: int):
+        """
+        Slices an mma simplextree to a gudhi simplextree, and compute its persistence on the diagonal line crossing the given basepoint.
+        """
+        gst = st.project_on_line(
+            basepoint=basepoint, parameter=parameter
+        )  # we consider only the 1rst coordinate (as )
+        gst.compute_persistence()
+        return gst.persistence_intervals_in_dimension(degree)
+
+    from gudhi.bottleneck import bottleneck_distance
+
+    low, high = module.get_box()
+    nfiltration = len(low)
+    basepoints = np.random.uniform(low=low, high=high, size=(nlines, nfiltration))
+    # barcodes from module
+    print("Computing mma barcodes...", flush=1, end="") if verbose else None
+    time = perf_counter()
+    bcs_from_mod = module.barcodes(degree=degree, basepoints=basepoints).get_points()
+    print(f"Done. {perf_counter() - time}s.") if verbose else None
+
+    def clean(dgm):
+        return np.array(
+            [
+                [birth[parameter], death[parameter]]
+                for birth, death in dgm
+                if len(birth) > 0 and birth[parameter] != np.inf
+            ]
+        )
+
+    bcs_from_mod = [
+        clean(dgm) for dgm in bcs_from_mod
+    ]  # we only consider the 1st coordinate of the barcode
+    # Computes gudhi barcodes
+    from tqdm import tqdm
+
+    bcs_from_gudhi = [
+        _get_bc_ST(st, basepoint=basepoint, degree=degree)
+        for basepoint in tqdm(
+            basepoints, disable=not verbose, desc="Computing gudhi barcodes"
+        )
+    ]
+    return max(
+        (
+            bottleneck_distance(a, b)
+            for a, b in tqdm(
+                zip(bcs_from_mod, bcs_from_gudhi),
+                disable=not verbose,
+                total=nlines,
+                desc="Computing bottleneck distances",
+            )
+        )
+    )