multipers 2.3.3b6__cp311-cp311-macosx_11_0_arm64.whl

multipers/ml/mma.py

@@ -0,0 +1,713 @@
+from typing import Callable, Iterable, List, Optional, Union
+
+import numpy as np
+from joblib import Parallel, delayed
+from sklearn.base import BaseEstimator, TransformerMixin
+from tqdm import tqdm
+
+import multipers as mp
+import multipers.simplex_tree_multi
+import multipers.slicer
+from multipers.grids import compute_grid
+from multipers.mma_structures import PyBox_f64, PyModule_type
+
+_FilteredComplexType = Union[
+    mp.slicer.Slicer_type, mp.simplex_tree_multi.SimplexTreeMulti_type
+]
+
+
+class FilteredComplex2MMA(BaseEstimator, TransformerMixin):
+    """
+    Turns a list of list of simplextrees or slicers to MMA approximations.
+
+    """
+
+    def __init__(
+        self,
+        n_jobs: int = -1,
+        expand_dim: Optional[int] = None,
+        prune_degrees_above: Optional[int] = None,
+        progress=False,
+        minpres_degrees: Optional[Iterable[int]] = None,
+        plot: bool = False,
+        **persistence_kwargs,
+    ) -> None:
+        super().__init__()
+        self.persistence_args = persistence_kwargs
+        self.n_jobs = n_jobs
+        self._num_axis = None
+        self.prune_degrees_above = prune_degrees_above
+        self.progress = progress
+        self.expand_dim = expand_dim
+        self._boxes = None
+        self._is_minpres = None
+        self.minpres_degrees = minpres_degrees
+        self.plot = plot
+        return
+
+    @staticmethod
+    def _is_filtered_complex(input):
+        return mp.simplex_tree_multi.is_simplextree_multi(input) or mp.slicer.is_slicer(
+            input, allow_minpres=True
+        )
+
+    def _input_checks(self, X):
+        assert len(X) > 0, "No filtered complex found. Cannot fit."
+        assert self._is_filtered_complex(
+            X[0][0]
+        ), f"X[0] is not a known filtered complex, {X[0]=}, nor X[0][0]."
+        self._num_axis = len(X[0])
+        first = X[0][0]
+        assert (
+            not mp.slicer.is_slicer(first) or self.expand_dim is None
+        ), "Cannot expand slicers."
+        self._is_minpres = mp.slicer.is_slicer(first) and isinstance(
+            first, Union[tuple, list]
+        )
+        assert not (
+            self._is_minpres and self.minpres_degrees is not None
+        ), "Input is already a minpres. Cannot reduce again."
+
+    def _infer_bounding_box(self, X):
+        assert self._num_axis is not None, "Fit first"
+        filtration_values = (
+            np.asarray(
+                [
+                    [s.filtration_bounds() for x in X for s in x[axis]]
+                    for axis in range(self._num_axis)
+                ]
+            )
+            if self._is_minpres
+            else np.asarray(
+                [
+                    [x[axis].filtration_bounds() for x in X]
+                    for axis in range(self._num_axis)
+                ]
+            )
+        )
+        num_parameters = filtration_values.shape[-1]
+        # Output : axis, data, min/max, num_parameters
+        # print("TEST : NUM PARAMETERS ", num_parameters)
+        m = np.asarray(
+            [
+                [
+                    filtration_values[axis, :, 0, parameter].min()
+                    for parameter in range(num_parameters)
+                ]
+                for axis in range(self._num_axis)
+            ]
+        )
+        M = np.asarray(
+            [
+                [
+                    filtration_values[axis, :, 1, parameter].max()
+                    for parameter in range(num_parameters)
+                ]
+                for axis in range(self._num_axis)
+            ]
+        )
+        # shape of m/M axis,num_parameters
+        self._boxes = [
+            np.array([m_of_axis, M_of_axis]) for m_of_axis, M_of_axis in zip(m, M)
+        ]
+
+    def fit(self, X, y=None):
+        if len(X) == 0:
+            return self
+        self._input_checks(X)
+        self._infer_bounding_box(X)
+        return self
+
+    def transform(self, X):
+        if self.prune_degrees_above is not None:
+            for x in X:
+                for x_ in x:
+                    if self._is_minpres:
+                        for s_ in x_:
+                            s_.prune_above_dimension(
+                                self.prune_degrees_above
+                            )  # we only do for H0 for computational ease
+                    else:
+                        x_.prune_above_dimension(
+                            self.prune_degrees_above
+                        )  # we only do for H0 for computational ease
+
+        def todo1(x, box):
+            if self.expand_dim is not None:
+                x.expansion(self.expand_dim)
+            if self.minpres_degrees is not None:
+                x = mp.slicer.minimal_presentation(
+                    mp.Slicer(x), degrees=self.minpres_degrees, vineyard=True
+                )
+            mod = mp.module_approximation(
+                x, box=box, verbose=False, **self.persistence_args
+            )
+            if self.plot:
+                mod.plot()
+            return mod
+
+        def todo(sts: Iterable[_FilteredComplexType]):
+            return tuple(todo1(st, box) for st, box in zip(sts, self._boxes))
+
+        return Parallel(n_jobs=self.n_jobs, backend="threading")(
+            delayed(todo)(x)
+            for x in tqdm(X, desc="Computing modules", disable=not self.progress)
+        )
+
+
+class SimplexTree2MMA(FilteredComplex2MMA):
+    def __init__(
+        self,
+        n_jobs: int = -1,
+        expand_dim: Optional[int] = None,
+        prune_degrees_above: Optional[int] = None,
+        progress=False,
+        minpres_degrees: Optional[Iterable[int]] = None,
+        **persistence_kwargs,
+    ):
+        stuff = locals()
+        stuff.pop("self")
+        keys = list(stuff.keys())
+        for key in keys:
+            if key.startswith("__"):
+                stuff.pop(key)
+        super().__init__(**stuff)
+        from warnings import warn
+
+        warn("This class is deprecated, use FilteredComplex2MMA instead.")
+
+
+class MMAFormatter(BaseEstimator, TransformerMixin):
+    def __init__(
+        self,
+        degrees: Optional[list[int]] = None,
+        axis=None,
+        verbose: bool = False,
+        normalize: bool = False,
+        weights=None,
+        quantiles=None,
+        dump=False,
+        from_dump=False,
+    ):
+        self._module_bounds = None
+        self.verbose = verbose
+        self.axis = axis
+        self._axis = []
+        self._has_axis = None
+        self._num_axis = 0
+        self.degrees = degrees
+        self._degrees = None
+        self.normalize = normalize
+        self._num_parameters = None
+        self.weights = weights
+        self.quantiles = quantiles
+        self.dump = dump
+        self.from_dump = from_dump
+
+    @staticmethod
+    def _maybe_from_dump(X_in):
+        if len(X_in) == 0:
+            return X_in
+        import pickle
+
+        if isinstance(X_in[0], bytes):
+            X = [pickle.loads(mods) for mods in X_in]
+        else:
+            X = X_in
+        return X
+        # return [[mp.multiparameter_module_approximation.from_dump(mod) for mod in mods] for mods in dumped_modules]
+
+    @staticmethod
+    def _get_module_bound(x, degree):
+        """
+        Output format : (2,num_parameters)
+        """
+        # l,L = x.get_box()
+        filtration_values = x.get_module_of_degree(degree).get_filtration_values(
+            unique=True
+        )
+        out = np.array([[f[0], f[-1]] for f in filtration_values if len(f) > 0]).T
+        if len(out) != 2:
+            print(f"Missing degree {degree} here !")
+            m = M = [np.nan for _ in range(x.num_parameters)]
+        else:
+            m, M = out
+        # m = np.where(m<np.inf, m, l)
+        # M = np.where(M>-np.inf, M,L)
+        return m, M
+
+    @staticmethod
+    def _infer_axis(X):
+        has_axis = not isinstance(X[0], PyModule_type)
+        assert not has_axis or isinstance(X[0][0], PyModule_type)
+        return has_axis
+
+    @staticmethod
+    def _infer_num_parameters(X, ax=slice(None)):
+        return X[0][ax].num_parameters
+
+    @staticmethod
+    def _infer_bounds(X, degrees=None, axis=[slice(None)], quantiles=None):
+        """
+        Compute bounds of filtration values of a list of modules.
+
+        Output Format
+        -------------
+        m,M of shape : (num_axis,num_degrees,2,num_parameters)
+        """
+        if degrees is None:
+            degrees = np.arange(X[0][axis[0]].max_degree + 1)
+        bounds = np.array(
+            [
+                [
+                    [
+                        MMAFormatter._get_module_bound(x[ax], degree)
+                        for degree in degrees
+                    ]
+                    for ax in axis
+                ]
+                for x in X
+            ]
+        )
+        if quantiles is not None:
+            qm, qM = quantiles
+            # TODO per axis, degree !!
+            # m = np.quantile(bounds[:,:,:,0,:], q=qm,axis=0)
+            # M = np.quantile(bounds[:,:,:,1,:], q=1-qM,axis=0)
+            num_pts, num_axis, num_degrees, _, num_parameters = bounds.shape
+            m = [
+                [
+                    [
+                        np.nanquantile(
+                            bounds[:, ax, degree, 0, parameter], axis=0, q=qm
+                        )
+                        for parameter in range(num_parameters)
+                    ]
+                    for degree in range(num_degrees)
+                ]
+                for ax in range(num_axis)
+            ]
+            m = np.asarray(m)
+            M = [
+                [
+                    [
+                        np.nanquantile(
+                            bounds[:, ax, degree, 1, parameter], axis=0, q=1 - qM
+                        )
+                        for parameter in range(num_parameters)
+                    ]
+                    for degree in range(num_degrees)
+                ]
+                for ax in range(num_axis)
+            ]
+            M = np.asarray(M)
+        else:
+            num_pts, num_axis, num_degrees, _, num_parameters = bounds.shape
+            m = [
+                [
+                    [
+                        np.nanmin(bounds[:, ax, degree, 0, parameter], axis=0)
+                        for parameter in range(num_parameters)
+                    ]
+                    for degree in range(num_degrees)
+                ]
+                for ax in range(num_axis)
+            ]
+            m = np.asarray(m)
+            M = [
+                [
+                    [
+                        np.nanmax(bounds[:, ax, degree, 1, parameter], axis=0)
+                        for parameter in range(num_parameters)
+                    ]
+                    for degree in range(num_degrees)
+                ]
+                for ax in range(num_axis)
+            ]
+            M = np.asarray(M)
+            # m = bounds[:,:,:,0,:].min(axis=0)
+            # M = bounds[:,:,:,1,:].max(axis=0)
+        return (m, M)
+
+    @staticmethod
+    def _infer_grid(
+        X: List[PyModule_type], strategy: str, resolution: int, degrees=None
+    ):
+        """
+        Given a list of PyModules, computes a multiparameter discrete grid,
+        with a given strategy,
+        from the filtration values of the summands of the modules.
+        """
+        num_parameters = X[0].num_parameters
+        if degrees is None:
+            # Format here : ((filtration values of parameter) for parameter)
+            filtration_values = tuple(
+                mod.get_filtration_values(unique=True) for mod in X
+            )
+        else:
+            filtration_values = tuple(
+                mod.get_module_of_degrees(degrees).get_filtration_values(unique=True)
+                for mod in X
+            )
+
+        if "_mean" in strategy:
+            substrategy = strategy.split("_")[0]
+            processed_filtration_values = [
+                compute_grid(f, resolution, substrategy, unique=False)
+                for f in filtration_values
+            ]
+            reduced_grid = np.mean(processed_filtration_values, axis=0)
+        # elif "_quantile" in strategy:
+        # substrategy = strategy.split("_")[0]
+        # processed_filtration_values = [reduce_grid(f, resolution, substrategy, unique=False) for f in filtration_values]
+        # reduced_grid = np.qu(processed_filtration_values, axis=0)
+        else:
+            filtration_values = [
+                np.unique(
+                    np.concatenate([f[parameter] for f in filtration_values], axis=0)
+                )
+                for parameter in range(num_parameters)
+            ]
+            reduced_grid = compute_grid(
+                filtration_values, resolution, strategy, unique=True
+            )
+
+        return reduced_grid
+
+    def _infer_degrees(self, X):
+        if self.degrees is None:
+            max_degrees = [
+                x[ax].max_degree for i, ax in enumerate(self._axis) for x in X
+            ] + [0]
+            self._degrees = np.arange(np.max(max_degrees) + 1)
+        else:
+            self._degrees = self.degrees
+
+    def fit(self, X_in, y=None):
+        X = self._maybe_from_dump(X_in)
+        if len(X) == 0:
+            return self
+        self._has_axis = self._infer_axis(X)
+        # assert not self._has_axis or isinstance(X[0][0], mp.PyModule)
+        if self.axis is None and self._has_axis:
+            self.axis = -1
+        if self.axis is not None and not (self._has_axis):
+            raise Exception(f"SMF didn't find an axis, but requested axis {self.axis}")
+        if self._has_axis:
+            self._num_axis = len(X[0])
+        if self.verbose:
+            print("-----------MMAFormatter-----------")
+            print("---- Infered stats")
+            print(f"Found axis : {self._has_axis}, num : {self._num_axis}")
+            print(f"Number of parameters : {self._num_parameters}")
+        self._axis = (
+            [slice(None)]
+            if self.axis is None
+            else range(self._num_axis) if self.axis == -1 else [self.axis]
+        )
+        self._infer_degrees(X)
+
+        self._num_parameters = self._infer_num_parameters(X, ax=self._axis[0])
+        if self.normalize:
+            # print(self._axis)
+            self._module_bounds = self._infer_bounds(
+                X, self._degrees, self._axis, self.quantiles
+            )
+        else:
+            m = np.zeros((self._num_axis, len(self._degrees), self._num_parameters))
+            M = m + 1
+            self._module_bounds = (m, M)
+        assert self._num_parameters == self._module_bounds[0].shape[-1]
+        if self.verbose:
+            print("---- Bounds (only computed if normalize):")
+            if self._has_axis and self._num_axis > 1:
+                print("(axis) x (degree) x (parameter)")
+            else:
+                print("(degree) x (parameter)")
+            m, M = self._module_bounds
+            print("-- Lower bound : ", m.shape)
+            print(m)
+            print("-- Upper bound :", M.shape)
+            print(M)
+        w = 1 if self.weights is None else np.asarray(self.weights)
+        m, M = self._module_bounds
+        normalizer = M - m
+        zero_normalizer = normalizer == 0
+        if np.any(zero_normalizer):
+            from warnings import warn
+
+            warn(f"Encountered empty bounds. Please fix me. \n M-m = {normalizer}")
+        normalizer[zero_normalizer] = 1
+        self._normalization_factors = w / normalizer
+        if self.verbose:
+            print("-- Normalization factors:", self._normalization_factors.shape)
+            print(self._normalization_factors)
+
+        if self.verbose:
+            print("---- Module size :")
+            for ax in self._axis:
+                print(f"- Axis {ax}")
+                for degree in self._degrees:
+                    sizes = [len(x[ax].get_module_of_degree(degree)) for x in X]
+                    print(
+                        f" - Degree {degree} size \
+                        {np.mean(sizes).round(decimals=2)}\
+                        ±{np.std(sizes).round(decimals=2)}"
+                    )
+            print("----------------------------------")
+        return self
+
+    @staticmethod
+    def copy_transform(mod, degrees, translation, rescale_factors, new_box):
+        copy = mod.get_module_of_degrees(
+            degrees
+        )  # and only returns the specific degrees
+        for j, degree in enumerate(degrees):
+            copy.translate(translation[j], degree=degree)
+            copy.rescale(rescale_factors[j], degree=degree)
+        copy.set_box(new_box)
+        return copy
+
+    def transform(self, X_in):
+        X = self._maybe_from_dump(X_in)
+        if np.any(self._normalization_factors != 1):
+            if self.verbose:
+                print("Normalizing...", end="")
+            w = (
+                [1] * self._num_parameters
+                if self.weights is None
+                else np.asarray(self.weights)
+            )
+            standard_box = np.array([[0] * self._num_parameters, w])
+
+            X_copy = [
+                [
+                    self.copy_transform(
+                        mod=x[ax],
+                        degrees=self._degrees,
+                        translation=-self._module_bounds[0][i],
+                        rescale_factors=self._normalization_factors[i],
+                        new_box=standard_box,
+                    )
+                    for i, ax in enumerate(self._axis)
+                ]
+                for x in X
+            ]
+            if self.verbose:
+                print("Done.")
+            return X_copy
+        if self.axis != -1:
+            X = [x[self.axis] for x in X]
+        if self.dump:
+            import pickle
+
+            X = [pickle.dumps(mods) for mods in X]
+        return X
+        # return [todo(x) for x in X]
+
+
+class MMA2IMG(BaseEstimator, TransformerMixin):
+    def __init__(
+        self,
+        degrees: list,
+        bandwidth: float = 0.1,
+        power: float = 1,
+        normalize: bool = False,
+        resolution: list | int = 50,
+        plot: bool = False,
+        box=None,
+        n_jobs=-1,
+        flatten=False,
+        progress=False,
+        grid_strategy="regular",
+        kernel="linear",
+        signed: bool = False,
+    ):
+        self.bandwidth = bandwidth
+        self.degrees = degrees
+        self.resolution = resolution
+        self.box = box
+        self.plot = plot
+        self._box = None
+        self.normalize = normalize
+        self.power = power
+        self._has_axis = None
+        self._num_parameters = None
+        self.n_jobs = n_jobs
+        self.flatten = flatten
+        self.progress = progress
+        self.grid_strategy = grid_strategy
+        self._num_axis = None
+        self._coords_to_compute = None
+        self._new_resolutions = None
+        self.kernel = kernel
+        self.signed = signed
+
+    def fit(self, X, y=None):
+        # TODO infer box
+        # TODO rescale module
+        self._has_axis = MMAFormatter._infer_axis(X)
+        if self._has_axis:
+            self._num_axis = len(X[0])
+        if self.box is None:
+            self._box = [[0, 0], [1, 1]]
+        else:
+            self._box = self.box
+        if self._has_axis:
+            its = (tuple(x[axis] for x in X) for axis in range(self._num_axis))
+            crs = tuple(
+                MMAFormatter._infer_grid(
+                    X_axis, self.grid_strategy, self.resolution, degrees=self.degrees
+                )
+                for X_axis in its
+            )
+            self._coords_to_compute = (
+                crs  # not the same resolutions, so cannot be put in an array
+            )
+            self._new_resolutions = np.asarray([tuple(len(g) for g in G) for G in crs])
+        else:
+            coords = MMAFormatter._infer_grid(
+                X, self.grid_strategy, self.resolution, degrees=self.degrees
+            )
+            self._coords_to_compute = coords
+            self._new_resolutions = np.array([len(g) for g in coords])
+        return self
+
+    def transform(self, X):
+        img_args = {
+            "bandwidth": self.bandwidth,
+            "p": self.power,
+            "normalize": self.normalize,
+            # "plot":self.plot,
+            # "cb":1, # colorbar
+            # "resolution" : self.resolution, # info in coordinates
+            "box": self.box,
+            "degrees": self.degrees,
+            # num_jobs is better for parallel over modules.
+            "n_jobs": self.n_jobs,
+            "kernel": self.kernel,
+            "signed": self.signed,
+            "flatten": True,  # custom coordinates
+        }
+        if self._has_axis:
+
+            def todo1(x, c):
+                return x.representation(grid=c, **img_args)
+
+        else:
+
+            def todo1(x):
+                return x.representation(grid=self._coords_to_compute, **img_args)[
+                    None, :
+                ]  # shape same as has_axis
+
+        if self._has_axis:
+
+            def todo2(mods):
+                return tuple(
+                    todo1(mod, c) for mod, c in zip(mods, self._coords_to_compute)
+                )
+
+        else:
+            todo2 = todo1
+
+        if self.flatten:
+
+            def todo(mods):
+                return np.concatenate(todo2(mods), axis=1).flatten()
+
+        else:
+
+            def todo(mods):
+                return tuple(
+                    img.reshape(len(img_args["degrees"]), *r)
+                    for img, r in zip(todo2(mods), self._new_resolutions)
+                )
+
+        return Parallel(n_jobs=self.n_jobs, backend="threading")(
+            delayed(todo)(x)
+            for x in tqdm(X, desc="Computing images", disable=not self.progress)
+        )  # res depends on ax (infer_grid)
+
+
+class MMA2Landscape(BaseEstimator, TransformerMixin):
+    """
+    Turns a list of MMA approximations into Landscapes vectorisations
+    """
+
+    def __init__(
+        self,
+        resolution=[100, 100],
+        degrees: list[int] | None = [0, 1],
+        ks: Iterable[int] = range(5),
+        phi: Callable = np.sum,
+        box=None,
+        plot: bool = False,
+        n_jobs=-1,
+        filtration_quantile: float = 0.01,
+    ) -> None:
+        super().__init__()
+        self.resolution: list[int] = resolution
+        self.degrees = degrees
+        self.ks = ks
+        self.phi = phi  # Has to have a axis=0 !
+        self.box = box
+        self.plot = plot
+        self.n_jobs = n_jobs
+        self.filtration_quantile = filtration_quantile
+        return
+
+    def fit(self, X, y=None):
+        if len(X) <= 0:
+            return
+        assert (
+            X[0].num_parameters == 2
+        ), f"Number of parameters {X[0].num_parameters} has to be 2."
+        if self.box is None:
+
+            def _bottom(mod):
+                return mod.get_bottom()
+
+            def _top(mod):
+                return mod.get_top()
+
+            m = np.quantile(
+                Parallel(n_jobs=self.n_jobs, backend="threading")(
+                    delayed(_bottom)(mod) for mod in X
+                ),
+                q=self.filtration_quantile,
+                axis=0,
+            )
+            M = np.quantile(
+                Parallel(n_jobs=self.n_jobs, backend="threading")(
+                    delayed(_top)(mod) for mod in X
+                ),
+                q=1 - self.filtration_quantile,
+                axis=0,
+            )
+            self.box = [m, M]
+        return self
+
+    def transform(self, X) -> list[np.ndarray]:
+        if len(X) <= 0:
+            return []
+
+        def todo(mod):
+            return np.concatenate(
+                [
+                    self.phi(
+                        mod.landscapes(
+                            ks=self.ks,
+                            resolution=self.resolution,
+                            degree=degree,
+                            plot=self.plot,
+                        ),
+                        axis=0,
+                    ).flatten()
+                    for degree in self.degrees
+                ]
+            ).flatten()
+
+        return Parallel(n_jobs=self.n_jobs, backend="threading")(
+            delayed(todo)(x) for x in X
+        )