amica-python 0.1.0__py3-none-any.whl

amica/__init__.py

@@ -0,0 +1,5 @@
+from . import datasets, utils
+from ._sklearn_interface import AMICA
+from .core import fit_amica
+
+__all__ = ['fit_amica', 'AMICA', 'datasets', 'utils']

amica/_batching.py

@@ -0,0 +1,194 @@
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import Union
+from warnings import warn
+
+import numpy as np
+import psutil
+import torch
+
+ArrayLike2D = Union[np.ndarray, "np.typing.NDArray[np.floating]"]
+
+
+class BatchLoader:
+    """Iterate over an array in fixed-size batches of data along a chosen axis.
+
+    We hand rolled this instead of using DataLoader because 1) we want to yield
+    slices of input array (i.e. a view), and 2) return the indices as
+    a slice object. DataLoader would internally convert the slice into a tensor
+    of indices.
+
+    Example (AMICA shape):
+        X: (n_samples, n_features)
+        it = BatchLoader(X, axis=0, batch_size=4096)
+        for X_blk, sl in it:
+            # X_blk is X[sl, :] where sl is slice(start, end)
+            ...
+    """
+
+    def __init__(self, X: ArrayLike2D, axis: int, batch_size: int | None = None):
+        # Validate inputs
+        cls_name = self.__class__.__name__
+        if not isinstance(X, torch.Tensor):
+            raise TypeError(f"{cls_name} expects a torch.Tensor")  # pragma: no cover
+        if X.ndim < 1:
+            raise ValueError(
+                f"{cls_name} expects an array with at least 1 dimension"
+            )  # pragma: no cover
+        self.X = X
+        self.axis = axis
+
+        if self.axis < 0:
+            self.axis += X.ndim
+        if not (0 <= self.axis < X.ndim):
+            raise ValueError(
+                f"axis {self.axis} out of bounds for array with ndim={X.ndim}"
+                )
+
+        # Determine batching parameters
+        n = X.shape[self.axis]
+        start = 0
+        stop = n
+        if batch_size is None:
+            # Treat as single chunk spanning [start:stop]
+            batch_size = stop
+
+        # Validate parameters
+        assert (0 <= start <= n), f"start {start} out of range [0, {n}]"
+        assert (0 <= stop <= n), f"stop {stop} out of range [0, {n}]"
+        assert start <= stop, f"start {start} must be <= stop {stop}"
+        if batch_size < 0:
+            raise ValueError(f"batch_size must be positive. Got {batch_size}.")
+        if batch_size > X.shape[self.axis]:
+            raise ValueError(
+                f"batch_size {batch_size} exceeds data size {X.shape[self.axis]} "
+                f"along axis {self.axis}."
+            )
+
+        # Store parameters
+        self.start = start
+        self.stop = stop
+        self.batch_size = int(batch_size)
+
+    def __getitem__(self, idx: int) -> torch.Tensor:
+        start = self.start + idx * self.batch_size
+        stop = min(start + self.batch_size, self.stop)
+
+
+        idx = [slice(None)] * self.X.ndim
+        idx[self.axis] = slice(start, stop)
+        return self.X[tuple(idx)]
+
+    def __iter__(self) -> Iterator[tuple[np.ndarray, slice]]:
+        axis = self.axis
+        start = self.start
+        stop = self.stop
+        step = self.batch_size
+
+        idx = [slice(None)] * self.X.ndim
+        assert -((stop - start) // -step) == len(self)  # sanity check
+        for s in range(start, stop, step):
+            e = min(s + step, stop)
+            batch_slice = slice(s, e)
+            idx[axis] = batch_slice
+            yield self.X[tuple(idx)], batch_slice
+
+    def __len__(self) -> int:
+        return (self.X.shape[self.axis] + self.batch_size - 1) // self.batch_size
+
+    def __repr__(self) -> str:
+        return (
+            f"{self.__class__.__name__}(Data shape: {self.X.shape}, "
+            f"Batched axis: {self.axis}, batch_size: {self.batch_size}, "
+            f"n_batches: {len(self)})"
+        )
+
+def choose_batch_size(
+        *,
+        N: int,
+        n_comps: int,
+        n_mix: int,
+        n_models: int = 1,
+        dtype: np.dtype = np.float64,
+        memory_fraction: float = 0.25,      # use up to 25% of available memory
+        memory_cap: float = 1.5 * 1024**3,  # 1.5 GB absolute ceiling
+        ) -> int:
+    """
+    Choose batch size for processing data in chunks.
+
+    Parameters
+    ----------
+    N : int
+        Total number of samples.
+    n_comps : int
+        Number of components to be learned in the model, e.g. size of the n_components
+        dimension of the data.
+    n_mix : int
+        Number of mixture components per source/component to be learned in the model.
+    dtype : np.dtype, optional
+        Data type of the input data, by default np.float64.
+    memory_cap : float, optional
+        Maximum memory (in bytes) to be used for processing, by default
+        ``1.5 * 1024**3`` (1.5 GB).
+
+    Notes
+    -----
+    The batch size is primarily determined by the estimated size of hot buffers (e.g.
+    y, z, fp, ufp), which scale with the size of n_samples:
+    - One array of shape (N,):
+        - loglik
+    - Two arrays of shape (N, n_models):
+        - modloglik
+        - v (model responsibilities)
+    - Two arrays of shape (N, n_comps)
+        - b
+        - g
+    - Five arrays of shape (N, n_comps, n_mix): u, y, z, fp, ufp
+        - u (mixture responsibilities)
+        - y
+        - z
+        - fp
+        - ufp
+    """
+    dtype_size = np.dtype(dtype).itemsize
+    # per-sample cost across pre-allocated buffers
+    bytes_per_sample = (
+        1                       # loglik
+        + 2 * n_models          # modloglik, v
+        + 2 * n_comps           # b, g
+        + 5 * n_comps * n_mix   # fp, u, ufp, y, z,
+        ) * dtype_size
+    # Plus small headroom for intermediates
+    bytes_per_sample = int(bytes_per_sample * 1.2)
+
+    # Pick memory budget
+    try:
+        hard_cap = 4 * 1024**3  # 4 GiB (avoid runaway memory use)
+        avail_mem = psutil.virtual_memory().available
+        mem_cap = min(avail_mem * memory_fraction, hard_cap)
+    except Exception:
+        mem_cap = memory_cap  # fallback to user-specified cap
+
+    max_batch_size = mem_cap // bytes_per_sample
+
+    # Ensure at least 1 sample. This should only trigger if n_comps and n_mix are huge.
+    if max_batch_size < 1:
+        raise MemoryError(
+            f"Cannot fit even 1 sample within memory cap of "
+            f"{mem_cap / 1024**3:.2f} GiB. "
+            f"Per-sample memory cost is {bytes_per_sample / 1024**3:.2f} GB."
+        )
+    batch_size = int(min(N, max_batch_size))
+
+    # Heuristic floor, we don't want absurdly small chunks or chunks that are too
+    # small relative to the model complexity (n_comps)
+    # This heuristic works well for typical ICA regimes, where n_comps is < 256
+    min_batch_size = max(8192, n_comps * 32)  # at least 32 samples per component
+    min_batch_size = min(min_batch_size, N)  # Cannot exceed N
+    if batch_size < min_batch_size:
+        warn(
+            f"Warning: To stay within the memory cap, batch size is {batch_size} "
+            f"samples, which is below the recommended minimum of {min_batch_size}."
+        )
+    return batch_size

amica/_newton.py

@@ -0,0 +1,77 @@
+"""Quasi-Newton related computations for estimation of gradient curvature terms."""
+import torch
+
+
+def compute_newton_terms(*, config, accumulators, mu):
+    """Compute second-order curvature or scaling terms for Hessian approximation.
+
+    Parameters
+    ----------
+    config : amica.state.Config
+        Configuration object containing model parameters. Specifically, it should have
+        ``n_components`` and ``dtype`` attributes.
+    accumulators : amica.state.Accumulators
+        Accumulators instance containing intermediate tensors needed for Newton term
+        calculations. It should have tensors stored in the following attributes:
+
+        - ``dbaralpha_numer`` (n_components, n_mixtures)
+        - ``dbaralpha_denom`` (n_components, n_mixtures)
+        - ``dsigma2_numer`` (n_components,)
+        - ``dsigma2_denom`` (n_components,)
+        - ``dkappa_numer`` (n_components, n_mixtures)
+        - ``dkappa_denom`` (n_components, n_mixtures)
+        - ``dlambda_numer`` (n_components, n_mixtures)
+        - ``dlambda_denom`` (n_components, n_mixtures)
+
+    mu : torch.Tensor
+        Tensor of shape (n_components, n_mixtures) representing the mean estimates for
+        each component and mixture. This is typically stored in the state object
+        (``state.mu``).
+
+    Returns
+    -------
+    dict
+        A dictionary containing the computed Newton terms:
+        - ``baralpha``: Tensor of shape (n_components, n_mixtures)
+        - ``sigma2``: Tensor of shape (n_components,)
+        - ``kappa``: Tensor of shape (n_components,)
+        - ``lambda_``: Tensor of shape (n_components,)
+    """
+    #--------------------------FORTRAN CODE--------------------------------------------
+    # baralpha = dbaralpha_numer / dbaralpha_denom
+    # sigma2 = dsigma2_numer / dsigma2_denom
+    # kappa = dble(0.0)
+    # lambda = dble(0.0)
+    #-----------------------------------------------------------------------------------
+    # weighting factor: how much mixture j contributes to source i
+    baralpha = accumulators.newton.dbaralpha_numer / accumulators.newton.dbaralpha_denom
+    # variance estimate for source i
+    sigma2 = accumulators.newton.dsigma2_numer / accumulators.newton.dsigma2_denom
+    # curvature terms
+    kappa = torch.zeros(
+        (config.n_components,), dtype=config.dtype, device=config.device
+        )
+    lambda_ = torch.zeros(
+        (config.n_components,), dtype=config.dtype, device=config.device
+        )
+
+    # Calculate dkap for all mixtures
+    dkap = accumulators.newton.dkappa_numer / accumulators.newton.dkappa_denom
+    kappa += torch.sum(baralpha * dkap, dim=1)
+
+    #--------------------------FORTRAN CODE-------------------------
+    # lambda(i,h) = lambda(i,h) + ...
+    #       baralpha(j,i,h) * ( dlambda_numer(j,i,h)/dlambda_denom(j,i,h) + ...
+    #---------------------------------------------------------------
+    lambda_inner_term = (
+        (accumulators.newton.dlambda_numer / accumulators.newton.dlambda_denom)
+        + (dkap * mu**2)
+    )
+    lambda_ += torch.sum(baralpha * lambda_inner_term, dim=1)
+
+    return {
+        "baralpha": baralpha,       # (n_components, n_mixtures)
+        "sigma2": sigma2,           # (n_components,)
+        "kappa": kappa,             # (n_components,)
+        "lambda_": lambda_,         # (n_components,)
+    }

amica/_sklearn_interface.py

@@ -0,0 +1,387 @@
+"""Scikit-learn class wrapper for AMICA."""
+import warnings
+
+import numpy as np
+from sklearn.base import BaseEstimator, TransformerMixin
+from sklearn.utils.validation import check_is_fitted, validate_data
+
+from .core import fit_amica
+
+CHECK_ARRAY_KWARGS = {
+    "dtype": [np.float64, np.float32],
+    "ensure_min_samples": 2,  # safeguard accidental (n_features, n_samples) inputs
+    "ensure_min_features": 2,
+}
+
+class AMICA(TransformerMixin, BaseEstimator):
+    """AMICA: adaptive Mixture algorithm for Independent Component Analysis.
+
+    Implements the AMICA algorithm as described in :footcite:t:`palmer2012` and
+    :footcite:t:`palmer2008`, and originally implemented in :footcite:t:`amica`.
+
+    Parameters
+    ----------
+    n_components : int, default=None
+        Number of components to use. If ``None``, then ``n_components == n_features``.
+
+        .. note::
+            If the data are rank deficient, then the effective number of components
+            will be lower than ``n_components``, as the number of components will be
+            set to the data rank.
+
+    n_mixtures : int, default=3
+        Number of mixtures components to use in the Gaussian Mixture Model (GMM) for
+        each component's source density. default is ``3``.
+    n_models : int, default=1
+        Number of ICA decompositions to run. Only ``1`` is supported currently.
+    batch_size : int, optional
+        Batch size for processing data in chunks along the samples axis. If ``None``,
+        batching is chosen automatically to keep peak memory under ~1.5 GB, and
+        warns if the batch size is below ~8k samples. If the input data is small enough
+        to process in one shot, no batching is used. If you want to enforce no batching
+        even when the data is very large, set ``batch_size`` to ``X.shape[0]``
+        to process all samples at once, but note that this may lead to
+        high memory usage for large datasets.
+    device : str, default='cpu'
+        Device to run the computations on. Can be either 'cpu' or 'cuda' for GPU
+        acceleration. Note that using 'cuda' requires a compatible NVIDIA GPU and
+        the appropriate CUDA drivers installed.
+    mean_center : bool, default=True
+        If ``True``, the data is mean-centered before whitening and fitting. This is
+        equivalent to ``do_mean=1`` in the Fortran AMICA program.
+    whiten : str {"zca", "pca", "variance"}, default="zca"
+        whitening strategy.
+
+        - ``"zca"``: Data is whitened with the inverse of the symmetric square
+            root of the covariance matrix. if ``n_components`` < ``n_features``, then
+            approximate sphering is done by multiplying by the eigenvectors of a reduced
+            dimensional subset of the principle component (eigenvector) subspace. This
+            is equivalent to ``do_sphere=1`` + ``do_approx_sphere=1`` in the
+            Fortran AMICA program. In EEBLAB's AMICA GUI, this is called
+            "Symmetric sphering".
+        - ``"pca"``: Data is whitened using only eigenvector projection and scaling to
+            do sphering (not symmetric or approximately symmetric). This is equivalent
+            to ``do_sphere=1`` + ``do_approx_sphere=0`` in the Fortran AMICA program.
+            In EEBLAB's AMICA GUI, this is called "Principle Components (Eigenvectors)".
+        - ``"variance"``: Diagonal Normalization. Each feature is scaled by the variance
+            across features. This is equivalent to ``do_sphere=0`` in the Fortran AMICA
+            program. In EEBLAB's AMICA GUI, this is called "No sphering transformation".
+
+    max_iter : int, default=500
+        Maximum number of iterations during fit.
+    tol : float, default=1e-7
+        Tolerance for stopping criteria. A positive scalar giving the tolerance at which
+        the un-mixing matrix is considered to have converged. The default is ``1e-7``.
+        Fortran AMICA program contained tunable tolerance parameters for two
+        different stopping criteria ``min_dll`` and ``min_grad_norm``. We only expose
+        one parameter, which is applied to both criteria.
+    lrate : float, default=0.05
+        Initial learning rate for the natural gradient. The Fortran AMICA program
+        exposed 2 tunable learning rate parameters, ``lrate`` and ``rholrate`` (initial
+        lrate for shape parameters) but we expose only one for simplicity, which is
+        applied to both.
+    pdftype : int, default=0
+        Type of source density model to use. Currently only ``0`` is supported,
+        which corresponds to the Gaussian Mixture Model (GMM) density.
+    do_newton : bool, default=True
+        If ``True``, the optimization method will switch from Stochastic Gradient
+        Descent (SGD) to newton updates after ``newt_start`` iterations. If ``False``,
+        only SGD updates are used.
+    newt_start : int, default=50
+        Number of iterations before switching to Newton updates if ``do_newton`` is
+        ``True``.
+    newtrate : float, default=1.0
+        lrate for newton iterations.
+    w_init : ndarray of shape (``n_components``, ``n_components``), default=``None``
+        Initial un-mixing array. If ``None``, then an array of values drawn from a
+        normal distribution is used.
+    sbeta_init : ndarray of shape (``n_components``, ``n_mixtures``), default=None
+        Initial scale parameters for the mixture components. If ``None``, then an array
+        of values drawn from a uniform distribution is used.
+    mu_init : ndarray of shape (``n_components``, ``n_mixtures``), default=None
+        Initial location parameters for the mixture components. If ``None``, then an
+        array of values drawn from a normal distribution is used.
+    random_state : int or None, default=None
+        Used to initialize ``w_init`` when not specified, with a
+        normal distribution. Pass an int for reproducible results
+        across multiple function calls. Note that unlike scikit-learn's FastICA, you
+        **cannot** pass a :class:`~numpy.random.BitGenerator` instance via
+        :func:`~numpy.random.default_rng`.
+    verbose : int, default=1
+        Output mode during optimization:
+
+        - ``0``: silent
+        - ``1``: progress bar
+        - ``2``: per-iteration FORTRAN-style
+
+    Attributes
+    ----------
+    components_ : ndarray of shape (``n_components``, ``n_features``)
+        The linear operator to apply to the data to get the independent
+        sources. This is equal to ``np.matmul(unmixing_matrix, self.whitening_)`` when
+        ``whiten`` is ``"zca"`` or ``"pca"``.
+    mixing_ : ndarray of shape (``n_features``, ``n_components``)
+        The pseudo-inverse of ``components_``. It is the linear operator
+        that maps independent sources to the data (in feature space).
+    mean_ : ndarray of shape(``n_features``,)
+        The mean over features. Only set if `self.whiten` is ``True``.
+    whitening_ : ndarray of shape (``n_components``, ``n_features``)
+        Only set if whiten is ``True``. This is the pre-whitening matrix
+        that projects data onto the first ``n_components`` principal components.
+    n_features_in_ : int
+        Number of features seen during :meth:`~AMICA.fit`.
+    n_iter_ : int
+        Number of iterations taken to converge during fit.
+    ll_ : ndarray of shape (``n_iter_``,)
+        The per-iteration Log-likelihood values of model fit.
+    mu_ : ndarray of shape (``n_components``, ``n_mixtures``)
+        Learned location parameters for each source-mixture component.
+    sbeta_ : ndarray of shape (``n_components``, ``n_mixtures``)
+        Learned scale parameters for each source-mixture component.
+    rho_ : ndarray of shape (``n_components``, ``n_mixtures``)
+        Learned shape parameters for each source-mixture component.
+    alpha_ : ndarray of shape (``n_components``, ``n_mixtures``)
+        Learned per-source mixture weights.
+    c_ : ndarray of shape (``n_components``,)
+        Learned source bias/offset terms.
+    locations_ : ndarray of shape (``n_components``, ``n_mixtures``)
+        Alias for ``mu_``.
+    scales_ : ndarray of shape (``n_components``, ``n_mixtures``)
+        Alias for ``sbeta_``.
+    shapes_ : ndarray of shape (``n_components``, ``n_mixtures``)
+        Alias for ``rho_``.
+    mixture_weights_ : ndarray of shape (``n_components``, ``n_mixtures``)
+        Alias for ``alpha_``.
+
+    References
+    ----------
+    .. footbibliography::
+
+
+    Examples
+    --------
+    >>> from sklearn.datasets import load_digits
+    >>> from amica import AMICA
+    >>> X, _ = load_digits(return_X_y=True)
+    >>> transformer = AMICA(n_components=7, random_state=0)
+    >>> X_transformed = transformer.fit_transform(X)
+    >>> X_transformed.shape
+    (1797, 7)
+    """
+
+    def __init__(
+            self,
+            n_components=None,
+            *,
+            n_mixtures=3,
+            batch_size=None,
+            device='cpu',
+            n_models=1,
+            mean_center=True,
+            whiten="zca",
+            max_iter=500,
+            tol=1e-7,
+            lrate=0.05,
+            pdftype=0,
+            do_newton=True,
+            newt_start=50,
+            newtrate=1.0,
+            w_init=None,
+            sbeta_init=None,
+            mu_init=None,
+            random_state=None,
+            verbose=1,
+            ):
+        super().__init__()
+        self.n_components = n_components
+        self.n_mixtures = n_mixtures
+        self.n_models = n_models
+        self.mean_center = mean_center
+        self.whiten = whiten
+        self._whiten = whiten  # for compatibility
+        self.max_iter = max_iter
+        self.tol = tol
+        self.lrate = lrate
+        self.pdftype = pdftype
+        self.do_newton = do_newton
+        self.newt_start = newt_start
+        self.newtrate = newtrate
+        self.w_init = w_init
+        self.sbeta_init = sbeta_init
+        self.mu_init = mu_init
+        self.random_state = random_state
+        self.verbose = verbose
+        self.batch_size = batch_size
+        self.device = device
+
+    def fit(self, X, y=None, verbose=None):
+        """Fit the AMICA model to the data X.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, ``n_features``)
+            Training data, where ``n_samples`` is the number of samples
+            and ``n_features`` is the number of features.
+        y : Ignored
+            Not used, present here for API consistency by convention.
+        verbose : int or None, default=None
+            Per-call override for estimator verbosity.
+            If ``None``, uses the estimator's ``self.verbose`` setting.
+
+        Returns
+        -------
+        self : object
+            Fitted estimator.
+        """
+        # Validate input data
+        X = validate_data(
+            self, X=X,
+            reset=True,
+            **CHECK_ARRAY_KWARGS
+            )
+        # Fit the model
+        fit_dict = fit_amica(
+            X,
+            n_components=self.n_components,
+            n_mixtures=self.n_mixtures,
+            batch_size=self.batch_size,
+            device=self.device,
+            mean_center=self.mean_center,
+            whiten=self.whiten,
+            max_iter=self.max_iter,
+            tol=self.tol,
+            lrate=self.lrate,
+            pdftype=self.pdftype,
+            do_newton=self.do_newton,
+            newt_start=self.newt_start,
+            newtrate=self.newtrate,
+            w_init=self.w_init,
+            sbeta_init=self.sbeta_init,
+            mu_init=self.mu_init,
+            random_state=self.random_state,
+            verbose=self.verbose if verbose is None else verbose,
+        )
+
+        # Set attributes
+        if self.mean_center:
+            self.mean_ = fit_dict['mean']
+        self.n_features_in_ = X.shape[1]
+        ll_full = np.asarray(fit_dict["LL"])
+        self.n_iter_ = int(np.count_nonzero(ll_full))
+        self.ll_ = ll_full[:self.n_iter_].copy()
+        self.whitening_ = fit_dict["S"][:self.n_components, :]
+        self._unmixing = fit_dict['W']
+        self.components_ = self._unmixing @ self.whitening_
+        self.mixing_ = np.linalg.pinv(self.whitening_) @ fit_dict["A"]
+        self.mu_ = np.asarray(fit_dict["mu"])
+        self.sbeta_ = np.asarray(fit_dict["sbeta"])
+        self.rho_ = np.asarray(fit_dict["rho"])
+        self.alpha_ = np.asarray(fit_dict["alpha"])
+        self.c_ = np.asarray(fit_dict["c"])
+        self.locations_ = self.mu_
+        self.scales_ = self.sbeta_
+        self.shapes_ = self.rho_
+        self.mixture_weights_ = self.alpha_
+        return self
+
+    def transform(self, X, copy=True):
+        """Recover the sources from X (apply the unmixing matrix).
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, ``n_features``)
+            Data to transform, where ``n_samples`` is the number of samples
+            and ``n_features`` is the number of features.
+        copy : bool, default=True
+            If False, data passed to fit can be overwritten. Defaults to True.
+
+        Returns
+        -------
+        X_new : ndarray of shape (n_samples, ``n_components``)
+            Estimated sources obtained by transforming the data with the estimated
+            unmixing matrix.
+        """
+        check_is_fitted(self)
+        X = validate_data(
+            self, X=X, reset=False, copy=copy, dtype=[np.float64, np.float32]
+            )
+
+        Xc = X - self.mean_ if hasattr(self, "mean_") and self.mean_ is not None else X
+        return Xc @ self.components_.T
+
+    def fit_transform(self, X, y=None):
+        """Fit the model to the data and transform it.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, ``n_features``)
+            Training data, where n_samples is the number of samples
+            and ``n_features`` is the number of features.
+        y : Ignored
+            Not used, present here for API consistency by convention.
+
+        Returns
+        -------
+        X_new : ndarray of shape (n_samples, ``n_components``)
+            Estimated sources obtained by transforming the data with the estimated
+            unmixing matrix.
+        """
+        # Here you would implement the AMICA fitting logic
+        X = validate_data(self, X=X, y=None, reset=False)
+        n_components = self.n_components
+        if self.whiten == "variance" and n_components is not None:
+            n_components = None
+            warnings.warn("Ignoring n_components with whiten='variance'.")
+        # For now, we just call the parent class's method
+        self.fit(X)
+        return self.transform(X)
+
+    def inverse_transform(self, X):
+        """Reconstruct data from its independent components.
+
+        Parameters
+        ----------
+        X : array-like of shape (``n_samples``, ``n_components``)
+            Independent components to invert.
+
+        Returns
+        -------
+        X_reconstructed : ndarray of shape (n_samples, ``n_features``)
+            Reconstructed data.
+
+        Examples
+        --------
+        >>> from sklearn.datasets import load_digits
+        >>> from amica import AMICA
+        >>> X, _ = load_digits(return_X_y=True)
+        >>> transformer = AMICA(n_components=7, random_state=0)
+        >>> X_transformed = transformer.fit_transform(X)
+        >>> X_reconstructed = transformer.inverse_transform(X_transformed)
+        >>> X_reconstructed.shape
+        (1797, 64)
+        """
+        check_is_fitted(self)
+        X = validate_data(
+            self, X=X, reset=False, dtype=[np.float64, np.float32]
+            )
+        X_rec = X @ self.mixing_.T
+        if hasattr(self, "mean_") and self.mean_ is not None:
+            X_rec += self.mean_
+        return X_rec
+
+    def to_mne(self, info):
+        """Convert a fitted AMICA instance to an MNE-Python ICA instance.
+
+        Parameters
+        ----------
+        info : instance of mne.Info
+            Channel metadata to attach to the ICA object.
+
+        Returns
+        -------
+        ica : instance of mne.preprocessing.ICA
+            ICA object compatible with MNE-Python tooling.
+        """
+        from .utils.mne import to_mne
+
+        return to_mne(self, info)