Add files using upload-large-folder tool

ckpts/universal/global_step40/zero/14.mlp.dense_4h_to_h.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aa0433a7a7c158702a1b2b176fec02c78490e6c9b78b7d112ad9b6f86cdf7a36
+size 33555612

ckpts/universal/global_step40/zero/14.mlp.dense_4h_to_h.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8c02430b06b5f09af241a4e5cee182e9e1d5715c08acdd027be18ffa44f13abc
+size 33555627

venv/lib/python3.10/site-packages/sklearn/decomposition/__init__.py

@@ -0,0 +1,52 @@
+"""
+The :mod:`sklearn.decomposition` module includes matrix decomposition
+algorithms, including among others PCA, NMF or ICA. Most of the algorithms of
+this module can be regarded as dimensionality reduction techniques.
+"""
+
+
+from ..utils.extmath import randomized_svd
+from ._dict_learning import (
+    DictionaryLearning,
+    MiniBatchDictionaryLearning,
+    SparseCoder,
+    dict_learning,
+    dict_learning_online,
+    sparse_encode,
+)
+from ._factor_analysis import FactorAnalysis
+from ._fastica import FastICA, fastica
+from ._incremental_pca import IncrementalPCA
+from ._kernel_pca import KernelPCA
+from ._lda import LatentDirichletAllocation
+from ._nmf import (
+    NMF,
+    MiniBatchNMF,
+    non_negative_factorization,
+)
+from ._pca import PCA
+from ._sparse_pca import MiniBatchSparsePCA, SparsePCA
+from ._truncated_svd import TruncatedSVD
+
+__all__ = [
+    "DictionaryLearning",
+    "FastICA",
+    "IncrementalPCA",
+    "KernelPCA",
+    "MiniBatchDictionaryLearning",
+    "MiniBatchNMF",
+    "MiniBatchSparsePCA",
+    "NMF",
+    "PCA",
+    "SparseCoder",
+    "SparsePCA",
+    "dict_learning",
+    "dict_learning_online",
+    "fastica",
+    "non_negative_factorization",
+    "randomized_svd",
+    "sparse_encode",
+    "FactorAnalysis",
+    "TruncatedSVD",
+    "LatentDirichletAllocation",
+]

venv/lib/python3.10/site-packages/sklearn/decomposition/_base.py

@@ -0,0 +1,193 @@
+"""Principal Component Analysis Base Classes"""
+
+# Author: Alexandre Gramfort <[email protected]>
+#         Olivier Grisel <[email protected]>
+#         Mathieu Blondel <[email protected]>
+#         Denis A. Engemann <[email protected]>
+#         Kyle Kastner <[email protected]>
+#
+# License: BSD 3 clause
+
+from abc import ABCMeta, abstractmethod
+
+import numpy as np
+from scipy import linalg
+from scipy.sparse import issparse
+
+from ..base import BaseEstimator, ClassNamePrefixFeaturesOutMixin, TransformerMixin
+from ..utils._array_api import _add_to_diagonal, device, get_namespace
+from ..utils.sparsefuncs import _implicit_column_offset
+from ..utils.validation import check_is_fitted
+
+
+class _BasePCA(
+    ClassNamePrefixFeaturesOutMixin, TransformerMixin, BaseEstimator, metaclass=ABCMeta
+):
+    """Base class for PCA methods.
+
+    Warning: This class should not be used directly.
+    Use derived classes instead.
+    """
+
+    def get_covariance(self):
+        """Compute data covariance with the generative model.
+
+        ``cov = components_.T * S**2 * components_ + sigma2 * eye(n_features)``
+        where S**2 contains the explained variances, and sigma2 contains the
+        noise variances.
+
+        Returns
+        -------
+        cov : array of shape=(n_features, n_features)
+            Estimated covariance of data.
+        """
+        xp, _ = get_namespace(self.components_)
+
+        components_ = self.components_
+        exp_var = self.explained_variance_
+        if self.whiten:
+            components_ = components_ * xp.sqrt(exp_var[:, np.newaxis])
+        exp_var_diff = exp_var - self.noise_variance_
+        exp_var_diff = xp.where(
+            exp_var > self.noise_variance_,
+            exp_var_diff,
+            xp.asarray(0.0, device=device(exp_var)),
+        )
+        cov = (components_.T * exp_var_diff) @ components_
+        _add_to_diagonal(cov, self.noise_variance_, xp)
+        return cov
+
+    def get_precision(self):
+        """Compute data precision matrix with the generative model.
+
+        Equals the inverse of the covariance but computed with
+        the matrix inversion lemma for efficiency.
+
+        Returns
+        -------
+        precision : array, shape=(n_features, n_features)
+            Estimated precision of data.
+        """
+        xp, is_array_api_compliant = get_namespace(self.components_)
+
+        n_features = self.components_.shape[1]
+
+        # handle corner cases first
+        if self.n_components_ == 0:
+            return xp.eye(n_features) / self.noise_variance_
+
+        if is_array_api_compliant:
+            linalg_inv = xp.linalg.inv
+        else:
+            linalg_inv = linalg.inv
+
+        if self.noise_variance_ == 0.0:
+            return linalg_inv(self.get_covariance())
+
+        # Get precision using matrix inversion lemma
+        components_ = self.components_
+        exp_var = self.explained_variance_
+        if self.whiten:
+            components_ = components_ * xp.sqrt(exp_var[:, np.newaxis])
+        exp_var_diff = exp_var - self.noise_variance_
+        exp_var_diff = xp.where(
+            exp_var > self.noise_variance_,
+            exp_var_diff,
+            xp.asarray(0.0, device=device(exp_var)),
+        )
+        precision = components_ @ components_.T / self.noise_variance_
+        _add_to_diagonal(precision, 1.0 / exp_var_diff, xp)
+        precision = components_.T @ linalg_inv(precision) @ components_
+        precision /= -(self.noise_variance_**2)
+        _add_to_diagonal(precision, 1.0 / self.noise_variance_, xp)
+        return precision
+
+    @abstractmethod
+    def fit(self, X, y=None):
+        """Placeholder for fit. Subclasses should implement this method!
+
+        Fit the model with 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.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+
+    def transform(self, X):
+        """Apply dimensionality reduction to X.
+
+        X is projected on the first principal components previously extracted
+        from a training set.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            New data, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+
+        Returns
+        -------
+        X_new : array-like of shape (n_samples, n_components)
+            Projection of X in the first principal components, where `n_samples`
+            is the number of samples and `n_components` is the number of the components.
+        """
+        xp, _ = get_namespace(X)
+
+        check_is_fitted(self)
+
+        X = self._validate_data(
+            X, accept_sparse=("csr", "csc"), dtype=[xp.float64, xp.float32], reset=False
+        )
+        if self.mean_ is not None:
+            if issparse(X):
+                X = _implicit_column_offset(X, self.mean_)
+            else:
+                X = X - self.mean_
+        X_transformed = X @ self.components_.T
+        if self.whiten:
+            X_transformed /= xp.sqrt(self.explained_variance_)
+        return X_transformed
+
+    def inverse_transform(self, X):
+        """Transform data back to its original space.
+
+        In other words, return an input `X_original` whose transform would be X.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_components)
+            New data, where `n_samples` is the number of samples
+            and `n_components` is the number of components.
+
+        Returns
+        -------
+        X_original array-like of shape (n_samples, n_features)
+            Original data, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+
+        Notes
+        -----
+        If whitening is enabled, inverse_transform will compute the
+        exact inverse operation, which includes reversing whitening.
+        """
+        xp, _ = get_namespace(X)
+
+        if self.whiten:
+            scaled_components = (
+                xp.sqrt(self.explained_variance_[:, np.newaxis]) * self.components_
+            )
+            return X @ scaled_components + self.mean_
+        else:
+            return X @ self.components_ + self.mean_
+
+    @property
+    def _n_features_out(self):
+        """Number of transformed output features."""
+        return self.components_.shape[0]

venv/lib/python3.10/site-packages/sklearn/decomposition/_dict_learning.py

@@ -0,0 +1,2301 @@
+""" Dictionary learning.
+"""
+# Author: Vlad Niculae, Gael Varoquaux, Alexandre Gramfort
+# License: BSD 3 clause
+
+import itertools
+import sys
+import time
+from numbers import Integral, Real
+from warnings import warn
+
+import numpy as np
+from joblib import effective_n_jobs
+from scipy import linalg
+
+from ..base import (
+    BaseEstimator,
+    ClassNamePrefixFeaturesOutMixin,
+    TransformerMixin,
+    _fit_context,
+)
+from ..linear_model import Lars, Lasso, LassoLars, orthogonal_mp_gram
+from ..utils import check_array, check_random_state, gen_batches, gen_even_slices
+from ..utils._param_validation import Hidden, Interval, StrOptions, validate_params
+from ..utils.extmath import randomized_svd, row_norms, svd_flip
+from ..utils.parallel import Parallel, delayed
+from ..utils.validation import check_is_fitted
+
+
+def _check_positive_coding(method, positive):
+    if positive and method in ["omp", "lars"]:
+        raise ValueError(
+            "Positive constraint not supported for '{}' coding method.".format(method)
+        )
+
+
+def _sparse_encode_precomputed(
+    X,
+    dictionary,
+    *,
+    gram=None,
+    cov=None,
+    algorithm="lasso_lars",
+    regularization=None,
+    copy_cov=True,
+    init=None,
+    max_iter=1000,
+    verbose=0,
+    positive=False,
+):
+    """Generic sparse coding with precomputed Gram and/or covariance matrices.
+
+    Each row of the result is the solution to a Lasso problem.
+
+    Parameters
+    ----------
+    X : ndarray of shape (n_samples, n_features)
+        Data matrix.
+
+    dictionary : ndarray of shape (n_components, n_features)
+        The dictionary matrix against which to solve the sparse coding of
+        the data. Some of the algorithms assume normalized rows.
+
+    gram : ndarray of shape (n_components, n_components), default=None
+        Precomputed Gram matrix, `dictionary * dictionary'`
+        gram can be `None` if method is 'threshold'.
+
+    cov : ndarray of shape (n_components, n_samples), default=None
+        Precomputed covariance, `dictionary * X'`.
+
+    algorithm : {'lasso_lars', 'lasso_cd', 'lars', 'omp', 'threshold'}, \
+            default='lasso_lars'
+        The algorithm used:
+
+        * `'lars'`: uses the least angle regression method
+          (`linear_model.lars_path`);
+        * `'lasso_lars'`: uses Lars to compute the Lasso solution;
+        * `'lasso_cd'`: uses the coordinate descent method to compute the
+          Lasso solution (`linear_model.Lasso`). lasso_lars will be faster if
+          the estimated components are sparse;
+        * `'omp'`: uses orthogonal matching pursuit to estimate the sparse
+          solution;
+        * `'threshold'`: squashes to zero all coefficients less than
+          regularization from the projection `dictionary * data'`.
+
+    regularization : int or float, default=None
+        The regularization parameter. It corresponds to alpha when
+        algorithm is `'lasso_lars'`, `'lasso_cd'` or `'threshold'`.
+        Otherwise it corresponds to `n_nonzero_coefs`.
+
+    init : ndarray of shape (n_samples, n_components), default=None
+        Initialization value of the sparse code. Only used if
+        `algorithm='lasso_cd'`.
+
+    max_iter : int, default=1000
+        Maximum number of iterations to perform if `algorithm='lasso_cd'` or
+        `'lasso_lars'`.
+
+    copy_cov : bool, default=True
+        Whether to copy the precomputed covariance matrix; if `False`, it may
+        be overwritten.
+
+    verbose : int, default=0
+        Controls the verbosity; the higher, the more messages.
+
+    positive: bool, default=False
+        Whether to enforce a positivity constraint on the sparse code.
+
+        .. versionadded:: 0.20
+
+    Returns
+    -------
+    code : ndarray of shape (n_components, n_features)
+        The sparse codes.
+    """
+    n_samples, n_features = X.shape
+    n_components = dictionary.shape[0]
+
+    if algorithm == "lasso_lars":
+        alpha = float(regularization) / n_features  # account for scaling
+        try:
+            err_mgt = np.seterr(all="ignore")
+
+            # Not passing in verbose=max(0, verbose-1) because Lars.fit already
+            # corrects the verbosity level.
+            lasso_lars = LassoLars(
+                alpha=alpha,
+                fit_intercept=False,
+                verbose=verbose,
+                precompute=gram,
+                fit_path=False,
+                positive=positive,
+                max_iter=max_iter,
+            )
+            lasso_lars.fit(dictionary.T, X.T, Xy=cov)
+            new_code = lasso_lars.coef_
+        finally:
+            np.seterr(**err_mgt)
+
+    elif algorithm == "lasso_cd":
+        alpha = float(regularization) / n_features  # account for scaling
+
+        # TODO: Make verbosity argument for Lasso?
+        # sklearn.linear_model.coordinate_descent.enet_path has a verbosity
+        # argument that we could pass in from Lasso.
+        clf = Lasso(
+            alpha=alpha,
+            fit_intercept=False,
+            precompute=gram,
+            max_iter=max_iter,
+            warm_start=True,
+            positive=positive,
+        )
+
+        if init is not None:
+            # In some workflows using coordinate descent algorithms:
+            #  - users might provide NumPy arrays with read-only buffers
+            #  - `joblib` might memmap arrays making their buffer read-only
+            # TODO: move this handling (which is currently too broad)
+            # closer to the actual private function which need buffers to be writable.
+            if not init.flags["WRITEABLE"]:
+                init = np.array(init)
+            clf.coef_ = init
+
+        clf.fit(dictionary.T, X.T, check_input=False)
+        new_code = clf.coef_
+
+    elif algorithm == "lars":
+        try:
+            err_mgt = np.seterr(all="ignore")
+
+            # Not passing in verbose=max(0, verbose-1) because Lars.fit already
+            # corrects the verbosity level.
+            lars = Lars(
+                fit_intercept=False,
+                verbose=verbose,
+                precompute=gram,
+                n_nonzero_coefs=int(regularization),
+                fit_path=False,
+            )
+            lars.fit(dictionary.T, X.T, Xy=cov)
+            new_code = lars.coef_
+        finally:
+            np.seterr(**err_mgt)
+
+    elif algorithm == "threshold":
+        new_code = (np.sign(cov) * np.maximum(np.abs(cov) - regularization, 0)).T
+        if positive:
+            np.clip(new_code, 0, None, out=new_code)
+
+    elif algorithm == "omp":
+        new_code = orthogonal_mp_gram(
+            Gram=gram,
+            Xy=cov,
+            n_nonzero_coefs=int(regularization),
+            tol=None,
+            norms_squared=row_norms(X, squared=True),
+            copy_Xy=copy_cov,
+        ).T
+
+    return new_code.reshape(n_samples, n_components)
+
+
+@validate_params(
+    {
+        "X": ["array-like"],
+        "dictionary": ["array-like"],
+        "gram": ["array-like", None],
+        "cov": ["array-like", None],
+        "algorithm": [
+            StrOptions({"lasso_lars", "lasso_cd", "lars", "omp", "threshold"})
+        ],
+        "n_nonzero_coefs": [Interval(Integral, 1, None, closed="left"), None],
+        "alpha": [Interval(Real, 0, None, closed="left"), None],
+        "copy_cov": ["boolean"],
+        "init": ["array-like", None],
+        "max_iter": [Interval(Integral, 0, None, closed="left")],
+        "n_jobs": [Integral, None],
+        "check_input": ["boolean"],
+        "verbose": ["verbose"],
+        "positive": ["boolean"],
+    },
+    prefer_skip_nested_validation=True,
+)
+# XXX : could be moved to the linear_model module
+def sparse_encode(
+    X,
+    dictionary,
+    *,
+    gram=None,
+    cov=None,
+    algorithm="lasso_lars",
+    n_nonzero_coefs=None,
+    alpha=None,
+    copy_cov=True,
+    init=None,
+    max_iter=1000,
+    n_jobs=None,
+    check_input=True,
+    verbose=0,
+    positive=False,
+):
+    """Sparse coding.
+
+    Each row of the result is the solution to a sparse coding problem.
+    The goal is to find a sparse array `code` such that::
+
+        X ~= code * dictionary
+
+    Read more in the :ref:`User Guide <SparseCoder>`.
+
+    Parameters
+    ----------
+    X : array-like of shape (n_samples, n_features)
+        Data matrix.
+
+    dictionary : array-like of shape (n_components, n_features)
+        The dictionary matrix against which to solve the sparse coding of
+        the data. Some of the algorithms assume normalized rows for meaningful
+        output.
+
+    gram : array-like of shape (n_components, n_components), default=None
+        Precomputed Gram matrix, `dictionary * dictionary'`.
+
+    cov : array-like of shape (n_components, n_samples), default=None
+        Precomputed covariance, `dictionary' * X`.
+
+    algorithm : {'lasso_lars', 'lasso_cd', 'lars', 'omp', 'threshold'}, \
+            default='lasso_lars'
+        The algorithm used:
+
+        * `'lars'`: uses the least angle regression method
+          (`linear_model.lars_path`);
+        * `'lasso_lars'`: uses Lars to compute the Lasso solution;
+        * `'lasso_cd'`: uses the coordinate descent method to compute the
+          Lasso solution (`linear_model.Lasso`). lasso_lars will be faster if
+          the estimated components are sparse;
+        * `'omp'`: uses orthogonal matching pursuit to estimate the sparse
+          solution;
+        * `'threshold'`: squashes to zero all coefficients less than
+          regularization from the projection `dictionary * data'`.
+
+    n_nonzero_coefs : int, default=None
+        Number of nonzero coefficients to target in each column of the
+        solution. This is only used by `algorithm='lars'` and `algorithm='omp'`
+        and is overridden by `alpha` in the `omp` case. If `None`, then
+        `n_nonzero_coefs=int(n_features / 10)`.
+
+    alpha : float, default=None
+        If `algorithm='lasso_lars'` or `algorithm='lasso_cd'`, `alpha` is the
+        penalty applied to the L1 norm.
+        If `algorithm='threshold'`, `alpha` is the absolute value of the
+        threshold below which coefficients will be squashed to zero.
+        If `algorithm='omp'`, `alpha` is the tolerance parameter: the value of
+        the reconstruction error targeted. In this case, it overrides
+        `n_nonzero_coefs`.
+        If `None`, default to 1.
+
+    copy_cov : bool, default=True
+        Whether to copy the precomputed covariance matrix; if `False`, it may
+        be overwritten.
+
+    init : ndarray of shape (n_samples, n_components), default=None
+        Initialization value of the sparse codes. Only used if
+        `algorithm='lasso_cd'`.
+
+    max_iter : int, default=1000
+        Maximum number of iterations to perform if `algorithm='lasso_cd'` or
+        `'lasso_lars'`.
+
+    n_jobs : int, default=None
+        Number of parallel jobs to run.
+        ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.
+        ``-1`` means using all processors. See :term:`Glossary <n_jobs>`
+        for more details.
+
+    check_input : bool, default=True
+        If `False`, the input arrays X and dictionary will not be checked.
+
+    verbose : int, default=0
+        Controls the verbosity; the higher, the more messages.
+
+    positive : bool, default=False
+        Whether to enforce positivity when finding the encoding.
+
+        .. versionadded:: 0.20
+
+    Returns
+    -------
+    code : ndarray of shape (n_samples, n_components)
+        The sparse codes.
+
+    See Also
+    --------
+    sklearn.linear_model.lars_path : Compute Least Angle Regression or Lasso
+        path using LARS algorithm.
+    sklearn.linear_model.orthogonal_mp : Solves Orthogonal Matching Pursuit problems.
+    sklearn.linear_model.Lasso : Train Linear Model with L1 prior as regularizer.
+    SparseCoder : Find a sparse representation of data from a fixed precomputed
+        dictionary.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.decomposition import sparse_encode
+    >>> X = np.array([[-1, -1, -1], [0, 0, 3]])
+    >>> dictionary = np.array(
+    ...     [[0, 1, 0],
+    ...      [-1, -1, 2],
+    ...      [1, 1, 1],
+    ...      [0, 1, 1],
+    ...      [0, 2, 1]],
+    ...    dtype=np.float64
+    ... )
+    >>> sparse_encode(X, dictionary, alpha=1e-10)
+    array([[ 0.,  0., -1.,  0.,  0.],
+           [ 0.,  1.,  1.,  0.,  0.]])
+    """
+    if check_input:
+        if algorithm == "lasso_cd":
+            dictionary = check_array(
+                dictionary, order="C", dtype=[np.float64, np.float32]
+            )
+            X = check_array(X, order="C", dtype=[np.float64, np.float32])
+        else:
+            dictionary = check_array(dictionary)
+            X = check_array(X)
+
+    if dictionary.shape[1] != X.shape[1]:
+        raise ValueError(
+            "Dictionary and X have different numbers of features:"
+            "dictionary.shape: {} X.shape{}".format(dictionary.shape, X.shape)
+        )
+
+    _check_positive_coding(algorithm, positive)
+
+    return _sparse_encode(
+        X,
+        dictionary,
+        gram=gram,
+        cov=cov,
+        algorithm=algorithm,
+        n_nonzero_coefs=n_nonzero_coefs,
+        alpha=alpha,
+        copy_cov=copy_cov,
+        init=init,
+        max_iter=max_iter,
+        n_jobs=n_jobs,
+        verbose=verbose,
+        positive=positive,
+    )
+
+
+def _sparse_encode(
+    X,
+    dictionary,
+    *,
+    gram=None,
+    cov=None,
+    algorithm="lasso_lars",
+    n_nonzero_coefs=None,
+    alpha=None,
+    copy_cov=True,
+    init=None,
+    max_iter=1000,
+    n_jobs=None,
+    verbose=0,
+    positive=False,
+):
+    """Sparse coding without input/parameter validation."""
+
+    n_samples, n_features = X.shape
+    n_components = dictionary.shape[0]
+
+    if algorithm in ("lars", "omp"):
+        regularization = n_nonzero_coefs
+        if regularization is None:
+            regularization = min(max(n_features / 10, 1), n_components)
+    else:
+        regularization = alpha
+        if regularization is None:
+            regularization = 1.0
+
+    if gram is None and algorithm != "threshold":
+        gram = np.dot(dictionary, dictionary.T)
+
+    if cov is None and algorithm != "lasso_cd":
+        copy_cov = False
+        cov = np.dot(dictionary, X.T)
+
+    if effective_n_jobs(n_jobs) == 1 or algorithm == "threshold":
+        code = _sparse_encode_precomputed(
+            X,
+            dictionary,
+            gram=gram,
+            cov=cov,
+            algorithm=algorithm,
+            regularization=regularization,
+            copy_cov=copy_cov,
+            init=init,
+            max_iter=max_iter,
+            verbose=verbose,
+            positive=positive,
+        )
+        return code
+
+    # Enter parallel code block
+    n_samples = X.shape[0]
+    n_components = dictionary.shape[0]
+    code = np.empty((n_samples, n_components))
+    slices = list(gen_even_slices(n_samples, effective_n_jobs(n_jobs)))
+
+    code_views = Parallel(n_jobs=n_jobs, verbose=verbose)(
+        delayed(_sparse_encode_precomputed)(
+            X[this_slice],
+            dictionary,
+            gram=gram,
+            cov=cov[:, this_slice] if cov is not None else None,
+            algorithm=algorithm,
+            regularization=regularization,
+            copy_cov=copy_cov,
+            init=init[this_slice] if init is not None else None,
+            max_iter=max_iter,
+            verbose=verbose,
+            positive=positive,
+        )
+        for this_slice in slices
+    )
+    for this_slice, this_view in zip(slices, code_views):
+        code[this_slice] = this_view
+    return code
+
+
+def _update_dict(
+    dictionary,
+    Y,
+    code,
+    A=None,
+    B=None,
+    verbose=False,
+    random_state=None,
+    positive=False,
+):
+    """Update the dense dictionary factor in place.
+
+    Parameters
+    ----------
+    dictionary : ndarray of shape (n_components, n_features)
+        Value of the dictionary at the previous iteration.
+
+    Y : ndarray of shape (n_samples, n_features)
+        Data matrix.
+
+    code : ndarray of shape (n_samples, n_components)
+        Sparse coding of the data against which to optimize the dictionary.
+
+    A : ndarray of shape (n_components, n_components), default=None
+        Together with `B`, sufficient stats of the online model to update the
+        dictionary.
+
+    B : ndarray of shape (n_features, n_components), default=None
+        Together with `A`, sufficient stats of the online model to update the
+        dictionary.
+
+    verbose: bool, default=False
+        Degree of output the procedure will print.
+
+    random_state : int, RandomState instance or None, default=None
+        Used for randomly initializing the dictionary. Pass an int for
+        reproducible results across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    positive : bool, default=False
+        Whether to enforce positivity when finding the dictionary.
+
+        .. versionadded:: 0.20
+    """
+    n_samples, n_components = code.shape
+    random_state = check_random_state(random_state)
+
+    if A is None:
+        A = code.T @ code
+    if B is None:
+        B = Y.T @ code
+
+    n_unused = 0
+
+    for k in range(n_components):
+        if A[k, k] > 1e-6:
+            # 1e-6 is arbitrary but consistent with the spams implementation
+            dictionary[k] += (B[:, k] - A[k] @ dictionary) / A[k, k]
+        else:
+            # kth atom is almost never used -> sample a new one from the data
+            newd = Y[random_state.choice(n_samples)]
+
+            # add small noise to avoid making the sparse coding ill conditioned
+            noise_level = 0.01 * (newd.std() or 1)  # avoid 0 std
+            noise = random_state.normal(0, noise_level, size=len(newd))
+
+            dictionary[k] = newd + noise
+            code[:, k] = 0
+            n_unused += 1
+
+        if positive:
+            np.clip(dictionary[k], 0, None, out=dictionary[k])
+
+        # Projection on the constraint set ||V_k|| <= 1
+        dictionary[k] /= max(linalg.norm(dictionary[k]), 1)
+
+    if verbose and n_unused > 0:
+        print(f"{n_unused} unused atoms resampled.")
+
+
+def _dict_learning(
+    X,
+    n_components,
+    *,
+    alpha,
+    max_iter,
+    tol,
+    method,
+    n_jobs,
+    dict_init,
+    code_init,
+    callback,
+    verbose,
+    random_state,
+    return_n_iter,
+    positive_dict,
+    positive_code,
+    method_max_iter,
+):
+    """Main dictionary learning algorithm"""
+    t0 = time.time()
+    # Init the code and the dictionary with SVD of Y
+    if code_init is not None and dict_init is not None:
+        code = np.array(code_init, order="F")
+        # Don't copy V, it will happen below
+        dictionary = dict_init
+    else:
+        code, S, dictionary = linalg.svd(X, full_matrices=False)
+        # flip the initial code's sign to enforce deterministic output
+        code, dictionary = svd_flip(code, dictionary)
+        dictionary = S[:, np.newaxis] * dictionary
+    r = len(dictionary)
+    if n_components <= r:  # True even if n_components=None
+        code = code[:, :n_components]
+        dictionary = dictionary[:n_components, :]
+    else:
+        code = np.c_[code, np.zeros((len(code), n_components - r))]
+        dictionary = np.r_[
+            dictionary, np.zeros((n_components - r, dictionary.shape[1]))
+        ]
+
+    # Fortran-order dict better suited for the sparse coding which is the
+    # bottleneck of this algorithm.
+    dictionary = np.asfortranarray(dictionary)
+
+    errors = []
+    current_cost = np.nan
+
+    if verbose == 1:
+        print("[dict_learning]", end=" ")
+
+    # If max_iter is 0, number of iterations returned should be zero
+    ii = -1
+
+    for ii in range(max_iter):
+        dt = time.time() - t0
+        if verbose == 1:
+            sys.stdout.write(".")
+            sys.stdout.flush()
+        elif verbose:
+            print(
+                "Iteration % 3i (elapsed time: % 3is, % 4.1fmn, current cost % 7.3f)"
+                % (ii, dt, dt / 60, current_cost)
+            )
+
+        # Update code
+        code = sparse_encode(
+            X,
+            dictionary,
+            algorithm=method,
+            alpha=alpha,
+            init=code,
+            n_jobs=n_jobs,
+            positive=positive_code,
+            max_iter=method_max_iter,
+            verbose=verbose,
+        )
+
+        # Update dictionary in place
+        _update_dict(
+            dictionary,
+            X,
+            code,
+            verbose=verbose,
+            random_state=random_state,
+            positive=positive_dict,
+        )
+
+        # Cost function
+        current_cost = 0.5 * np.sum((X - code @ dictionary) ** 2) + alpha * np.sum(
+            np.abs(code)
+        )
+        errors.append(current_cost)
+
+        if ii > 0:
+            dE = errors[-2] - errors[-1]
+            # assert(dE >= -tol * errors[-1])
+            if dE < tol * errors[-1]:
+                if verbose == 1:
+                    # A line return
+                    print("")
+                elif verbose:
+                    print("--- Convergence reached after %d iterations" % ii)
+                break
+        if ii % 5 == 0 and callback is not None:
+            callback(locals())
+
+    if return_n_iter:
+        return code, dictionary, errors, ii + 1
+    else:
+        return code, dictionary, errors
+
+
+def dict_learning_online(
+    X,
+    n_components=2,
+    *,
+    alpha=1,
+    max_iter=100,
+    return_code=True,
+    dict_init=None,
+    callback=None,
+    batch_size=256,
+    verbose=False,
+    shuffle=True,
+    n_jobs=None,
+    method="lars",
+    random_state=None,
+    positive_dict=False,
+    positive_code=False,
+    method_max_iter=1000,
+    tol=1e-3,
+    max_no_improvement=10,
+):
+    """Solve a dictionary learning matrix factorization problem online.
+
+    Finds the best dictionary and the corresponding sparse code for
+    approximating the data matrix X by solving::
+
+        (U^*, V^*) = argmin 0.5 || X - U V ||_Fro^2 + alpha * || U ||_1,1
+                     (U,V)
+                     with || V_k ||_2 = 1 for all  0 <= k < n_components
+
+    where V is the dictionary and U is the sparse code. ||.||_Fro stands for
+    the Frobenius norm and ||.||_1,1 stands for the entry-wise matrix norm
+    which is the sum of the absolute values of all the entries in the matrix.
+    This is accomplished by repeatedly iterating over mini-batches by slicing
+    the input data.
+
+    Read more in the :ref:`User Guide <DictionaryLearning>`.
+
+    Parameters
+    ----------
+    X : ndarray of shape (n_samples, n_features)
+        Data matrix.
+
+    n_components : int or None, default=2
+        Number of dictionary atoms to extract. If None, then ``n_components``
+        is set to ``n_features``.
+
+    alpha : float, default=1
+        Sparsity controlling parameter.
+
+    max_iter : int, default=100
+        Maximum number of iterations over the complete dataset before
+        stopping independently of any early stopping criterion heuristics.
+
+        .. versionadded:: 1.1
+
+        .. deprecated:: 1.4
+           `max_iter=None` is deprecated in 1.4 and will be removed in 1.6.
+           Use the default value (i.e. `100`) instead.
+
+    return_code : bool, default=True
+        Whether to also return the code U or just the dictionary `V`.
+
+    dict_init : ndarray of shape (n_components, n_features), default=None
+        Initial values for the dictionary for warm restart scenarios.
+        If `None`, the initial values for the dictionary are created
+        with an SVD decomposition of the data via
+        :func:`~sklearn.utils.extmath.randomized_svd`.
+
+    callback : callable, default=None
+        A callable that gets invoked at the end of each iteration.
+
+    batch_size : int, default=256
+        The number of samples to take in each batch.
+
+        .. versionchanged:: 1.3
+           The default value of `batch_size` changed from 3 to 256 in version 1.3.
+
+    verbose : bool, default=False
+        To control the verbosity of the procedure.
+
+    shuffle : bool, default=True
+        Whether to shuffle the data before splitting it in batches.
+
+    n_jobs : int, default=None
+        Number of parallel jobs to run.
+        ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.
+        ``-1`` means using all processors. See :term:`Glossary <n_jobs>`
+        for more details.
+
+    method : {'lars', 'cd'}, default='lars'
+        * `'lars'`: uses the least angle regression method to solve the lasso
+          problem (`linear_model.lars_path`);
+        * `'cd'`: uses the coordinate descent method to compute the
+          Lasso solution (`linear_model.Lasso`). Lars will be faster if
+          the estimated components are sparse.
+
+    random_state : int, RandomState instance or None, default=None
+        Used for initializing the dictionary when ``dict_init`` is not
+        specified, randomly shuffling the data when ``shuffle`` is set to
+        ``True``, and updating the dictionary. Pass an int for reproducible
+        results across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    positive_dict : bool, default=False
+        Whether to enforce positivity when finding the dictionary.
+
+        .. versionadded:: 0.20
+
+    positive_code : bool, default=False
+        Whether to enforce positivity when finding the code.
+
+        .. versionadded:: 0.20
+
+    method_max_iter : int, default=1000
+        Maximum number of iterations to perform when solving the lasso problem.
+
+        .. versionadded:: 0.22
+
+    tol : float, default=1e-3
+        Control early stopping based on the norm of the differences in the
+        dictionary between 2 steps.
+
+        To disable early stopping based on changes in the dictionary, set
+        `tol` to 0.0.
+
+        .. versionadded:: 1.1
+
+    max_no_improvement : int, default=10
+        Control early stopping based on the consecutive number of mini batches
+        that does not yield an improvement on the smoothed cost function.
+
+        To disable convergence detection based on cost function, set
+        `max_no_improvement` to None.
+
+        .. versionadded:: 1.1
+
+    Returns
+    -------
+    code : ndarray of shape (n_samples, n_components),
+        The sparse code (only returned if `return_code=True`).
+
+    dictionary : ndarray of shape (n_components, n_features),
+        The solutions to the dictionary learning problem.
+
+    n_iter : int
+        Number of iterations run. Returned only if `return_n_iter` is
+        set to `True`.
+
+    See Also
+    --------
+    dict_learning : Solve a dictionary learning matrix factorization problem.
+    DictionaryLearning : Find a dictionary that sparsely encodes data.
+    MiniBatchDictionaryLearning : A faster, less accurate, version of the dictionary
+        learning algorithm.
+    SparsePCA : Sparse Principal Components Analysis.
+    MiniBatchSparsePCA : Mini-batch Sparse Principal Components Analysis.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.datasets import make_sparse_coded_signal
+    >>> from sklearn.decomposition import dict_learning_online
+    >>> X, _, _ = make_sparse_coded_signal(
+    ...     n_samples=30, n_components=15, n_features=20, n_nonzero_coefs=10,
+    ...     random_state=42,
+    ... )
+    >>> U, V = dict_learning_online(
+    ...     X, n_components=15, alpha=0.2, max_iter=20, batch_size=3, random_state=42
+    ... )
+
+    We can check the level of sparsity of `U`:
+
+    >>> np.mean(U == 0)
+    0.53...
+
+    We can compare the average squared euclidean norm of the reconstruction
+    error of the sparse coded signal relative to the squared euclidean norm of
+    the original signal:
+
+    >>> X_hat = U @ V
+    >>> np.mean(np.sum((X_hat - X) ** 2, axis=1) / np.sum(X ** 2, axis=1))
+    0.05...
+    """
+    # TODO(1.6): remove in 1.6
+    if max_iter is None:
+        warn(
+            (
+                "`max_iter=None` is deprecated in version 1.4 and will be removed in "
+                "version 1.6. Use the default value (i.e. `100`) instead."
+            ),
+            FutureWarning,
+        )
+        max_iter = 100
+
+    transform_algorithm = "lasso_" + method
+
+    est = MiniBatchDictionaryLearning(
+        n_components=n_components,
+        alpha=alpha,
+        max_iter=max_iter,
+        n_jobs=n_jobs,
+        fit_algorithm=method,
+        batch_size=batch_size,
+        shuffle=shuffle,
+        dict_init=dict_init,
+        random_state=random_state,
+        transform_algorithm=transform_algorithm,
+        transform_alpha=alpha,
+        positive_code=positive_code,
+        positive_dict=positive_dict,
+        transform_max_iter=method_max_iter,
+        verbose=verbose,
+        callback=callback,
+        tol=tol,
+        max_no_improvement=max_no_improvement,
+    ).fit(X)
+
+    if not return_code:
+        return est.components_
+    else:
+        code = est.transform(X)
+        return code, est.components_
+
+
+@validate_params(
+    {
+        "X": ["array-like"],
+        "method": [StrOptions({"lars", "cd"})],
+        "return_n_iter": ["boolean"],
+        "method_max_iter": [Interval(Integral, 0, None, closed="left")],
+    },
+    prefer_skip_nested_validation=False,
+)
+def dict_learning(
+    X,
+    n_components,
+    *,
+    alpha,
+    max_iter=100,
+    tol=1e-8,
+    method="lars",
+    n_jobs=None,
+    dict_init=None,
+    code_init=None,
+    callback=None,
+    verbose=False,
+    random_state=None,
+    return_n_iter=False,
+    positive_dict=False,
+    positive_code=False,
+    method_max_iter=1000,
+):
+    """Solve a dictionary learning matrix factorization problem.
+
+    Finds the best dictionary and the corresponding sparse code for
+    approximating the data matrix X by solving::
+
+        (U^*, V^*) = argmin 0.5 || X - U V ||_Fro^2 + alpha * || U ||_1,1
+                     (U,V)
+                    with || V_k ||_2 = 1 for all  0 <= k < n_components
+
+    where V is the dictionary and U is the sparse code. ||.||_Fro stands for
+    the Frobenius norm and ||.||_1,1 stands for the entry-wise matrix norm
+    which is the sum of the absolute values of all the entries in the matrix.
+
+    Read more in the :ref:`User Guide <DictionaryLearning>`.
+
+    Parameters
+    ----------
+    X : array-like of shape (n_samples, n_features)
+        Data matrix.
+
+    n_components : int
+        Number of dictionary atoms to extract.
+
+    alpha : int or float
+        Sparsity controlling parameter.
+
+    max_iter : int, default=100
+        Maximum number of iterations to perform.
+
+    tol : float, default=1e-8
+        Tolerance for the stopping condition.
+
+    method : {'lars', 'cd'}, default='lars'
+        The method used:
+
+        * `'lars'`: uses the least angle regression method to solve the lasso
+           problem (`linear_model.lars_path`);
+        * `'cd'`: uses the coordinate descent method to compute the
+          Lasso solution (`linear_model.Lasso`). Lars will be faster if
+          the estimated components are sparse.
+
+    n_jobs : int, default=None
+        Number of parallel jobs to run.
+        ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.
+        ``-1`` means using all processors. See :term:`Glossary <n_jobs>`
+        for more details.
+
+    dict_init : ndarray of shape (n_components, n_features), default=None
+        Initial value for the dictionary for warm restart scenarios. Only used
+        if `code_init` and `dict_init` are not None.
+
+    code_init : ndarray of shape (n_samples, n_components), default=None
+        Initial value for the sparse code for warm restart scenarios. Only used
+        if `code_init` and `dict_init` are not None.
+
+    callback : callable, default=None
+        Callable that gets invoked every five iterations.
+
+    verbose : bool, default=False
+        To control the verbosity of the procedure.
+
+    random_state : int, RandomState instance or None, default=None
+        Used for randomly initializing the dictionary. Pass an int for
+        reproducible results across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    return_n_iter : bool, default=False
+        Whether or not to return the number of iterations.
+
+    positive_dict : bool, default=False
+        Whether to enforce positivity when finding the dictionary.
+
+        .. versionadded:: 0.20
+
+    positive_code : bool, default=False
+        Whether to enforce positivity when finding the code.
+
+        .. versionadded:: 0.20
+
+    method_max_iter : int, default=1000
+        Maximum number of iterations to perform.
+
+        .. versionadded:: 0.22
+
+    Returns
+    -------
+    code : ndarray of shape (n_samples, n_components)
+        The sparse code factor in the matrix factorization.
+
+    dictionary : ndarray of shape (n_components, n_features),
+        The dictionary factor in the matrix factorization.
+
+    errors : array
+        Vector of errors at each iteration.
+
+    n_iter : int
+        Number of iterations run. Returned only if `return_n_iter` is
+        set to True.
+
+    See Also
+    --------
+    dict_learning_online : Solve a dictionary learning matrix factorization
+        problem online.
+    DictionaryLearning : Find a dictionary that sparsely encodes data.
+    MiniBatchDictionaryLearning : A faster, less accurate version
+        of the dictionary learning algorithm.
+    SparsePCA : Sparse Principal Components Analysis.
+    MiniBatchSparsePCA : Mini-batch Sparse Principal Components Analysis.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.datasets import make_sparse_coded_signal
+    >>> from sklearn.decomposition import dict_learning
+    >>> X, _, _ = make_sparse_coded_signal(
+    ...     n_samples=30, n_components=15, n_features=20, n_nonzero_coefs=10,
+    ...     random_state=42,
+    ... )
+    >>> U, V, errors = dict_learning(X, n_components=15, alpha=0.1, random_state=42)
+
+    We can check the level of sparsity of `U`:
+
+    >>> np.mean(U == 0)
+    0.6...
+
+    We can compare the average squared euclidean norm of the reconstruction
+    error of the sparse coded signal relative to the squared euclidean norm of
+    the original signal:
+
+    >>> X_hat = U @ V
+    >>> np.mean(np.sum((X_hat - X) ** 2, axis=1) / np.sum(X ** 2, axis=1))
+    0.01...
+    """
+    estimator = DictionaryLearning(
+        n_components=n_components,
+        alpha=alpha,
+        max_iter=max_iter,
+        tol=tol,
+        fit_algorithm=method,
+        n_jobs=n_jobs,
+        dict_init=dict_init,
+        callback=callback,
+        code_init=code_init,
+        verbose=verbose,
+        random_state=random_state,
+        positive_code=positive_code,
+        positive_dict=positive_dict,
+        transform_max_iter=method_max_iter,
+    ).set_output(transform="default")
+    code = estimator.fit_transform(X)
+    if return_n_iter:
+        return (
+            code,
+            estimator.components_,
+            estimator.error_,
+            estimator.n_iter_,
+        )
+    return code, estimator.components_, estimator.error_
+
+
+class _BaseSparseCoding(ClassNamePrefixFeaturesOutMixin, TransformerMixin):
+    """Base class from SparseCoder and DictionaryLearning algorithms."""
+
+    def __init__(
+        self,
+        transform_algorithm,
+        transform_n_nonzero_coefs,
+        transform_alpha,
+        split_sign,
+        n_jobs,
+        positive_code,
+        transform_max_iter,
+    ):
+        self.transform_algorithm = transform_algorithm
+        self.transform_n_nonzero_coefs = transform_n_nonzero_coefs
+        self.transform_alpha = transform_alpha
+        self.transform_max_iter = transform_max_iter
+        self.split_sign = split_sign
+        self.n_jobs = n_jobs
+        self.positive_code = positive_code
+
+    def _transform(self, X, dictionary):
+        """Private method allowing to accommodate both DictionaryLearning and
+        SparseCoder."""
+        X = self._validate_data(X, reset=False)
+
+        if hasattr(self, "alpha") and self.transform_alpha is None:
+            transform_alpha = self.alpha
+        else:
+            transform_alpha = self.transform_alpha
+
+        code = sparse_encode(
+            X,
+            dictionary,
+            algorithm=self.transform_algorithm,
+            n_nonzero_coefs=self.transform_n_nonzero_coefs,
+            alpha=transform_alpha,
+            max_iter=self.transform_max_iter,
+            n_jobs=self.n_jobs,
+            positive=self.positive_code,
+        )
+
+        if self.split_sign:
+            # feature vector is split into a positive and negative side
+            n_samples, n_features = code.shape
+            split_code = np.empty((n_samples, 2 * n_features))
+            split_code[:, :n_features] = np.maximum(code, 0)
+            split_code[:, n_features:] = -np.minimum(code, 0)
+            code = split_code
+
+        return code
+
+    def transform(self, X):
+        """Encode the data as a sparse combination of the dictionary atoms.
+
+        Coding method is determined by the object parameter
+        `transform_algorithm`.
+
+        Parameters
+        ----------
+        X : ndarray of shape (n_samples, n_features)
+            Test data to be transformed, must have the same number of
+            features as the data used to train the model.
+
+        Returns
+        -------
+        X_new : ndarray of shape (n_samples, n_components)
+            Transformed data.
+        """
+        check_is_fitted(self)
+        return self._transform(X, self.components_)
+
+
+class SparseCoder(_BaseSparseCoding, BaseEstimator):
+    """Sparse coding.
+
+    Finds a sparse representation of data against a fixed, precomputed
+    dictionary.
+
+    Each row of the result is the solution to a sparse coding problem.
+    The goal is to find a sparse array `code` such that::
+
+        X ~= code * dictionary
+
+    Read more in the :ref:`User Guide <SparseCoder>`.
+
+    Parameters
+    ----------
+    dictionary : ndarray of shape (n_components, n_features)
+        The dictionary atoms used for sparse coding. Lines are assumed to be
+        normalized to unit norm.
+
+    transform_algorithm : {'lasso_lars', 'lasso_cd', 'lars', 'omp', \
+            'threshold'}, default='omp'
+        Algorithm used to transform the data:
+
+        - `'lars'`: uses the least angle regression method
+          (`linear_model.lars_path`);
+        - `'lasso_lars'`: uses Lars to compute the Lasso solution;
+        - `'lasso_cd'`: uses the coordinate descent method to compute the
+          Lasso solution (linear_model.Lasso). `'lasso_lars'` will be faster if
+          the estimated components are sparse;
+        - `'omp'`: uses orthogonal matching pursuit to estimate the sparse
+          solution;
+        - `'threshold'`: squashes to zero all coefficients less than alpha from
+          the projection ``dictionary * X'``.
+
+    transform_n_nonzero_coefs : int, default=None
+        Number of nonzero coefficients to target in each column of the
+        solution. This is only used by `algorithm='lars'` and `algorithm='omp'`
+        and is overridden by `alpha` in the `omp` case. If `None`, then
+        `transform_n_nonzero_coefs=int(n_features / 10)`.
+
+    transform_alpha : float, default=None
+        If `algorithm='lasso_lars'` or `algorithm='lasso_cd'`, `alpha` is the
+        penalty applied to the L1 norm.
+        If `algorithm='threshold'`, `alpha` is the absolute value of the
+        threshold below which coefficients will be squashed to zero.
+        If `algorithm='omp'`, `alpha` is the tolerance parameter: the value of
+        the reconstruction error targeted. In this case, it overrides
+        `n_nonzero_coefs`.
+        If `None`, default to 1.
+
+    split_sign : bool, default=False
+        Whether to split the sparse feature vector into the concatenation of
+        its negative part and its positive part. This can improve the
+        performance of downstream classifiers.
+
+    n_jobs : int, default=None
+        Number of parallel jobs to run.
+        ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.
+        ``-1`` means using all processors. See :term:`Glossary <n_jobs>`
+        for more details.
+
+    positive_code : bool, default=False
+        Whether to enforce positivity when finding the code.
+
+        .. versionadded:: 0.20
+
+    transform_max_iter : int, default=1000
+        Maximum number of iterations to perform if `algorithm='lasso_cd'` or
+        `lasso_lars`.
+
+        .. versionadded:: 0.22
+
+    Attributes
+    ----------
+    n_components_ : int
+        Number of atoms.
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    See Also
+    --------
+    DictionaryLearning : Find a dictionary that sparsely encodes data.
+    MiniBatchDictionaryLearning : A faster, less accurate, version of the
+        dictionary learning algorithm.
+    MiniBatchSparsePCA : Mini-batch Sparse Principal Components Analysis.
+    SparsePCA : Sparse Principal Components Analysis.
+    sparse_encode : Sparse coding where each row of the result is the solution
+        to a sparse coding problem.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.decomposition import SparseCoder
+    >>> X = np.array([[-1, -1, -1], [0, 0, 3]])
+    >>> dictionary = np.array(
+    ...     [[0, 1, 0],
+    ...      [-1, -1, 2],
+    ...      [1, 1, 1],
+    ...      [0, 1, 1],
+    ...      [0, 2, 1]],
+    ...    dtype=np.float64
+    ... )
+    >>> coder = SparseCoder(
+    ...     dictionary=dictionary, transform_algorithm='lasso_lars',
+    ...     transform_alpha=1e-10,
+    ... )
+    >>> coder.transform(X)
+    array([[ 0.,  0., -1.,  0.,  0.],
+           [ 0.,  1.,  1.,  0.,  0.]])
+    """
+
+    _required_parameters = ["dictionary"]
+
+    def __init__(
+        self,
+        dictionary,
+        *,
+        transform_algorithm="omp",
+        transform_n_nonzero_coefs=None,
+        transform_alpha=None,
+        split_sign=False,
+        n_jobs=None,
+        positive_code=False,
+        transform_max_iter=1000,
+    ):
+        super().__init__(
+            transform_algorithm,
+            transform_n_nonzero_coefs,
+            transform_alpha,
+            split_sign,
+            n_jobs,
+            positive_code,
+            transform_max_iter,
+        )
+        self.dictionary = dictionary
+
+    def fit(self, X, y=None):
+        """Do nothing and return the estimator unchanged.
+
+        This method is just there to implement the usual API and hence
+        work in pipelines.
+
+        Parameters
+        ----------
+        X : Ignored
+            Not used, present for API consistency by convention.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        return self
+
+    def transform(self, X, y=None):
+        """Encode the data as a sparse combination of the dictionary atoms.
+
+        Coding method is determined by the object parameter
+        `transform_algorithm`.
+
+        Parameters
+        ----------
+        X : ndarray of shape (n_samples, n_features)
+            Training vector, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        X_new : ndarray of shape (n_samples, n_components)
+            Transformed data.
+        """
+        return super()._transform(X, self.dictionary)
+
+    def _more_tags(self):
+        return {
+            "requires_fit": False,
+            "preserves_dtype": [np.float64, np.float32],
+        }
+
+    @property
+    def n_components_(self):
+        """Number of atoms."""
+        return self.dictionary.shape[0]
+
+    @property
+    def n_features_in_(self):
+        """Number of features seen during `fit`."""
+        return self.dictionary.shape[1]
+
+    @property
+    def _n_features_out(self):
+        """Number of transformed output features."""
+        return self.n_components_
+
+
+class DictionaryLearning(_BaseSparseCoding, BaseEstimator):
+    """Dictionary learning.
+
+    Finds a dictionary (a set of atoms) that performs well at sparsely
+    encoding the fitted data.
+
+    Solves the optimization problem::
+
+        (U^*,V^*) = argmin 0.5 || X - U V ||_Fro^2 + alpha * || U ||_1,1
+                    (U,V)
+                    with || V_k ||_2 <= 1 for all  0 <= k < n_components
+
+    ||.||_Fro stands for the Frobenius norm and ||.||_1,1 stands for
+    the entry-wise matrix norm which is the sum of the absolute values
+    of all the entries in the matrix.
+
+    Read more in the :ref:`User Guide <DictionaryLearning>`.
+
+    Parameters
+    ----------
+    n_components : int, default=None
+        Number of dictionary elements to extract. If None, then ``n_components``
+        is set to ``n_features``.
+
+    alpha : float, default=1.0
+        Sparsity controlling parameter.
+
+    max_iter : int, default=1000
+        Maximum number of iterations to perform.
+
+    tol : float, default=1e-8
+        Tolerance for numerical error.
+
+    fit_algorithm : {'lars', 'cd'}, default='lars'
+        * `'lars'`: uses the least angle regression method to solve the lasso
+          problem (:func:`~sklearn.linear_model.lars_path`);
+        * `'cd'`: uses the coordinate descent method to compute the
+          Lasso solution (:class:`~sklearn.linear_model.Lasso`). Lars will be
+          faster if the estimated components are sparse.
+
+        .. versionadded:: 0.17
+           *cd* coordinate descent method to improve speed.
+
+    transform_algorithm : {'lasso_lars', 'lasso_cd', 'lars', 'omp', \
+            'threshold'}, default='omp'
+        Algorithm used to transform the data:
+
+        - `'lars'`: uses the least angle regression method
+          (:func:`~sklearn.linear_model.lars_path`);
+        - `'lasso_lars'`: uses Lars to compute the Lasso solution.
+        - `'lasso_cd'`: uses the coordinate descent method to compute the
+          Lasso solution (:class:`~sklearn.linear_model.Lasso`). `'lasso_lars'`
+          will be faster if the estimated components are sparse.
+        - `'omp'`: uses orthogonal matching pursuit to estimate the sparse
+          solution.
+        - `'threshold'`: squashes to zero all coefficients less than alpha from
+          the projection ``dictionary * X'``.
+
+        .. versionadded:: 0.17
+           *lasso_cd* coordinate descent method to improve speed.
+
+    transform_n_nonzero_coefs : int, default=None
+        Number of nonzero coefficients to target in each column of the
+        solution. This is only used by `algorithm='lars'` and
+        `algorithm='omp'`. If `None`, then
+        `transform_n_nonzero_coefs=int(n_features / 10)`.
+
+    transform_alpha : float, default=None
+        If `algorithm='lasso_lars'` or `algorithm='lasso_cd'`, `alpha` is the
+        penalty applied to the L1 norm.
+        If `algorithm='threshold'`, `alpha` is the absolute value of the
+        threshold below which coefficients will be squashed to zero.
+        If `None`, defaults to `alpha`.
+
+        .. versionchanged:: 1.2
+            When None, default value changed from 1.0 to `alpha`.
+
+    n_jobs : int or None, default=None
+        Number of parallel jobs to run.
+        ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.
+        ``-1`` means using all processors. See :term:`Glossary <n_jobs>`
+        for more details.
+
+    code_init : ndarray of shape (n_samples, n_components), default=None
+        Initial value for the code, for warm restart. Only used if `code_init`
+        and `dict_init` are not None.
+
+    dict_init : ndarray of shape (n_components, n_features), default=None
+        Initial values for the dictionary, for warm restart. Only used if
+        `code_init` and `dict_init` are not None.
+
+    callback : callable, default=None
+        Callable that gets invoked every five iterations.
+
+        .. versionadded:: 1.3
+
+    verbose : bool, default=False
+        To control the verbosity of the procedure.
+
+    split_sign : bool, default=False
+        Whether to split the sparse feature vector into the concatenation of
+        its negative part and its positive part. This can improve the
+        performance of downstream classifiers.
+
+    random_state : int, RandomState instance or None, default=None
+        Used for initializing the dictionary when ``dict_init`` is not
+        specified, randomly shuffling the data when ``shuffle`` is set to
+        ``True``, and updating the dictionary. Pass an int for reproducible
+        results across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    positive_code : bool, default=False
+        Whether to enforce positivity when finding the code.
+
+        .. versionadded:: 0.20
+
+    positive_dict : bool, default=False
+        Whether to enforce positivity when finding the dictionary.
+
+        .. versionadded:: 0.20
+
+    transform_max_iter : int, default=1000
+        Maximum number of iterations to perform if `algorithm='lasso_cd'` or
+        `'lasso_lars'`.
+
+        .. versionadded:: 0.22
+
+    Attributes
+    ----------
+    components_ : ndarray of shape (n_components, n_features)
+        dictionary atoms extracted from the data
+
+    error_ : array
+        vector of errors at each iteration
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    n_iter_ : int
+        Number of iterations run.
+
+    See Also
+    --------
+    MiniBatchDictionaryLearning: A faster, less accurate, version of the
+        dictionary learning algorithm.
+    MiniBatchSparsePCA : Mini-batch Sparse Principal Components Analysis.
+    SparseCoder : Find a sparse representation of data from a fixed,
+        precomputed dictionary.
+    SparsePCA : Sparse Principal Components Analysis.
+
+    References
+    ----------
+
+    J. Mairal, F. Bach, J. Ponce, G. Sapiro, 2009: Online dictionary learning
+    for sparse coding (https://www.di.ens.fr/sierra/pdfs/icml09.pdf)
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.datasets import make_sparse_coded_signal
+    >>> from sklearn.decomposition import DictionaryLearning
+    >>> X, dictionary, code = make_sparse_coded_signal(
+    ...     n_samples=30, n_components=15, n_features=20, n_nonzero_coefs=10,
+    ...     random_state=42,
+    ... )
+    >>> dict_learner = DictionaryLearning(
+    ...     n_components=15, transform_algorithm='lasso_lars', transform_alpha=0.1,
+    ...     random_state=42,
+    ... )
+    >>> X_transformed = dict_learner.fit(X).transform(X)
+
+    We can check the level of sparsity of `X_transformed`:
+
+    >>> np.mean(X_transformed == 0)
+    0.52...
+
+    We can compare the average squared euclidean norm of the reconstruction
+    error of the sparse coded signal relative to the squared euclidean norm of
+    the original signal:
+
+    >>> X_hat = X_transformed @ dict_learner.components_
+    >>> np.mean(np.sum((X_hat - X) ** 2, axis=1) / np.sum(X ** 2, axis=1))
+    0.05...
+    """
+
+    _parameter_constraints: dict = {
+        "n_components": [Interval(Integral, 1, None, closed="left"), None],
+        "alpha": [Interval(Real, 0, None, closed="left")],
+        "max_iter": [Interval(Integral, 0, None, closed="left")],
+        "tol": [Interval(Real, 0, None, closed="left")],
+        "fit_algorithm": [StrOptions({"lars", "cd"})],
+        "transform_algorithm": [
+            StrOptions({"lasso_lars", "lasso_cd", "lars", "omp", "threshold"})
+        ],
+        "transform_n_nonzero_coefs": [Interval(Integral, 1, None, closed="left"), None],
+        "transform_alpha": [Interval(Real, 0, None, closed="left"), None],
+        "n_jobs": [Integral, None],
+        "code_init": [np.ndarray, None],
+        "dict_init": [np.ndarray, None],
+        "callback": [callable, None],
+        "verbose": ["verbose"],
+        "split_sign": ["boolean"],
+        "random_state": ["random_state"],
+        "positive_code": ["boolean"],
+        "positive_dict": ["boolean"],
+        "transform_max_iter": [Interval(Integral, 0, None, closed="left")],
+    }
+
+    def __init__(
+        self,
+        n_components=None,
+        *,
+        alpha=1,
+        max_iter=1000,
+        tol=1e-8,
+        fit_algorithm="lars",
+        transform_algorithm="omp",
+        transform_n_nonzero_coefs=None,
+        transform_alpha=None,
+        n_jobs=None,
+        code_init=None,
+        dict_init=None,
+        callback=None,
+        verbose=False,
+        split_sign=False,
+        random_state=None,
+        positive_code=False,
+        positive_dict=False,
+        transform_max_iter=1000,
+    ):
+        super().__init__(
+            transform_algorithm,
+            transform_n_nonzero_coefs,
+            transform_alpha,
+            split_sign,
+            n_jobs,
+            positive_code,
+            transform_max_iter,
+        )
+        self.n_components = n_components
+        self.alpha = alpha
+        self.max_iter = max_iter
+        self.tol = tol
+        self.fit_algorithm = fit_algorithm
+        self.code_init = code_init
+        self.dict_init = dict_init
+        self.callback = callback
+        self.verbose = verbose
+        self.random_state = random_state
+        self.positive_dict = positive_dict
+
+    def fit(self, X, y=None):
+        """Fit the model from data in X.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training vector, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        self.fit_transform(X)
+        return self
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit_transform(self, X, y=None):
+        """Fit the model from data in X and return the transformed data.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training vector, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        V : ndarray of shape (n_samples, n_components)
+            Transformed data.
+        """
+        _check_positive_coding(method=self.fit_algorithm, positive=self.positive_code)
+
+        method = "lasso_" + self.fit_algorithm
+
+        random_state = check_random_state(self.random_state)
+        X = self._validate_data(X)
+
+        if self.n_components is None:
+            n_components = X.shape[1]
+        else:
+            n_components = self.n_components
+
+        V, U, E, self.n_iter_ = _dict_learning(
+            X,
+            n_components,
+            alpha=self.alpha,
+            tol=self.tol,
+            max_iter=self.max_iter,
+            method=method,
+            method_max_iter=self.transform_max_iter,
+            n_jobs=self.n_jobs,
+            code_init=self.code_init,
+            dict_init=self.dict_init,
+            callback=self.callback,
+            verbose=self.verbose,
+            random_state=random_state,
+            return_n_iter=True,
+            positive_dict=self.positive_dict,
+            positive_code=self.positive_code,
+        )
+        self.components_ = U
+        self.error_ = E
+
+        return V
+
+    @property
+    def _n_features_out(self):
+        """Number of transformed output features."""
+        return self.components_.shape[0]
+
+    def _more_tags(self):
+        return {
+            "preserves_dtype": [np.float64, np.float32],
+        }
+
+
+class MiniBatchDictionaryLearning(_BaseSparseCoding, BaseEstimator):
+    """Mini-batch dictionary learning.
+
+    Finds a dictionary (a set of atoms) that performs well at sparsely
+    encoding the fitted data.
+
+    Solves the optimization problem::
+
+       (U^*,V^*) = argmin 0.5 || X - U V ||_Fro^2 + alpha * || U ||_1,1
+                    (U,V)
+                    with || V_k ||_2 <= 1 for all  0 <= k < n_components
+
+    ||.||_Fro stands for the Frobenius norm and ||.||_1,1 stands for
+    the entry-wise matrix norm which is the sum of the absolute values
+    of all the entries in the matrix.
+
+    Read more in the :ref:`User Guide <DictionaryLearning>`.
+
+    Parameters
+    ----------
+    n_components : int, default=None
+        Number of dictionary elements to extract.
+
+    alpha : float, default=1
+        Sparsity controlling parameter.
+
+    max_iter : int, default=1_000
+        Maximum number of iterations over the complete dataset before
+        stopping independently of any early stopping criterion heuristics.
+
+        .. versionadded:: 1.1
+
+        .. deprecated:: 1.4
+           `max_iter=None` is deprecated in 1.4 and will be removed in 1.6.
+           Use the default value (i.e. `1_000`) instead.
+
+    fit_algorithm : {'lars', 'cd'}, default='lars'
+        The algorithm used:
+
+        - `'lars'`: uses the least angle regression method to solve the lasso
+          problem (`linear_model.lars_path`)
+        - `'cd'`: uses the coordinate descent method to compute the
+          Lasso solution (`linear_model.Lasso`). Lars will be faster if
+          the estimated components are sparse.
+
+    n_jobs : int, default=None
+        Number of parallel jobs to run.
+        ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.
+        ``-1`` means using all processors. See :term:`Glossary <n_jobs>`
+        for more details.
+
+    batch_size : int, default=256
+        Number of samples in each mini-batch.
+
+        .. versionchanged:: 1.3
+           The default value of `batch_size` changed from 3 to 256 in version 1.3.
+
+    shuffle : bool, default=True
+        Whether to shuffle the samples before forming batches.
+
+    dict_init : ndarray of shape (n_components, n_features), default=None
+        Initial value of the dictionary for warm restart scenarios.
+
+    transform_algorithm : {'lasso_lars', 'lasso_cd', 'lars', 'omp', \
+            'threshold'}, default='omp'
+        Algorithm used to transform the data:
+
+        - `'lars'`: uses the least angle regression method
+          (`linear_model.lars_path`);
+        - `'lasso_lars'`: uses Lars to compute the Lasso solution.
+        - `'lasso_cd'`: uses the coordinate descent method to compute the
+          Lasso solution (`linear_model.Lasso`). `'lasso_lars'` will be faster
+          if the estimated components are sparse.
+        - `'omp'`: uses orthogonal matching pursuit to estimate the sparse
+          solution.
+        - `'threshold'`: squashes to zero all coefficients less than alpha from
+          the projection ``dictionary * X'``.
+
+    transform_n_nonzero_coefs : int, default=None
+        Number of nonzero coefficients to target in each column of the
+        solution. This is only used by `algorithm='lars'` and
+        `algorithm='omp'`. If `None`, then
+        `transform_n_nonzero_coefs=int(n_features / 10)`.
+
+    transform_alpha : float, default=None
+        If `algorithm='lasso_lars'` or `algorithm='lasso_cd'`, `alpha` is the
+        penalty applied to the L1 norm.
+        If `algorithm='threshold'`, `alpha` is the absolute value of the
+        threshold below which coefficients will be squashed to zero.
+        If `None`, defaults to `alpha`.
+
+        .. versionchanged:: 1.2
+            When None, default value changed from 1.0 to `alpha`.
+
+    verbose : bool or int, default=False
+        To control the verbosity of the procedure.
+
+    split_sign : bool, default=False
+        Whether to split the sparse feature vector into the concatenation of
+        its negative part and its positive part. This can improve the
+        performance of downstream classifiers.
+
+    random_state : int, RandomState instance or None, default=None
+        Used for initializing the dictionary when ``dict_init`` is not
+        specified, randomly shuffling the data when ``shuffle`` is set to
+        ``True``, and updating the dictionary. Pass an int for reproducible
+        results across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    positive_code : bool, default=False
+        Whether to enforce positivity when finding the code.
+
+        .. versionadded:: 0.20
+
+    positive_dict : bool, default=False
+        Whether to enforce positivity when finding the dictionary.
+
+        .. versionadded:: 0.20
+
+    transform_max_iter : int, default=1000
+        Maximum number of iterations to perform if `algorithm='lasso_cd'` or
+        `'lasso_lars'`.
+
+        .. versionadded:: 0.22
+
+    callback : callable, default=None
+        A callable that gets invoked at the end of each iteration.
+
+        .. versionadded:: 1.1
+
+    tol : float, default=1e-3
+        Control early stopping based on the norm of the differences in the
+        dictionary between 2 steps.
+
+        To disable early stopping based on changes in the dictionary, set
+        `tol` to 0.0.
+
+        .. versionadded:: 1.1
+
+    max_no_improvement : int, default=10
+        Control early stopping based on the consecutive number of mini batches
+        that does not yield an improvement on the smoothed cost function.
+
+        To disable convergence detection based on cost function, set
+        `max_no_improvement` to None.
+
+        .. versionadded:: 1.1
+
+    Attributes
+    ----------
+    components_ : ndarray of shape (n_components, n_features)
+        Components extracted from the data.
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    n_iter_ : int
+        Number of iterations over the full dataset.
+
+    n_steps_ : int
+        Number of mini-batches processed.
+
+        .. versionadded:: 1.1
+
+    See Also
+    --------
+    DictionaryLearning : Find a dictionary that sparsely encodes data.
+    MiniBatchSparsePCA : Mini-batch Sparse Principal Components Analysis.
+    SparseCoder : Find a sparse representation of data from a fixed,
+        precomputed dictionary.
+    SparsePCA : Sparse Principal Components Analysis.
+
+    References
+    ----------
+
+    J. Mairal, F. Bach, J. Ponce, G. Sapiro, 2009: Online dictionary learning
+    for sparse coding (https://www.di.ens.fr/sierra/pdfs/icml09.pdf)
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.datasets import make_sparse_coded_signal
+    >>> from sklearn.decomposition import MiniBatchDictionaryLearning
+    >>> X, dictionary, code = make_sparse_coded_signal(
+    ...     n_samples=30, n_components=15, n_features=20, n_nonzero_coefs=10,
+    ...     random_state=42)
+    >>> dict_learner = MiniBatchDictionaryLearning(
+    ...     n_components=15, batch_size=3, transform_algorithm='lasso_lars',
+    ...     transform_alpha=0.1, max_iter=20, random_state=42)
+    >>> X_transformed = dict_learner.fit_transform(X)
+
+    We can check the level of sparsity of `X_transformed`:
+
+    >>> np.mean(X_transformed == 0) > 0.5
+    True
+
+    We can compare the average squared euclidean norm of the reconstruction
+    error of the sparse coded signal relative to the squared euclidean norm of
+    the original signal:
+
+    >>> X_hat = X_transformed @ dict_learner.components_
+    >>> np.mean(np.sum((X_hat - X) ** 2, axis=1) / np.sum(X ** 2, axis=1))
+    0.052...
+    """
+
+    _parameter_constraints: dict = {
+        "n_components": [Interval(Integral, 1, None, closed="left"), None],
+        "alpha": [Interval(Real, 0, None, closed="left")],
+        "max_iter": [Interval(Integral, 0, None, closed="left"), Hidden(None)],
+        "fit_algorithm": [StrOptions({"cd", "lars"})],
+        "n_jobs": [None, Integral],
+        "batch_size": [Interval(Integral, 1, None, closed="left")],
+        "shuffle": ["boolean"],
+        "dict_init": [None, np.ndarray],
+        "transform_algorithm": [
+            StrOptions({"lasso_lars", "lasso_cd", "lars", "omp", "threshold"})
+        ],
+        "transform_n_nonzero_coefs": [Interval(Integral, 1, None, closed="left"), None],
+        "transform_alpha": [Interval(Real, 0, None, closed="left"), None],
+        "verbose": ["verbose"],
+        "split_sign": ["boolean"],
+        "random_state": ["random_state"],
+        "positive_code": ["boolean"],
+        "positive_dict": ["boolean"],
+        "transform_max_iter": [Interval(Integral, 0, None, closed="left")],
+        "callback": [None, callable],
+        "tol": [Interval(Real, 0, None, closed="left")],
+        "max_no_improvement": [Interval(Integral, 0, None, closed="left"), None],
+    }
+
+    def __init__(
+        self,
+        n_components=None,
+        *,
+        alpha=1,
+        max_iter=1_000,
+        fit_algorithm="lars",
+        n_jobs=None,
+        batch_size=256,
+        shuffle=True,
+        dict_init=None,
+        transform_algorithm="omp",
+        transform_n_nonzero_coefs=None,
+        transform_alpha=None,
+        verbose=False,
+        split_sign=False,
+        random_state=None,
+        positive_code=False,
+        positive_dict=False,
+        transform_max_iter=1000,
+        callback=None,
+        tol=1e-3,
+        max_no_improvement=10,
+    ):
+        super().__init__(
+            transform_algorithm,
+            transform_n_nonzero_coefs,
+            transform_alpha,
+            split_sign,
+            n_jobs,
+            positive_code,
+            transform_max_iter,
+        )
+        self.n_components = n_components
+        self.alpha = alpha
+        self.max_iter = max_iter
+        self.fit_algorithm = fit_algorithm
+        self.dict_init = dict_init
+        self.verbose = verbose
+        self.shuffle = shuffle
+        self.batch_size = batch_size
+        self.split_sign = split_sign
+        self.random_state = random_state
+        self.positive_dict = positive_dict
+        self.callback = callback
+        self.max_no_improvement = max_no_improvement
+        self.tol = tol
+
+    def _check_params(self, X):
+        # n_components
+        self._n_components = self.n_components
+        if self._n_components is None:
+            self._n_components = X.shape[1]
+
+        # fit_algorithm
+        _check_positive_coding(self.fit_algorithm, self.positive_code)
+        self._fit_algorithm = "lasso_" + self.fit_algorithm
+
+        # batch_size
+        self._batch_size = min(self.batch_size, X.shape[0])
+
+    def _initialize_dict(self, X, random_state):
+        """Initialization of the dictionary."""
+        if self.dict_init is not None:
+            dictionary = self.dict_init
+        else:
+            # Init V with SVD of X
+            _, S, dictionary = randomized_svd(
+                X, self._n_components, random_state=random_state
+            )
+            dictionary = S[:, np.newaxis] * dictionary
+
+        if self._n_components <= len(dictionary):
+            dictionary = dictionary[: self._n_components, :]
+        else:
+            dictionary = np.concatenate(
+                (
+                    dictionary,
+                    np.zeros(
+                        (self._n_components - len(dictionary), dictionary.shape[1]),
+                        dtype=dictionary.dtype,
+                    ),
+                )
+            )
+
+        dictionary = check_array(dictionary, order="F", dtype=X.dtype, copy=False)
+        dictionary = np.require(dictionary, requirements="W")
+
+        return dictionary
+
+    def _update_inner_stats(self, X, code, batch_size, step):
+        """Update the inner stats inplace."""
+        if step < batch_size - 1:
+            theta = (step + 1) * batch_size
+        else:
+            theta = batch_size**2 + step + 1 - batch_size
+        beta = (theta + 1 - batch_size) / (theta + 1)
+
+        self._A *= beta
+        self._A += code.T @ code / batch_size
+        self._B *= beta
+        self._B += X.T @ code / batch_size
+
+    def _minibatch_step(self, X, dictionary, random_state, step):
+        """Perform the update on the dictionary for one minibatch."""
+        batch_size = X.shape[0]
+
+        # Compute code for this batch
+        code = _sparse_encode(
+            X,
+            dictionary,
+            algorithm=self._fit_algorithm,
+            alpha=self.alpha,
+            n_jobs=self.n_jobs,
+            positive=self.positive_code,
+            max_iter=self.transform_max_iter,
+            verbose=self.verbose,
+        )
+
+        batch_cost = (
+            0.5 * ((X - code @ dictionary) ** 2).sum()
+            + self.alpha * np.sum(np.abs(code))
+        ) / batch_size
+
+        # Update inner stats
+        self._update_inner_stats(X, code, batch_size, step)
+
+        # Update dictionary
+        _update_dict(
+            dictionary,
+            X,
+            code,
+            self._A,
+            self._B,
+            verbose=self.verbose,
+            random_state=random_state,
+            positive=self.positive_dict,
+        )
+
+        return batch_cost
+
+    def _check_convergence(
+        self, X, batch_cost, new_dict, old_dict, n_samples, step, n_steps
+    ):
+        """Helper function to encapsulate the early stopping logic.
+
+        Early stopping is based on two factors:
+        - A small change of the dictionary between two minibatch updates. This is
+          controlled by the tol parameter.
+        - No more improvement on a smoothed estimate of the objective function for a
+          a certain number of consecutive minibatch updates. This is controlled by
+          the max_no_improvement parameter.
+        """
+        batch_size = X.shape[0]
+
+        # counts steps starting from 1 for user friendly verbose mode.
+        step = step + 1
+
+        # Ignore 100 first steps or 1 epoch to avoid initializing the ewa_cost with a
+        # too bad value
+        if step <= min(100, n_samples / batch_size):
+            if self.verbose:
+                print(f"Minibatch step {step}/{n_steps}: mean batch cost: {batch_cost}")
+            return False
+
+        # Compute an Exponentially Weighted Average of the cost function to
+        # monitor the convergence while discarding minibatch-local stochastic
+        # variability: https://en.wikipedia.org/wiki/Moving_average
+        if self._ewa_cost is None:
+            self._ewa_cost = batch_cost
+        else:
+            alpha = batch_size / (n_samples + 1)
+            alpha = min(alpha, 1)
+            self._ewa_cost = self._ewa_cost * (1 - alpha) + batch_cost * alpha
+
+        if self.verbose:
+            print(
+                f"Minibatch step {step}/{n_steps}: mean batch cost: "
+                f"{batch_cost}, ewa cost: {self._ewa_cost}"
+            )
+
+        # Early stopping based on change of dictionary
+        dict_diff = linalg.norm(new_dict - old_dict) / self._n_components
+        if self.tol > 0 and dict_diff <= self.tol:
+            if self.verbose:
+                print(f"Converged (small dictionary change) at step {step}/{n_steps}")
+            return True
+
+        # Early stopping heuristic due to lack of improvement on smoothed
+        # cost function
+        if self._ewa_cost_min is None or self._ewa_cost < self._ewa_cost_min:
+            self._no_improvement = 0
+            self._ewa_cost_min = self._ewa_cost
+        else:
+            self._no_improvement += 1
+
+        if (
+            self.max_no_improvement is not None
+            and self._no_improvement >= self.max_no_improvement
+        ):
+            if self.verbose:
+                print(
+                    "Converged (lack of improvement in objective function) "
+                    f"at step {step}/{n_steps}"
+                )
+            return True
+
+        return False
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, X, y=None):
+        """Fit the model from data in X.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training vector, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        X = self._validate_data(
+            X, dtype=[np.float64, np.float32], order="C", copy=False
+        )
+
+        self._check_params(X)
+        self._random_state = check_random_state(self.random_state)
+
+        dictionary = self._initialize_dict(X, self._random_state)
+        old_dict = dictionary.copy()
+
+        if self.shuffle:
+            X_train = X.copy()
+            self._random_state.shuffle(X_train)
+        else:
+            X_train = X
+
+        n_samples, n_features = X_train.shape
+
+        if self.verbose:
+            print("[dict_learning]")
+
+        # Inner stats
+        self._A = np.zeros(
+            (self._n_components, self._n_components), dtype=X_train.dtype
+        )
+        self._B = np.zeros((n_features, self._n_components), dtype=X_train.dtype)
+
+        # TODO(1.6): remove in 1.6
+        if self.max_iter is None:
+            warn(
+                (
+                    "`max_iter=None` is deprecated in version 1.4 and will be removed"
+                    " in version 1.6. Use the default value (i.e. `1_000`) instead."
+                ),
+                FutureWarning,
+            )
+            max_iter = 1_000
+        else:
+            max_iter = self.max_iter
+
+        # Attributes to monitor the convergence
+        self._ewa_cost = None
+        self._ewa_cost_min = None
+        self._no_improvement = 0
+
+        batches = gen_batches(n_samples, self._batch_size)
+        batches = itertools.cycle(batches)
+        n_steps_per_iter = int(np.ceil(n_samples / self._batch_size))
+        n_steps = max_iter * n_steps_per_iter
+
+        i = -1  # to allow max_iter = 0
+
+        for i, batch in zip(range(n_steps), batches):
+            X_batch = X_train[batch]
+
+            batch_cost = self._minibatch_step(
+                X_batch, dictionary, self._random_state, i
+            )
+
+            if self._check_convergence(
+                X_batch, batch_cost, dictionary, old_dict, n_samples, i, n_steps
+            ):
+                break
+
+            # XXX callback param added for backward compat in #18975 but a common
+            # unified callback API should be preferred
+            if self.callback is not None:
+                self.callback(locals())
+
+            old_dict[:] = dictionary
+
+        self.n_steps_ = i + 1
+        self.n_iter_ = np.ceil(self.n_steps_ / n_steps_per_iter)
+        self.components_ = dictionary
+
+        return self
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def partial_fit(self, X, y=None):
+        """Update the model using the data in X as a mini-batch.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training vector, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        self : object
+            Return the instance itself.
+        """
+        has_components = hasattr(self, "components_")
+
+        X = self._validate_data(
+            X, dtype=[np.float64, np.float32], order="C", reset=not has_components
+        )
+
+        if not has_components:
+            # This instance has not been fitted yet (fit or partial_fit)
+            self._check_params(X)
+            self._random_state = check_random_state(self.random_state)
+
+            dictionary = self._initialize_dict(X, self._random_state)
+
+            self.n_steps_ = 0
+
+            self._A = np.zeros((self._n_components, self._n_components), dtype=X.dtype)
+            self._B = np.zeros((X.shape[1], self._n_components), dtype=X.dtype)
+        else:
+            dictionary = self.components_
+
+        self._minibatch_step(X, dictionary, self._random_state, self.n_steps_)
+
+        self.components_ = dictionary
+        self.n_steps_ += 1
+
+        return self
+
+    @property
+    def _n_features_out(self):
+        """Number of transformed output features."""
+        return self.components_.shape[0]
+
+    def _more_tags(self):
+        return {
+            "preserves_dtype": [np.float64, np.float32],
+        }

venv/lib/python3.10/site-packages/sklearn/decomposition/_factor_analysis.py

@@ -0,0 +1,458 @@
+"""Factor Analysis.
+
+A latent linear variable model.
+
+FactorAnalysis is similar to probabilistic PCA implemented by PCA.score
+While PCA assumes Gaussian noise with the same variance for each
+feature, the FactorAnalysis model assumes different variances for
+each of them.
+
+This implementation is based on David Barber's Book,
+Bayesian Reasoning and Machine Learning,
+http://www.cs.ucl.ac.uk/staff/d.barber/brml,
+Algorithm 21.1
+"""
+
+# Author: Christian Osendorfer <[email protected]>
+#         Alexandre Gramfort <[email protected]>
+#         Denis A. Engemann <[email protected]>
+
+# License: BSD3
+
+import warnings
+from math import log, sqrt
+from numbers import Integral, Real
+
+import numpy as np
+from scipy import linalg
+
+from ..base import (
+    BaseEstimator,
+    ClassNamePrefixFeaturesOutMixin,
+    TransformerMixin,
+    _fit_context,
+)
+from ..exceptions import ConvergenceWarning
+from ..utils import check_random_state
+from ..utils._param_validation import Interval, StrOptions
+from ..utils.extmath import fast_logdet, randomized_svd, squared_norm
+from ..utils.validation import check_is_fitted
+
+
+class FactorAnalysis(ClassNamePrefixFeaturesOutMixin, TransformerMixin, BaseEstimator):
+    """Factor Analysis (FA).
+
+    A simple linear generative model with Gaussian latent variables.
+
+    The observations are assumed to be caused by a linear transformation of
+    lower dimensional latent factors and added Gaussian noise.
+    Without loss of generality the factors are distributed according to a
+    Gaussian with zero mean and unit covariance. The noise is also zero mean
+    and has an arbitrary diagonal covariance matrix.
+
+    If we would restrict the model further, by assuming that the Gaussian
+    noise is even isotropic (all diagonal entries are the same) we would obtain
+    :class:`PCA`.
+
+    FactorAnalysis performs a maximum likelihood estimate of the so-called
+    `loading` matrix, the transformation of the latent variables to the
+    observed ones, using SVD based approach.
+
+    Read more in the :ref:`User Guide <FA>`.
+
+    .. versionadded:: 0.13
+
+    Parameters
+    ----------
+    n_components : int, default=None
+        Dimensionality of latent space, the number of components
+        of ``X`` that are obtained after ``transform``.
+        If None, n_components is set to the number of features.
+
+    tol : float, default=1e-2
+        Stopping tolerance for log-likelihood increase.
+
+    copy : bool, default=True
+        Whether to make a copy of X. If ``False``, the input X gets overwritten
+        during fitting.
+
+    max_iter : int, default=1000
+        Maximum number of iterations.
+
+    noise_variance_init : array-like of shape (n_features,), default=None
+        The initial guess of the noise variance for each feature.
+        If None, it defaults to np.ones(n_features).
+
+    svd_method : {'lapack', 'randomized'}, default='randomized'
+        Which SVD method to use. If 'lapack' use standard SVD from
+        scipy.linalg, if 'randomized' use fast ``randomized_svd`` function.
+        Defaults to 'randomized'. For most applications 'randomized' will
+        be sufficiently precise while providing significant speed gains.
+        Accuracy can also be improved by setting higher values for
+        `iterated_power`. If this is not sufficient, for maximum precision
+        you should choose 'lapack'.
+
+    iterated_power : int, default=3
+        Number of iterations for the power method. 3 by default. Only used
+        if ``svd_method`` equals 'randomized'.
+
+    rotation : {'varimax', 'quartimax'}, default=None
+        If not None, apply the indicated rotation. Currently, varimax and
+        quartimax are implemented. See
+        `"The varimax criterion for analytic rotation in factor analysis"
+        <https://link.springer.com/article/10.1007%2FBF02289233>`_
+        H. F. Kaiser, 1958.
+
+        .. versionadded:: 0.24
+
+    random_state : int or RandomState instance, default=0
+        Only used when ``svd_method`` equals 'randomized'. Pass an int for
+        reproducible results across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    Attributes
+    ----------
+    components_ : ndarray of shape (n_components, n_features)
+        Components with maximum variance.
+
+    loglike_ : list of shape (n_iterations,)
+        The log likelihood at each iteration.
+
+    noise_variance_ : ndarray of shape (n_features,)
+        The estimated noise variance for each feature.
+
+    n_iter_ : int
+        Number of iterations run.
+
+    mean_ : ndarray of shape (n_features,)
+        Per-feature empirical mean, estimated from the training set.
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    See Also
+    --------
+    PCA: Principal component analysis is also a latent linear variable model
+        which however assumes equal noise variance for each feature.
+        This extra assumption makes probabilistic PCA faster as it can be
+        computed in closed form.
+    FastICA: Independent component analysis, a latent variable model with
+        non-Gaussian latent variables.
+
+    References
+    ----------
+    - David Barber, Bayesian Reasoning and Machine Learning,
+      Algorithm 21.1.
+
+    - Christopher M. Bishop: Pattern Recognition and Machine Learning,
+      Chapter 12.2.4.
+
+    Examples
+    --------
+    >>> from sklearn.datasets import load_digits
+    >>> from sklearn.decomposition import FactorAnalysis
+    >>> X, _ = load_digits(return_X_y=True)
+    >>> transformer = FactorAnalysis(n_components=7, random_state=0)
+    >>> X_transformed = transformer.fit_transform(X)
+    >>> X_transformed.shape
+    (1797, 7)
+    """
+
+    _parameter_constraints: dict = {
+        "n_components": [Interval(Integral, 0, None, closed="left"), None],
+        "tol": [Interval(Real, 0.0, None, closed="left")],
+        "copy": ["boolean"],
+        "max_iter": [Interval(Integral, 1, None, closed="left")],
+        "noise_variance_init": ["array-like", None],
+        "svd_method": [StrOptions({"randomized", "lapack"})],
+        "iterated_power": [Interval(Integral, 0, None, closed="left")],
+        "rotation": [StrOptions({"varimax", "quartimax"}), None],
+        "random_state": ["random_state"],
+    }
+
+    def __init__(
+        self,
+        n_components=None,
+        *,
+        tol=1e-2,
+        copy=True,
+        max_iter=1000,
+        noise_variance_init=None,
+        svd_method="randomized",
+        iterated_power=3,
+        rotation=None,
+        random_state=0,
+    ):
+        self.n_components = n_components
+        self.copy = copy
+        self.tol = tol
+        self.max_iter = max_iter
+        self.svd_method = svd_method
+
+        self.noise_variance_init = noise_variance_init
+        self.iterated_power = iterated_power
+        self.random_state = random_state
+        self.rotation = rotation
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, X, y=None):
+        """Fit the FactorAnalysis model to X using SVD based approach.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training data.
+
+        y : Ignored
+            Ignored parameter.
+
+        Returns
+        -------
+        self : object
+            FactorAnalysis class instance.
+        """
+        X = self._validate_data(X, copy=self.copy, dtype=np.float64)
+
+        n_samples, n_features = X.shape
+        n_components = self.n_components
+        if n_components is None:
+            n_components = n_features
+
+        self.mean_ = np.mean(X, axis=0)
+        X -= self.mean_
+
+        # some constant terms
+        nsqrt = sqrt(n_samples)
+        llconst = n_features * log(2.0 * np.pi) + n_components
+        var = np.var(X, axis=0)
+
+        if self.noise_variance_init is None:
+            psi = np.ones(n_features, dtype=X.dtype)
+        else:
+            if len(self.noise_variance_init) != n_features:
+                raise ValueError(
+                    "noise_variance_init dimension does not "
+                    "with number of features : %d != %d"
+                    % (len(self.noise_variance_init), n_features)
+                )
+            psi = np.array(self.noise_variance_init)
+
+        loglike = []
+        old_ll = -np.inf
+        SMALL = 1e-12
+
+        # we'll modify svd outputs to return unexplained variance
+        # to allow for unified computation of loglikelihood
+        if self.svd_method == "lapack":
+
+            def my_svd(X):
+                _, s, Vt = linalg.svd(X, full_matrices=False, check_finite=False)
+                return (
+                    s[:n_components],
+                    Vt[:n_components],
+                    squared_norm(s[n_components:]),
+                )
+
+        else:  # svd_method == "randomized"
+            random_state = check_random_state(self.random_state)
+
+            def my_svd(X):
+                _, s, Vt = randomized_svd(
+                    X,
+                    n_components,
+                    random_state=random_state,
+                    n_iter=self.iterated_power,
+                )
+                return s, Vt, squared_norm(X) - squared_norm(s)
+
+        for i in range(self.max_iter):
+            # SMALL helps numerics
+            sqrt_psi = np.sqrt(psi) + SMALL
+            s, Vt, unexp_var = my_svd(X / (sqrt_psi * nsqrt))
+            s **= 2
+            # Use 'maximum' here to avoid sqrt problems.
+            W = np.sqrt(np.maximum(s - 1.0, 0.0))[:, np.newaxis] * Vt
+            del Vt
+            W *= sqrt_psi
+
+            # loglikelihood
+            ll = llconst + np.sum(np.log(s))
+            ll += unexp_var + np.sum(np.log(psi))
+            ll *= -n_samples / 2.0
+            loglike.append(ll)
+            if (ll - old_ll) < self.tol:
+                break
+            old_ll = ll
+
+            psi = np.maximum(var - np.sum(W**2, axis=0), SMALL)
+        else:
+            warnings.warn(
+                "FactorAnalysis did not converge."
+                + " You might want"
+                + " to increase the number of iterations.",
+                ConvergenceWarning,
+            )
+
+        self.components_ = W
+        if self.rotation is not None:
+            self.components_ = self._rotate(W)
+        self.noise_variance_ = psi
+        self.loglike_ = loglike
+        self.n_iter_ = i + 1
+        return self
+
+    def transform(self, X):
+        """Apply dimensionality reduction to X using the model.
+
+        Compute the expected mean of the latent variables.
+        See Barber, 21.2.33 (or Bishop, 12.66).
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training data.
+
+        Returns
+        -------
+        X_new : ndarray of shape (n_samples, n_components)
+            The latent variables of X.
+        """
+        check_is_fitted(self)
+
+        X = self._validate_data(X, reset=False)
+        Ih = np.eye(len(self.components_))
+
+        X_transformed = X - self.mean_
+
+        Wpsi = self.components_ / self.noise_variance_
+        cov_z = linalg.inv(Ih + np.dot(Wpsi, self.components_.T))
+        tmp = np.dot(X_transformed, Wpsi.T)
+        X_transformed = np.dot(tmp, cov_z)
+
+        return X_transformed
+
+    def get_covariance(self):
+        """Compute data covariance with the FactorAnalysis model.
+
+        ``cov = components_.T * components_ + diag(noise_variance)``
+
+        Returns
+        -------
+        cov : ndarray of shape (n_features, n_features)
+            Estimated covariance of data.
+        """
+        check_is_fitted(self)
+
+        cov = np.dot(self.components_.T, self.components_)
+        cov.flat[:: len(cov) + 1] += self.noise_variance_  # modify diag inplace
+        return cov
+
+    def get_precision(self):
+        """Compute data precision matrix with the FactorAnalysis model.
+
+        Returns
+        -------
+        precision : ndarray of shape (n_features, n_features)
+            Estimated precision of data.
+        """
+        check_is_fitted(self)
+
+        n_features = self.components_.shape[1]
+
+        # handle corner cases first
+        if self.n_components == 0:
+            return np.diag(1.0 / self.noise_variance_)
+        if self.n_components == n_features:
+            return linalg.inv(self.get_covariance())
+
+        # Get precision using matrix inversion lemma
+        components_ = self.components_
+        precision = np.dot(components_ / self.noise_variance_, components_.T)
+        precision.flat[:: len(precision) + 1] += 1.0
+        precision = np.dot(components_.T, np.dot(linalg.inv(precision), components_))
+        precision /= self.noise_variance_[:, np.newaxis]
+        precision /= -self.noise_variance_[np.newaxis, :]
+        precision.flat[:: len(precision) + 1] += 1.0 / self.noise_variance_
+        return precision
+
+    def score_samples(self, X):
+        """Compute the log-likelihood of each sample.
+
+        Parameters
+        ----------
+        X : ndarray of shape (n_samples, n_features)
+            The data.
+
+        Returns
+        -------
+        ll : ndarray of shape (n_samples,)
+            Log-likelihood of each sample under the current model.
+        """
+        check_is_fitted(self)
+        X = self._validate_data(X, reset=False)
+        Xr = X - self.mean_
+        precision = self.get_precision()
+        n_features = X.shape[1]
+        log_like = -0.5 * (Xr * (np.dot(Xr, precision))).sum(axis=1)
+        log_like -= 0.5 * (n_features * log(2.0 * np.pi) - fast_logdet(precision))
+        return log_like
+
+    def score(self, X, y=None):
+        """Compute the average log-likelihood of the samples.
+
+        Parameters
+        ----------
+        X : ndarray of shape (n_samples, n_features)
+            The data.
+
+        y : Ignored
+            Ignored parameter.
+
+        Returns
+        -------
+        ll : float
+            Average log-likelihood of the samples under the current model.
+        """
+        return np.mean(self.score_samples(X))
+
+    def _rotate(self, components, n_components=None, tol=1e-6):
+        "Rotate the factor analysis solution."
+        # note that tol is not exposed
+        return _ortho_rotation(components.T, method=self.rotation, tol=tol)[
+            : self.n_components
+        ]
+
+    @property
+    def _n_features_out(self):
+        """Number of transformed output features."""
+        return self.components_.shape[0]
+
+
+def _ortho_rotation(components, method="varimax", tol=1e-6, max_iter=100):
+    """Return rotated components."""
+    nrow, ncol = components.shape
+    rotation_matrix = np.eye(ncol)
+    var = 0
+
+    for _ in range(max_iter):
+        comp_rot = np.dot(components, rotation_matrix)
+        if method == "varimax":
+            tmp = comp_rot * np.transpose((comp_rot**2).sum(axis=0) / nrow)
+        elif method == "quartimax":
+            tmp = 0
+        u, s, v = np.linalg.svd(np.dot(components.T, comp_rot**3 - tmp))
+        rotation_matrix = np.dot(u, v)
+        var_new = np.sum(s)
+        if var != 0 and var_new < var * (1 + tol):
+            break
+        var = var_new
+
+    return np.dot(components, rotation_matrix).T

venv/lib/python3.10/site-packages/sklearn/decomposition/_fastica.py

@@ -0,0 +1,795 @@
+"""
+Python implementation of the fast ICA algorithms.
+
+Reference: Tables 8.3 and 8.4 page 196 in the book:
+Independent Component Analysis, by  Hyvarinen et al.
+"""
+
+# Authors: Pierre Lafaye de Micheaux, Stefan van der Walt, Gael Varoquaux,
+#          Bertrand Thirion, Alexandre Gramfort, Denis A. Engemann
+# License: BSD 3 clause
+
+import warnings
+from numbers import Integral, Real
+
+import numpy as np
+from scipy import linalg
+
+from ..base import (
+    BaseEstimator,
+    ClassNamePrefixFeaturesOutMixin,
+    TransformerMixin,
+    _fit_context,
+)
+from ..exceptions import ConvergenceWarning
+from ..utils import as_float_array, check_array, check_random_state
+from ..utils._param_validation import Interval, Options, StrOptions, validate_params
+from ..utils.validation import check_is_fitted
+
+__all__ = ["fastica", "FastICA"]
+
+
+def _gs_decorrelation(w, W, j):
+    """
+    Orthonormalize w wrt the first j rows of W.
+
+    Parameters
+    ----------
+    w : ndarray of shape (n,)
+        Array to be orthogonalized
+
+    W : ndarray of shape (p, n)
+        Null space definition
+
+    j : int < p
+        The no of (from the first) rows of Null space W wrt which w is
+        orthogonalized.
+
+    Notes
+    -----
+    Assumes that W is orthogonal
+    w changed in place
+    """
+    w -= np.linalg.multi_dot([w, W[:j].T, W[:j]])
+    return w
+
+
+def _sym_decorrelation(W):
+    """Symmetric decorrelation
+    i.e. W <- (W * W.T) ^{-1/2} * W
+    """
+    s, u = linalg.eigh(np.dot(W, W.T))
+    # Avoid sqrt of negative values because of rounding errors. Note that
+    # np.sqrt(tiny) is larger than tiny and therefore this clipping also
+    # prevents division by zero in the next step.
+    s = np.clip(s, a_min=np.finfo(W.dtype).tiny, a_max=None)
+
+    # u (resp. s) contains the eigenvectors (resp. square roots of
+    # the eigenvalues) of W * W.T
+    return np.linalg.multi_dot([u * (1.0 / np.sqrt(s)), u.T, W])
+
+
+def _ica_def(X, tol, g, fun_args, max_iter, w_init):
+    """Deflationary FastICA using fun approx to neg-entropy function
+
+    Used internally by FastICA.
+    """
+
+    n_components = w_init.shape[0]
+    W = np.zeros((n_components, n_components), dtype=X.dtype)
+    n_iter = []
+
+    # j is the index of the extracted component
+    for j in range(n_components):
+        w = w_init[j, :].copy()
+        w /= np.sqrt((w**2).sum())
+
+        for i in range(max_iter):
+            gwtx, g_wtx = g(np.dot(w.T, X), fun_args)
+
+            w1 = (X * gwtx).mean(axis=1) - g_wtx.mean() * w
+
+            _gs_decorrelation(w1, W, j)
+
+            w1 /= np.sqrt((w1**2).sum())
+
+            lim = np.abs(np.abs((w1 * w).sum()) - 1)
+            w = w1
+            if lim < tol:
+                break
+
+        n_iter.append(i + 1)
+        W[j, :] = w
+
+    return W, max(n_iter)
+
+
+def _ica_par(X, tol, g, fun_args, max_iter, w_init):
+    """Parallel FastICA.
+
+    Used internally by FastICA --main loop
+
+    """
+    W = _sym_decorrelation(w_init)
+    del w_init
+    p_ = float(X.shape[1])
+    for ii in range(max_iter):
+        gwtx, g_wtx = g(np.dot(W, X), fun_args)
+        W1 = _sym_decorrelation(np.dot(gwtx, X.T) / p_ - g_wtx[:, np.newaxis] * W)
+        del gwtx, g_wtx
+        # builtin max, abs are faster than numpy counter parts.
+        # np.einsum allows having the lowest memory footprint.
+        # It is faster than np.diag(np.dot(W1, W.T)).
+        lim = max(abs(abs(np.einsum("ij,ij->i", W1, W)) - 1))
+        W = W1
+        if lim < tol:
+            break
+    else:
+        warnings.warn(
+            (
+                "FastICA did not converge. Consider increasing "
+                "tolerance or the maximum number of iterations."
+            ),
+            ConvergenceWarning,
+        )
+
+    return W, ii + 1
+
+
+# Some standard non-linear functions.
+# XXX: these should be optimized, as they can be a bottleneck.
+def _logcosh(x, fun_args=None):
+    alpha = fun_args.get("alpha", 1.0)  # comment it out?
+
+    x *= alpha
+    gx = np.tanh(x, x)  # apply the tanh inplace
+    g_x = np.empty(x.shape[0], dtype=x.dtype)
+    # XXX compute in chunks to avoid extra allocation
+    for i, gx_i in enumerate(gx):  # please don't vectorize.
+        g_x[i] = (alpha * (1 - gx_i**2)).mean()
+    return gx, g_x
+
+
+def _exp(x, fun_args):
+    exp = np.exp(-(x**2) / 2)
+    gx = x * exp
+    g_x = (1 - x**2) * exp
+    return gx, g_x.mean(axis=-1)
+
+
+def _cube(x, fun_args):
+    return x**3, (3 * x**2).mean(axis=-1)
+
+
+@validate_params(
+    {
+        "X": ["array-like"],
+        "return_X_mean": ["boolean"],
+        "compute_sources": ["boolean"],
+        "return_n_iter": ["boolean"],
+    },
+    prefer_skip_nested_validation=False,
+)
+def fastica(
+    X,
+    n_components=None,
+    *,
+    algorithm="parallel",
+    whiten="unit-variance",
+    fun="logcosh",
+    fun_args=None,
+    max_iter=200,
+    tol=1e-04,
+    w_init=None,
+    whiten_solver="svd",
+    random_state=None,
+    return_X_mean=False,
+    compute_sources=True,
+    return_n_iter=False,
+):
+    """Perform Fast Independent Component Analysis.
+
+    The implementation is based on [1]_.
+
+    Read more in the :ref:`User Guide <ICA>`.
+
+    Parameters
+    ----------
+    X : array-like of shape (n_samples, n_features)
+        Training vector, where `n_samples` is the number of samples and
+        `n_features` is the number of features.
+
+    n_components : int, default=None
+        Number of components to use. If None is passed, all are used.
+
+    algorithm : {'parallel', 'deflation'}, default='parallel'
+        Specify which algorithm to use for FastICA.
+
+    whiten : str or bool, default='unit-variance'
+        Specify the whitening strategy to use.
+
+        - If 'arbitrary-variance', a whitening with variance
+          arbitrary is used.
+        - If 'unit-variance', the whitening matrix is rescaled to ensure that
+          each recovered source has unit variance.
+        - If False, the data is already considered to be whitened, and no
+          whitening is performed.
+
+        .. versionchanged:: 1.3
+            The default value of `whiten` changed to 'unit-variance' in 1.3.
+
+    fun : {'logcosh', 'exp', 'cube'} or callable, default='logcosh'
+        The functional form of the G function used in the
+        approximation to neg-entropy. Could be either 'logcosh', 'exp',
+        or 'cube'.
+        You can also provide your own function. It should return a tuple
+        containing the value of the function, and of its derivative, in the
+        point. The derivative should be averaged along its last dimension.
+        Example::
+
+            def my_g(x):
+                return x ** 3, (3 * x ** 2).mean(axis=-1)
+
+    fun_args : dict, default=None
+        Arguments to send to the functional form.
+        If empty or None and if fun='logcosh', fun_args will take value
+        {'alpha' : 1.0}.
+
+    max_iter : int, default=200
+        Maximum number of iterations to perform.
+
+    tol : float, default=1e-4
+        A positive scalar giving the tolerance at which the
+        un-mixing matrix is considered to have converged.
+
+    w_init : ndarray of shape (n_components, n_components), default=None
+        Initial un-mixing array. If `w_init=None`, then an array of values
+        drawn from a normal distribution is used.
+
+    whiten_solver : {"eigh", "svd"}, default="svd"
+        The solver to use for whitening.
+
+        - "svd" is more stable numerically if the problem is degenerate, and
+          often faster when `n_samples <= n_features`.
+
+        - "eigh" is generally more memory efficient when
+          `n_samples >= n_features`, and can be faster when
+          `n_samples >= 50 * n_features`.
+
+        .. versionadded:: 1.2
+
+    random_state : int, RandomState instance 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.
+        See :term:`Glossary <random_state>`.
+
+    return_X_mean : bool, default=False
+        If True, X_mean is returned too.
+
+    compute_sources : bool, default=True
+        If False, sources are not computed, but only the rotation matrix.
+        This can save memory when working with big data. Defaults to True.
+
+    return_n_iter : bool, default=False
+        Whether or not to return the number of iterations.
+
+    Returns
+    -------
+    K : ndarray of shape (n_components, n_features) or None
+        If whiten is 'True', K is the pre-whitening matrix that projects data
+        onto the first n_components principal components. If whiten is 'False',
+        K is 'None'.
+
+    W : ndarray of shape (n_components, n_components)
+        The square matrix that unmixes the data after whitening.
+        The mixing matrix is the pseudo-inverse of matrix ``W K``
+        if K is not None, else it is the inverse of W.
+
+    S : ndarray of shape (n_samples, n_components) or None
+        Estimated source matrix.
+
+    X_mean : ndarray of shape (n_features,)
+        The mean over features. Returned only if return_X_mean is True.
+
+    n_iter : int
+        If the algorithm is "deflation", n_iter is the
+        maximum number of iterations run across all components. Else
+        they are just the number of iterations taken to converge. This is
+        returned only when return_n_iter is set to `True`.
+
+    Notes
+    -----
+    The data matrix X is considered to be a linear combination of
+    non-Gaussian (independent) components i.e. X = AS where columns of S
+    contain the independent components and A is a linear mixing
+    matrix. In short ICA attempts to `un-mix' the data by estimating an
+    un-mixing matrix W where ``S = W K X.``
+    While FastICA was proposed to estimate as many sources
+    as features, it is possible to estimate less by setting
+    n_components < n_features. It this case K is not a square matrix
+    and the estimated A is the pseudo-inverse of ``W K``.
+
+    This implementation was originally made for data of shape
+    [n_features, n_samples]. Now the input is transposed
+    before the algorithm is applied. This makes it slightly
+    faster for Fortran-ordered input.
+
+    References
+    ----------
+    .. [1] A. Hyvarinen and E. Oja, "Fast Independent Component Analysis",
+           Algorithms and Applications, Neural Networks, 13(4-5), 2000,
+           pp. 411-430.
+
+    Examples
+    --------
+    >>> from sklearn.datasets import load_digits
+    >>> from sklearn.decomposition import fastica
+    >>> X, _ = load_digits(return_X_y=True)
+    >>> K, W, S = fastica(X, n_components=7, random_state=0, whiten='unit-variance')
+    >>> K.shape
+    (7, 64)
+    >>> W.shape
+    (7, 7)
+    >>> S.shape
+    (1797, 7)
+    """
+    est = FastICA(
+        n_components=n_components,
+        algorithm=algorithm,
+        whiten=whiten,
+        fun=fun,
+        fun_args=fun_args,
+        max_iter=max_iter,
+        tol=tol,
+        w_init=w_init,
+        whiten_solver=whiten_solver,
+        random_state=random_state,
+    )
+    est._validate_params()
+    S = est._fit_transform(X, compute_sources=compute_sources)
+
+    if est.whiten in ["unit-variance", "arbitrary-variance"]:
+        K = est.whitening_
+        X_mean = est.mean_
+    else:
+        K = None
+        X_mean = None
+
+    returned_values = [K, est._unmixing, S]
+    if return_X_mean:
+        returned_values.append(X_mean)
+    if return_n_iter:
+        returned_values.append(est.n_iter_)
+
+    return returned_values
+
+
+class FastICA(ClassNamePrefixFeaturesOutMixin, TransformerMixin, BaseEstimator):
+    """FastICA: a fast algorithm for Independent Component Analysis.
+
+    The implementation is based on [1]_.
+
+    Read more in the :ref:`User Guide <ICA>`.
+
+    Parameters
+    ----------
+    n_components : int, default=None
+        Number of components to use. If None is passed, all are used.
+
+    algorithm : {'parallel', 'deflation'}, default='parallel'
+        Specify which algorithm to use for FastICA.
+
+    whiten : str or bool, default='unit-variance'
+        Specify the whitening strategy to use.
+
+        - If 'arbitrary-variance', a whitening with variance
+          arbitrary is used.
+        - If 'unit-variance', the whitening matrix is rescaled to ensure that
+          each recovered source has unit variance.
+        - If False, the data is already considered to be whitened, and no
+          whitening is performed.
+
+        .. versionchanged:: 1.3
+            The default value of `whiten` changed to 'unit-variance' in 1.3.
+
+    fun : {'logcosh', 'exp', 'cube'} or callable, default='logcosh'
+        The functional form of the G function used in the
+        approximation to neg-entropy. Could be either 'logcosh', 'exp',
+        or 'cube'.
+        You can also provide your own function. It should return a tuple
+        containing the value of the function, and of its derivative, in the
+        point. The derivative should be averaged along its last dimension.
+        Example::
+
+            def my_g(x):
+                return x ** 3, (3 * x ** 2).mean(axis=-1)
+
+    fun_args : dict, default=None
+        Arguments to send to the functional form.
+        If empty or None and if fun='logcosh', fun_args will take value
+        {'alpha' : 1.0}.
+
+    max_iter : int, default=200
+        Maximum number of iterations during fit.
+
+    tol : float, default=1e-4
+        A positive scalar giving the tolerance at which the
+        un-mixing matrix is considered to have converged.
+
+    w_init : array-like of shape (n_components, n_components), default=None
+        Initial un-mixing array. If `w_init=None`, then an array of values
+        drawn from a normal distribution is used.
+
+    whiten_solver : {"eigh", "svd"}, default="svd"
+        The solver to use for whitening.
+
+        - "svd" is more stable numerically if the problem is degenerate, and
+          often faster when `n_samples <= n_features`.
+
+        - "eigh" is generally more memory efficient when
+          `n_samples >= n_features`, and can be faster when
+          `n_samples >= 50 * n_features`.
+
+        .. versionadded:: 1.2
+
+    random_state : int, RandomState instance 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.
+        See :term:`Glossary <random_state>`.
+
+    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 the unmixing matrix when ``whiten`` is
+        False, and equal to ``np.dot(unmixing_matrix, self.whitening_)`` when
+        ``whiten`` is True.
+
+    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.
+
+    mean_ : ndarray of shape(n_features,)
+        The mean over features. Only set if `self.whiten` is True.
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    n_iter_ : int
+        If the algorithm is "deflation", n_iter is the
+        maximum number of iterations run across all components. Else
+        they are just the number of iterations taken to converge.
+
+    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.
+
+    See Also
+    --------
+    PCA : Principal component analysis (PCA).
+    IncrementalPCA : Incremental principal components analysis (IPCA).
+    KernelPCA : Kernel Principal component analysis (KPCA).
+    MiniBatchSparsePCA : Mini-batch Sparse Principal Components Analysis.
+    SparsePCA : Sparse Principal Components Analysis (SparsePCA).
+
+    References
+    ----------
+    .. [1] A. Hyvarinen and E. Oja, Independent Component Analysis:
+           Algorithms and Applications, Neural Networks, 13(4-5), 2000,
+           pp. 411-430.
+
+    Examples
+    --------
+    >>> from sklearn.datasets import load_digits
+    >>> from sklearn.decomposition import FastICA
+    >>> X, _ = load_digits(return_X_y=True)
+    >>> transformer = FastICA(n_components=7,
+    ...         random_state=0,
+    ...         whiten='unit-variance')
+    >>> X_transformed = transformer.fit_transform(X)
+    >>> X_transformed.shape
+    (1797, 7)
+    """
+
+    _parameter_constraints: dict = {
+        "n_components": [Interval(Integral, 1, None, closed="left"), None],
+        "algorithm": [StrOptions({"parallel", "deflation"})],
+        "whiten": [
+            StrOptions({"arbitrary-variance", "unit-variance"}),
+            Options(bool, {False}),
+        ],
+        "fun": [StrOptions({"logcosh", "exp", "cube"}), callable],
+        "fun_args": [dict, None],
+        "max_iter": [Interval(Integral, 1, None, closed="left")],
+        "tol": [Interval(Real, 0.0, None, closed="left")],
+        "w_init": ["array-like", None],
+        "whiten_solver": [StrOptions({"eigh", "svd"})],
+        "random_state": ["random_state"],
+    }
+
+    def __init__(
+        self,
+        n_components=None,
+        *,
+        algorithm="parallel",
+        whiten="unit-variance",
+        fun="logcosh",
+        fun_args=None,
+        max_iter=200,
+        tol=1e-4,
+        w_init=None,
+        whiten_solver="svd",
+        random_state=None,
+    ):
+        super().__init__()
+        self.n_components = n_components
+        self.algorithm = algorithm
+        self.whiten = whiten
+        self.fun = fun
+        self.fun_args = fun_args
+        self.max_iter = max_iter
+        self.tol = tol
+        self.w_init = w_init
+        self.whiten_solver = whiten_solver
+        self.random_state = random_state
+
+    def _fit_transform(self, X, compute_sources=False):
+        """Fit the model.
+
+        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.
+
+        compute_sources : bool, default=False
+            If False, sources are not computes but only the rotation matrix.
+            This can save memory when working with big data. Defaults to False.
+
+        Returns
+        -------
+        S : ndarray of shape (n_samples, n_components) or None
+            Sources matrix. `None` if `compute_sources` is `False`.
+        """
+        XT = self._validate_data(
+            X, copy=self.whiten, dtype=[np.float64, np.float32], ensure_min_samples=2
+        ).T
+        fun_args = {} if self.fun_args is None else self.fun_args
+        random_state = check_random_state(self.random_state)
+
+        alpha = fun_args.get("alpha", 1.0)
+        if not 1 <= alpha <= 2:
+            raise ValueError("alpha must be in [1,2]")
+
+        if self.fun == "logcosh":
+            g = _logcosh
+        elif self.fun == "exp":
+            g = _exp
+        elif self.fun == "cube":
+            g = _cube
+        elif callable(self.fun):
+
+            def g(x, fun_args):
+                return self.fun(x, **fun_args)
+
+        n_features, n_samples = XT.shape
+        n_components = self.n_components
+        if not self.whiten and n_components is not None:
+            n_components = None
+            warnings.warn("Ignoring n_components with whiten=False.")
+
+        if n_components is None:
+            n_components = min(n_samples, n_features)
+        if n_components > min(n_samples, n_features):
+            n_components = min(n_samples, n_features)
+            warnings.warn(
+                "n_components is too large: it will be set to %s" % n_components
+            )
+
+        if self.whiten:
+            # Centering the features of X
+            X_mean = XT.mean(axis=-1)
+            XT -= X_mean[:, np.newaxis]
+
+            # Whitening and preprocessing by PCA
+            if self.whiten_solver == "eigh":
+                # Faster when num_samples >> n_features
+                d, u = linalg.eigh(XT.dot(X))
+                sort_indices = np.argsort(d)[::-1]
+                eps = np.finfo(d.dtype).eps
+                degenerate_idx = d < eps
+                if np.any(degenerate_idx):
+                    warnings.warn(
+                        "There are some small singular values, using "
+                        "whiten_solver = 'svd' might lead to more "
+                        "accurate results."
+                    )
+                d[degenerate_idx] = eps  # For numerical issues
+                np.sqrt(d, out=d)
+                d, u = d[sort_indices], u[:, sort_indices]
+            elif self.whiten_solver == "svd":
+                u, d = linalg.svd(XT, full_matrices=False, check_finite=False)[:2]
+
+            # Give consistent eigenvectors for both svd solvers
+            u *= np.sign(u[0])
+
+            K = (u / d).T[:n_components]  # see (6.33) p.140
+            del u, d
+            X1 = np.dot(K, XT)
+            # see (13.6) p.267 Here X1 is white and data
+            # in X has been projected onto a subspace by PCA
+            X1 *= np.sqrt(n_samples)
+        else:
+            # X must be casted to floats to avoid typing issues with numpy
+            # 2.0 and the line below
+            X1 = as_float_array(XT, copy=False)  # copy has been taken care of
+
+        w_init = self.w_init
+        if w_init is None:
+            w_init = np.asarray(
+                random_state.normal(size=(n_components, n_components)), dtype=X1.dtype
+            )
+
+        else:
+            w_init = np.asarray(w_init)
+            if w_init.shape != (n_components, n_components):
+                raise ValueError(
+                    "w_init has invalid shape -- should be %(shape)s"
+                    % {"shape": (n_components, n_components)}
+                )
+
+        kwargs = {
+            "tol": self.tol,
+            "g": g,
+            "fun_args": fun_args,
+            "max_iter": self.max_iter,
+            "w_init": w_init,
+        }
+
+        if self.algorithm == "parallel":
+            W, n_iter = _ica_par(X1, **kwargs)
+        elif self.algorithm == "deflation":
+            W, n_iter = _ica_def(X1, **kwargs)
+        del X1
+
+        self.n_iter_ = n_iter
+
+        if compute_sources:
+            if self.whiten:
+                S = np.linalg.multi_dot([W, K, XT]).T
+            else:
+                S = np.dot(W, XT).T
+        else:
+            S = None
+
+        if self.whiten:
+            if self.whiten == "unit-variance":
+                if not compute_sources:
+                    S = np.linalg.multi_dot([W, K, XT]).T
+                S_std = np.std(S, axis=0, keepdims=True)
+                S /= S_std
+                W /= S_std.T
+
+            self.components_ = np.dot(W, K)
+            self.mean_ = X_mean
+            self.whitening_ = K
+        else:
+            self.components_ = W
+
+        self.mixing_ = linalg.pinv(self.components_, check_finite=False)
+        self._unmixing = W
+
+        return S
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit_transform(self, X, y=None):
+        """Fit the model and recover the sources from 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 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.
+        """
+        return self._fit_transform(X, compute_sources=True)
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, X, y=None):
+        """Fit the model to 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 for API consistency by convention.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        self._fit_transform(X, compute_sources=False)
+        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 = self._validate_data(
+            X, copy=(copy and self.whiten), dtype=[np.float64, np.float32], reset=False
+        )
+        if self.whiten:
+            X -= self.mean_
+
+        return np.dot(X, self.components_.T)
+
+    def inverse_transform(self, X, copy=True):
+        """Transform the sources back to the mixed data (apply mixing matrix).
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_components)
+            Sources, where `n_samples` is the number of samples
+            and `n_components` is the number of components.
+        copy : bool, default=True
+            If False, data passed to fit are overwritten. Defaults to True.
+
+        Returns
+        -------
+        X_new : ndarray of shape (n_samples, n_features)
+            Reconstructed data obtained with the mixing matrix.
+        """
+        check_is_fitted(self)
+
+        X = check_array(X, copy=(copy and self.whiten), dtype=[np.float64, np.float32])
+        X = np.dot(X, self.mixing_.T)
+        if self.whiten:
+            X += self.mean_
+
+        return X
+
+    @property
+    def _n_features_out(self):
+        """Number of transformed output features."""
+        return self.components_.shape[0]
+
+    def _more_tags(self):
+        return {"preserves_dtype": [np.float32, np.float64]}

venv/lib/python3.10/site-packages/sklearn/decomposition/_incremental_pca.py

@@ -0,0 +1,409 @@
+"""Incremental Principal Components Analysis."""
+
+# Author: Kyle Kastner <[email protected]>
+#         Giorgio Patrini
+# License: BSD 3 clause
+
+from numbers import Integral
+
+import numpy as np
+from scipy import linalg, sparse
+
+from ..base import _fit_context
+from ..utils import gen_batches
+from ..utils._param_validation import Interval
+from ..utils.extmath import _incremental_mean_and_var, svd_flip
+from ._base import _BasePCA
+
+
+class IncrementalPCA(_BasePCA):
+    """Incremental principal components analysis (IPCA).
+
+    Linear dimensionality reduction using Singular Value Decomposition of
+    the data, keeping only the most significant singular vectors to
+    project the data to a lower dimensional space. The input data is centered
+    but not scaled for each feature before applying the SVD.
+
+    Depending on the size of the input data, this algorithm can be much more
+    memory efficient than a PCA, and allows sparse input.
+
+    This algorithm has constant memory complexity, on the order
+    of ``batch_size * n_features``, enabling use of np.memmap files without
+    loading the entire file into memory. For sparse matrices, the input
+    is converted to dense in batches (in order to be able to subtract the
+    mean) which avoids storing the entire dense matrix at any one time.
+
+    The computational overhead of each SVD is
+    ``O(batch_size * n_features ** 2)``, but only 2 * batch_size samples
+    remain in memory at a time. There will be ``n_samples / batch_size`` SVD
+    computations to get the principal components, versus 1 large SVD of
+    complexity ``O(n_samples * n_features ** 2)`` for PCA.
+
+    For a usage example, see
+    :ref:`sphx_glr_auto_examples_decomposition_plot_incremental_pca.py`.
+
+    Read more in the :ref:`User Guide <IncrementalPCA>`.
+
+    .. versionadded:: 0.16
+
+    Parameters
+    ----------
+    n_components : int, default=None
+        Number of components to keep. If ``n_components`` is ``None``,
+        then ``n_components`` is set to ``min(n_samples, n_features)``.
+
+    whiten : bool, default=False
+        When True (False by default) the ``components_`` vectors are divided
+        by ``n_samples`` times ``components_`` to ensure uncorrelated outputs
+        with unit component-wise variances.
+
+        Whitening will remove some information from the transformed signal
+        (the relative variance scales of the components) but can sometimes
+        improve the predictive accuracy of the downstream estimators by
+        making data respect some hard-wired assumptions.
+
+    copy : bool, default=True
+        If False, X will be overwritten. ``copy=False`` can be used to
+        save memory but is unsafe for general use.
+
+    batch_size : int, default=None
+        The number of samples to use for each batch. Only used when calling
+        ``fit``. If ``batch_size`` is ``None``, then ``batch_size``
+        is inferred from the data and set to ``5 * n_features``, to provide a
+        balance between approximation accuracy and memory consumption.
+
+    Attributes
+    ----------
+    components_ : ndarray of shape (n_components, n_features)
+        Principal axes in feature space, representing the directions of
+        maximum variance in the data. Equivalently, the right singular
+        vectors of the centered input data, parallel to its eigenvectors.
+        The components are sorted by decreasing ``explained_variance_``.
+
+    explained_variance_ : ndarray of shape (n_components,)
+        Variance explained by each of the selected components.
+
+    explained_variance_ratio_ : ndarray of shape (n_components,)
+        Percentage of variance explained by each of the selected components.
+        If all components are stored, the sum of explained variances is equal
+        to 1.0.
+
+    singular_values_ : ndarray of shape (n_components,)
+        The singular values corresponding to each of the selected components.
+        The singular values are equal to the 2-norms of the ``n_components``
+        variables in the lower-dimensional space.
+
+    mean_ : ndarray of shape (n_features,)
+        Per-feature empirical mean, aggregate over calls to ``partial_fit``.
+
+    var_ : ndarray of shape (n_features,)
+        Per-feature empirical variance, aggregate over calls to
+        ``partial_fit``.
+
+    noise_variance_ : float
+        The estimated noise covariance following the Probabilistic PCA model
+        from Tipping and Bishop 1999. See "Pattern Recognition and
+        Machine Learning" by C. Bishop, 12.2.1 p. 574 or
+        http://www.miketipping.com/papers/met-mppca.pdf.
+
+    n_components_ : int
+        The estimated number of components. Relevant when
+        ``n_components=None``.
+
+    n_samples_seen_ : int
+        The number of samples processed by the estimator. Will be reset on
+        new calls to fit, but increments across ``partial_fit`` calls.
+
+    batch_size_ : int
+        Inferred batch size from ``batch_size``.
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    See Also
+    --------
+    PCA : Principal component analysis (PCA).
+    KernelPCA : Kernel Principal component analysis (KPCA).
+    SparsePCA : Sparse Principal Components Analysis (SparsePCA).
+    TruncatedSVD : Dimensionality reduction using truncated SVD.
+
+    Notes
+    -----
+    Implements the incremental PCA model from:
+    *D. Ross, J. Lim, R. Lin, M. Yang, Incremental Learning for Robust Visual
+    Tracking, International Journal of Computer Vision, Volume 77, Issue 1-3,
+    pp. 125-141, May 2008.*
+    See https://www.cs.toronto.edu/~dross/ivt/RossLimLinYang_ijcv.pdf
+
+    This model is an extension of the Sequential Karhunen-Loeve Transform from:
+    :doi:`A. Levy and M. Lindenbaum, Sequential Karhunen-Loeve Basis Extraction and
+    its Application to Images, IEEE Transactions on Image Processing, Volume 9,
+    Number 8, pp. 1371-1374, August 2000. <10.1109/83.855432>`
+
+    We have specifically abstained from an optimization used by authors of both
+    papers, a QR decomposition used in specific situations to reduce the
+    algorithmic complexity of the SVD. The source for this technique is
+    *Matrix Computations, Third Edition, G. Holub and C. Van Loan, Chapter 5,
+    section 5.4.4, pp 252-253.*. This technique has been omitted because it is
+    advantageous only when decomposing a matrix with ``n_samples`` (rows)
+    >= 5/3 * ``n_features`` (columns), and hurts the readability of the
+    implemented algorithm. This would be a good opportunity for future
+    optimization, if it is deemed necessary.
+
+    References
+    ----------
+    D. Ross, J. Lim, R. Lin, M. Yang. Incremental Learning for Robust Visual
+    Tracking, International Journal of Computer Vision, Volume 77,
+    Issue 1-3, pp. 125-141, May 2008.
+
+    G. Golub and C. Van Loan. Matrix Computations, Third Edition, Chapter 5,
+    Section 5.4.4, pp. 252-253.
+
+    Examples
+    --------
+    >>> from sklearn.datasets import load_digits
+    >>> from sklearn.decomposition import IncrementalPCA
+    >>> from scipy import sparse
+    >>> X, _ = load_digits(return_X_y=True)
+    >>> transformer = IncrementalPCA(n_components=7, batch_size=200)
+    >>> # either partially fit on smaller batches of data
+    >>> transformer.partial_fit(X[:100, :])
+    IncrementalPCA(batch_size=200, n_components=7)
+    >>> # or let the fit function itself divide the data into batches
+    >>> X_sparse = sparse.csr_matrix(X)
+    >>> X_transformed = transformer.fit_transform(X_sparse)
+    >>> X_transformed.shape
+    (1797, 7)
+    """
+
+    _parameter_constraints: dict = {
+        "n_components": [Interval(Integral, 1, None, closed="left"), None],
+        "whiten": ["boolean"],
+        "copy": ["boolean"],
+        "batch_size": [Interval(Integral, 1, None, closed="left"), None],
+    }
+
+    def __init__(self, n_components=None, *, whiten=False, copy=True, batch_size=None):
+        self.n_components = n_components
+        self.whiten = whiten
+        self.copy = copy
+        self.batch_size = batch_size
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, X, y=None):
+        """Fit the model with X, using minibatches of size batch_size.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} 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 for API consistency by convention.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        self.components_ = None
+        self.n_samples_seen_ = 0
+        self.mean_ = 0.0
+        self.var_ = 0.0
+        self.singular_values_ = None
+        self.explained_variance_ = None
+        self.explained_variance_ratio_ = None
+        self.noise_variance_ = None
+
+        X = self._validate_data(
+            X,
+            accept_sparse=["csr", "csc", "lil"],
+            copy=self.copy,
+            dtype=[np.float64, np.float32],
+        )
+        n_samples, n_features = X.shape
+
+        if self.batch_size is None:
+            self.batch_size_ = 5 * n_features
+        else:
+            self.batch_size_ = self.batch_size
+
+        for batch in gen_batches(
+            n_samples, self.batch_size_, min_batch_size=self.n_components or 0
+        ):
+            X_batch = X[batch]
+            if sparse.issparse(X_batch):
+                X_batch = X_batch.toarray()
+            self.partial_fit(X_batch, check_input=False)
+
+        return self
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def partial_fit(self, X, y=None, check_input=True):
+        """Incremental fit with X. All of X is processed as a single batch.
+
+        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 for API consistency by convention.
+
+        check_input : bool, default=True
+            Run check_array on X.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        first_pass = not hasattr(self, "components_")
+
+        if check_input:
+            if sparse.issparse(X):
+                raise TypeError(
+                    "IncrementalPCA.partial_fit does not support "
+                    "sparse input. Either convert data to dense "
+                    "or use IncrementalPCA.fit to do so in batches."
+                )
+            X = self._validate_data(
+                X, copy=self.copy, dtype=[np.float64, np.float32], reset=first_pass
+            )
+        n_samples, n_features = X.shape
+        if first_pass:
+            self.components_ = None
+
+        if self.n_components is None:
+            if self.components_ is None:
+                self.n_components_ = min(n_samples, n_features)
+            else:
+                self.n_components_ = self.components_.shape[0]
+        elif not self.n_components <= n_features:
+            raise ValueError(
+                "n_components=%r invalid for n_features=%d, need "
+                "more rows than columns for IncrementalPCA "
+                "processing" % (self.n_components, n_features)
+            )
+        elif not self.n_components <= n_samples:
+            raise ValueError(
+                "n_components=%r must be less or equal to "
+                "the batch number of samples "
+                "%d." % (self.n_components, n_samples)
+            )
+        else:
+            self.n_components_ = self.n_components
+
+        if (self.components_ is not None) and (
+            self.components_.shape[0] != self.n_components_
+        ):
+            raise ValueError(
+                "Number of input features has changed from %i "
+                "to %i between calls to partial_fit! Try "
+                "setting n_components to a fixed value."
+                % (self.components_.shape[0], self.n_components_)
+            )
+
+        # This is the first partial_fit
+        if not hasattr(self, "n_samples_seen_"):
+            self.n_samples_seen_ = 0
+            self.mean_ = 0.0
+            self.var_ = 0.0
+
+        # Update stats - they are 0 if this is the first step
+        col_mean, col_var, n_total_samples = _incremental_mean_and_var(
+            X,
+            last_mean=self.mean_,
+            last_variance=self.var_,
+            last_sample_count=np.repeat(self.n_samples_seen_, X.shape[1]),
+        )
+        n_total_samples = n_total_samples[0]
+
+        # Whitening
+        if self.n_samples_seen_ == 0:
+            # If it is the first step, simply whiten X
+            X -= col_mean
+        else:
+            col_batch_mean = np.mean(X, axis=0)
+            X -= col_batch_mean
+            # Build matrix of combined previous basis and new data
+            mean_correction = np.sqrt(
+                (self.n_samples_seen_ / n_total_samples) * n_samples
+            ) * (self.mean_ - col_batch_mean)
+            X = np.vstack(
+                (
+                    self.singular_values_.reshape((-1, 1)) * self.components_,
+                    X,
+                    mean_correction,
+                )
+            )
+
+        U, S, Vt = linalg.svd(X, full_matrices=False, check_finite=False)
+        U, Vt = svd_flip(U, Vt, u_based_decision=False)
+        explained_variance = S**2 / (n_total_samples - 1)
+        explained_variance_ratio = S**2 / np.sum(col_var * n_total_samples)
+
+        self.n_samples_seen_ = n_total_samples
+        self.components_ = Vt[: self.n_components_]
+        self.singular_values_ = S[: self.n_components_]
+        self.mean_ = col_mean
+        self.var_ = col_var
+        self.explained_variance_ = explained_variance[: self.n_components_]
+        self.explained_variance_ratio_ = explained_variance_ratio[: self.n_components_]
+        # we already checked `self.n_components <= n_samples` above
+        if self.n_components_ not in (n_samples, n_features):
+            self.noise_variance_ = explained_variance[self.n_components_ :].mean()
+        else:
+            self.noise_variance_ = 0.0
+        return self
+
+    def transform(self, X):
+        """Apply dimensionality reduction to X.
+
+        X is projected on the first principal components previously extracted
+        from a training set, using minibatches of size batch_size if X is
+        sparse.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            New data, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+
+        Returns
+        -------
+        X_new : ndarray of shape (n_samples, n_components)
+            Projection of X in the first principal components.
+
+        Examples
+        --------
+
+        >>> import numpy as np
+        >>> from sklearn.decomposition import IncrementalPCA
+        >>> X = np.array([[-1, -1], [-2, -1], [-3, -2],
+        ...               [1, 1], [2, 1], [3, 2]])
+        >>> ipca = IncrementalPCA(n_components=2, batch_size=3)
+        >>> ipca.fit(X)
+        IncrementalPCA(batch_size=3, n_components=2)
+        >>> ipca.transform(X) # doctest: +SKIP
+        """
+        if sparse.issparse(X):
+            n_samples = X.shape[0]
+            output = []
+            for batch in gen_batches(
+                n_samples, self.batch_size_, min_batch_size=self.n_components or 0
+            ):
+                output.append(super().transform(X[batch].toarray()))
+            return np.vstack(output)
+        else:
+            return super().transform(X)

venv/lib/python3.10/site-packages/sklearn/decomposition/_kernel_pca.py

@@ -0,0 +1,572 @@
+"""Kernel Principal Components Analysis."""
+
+# Author: Mathieu Blondel <[email protected]>
+#         Sylvain Marie <[email protected]>
+# License: BSD 3 clause
+
+from numbers import Integral, Real
+
+import numpy as np
+from scipy import linalg
+from scipy.linalg import eigh
+from scipy.sparse.linalg import eigsh
+
+from ..base import (
+    BaseEstimator,
+    ClassNamePrefixFeaturesOutMixin,
+    TransformerMixin,
+    _fit_context,
+)
+from ..exceptions import NotFittedError
+from ..metrics.pairwise import pairwise_kernels
+from ..preprocessing import KernelCenterer
+from ..utils._arpack import _init_arpack_v0
+from ..utils._param_validation import Interval, StrOptions
+from ..utils.extmath import _randomized_eigsh, svd_flip
+from ..utils.validation import (
+    _check_psd_eigenvalues,
+    check_is_fitted,
+)
+
+
+class KernelPCA(ClassNamePrefixFeaturesOutMixin, TransformerMixin, BaseEstimator):
+    """Kernel Principal component analysis (KPCA) [1]_.
+
+    Non-linear dimensionality reduction through the use of kernels (see
+    :ref:`metrics`).
+
+    It uses the :func:`scipy.linalg.eigh` LAPACK implementation of the full SVD
+    or the :func:`scipy.sparse.linalg.eigsh` ARPACK implementation of the
+    truncated SVD, depending on the shape of the input data and the number of
+    components to extract. It can also use a randomized truncated SVD by the
+    method proposed in [3]_, see `eigen_solver`.
+
+    For a usage example, see
+    :ref:`sphx_glr_auto_examples_decomposition_plot_kernel_pca.py`.
+
+    Read more in the :ref:`User Guide <kernel_PCA>`.
+
+    Parameters
+    ----------
+    n_components : int, default=None
+        Number of components. If None, all non-zero components are kept.
+
+    kernel : {'linear', 'poly', 'rbf', 'sigmoid', 'cosine', 'precomputed'} \
+            or callable, default='linear'
+        Kernel used for PCA.
+
+    gamma : float, default=None
+        Kernel coefficient for rbf, poly and sigmoid kernels. Ignored by other
+        kernels. If ``gamma`` is ``None``, then it is set to ``1/n_features``.
+
+    degree : float, default=3
+        Degree for poly kernels. Ignored by other kernels.
+
+    coef0 : float, default=1
+        Independent term in poly and sigmoid kernels.
+        Ignored by other kernels.
+
+    kernel_params : dict, default=None
+        Parameters (keyword arguments) and
+        values for kernel passed as callable object.
+        Ignored by other kernels.
+
+    alpha : float, default=1.0
+        Hyperparameter of the ridge regression that learns the
+        inverse transform (when fit_inverse_transform=True).
+
+    fit_inverse_transform : bool, default=False
+        Learn the inverse transform for non-precomputed kernels
+        (i.e. learn to find the pre-image of a point). This method is based
+        on [2]_.
+
+    eigen_solver : {'auto', 'dense', 'arpack', 'randomized'}, \
+            default='auto'
+        Select eigensolver to use. If `n_components` is much
+        less than the number of training samples, randomized (or arpack to a
+        smaller extent) may be more efficient than the dense eigensolver.
+        Randomized SVD is performed according to the method of Halko et al
+        [3]_.
+
+        auto :
+            the solver is selected by a default policy based on n_samples
+            (the number of training samples) and `n_components`:
+            if the number of components to extract is less than 10 (strict) and
+            the number of samples is more than 200 (strict), the 'arpack'
+            method is enabled. Otherwise the exact full eigenvalue
+            decomposition is computed and optionally truncated afterwards
+            ('dense' method).
+        dense :
+            run exact full eigenvalue decomposition calling the standard
+            LAPACK solver via `scipy.linalg.eigh`, and select the components
+            by postprocessing
+        arpack :
+            run SVD truncated to n_components calling ARPACK solver using
+            `scipy.sparse.linalg.eigsh`. It requires strictly
+            0 < n_components < n_samples
+        randomized :
+            run randomized SVD by the method of Halko et al. [3]_. The current
+            implementation selects eigenvalues based on their module; therefore
+            using this method can lead to unexpected results if the kernel is
+            not positive semi-definite. See also [4]_.
+
+        .. versionchanged:: 1.0
+           `'randomized'` was added.
+
+    tol : float, default=0
+        Convergence tolerance for arpack.
+        If 0, optimal value will be chosen by arpack.
+
+    max_iter : int, default=None
+        Maximum number of iterations for arpack.
+        If None, optimal value will be chosen by arpack.
+
+    iterated_power : int >= 0, or 'auto', default='auto'
+        Number of iterations for the power method computed by
+        svd_solver == 'randomized'. When 'auto', it is set to 7 when
+        `n_components < 0.1 * min(X.shape)`, other it is set to 4.
+
+        .. versionadded:: 1.0
+
+    remove_zero_eig : bool, default=False
+        If True, then all components with zero eigenvalues are removed, so
+        that the number of components in the output may be < n_components
+        (and sometimes even zero due to numerical instability).
+        When n_components is None, this parameter is ignored and components
+        with zero eigenvalues are removed regardless.
+
+    random_state : int, RandomState instance or None, default=None
+        Used when ``eigen_solver`` == 'arpack' or 'randomized'. Pass an int
+        for reproducible results across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+        .. versionadded:: 0.18
+
+    copy_X : bool, default=True
+        If True, input X is copied and stored by the model in the `X_fit_`
+        attribute. If no further changes will be done to X, setting
+        `copy_X=False` saves memory by storing a reference.
+
+        .. versionadded:: 0.18
+
+    n_jobs : int, default=None
+        The number of parallel jobs to run.
+        ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.
+        ``-1`` means using all processors. See :term:`Glossary <n_jobs>`
+        for more details.
+
+        .. versionadded:: 0.18
+
+    Attributes
+    ----------
+    eigenvalues_ : ndarray of shape (n_components,)
+        Eigenvalues of the centered kernel matrix in decreasing order.
+        If `n_components` and `remove_zero_eig` are not set,
+        then all values are stored.
+
+    eigenvectors_ : ndarray of shape (n_samples, n_components)
+        Eigenvectors of the centered kernel matrix. If `n_components` and
+        `remove_zero_eig` are not set, then all components are stored.
+
+    dual_coef_ : ndarray of shape (n_samples, n_features)
+        Inverse transform matrix. Only available when
+        ``fit_inverse_transform`` is True.
+
+    X_transformed_fit_ : ndarray of shape (n_samples, n_components)
+        Projection of the fitted data on the kernel principal components.
+        Only available when ``fit_inverse_transform`` is True.
+
+    X_fit_ : ndarray of shape (n_samples, n_features)
+        The data used to fit the model. If `copy_X=False`, then `X_fit_` is
+        a reference. This attribute is used for the calls to transform.
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    gamma_ : float
+        Kernel coefficient for rbf, poly and sigmoid kernels. When `gamma`
+        is explicitly provided, this is just the same as `gamma`. When `gamma`
+        is `None`, this is the actual value of kernel coefficient.
+
+        .. versionadded:: 1.3
+
+    See Also
+    --------
+    FastICA : A fast algorithm for Independent Component Analysis.
+    IncrementalPCA : Incremental Principal Component Analysis.
+    NMF : Non-Negative Matrix Factorization.
+    PCA : Principal Component Analysis.
+    SparsePCA : Sparse Principal Component Analysis.
+    TruncatedSVD : Dimensionality reduction using truncated SVD.
+
+    References
+    ----------
+    .. [1] `Schölkopf, Bernhard, Alexander Smola, and Klaus-Robert Müller.
+       "Kernel principal component analysis."
+       International conference on artificial neural networks.
+       Springer, Berlin, Heidelberg, 1997.
+       <https://people.eecs.berkeley.edu/~wainwrig/stat241b/scholkopf_kernel.pdf>`_
+
+    .. [2] `Bakır, Gökhan H., Jason Weston, and Bernhard Schölkopf.
+       "Learning to find pre-images."
+       Advances in neural information processing systems 16 (2004): 449-456.
+       <https://papers.nips.cc/paper/2003/file/ac1ad983e08ad3304a97e147f522747e-Paper.pdf>`_
+
+    .. [3] :arxiv:`Halko, Nathan, Per-Gunnar Martinsson, and Joel A. Tropp.
+       "Finding structure with randomness: Probabilistic algorithms for
+       constructing approximate matrix decompositions."
+       SIAM review 53.2 (2011): 217-288. <0909.4061>`
+
+    .. [4] `Martinsson, Per-Gunnar, Vladimir Rokhlin, and Mark Tygert.
+       "A randomized algorithm for the decomposition of matrices."
+       Applied and Computational Harmonic Analysis 30.1 (2011): 47-68.
+       <https://www.sciencedirect.com/science/article/pii/S1063520310000242>`_
+
+    Examples
+    --------
+    >>> from sklearn.datasets import load_digits
+    >>> from sklearn.decomposition import KernelPCA
+    >>> X, _ = load_digits(return_X_y=True)
+    >>> transformer = KernelPCA(n_components=7, kernel='linear')
+    >>> X_transformed = transformer.fit_transform(X)
+    >>> X_transformed.shape
+    (1797, 7)
+    """
+
+    _parameter_constraints: dict = {
+        "n_components": [
+            Interval(Integral, 1, None, closed="left"),
+            None,
+        ],
+        "kernel": [
+            StrOptions({"linear", "poly", "rbf", "sigmoid", "cosine", "precomputed"}),
+            callable,
+        ],
+        "gamma": [
+            Interval(Real, 0, None, closed="left"),
+            None,
+        ],
+        "degree": [Interval(Real, 0, None, closed="left")],
+        "coef0": [Interval(Real, None, None, closed="neither")],
+        "kernel_params": [dict, None],
+        "alpha": [Interval(Real, 0, None, closed="left")],
+        "fit_inverse_transform": ["boolean"],
+        "eigen_solver": [StrOptions({"auto", "dense", "arpack", "randomized"})],
+        "tol": [Interval(Real, 0, None, closed="left")],
+        "max_iter": [
+            Interval(Integral, 1, None, closed="left"),
+            None,
+        ],
+        "iterated_power": [
+            Interval(Integral, 0, None, closed="left"),
+            StrOptions({"auto"}),
+        ],
+        "remove_zero_eig": ["boolean"],
+        "random_state": ["random_state"],
+        "copy_X": ["boolean"],
+        "n_jobs": [None, Integral],
+    }
+
+    def __init__(
+        self,
+        n_components=None,
+        *,
+        kernel="linear",
+        gamma=None,
+        degree=3,
+        coef0=1,
+        kernel_params=None,
+        alpha=1.0,
+        fit_inverse_transform=False,
+        eigen_solver="auto",
+        tol=0,
+        max_iter=None,
+        iterated_power="auto",
+        remove_zero_eig=False,
+        random_state=None,
+        copy_X=True,
+        n_jobs=None,
+    ):
+        self.n_components = n_components
+        self.kernel = kernel
+        self.kernel_params = kernel_params
+        self.gamma = gamma
+        self.degree = degree
+        self.coef0 = coef0
+        self.alpha = alpha
+        self.fit_inverse_transform = fit_inverse_transform
+        self.eigen_solver = eigen_solver
+        self.tol = tol
+        self.max_iter = max_iter
+        self.iterated_power = iterated_power
+        self.remove_zero_eig = remove_zero_eig
+        self.random_state = random_state
+        self.n_jobs = n_jobs
+        self.copy_X = copy_X
+
+    def _get_kernel(self, X, Y=None):
+        if callable(self.kernel):
+            params = self.kernel_params or {}
+        else:
+            params = {"gamma": self.gamma_, "degree": self.degree, "coef0": self.coef0}
+        return pairwise_kernels(
+            X, Y, metric=self.kernel, filter_params=True, n_jobs=self.n_jobs, **params
+        )
+
+    def _fit_transform(self, K):
+        """Fit's using kernel K"""
+        # center kernel
+        K = self._centerer.fit_transform(K)
+
+        # adjust n_components according to user inputs
+        if self.n_components is None:
+            n_components = K.shape[0]  # use all dimensions
+        else:
+            n_components = min(K.shape[0], self.n_components)
+
+        # compute eigenvectors
+        if self.eigen_solver == "auto":
+            if K.shape[0] > 200 and n_components < 10:
+                eigen_solver = "arpack"
+            else:
+                eigen_solver = "dense"
+        else:
+            eigen_solver = self.eigen_solver
+
+        if eigen_solver == "dense":
+            # Note: subset_by_index specifies the indices of smallest/largest to return
+            self.eigenvalues_, self.eigenvectors_ = eigh(
+                K, subset_by_index=(K.shape[0] - n_components, K.shape[0] - 1)
+            )
+        elif eigen_solver == "arpack":
+            v0 = _init_arpack_v0(K.shape[0], self.random_state)
+            self.eigenvalues_, self.eigenvectors_ = eigsh(
+                K, n_components, which="LA", tol=self.tol, maxiter=self.max_iter, v0=v0
+            )
+        elif eigen_solver == "randomized":
+            self.eigenvalues_, self.eigenvectors_ = _randomized_eigsh(
+                K,
+                n_components=n_components,
+                n_iter=self.iterated_power,
+                random_state=self.random_state,
+                selection="module",
+            )
+
+        # make sure that the eigenvalues are ok and fix numerical issues
+        self.eigenvalues_ = _check_psd_eigenvalues(
+            self.eigenvalues_, enable_warnings=False
+        )
+
+        # flip eigenvectors' sign to enforce deterministic output
+        self.eigenvectors_, _ = svd_flip(
+            self.eigenvectors_, np.zeros_like(self.eigenvectors_).T
+        )
+
+        # sort eigenvectors in descending order
+        indices = self.eigenvalues_.argsort()[::-1]
+        self.eigenvalues_ = self.eigenvalues_[indices]
+        self.eigenvectors_ = self.eigenvectors_[:, indices]
+
+        # remove eigenvectors with a zero eigenvalue (null space) if required
+        if self.remove_zero_eig or self.n_components is None:
+            self.eigenvectors_ = self.eigenvectors_[:, self.eigenvalues_ > 0]
+            self.eigenvalues_ = self.eigenvalues_[self.eigenvalues_ > 0]
+
+        # Maintenance note on Eigenvectors normalization
+        # ----------------------------------------------
+        # there is a link between
+        # the eigenvectors of K=Phi(X)'Phi(X) and the ones of Phi(X)Phi(X)'
+        # if v is an eigenvector of K
+        #     then Phi(X)v  is an eigenvector of Phi(X)Phi(X)'
+        # if u is an eigenvector of Phi(X)Phi(X)'
+        #     then Phi(X)'u is an eigenvector of Phi(X)'Phi(X)
+        #
+        # At this stage our self.eigenvectors_ (the v) have norm 1, we need to scale
+        # them so that eigenvectors in kernel feature space (the u) have norm=1
+        # instead
+        #
+        # We COULD scale them here:
+        #       self.eigenvectors_ = self.eigenvectors_ / np.sqrt(self.eigenvalues_)
+        #
+        # But choose to perform that LATER when needed, in `fit()` and in
+        # `transform()`.
+
+        return K
+
+    def _fit_inverse_transform(self, X_transformed, X):
+        if hasattr(X, "tocsr"):
+            raise NotImplementedError(
+                "Inverse transform not implemented for sparse matrices!"
+            )
+
+        n_samples = X_transformed.shape[0]
+        K = self._get_kernel(X_transformed)
+        K.flat[:: n_samples + 1] += self.alpha
+        self.dual_coef_ = linalg.solve(K, X, assume_a="pos", overwrite_a=True)
+        self.X_transformed_fit_ = X_transformed
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, X, y=None):
+        """Fit the model from data in X.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            Training vector, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        if self.fit_inverse_transform and self.kernel == "precomputed":
+            raise ValueError("Cannot fit_inverse_transform with a precomputed kernel.")
+        X = self._validate_data(X, accept_sparse="csr", copy=self.copy_X)
+        self.gamma_ = 1 / X.shape[1] if self.gamma is None else self.gamma
+        self._centerer = KernelCenterer().set_output(transform="default")
+        K = self._get_kernel(X)
+        self._fit_transform(K)
+
+        if self.fit_inverse_transform:
+            # no need to use the kernel to transform X, use shortcut expression
+            X_transformed = self.eigenvectors_ * np.sqrt(self.eigenvalues_)
+
+            self._fit_inverse_transform(X_transformed, X)
+
+        self.X_fit_ = X
+        return self
+
+    def fit_transform(self, X, y=None, **params):
+        """Fit the model from data in X and transform X.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            Training vector, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        **params : kwargs
+            Parameters (keyword arguments) and values passed to
+            the fit_transform instance.
+
+        Returns
+        -------
+        X_new : ndarray of shape (n_samples, n_components)
+            Returns the instance itself.
+        """
+        self.fit(X, **params)
+
+        # no need to use the kernel to transform X, use shortcut expression
+        X_transformed = self.eigenvectors_ * np.sqrt(self.eigenvalues_)
+
+        if self.fit_inverse_transform:
+            self._fit_inverse_transform(X_transformed, X)
+
+        return X_transformed
+
+    def transform(self, X):
+        """Transform X.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            Training vector, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+
+        Returns
+        -------
+        X_new : ndarray of shape (n_samples, n_components)
+            Returns the instance itself.
+        """
+        check_is_fitted(self)
+        X = self._validate_data(X, accept_sparse="csr", reset=False)
+
+        # Compute centered gram matrix between X and training data X_fit_
+        K = self._centerer.transform(self._get_kernel(X, self.X_fit_))
+
+        # scale eigenvectors (properly account for null-space for dot product)
+        non_zeros = np.flatnonzero(self.eigenvalues_)
+        scaled_alphas = np.zeros_like(self.eigenvectors_)
+        scaled_alphas[:, non_zeros] = self.eigenvectors_[:, non_zeros] / np.sqrt(
+            self.eigenvalues_[non_zeros]
+        )
+
+        # Project with a scalar product between K and the scaled eigenvectors
+        return np.dot(K, scaled_alphas)
+
+    def inverse_transform(self, X):
+        """Transform X back to original space.
+
+        ``inverse_transform`` approximates the inverse transformation using
+        a learned pre-image. The pre-image is learned by kernel ridge
+        regression of the original data on their low-dimensional representation
+        vectors.
+
+        .. note:
+            :meth:`~sklearn.decomposition.fit` internally uses a centered
+            kernel. As the centered kernel no longer contains the information
+            of the mean of kernel features, such information is not taken into
+            account in reconstruction.
+
+        .. note::
+            When users want to compute inverse transformation for 'linear'
+            kernel, it is recommended that they use
+            :class:`~sklearn.decomposition.PCA` instead. Unlike
+            :class:`~sklearn.decomposition.PCA`,
+            :class:`~sklearn.decomposition.KernelPCA`'s ``inverse_transform``
+            does not reconstruct the mean of data when 'linear' kernel is used
+            due to the use of centered kernel.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_components)
+            Training vector, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+
+        Returns
+        -------
+        X_new : ndarray of shape (n_samples, n_features)
+            Returns the instance itself.
+
+        References
+        ----------
+        `Bakır, Gökhan H., Jason Weston, and Bernhard Schölkopf.
+        "Learning to find pre-images."
+        Advances in neural information processing systems 16 (2004): 449-456.
+        <https://papers.nips.cc/paper/2003/file/ac1ad983e08ad3304a97e147f522747e-Paper.pdf>`_
+        """
+        if not self.fit_inverse_transform:
+            raise NotFittedError(
+                "The fit_inverse_transform parameter was not"
+                " set to True when instantiating and hence "
+                "the inverse transform is not available."
+            )
+
+        K = self._get_kernel(X, self.X_transformed_fit_)
+        return np.dot(K, self.dual_coef_)
+
+    def _more_tags(self):
+        return {
+            "preserves_dtype": [np.float64, np.float32],
+            "pairwise": self.kernel == "precomputed",
+        }
+
+    @property
+    def _n_features_out(self):
+        """Number of transformed output features."""
+        return self.eigenvalues_.shape[0]

venv/lib/python3.10/site-packages/sklearn/decomposition/_lda.py

@@ -0,0 +1,929 @@
+"""
+
+=============================================================
+Online Latent Dirichlet Allocation with variational inference
+=============================================================
+
+This implementation is modified from Matthew D. Hoffman's onlineldavb code
+Link: https://github.com/blei-lab/onlineldavb
+"""
+
+# Author: Chyi-Kwei Yau
+# Author: Matthew D. Hoffman (original onlineldavb implementation)
+from numbers import Integral, Real
+
+import numpy as np
+import scipy.sparse as sp
+from joblib import effective_n_jobs
+from scipy.special import gammaln, logsumexp
+
+from ..base import (
+    BaseEstimator,
+    ClassNamePrefixFeaturesOutMixin,
+    TransformerMixin,
+    _fit_context,
+)
+from ..utils import check_random_state, gen_batches, gen_even_slices
+from ..utils._param_validation import Interval, StrOptions
+from ..utils.parallel import Parallel, delayed
+from ..utils.validation import check_is_fitted, check_non_negative
+from ._online_lda_fast import (
+    _dirichlet_expectation_1d as cy_dirichlet_expectation_1d,
+)
+from ._online_lda_fast import (
+    _dirichlet_expectation_2d,
+)
+from ._online_lda_fast import (
+    mean_change as cy_mean_change,
+)
+
+EPS = np.finfo(float).eps
+
+
+def _update_doc_distribution(
+    X,
+    exp_topic_word_distr,
+    doc_topic_prior,
+    max_doc_update_iter,
+    mean_change_tol,
+    cal_sstats,
+    random_state,
+):
+    """E-step: update document-topic distribution.
+
+    Parameters
+    ----------
+    X : {array-like, sparse matrix} of shape (n_samples, n_features)
+        Document word matrix.
+
+    exp_topic_word_distr : ndarray of shape (n_topics, n_features)
+        Exponential value of expectation of log topic word distribution.
+        In the literature, this is `exp(E[log(beta)])`.
+
+    doc_topic_prior : float
+        Prior of document topic distribution `theta`.
+
+    max_doc_update_iter : int
+        Max number of iterations for updating document topic distribution in
+        the E-step.
+
+    mean_change_tol : float
+        Stopping tolerance for updating document topic distribution in E-step.
+
+    cal_sstats : bool
+        Parameter that indicate to calculate sufficient statistics or not.
+        Set `cal_sstats` to `True` when we need to run M-step.
+
+    random_state : RandomState instance or None
+        Parameter that indicate how to initialize document topic distribution.
+        Set `random_state` to None will initialize document topic distribution
+        to a constant number.
+
+    Returns
+    -------
+    (doc_topic_distr, suff_stats) :
+        `doc_topic_distr` is unnormalized topic distribution for each document.
+        In the literature, this is `gamma`. we can calculate `E[log(theta)]`
+        from it.
+        `suff_stats` is expected sufficient statistics for the M-step.
+            When `cal_sstats == False`, this will be None.
+
+    """
+    is_sparse_x = sp.issparse(X)
+    n_samples, n_features = X.shape
+    n_topics = exp_topic_word_distr.shape[0]
+
+    if random_state:
+        doc_topic_distr = random_state.gamma(100.0, 0.01, (n_samples, n_topics)).astype(
+            X.dtype, copy=False
+        )
+    else:
+        doc_topic_distr = np.ones((n_samples, n_topics), dtype=X.dtype)
+
+    # In the literature, this is `exp(E[log(theta)])`
+    exp_doc_topic = np.exp(_dirichlet_expectation_2d(doc_topic_distr))
+
+    # diff on `component_` (only calculate it when `cal_diff` is True)
+    suff_stats = (
+        np.zeros(exp_topic_word_distr.shape, dtype=X.dtype) if cal_sstats else None
+    )
+
+    if is_sparse_x:
+        X_data = X.data
+        X_indices = X.indices
+        X_indptr = X.indptr
+
+    # These cython functions are called in a nested loop on usually very small arrays
+    # (length=n_topics). In that case, finding the appropriate signature of the
+    # fused-typed function can be more costly than its execution, hence the dispatch
+    # is done outside of the loop.
+    ctype = "float" if X.dtype == np.float32 else "double"
+    mean_change = cy_mean_change[ctype]
+    dirichlet_expectation_1d = cy_dirichlet_expectation_1d[ctype]
+    eps = np.finfo(X.dtype).eps
+
+    for idx_d in range(n_samples):
+        if is_sparse_x:
+            ids = X_indices[X_indptr[idx_d] : X_indptr[idx_d + 1]]
+            cnts = X_data[X_indptr[idx_d] : X_indptr[idx_d + 1]]
+        else:
+            ids = np.nonzero(X[idx_d, :])[0]
+            cnts = X[idx_d, ids]
+
+        doc_topic_d = doc_topic_distr[idx_d, :]
+        # The next one is a copy, since the inner loop overwrites it.
+        exp_doc_topic_d = exp_doc_topic[idx_d, :].copy()
+        exp_topic_word_d = exp_topic_word_distr[:, ids]
+
+        # Iterate between `doc_topic_d` and `norm_phi` until convergence
+        for _ in range(0, max_doc_update_iter):
+            last_d = doc_topic_d
+
+            # The optimal phi_{dwk} is proportional to
+            # exp(E[log(theta_{dk})]) * exp(E[log(beta_{dw})]).
+            norm_phi = np.dot(exp_doc_topic_d, exp_topic_word_d) + eps
+
+            doc_topic_d = exp_doc_topic_d * np.dot(cnts / norm_phi, exp_topic_word_d.T)
+            # Note: adds doc_topic_prior to doc_topic_d, in-place.
+            dirichlet_expectation_1d(doc_topic_d, doc_topic_prior, exp_doc_topic_d)
+
+            if mean_change(last_d, doc_topic_d) < mean_change_tol:
+                break
+        doc_topic_distr[idx_d, :] = doc_topic_d
+
+        # Contribution of document d to the expected sufficient
+        # statistics for the M step.
+        if cal_sstats:
+            norm_phi = np.dot(exp_doc_topic_d, exp_topic_word_d) + eps
+            suff_stats[:, ids] += np.outer(exp_doc_topic_d, cnts / norm_phi)
+
+    return (doc_topic_distr, suff_stats)
+
+
+class LatentDirichletAllocation(
+    ClassNamePrefixFeaturesOutMixin, TransformerMixin, BaseEstimator
+):
+    """Latent Dirichlet Allocation with online variational Bayes algorithm.
+
+    The implementation is based on [1]_ and [2]_.
+
+    .. versionadded:: 0.17
+
+    Read more in the :ref:`User Guide <LatentDirichletAllocation>`.
+
+    Parameters
+    ----------
+    n_components : int, default=10
+        Number of topics.
+
+        .. versionchanged:: 0.19
+            ``n_topics`` was renamed to ``n_components``
+
+    doc_topic_prior : float, default=None
+        Prior of document topic distribution `theta`. If the value is None,
+        defaults to `1 / n_components`.
+        In [1]_, this is called `alpha`.
+
+    topic_word_prior : float, default=None
+        Prior of topic word distribution `beta`. If the value is None, defaults
+        to `1 / n_components`.
+        In [1]_, this is called `eta`.
+
+    learning_method : {'batch', 'online'}, default='batch'
+        Method used to update `_component`. Only used in :meth:`fit` method.
+        In general, if the data size is large, the online update will be much
+        faster than the batch update.
+
+        Valid options::
+
+            'batch': Batch variational Bayes method. Use all training data in
+                each EM update.
+                Old `components_` will be overwritten in each iteration.
+            'online': Online variational Bayes method. In each EM update, use
+                mini-batch of training data to update the ``components_``
+                variable incrementally. The learning rate is controlled by the
+                ``learning_decay`` and the ``learning_offset`` parameters.
+
+        .. versionchanged:: 0.20
+            The default learning method is now ``"batch"``.
+
+    learning_decay : float, default=0.7
+        It is a parameter that control learning rate in the online learning
+        method. The value should be set between (0.5, 1.0] to guarantee
+        asymptotic convergence. When the value is 0.0 and batch_size is
+        ``n_samples``, the update method is same as batch learning. In the
+        literature, this is called kappa.
+
+    learning_offset : float, default=10.0
+        A (positive) parameter that downweights early iterations in online
+        learning.  It should be greater than 1.0. In the literature, this is
+        called tau_0.
+
+    max_iter : int, default=10
+        The maximum number of passes over the training data (aka epochs).
+        It only impacts the behavior in the :meth:`fit` method, and not the
+        :meth:`partial_fit` method.
+
+    batch_size : int, default=128
+        Number of documents to use in each EM iteration. Only used in online
+        learning.
+
+    evaluate_every : int, default=-1
+        How often to evaluate perplexity. Only used in `fit` method.
+        set it to 0 or negative number to not evaluate perplexity in
+        training at all. Evaluating perplexity can help you check convergence
+        in training process, but it will also increase total training time.
+        Evaluating perplexity in every iteration might increase training time
+        up to two-fold.
+
+    total_samples : int, default=1e6
+        Total number of documents. Only used in the :meth:`partial_fit` method.
+
+    perp_tol : float, default=1e-1
+        Perplexity tolerance in batch learning. Only used when
+        ``evaluate_every`` is greater than 0.
+
+    mean_change_tol : float, default=1e-3
+        Stopping tolerance for updating document topic distribution in E-step.
+
+    max_doc_update_iter : int, default=100
+        Max number of iterations for updating document topic distribution in
+        the E-step.
+
+    n_jobs : int, default=None
+        The number of jobs to use in the E-step.
+        ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.
+        ``-1`` means using all processors. See :term:`Glossary <n_jobs>`
+        for more details.
+
+    verbose : int, default=0
+        Verbosity level.
+
+    random_state : int, RandomState instance or None, default=None
+        Pass an int for reproducible results across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    Attributes
+    ----------
+    components_ : ndarray of shape (n_components, n_features)
+        Variational parameters for topic word distribution. Since the complete
+        conditional for topic word distribution is a Dirichlet,
+        ``components_[i, j]`` can be viewed as pseudocount that represents the
+        number of times word `j` was assigned to topic `i`.
+        It can also be viewed as distribution over the words for each topic
+        after normalization:
+        ``model.components_ / model.components_.sum(axis=1)[:, np.newaxis]``.
+
+    exp_dirichlet_component_ : ndarray of shape (n_components, n_features)
+        Exponential value of expectation of log topic word distribution.
+        In the literature, this is `exp(E[log(beta)])`.
+
+    n_batch_iter_ : int
+        Number of iterations of the EM step.
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    n_iter_ : int
+        Number of passes over the dataset.
+
+    bound_ : float
+        Final perplexity score on training set.
+
+    doc_topic_prior_ : float
+        Prior of document topic distribution `theta`. If the value is None,
+        it is `1 / n_components`.
+
+    random_state_ : RandomState instance
+        RandomState instance that is generated either from a seed, the random
+        number generator or by `np.random`.
+
+    topic_word_prior_ : float
+        Prior of topic word distribution `beta`. If the value is None, it is
+        `1 / n_components`.
+
+    See Also
+    --------
+    sklearn.discriminant_analysis.LinearDiscriminantAnalysis:
+        A classifier with a linear decision boundary, generated by fitting
+        class conditional densities to the data and using Bayes' rule.
+
+    References
+    ----------
+    .. [1] "Online Learning for Latent Dirichlet Allocation", Matthew D.
+           Hoffman, David M. Blei, Francis Bach, 2010
+           https://github.com/blei-lab/onlineldavb
+
+    .. [2] "Stochastic Variational Inference", Matthew D. Hoffman,
+           David M. Blei, Chong Wang, John Paisley, 2013
+
+    Examples
+    --------
+    >>> from sklearn.decomposition import LatentDirichletAllocation
+    >>> from sklearn.datasets import make_multilabel_classification
+    >>> # This produces a feature matrix of token counts, similar to what
+    >>> # CountVectorizer would produce on text.
+    >>> X, _ = make_multilabel_classification(random_state=0)
+    >>> lda = LatentDirichletAllocation(n_components=5,
+    ...     random_state=0)
+    >>> lda.fit(X)
+    LatentDirichletAllocation(...)
+    >>> # get topics for some given samples:
+    >>> lda.transform(X[-2:])
+    array([[0.00360392, 0.25499205, 0.0036211 , 0.64236448, 0.09541846],
+           [0.15297572, 0.00362644, 0.44412786, 0.39568399, 0.003586  ]])
+    """
+
+    _parameter_constraints: dict = {
+        "n_components": [Interval(Integral, 0, None, closed="neither")],
+        "doc_topic_prior": [None, Interval(Real, 0, 1, closed="both")],
+        "topic_word_prior": [None, Interval(Real, 0, 1, closed="both")],
+        "learning_method": [StrOptions({"batch", "online"})],
+        "learning_decay": [Interval(Real, 0, 1, closed="both")],
+        "learning_offset": [Interval(Real, 1.0, None, closed="left")],
+        "max_iter": [Interval(Integral, 0, None, closed="left")],
+        "batch_size": [Interval(Integral, 0, None, closed="neither")],
+        "evaluate_every": [Interval(Integral, None, None, closed="neither")],
+        "total_samples": [Interval(Real, 0, None, closed="neither")],
+        "perp_tol": [Interval(Real, 0, None, closed="left")],
+        "mean_change_tol": [Interval(Real, 0, None, closed="left")],
+        "max_doc_update_iter": [Interval(Integral, 0, None, closed="left")],
+        "n_jobs": [None, Integral],
+        "verbose": ["verbose"],
+        "random_state": ["random_state"],
+    }
+
+    def __init__(
+        self,
+        n_components=10,
+        *,
+        doc_topic_prior=None,
+        topic_word_prior=None,
+        learning_method="batch",
+        learning_decay=0.7,
+        learning_offset=10.0,
+        max_iter=10,
+        batch_size=128,
+        evaluate_every=-1,
+        total_samples=1e6,
+        perp_tol=1e-1,
+        mean_change_tol=1e-3,
+        max_doc_update_iter=100,
+        n_jobs=None,
+        verbose=0,
+        random_state=None,
+    ):
+        self.n_components = n_components
+        self.doc_topic_prior = doc_topic_prior
+        self.topic_word_prior = topic_word_prior
+        self.learning_method = learning_method
+        self.learning_decay = learning_decay
+        self.learning_offset = learning_offset
+        self.max_iter = max_iter
+        self.batch_size = batch_size
+        self.evaluate_every = evaluate_every
+        self.total_samples = total_samples
+        self.perp_tol = perp_tol
+        self.mean_change_tol = mean_change_tol
+        self.max_doc_update_iter = max_doc_update_iter
+        self.n_jobs = n_jobs
+        self.verbose = verbose
+        self.random_state = random_state
+
+    def _init_latent_vars(self, n_features, dtype=np.float64):
+        """Initialize latent variables."""
+
+        self.random_state_ = check_random_state(self.random_state)
+        self.n_batch_iter_ = 1
+        self.n_iter_ = 0
+
+        if self.doc_topic_prior is None:
+            self.doc_topic_prior_ = 1.0 / self.n_components
+        else:
+            self.doc_topic_prior_ = self.doc_topic_prior
+
+        if self.topic_word_prior is None:
+            self.topic_word_prior_ = 1.0 / self.n_components
+        else:
+            self.topic_word_prior_ = self.topic_word_prior
+
+        init_gamma = 100.0
+        init_var = 1.0 / init_gamma
+        # In the literature, this is called `lambda`
+        self.components_ = self.random_state_.gamma(
+            init_gamma, init_var, (self.n_components, n_features)
+        ).astype(dtype, copy=False)
+
+        # In the literature, this is `exp(E[log(beta)])`
+        self.exp_dirichlet_component_ = np.exp(
+            _dirichlet_expectation_2d(self.components_)
+        )
+
+    def _e_step(self, X, cal_sstats, random_init, parallel=None):
+        """E-step in EM update.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            Document word matrix.
+
+        cal_sstats : bool
+            Parameter that indicate whether to calculate sufficient statistics
+            or not. Set ``cal_sstats`` to True when we need to run M-step.
+
+        random_init : bool
+            Parameter that indicate whether to initialize document topic
+            distribution randomly in the E-step. Set it to True in training
+            steps.
+
+        parallel : joblib.Parallel, default=None
+            Pre-initialized instance of joblib.Parallel.
+
+        Returns
+        -------
+        (doc_topic_distr, suff_stats) :
+            `doc_topic_distr` is unnormalized topic distribution for each
+            document. In the literature, this is called `gamma`.
+            `suff_stats` is expected sufficient statistics for the M-step.
+            When `cal_sstats == False`, it will be None.
+
+        """
+
+        # Run e-step in parallel
+        random_state = self.random_state_ if random_init else None
+
+        # TODO: make Parallel._effective_n_jobs public instead?
+        n_jobs = effective_n_jobs(self.n_jobs)
+        if parallel is None:
+            parallel = Parallel(n_jobs=n_jobs, verbose=max(0, self.verbose - 1))
+        results = parallel(
+            delayed(_update_doc_distribution)(
+                X[idx_slice, :],
+                self.exp_dirichlet_component_,
+                self.doc_topic_prior_,
+                self.max_doc_update_iter,
+                self.mean_change_tol,
+                cal_sstats,
+                random_state,
+            )
+            for idx_slice in gen_even_slices(X.shape[0], n_jobs)
+        )
+
+        # merge result
+        doc_topics, sstats_list = zip(*results)
+        doc_topic_distr = np.vstack(doc_topics)
+
+        if cal_sstats:
+            # This step finishes computing the sufficient statistics for the
+            # M-step.
+            suff_stats = np.zeros(self.components_.shape, dtype=self.components_.dtype)
+            for sstats in sstats_list:
+                suff_stats += sstats
+            suff_stats *= self.exp_dirichlet_component_
+        else:
+            suff_stats = None
+
+        return (doc_topic_distr, suff_stats)
+
+    def _em_step(self, X, total_samples, batch_update, parallel=None):
+        """EM update for 1 iteration.
+
+        update `_component` by batch VB or online VB.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            Document word matrix.
+
+        total_samples : int
+            Total number of documents. It is only used when
+            batch_update is `False`.
+
+        batch_update : bool
+            Parameter that controls updating method.
+            `True` for batch learning, `False` for online learning.
+
+        parallel : joblib.Parallel, default=None
+            Pre-initialized instance of joblib.Parallel
+
+        Returns
+        -------
+        doc_topic_distr : ndarray of shape (n_samples, n_components)
+            Unnormalized document topic distribution.
+        """
+
+        # E-step
+        _, suff_stats = self._e_step(
+            X, cal_sstats=True, random_init=True, parallel=parallel
+        )
+
+        # M-step
+        if batch_update:
+            self.components_ = self.topic_word_prior_ + suff_stats
+        else:
+            # online update
+            # In the literature, the weight is `rho`
+            weight = np.power(
+                self.learning_offset + self.n_batch_iter_, -self.learning_decay
+            )
+            doc_ratio = float(total_samples) / X.shape[0]
+            self.components_ *= 1 - weight
+            self.components_ += weight * (
+                self.topic_word_prior_ + doc_ratio * suff_stats
+            )
+
+        # update `component_` related variables
+        self.exp_dirichlet_component_ = np.exp(
+            _dirichlet_expectation_2d(self.components_)
+        )
+        self.n_batch_iter_ += 1
+        return
+
+    def _more_tags(self):
+        return {
+            "preserves_dtype": [np.float64, np.float32],
+            "requires_positive_X": True,
+        }
+
+    def _check_non_neg_array(self, X, reset_n_features, whom):
+        """check X format
+
+        check X format and make sure no negative value in X.
+
+        Parameters
+        ----------
+        X :  array-like or sparse matrix
+
+        """
+        dtype = [np.float64, np.float32] if reset_n_features else self.components_.dtype
+
+        X = self._validate_data(
+            X,
+            reset=reset_n_features,
+            accept_sparse="csr",
+            dtype=dtype,
+        )
+        check_non_negative(X, whom)
+
+        return X
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def partial_fit(self, X, y=None):
+        """Online VB with Mini-Batch update.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            Document word matrix.
+
+        y : Ignored
+            Not used, present here for API consistency by convention.
+
+        Returns
+        -------
+        self
+            Partially fitted estimator.
+        """
+        first_time = not hasattr(self, "components_")
+
+        X = self._check_non_neg_array(
+            X, reset_n_features=first_time, whom="LatentDirichletAllocation.partial_fit"
+        )
+        n_samples, n_features = X.shape
+        batch_size = self.batch_size
+
+        # initialize parameters or check
+        if first_time:
+            self._init_latent_vars(n_features, dtype=X.dtype)
+
+        if n_features != self.components_.shape[1]:
+            raise ValueError(
+                "The provided data has %d dimensions while "
+                "the model was trained with feature size %d."
+                % (n_features, self.components_.shape[1])
+            )
+
+        n_jobs = effective_n_jobs(self.n_jobs)
+        with Parallel(n_jobs=n_jobs, verbose=max(0, self.verbose - 1)) as parallel:
+            for idx_slice in gen_batches(n_samples, batch_size):
+                self._em_step(
+                    X[idx_slice, :],
+                    total_samples=self.total_samples,
+                    batch_update=False,
+                    parallel=parallel,
+                )
+
+        return self
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, X, y=None):
+        """Learn model for the data X with variational Bayes method.
+
+        When `learning_method` is 'online', use mini-batch update.
+        Otherwise, use batch update.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            Document word matrix.
+
+        y : Ignored
+            Not used, present here for API consistency by convention.
+
+        Returns
+        -------
+        self
+            Fitted estimator.
+        """
+        X = self._check_non_neg_array(
+            X, reset_n_features=True, whom="LatentDirichletAllocation.fit"
+        )
+        n_samples, n_features = X.shape
+        max_iter = self.max_iter
+        evaluate_every = self.evaluate_every
+        learning_method = self.learning_method
+
+        batch_size = self.batch_size
+
+        # initialize parameters
+        self._init_latent_vars(n_features, dtype=X.dtype)
+        # change to perplexity later
+        last_bound = None
+        n_jobs = effective_n_jobs(self.n_jobs)
+        with Parallel(n_jobs=n_jobs, verbose=max(0, self.verbose - 1)) as parallel:
+            for i in range(max_iter):
+                if learning_method == "online":
+                    for idx_slice in gen_batches(n_samples, batch_size):
+                        self._em_step(
+                            X[idx_slice, :],
+                            total_samples=n_samples,
+                            batch_update=False,
+                            parallel=parallel,
+                        )
+                else:
+                    # batch update
+                    self._em_step(
+                        X, total_samples=n_samples, batch_update=True, parallel=parallel
+                    )
+
+                # check perplexity
+                if evaluate_every > 0 and (i + 1) % evaluate_every == 0:
+                    doc_topics_distr, _ = self._e_step(
+                        X, cal_sstats=False, random_init=False, parallel=parallel
+                    )
+                    bound = self._perplexity_precomp_distr(
+                        X, doc_topics_distr, sub_sampling=False
+                    )
+                    if self.verbose:
+                        print(
+                            "iteration: %d of max_iter: %d, perplexity: %.4f"
+                            % (i + 1, max_iter, bound)
+                        )
+
+                    if last_bound and abs(last_bound - bound) < self.perp_tol:
+                        break
+                    last_bound = bound
+
+                elif self.verbose:
+                    print("iteration: %d of max_iter: %d" % (i + 1, max_iter))
+                self.n_iter_ += 1
+
+        # calculate final perplexity value on train set
+        doc_topics_distr, _ = self._e_step(
+            X, cal_sstats=False, random_init=False, parallel=parallel
+        )
+        self.bound_ = self._perplexity_precomp_distr(
+            X, doc_topics_distr, sub_sampling=False
+        )
+
+        return self
+
+    def _unnormalized_transform(self, X):
+        """Transform data X according to fitted model.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            Document word matrix.
+
+        Returns
+        -------
+        doc_topic_distr : ndarray of shape (n_samples, n_components)
+            Document topic distribution for X.
+        """
+        doc_topic_distr, _ = self._e_step(X, cal_sstats=False, random_init=False)
+
+        return doc_topic_distr
+
+    def transform(self, X):
+        """Transform data X according to the fitted model.
+
+           .. versionchanged:: 0.18
+              *doc_topic_distr* is now normalized
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            Document word matrix.
+
+        Returns
+        -------
+        doc_topic_distr : ndarray of shape (n_samples, n_components)
+            Document topic distribution for X.
+        """
+        check_is_fitted(self)
+        X = self._check_non_neg_array(
+            X, reset_n_features=False, whom="LatentDirichletAllocation.transform"
+        )
+        doc_topic_distr = self._unnormalized_transform(X)
+        doc_topic_distr /= doc_topic_distr.sum(axis=1)[:, np.newaxis]
+        return doc_topic_distr
+
+    def _approx_bound(self, X, doc_topic_distr, sub_sampling):
+        """Estimate the variational bound.
+
+        Estimate the variational bound over "all documents" using only the
+        documents passed in as X. Since log-likelihood of each word cannot
+        be computed directly, we use this bound to estimate it.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            Document word matrix.
+
+        doc_topic_distr : ndarray of shape (n_samples, n_components)
+            Document topic distribution. In the literature, this is called
+            gamma.
+
+        sub_sampling : bool, default=False
+            Compensate for subsampling of documents.
+            It is used in calculate bound in online learning.
+
+        Returns
+        -------
+        score : float
+
+        """
+
+        def _loglikelihood(prior, distr, dirichlet_distr, size):
+            # calculate log-likelihood
+            score = np.sum((prior - distr) * dirichlet_distr)
+            score += np.sum(gammaln(distr) - gammaln(prior))
+            score += np.sum(gammaln(prior * size) - gammaln(np.sum(distr, 1)))
+            return score
+
+        is_sparse_x = sp.issparse(X)
+        n_samples, n_components = doc_topic_distr.shape
+        n_features = self.components_.shape[1]
+        score = 0
+
+        dirichlet_doc_topic = _dirichlet_expectation_2d(doc_topic_distr)
+        dirichlet_component_ = _dirichlet_expectation_2d(self.components_)
+        doc_topic_prior = self.doc_topic_prior_
+        topic_word_prior = self.topic_word_prior_
+
+        if is_sparse_x:
+            X_data = X.data
+            X_indices = X.indices
+            X_indptr = X.indptr
+
+        # E[log p(docs | theta, beta)]
+        for idx_d in range(0, n_samples):
+            if is_sparse_x:
+                ids = X_indices[X_indptr[idx_d] : X_indptr[idx_d + 1]]
+                cnts = X_data[X_indptr[idx_d] : X_indptr[idx_d + 1]]
+            else:
+                ids = np.nonzero(X[idx_d, :])[0]
+                cnts = X[idx_d, ids]
+            temp = (
+                dirichlet_doc_topic[idx_d, :, np.newaxis] + dirichlet_component_[:, ids]
+            )
+            norm_phi = logsumexp(temp, axis=0)
+            score += np.dot(cnts, norm_phi)
+
+        # compute E[log p(theta | alpha) - log q(theta | gamma)]
+        score += _loglikelihood(
+            doc_topic_prior, doc_topic_distr, dirichlet_doc_topic, self.n_components
+        )
+
+        # Compensate for the subsampling of the population of documents
+        if sub_sampling:
+            doc_ratio = float(self.total_samples) / n_samples
+            score *= doc_ratio
+
+        # E[log p(beta | eta) - log q (beta | lambda)]
+        score += _loglikelihood(
+            topic_word_prior, self.components_, dirichlet_component_, n_features
+        )
+
+        return score
+
+    def score(self, X, y=None):
+        """Calculate approximate log-likelihood as score.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            Document word matrix.
+
+        y : Ignored
+            Not used, present here for API consistency by convention.
+
+        Returns
+        -------
+        score : float
+            Use approximate bound as score.
+        """
+        check_is_fitted(self)
+        X = self._check_non_neg_array(
+            X, reset_n_features=False, whom="LatentDirichletAllocation.score"
+        )
+
+        doc_topic_distr = self._unnormalized_transform(X)
+        score = self._approx_bound(X, doc_topic_distr, sub_sampling=False)
+        return score
+
+    def _perplexity_precomp_distr(self, X, doc_topic_distr=None, sub_sampling=False):
+        """Calculate approximate perplexity for data X with ability to accept
+        precomputed doc_topic_distr
+
+        Perplexity is defined as exp(-1. * log-likelihood per word)
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            Document word matrix.
+
+        doc_topic_distr : ndarray of shape (n_samples, n_components), \
+                default=None
+            Document topic distribution.
+            If it is None, it will be generated by applying transform on X.
+
+        Returns
+        -------
+        score : float
+            Perplexity score.
+        """
+        if doc_topic_distr is None:
+            doc_topic_distr = self._unnormalized_transform(X)
+        else:
+            n_samples, n_components = doc_topic_distr.shape
+            if n_samples != X.shape[0]:
+                raise ValueError(
+                    "Number of samples in X and doc_topic_distr do not match."
+                )
+
+            if n_components != self.n_components:
+                raise ValueError("Number of topics does not match.")
+
+        current_samples = X.shape[0]
+        bound = self._approx_bound(X, doc_topic_distr, sub_sampling)
+
+        if sub_sampling:
+            word_cnt = X.sum() * (float(self.total_samples) / current_samples)
+        else:
+            word_cnt = X.sum()
+        perword_bound = bound / word_cnt
+
+        return np.exp(-1.0 * perword_bound)
+
+    def perplexity(self, X, sub_sampling=False):
+        """Calculate approximate perplexity for data X.
+
+        Perplexity is defined as exp(-1. * log-likelihood per word)
+
+        .. versionchanged:: 0.19
+           *doc_topic_distr* argument has been deprecated and is ignored
+           because user no longer has access to unnormalized distribution
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            Document word matrix.
+
+        sub_sampling : bool
+            Do sub-sampling or not.
+
+        Returns
+        -------
+        score : float
+            Perplexity score.
+        """
+        check_is_fitted(self)
+        X = self._check_non_neg_array(
+            X, reset_n_features=True, whom="LatentDirichletAllocation.perplexity"
+        )
+        return self._perplexity_precomp_distr(X, sub_sampling=sub_sampling)
+
+    @property
+    def _n_features_out(self):
+        """Number of transformed output features."""
+        return self.components_.shape[0]

venv/lib/python3.10/site-packages/sklearn/decomposition/_nmf.py

@@ -0,0 +1,2443 @@
+""" Non-negative matrix factorization.
+"""
+# Author: Vlad Niculae
+#         Lars Buitinck
+#         Mathieu Blondel <[email protected]>
+#         Tom Dupre la Tour
+# License: BSD 3 clause
+
+import itertools
+import time
+import warnings
+from abc import ABC
+from math import sqrt
+from numbers import Integral, Real
+
+import numpy as np
+import scipy.sparse as sp
+from scipy import linalg
+
+from .._config import config_context
+from ..base import (
+    BaseEstimator,
+    ClassNamePrefixFeaturesOutMixin,
+    TransformerMixin,
+    _fit_context,
+)
+from ..exceptions import ConvergenceWarning
+from ..utils import check_array, check_random_state, gen_batches, metadata_routing
+from ..utils._param_validation import (
+    Hidden,
+    Interval,
+    StrOptions,
+    validate_params,
+)
+from ..utils.extmath import randomized_svd, safe_sparse_dot, squared_norm
+from ..utils.validation import (
+    check_is_fitted,
+    check_non_negative,
+)
+from ._cdnmf_fast import _update_cdnmf_fast
+
+EPSILON = np.finfo(np.float32).eps
+
+
+def norm(x):
+    """Dot product-based Euclidean norm implementation.
+
+    See: http://fa.bianp.net/blog/2011/computing-the-vector-norm/
+
+    Parameters
+    ----------
+    x : array-like
+        Vector for which to compute the norm.
+    """
+    return sqrt(squared_norm(x))
+
+
+def trace_dot(X, Y):
+    """Trace of np.dot(X, Y.T).
+
+    Parameters
+    ----------
+    X : array-like
+        First matrix.
+    Y : array-like
+        Second matrix.
+    """
+    return np.dot(X.ravel(), Y.ravel())
+
+
+def _check_init(A, shape, whom):
+    A = check_array(A)
+    if shape[0] != "auto" and A.shape[0] != shape[0]:
+        raise ValueError(
+            f"Array with wrong first dimension passed to {whom}. Expected {shape[0]}, "
+            f"but got {A.shape[0]}."
+        )
+    if shape[1] != "auto" and A.shape[1] != shape[1]:
+        raise ValueError(
+            f"Array with wrong second dimension passed to {whom}. Expected {shape[1]}, "
+            f"but got {A.shape[1]}."
+        )
+    check_non_negative(A, whom)
+    if np.max(A) == 0:
+        raise ValueError(f"Array passed to {whom} is full of zeros.")
+
+
+def _beta_divergence(X, W, H, beta, square_root=False):
+    """Compute the beta-divergence of X and dot(W, H).
+
+    Parameters
+    ----------
+    X : float or array-like of shape (n_samples, n_features)
+
+    W : float or array-like of shape (n_samples, n_components)
+
+    H : float or array-like of shape (n_components, n_features)
+
+    beta : float or {'frobenius', 'kullback-leibler', 'itakura-saito'}
+        Parameter of the beta-divergence.
+        If beta == 2, this is half the Frobenius *squared* norm.
+        If beta == 1, this is the generalized Kullback-Leibler divergence.
+        If beta == 0, this is the Itakura-Saito divergence.
+        Else, this is the general beta-divergence.
+
+    square_root : bool, default=False
+        If True, return np.sqrt(2 * res)
+        For beta == 2, it corresponds to the Frobenius norm.
+
+    Returns
+    -------
+        res : float
+            Beta divergence of X and np.dot(X, H).
+    """
+    beta = _beta_loss_to_float(beta)
+
+    # The method can be called with scalars
+    if not sp.issparse(X):
+        X = np.atleast_2d(X)
+    W = np.atleast_2d(W)
+    H = np.atleast_2d(H)
+
+    # Frobenius norm
+    if beta == 2:
+        # Avoid the creation of the dense np.dot(W, H) if X is sparse.
+        if sp.issparse(X):
+            norm_X = np.dot(X.data, X.data)
+            norm_WH = trace_dot(np.linalg.multi_dot([W.T, W, H]), H)
+            cross_prod = trace_dot((X @ H.T), W)
+            res = (norm_X + norm_WH - 2.0 * cross_prod) / 2.0
+        else:
+            res = squared_norm(X - np.dot(W, H)) / 2.0
+
+        if square_root:
+            return np.sqrt(res * 2)
+        else:
+            return res
+
+    if sp.issparse(X):
+        # compute np.dot(W, H) only where X is nonzero
+        WH_data = _special_sparse_dot(W, H, X).data
+        X_data = X.data
+    else:
+        WH = np.dot(W, H)
+        WH_data = WH.ravel()
+        X_data = X.ravel()
+
+    # do not affect the zeros: here 0 ** (-1) = 0 and not infinity
+    indices = X_data > EPSILON
+    WH_data = WH_data[indices]
+    X_data = X_data[indices]
+
+    # used to avoid division by zero
+    WH_data[WH_data < EPSILON] = EPSILON
+
+    # generalized Kullback-Leibler divergence
+    if beta == 1:
+        # fast and memory efficient computation of np.sum(np.dot(W, H))
+        sum_WH = np.dot(np.sum(W, axis=0), np.sum(H, axis=1))
+        # computes np.sum(X * log(X / WH)) only where X is nonzero
+        div = X_data / WH_data
+        res = np.dot(X_data, np.log(div))
+        # add full np.sum(np.dot(W, H)) - np.sum(X)
+        res += sum_WH - X_data.sum()
+
+    # Itakura-Saito divergence
+    elif beta == 0:
+        div = X_data / WH_data
+        res = np.sum(div) - np.prod(X.shape) - np.sum(np.log(div))
+
+    # beta-divergence, beta not in (0, 1, 2)
+    else:
+        if sp.issparse(X):
+            # slow loop, but memory efficient computation of :
+            # np.sum(np.dot(W, H) ** beta)
+            sum_WH_beta = 0
+            for i in range(X.shape[1]):
+                sum_WH_beta += np.sum(np.dot(W, H[:, i]) ** beta)
+
+        else:
+            sum_WH_beta = np.sum(WH**beta)
+
+        sum_X_WH = np.dot(X_data, WH_data ** (beta - 1))
+        res = (X_data**beta).sum() - beta * sum_X_WH
+        res += sum_WH_beta * (beta - 1)
+        res /= beta * (beta - 1)
+
+    if square_root:
+        res = max(res, 0)  # avoid negative number due to rounding errors
+        return np.sqrt(2 * res)
+    else:
+        return res
+
+
+def _special_sparse_dot(W, H, X):
+    """Computes np.dot(W, H), only where X is non zero."""
+    if sp.issparse(X):
+        ii, jj = X.nonzero()
+        n_vals = ii.shape[0]
+        dot_vals = np.empty(n_vals)
+        n_components = W.shape[1]
+
+        batch_size = max(n_components, n_vals // n_components)
+        for start in range(0, n_vals, batch_size):
+            batch = slice(start, start + batch_size)
+            dot_vals[batch] = np.multiply(W[ii[batch], :], H.T[jj[batch], :]).sum(
+                axis=1
+            )
+
+        WH = sp.coo_matrix((dot_vals, (ii, jj)), shape=X.shape)
+        return WH.tocsr()
+    else:
+        return np.dot(W, H)
+
+
+def _beta_loss_to_float(beta_loss):
+    """Convert string beta_loss to float."""
+    beta_loss_map = {"frobenius": 2, "kullback-leibler": 1, "itakura-saito": 0}
+    if isinstance(beta_loss, str):
+        beta_loss = beta_loss_map[beta_loss]
+    return beta_loss
+
+
+def _initialize_nmf(X, n_components, init=None, eps=1e-6, random_state=None):
+    """Algorithms for NMF initialization.
+
+    Computes an initial guess for the non-negative
+    rank k matrix approximation for X: X = WH.
+
+    Parameters
+    ----------
+    X : array-like of shape (n_samples, n_features)
+        The data matrix to be decomposed.
+
+    n_components : int
+        The number of components desired in the approximation.
+
+    init :  {'random', 'nndsvd', 'nndsvda', 'nndsvdar'}, default=None
+        Method used to initialize the procedure.
+        Valid options:
+
+        - None: 'nndsvda' if n_components <= min(n_samples, n_features),
+            otherwise 'random'.
+
+        - 'random': non-negative random matrices, scaled with:
+            sqrt(X.mean() / n_components)
+
+        - 'nndsvd': Nonnegative Double Singular Value Decomposition (NNDSVD)
+            initialization (better for sparseness)
+
+        - 'nndsvda': NNDSVD with zeros filled with the average of X
+            (better when sparsity is not desired)
+
+        - 'nndsvdar': NNDSVD with zeros filled with small random values
+            (generally faster, less accurate alternative to NNDSVDa
+            for when sparsity is not desired)
+
+        - 'custom': use custom matrices W and H
+
+        .. versionchanged:: 1.1
+            When `init=None` and n_components is less than n_samples and n_features
+            defaults to `nndsvda` instead of `nndsvd`.
+
+    eps : float, default=1e-6
+        Truncate all values less then this in output to zero.
+
+    random_state : int, RandomState instance or None, default=None
+        Used when ``init`` == 'nndsvdar' or 'random'. Pass an int for
+        reproducible results across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    Returns
+    -------
+    W : array-like of shape (n_samples, n_components)
+        Initial guesses for solving X ~= WH.
+
+    H : array-like of shape (n_components, n_features)
+        Initial guesses for solving X ~= WH.
+
+    References
+    ----------
+    C. Boutsidis, E. Gallopoulos: SVD based initialization: A head start for
+    nonnegative matrix factorization - Pattern Recognition, 2008
+    http://tinyurl.com/nndsvd
+    """
+    check_non_negative(X, "NMF initialization")
+    n_samples, n_features = X.shape
+
+    if (
+        init is not None
+        and init != "random"
+        and n_components > min(n_samples, n_features)
+    ):
+        raise ValueError(
+            "init = '{}' can only be used when "
+            "n_components <= min(n_samples, n_features)".format(init)
+        )
+
+    if init is None:
+        if n_components <= min(n_samples, n_features):
+            init = "nndsvda"
+        else:
+            init = "random"
+
+    # Random initialization
+    if init == "random":
+        avg = np.sqrt(X.mean() / n_components)
+        rng = check_random_state(random_state)
+        H = avg * rng.standard_normal(size=(n_components, n_features)).astype(
+            X.dtype, copy=False
+        )
+        W = avg * rng.standard_normal(size=(n_samples, n_components)).astype(
+            X.dtype, copy=False
+        )
+        np.abs(H, out=H)
+        np.abs(W, out=W)
+        return W, H
+
+    # NNDSVD initialization
+    U, S, V = randomized_svd(X, n_components, random_state=random_state)
+    W = np.zeros_like(U)
+    H = np.zeros_like(V)
+
+    # The leading singular triplet is non-negative
+    # so it can be used as is for initialization.
+    W[:, 0] = np.sqrt(S[0]) * np.abs(U[:, 0])
+    H[0, :] = np.sqrt(S[0]) * np.abs(V[0, :])
+
+    for j in range(1, n_components):
+        x, y = U[:, j], V[j, :]
+
+        # extract positive and negative parts of column vectors
+        x_p, y_p = np.maximum(x, 0), np.maximum(y, 0)
+        x_n, y_n = np.abs(np.minimum(x, 0)), np.abs(np.minimum(y, 0))
+
+        # and their norms
+        x_p_nrm, y_p_nrm = norm(x_p), norm(y_p)
+        x_n_nrm, y_n_nrm = norm(x_n), norm(y_n)
+
+        m_p, m_n = x_p_nrm * y_p_nrm, x_n_nrm * y_n_nrm
+
+        # choose update
+        if m_p > m_n:
+            u = x_p / x_p_nrm
+            v = y_p / y_p_nrm
+            sigma = m_p
+        else:
+            u = x_n / x_n_nrm
+            v = y_n / y_n_nrm
+            sigma = m_n
+
+        lbd = np.sqrt(S[j] * sigma)
+        W[:, j] = lbd * u
+        H[j, :] = lbd * v
+
+    W[W < eps] = 0
+    H[H < eps] = 0
+
+    if init == "nndsvd":
+        pass
+    elif init == "nndsvda":
+        avg = X.mean()
+        W[W == 0] = avg
+        H[H == 0] = avg
+    elif init == "nndsvdar":
+        rng = check_random_state(random_state)
+        avg = X.mean()
+        W[W == 0] = abs(avg * rng.standard_normal(size=len(W[W == 0])) / 100)
+        H[H == 0] = abs(avg * rng.standard_normal(size=len(H[H == 0])) / 100)
+    else:
+        raise ValueError(
+            "Invalid init parameter: got %r instead of one of %r"
+            % (init, (None, "random", "nndsvd", "nndsvda", "nndsvdar"))
+        )
+
+    return W, H
+
+
+def _update_coordinate_descent(X, W, Ht, l1_reg, l2_reg, shuffle, random_state):
+    """Helper function for _fit_coordinate_descent.
+
+    Update W to minimize the objective function, iterating once over all
+    coordinates. By symmetry, to update H, one can call
+    _update_coordinate_descent(X.T, Ht, W, ...).
+
+    """
+    n_components = Ht.shape[1]
+
+    HHt = np.dot(Ht.T, Ht)
+    XHt = safe_sparse_dot(X, Ht)
+
+    # L2 regularization corresponds to increase of the diagonal of HHt
+    if l2_reg != 0.0:
+        # adds l2_reg only on the diagonal
+        HHt.flat[:: n_components + 1] += l2_reg
+    # L1 regularization corresponds to decrease of each element of XHt
+    if l1_reg != 0.0:
+        XHt -= l1_reg
+
+    if shuffle:
+        permutation = random_state.permutation(n_components)
+    else:
+        permutation = np.arange(n_components)
+    # The following seems to be required on 64-bit Windows w/ Python 3.5.
+    permutation = np.asarray(permutation, dtype=np.intp)
+    return _update_cdnmf_fast(W, HHt, XHt, permutation)
+
+
+def _fit_coordinate_descent(
+    X,
+    W,
+    H,
+    tol=1e-4,
+    max_iter=200,
+    l1_reg_W=0,
+    l1_reg_H=0,
+    l2_reg_W=0,
+    l2_reg_H=0,
+    update_H=True,
+    verbose=0,
+    shuffle=False,
+    random_state=None,
+):
+    """Compute Non-negative Matrix Factorization (NMF) with Coordinate Descent
+
+    The objective function is minimized with an alternating minimization of W
+    and H. Each minimization is done with a cyclic (up to a permutation of the
+    features) Coordinate Descent.
+
+    Parameters
+    ----------
+    X : array-like of shape (n_samples, n_features)
+        Constant matrix.
+
+    W : array-like of shape (n_samples, n_components)
+        Initial guess for the solution.
+
+    H : array-like of shape (n_components, n_features)
+        Initial guess for the solution.
+
+    tol : float, default=1e-4
+        Tolerance of the stopping condition.
+
+    max_iter : int, default=200
+        Maximum number of iterations before timing out.
+
+    l1_reg_W : float, default=0.
+        L1 regularization parameter for W.
+
+    l1_reg_H : float, default=0.
+        L1 regularization parameter for H.
+
+    l2_reg_W : float, default=0.
+        L2 regularization parameter for W.
+
+    l2_reg_H : float, default=0.
+        L2 regularization parameter for H.
+
+    update_H : bool, default=True
+        Set to True, both W and H will be estimated from initial guesses.
+        Set to False, only W will be estimated.
+
+    verbose : int, default=0
+        The verbosity level.
+
+    shuffle : bool, default=False
+        If true, randomize the order of coordinates in the CD solver.
+
+    random_state : int, RandomState instance or None, default=None
+        Used to randomize the coordinates in the CD solver, when
+        ``shuffle`` is set to ``True``. Pass an int for reproducible
+        results across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    Returns
+    -------
+    W : ndarray of shape (n_samples, n_components)
+        Solution to the non-negative least squares problem.
+
+    H : ndarray of shape (n_components, n_features)
+        Solution to the non-negative least squares problem.
+
+    n_iter : int
+        The number of iterations done by the algorithm.
+
+    References
+    ----------
+    .. [1] :doi:`"Fast local algorithms for large scale nonnegative matrix and tensor
+       factorizations" <10.1587/transfun.E92.A.708>`
+       Cichocki, Andrzej, and P. H. A. N. Anh-Huy. IEICE transactions on fundamentals
+       of electronics, communications and computer sciences 92.3: 708-721, 2009.
+    """
+    # so W and Ht are both in C order in memory
+    Ht = check_array(H.T, order="C")
+    X = check_array(X, accept_sparse="csr")
+
+    rng = check_random_state(random_state)
+
+    for n_iter in range(1, max_iter + 1):
+        violation = 0.0
+
+        # Update W
+        violation += _update_coordinate_descent(
+            X, W, Ht, l1_reg_W, l2_reg_W, shuffle, rng
+        )
+        # Update H
+        if update_H:
+            violation += _update_coordinate_descent(
+                X.T, Ht, W, l1_reg_H, l2_reg_H, shuffle, rng
+            )
+
+        if n_iter == 1:
+            violation_init = violation
+
+        if violation_init == 0:
+            break
+
+        if verbose:
+            print("violation:", violation / violation_init)
+
+        if violation / violation_init <= tol:
+            if verbose:
+                print("Converged at iteration", n_iter + 1)
+            break
+
+    return W, Ht.T, n_iter
+
+
+def _multiplicative_update_w(
+    X,
+    W,
+    H,
+    beta_loss,
+    l1_reg_W,
+    l2_reg_W,
+    gamma,
+    H_sum=None,
+    HHt=None,
+    XHt=None,
+    update_H=True,
+):
+    """Update W in Multiplicative Update NMF."""
+    if beta_loss == 2:
+        # Numerator
+        if XHt is None:
+            XHt = safe_sparse_dot(X, H.T)
+        if update_H:
+            # avoid a copy of XHt, which will be re-computed (update_H=True)
+            numerator = XHt
+        else:
+            # preserve the XHt, which is not re-computed (update_H=False)
+            numerator = XHt.copy()
+
+        # Denominator
+        if HHt is None:
+            HHt = np.dot(H, H.T)
+        denominator = np.dot(W, HHt)
+
+    else:
+        # Numerator
+        # if X is sparse, compute WH only where X is non zero
+        WH_safe_X = _special_sparse_dot(W, H, X)
+        if sp.issparse(X):
+            WH_safe_X_data = WH_safe_X.data
+            X_data = X.data
+        else:
+            WH_safe_X_data = WH_safe_X
+            X_data = X
+            # copy used in the Denominator
+            WH = WH_safe_X.copy()
+            if beta_loss - 1.0 < 0:
+                WH[WH < EPSILON] = EPSILON
+
+        # to avoid taking a negative power of zero
+        if beta_loss - 2.0 < 0:
+            WH_safe_X_data[WH_safe_X_data < EPSILON] = EPSILON
+
+        if beta_loss == 1:
+            np.divide(X_data, WH_safe_X_data, out=WH_safe_X_data)
+        elif beta_loss == 0:
+            # speeds up computation time
+            # refer to /numpy/numpy/issues/9363
+            WH_safe_X_data **= -1
+            WH_safe_X_data **= 2
+            # element-wise multiplication
+            WH_safe_X_data *= X_data
+        else:
+            WH_safe_X_data **= beta_loss - 2
+            # element-wise multiplication
+            WH_safe_X_data *= X_data
+
+        # here numerator = dot(X * (dot(W, H) ** (beta_loss - 2)), H.T)
+        numerator = safe_sparse_dot(WH_safe_X, H.T)
+
+        # Denominator
+        if beta_loss == 1:
+            if H_sum is None:
+                H_sum = np.sum(H, axis=1)  # shape(n_components, )
+            denominator = H_sum[np.newaxis, :]
+
+        else:
+            # computation of WHHt = dot(dot(W, H) ** beta_loss - 1, H.T)
+            if sp.issparse(X):
+                # memory efficient computation
+                # (compute row by row, avoiding the dense matrix WH)
+                WHHt = np.empty(W.shape)
+                for i in range(X.shape[0]):
+                    WHi = np.dot(W[i, :], H)
+                    if beta_loss - 1 < 0:
+                        WHi[WHi < EPSILON] = EPSILON
+                    WHi **= beta_loss - 1
+                    WHHt[i, :] = np.dot(WHi, H.T)
+            else:
+                WH **= beta_loss - 1
+                WHHt = np.dot(WH, H.T)
+            denominator = WHHt
+
+    # Add L1 and L2 regularization
+    if l1_reg_W > 0:
+        denominator += l1_reg_W
+    if l2_reg_W > 0:
+        denominator = denominator + l2_reg_W * W
+    denominator[denominator == 0] = EPSILON
+
+    numerator /= denominator
+    delta_W = numerator
+
+    # gamma is in ]0, 1]
+    if gamma != 1:
+        delta_W **= gamma
+
+    W *= delta_W
+
+    return W, H_sum, HHt, XHt
+
+
+def _multiplicative_update_h(
+    X, W, H, beta_loss, l1_reg_H, l2_reg_H, gamma, A=None, B=None, rho=None
+):
+    """update H in Multiplicative Update NMF."""
+    if beta_loss == 2:
+        numerator = safe_sparse_dot(W.T, X)
+        denominator = np.linalg.multi_dot([W.T, W, H])
+
+    else:
+        # Numerator
+        WH_safe_X = _special_sparse_dot(W, H, X)
+        if sp.issparse(X):
+            WH_safe_X_data = WH_safe_X.data
+            X_data = X.data
+        else:
+            WH_safe_X_data = WH_safe_X
+            X_data = X
+            # copy used in the Denominator
+            WH = WH_safe_X.copy()
+            if beta_loss - 1.0 < 0:
+                WH[WH < EPSILON] = EPSILON
+
+        # to avoid division by zero
+        if beta_loss - 2.0 < 0:
+            WH_safe_X_data[WH_safe_X_data < EPSILON] = EPSILON
+
+        if beta_loss == 1:
+            np.divide(X_data, WH_safe_X_data, out=WH_safe_X_data)
+        elif beta_loss == 0:
+            # speeds up computation time
+            # refer to /numpy/numpy/issues/9363
+            WH_safe_X_data **= -1
+            WH_safe_X_data **= 2
+            # element-wise multiplication
+            WH_safe_X_data *= X_data
+        else:
+            WH_safe_X_data **= beta_loss - 2
+            # element-wise multiplication
+            WH_safe_X_data *= X_data
+
+        # here numerator = dot(W.T, (dot(W, H) ** (beta_loss - 2)) * X)
+        numerator = safe_sparse_dot(W.T, WH_safe_X)
+
+        # Denominator
+        if beta_loss == 1:
+            W_sum = np.sum(W, axis=0)  # shape(n_components, )
+            W_sum[W_sum == 0] = 1.0
+            denominator = W_sum[:, np.newaxis]
+
+        # beta_loss not in (1, 2)
+        else:
+            # computation of WtWH = dot(W.T, dot(W, H) ** beta_loss - 1)
+            if sp.issparse(X):
+                # memory efficient computation
+                # (compute column by column, avoiding the dense matrix WH)
+                WtWH = np.empty(H.shape)
+                for i in range(X.shape[1]):
+                    WHi = np.dot(W, H[:, i])
+                    if beta_loss - 1 < 0:
+                        WHi[WHi < EPSILON] = EPSILON
+                    WHi **= beta_loss - 1
+                    WtWH[:, i] = np.dot(W.T, WHi)
+            else:
+                WH **= beta_loss - 1
+                WtWH = np.dot(W.T, WH)
+            denominator = WtWH
+
+    # Add L1 and L2 regularization
+    if l1_reg_H > 0:
+        denominator += l1_reg_H
+    if l2_reg_H > 0:
+        denominator = denominator + l2_reg_H * H
+    denominator[denominator == 0] = EPSILON
+
+    if A is not None and B is not None:
+        # Updates for the online nmf
+        if gamma != 1:
+            H **= 1 / gamma
+        numerator *= H
+        A *= rho
+        B *= rho
+        A += numerator
+        B += denominator
+        H = A / B
+
+        if gamma != 1:
+            H **= gamma
+    else:
+        delta_H = numerator
+        delta_H /= denominator
+        if gamma != 1:
+            delta_H **= gamma
+        H *= delta_H
+
+    return H
+
+
+def _fit_multiplicative_update(
+    X,
+    W,
+    H,
+    beta_loss="frobenius",
+    max_iter=200,
+    tol=1e-4,
+    l1_reg_W=0,
+    l1_reg_H=0,
+    l2_reg_W=0,
+    l2_reg_H=0,
+    update_H=True,
+    verbose=0,
+):
+    """Compute Non-negative Matrix Factorization with Multiplicative Update.
+
+    The objective function is _beta_divergence(X, WH) and is minimized with an
+    alternating minimization of W and H. Each minimization is done with a
+    Multiplicative Update.
+
+    Parameters
+    ----------
+    X : array-like of shape (n_samples, n_features)
+        Constant input matrix.
+
+    W : array-like of shape (n_samples, n_components)
+        Initial guess for the solution.
+
+    H : array-like of shape (n_components, n_features)
+        Initial guess for the solution.
+
+    beta_loss : float or {'frobenius', 'kullback-leibler', \
+            'itakura-saito'}, default='frobenius'
+        String must be in {'frobenius', 'kullback-leibler', 'itakura-saito'}.
+        Beta divergence to be minimized, measuring the distance between X
+        and the dot product WH. Note that values different from 'frobenius'
+        (or 2) and 'kullback-leibler' (or 1) lead to significantly slower
+        fits. Note that for beta_loss <= 0 (or 'itakura-saito'), the input
+        matrix X cannot contain zeros.
+
+    max_iter : int, default=200
+        Number of iterations.
+
+    tol : float, default=1e-4
+        Tolerance of the stopping condition.
+
+    l1_reg_W : float, default=0.
+        L1 regularization parameter for W.
+
+    l1_reg_H : float, default=0.
+        L1 regularization parameter for H.
+
+    l2_reg_W : float, default=0.
+        L2 regularization parameter for W.
+
+    l2_reg_H : float, default=0.
+        L2 regularization parameter for H.
+
+    update_H : bool, default=True
+        Set to True, both W and H will be estimated from initial guesses.
+        Set to False, only W will be estimated.
+
+    verbose : int, default=0
+        The verbosity level.
+
+    Returns
+    -------
+    W : ndarray of shape (n_samples, n_components)
+        Solution to the non-negative least squares problem.
+
+    H : ndarray of shape (n_components, n_features)
+        Solution to the non-negative least squares problem.
+
+    n_iter : int
+        The number of iterations done by the algorithm.
+
+    References
+    ----------
+    Lee, D. D., & Seung, H., S. (2001). Algorithms for Non-negative Matrix
+    Factorization. Adv. Neural Inform. Process. Syst.. 13.
+    Fevotte, C., & Idier, J. (2011). Algorithms for nonnegative matrix
+    factorization with the beta-divergence. Neural Computation, 23(9).
+    """
+    start_time = time.time()
+
+    beta_loss = _beta_loss_to_float(beta_loss)
+
+    # gamma for Maximization-Minimization (MM) algorithm [Fevotte 2011]
+    if beta_loss < 1:
+        gamma = 1.0 / (2.0 - beta_loss)
+    elif beta_loss > 2:
+        gamma = 1.0 / (beta_loss - 1.0)
+    else:
+        gamma = 1.0
+
+    # used for the convergence criterion
+    error_at_init = _beta_divergence(X, W, H, beta_loss, square_root=True)
+    previous_error = error_at_init
+
+    H_sum, HHt, XHt = None, None, None
+    for n_iter in range(1, max_iter + 1):
+        # update W
+        # H_sum, HHt and XHt are saved and reused if not update_H
+        W, H_sum, HHt, XHt = _multiplicative_update_w(
+            X,
+            W,
+            H,
+            beta_loss=beta_loss,
+            l1_reg_W=l1_reg_W,
+            l2_reg_W=l2_reg_W,
+            gamma=gamma,
+            H_sum=H_sum,
+            HHt=HHt,
+            XHt=XHt,
+            update_H=update_H,
+        )
+
+        # necessary for stability with beta_loss < 1
+        if beta_loss < 1:
+            W[W < np.finfo(np.float64).eps] = 0.0
+
+        # update H (only at fit or fit_transform)
+        if update_H:
+            H = _multiplicative_update_h(
+                X,
+                W,
+                H,
+                beta_loss=beta_loss,
+                l1_reg_H=l1_reg_H,
+                l2_reg_H=l2_reg_H,
+                gamma=gamma,
+            )
+
+            # These values will be recomputed since H changed
+            H_sum, HHt, XHt = None, None, None
+
+            # necessary for stability with beta_loss < 1
+            if beta_loss <= 1:
+                H[H < np.finfo(np.float64).eps] = 0.0
+
+        # test convergence criterion every 10 iterations
+        if tol > 0 and n_iter % 10 == 0:
+            error = _beta_divergence(X, W, H, beta_loss, square_root=True)
+
+            if verbose:
+                iter_time = time.time()
+                print(
+                    "Epoch %02d reached after %.3f seconds, error: %f"
+                    % (n_iter, iter_time - start_time, error)
+                )
+
+            if (previous_error - error) / error_at_init < tol:
+                break
+            previous_error = error
+
+    # do not print if we have already printed in the convergence test
+    if verbose and (tol == 0 or n_iter % 10 != 0):
+        end_time = time.time()
+        print(
+            "Epoch %02d reached after %.3f seconds." % (n_iter, end_time - start_time)
+        )
+
+    return W, H, n_iter
+
+
+@validate_params(
+    {
+        "X": ["array-like", "sparse matrix"],
+        "W": ["array-like", None],
+        "H": ["array-like", None],
+        "update_H": ["boolean"],
+    },
+    prefer_skip_nested_validation=False,
+)
+def non_negative_factorization(
+    X,
+    W=None,
+    H=None,
+    n_components="warn",
+    *,
+    init=None,
+    update_H=True,
+    solver="cd",
+    beta_loss="frobenius",
+    tol=1e-4,
+    max_iter=200,
+    alpha_W=0.0,
+    alpha_H="same",
+    l1_ratio=0.0,
+    random_state=None,
+    verbose=0,
+    shuffle=False,
+):
+    """Compute Non-negative Matrix Factorization (NMF).
+
+    Find two non-negative matrices (W, H) whose product approximates the non-
+    negative matrix X. This factorization can be used for example for
+    dimensionality reduction, source separation or topic extraction.
+
+    The objective function is:
+
+        .. math::
+
+            L(W, H) &= 0.5 * ||X - WH||_{loss}^2
+
+            &+ alpha\\_W * l1\\_ratio * n\\_features * ||vec(W)||_1
+
+            &+ alpha\\_H * l1\\_ratio * n\\_samples * ||vec(H)||_1
+
+            &+ 0.5 * alpha\\_W * (1 - l1\\_ratio) * n\\_features * ||W||_{Fro}^2
+
+            &+ 0.5 * alpha\\_H * (1 - l1\\_ratio) * n\\_samples * ||H||_{Fro}^2
+
+    Where:
+
+    :math:`||A||_{Fro}^2 = \\sum_{i,j} A_{ij}^2` (Frobenius norm)
+
+    :math:`||vec(A)||_1 = \\sum_{i,j} abs(A_{ij})` (Elementwise L1 norm)
+
+    The generic norm :math:`||X - WH||_{loss}^2` may represent
+    the Frobenius norm or another supported beta-divergence loss.
+    The choice between options is controlled by the `beta_loss` parameter.
+
+    The regularization terms are scaled by `n_features` for `W` and by `n_samples` for
+    `H` to keep their impact balanced with respect to one another and to the data fit
+    term as independent as possible of the size `n_samples` of the training set.
+
+    The objective function is minimized with an alternating minimization of W
+    and H. If H is given and update_H=False, it solves for W only.
+
+    Note that the transformed data is named W and the components matrix is named H. In
+    the NMF literature, the naming convention is usually the opposite since the data
+    matrix X is transposed.
+
+    Parameters
+    ----------
+    X : {array-like, sparse matrix} of shape (n_samples, n_features)
+        Constant matrix.
+
+    W : array-like of shape (n_samples, n_components), default=None
+        If `init='custom'`, it is used as initial guess for the solution.
+        If `update_H=False`, it is initialised as an array of zeros, unless
+        `solver='mu'`, then it is filled with values calculated by
+        `np.sqrt(X.mean() / self._n_components)`.
+        If `None`, uses the initialisation method specified in `init`.
+
+    H : array-like of shape (n_components, n_features), default=None
+        If `init='custom'`, it is used as initial guess for the solution.
+        If `update_H=False`, it is used as a constant, to solve for W only.
+        If `None`, uses the initialisation method specified in `init`.
+
+    n_components : int or {'auto'} or None, default=None
+        Number of components, if n_components is not set all features
+        are kept.
+        If `n_components='auto'`, the number of components is automatically inferred
+        from `W` or `H` shapes.
+
+        .. versionchanged:: 1.4
+            Added `'auto'` value.
+
+    init : {'random', 'nndsvd', 'nndsvda', 'nndsvdar', 'custom'}, default=None
+        Method used to initialize the procedure.
+
+        Valid options:
+
+        - None: 'nndsvda' if n_components < n_features, otherwise 'random'.
+        - 'random': non-negative random matrices, scaled with:
+          `sqrt(X.mean() / n_components)`
+        - 'nndsvd': Nonnegative Double Singular Value Decomposition (NNDSVD)
+          initialization (better for sparseness)
+        - 'nndsvda': NNDSVD with zeros filled with the average of X
+          (better when sparsity is not desired)
+        - 'nndsvdar': NNDSVD with zeros filled with small random values
+          (generally faster, less accurate alternative to NNDSVDa
+          for when sparsity is not desired)
+        - 'custom': If `update_H=True`, use custom matrices W and H which must both
+          be provided. If `update_H=False`, then only custom matrix H is used.
+
+        .. versionchanged:: 0.23
+            The default value of `init` changed from 'random' to None in 0.23.
+
+        .. versionchanged:: 1.1
+            When `init=None` and n_components is less than n_samples and n_features
+            defaults to `nndsvda` instead of `nndsvd`.
+
+    update_H : bool, default=True
+        Set to True, both W and H will be estimated from initial guesses.
+        Set to False, only W will be estimated.
+
+    solver : {'cd', 'mu'}, default='cd'
+        Numerical solver to use:
+
+        - 'cd' is a Coordinate Descent solver that uses Fast Hierarchical
+          Alternating Least Squares (Fast HALS).
+        - 'mu' is a Multiplicative Update solver.
+
+        .. versionadded:: 0.17
+           Coordinate Descent solver.
+
+        .. versionadded:: 0.19
+           Multiplicative Update solver.
+
+    beta_loss : float or {'frobenius', 'kullback-leibler', \
+            'itakura-saito'}, default='frobenius'
+        Beta divergence to be minimized, measuring the distance between X
+        and the dot product WH. Note that values different from 'frobenius'
+        (or 2) and 'kullback-leibler' (or 1) lead to significantly slower
+        fits. Note that for beta_loss <= 0 (or 'itakura-saito'), the input
+        matrix X cannot contain zeros. Used only in 'mu' solver.
+
+        .. versionadded:: 0.19
+
+    tol : float, default=1e-4
+        Tolerance of the stopping condition.
+
+    max_iter : int, default=200
+        Maximum number of iterations before timing out.
+
+    alpha_W : float, default=0.0
+        Constant that multiplies the regularization terms of `W`. Set it to zero
+        (default) to have no regularization on `W`.
+
+        .. versionadded:: 1.0
+
+    alpha_H : float or "same", default="same"
+        Constant that multiplies the regularization terms of `H`. Set it to zero to
+        have no regularization on `H`. If "same" (default), it takes the same value as
+        `alpha_W`.
+
+        .. versionadded:: 1.0
+
+    l1_ratio : float, default=0.0
+        The regularization mixing parameter, with 0 <= l1_ratio <= 1.
+        For l1_ratio = 0 the penalty is an elementwise L2 penalty
+        (aka Frobenius Norm).
+        For l1_ratio = 1 it is an elementwise L1 penalty.
+        For 0 < l1_ratio < 1, the penalty is a combination of L1 and L2.
+
+    random_state : int, RandomState instance or None, default=None
+        Used for NMF initialisation (when ``init`` == 'nndsvdar' or
+        'random'), and in Coordinate Descent. Pass an int for reproducible
+        results across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    verbose : int, default=0
+        The verbosity level.
+
+    shuffle : bool, default=False
+        If true, randomize the order of coordinates in the CD solver.
+
+    Returns
+    -------
+    W : ndarray of shape (n_samples, n_components)
+        Solution to the non-negative least squares problem.
+
+    H : ndarray of shape (n_components, n_features)
+        Solution to the non-negative least squares problem.
+
+    n_iter : int
+        Actual number of iterations.
+
+    References
+    ----------
+    .. [1] :doi:`"Fast local algorithms for large scale nonnegative matrix and tensor
+       factorizations" <10.1587/transfun.E92.A.708>`
+       Cichocki, Andrzej, and P. H. A. N. Anh-Huy. IEICE transactions on fundamentals
+       of electronics, communications and computer sciences 92.3: 708-721, 2009.
+
+    .. [2] :doi:`"Algorithms for nonnegative matrix factorization with the
+       beta-divergence" <10.1162/NECO_a_00168>`
+       Fevotte, C., & Idier, J. (2011). Neural Computation, 23(9).
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> X = np.array([[1,1], [2, 1], [3, 1.2], [4, 1], [5, 0.8], [6, 1]])
+    >>> from sklearn.decomposition import non_negative_factorization
+    >>> W, H, n_iter = non_negative_factorization(
+    ...     X, n_components=2, init='random', random_state=0)
+    """
+    est = NMF(
+        n_components=n_components,
+        init=init,
+        solver=solver,
+        beta_loss=beta_loss,
+        tol=tol,
+        max_iter=max_iter,
+        random_state=random_state,
+        alpha_W=alpha_W,
+        alpha_H=alpha_H,
+        l1_ratio=l1_ratio,
+        verbose=verbose,
+        shuffle=shuffle,
+    )
+    est._validate_params()
+
+    X = check_array(X, accept_sparse=("csr", "csc"), dtype=[np.float64, np.float32])
+
+    with config_context(assume_finite=True):
+        W, H, n_iter = est._fit_transform(X, W=W, H=H, update_H=update_H)
+
+    return W, H, n_iter
+
+
+class _BaseNMF(ClassNamePrefixFeaturesOutMixin, TransformerMixin, BaseEstimator, ABC):
+    """Base class for NMF and MiniBatchNMF."""
+
+    # This prevents ``set_split_inverse_transform`` to be generated for the
+    # non-standard ``W`` arg on ``inverse_transform``.
+    # TODO: remove when W is removed in v1.5 for inverse_transform
+    __metadata_request__inverse_transform = {"W": metadata_routing.UNUSED}
+
+    _parameter_constraints: dict = {
+        "n_components": [
+            Interval(Integral, 1, None, closed="left"),
+            None,
+            StrOptions({"auto"}),
+            Hidden(StrOptions({"warn"})),
+        ],
+        "init": [
+            StrOptions({"random", "nndsvd", "nndsvda", "nndsvdar", "custom"}),
+            None,
+        ],
+        "beta_loss": [
+            StrOptions({"frobenius", "kullback-leibler", "itakura-saito"}),
+            Real,
+        ],
+        "tol": [Interval(Real, 0, None, closed="left")],
+        "max_iter": [Interval(Integral, 1, None, closed="left")],
+        "random_state": ["random_state"],
+        "alpha_W": [Interval(Real, 0, None, closed="left")],
+        "alpha_H": [Interval(Real, 0, None, closed="left"), StrOptions({"same"})],
+        "l1_ratio": [Interval(Real, 0, 1, closed="both")],
+        "verbose": ["verbose"],
+    }
+
+    def __init__(
+        self,
+        n_components="warn",
+        *,
+        init=None,
+        beta_loss="frobenius",
+        tol=1e-4,
+        max_iter=200,
+        random_state=None,
+        alpha_W=0.0,
+        alpha_H="same",
+        l1_ratio=0.0,
+        verbose=0,
+    ):
+        self.n_components = n_components
+        self.init = init
+        self.beta_loss = beta_loss
+        self.tol = tol
+        self.max_iter = max_iter
+        self.random_state = random_state
+        self.alpha_W = alpha_W
+        self.alpha_H = alpha_H
+        self.l1_ratio = l1_ratio
+        self.verbose = verbose
+
+    def _check_params(self, X):
+        # n_components
+        self._n_components = self.n_components
+        if self.n_components == "warn":
+            warnings.warn(
+                (
+                    "The default value of `n_components` will change from `None` to"
+                    " `'auto'` in 1.6. Set the value of `n_components` to `None`"
+                    " explicitly to suppress the warning."
+                ),
+                FutureWarning,
+            )
+            self._n_components = None  # Keeping the old default value
+        if self._n_components is None:
+            self._n_components = X.shape[1]
+
+        # beta_loss
+        self._beta_loss = _beta_loss_to_float(self.beta_loss)
+
+    def _check_w_h(self, X, W, H, update_H):
+        """Check W and H, or initialize them."""
+        n_samples, n_features = X.shape
+
+        if self.init == "custom" and update_H:
+            _check_init(H, (self._n_components, n_features), "NMF (input H)")
+            _check_init(W, (n_samples, self._n_components), "NMF (input W)")
+            if self._n_components == "auto":
+                self._n_components = H.shape[0]
+
+            if H.dtype != X.dtype or W.dtype != X.dtype:
+                raise TypeError(
+                    "H and W should have the same dtype as X. Got "
+                    "H.dtype = {} and W.dtype = {}.".format(H.dtype, W.dtype)
+                )
+
+        elif not update_H:
+            if W is not None:
+                warnings.warn(
+                    "When update_H=False, the provided initial W is not used.",
+                    RuntimeWarning,
+                )
+
+            _check_init(H, (self._n_components, n_features), "NMF (input H)")
+            if self._n_components == "auto":
+                self._n_components = H.shape[0]
+
+            if H.dtype != X.dtype:
+                raise TypeError(
+                    "H should have the same dtype as X. Got H.dtype = {}.".format(
+                        H.dtype
+                    )
+                )
+
+            # 'mu' solver should not be initialized by zeros
+            if self.solver == "mu":
+                avg = np.sqrt(X.mean() / self._n_components)
+                W = np.full((n_samples, self._n_components), avg, dtype=X.dtype)
+            else:
+                W = np.zeros((n_samples, self._n_components), dtype=X.dtype)
+
+        else:
+            if W is not None or H is not None:
+                warnings.warn(
+                    (
+                        "When init!='custom', provided W or H are ignored. Set "
+                        " init='custom' to use them as initialization."
+                    ),
+                    RuntimeWarning,
+                )
+
+            if self._n_components == "auto":
+                self._n_components = X.shape[1]
+
+            W, H = _initialize_nmf(
+                X, self._n_components, init=self.init, random_state=self.random_state
+            )
+
+        return W, H
+
+    def _compute_regularization(self, X):
+        """Compute scaled regularization terms."""
+        n_samples, n_features = X.shape
+        alpha_W = self.alpha_W
+        alpha_H = self.alpha_W if self.alpha_H == "same" else self.alpha_H
+
+        l1_reg_W = n_features * alpha_W * self.l1_ratio
+        l1_reg_H = n_samples * alpha_H * self.l1_ratio
+        l2_reg_W = n_features * alpha_W * (1.0 - self.l1_ratio)
+        l2_reg_H = n_samples * alpha_H * (1.0 - self.l1_ratio)
+
+        return l1_reg_W, l1_reg_H, l2_reg_W, l2_reg_H
+
+    def fit(self, X, y=None, **params):
+        """Learn a NMF model for the data X.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            Training vector, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        **params : kwargs
+            Parameters (keyword arguments) and values passed to
+            the fit_transform instance.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        # param validation is done in fit_transform
+
+        self.fit_transform(X, **params)
+        return self
+
+    def inverse_transform(self, Xt=None, W=None):
+        """Transform data back to its original space.
+
+        .. versionadded:: 0.18
+
+        Parameters
+        ----------
+        Xt : {ndarray, sparse matrix} of shape (n_samples, n_components)
+            Transformed data matrix.
+
+        W : deprecated
+            Use `Xt` instead.
+
+            .. deprecated:: 1.3
+
+        Returns
+        -------
+        X : ndarray of shape (n_samples, n_features)
+            Returns a data matrix of the original shape.
+        """
+        if Xt is None and W is None:
+            raise TypeError("Missing required positional argument: Xt")
+
+        if W is not None and Xt is not None:
+            raise ValueError("Please provide only `Xt`, and not `W`.")
+
+        if W is not None:
+            warnings.warn(
+                (
+                    "Input argument `W` was renamed to `Xt` in v1.3 and will be removed"
+                    " in v1.5."
+                ),
+                FutureWarning,
+            )
+            Xt = W
+
+        check_is_fitted(self)
+        return Xt @ self.components_
+
+    @property
+    def _n_features_out(self):
+        """Number of transformed output features."""
+        return self.components_.shape[0]
+
+    def _more_tags(self):
+        return {
+            "requires_positive_X": True,
+            "preserves_dtype": [np.float64, np.float32],
+        }
+
+
+class NMF(_BaseNMF):
+    """Non-Negative Matrix Factorization (NMF).
+
+    Find two non-negative matrices, i.e. matrices with all non-negative elements, (W, H)
+    whose product approximates the non-negative matrix X. This factorization can be used
+    for example for dimensionality reduction, source separation or topic extraction.
+
+    The objective function is:
+
+        .. math::
+
+            L(W, H) &= 0.5 * ||X - WH||_{loss}^2
+
+            &+ alpha\\_W * l1\\_ratio * n\\_features * ||vec(W)||_1
+
+            &+ alpha\\_H * l1\\_ratio * n\\_samples * ||vec(H)||_1
+
+            &+ 0.5 * alpha\\_W * (1 - l1\\_ratio) * n\\_features * ||W||_{Fro}^2
+
+            &+ 0.5 * alpha\\_H * (1 - l1\\_ratio) * n\\_samples * ||H||_{Fro}^2
+
+    Where:
+
+    :math:`||A||_{Fro}^2 = \\sum_{i,j} A_{ij}^2` (Frobenius norm)
+
+    :math:`||vec(A)||_1 = \\sum_{i,j} abs(A_{ij})` (Elementwise L1 norm)
+
+    The generic norm :math:`||X - WH||_{loss}` may represent
+    the Frobenius norm or another supported beta-divergence loss.
+    The choice between options is controlled by the `beta_loss` parameter.
+
+    The regularization terms are scaled by `n_features` for `W` and by `n_samples` for
+    `H` to keep their impact balanced with respect to one another and to the data fit
+    term as independent as possible of the size `n_samples` of the training set.
+
+    The objective function is minimized with an alternating minimization of W
+    and H.
+
+    Note that the transformed data is named W and the components matrix is named H. In
+    the NMF literature, the naming convention is usually the opposite since the data
+    matrix X is transposed.
+
+    Read more in the :ref:`User Guide <NMF>`.
+
+    Parameters
+    ----------
+    n_components : int or {'auto'} or None, default=None
+        Number of components, if n_components is not set all features
+        are kept.
+        If `n_components='auto'`, the number of components is automatically inferred
+        from W or H shapes.
+
+        .. versionchanged:: 1.4
+            Added `'auto'` value.
+
+    init : {'random', 'nndsvd', 'nndsvda', 'nndsvdar', 'custom'}, default=None
+        Method used to initialize the procedure.
+        Valid options:
+
+        - `None`: 'nndsvda' if n_components <= min(n_samples, n_features),
+          otherwise random.
+
+        - `'random'`: non-negative random matrices, scaled with:
+          `sqrt(X.mean() / n_components)`
+
+        - `'nndsvd'`: Nonnegative Double Singular Value Decomposition (NNDSVD)
+          initialization (better for sparseness)
+
+        - `'nndsvda'`: NNDSVD with zeros filled with the average of X
+          (better when sparsity is not desired)
+
+        - `'nndsvdar'` NNDSVD with zeros filled with small random values
+          (generally faster, less accurate alternative to NNDSVDa
+          for when sparsity is not desired)
+
+        - `'custom'`: Use custom matrices `W` and `H` which must both be provided.
+
+        .. versionchanged:: 1.1
+            When `init=None` and n_components is less than n_samples and n_features
+            defaults to `nndsvda` instead of `nndsvd`.
+
+    solver : {'cd', 'mu'}, default='cd'
+        Numerical solver to use:
+
+        - 'cd' is a Coordinate Descent solver.
+        - 'mu' is a Multiplicative Update solver.
+
+        .. versionadded:: 0.17
+           Coordinate Descent solver.
+
+        .. versionadded:: 0.19
+           Multiplicative Update solver.
+
+    beta_loss : float or {'frobenius', 'kullback-leibler', \
+            'itakura-saito'}, default='frobenius'
+        Beta divergence to be minimized, measuring the distance between X
+        and the dot product WH. Note that values different from 'frobenius'
+        (or 2) and 'kullback-leibler' (or 1) lead to significantly slower
+        fits. Note that for beta_loss <= 0 (or 'itakura-saito'), the input
+        matrix X cannot contain zeros. Used only in 'mu' solver.
+
+        .. versionadded:: 0.19
+
+    tol : float, default=1e-4
+        Tolerance of the stopping condition.
+
+    max_iter : int, default=200
+        Maximum number of iterations before timing out.
+
+    random_state : int, RandomState instance or None, default=None
+        Used for initialisation (when ``init`` == 'nndsvdar' or
+        'random'), and in Coordinate Descent. Pass an int for reproducible
+        results across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    alpha_W : float, default=0.0
+        Constant that multiplies the regularization terms of `W`. Set it to zero
+        (default) to have no regularization on `W`.
+
+        .. versionadded:: 1.0
+
+    alpha_H : float or "same", default="same"
+        Constant that multiplies the regularization terms of `H`. Set it to zero to
+        have no regularization on `H`. If "same" (default), it takes the same value as
+        `alpha_W`.
+
+        .. versionadded:: 1.0
+
+    l1_ratio : float, default=0.0
+        The regularization mixing parameter, with 0 <= l1_ratio <= 1.
+        For l1_ratio = 0 the penalty is an elementwise L2 penalty
+        (aka Frobenius Norm).
+        For l1_ratio = 1 it is an elementwise L1 penalty.
+        For 0 < l1_ratio < 1, the penalty is a combination of L1 and L2.
+
+        .. versionadded:: 0.17
+           Regularization parameter *l1_ratio* used in the Coordinate Descent
+           solver.
+
+    verbose : int, default=0
+        Whether to be verbose.
+
+    shuffle : bool, default=False
+        If true, randomize the order of coordinates in the CD solver.
+
+        .. versionadded:: 0.17
+           *shuffle* parameter used in the Coordinate Descent solver.
+
+    Attributes
+    ----------
+    components_ : ndarray of shape (n_components, n_features)
+        Factorization matrix, sometimes called 'dictionary'.
+
+    n_components_ : int
+        The number of components. It is same as the `n_components` parameter
+        if it was given. Otherwise, it will be same as the number of
+        features.
+
+    reconstruction_err_ : float
+        Frobenius norm of the matrix difference, or beta-divergence, between
+        the training data ``X`` and the reconstructed data ``WH`` from
+        the fitted model.
+
+    n_iter_ : int
+        Actual number of iterations.
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    See Also
+    --------
+    DictionaryLearning : Find a dictionary that sparsely encodes data.
+    MiniBatchSparsePCA : Mini-batch Sparse Principal Components Analysis.
+    PCA : Principal component analysis.
+    SparseCoder : Find a sparse representation of data from a fixed,
+        precomputed dictionary.
+    SparsePCA : Sparse Principal Components Analysis.
+    TruncatedSVD : Dimensionality reduction using truncated SVD.
+
+    References
+    ----------
+    .. [1] :doi:`"Fast local algorithms for large scale nonnegative matrix and tensor
+       factorizations" <10.1587/transfun.E92.A.708>`
+       Cichocki, Andrzej, and P. H. A. N. Anh-Huy. IEICE transactions on fundamentals
+       of electronics, communications and computer sciences 92.3: 708-721, 2009.
+
+    .. [2] :doi:`"Algorithms for nonnegative matrix factorization with the
+       beta-divergence" <10.1162/NECO_a_00168>`
+       Fevotte, C., & Idier, J. (2011). Neural Computation, 23(9).
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> X = np.array([[1, 1], [2, 1], [3, 1.2], [4, 1], [5, 0.8], [6, 1]])
+    >>> from sklearn.decomposition import NMF
+    >>> model = NMF(n_components=2, init='random', random_state=0)
+    >>> W = model.fit_transform(X)
+    >>> H = model.components_
+    """
+
+    _parameter_constraints: dict = {
+        **_BaseNMF._parameter_constraints,
+        "solver": [StrOptions({"mu", "cd"})],
+        "shuffle": ["boolean"],
+    }
+
+    def __init__(
+        self,
+        n_components="warn",
+        *,
+        init=None,
+        solver="cd",
+        beta_loss="frobenius",
+        tol=1e-4,
+        max_iter=200,
+        random_state=None,
+        alpha_W=0.0,
+        alpha_H="same",
+        l1_ratio=0.0,
+        verbose=0,
+        shuffle=False,
+    ):
+        super().__init__(
+            n_components=n_components,
+            init=init,
+            beta_loss=beta_loss,
+            tol=tol,
+            max_iter=max_iter,
+            random_state=random_state,
+            alpha_W=alpha_W,
+            alpha_H=alpha_H,
+            l1_ratio=l1_ratio,
+            verbose=verbose,
+        )
+
+        self.solver = solver
+        self.shuffle = shuffle
+
+    def _check_params(self, X):
+        super()._check_params(X)
+
+        # solver
+        if self.solver != "mu" and self.beta_loss not in (2, "frobenius"):
+            # 'mu' is the only solver that handles other beta losses than 'frobenius'
+            raise ValueError(
+                f"Invalid beta_loss parameter: solver {self.solver!r} does not handle "
+                f"beta_loss = {self.beta_loss!r}"
+            )
+        if self.solver == "mu" and self.init == "nndsvd":
+            warnings.warn(
+                (
+                    "The multiplicative update ('mu') solver cannot update "
+                    "zeros present in the initialization, and so leads to "
+                    "poorer results when used jointly with init='nndsvd'. "
+                    "You may try init='nndsvda' or init='nndsvdar' instead."
+                ),
+                UserWarning,
+            )
+
+        return self
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit_transform(self, X, y=None, W=None, H=None):
+        """Learn a NMF model for the data X and returns the transformed data.
+
+        This is more efficient than calling fit followed by transform.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            Training vector, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        W : array-like of shape (n_samples, n_components), default=None
+            If `init='custom'`, it is used as initial guess for the solution.
+            If `None`, uses the initialisation method specified in `init`.
+
+        H : array-like of shape (n_components, n_features), default=None
+            If `init='custom'`, it is used as initial guess for the solution.
+            If `None`, uses the initialisation method specified in `init`.
+
+        Returns
+        -------
+        W : ndarray of shape (n_samples, n_components)
+            Transformed data.
+        """
+        X = self._validate_data(
+            X, accept_sparse=("csr", "csc"), dtype=[np.float64, np.float32]
+        )
+
+        with config_context(assume_finite=True):
+            W, H, n_iter = self._fit_transform(X, W=W, H=H)
+
+        self.reconstruction_err_ = _beta_divergence(
+            X, W, H, self._beta_loss, square_root=True
+        )
+
+        self.n_components_ = H.shape[0]
+        self.components_ = H
+        self.n_iter_ = n_iter
+
+        return W
+
+    def _fit_transform(self, X, y=None, W=None, H=None, update_H=True):
+        """Learn a NMF model for the data X and returns the transformed data.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            Data matrix to be decomposed
+
+        y : Ignored
+
+        W : array-like of shape (n_samples, n_components), default=None
+            If `init='custom'`, it is used as initial guess for the solution.
+            If `update_H=False`, it is initialised as an array of zeros, unless
+            `solver='mu'`, then it is filled with values calculated by
+            `np.sqrt(X.mean() / self._n_components)`.
+            If `None`, uses the initialisation method specified in `init`.
+
+        H : array-like of shape (n_components, n_features), default=None
+            If `init='custom'`, it is used as initial guess for the solution.
+            If `update_H=False`, it is used as a constant, to solve for W only.
+            If `None`, uses the initialisation method specified in `init`.
+
+        update_H : bool, default=True
+            If True, both W and H will be estimated from initial guesses,
+            this corresponds to a call to the 'fit_transform' method.
+            If False, only W will be estimated, this corresponds to a call
+            to the 'transform' method.
+
+        Returns
+        -------
+        W : ndarray of shape (n_samples, n_components)
+            Transformed data.
+
+        H : ndarray of shape (n_components, n_features)
+            Factorization matrix, sometimes called 'dictionary'.
+
+        n_iter_ : int
+            Actual number of iterations.
+        """
+        check_non_negative(X, "NMF (input X)")
+
+        # check parameters
+        self._check_params(X)
+
+        if X.min() == 0 and self._beta_loss <= 0:
+            raise ValueError(
+                "When beta_loss <= 0 and X contains zeros, "
+                "the solver may diverge. Please add small values "
+                "to X, or use a positive beta_loss."
+            )
+
+        # initialize or check W and H
+        W, H = self._check_w_h(X, W, H, update_H)
+
+        # scale the regularization terms
+        l1_reg_W, l1_reg_H, l2_reg_W, l2_reg_H = self._compute_regularization(X)
+
+        if self.solver == "cd":
+            W, H, n_iter = _fit_coordinate_descent(
+                X,
+                W,
+                H,
+                self.tol,
+                self.max_iter,
+                l1_reg_W,
+                l1_reg_H,
+                l2_reg_W,
+                l2_reg_H,
+                update_H=update_H,
+                verbose=self.verbose,
+                shuffle=self.shuffle,
+                random_state=self.random_state,
+            )
+        elif self.solver == "mu":
+            W, H, n_iter, *_ = _fit_multiplicative_update(
+                X,
+                W,
+                H,
+                self._beta_loss,
+                self.max_iter,
+                self.tol,
+                l1_reg_W,
+                l1_reg_H,
+                l2_reg_W,
+                l2_reg_H,
+                update_H,
+                self.verbose,
+            )
+        else:
+            raise ValueError("Invalid solver parameter '%s'." % self.solver)
+
+        if n_iter == self.max_iter and self.tol > 0:
+            warnings.warn(
+                "Maximum number of iterations %d reached. Increase "
+                "it to improve convergence."
+                % self.max_iter,
+                ConvergenceWarning,
+            )
+
+        return W, H, n_iter
+
+    def transform(self, X):
+        """Transform the data X according to the fitted NMF model.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            Training vector, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+
+        Returns
+        -------
+        W : ndarray of shape (n_samples, n_components)
+            Transformed data.
+        """
+        check_is_fitted(self)
+        X = self._validate_data(
+            X, accept_sparse=("csr", "csc"), dtype=[np.float64, np.float32], reset=False
+        )
+
+        with config_context(assume_finite=True):
+            W, *_ = self._fit_transform(X, H=self.components_, update_H=False)
+
+        return W
+
+
+class MiniBatchNMF(_BaseNMF):
+    """Mini-Batch Non-Negative Matrix Factorization (NMF).
+
+    .. versionadded:: 1.1
+
+    Find two non-negative matrices, i.e. matrices with all non-negative elements,
+    (`W`, `H`) whose product approximates the non-negative matrix `X`. This
+    factorization can be used for example for dimensionality reduction, source
+    separation or topic extraction.
+
+    The objective function is:
+
+        .. math::
+
+            L(W, H) &= 0.5 * ||X - WH||_{loss}^2
+
+            &+ alpha\\_W * l1\\_ratio * n\\_features * ||vec(W)||_1
+
+            &+ alpha\\_H * l1\\_ratio * n\\_samples * ||vec(H)||_1
+
+            &+ 0.5 * alpha\\_W * (1 - l1\\_ratio) * n\\_features * ||W||_{Fro}^2
+
+            &+ 0.5 * alpha\\_H * (1 - l1\\_ratio) * n\\_samples * ||H||_{Fro}^2
+
+    Where:
+
+    :math:`||A||_{Fro}^2 = \\sum_{i,j} A_{ij}^2` (Frobenius norm)
+
+    :math:`||vec(A)||_1 = \\sum_{i,j} abs(A_{ij})` (Elementwise L1 norm)
+
+    The generic norm :math:`||X - WH||_{loss}^2` may represent
+    the Frobenius norm or another supported beta-divergence loss.
+    The choice between options is controlled by the `beta_loss` parameter.
+
+    The objective function is minimized with an alternating minimization of `W`
+    and `H`.
+
+    Note that the transformed data is named `W` and the components matrix is
+    named `H`. In the NMF literature, the naming convention is usually the opposite
+    since the data matrix `X` is transposed.
+
+    Read more in the :ref:`User Guide <MiniBatchNMF>`.
+
+    Parameters
+    ----------
+    n_components : int or {'auto'} or None, default=None
+        Number of components, if `n_components` is not set all features
+        are kept.
+        If `n_components='auto'`, the number of components is automatically inferred
+        from W or H shapes.
+
+        .. versionchanged:: 1.4
+            Added `'auto'` value.
+
+    init : {'random', 'nndsvd', 'nndsvda', 'nndsvdar', 'custom'}, default=None
+        Method used to initialize the procedure.
+        Valid options:
+
+        - `None`: 'nndsvda' if `n_components <= min(n_samples, n_features)`,
+          otherwise random.
+
+        - `'random'`: non-negative random matrices, scaled with:
+          `sqrt(X.mean() / n_components)`
+
+        - `'nndsvd'`: Nonnegative Double Singular Value Decomposition (NNDSVD)
+          initialization (better for sparseness).
+
+        - `'nndsvda'`: NNDSVD with zeros filled with the average of X
+          (better when sparsity is not desired).
+
+        - `'nndsvdar'` NNDSVD with zeros filled with small random values
+          (generally faster, less accurate alternative to NNDSVDa
+          for when sparsity is not desired).
+
+        - `'custom'`: Use custom matrices `W` and `H` which must both be provided.
+
+    batch_size : int, default=1024
+        Number of samples in each mini-batch. Large batch sizes
+        give better long-term convergence at the cost of a slower start.
+
+    beta_loss : float or {'frobenius', 'kullback-leibler', \
+            'itakura-saito'}, default='frobenius'
+        Beta divergence to be minimized, measuring the distance between `X`
+        and the dot product `WH`. Note that values different from 'frobenius'
+        (or 2) and 'kullback-leibler' (or 1) lead to significantly slower
+        fits. Note that for `beta_loss <= 0` (or 'itakura-saito'), the input
+        matrix `X` cannot contain zeros.
+
+    tol : float, default=1e-4
+        Control early stopping based on the norm of the differences in `H`
+        between 2 steps. To disable early stopping based on changes in `H`, set
+        `tol` to 0.0.
+
+    max_no_improvement : int, default=10
+        Control early stopping based on the consecutive number of mini batches
+        that does not yield an improvement on the smoothed cost function.
+        To disable convergence detection based on cost function, set
+        `max_no_improvement` to None.
+
+    max_iter : int, default=200
+        Maximum number of iterations over the complete dataset before
+        timing out.
+
+    alpha_W : float, default=0.0
+        Constant that multiplies the regularization terms of `W`. Set it to zero
+        (default) to have no regularization on `W`.
+
+    alpha_H : float or "same", default="same"
+        Constant that multiplies the regularization terms of `H`. Set it to zero to
+        have no regularization on `H`. If "same" (default), it takes the same value as
+        `alpha_W`.
+
+    l1_ratio : float, default=0.0
+        The regularization mixing parameter, with 0 <= l1_ratio <= 1.
+        For l1_ratio = 0 the penalty is an elementwise L2 penalty
+        (aka Frobenius Norm).
+        For l1_ratio = 1 it is an elementwise L1 penalty.
+        For 0 < l1_ratio < 1, the penalty is a combination of L1 and L2.
+
+    forget_factor : float, default=0.7
+        Amount of rescaling of past information. Its value could be 1 with
+        finite datasets. Choosing values < 1 is recommended with online
+        learning as more recent batches will weight more than past batches.
+
+    fresh_restarts : bool, default=False
+        Whether to completely solve for W at each step. Doing fresh restarts will likely
+        lead to a better solution for a same number of iterations but it is much slower.
+
+    fresh_restarts_max_iter : int, default=30
+        Maximum number of iterations when solving for W at each step. Only used when
+        doing fresh restarts. These iterations may be stopped early based on a small
+        change of W controlled by `tol`.
+
+    transform_max_iter : int, default=None
+        Maximum number of iterations when solving for W at transform time.
+        If None, it defaults to `max_iter`.
+
+    random_state : int, RandomState instance or None, default=None
+        Used for initialisation (when ``init`` == 'nndsvdar' or
+        'random'), and in Coordinate Descent. Pass an int for reproducible
+        results across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    verbose : bool, default=False
+        Whether to be verbose.
+
+    Attributes
+    ----------
+    components_ : ndarray of shape (n_components, n_features)
+        Factorization matrix, sometimes called 'dictionary'.
+
+    n_components_ : int
+        The number of components. It is same as the `n_components` parameter
+        if it was given. Otherwise, it will be same as the number of
+        features.
+
+    reconstruction_err_ : float
+        Frobenius norm of the matrix difference, or beta-divergence, between
+        the training data `X` and the reconstructed data `WH` from
+        the fitted model.
+
+    n_iter_ : int
+        Actual number of started iterations over the whole dataset.
+
+    n_steps_ : int
+        Number of mini-batches processed.
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+    See Also
+    --------
+    NMF : Non-negative matrix factorization.
+    MiniBatchDictionaryLearning : Finds a dictionary that can best be used to represent
+        data using a sparse code.
+
+    References
+    ----------
+    .. [1] :doi:`"Fast local algorithms for large scale nonnegative matrix and tensor
+       factorizations" <10.1587/transfun.E92.A.708>`
+       Cichocki, Andrzej, and P. H. A. N. Anh-Huy. IEICE transactions on fundamentals
+       of electronics, communications and computer sciences 92.3: 708-721, 2009.
+
+    .. [2] :doi:`"Algorithms for nonnegative matrix factorization with the
+       beta-divergence" <10.1162/NECO_a_00168>`
+       Fevotte, C., & Idier, J. (2011). Neural Computation, 23(9).
+
+    .. [3] :doi:`"Online algorithms for nonnegative matrix factorization with the
+       Itakura-Saito divergence" <10.1109/ASPAA.2011.6082314>`
+       Lefevre, A., Bach, F., Fevotte, C. (2011). WASPA.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> X = np.array([[1, 1], [2, 1], [3, 1.2], [4, 1], [5, 0.8], [6, 1]])
+    >>> from sklearn.decomposition import MiniBatchNMF
+    >>> model = MiniBatchNMF(n_components=2, init='random', random_state=0)
+    >>> W = model.fit_transform(X)
+    >>> H = model.components_
+    """
+
+    _parameter_constraints: dict = {
+        **_BaseNMF._parameter_constraints,
+        "max_no_improvement": [Interval(Integral, 1, None, closed="left"), None],
+        "batch_size": [Interval(Integral, 1, None, closed="left")],
+        "forget_factor": [Interval(Real, 0, 1, closed="both")],
+        "fresh_restarts": ["boolean"],
+        "fresh_restarts_max_iter": [Interval(Integral, 1, None, closed="left")],
+        "transform_max_iter": [Interval(Integral, 1, None, closed="left"), None],
+    }
+
+    def __init__(
+        self,
+        n_components="warn",
+        *,
+        init=None,
+        batch_size=1024,
+        beta_loss="frobenius",
+        tol=1e-4,
+        max_no_improvement=10,
+        max_iter=200,
+        alpha_W=0.0,
+        alpha_H="same",
+        l1_ratio=0.0,
+        forget_factor=0.7,
+        fresh_restarts=False,
+        fresh_restarts_max_iter=30,
+        transform_max_iter=None,
+        random_state=None,
+        verbose=0,
+    ):
+        super().__init__(
+            n_components=n_components,
+            init=init,
+            beta_loss=beta_loss,
+            tol=tol,
+            max_iter=max_iter,
+            random_state=random_state,
+            alpha_W=alpha_W,
+            alpha_H=alpha_H,
+            l1_ratio=l1_ratio,
+            verbose=verbose,
+        )
+
+        self.max_no_improvement = max_no_improvement
+        self.batch_size = batch_size
+        self.forget_factor = forget_factor
+        self.fresh_restarts = fresh_restarts
+        self.fresh_restarts_max_iter = fresh_restarts_max_iter
+        self.transform_max_iter = transform_max_iter
+
+    def _check_params(self, X):
+        super()._check_params(X)
+
+        # batch_size
+        self._batch_size = min(self.batch_size, X.shape[0])
+
+        # forget_factor
+        self._rho = self.forget_factor ** (self._batch_size / X.shape[0])
+
+        # gamma for Maximization-Minimization (MM) algorithm [Fevotte 2011]
+        if self._beta_loss < 1:
+            self._gamma = 1.0 / (2.0 - self._beta_loss)
+        elif self._beta_loss > 2:
+            self._gamma = 1.0 / (self._beta_loss - 1.0)
+        else:
+            self._gamma = 1.0
+
+        # transform_max_iter
+        self._transform_max_iter = (
+            self.max_iter
+            if self.transform_max_iter is None
+            else self.transform_max_iter
+        )
+
+        return self
+
+    def _solve_W(self, X, H, max_iter):
+        """Minimize the objective function w.r.t W.
+
+        Update W with H being fixed, until convergence. This is the heart
+        of `transform` but it's also used during `fit` when doing fresh restarts.
+        """
+        avg = np.sqrt(X.mean() / self._n_components)
+        W = np.full((X.shape[0], self._n_components), avg, dtype=X.dtype)
+        W_buffer = W.copy()
+
+        # Get scaled regularization terms. Done for each minibatch to take into account
+        # variable sizes of minibatches.
+        l1_reg_W, _, l2_reg_W, _ = self._compute_regularization(X)
+
+        for _ in range(max_iter):
+            W, *_ = _multiplicative_update_w(
+                X, W, H, self._beta_loss, l1_reg_W, l2_reg_W, self._gamma
+            )
+
+            W_diff = linalg.norm(W - W_buffer) / linalg.norm(W)
+            if self.tol > 0 and W_diff <= self.tol:
+                break
+
+            W_buffer[:] = W
+
+        return W
+
+    def _minibatch_step(self, X, W, H, update_H):
+        """Perform the update of W and H for one minibatch."""
+        batch_size = X.shape[0]
+
+        # get scaled regularization terms. Done for each minibatch to take into account
+        # variable sizes of minibatches.
+        l1_reg_W, l1_reg_H, l2_reg_W, l2_reg_H = self._compute_regularization(X)
+
+        # update W
+        if self.fresh_restarts or W is None:
+            W = self._solve_W(X, H, self.fresh_restarts_max_iter)
+        else:
+            W, *_ = _multiplicative_update_w(
+                X, W, H, self._beta_loss, l1_reg_W, l2_reg_W, self._gamma
+            )
+
+        # necessary for stability with beta_loss < 1
+        if self._beta_loss < 1:
+            W[W < np.finfo(np.float64).eps] = 0.0
+
+        batch_cost = (
+            _beta_divergence(X, W, H, self._beta_loss)
+            + l1_reg_W * W.sum()
+            + l1_reg_H * H.sum()
+            + l2_reg_W * (W**2).sum()
+            + l2_reg_H * (H**2).sum()
+        ) / batch_size
+
+        # update H (only at fit or fit_transform)
+        if update_H:
+            H[:] = _multiplicative_update_h(
+                X,
+                W,
+                H,
+                beta_loss=self._beta_loss,
+                l1_reg_H=l1_reg_H,
+                l2_reg_H=l2_reg_H,
+                gamma=self._gamma,
+                A=self._components_numerator,
+                B=self._components_denominator,
+                rho=self._rho,
+            )
+
+            # necessary for stability with beta_loss < 1
+            if self._beta_loss <= 1:
+                H[H < np.finfo(np.float64).eps] = 0.0
+
+        return batch_cost
+
+    def _minibatch_convergence(
+        self, X, batch_cost, H, H_buffer, n_samples, step, n_steps
+    ):
+        """Helper function to encapsulate the early stopping logic"""
+        batch_size = X.shape[0]
+
+        # counts steps starting from 1 for user friendly verbose mode.
+        step = step + 1
+
+        # Ignore first iteration because H is not updated yet.
+        if step == 1:
+            if self.verbose:
+                print(f"Minibatch step {step}/{n_steps}: mean batch cost: {batch_cost}")
+            return False
+
+        # Compute an Exponentially Weighted Average of the cost function to
+        # monitor the convergence while discarding minibatch-local stochastic
+        # variability: https://en.wikipedia.org/wiki/Moving_average
+        if self._ewa_cost is None:
+            self._ewa_cost = batch_cost
+        else:
+            alpha = batch_size / (n_samples + 1)
+            alpha = min(alpha, 1)
+            self._ewa_cost = self._ewa_cost * (1 - alpha) + batch_cost * alpha
+
+        # Log progress to be able to monitor convergence
+        if self.verbose:
+            print(
+                f"Minibatch step {step}/{n_steps}: mean batch cost: "
+                f"{batch_cost}, ewa cost: {self._ewa_cost}"
+            )
+
+        # Early stopping based on change of H
+        H_diff = linalg.norm(H - H_buffer) / linalg.norm(H)
+        if self.tol > 0 and H_diff <= self.tol:
+            if self.verbose:
+                print(f"Converged (small H change) at step {step}/{n_steps}")
+            return True
+
+        # Early stopping heuristic due to lack of improvement on smoothed
+        # cost function
+        if self._ewa_cost_min is None or self._ewa_cost < self._ewa_cost_min:
+            self._no_improvement = 0
+            self._ewa_cost_min = self._ewa_cost
+        else:
+            self._no_improvement += 1
+
+        if (
+            self.max_no_improvement is not None
+            and self._no_improvement >= self.max_no_improvement
+        ):
+            if self.verbose:
+                print(
+                    "Converged (lack of improvement in objective function) "
+                    f"at step {step}/{n_steps}"
+                )
+            return True
+
+        return False
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit_transform(self, X, y=None, W=None, H=None):
+        """Learn a NMF model for the data X and returns the transformed data.
+
+        This is more efficient than calling fit followed by transform.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            Data matrix to be decomposed.
+
+        y : Ignored
+            Not used, present here for API consistency by convention.
+
+        W : array-like of shape (n_samples, n_components), default=None
+            If `init='custom'`, it is used as initial guess for the solution.
+            If `None`, uses the initialisation method specified in `init`.
+
+        H : array-like of shape (n_components, n_features), default=None
+            If `init='custom'`, it is used as initial guess for the solution.
+            If `None`, uses the initialisation method specified in `init`.
+
+        Returns
+        -------
+        W : ndarray of shape (n_samples, n_components)
+            Transformed data.
+        """
+        X = self._validate_data(
+            X, accept_sparse=("csr", "csc"), dtype=[np.float64, np.float32]
+        )
+
+        with config_context(assume_finite=True):
+            W, H, n_iter, n_steps = self._fit_transform(X, W=W, H=H)
+
+        self.reconstruction_err_ = _beta_divergence(
+            X, W, H, self._beta_loss, square_root=True
+        )
+
+        self.n_components_ = H.shape[0]
+        self.components_ = H
+        self.n_iter_ = n_iter
+        self.n_steps_ = n_steps
+
+        return W
+
+    def _fit_transform(self, X, W=None, H=None, update_H=True):
+        """Learn a NMF model for the data X and returns the transformed data.
+
+        Parameters
+        ----------
+        X : {ndarray, sparse matrix} of shape (n_samples, n_features)
+            Data matrix to be decomposed.
+
+        W : array-like of shape (n_samples, n_components), default=None
+            If `init='custom'`, it is used as initial guess for the solution.
+            If `update_H=False`, it is initialised as an array of zeros, unless
+            `solver='mu'`, then it is filled with values calculated by
+            `np.sqrt(X.mean() / self._n_components)`.
+            If `None`, uses the initialisation method specified in `init`.
+
+        H : array-like of shape (n_components, n_features), default=None
+            If `init='custom'`, it is used as initial guess for the solution.
+            If `update_H=False`, it is used as a constant, to solve for W only.
+            If `None`, uses the initialisation method specified in `init`.
+
+        update_H : bool, default=True
+            If True, both W and H will be estimated from initial guesses,
+            this corresponds to a call to the `fit_transform` method.
+            If False, only W will be estimated, this corresponds to a call
+            to the `transform` method.
+
+        Returns
+        -------
+        W : ndarray of shape (n_samples, n_components)
+            Transformed data.
+
+        H : ndarray of shape (n_components, n_features)
+            Factorization matrix, sometimes called 'dictionary'.
+
+        n_iter : int
+            Actual number of started iterations over the whole dataset.
+
+        n_steps : int
+            Number of mini-batches processed.
+        """
+        check_non_negative(X, "MiniBatchNMF (input X)")
+        self._check_params(X)
+
+        if X.min() == 0 and self._beta_loss <= 0:
+            raise ValueError(
+                "When beta_loss <= 0 and X contains zeros, "
+                "the solver may diverge. Please add small values "
+                "to X, or use a positive beta_loss."
+            )
+
+        n_samples = X.shape[0]
+
+        # initialize or check W and H
+        W, H = self._check_w_h(X, W, H, update_H)
+        H_buffer = H.copy()
+
+        # Initialize auxiliary matrices
+        self._components_numerator = H.copy()
+        self._components_denominator = np.ones(H.shape, dtype=H.dtype)
+
+        # Attributes to monitor the convergence
+        self._ewa_cost = None
+        self._ewa_cost_min = None
+        self._no_improvement = 0
+
+        batches = gen_batches(n_samples, self._batch_size)
+        batches = itertools.cycle(batches)
+        n_steps_per_iter = int(np.ceil(n_samples / self._batch_size))
+        n_steps = self.max_iter * n_steps_per_iter
+
+        for i, batch in zip(range(n_steps), batches):
+            batch_cost = self._minibatch_step(X[batch], W[batch], H, update_H)
+
+            if update_H and self._minibatch_convergence(
+                X[batch], batch_cost, H, H_buffer, n_samples, i, n_steps
+            ):
+                break
+
+            H_buffer[:] = H
+
+        if self.fresh_restarts:
+            W = self._solve_W(X, H, self._transform_max_iter)
+
+        n_steps = i + 1
+        n_iter = int(np.ceil(n_steps / n_steps_per_iter))
+
+        if n_iter == self.max_iter and self.tol > 0:
+            warnings.warn(
+                (
+                    f"Maximum number of iterations {self.max_iter} reached. "
+                    "Increase it to improve convergence."
+                ),
+                ConvergenceWarning,
+            )
+
+        return W, H, n_iter, n_steps
+
+    def transform(self, X):
+        """Transform the data X according to the fitted MiniBatchNMF model.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            Data matrix to be transformed by the model.
+
+        Returns
+        -------
+        W : ndarray of shape (n_samples, n_components)
+            Transformed data.
+        """
+        check_is_fitted(self)
+        X = self._validate_data(
+            X, accept_sparse=("csr", "csc"), dtype=[np.float64, np.float32], reset=False
+        )
+
+        W = self._solve_W(X, self.components_, self._transform_max_iter)
+
+        return W
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def partial_fit(self, X, y=None, W=None, H=None):
+        """Update the model using the data in `X` as a mini-batch.
+
+        This method is expected to be called several times consecutively
+        on different chunks of a dataset so as to implement out-of-core
+        or online learning.
+
+        This is especially useful when the whole dataset is too big to fit in
+        memory at once (see :ref:`scaling_strategies`).
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            Data matrix to be decomposed.
+
+        y : Ignored
+            Not used, present here for API consistency by convention.
+
+        W : array-like of shape (n_samples, n_components), default=None
+            If `init='custom'`, it is used as initial guess for the solution.
+            Only used for the first call to `partial_fit`.
+
+        H : array-like of shape (n_components, n_features), default=None
+            If `init='custom'`, it is used as initial guess for the solution.
+            Only used for the first call to `partial_fit`.
+
+        Returns
+        -------
+        self
+            Returns the instance itself.
+        """
+        has_components = hasattr(self, "components_")
+
+        X = self._validate_data(
+            X,
+            accept_sparse=("csr", "csc"),
+            dtype=[np.float64, np.float32],
+            reset=not has_components,
+        )
+
+        if not has_components:
+            # This instance has not been fitted yet (fit or partial_fit)
+            self._check_params(X)
+            _, H = self._check_w_h(X, W=W, H=H, update_H=True)
+
+            self._components_numerator = H.copy()
+            self._components_denominator = np.ones(H.shape, dtype=H.dtype)
+            self.n_steps_ = 0
+        else:
+            H = self.components_
+
+        self._minibatch_step(X, None, H, update_H=True)
+
+        self.n_components_ = H.shape[0]
+        self.components_ = H
+        self.n_steps_ += 1
+
+        return self

venv/lib/python3.10/site-packages/sklearn/decomposition/_pca.py

@@ -0,0 +1,747 @@
+""" Principal Component Analysis.
+"""
+
+# Author: Alexandre Gramfort <[email protected]>
+#         Olivier Grisel <[email protected]>
+#         Mathieu Blondel <[email protected]>
+#         Denis A. Engemann <[email protected]>
+#         Michael Eickenberg <[email protected]>
+#         Giorgio Patrini <[email protected]>
+#
+# License: BSD 3 clause
+
+from math import log, sqrt
+from numbers import Integral, Real
+
+import numpy as np
+from scipy import linalg
+from scipy.sparse import issparse
+from scipy.sparse.linalg import svds
+from scipy.special import gammaln
+
+from ..base import _fit_context
+from ..utils import check_random_state
+from ..utils._arpack import _init_arpack_v0
+from ..utils._array_api import _convert_to_numpy, get_namespace
+from ..utils._param_validation import Interval, RealNotInt, StrOptions
+from ..utils.extmath import fast_logdet, randomized_svd, stable_cumsum, svd_flip
+from ..utils.sparsefuncs import _implicit_column_offset, mean_variance_axis
+from ..utils.validation import check_is_fitted
+from ._base import _BasePCA
+
+
+def _assess_dimension(spectrum, rank, n_samples):
+    """Compute the log-likelihood of a rank ``rank`` dataset.
+
+    The dataset is assumed to be embedded in gaussian noise of shape(n,
+    dimf) having spectrum ``spectrum``. This implements the method of
+    T. P. Minka.
+
+    Parameters
+    ----------
+    spectrum : ndarray of shape (n_features,)
+        Data spectrum.
+    rank : int
+        Tested rank value. It should be strictly lower than n_features,
+        otherwise the method isn't specified (division by zero in equation
+        (31) from the paper).
+    n_samples : int
+        Number of samples.
+
+    Returns
+    -------
+    ll : float
+        The log-likelihood.
+
+    References
+    ----------
+    This implements the method of `Thomas P. Minka:
+    Automatic Choice of Dimensionality for PCA. NIPS 2000: 598-604
+    <https://proceedings.neurips.cc/paper/2000/file/7503cfacd12053d309b6bed5c89de212-Paper.pdf>`_
+    """
+    xp, _ = get_namespace(spectrum)
+
+    n_features = spectrum.shape[0]
+    if not 1 <= rank < n_features:
+        raise ValueError("the tested rank should be in [1, n_features - 1]")
+
+    eps = 1e-15
+
+    if spectrum[rank - 1] < eps:
+        # When the tested rank is associated with a small eigenvalue, there's
+        # no point in computing the log-likelihood: it's going to be very
+        # small and won't be the max anyway. Also, it can lead to numerical
+        # issues below when computing pa, in particular in log((spectrum[i] -
+        # spectrum[j]) because this will take the log of something very small.
+        return -xp.inf
+
+    pu = -rank * log(2.0)
+    for i in range(1, rank + 1):
+        pu += (
+            gammaln((n_features - i + 1) / 2.0)
+            - log(xp.pi) * (n_features - i + 1) / 2.0
+        )
+
+    pl = xp.sum(xp.log(spectrum[:rank]))
+    pl = -pl * n_samples / 2.0
+
+    v = max(eps, xp.sum(spectrum[rank:]) / (n_features - rank))
+    pv = -log(v) * n_samples * (n_features - rank) / 2.0
+
+    m = n_features * rank - rank * (rank + 1.0) / 2.0
+    pp = log(2.0 * xp.pi) * (m + rank) / 2.0
+
+    pa = 0.0
+    spectrum_ = xp.asarray(spectrum, copy=True)
+    spectrum_[rank:n_features] = v
+    for i in range(rank):
+        for j in range(i + 1, spectrum.shape[0]):
+            pa += log(
+                (spectrum[i] - spectrum[j]) * (1.0 / spectrum_[j] - 1.0 / spectrum_[i])
+            ) + log(n_samples)
+
+    ll = pu + pl + pv + pp - pa / 2.0 - rank * log(n_samples) / 2.0
+
+    return ll
+
+
+def _infer_dimension(spectrum, n_samples):
+    """Infers the dimension of a dataset with a given spectrum.
+
+    The returned value will be in [1, n_features - 1].
+    """
+    xp, _ = get_namespace(spectrum)
+
+    ll = xp.empty_like(spectrum)
+    ll[0] = -xp.inf  # we don't want to return n_components = 0
+    for rank in range(1, spectrum.shape[0]):
+        ll[rank] = _assess_dimension(spectrum, rank, n_samples)
+    return xp.argmax(ll)
+
+
+class PCA(_BasePCA):
+    """Principal component analysis (PCA).
+
+    Linear dimensionality reduction using Singular Value Decomposition of the
+    data to project it to a lower dimensional space. The input data is centered
+    but not scaled for each feature before applying the SVD.
+
+    It uses the LAPACK implementation of the full SVD or a randomized truncated
+    SVD by the method of Halko et al. 2009, depending on the shape of the input
+    data and the number of components to extract.
+
+    It can also use the scipy.sparse.linalg ARPACK implementation of the
+    truncated SVD.
+
+    Notice that this class does not support sparse input. See
+    :class:`TruncatedSVD` for an alternative with sparse data.
+
+    For a usage example, see
+    :ref:`sphx_glr_auto_examples_decomposition_plot_pca_iris.py`
+
+    Read more in the :ref:`User Guide <PCA>`.
+
+    Parameters
+    ----------
+    n_components : int, float or 'mle', default=None
+        Number of components to keep.
+        if n_components is not set all components are kept::
+
+            n_components == min(n_samples, n_features)
+
+        If ``n_components == 'mle'`` and ``svd_solver == 'full'``, Minka's
+        MLE is used to guess the dimension. Use of ``n_components == 'mle'``
+        will interpret ``svd_solver == 'auto'`` as ``svd_solver == 'full'``.
+
+        If ``0 < n_components < 1`` and ``svd_solver == 'full'``, select the
+        number of components such that the amount of variance that needs to be
+        explained is greater than the percentage specified by n_components.
+
+        If ``svd_solver == 'arpack'``, the number of components must be
+        strictly less than the minimum of n_features and n_samples.
+
+        Hence, the None case results in::
+
+            n_components == min(n_samples, n_features) - 1
+
+    copy : bool, default=True
+        If False, data passed to fit are overwritten and running
+        fit(X).transform(X) will not yield the expected results,
+        use fit_transform(X) instead.
+
+    whiten : bool, default=False
+        When True (False by default) the `components_` vectors are multiplied
+        by the square root of n_samples and then divided by the singular values
+        to ensure uncorrelated outputs with unit component-wise variances.
+
+        Whitening will remove some information from the transformed signal
+        (the relative variance scales of the components) but can sometime
+        improve the predictive accuracy of the downstream estimators by
+        making their data respect some hard-wired assumptions.
+
+    svd_solver : {'auto', 'full', 'arpack', 'randomized'}, default='auto'
+        If auto :
+            The solver is selected by a default policy based on `X.shape` and
+            `n_components`: if the input data is larger than 500x500 and the
+            number of components to extract is lower than 80% of the smallest
+            dimension of the data, then the more efficient 'randomized'
+            method is enabled. Otherwise the exact full SVD is computed and
+            optionally truncated afterwards.
+        If full :
+            run exact full SVD calling the standard LAPACK solver via
+            `scipy.linalg.svd` and select the components by postprocessing
+        If arpack :
+            run SVD truncated to n_components calling ARPACK solver via
+            `scipy.sparse.linalg.svds`. It requires strictly
+            0 < n_components < min(X.shape)
+        If randomized :
+            run randomized SVD by the method of Halko et al.
+
+        .. versionadded:: 0.18.0
+
+    tol : float, default=0.0
+        Tolerance for singular values computed by svd_solver == 'arpack'.
+        Must be of range [0.0, infinity).
+
+        .. versionadded:: 0.18.0
+
+    iterated_power : int or 'auto', default='auto'
+        Number of iterations for the power method computed by
+        svd_solver == 'randomized'.
+        Must be of range [0, infinity).
+
+        .. versionadded:: 0.18.0
+
+    n_oversamples : int, default=10
+        This parameter is only relevant when `svd_solver="randomized"`.
+        It corresponds to the additional number of random vectors to sample the
+        range of `X` so as to ensure proper conditioning. See
+        :func:`~sklearn.utils.extmath.randomized_svd` for more details.
+
+        .. versionadded:: 1.1
+
+    power_iteration_normalizer : {'auto', 'QR', 'LU', 'none'}, default='auto'
+        Power iteration normalizer for randomized SVD solver.
+        Not used by ARPACK. See :func:`~sklearn.utils.extmath.randomized_svd`
+        for more details.
+
+        .. versionadded:: 1.1
+
+    random_state : int, RandomState instance or None, default=None
+        Used when the 'arpack' or 'randomized' solvers are used. Pass an int
+        for reproducible results across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+        .. versionadded:: 0.18.0
+
+    Attributes
+    ----------
+    components_ : ndarray of shape (n_components, n_features)
+        Principal axes in feature space, representing the directions of
+        maximum variance in the data. Equivalently, the right singular
+        vectors of the centered input data, parallel to its eigenvectors.
+        The components are sorted by decreasing ``explained_variance_``.
+
+    explained_variance_ : ndarray of shape (n_components,)
+        The amount of variance explained by each of the selected components.
+        The variance estimation uses `n_samples - 1` degrees of freedom.
+
+        Equal to n_components largest eigenvalues
+        of the covariance matrix of X.
+
+        .. versionadded:: 0.18
+
+    explained_variance_ratio_ : ndarray of shape (n_components,)
+        Percentage of variance explained by each of the selected components.
+
+        If ``n_components`` is not set then all components are stored and the
+        sum of the ratios is equal to 1.0.
+
+    singular_values_ : ndarray of shape (n_components,)
+        The singular values corresponding to each of the selected components.
+        The singular values are equal to the 2-norms of the ``n_components``
+        variables in the lower-dimensional space.
+
+        .. versionadded:: 0.19
+
+    mean_ : ndarray of shape (n_features,)
+        Per-feature empirical mean, estimated from the training set.
+
+        Equal to `X.mean(axis=0)`.
+
+    n_components_ : int
+        The estimated number of components. When n_components is set
+        to 'mle' or a number between 0 and 1 (with svd_solver == 'full') this
+        number is estimated from input data. Otherwise it equals the parameter
+        n_components, or the lesser value of n_features and n_samples
+        if n_components is None.
+
+    n_samples_ : int
+        Number of samples in the training data.
+
+    noise_variance_ : float
+        The estimated noise covariance following the Probabilistic PCA model
+        from Tipping and Bishop 1999. See "Pattern Recognition and
+        Machine Learning" by C. Bishop, 12.2.1 p. 574 or
+        http://www.miketipping.com/papers/met-mppca.pdf. It is required to
+        compute the estimated data covariance and score samples.
+
+        Equal to the average of (min(n_features, n_samples) - n_components)
+        smallest eigenvalues of the covariance matrix of X.
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    See Also
+    --------
+    KernelPCA : Kernel Principal Component Analysis.
+    SparsePCA : Sparse Principal Component Analysis.
+    TruncatedSVD : Dimensionality reduction using truncated SVD.
+    IncrementalPCA : Incremental Principal Component Analysis.
+
+    References
+    ----------
+    For n_components == 'mle', this class uses the method from:
+    `Minka, T. P.. "Automatic choice of dimensionality for PCA".
+    In NIPS, pp. 598-604 <https://tminka.github.io/papers/pca/minka-pca.pdf>`_
+
+    Implements the probabilistic PCA model from:
+    `Tipping, M. E., and Bishop, C. M. (1999). "Probabilistic principal
+    component analysis". Journal of the Royal Statistical Society:
+    Series B (Statistical Methodology), 61(3), 611-622.
+    <http://www.miketipping.com/papers/met-mppca.pdf>`_
+    via the score and score_samples methods.
+
+    For svd_solver == 'arpack', refer to `scipy.sparse.linalg.svds`.
+
+    For svd_solver == 'randomized', see:
+    :doi:`Halko, N., Martinsson, P. G., and Tropp, J. A. (2011).
+    "Finding structure with randomness: Probabilistic algorithms for
+    constructing approximate matrix decompositions".
+    SIAM review, 53(2), 217-288.
+    <10.1137/090771806>`
+    and also
+    :doi:`Martinsson, P. G., Rokhlin, V., and Tygert, M. (2011).
+    "A randomized algorithm for the decomposition of matrices".
+    Applied and Computational Harmonic Analysis, 30(1), 47-68.
+    <10.1016/j.acha.2010.02.003>`
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.decomposition import PCA
+    >>> X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])
+    >>> pca = PCA(n_components=2)
+    >>> pca.fit(X)
+    PCA(n_components=2)
+    >>> print(pca.explained_variance_ratio_)
+    [0.9924... 0.0075...]
+    >>> print(pca.singular_values_)
+    [6.30061... 0.54980...]
+
+    >>> pca = PCA(n_components=2, svd_solver='full')
+    >>> pca.fit(X)
+    PCA(n_components=2, svd_solver='full')
+    >>> print(pca.explained_variance_ratio_)
+    [0.9924... 0.00755...]
+    >>> print(pca.singular_values_)
+    [6.30061... 0.54980...]
+
+    >>> pca = PCA(n_components=1, svd_solver='arpack')
+    >>> pca.fit(X)
+    PCA(n_components=1, svd_solver='arpack')
+    >>> print(pca.explained_variance_ratio_)
+    [0.99244...]
+    >>> print(pca.singular_values_)
+    [6.30061...]
+    """
+
+    _parameter_constraints: dict = {
+        "n_components": [
+            Interval(Integral, 0, None, closed="left"),
+            Interval(RealNotInt, 0, 1, closed="neither"),
+            StrOptions({"mle"}),
+            None,
+        ],
+        "copy": ["boolean"],
+        "whiten": ["boolean"],
+        "svd_solver": [StrOptions({"auto", "full", "arpack", "randomized"})],
+        "tol": [Interval(Real, 0, None, closed="left")],
+        "iterated_power": [
+            StrOptions({"auto"}),
+            Interval(Integral, 0, None, closed="left"),
+        ],
+        "n_oversamples": [Interval(Integral, 1, None, closed="left")],
+        "power_iteration_normalizer": [StrOptions({"auto", "QR", "LU", "none"})],
+        "random_state": ["random_state"],
+    }
+
+    def __init__(
+        self,
+        n_components=None,
+        *,
+        copy=True,
+        whiten=False,
+        svd_solver="auto",
+        tol=0.0,
+        iterated_power="auto",
+        n_oversamples=10,
+        power_iteration_normalizer="auto",
+        random_state=None,
+    ):
+        self.n_components = n_components
+        self.copy = copy
+        self.whiten = whiten
+        self.svd_solver = svd_solver
+        self.tol = tol
+        self.iterated_power = iterated_power
+        self.n_oversamples = n_oversamples
+        self.power_iteration_normalizer = power_iteration_normalizer
+        self.random_state = random_state
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, X, y=None):
+        """Fit the model with X.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} 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
+            Ignored.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        self._fit(X)
+        return self
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit_transform(self, X, y=None):
+        """Fit the model with X and apply the dimensionality reduction on X.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} 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
+            Ignored.
+
+        Returns
+        -------
+        X_new : ndarray of shape (n_samples, n_components)
+            Transformed values.
+
+        Notes
+        -----
+        This method returns a Fortran-ordered array. To convert it to a
+        C-ordered array, use 'np.ascontiguousarray'.
+        """
+        U, S, Vt = self._fit(X)
+        U = U[:, : self.n_components_]
+
+        if self.whiten:
+            # X_new = X * V / S * sqrt(n_samples) = U * sqrt(n_samples)
+            U *= sqrt(X.shape[0] - 1)
+        else:
+            # X_new = X * V = U * S * Vt * V = U * S
+            U *= S[: self.n_components_]
+
+        return U
+
+    def _fit(self, X):
+        """Dispatch to the right submethod depending on the chosen solver."""
+        xp, is_array_api_compliant = get_namespace(X)
+
+        # Raise an error for sparse input and unsupported svd_solver
+        if issparse(X) and self.svd_solver != "arpack":
+            raise TypeError(
+                'PCA only support sparse inputs with the "arpack" solver, while '
+                f'"{self.svd_solver}" was passed. See TruncatedSVD for a possible'
+                " alternative."
+            )
+        # Raise an error for non-Numpy input and arpack solver.
+        if self.svd_solver == "arpack" and is_array_api_compliant:
+            raise ValueError(
+                "PCA with svd_solver='arpack' is not supported for Array API inputs."
+            )
+
+        X = self._validate_data(
+            X,
+            dtype=[xp.float64, xp.float32],
+            accept_sparse=("csr", "csc"),
+            ensure_2d=True,
+            copy=self.copy,
+        )
+
+        # Handle n_components==None
+        if self.n_components is None:
+            if self.svd_solver != "arpack":
+                n_components = min(X.shape)
+            else:
+                n_components = min(X.shape) - 1
+        else:
+            n_components = self.n_components
+
+        # Handle svd_solver
+        self._fit_svd_solver = self.svd_solver
+        if self._fit_svd_solver == "auto":
+            # Small problem or n_components == 'mle', just call full PCA
+            if max(X.shape) <= 500 or n_components == "mle":
+                self._fit_svd_solver = "full"
+            elif 1 <= n_components < 0.8 * min(X.shape):
+                self._fit_svd_solver = "randomized"
+            # This is also the case of n_components in (0,1)
+            else:
+                self._fit_svd_solver = "full"
+
+        # Call different fits for either full or truncated SVD
+        if self._fit_svd_solver == "full":
+            return self._fit_full(X, n_components)
+        elif self._fit_svd_solver in ["arpack", "randomized"]:
+            return self._fit_truncated(X, n_components, self._fit_svd_solver)
+
+    def _fit_full(self, X, n_components):
+        """Fit the model by computing full SVD on X."""
+        xp, is_array_api_compliant = get_namespace(X)
+
+        n_samples, n_features = X.shape
+
+        if n_components == "mle":
+            if n_samples < n_features:
+                raise ValueError(
+                    "n_components='mle' is only supported if n_samples >= n_features"
+                )
+        elif not 0 <= n_components <= min(n_samples, n_features):
+            raise ValueError(
+                "n_components=%r must be between 0 and "
+                "min(n_samples, n_features)=%r with "
+                "svd_solver='full'" % (n_components, min(n_samples, n_features))
+            )
+
+        # Center data
+        self.mean_ = xp.mean(X, axis=0)
+        X -= self.mean_
+
+        if not is_array_api_compliant:
+            # Use scipy.linalg with NumPy/SciPy inputs for the sake of not
+            # introducing unanticipated behavior changes. In the long run we
+            # could instead decide to always use xp.linalg.svd for all inputs,
+            # but that would make this code rely on numpy's SVD instead of
+            # scipy's. It's not 100% clear whether they use the same LAPACK
+            # solver by default though (assuming both are built against the
+            # same BLAS).
+            U, S, Vt = linalg.svd(X, full_matrices=False)
+        else:
+            U, S, Vt = xp.linalg.svd(X, full_matrices=False)
+        # flip eigenvectors' sign to enforce deterministic output
+        U, Vt = svd_flip(U, Vt)
+
+        components_ = Vt
+
+        # Get variance explained by singular values
+        explained_variance_ = (S**2) / (n_samples - 1)
+        total_var = xp.sum(explained_variance_)
+        explained_variance_ratio_ = explained_variance_ / total_var
+        singular_values_ = xp.asarray(S, copy=True)  # Store the singular values.
+
+        # Postprocess the number of components required
+        if n_components == "mle":
+            n_components = _infer_dimension(explained_variance_, n_samples)
+        elif 0 < n_components < 1.0:
+            # number of components for which the cumulated explained
+            # variance percentage is superior to the desired threshold
+            # side='right' ensures that number of features selected
+            # their variance is always greater than n_components float
+            # passed. More discussion in issue: #15669
+            if is_array_api_compliant:
+                # Convert to numpy as xp.cumsum and xp.searchsorted are not
+                # part of the Array API standard yet:
+                #
+                # https://github.com/data-apis/array-api/issues/597
+                # https://github.com/data-apis/array-api/issues/688
+                #
+                # Furthermore, it's not always safe to call them for namespaces
+                # that already implement them: for instance as
+                # cupy.searchsorted does not accept a float as second argument.
+                explained_variance_ratio_np = _convert_to_numpy(
+                    explained_variance_ratio_, xp=xp
+                )
+            else:
+                explained_variance_ratio_np = explained_variance_ratio_
+            ratio_cumsum = stable_cumsum(explained_variance_ratio_np)
+            n_components = np.searchsorted(ratio_cumsum, n_components, side="right") + 1
+
+        # Compute noise covariance using Probabilistic PCA model
+        # The sigma2 maximum likelihood (cf. eq. 12.46)
+        if n_components < min(n_features, n_samples):
+            self.noise_variance_ = xp.mean(explained_variance_[n_components:])
+        else:
+            self.noise_variance_ = 0.0
+
+        self.n_samples_ = n_samples
+        self.components_ = components_[:n_components, :]
+        self.n_components_ = n_components
+        self.explained_variance_ = explained_variance_[:n_components]
+        self.explained_variance_ratio_ = explained_variance_ratio_[:n_components]
+        self.singular_values_ = singular_values_[:n_components]
+
+        return U, S, Vt
+
+    def _fit_truncated(self, X, n_components, svd_solver):
+        """Fit the model by computing truncated SVD (by ARPACK or randomized)
+        on X.
+        """
+        xp, _ = get_namespace(X)
+
+        n_samples, n_features = X.shape
+
+        if isinstance(n_components, str):
+            raise ValueError(
+                "n_components=%r cannot be a string with svd_solver='%s'"
+                % (n_components, svd_solver)
+            )
+        elif not 1 <= n_components <= min(n_samples, n_features):
+            raise ValueError(
+                "n_components=%r must be between 1 and "
+                "min(n_samples, n_features)=%r with "
+                "svd_solver='%s'"
+                % (n_components, min(n_samples, n_features), svd_solver)
+            )
+        elif svd_solver == "arpack" and n_components == min(n_samples, n_features):
+            raise ValueError(
+                "n_components=%r must be strictly less than "
+                "min(n_samples, n_features)=%r with "
+                "svd_solver='%s'"
+                % (n_components, min(n_samples, n_features), svd_solver)
+            )
+
+        random_state = check_random_state(self.random_state)
+
+        # Center data
+        total_var = None
+        if issparse(X):
+            self.mean_, var = mean_variance_axis(X, axis=0)
+            total_var = var.sum() * n_samples / (n_samples - 1)  # ddof=1
+            X = _implicit_column_offset(X, self.mean_)
+        else:
+            self.mean_ = xp.mean(X, axis=0)
+            X -= self.mean_
+
+        if svd_solver == "arpack":
+            v0 = _init_arpack_v0(min(X.shape), random_state)
+            U, S, Vt = svds(X, k=n_components, tol=self.tol, v0=v0)
+            # svds doesn't abide by scipy.linalg.svd/randomized_svd
+            # conventions, so reverse its outputs.
+            S = S[::-1]
+            # flip eigenvectors' sign to enforce deterministic output
+            U, Vt = svd_flip(U[:, ::-1], Vt[::-1])
+
+        elif svd_solver == "randomized":
+            # sign flipping is done inside
+            U, S, Vt = randomized_svd(
+                X,
+                n_components=n_components,
+                n_oversamples=self.n_oversamples,
+                n_iter=self.iterated_power,
+                power_iteration_normalizer=self.power_iteration_normalizer,
+                flip_sign=True,
+                random_state=random_state,
+            )
+
+        self.n_samples_ = n_samples
+        self.components_ = Vt
+        self.n_components_ = n_components
+
+        # Get variance explained by singular values
+        self.explained_variance_ = (S**2) / (n_samples - 1)
+
+        # Workaround in-place variance calculation since at the time numpy
+        # did not have a way to calculate variance in-place.
+        #
+        # TODO: update this code to either:
+        # * Use the array-api variance calculation, unless memory usage suffers
+        # * Update sklearn.utils.extmath._incremental_mean_and_var to support array-api
+        # See: https://github.com/scikit-learn/scikit-learn/pull/18689#discussion_r1335540991
+        if total_var is None:
+            N = X.shape[0] - 1
+            X **= 2
+            total_var = xp.sum(X) / N
+
+        self.explained_variance_ratio_ = self.explained_variance_ / total_var
+        self.singular_values_ = xp.asarray(S, copy=True)  # Store the singular values.
+
+        if self.n_components_ < min(n_features, n_samples):
+            self.noise_variance_ = total_var - xp.sum(self.explained_variance_)
+            self.noise_variance_ /= min(n_features, n_samples) - n_components
+        else:
+            self.noise_variance_ = 0.0
+
+        return U, S, Vt
+
+    def score_samples(self, X):
+        """Return the log-likelihood of each sample.
+
+        See. "Pattern Recognition and Machine Learning"
+        by C. Bishop, 12.2.1 p. 574
+        or http://www.miketipping.com/papers/met-mppca.pdf
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            The data.
+
+        Returns
+        -------
+        ll : ndarray of shape (n_samples,)
+            Log-likelihood of each sample under the current model.
+        """
+        check_is_fitted(self)
+        xp, _ = get_namespace(X)
+        X = self._validate_data(X, dtype=[xp.float64, xp.float32], reset=False)
+        Xr = X - self.mean_
+        n_features = X.shape[1]
+        precision = self.get_precision()
+        log_like = -0.5 * xp.sum(Xr * (Xr @ precision), axis=1)
+        log_like -= 0.5 * (n_features * log(2.0 * np.pi) - fast_logdet(precision))
+        return log_like
+
+    def score(self, X, y=None):
+        """Return the average log-likelihood of all samples.
+
+        See. "Pattern Recognition and Machine Learning"
+        by C. Bishop, 12.2.1 p. 574
+        or http://www.miketipping.com/papers/met-mppca.pdf
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            The data.
+
+        y : Ignored
+            Ignored.
+
+        Returns
+        -------
+        ll : float
+            Average log-likelihood of the samples under the current model.
+        """
+        xp, _ = get_namespace(X)
+        return float(xp.mean(self.score_samples(X)))
+
+    def _more_tags(self):
+        return {"preserves_dtype": [np.float64, np.float32], "array_api_support": True}

venv/lib/python3.10/site-packages/sklearn/decomposition/_sparse_pca.py

@@ -0,0 +1,551 @@
+"""Matrix factorization with Sparse PCA."""
+# Author: Vlad Niculae, Gael Varoquaux, Alexandre Gramfort
+# License: BSD 3 clause
+
+from numbers import Integral, Real
+
+import numpy as np
+
+from ..base import (
+    BaseEstimator,
+    ClassNamePrefixFeaturesOutMixin,
+    TransformerMixin,
+    _fit_context,
+)
+from ..linear_model import ridge_regression
+from ..utils import check_random_state
+from ..utils._param_validation import Hidden, Interval, StrOptions
+from ..utils.extmath import svd_flip
+from ..utils.validation import check_array, check_is_fitted
+from ._dict_learning import MiniBatchDictionaryLearning, dict_learning
+
+
+class _BaseSparsePCA(ClassNamePrefixFeaturesOutMixin, TransformerMixin, BaseEstimator):
+    """Base class for SparsePCA and MiniBatchSparsePCA"""
+
+    _parameter_constraints: dict = {
+        "n_components": [None, Interval(Integral, 1, None, closed="left")],
+        "alpha": [Interval(Real, 0.0, None, closed="left")],
+        "ridge_alpha": [Interval(Real, 0.0, None, closed="left")],
+        "max_iter": [Interval(Integral, 0, None, closed="left")],
+        "tol": [Interval(Real, 0.0, None, closed="left")],
+        "method": [StrOptions({"lars", "cd"})],
+        "n_jobs": [Integral, None],
+        "verbose": ["verbose"],
+        "random_state": ["random_state"],
+    }
+
+    def __init__(
+        self,
+        n_components=None,
+        *,
+        alpha=1,
+        ridge_alpha=0.01,
+        max_iter=1000,
+        tol=1e-8,
+        method="lars",
+        n_jobs=None,
+        verbose=False,
+        random_state=None,
+    ):
+        self.n_components = n_components
+        self.alpha = alpha
+        self.ridge_alpha = ridge_alpha
+        self.max_iter = max_iter
+        self.tol = tol
+        self.method = method
+        self.n_jobs = n_jobs
+        self.verbose = verbose
+        self.random_state = random_state
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, X, y=None):
+        """Fit the model from data in X.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training vector, 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
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        random_state = check_random_state(self.random_state)
+        X = self._validate_data(X)
+
+        self.mean_ = X.mean(axis=0)
+        X = X - self.mean_
+
+        if self.n_components is None:
+            n_components = X.shape[1]
+        else:
+            n_components = self.n_components
+
+        return self._fit(X, n_components, random_state)
+
+    def transform(self, X):
+        """Least Squares projection of the data onto the sparse components.
+
+        To avoid instability issues in case the system is under-determined,
+        regularization can be applied (Ridge regression) via the
+        `ridge_alpha` parameter.
+
+        Note that Sparse PCA components orthogonality is not enforced as in PCA
+        hence one cannot use a simple linear projection.
+
+        Parameters
+        ----------
+        X : ndarray of shape (n_samples, n_features)
+            Test data to be transformed, must have the same number of
+            features as the data used to train the model.
+
+        Returns
+        -------
+        X_new : ndarray of shape (n_samples, n_components)
+            Transformed data.
+        """
+        check_is_fitted(self)
+
+        X = self._validate_data(X, reset=False)
+        X = X - self.mean_
+
+        U = ridge_regression(
+            self.components_.T, X.T, self.ridge_alpha, solver="cholesky"
+        )
+
+        return U
+
+    def inverse_transform(self, X):
+        """Transform data from the latent space to the original space.
+
+        This inversion is an approximation due to the loss of information
+        induced by the forward decomposition.
+
+        .. versionadded:: 1.2
+
+        Parameters
+        ----------
+        X : ndarray of shape (n_samples, n_components)
+            Data in the latent space.
+
+        Returns
+        -------
+        X_original : ndarray of shape (n_samples, n_features)
+            Reconstructed data in the original space.
+        """
+        check_is_fitted(self)
+        X = check_array(X)
+
+        return (X @ self.components_) + self.mean_
+
+    @property
+    def _n_features_out(self):
+        """Number of transformed output features."""
+        return self.components_.shape[0]
+
+    def _more_tags(self):
+        return {
+            "preserves_dtype": [np.float64, np.float32],
+        }
+
+
+class SparsePCA(_BaseSparsePCA):
+    """Sparse Principal Components Analysis (SparsePCA).
+
+    Finds the set of sparse components that can optimally reconstruct
+    the data.  The amount of sparseness is controllable by the coefficient
+    of the L1 penalty, given by the parameter alpha.
+
+    Read more in the :ref:`User Guide <SparsePCA>`.
+
+    Parameters
+    ----------
+    n_components : int, default=None
+        Number of sparse atoms to extract. If None, then ``n_components``
+        is set to ``n_features``.
+
+    alpha : float, default=1
+        Sparsity controlling parameter. Higher values lead to sparser
+        components.
+
+    ridge_alpha : float, default=0.01
+        Amount of ridge shrinkage to apply in order to improve
+        conditioning when calling the transform method.
+
+    max_iter : int, default=1000
+        Maximum number of iterations to perform.
+
+    tol : float, default=1e-8
+        Tolerance for the stopping condition.
+
+    method : {'lars', 'cd'}, default='lars'
+        Method to be used for optimization.
+        lars: uses the least angle regression method to solve the lasso problem
+        (linear_model.lars_path)
+        cd: uses the coordinate descent method to compute the
+        Lasso solution (linear_model.Lasso). Lars will be faster if
+        the estimated components are sparse.
+
+    n_jobs : int, default=None
+        Number of parallel jobs to run.
+        ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.
+        ``-1`` means using all processors. See :term:`Glossary <n_jobs>`
+        for more details.
+
+    U_init : ndarray of shape (n_samples, n_components), default=None
+        Initial values for the loadings for warm restart scenarios. Only used
+        if `U_init` and `V_init` are not None.
+
+    V_init : ndarray of shape (n_components, n_features), default=None
+        Initial values for the components for warm restart scenarios. Only used
+        if `U_init` and `V_init` are not None.
+
+    verbose : int or bool, default=False
+        Controls the verbosity; the higher, the more messages. Defaults to 0.
+
+    random_state : int, RandomState instance or None, default=None
+        Used during dictionary learning. Pass an int for reproducible results
+        across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    Attributes
+    ----------
+    components_ : ndarray of shape (n_components, n_features)
+        Sparse components extracted from the data.
+
+    error_ : ndarray
+        Vector of errors at each iteration.
+
+    n_components_ : int
+        Estimated number of components.
+
+        .. versionadded:: 0.23
+
+    n_iter_ : int
+        Number of iterations run.
+
+    mean_ : ndarray of shape (n_features,)
+        Per-feature empirical mean, estimated from the training set.
+        Equal to ``X.mean(axis=0)``.
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    See Also
+    --------
+    PCA : Principal Component Analysis implementation.
+    MiniBatchSparsePCA : Mini batch variant of `SparsePCA` that is faster but less
+        accurate.
+    DictionaryLearning : Generic dictionary learning problem using a sparse code.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.datasets import make_friedman1
+    >>> from sklearn.decomposition import SparsePCA
+    >>> X, _ = make_friedman1(n_samples=200, n_features=30, random_state=0)
+    >>> transformer = SparsePCA(n_components=5, random_state=0)
+    >>> transformer.fit(X)
+    SparsePCA(...)
+    >>> X_transformed = transformer.transform(X)
+    >>> X_transformed.shape
+    (200, 5)
+    >>> # most values in the components_ are zero (sparsity)
+    >>> np.mean(transformer.components_ == 0)
+    0.9666...
+    """
+
+    _parameter_constraints: dict = {
+        **_BaseSparsePCA._parameter_constraints,
+        "U_init": [None, np.ndarray],
+        "V_init": [None, np.ndarray],
+    }
+
+    def __init__(
+        self,
+        n_components=None,
+        *,
+        alpha=1,
+        ridge_alpha=0.01,
+        max_iter=1000,
+        tol=1e-8,
+        method="lars",
+        n_jobs=None,
+        U_init=None,
+        V_init=None,
+        verbose=False,
+        random_state=None,
+    ):
+        super().__init__(
+            n_components=n_components,
+            alpha=alpha,
+            ridge_alpha=ridge_alpha,
+            max_iter=max_iter,
+            tol=tol,
+            method=method,
+            n_jobs=n_jobs,
+            verbose=verbose,
+            random_state=random_state,
+        )
+        self.U_init = U_init
+        self.V_init = V_init
+
+    def _fit(self, X, n_components, random_state):
+        """Specialized `fit` for SparsePCA."""
+
+        code_init = self.V_init.T if self.V_init is not None else None
+        dict_init = self.U_init.T if self.U_init is not None else None
+        code, dictionary, E, self.n_iter_ = dict_learning(
+            X.T,
+            n_components,
+            alpha=self.alpha,
+            tol=self.tol,
+            max_iter=self.max_iter,
+            method=self.method,
+            n_jobs=self.n_jobs,
+            verbose=self.verbose,
+            random_state=random_state,
+            code_init=code_init,
+            dict_init=dict_init,
+            return_n_iter=True,
+        )
+        # flip eigenvectors' sign to enforce deterministic output
+        code, dictionary = svd_flip(code, dictionary, u_based_decision=False)
+        self.components_ = code.T
+        components_norm = np.linalg.norm(self.components_, axis=1)[:, np.newaxis]
+        components_norm[components_norm == 0] = 1
+        self.components_ /= components_norm
+        self.n_components_ = len(self.components_)
+
+        self.error_ = E
+        return self
+
+
+class MiniBatchSparsePCA(_BaseSparsePCA):
+    """Mini-batch Sparse Principal Components Analysis.
+
+    Finds the set of sparse components that can optimally reconstruct
+    the data.  The amount of sparseness is controllable by the coefficient
+    of the L1 penalty, given by the parameter alpha.
+
+    For an example comparing sparse PCA to PCA, see
+    :ref:`sphx_glr_auto_examples_decomposition_plot_faces_decomposition.py`
+
+    Read more in the :ref:`User Guide <SparsePCA>`.
+
+    Parameters
+    ----------
+    n_components : int, default=None
+        Number of sparse atoms to extract. If None, then ``n_components``
+        is set to ``n_features``.
+
+    alpha : int, default=1
+        Sparsity controlling parameter. Higher values lead to sparser
+        components.
+
+    ridge_alpha : float, default=0.01
+        Amount of ridge shrinkage to apply in order to improve
+        conditioning when calling the transform method.
+
+    max_iter : int, default=1_000
+        Maximum number of iterations over the complete dataset before
+        stopping independently of any early stopping criterion heuristics.
+
+        .. versionadded:: 1.2
+
+        .. deprecated:: 1.4
+           `max_iter=None` is deprecated in 1.4 and will be removed in 1.6.
+           Use the default value (i.e. `100`) instead.
+
+    callback : callable, default=None
+        Callable that gets invoked every five iterations.
+
+    batch_size : int, default=3
+        The number of features to take in each mini batch.
+
+    verbose : int or bool, default=False
+        Controls the verbosity; the higher, the more messages. Defaults to 0.
+
+    shuffle : bool, default=True
+        Whether to shuffle the data before splitting it in batches.
+
+    n_jobs : int, default=None
+        Number of parallel jobs to run.
+        ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.
+        ``-1`` means using all processors. See :term:`Glossary <n_jobs>`
+        for more details.
+
+    method : {'lars', 'cd'}, default='lars'
+        Method to be used for optimization.
+        lars: uses the least angle regression method to solve the lasso problem
+        (linear_model.lars_path)
+        cd: uses the coordinate descent method to compute the
+        Lasso solution (linear_model.Lasso). Lars will be faster if
+        the estimated components are sparse.
+
+    random_state : int, RandomState instance or None, default=None
+        Used for random shuffling when ``shuffle`` is set to ``True``,
+        during online dictionary learning. Pass an int for reproducible results
+        across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    tol : float, default=1e-3
+        Control early stopping based on the norm of the differences in the
+        dictionary between 2 steps.
+
+        To disable early stopping based on changes in the dictionary, set
+        `tol` to 0.0.
+
+        .. versionadded:: 1.1
+
+    max_no_improvement : int or None, default=10
+        Control early stopping based on the consecutive number of mini batches
+        that does not yield an improvement on the smoothed cost function.
+
+        To disable convergence detection based on cost function, set
+        `max_no_improvement` to `None`.
+
+        .. versionadded:: 1.1
+
+    Attributes
+    ----------
+    components_ : ndarray of shape (n_components, n_features)
+        Sparse components extracted from the data.
+
+    n_components_ : int
+        Estimated number of components.
+
+        .. versionadded:: 0.23
+
+    n_iter_ : int
+        Number of iterations run.
+
+    mean_ : ndarray of shape (n_features,)
+        Per-feature empirical mean, estimated from the training set.
+        Equal to ``X.mean(axis=0)``.
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    See Also
+    --------
+    DictionaryLearning : Find a dictionary that sparsely encodes data.
+    IncrementalPCA : Incremental principal components analysis.
+    PCA : Principal component analysis.
+    SparsePCA : Sparse Principal Components Analysis.
+    TruncatedSVD : Dimensionality reduction using truncated SVD.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.datasets import make_friedman1
+    >>> from sklearn.decomposition import MiniBatchSparsePCA
+    >>> X, _ = make_friedman1(n_samples=200, n_features=30, random_state=0)
+    >>> transformer = MiniBatchSparsePCA(n_components=5, batch_size=50,
+    ...                                  max_iter=10, random_state=0)
+    >>> transformer.fit(X)
+    MiniBatchSparsePCA(...)
+    >>> X_transformed = transformer.transform(X)
+    >>> X_transformed.shape
+    (200, 5)
+    >>> # most values in the components_ are zero (sparsity)
+    >>> np.mean(transformer.components_ == 0)
+    0.9...
+    """
+
+    _parameter_constraints: dict = {
+        **_BaseSparsePCA._parameter_constraints,
+        "max_iter": [Interval(Integral, 0, None, closed="left"), Hidden(None)],
+        "callback": [None, callable],
+        "batch_size": [Interval(Integral, 1, None, closed="left")],
+        "shuffle": ["boolean"],
+        "max_no_improvement": [Interval(Integral, 0, None, closed="left"), None],
+    }
+
+    def __init__(
+        self,
+        n_components=None,
+        *,
+        alpha=1,
+        ridge_alpha=0.01,
+        max_iter=1_000,
+        callback=None,
+        batch_size=3,
+        verbose=False,
+        shuffle=True,
+        n_jobs=None,
+        method="lars",
+        random_state=None,
+        tol=1e-3,
+        max_no_improvement=10,
+    ):
+        super().__init__(
+            n_components=n_components,
+            alpha=alpha,
+            ridge_alpha=ridge_alpha,
+            max_iter=max_iter,
+            tol=tol,
+            method=method,
+            n_jobs=n_jobs,
+            verbose=verbose,
+            random_state=random_state,
+        )
+        self.callback = callback
+        self.batch_size = batch_size
+        self.shuffle = shuffle
+        self.max_no_improvement = max_no_improvement
+
+    def _fit(self, X, n_components, random_state):
+        """Specialized `fit` for MiniBatchSparsePCA."""
+
+        transform_algorithm = "lasso_" + self.method
+        est = MiniBatchDictionaryLearning(
+            n_components=n_components,
+            alpha=self.alpha,
+            max_iter=self.max_iter,
+            dict_init=None,
+            batch_size=self.batch_size,
+            shuffle=self.shuffle,
+            n_jobs=self.n_jobs,
+            fit_algorithm=self.method,
+            random_state=random_state,
+            transform_algorithm=transform_algorithm,
+            transform_alpha=self.alpha,
+            verbose=self.verbose,
+            callback=self.callback,
+            tol=self.tol,
+            max_no_improvement=self.max_no_improvement,
+        )
+        est.set_output(transform="default")
+        est.fit(X.T)
+
+        self.components_, self.n_iter_ = est.transform(X.T).T, est.n_iter_
+
+        components_norm = np.linalg.norm(self.components_, axis=1)[:, np.newaxis]
+        components_norm[components_norm == 0] = 1
+        self.components_ /= components_norm
+        self.n_components_ = len(self.components_)
+
+        return self

venv/lib/python3.10/site-packages/sklearn/decomposition/_truncated_svd.py

@@ -0,0 +1,319 @@
+"""Truncated SVD for sparse matrices, aka latent semantic analysis (LSA).
+"""
+
+# Author: Lars Buitinck
+#         Olivier Grisel <[email protected]>
+#         Michael Becker <[email protected]>
+# License: 3-clause BSD.
+
+from numbers import Integral, Real
+
+import numpy as np
+import scipy.sparse as sp
+from scipy.sparse.linalg import svds
+
+from ..base import (
+    BaseEstimator,
+    ClassNamePrefixFeaturesOutMixin,
+    TransformerMixin,
+    _fit_context,
+)
+from ..utils import check_array, check_random_state
+from ..utils._arpack import _init_arpack_v0
+from ..utils._param_validation import Interval, StrOptions
+from ..utils.extmath import randomized_svd, safe_sparse_dot, svd_flip
+from ..utils.sparsefuncs import mean_variance_axis
+from ..utils.validation import check_is_fitted
+
+__all__ = ["TruncatedSVD"]
+
+
+class TruncatedSVD(ClassNamePrefixFeaturesOutMixin, TransformerMixin, BaseEstimator):
+    """Dimensionality reduction using truncated SVD (aka LSA).
+
+    This transformer performs linear dimensionality reduction by means of
+    truncated singular value decomposition (SVD). Contrary to PCA, this
+    estimator does not center the data before computing the singular value
+    decomposition. This means it can work with sparse matrices
+    efficiently.
+
+    In particular, truncated SVD works on term count/tf-idf matrices as
+    returned by the vectorizers in :mod:`sklearn.feature_extraction.text`. In
+    that context, it is known as latent semantic analysis (LSA).
+
+    This estimator supports two algorithms: a fast randomized SVD solver, and
+    a "naive" algorithm that uses ARPACK as an eigensolver on `X * X.T` or
+    `X.T * X`, whichever is more efficient.
+
+    Read more in the :ref:`User Guide <LSA>`.
+
+    Parameters
+    ----------
+    n_components : int, default=2
+        Desired dimensionality of output data.
+        If algorithm='arpack', must be strictly less than the number of features.
+        If algorithm='randomized', must be less than or equal to the number of features.
+        The default value is useful for visualisation. For LSA, a value of
+        100 is recommended.
+
+    algorithm : {'arpack', 'randomized'}, default='randomized'
+        SVD solver to use. Either "arpack" for the ARPACK wrapper in SciPy
+        (scipy.sparse.linalg.svds), or "randomized" for the randomized
+        algorithm due to Halko (2009).
+
+    n_iter : int, default=5
+        Number of iterations for randomized SVD solver. Not used by ARPACK. The
+        default is larger than the default in
+        :func:`~sklearn.utils.extmath.randomized_svd` to handle sparse
+        matrices that may have large slowly decaying spectrum.
+
+    n_oversamples : int, default=10
+        Number of oversamples for randomized SVD solver. Not used by ARPACK.
+        See :func:`~sklearn.utils.extmath.randomized_svd` for a complete
+        description.
+
+        .. versionadded:: 1.1
+
+    power_iteration_normalizer : {'auto', 'QR', 'LU', 'none'}, default='auto'
+        Power iteration normalizer for randomized SVD solver.
+        Not used by ARPACK. See :func:`~sklearn.utils.extmath.randomized_svd`
+        for more details.
+
+        .. versionadded:: 1.1
+
+    random_state : int, RandomState instance or None, default=None
+        Used during randomized svd. Pass an int for reproducible results across
+        multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    tol : float, default=0.0
+        Tolerance for ARPACK. 0 means machine precision. Ignored by randomized
+        SVD solver.
+
+    Attributes
+    ----------
+    components_ : ndarray of shape (n_components, n_features)
+        The right singular vectors of the input data.
+
+    explained_variance_ : ndarray of shape (n_components,)
+        The variance of the training samples transformed by a projection to
+        each component.
+
+    explained_variance_ratio_ : ndarray of shape (n_components,)
+        Percentage of variance explained by each of the selected components.
+
+    singular_values_ : ndarray of shape (n_components,)
+        The singular values corresponding to each of the selected components.
+        The singular values are equal to the 2-norms of the ``n_components``
+        variables in the lower-dimensional space.
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    See Also
+    --------
+    DictionaryLearning : Find a dictionary that sparsely encodes data.
+    FactorAnalysis : A simple linear generative model with
+        Gaussian latent variables.
+    IncrementalPCA : Incremental principal components analysis.
+    KernelPCA : Kernel Principal component analysis.
+    NMF : Non-Negative Matrix Factorization.
+    PCA : Principal component analysis.
+
+    Notes
+    -----
+    SVD suffers from a problem called "sign indeterminacy", which means the
+    sign of the ``components_`` and the output from transform depend on the
+    algorithm and random state. To work around this, fit instances of this
+    class to data once, then keep the instance around to do transformations.
+
+    References
+    ----------
+    :arxiv:`Halko, et al. (2009). "Finding structure with randomness:
+    Stochastic algorithms for constructing approximate matrix decompositions"
+    <0909.4061>`
+
+    Examples
+    --------
+    >>> from sklearn.decomposition import TruncatedSVD
+    >>> from scipy.sparse import csr_matrix
+    >>> import numpy as np
+    >>> np.random.seed(0)
+    >>> X_dense = np.random.rand(100, 100)
+    >>> X_dense[:, 2 * np.arange(50)] = 0
+    >>> X = csr_matrix(X_dense)
+    >>> svd = TruncatedSVD(n_components=5, n_iter=7, random_state=42)
+    >>> svd.fit(X)
+    TruncatedSVD(n_components=5, n_iter=7, random_state=42)
+    >>> print(svd.explained_variance_ratio_)
+    [0.0157... 0.0512... 0.0499... 0.0479... 0.0453...]
+    >>> print(svd.explained_variance_ratio_.sum())
+    0.2102...
+    >>> print(svd.singular_values_)
+    [35.2410...  4.5981...   4.5420...  4.4486...  4.3288...]
+    """
+
+    _parameter_constraints: dict = {
+        "n_components": [Interval(Integral, 1, None, closed="left")],
+        "algorithm": [StrOptions({"arpack", "randomized"})],
+        "n_iter": [Interval(Integral, 0, None, closed="left")],
+        "n_oversamples": [Interval(Integral, 1, None, closed="left")],
+        "power_iteration_normalizer": [StrOptions({"auto", "OR", "LU", "none"})],
+        "random_state": ["random_state"],
+        "tol": [Interval(Real, 0, None, closed="left")],
+    }
+
+    def __init__(
+        self,
+        n_components=2,
+        *,
+        algorithm="randomized",
+        n_iter=5,
+        n_oversamples=10,
+        power_iteration_normalizer="auto",
+        random_state=None,
+        tol=0.0,
+    ):
+        self.algorithm = algorithm
+        self.n_components = n_components
+        self.n_iter = n_iter
+        self.n_oversamples = n_oversamples
+        self.power_iteration_normalizer = power_iteration_normalizer
+        self.random_state = random_state
+        self.tol = tol
+
+    def fit(self, X, y=None):
+        """Fit model on training data X.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            Training data.
+
+        y : Ignored
+            Not used, present here for API consistency by convention.
+
+        Returns
+        -------
+        self : object
+            Returns the transformer object.
+        """
+        self.fit_transform(X)
+        return self
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit_transform(self, X, y=None):
+        """Fit model to X and perform dimensionality reduction on X.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            Training data.
+
+        y : Ignored
+            Not used, present here for API consistency by convention.
+
+        Returns
+        -------
+        X_new : ndarray of shape (n_samples, n_components)
+            Reduced version of X. This will always be a dense array.
+        """
+        X = self._validate_data(X, accept_sparse=["csr", "csc"], ensure_min_features=2)
+        random_state = check_random_state(self.random_state)
+
+        if self.algorithm == "arpack":
+            v0 = _init_arpack_v0(min(X.shape), random_state)
+            U, Sigma, VT = svds(X, k=self.n_components, tol=self.tol, v0=v0)
+            # svds doesn't abide by scipy.linalg.svd/randomized_svd
+            # conventions, so reverse its outputs.
+            Sigma = Sigma[::-1]
+            U, VT = svd_flip(U[:, ::-1], VT[::-1])
+
+        elif self.algorithm == "randomized":
+            if self.n_components > X.shape[1]:
+                raise ValueError(
+                    f"n_components({self.n_components}) must be <="
+                    f" n_features({X.shape[1]})."
+                )
+            U, Sigma, VT = randomized_svd(
+                X,
+                self.n_components,
+                n_iter=self.n_iter,
+                n_oversamples=self.n_oversamples,
+                power_iteration_normalizer=self.power_iteration_normalizer,
+                random_state=random_state,
+            )
+
+        self.components_ = VT
+
+        # As a result of the SVD approximation error on X ~ U @ Sigma @ V.T,
+        # X @ V is not the same as U @ Sigma
+        if self.algorithm == "randomized" or (
+            self.algorithm == "arpack" and self.tol > 0
+        ):
+            X_transformed = safe_sparse_dot(X, self.components_.T)
+        else:
+            X_transformed = U * Sigma
+
+        # Calculate explained variance & explained variance ratio
+        self.explained_variance_ = exp_var = np.var(X_transformed, axis=0)
+        if sp.issparse(X):
+            _, full_var = mean_variance_axis(X, axis=0)
+            full_var = full_var.sum()
+        else:
+            full_var = np.var(X, axis=0).sum()
+        self.explained_variance_ratio_ = exp_var / full_var
+        self.singular_values_ = Sigma  # Store the singular values.
+
+        return X_transformed
+
+    def transform(self, X):
+        """Perform dimensionality reduction on X.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            New data.
+
+        Returns
+        -------
+        X_new : ndarray of shape (n_samples, n_components)
+            Reduced version of X. This will always be a dense array.
+        """
+        check_is_fitted(self)
+        X = self._validate_data(X, accept_sparse=["csr", "csc"], reset=False)
+        return safe_sparse_dot(X, self.components_.T)
+
+    def inverse_transform(self, X):
+        """Transform X back to its original space.
+
+        Returns an array X_original whose transform would be X.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_components)
+            New data.
+
+        Returns
+        -------
+        X_original : ndarray of shape (n_samples, n_features)
+            Note that this is always a dense array.
+        """
+        X = check_array(X)
+        return np.dot(X, self.components_)
+
+    def _more_tags(self):
+        return {"preserves_dtype": [np.float64, np.float32]}
+
+    @property
+    def _n_features_out(self):
+        """Number of transformed output features."""
+        return self.components_.shape[0]

venv/lib/python3.10/site-packages/sklearn/decomposition/tests/test_factor_analysis.py

@@ -0,0 +1,116 @@
+# Author: Christian Osendorfer <[email protected]>
+#         Alexandre Gramfort <[email protected]>
+# License: BSD3
+
+from itertools import combinations
+
+import numpy as np
+import pytest
+
+from sklearn.decomposition import FactorAnalysis
+from sklearn.decomposition._factor_analysis import _ortho_rotation
+from sklearn.exceptions import ConvergenceWarning
+from sklearn.utils._testing import (
+    assert_almost_equal,
+    assert_array_almost_equal,
+    ignore_warnings,
+)
+
+
+# Ignore warnings from switching to more power iterations in randomized_svd
+@ignore_warnings
+def test_factor_analysis():
+    # Test FactorAnalysis ability to recover the data covariance structure
+    rng = np.random.RandomState(0)
+    n_samples, n_features, n_components = 20, 5, 3
+
+    # Some random settings for the generative model
+    W = rng.randn(n_components, n_features)
+    # latent variable of dim 3, 20 of it
+    h = rng.randn(n_samples, n_components)
+    # using gamma to model different noise variance
+    # per component
+    noise = rng.gamma(1, size=n_features) * rng.randn(n_samples, n_features)
+
+    # generate observations
+    # wlog, mean is 0
+    X = np.dot(h, W) + noise
+
+    fas = []
+    for method in ["randomized", "lapack"]:
+        fa = FactorAnalysis(n_components=n_components, svd_method=method)
+        fa.fit(X)
+        fas.append(fa)
+
+        X_t = fa.transform(X)
+        assert X_t.shape == (n_samples, n_components)
+
+        assert_almost_equal(fa.loglike_[-1], fa.score_samples(X).sum())
+        assert_almost_equal(fa.score_samples(X).mean(), fa.score(X))
+
+        diff = np.all(np.diff(fa.loglike_))
+        assert diff > 0.0, "Log likelihood dif not increase"
+
+        # Sample Covariance
+        scov = np.cov(X, rowvar=0.0, bias=1.0)
+
+        # Model Covariance
+        mcov = fa.get_covariance()
+        diff = np.sum(np.abs(scov - mcov)) / W.size
+        assert diff < 0.1, "Mean absolute difference is %f" % diff
+        fa = FactorAnalysis(
+            n_components=n_components, noise_variance_init=np.ones(n_features)
+        )
+        with pytest.raises(ValueError):
+            fa.fit(X[:, :2])
+
+    def f(x, y):
+        return np.abs(getattr(x, y))  # sign will not be equal
+
+    fa1, fa2 = fas
+    for attr in ["loglike_", "components_", "noise_variance_"]:
+        assert_almost_equal(f(fa1, attr), f(fa2, attr))
+
+    fa1.max_iter = 1
+    fa1.verbose = True
+    with pytest.warns(ConvergenceWarning):
+        fa1.fit(X)
+
+    # Test get_covariance and get_precision with n_components == n_features
+    # with n_components < n_features and with n_components == 0
+    for n_components in [0, 2, X.shape[1]]:
+        fa.n_components = n_components
+        fa.fit(X)
+        cov = fa.get_covariance()
+        precision = fa.get_precision()
+        assert_array_almost_equal(np.dot(cov, precision), np.eye(X.shape[1]), 12)
+
+    # test rotation
+    n_components = 2
+
+    results, projections = {}, {}
+    for method in (None, "varimax", "quartimax"):
+        fa_var = FactorAnalysis(n_components=n_components, rotation=method)
+        results[method] = fa_var.fit_transform(X)
+        projections[method] = fa_var.get_covariance()
+    for rot1, rot2 in combinations([None, "varimax", "quartimax"], 2):
+        assert not np.allclose(results[rot1], results[rot2])
+        assert np.allclose(projections[rot1], projections[rot2], atol=3)
+
+    # test against R's psych::principal with rotate="varimax"
+    # (i.e., the values below stem from rotating the components in R)
+    # R's factor analysis returns quite different values; therefore, we only
+    # test the rotation itself
+    factors = np.array(
+        [
+            [0.89421016, -0.35854928, -0.27770122, 0.03773647],
+            [-0.45081822, -0.89132754, 0.0932195, -0.01787973],
+            [0.99500666, -0.02031465, 0.05426497, -0.11539407],
+            [0.96822861, -0.06299656, 0.24411001, 0.07540887],
+        ]
+    )
+    r_solution = np.array(
+        [[0.962, 0.052], [-0.141, 0.989], [0.949, -0.300], [0.937, -0.251]]
+    )
+    rotated = _ortho_rotation(factors[:, :n_components], method="varimax").T
+    assert_array_almost_equal(np.abs(rotated), np.abs(r_solution), decimal=3)

venv/lib/python3.10/site-packages/sklearn/decomposition/tests/test_fastica.py

@@ -0,0 +1,451 @@
+"""
+Test the fastica algorithm.
+"""
+import itertools
+import os
+import warnings
+
+import numpy as np
+import pytest
+from scipy import stats
+
+from sklearn.decomposition import PCA, FastICA, fastica
+from sklearn.decomposition._fastica import _gs_decorrelation
+from sklearn.exceptions import ConvergenceWarning
+from sklearn.utils._testing import assert_allclose
+
+
+def center_and_norm(x, axis=-1):
+    """Centers and norms x **in place**
+
+    Parameters
+    -----------
+    x: ndarray
+        Array with an axis of observations (statistical units) measured on
+        random variables.
+    axis: int, optional
+        Axis along which the mean and variance are calculated.
+    """
+    x = np.rollaxis(x, axis)
+    x -= x.mean(axis=0)
+    x /= x.std(axis=0)
+
+
+def test_gs():
+    # Test gram schmidt orthonormalization
+    # generate a random orthogonal  matrix
+    rng = np.random.RandomState(0)
+    W, _, _ = np.linalg.svd(rng.randn(10, 10))
+    w = rng.randn(10)
+    _gs_decorrelation(w, W, 10)
+    assert (w**2).sum() < 1.0e-10
+    w = rng.randn(10)
+    u = _gs_decorrelation(w, W, 5)
+    tmp = np.dot(u, W.T)
+    assert (tmp[:5] ** 2).sum() < 1.0e-10
+
+
+def test_fastica_attributes_dtypes(global_dtype):
+    rng = np.random.RandomState(0)
+    X = rng.random_sample((100, 10)).astype(global_dtype, copy=False)
+    fica = FastICA(
+        n_components=5, max_iter=1000, whiten="unit-variance", random_state=0
+    ).fit(X)
+    assert fica.components_.dtype == global_dtype
+    assert fica.mixing_.dtype == global_dtype
+    assert fica.mean_.dtype == global_dtype
+    assert fica.whitening_.dtype == global_dtype
+
+
+def test_fastica_return_dtypes(global_dtype):
+    rng = np.random.RandomState(0)
+    X = rng.random_sample((100, 10)).astype(global_dtype, copy=False)
+    k_, mixing_, s_ = fastica(
+        X, max_iter=1000, whiten="unit-variance", random_state=rng
+    )
+    assert k_.dtype == global_dtype
+    assert mixing_.dtype == global_dtype
+    assert s_.dtype == global_dtype
+
+
+@pytest.mark.parametrize("add_noise", [True, False])
+def test_fastica_simple(add_noise, global_random_seed, global_dtype):
+    if (
+        global_random_seed == 20
+        and global_dtype == np.float32
+        and not add_noise
+        and os.getenv("DISTRIB") == "ubuntu"
+    ):
+        pytest.xfail(
+            "FastICA instability with Ubuntu Atlas build with float32 "
+            "global_dtype. For more details, see "
+            "https://github.com/scikit-learn/scikit-learn/issues/24131#issuecomment-1208091119"  # noqa
+        )
+
+    # Test the FastICA algorithm on very simple data.
+    rng = np.random.RandomState(global_random_seed)
+    n_samples = 1000
+    # Generate two sources:
+    s1 = (2 * np.sin(np.linspace(0, 100, n_samples)) > 0) - 1
+    s2 = stats.t.rvs(1, size=n_samples, random_state=global_random_seed)
+    s = np.c_[s1, s2].T
+    center_and_norm(s)
+    s = s.astype(global_dtype)
+    s1, s2 = s
+
+    # Mixing angle
+    phi = 0.6
+    mixing = np.array([[np.cos(phi), np.sin(phi)], [np.sin(phi), -np.cos(phi)]])
+    mixing = mixing.astype(global_dtype)
+    m = np.dot(mixing, s)
+
+    if add_noise:
+        m += 0.1 * rng.randn(2, 1000)
+
+    center_and_norm(m)
+
+    # function as fun arg
+    def g_test(x):
+        return x**3, (3 * x**2).mean(axis=-1)
+
+    algos = ["parallel", "deflation"]
+    nls = ["logcosh", "exp", "cube", g_test]
+    whitening = ["arbitrary-variance", "unit-variance", False]
+    for algo, nl, whiten in itertools.product(algos, nls, whitening):
+        if whiten:
+            k_, mixing_, s_ = fastica(
+                m.T, fun=nl, whiten=whiten, algorithm=algo, random_state=rng
+            )
+            with pytest.raises(ValueError):
+                fastica(m.T, fun=np.tanh, whiten=whiten, algorithm=algo)
+        else:
+            pca = PCA(n_components=2, whiten=True, random_state=rng)
+            X = pca.fit_transform(m.T)
+            k_, mixing_, s_ = fastica(
+                X, fun=nl, algorithm=algo, whiten=False, random_state=rng
+            )
+            with pytest.raises(ValueError):
+                fastica(X, fun=np.tanh, algorithm=algo)
+        s_ = s_.T
+        # Check that the mixing model described in the docstring holds:
+        if whiten:
+            # XXX: exact reconstruction to standard relative tolerance is not
+            # possible. This is probably expected when add_noise is True but we
+            # also need a non-trivial atol in float32 when add_noise is False.
+            #
+            # Note that the 2 sources are non-Gaussian in this test.
+            atol = 1e-5 if global_dtype == np.float32 else 0
+            assert_allclose(np.dot(np.dot(mixing_, k_), m), s_, atol=atol)
+
+        center_and_norm(s_)
+        s1_, s2_ = s_
+        # Check to see if the sources have been estimated
+        # in the wrong order
+        if abs(np.dot(s1_, s2)) > abs(np.dot(s1_, s1)):
+            s2_, s1_ = s_
+        s1_ *= np.sign(np.dot(s1_, s1))
+        s2_ *= np.sign(np.dot(s2_, s2))
+
+        # Check that we have estimated the original sources
+        if not add_noise:
+            assert_allclose(np.dot(s1_, s1) / n_samples, 1, atol=1e-2)
+            assert_allclose(np.dot(s2_, s2) / n_samples, 1, atol=1e-2)
+        else:
+            assert_allclose(np.dot(s1_, s1) / n_samples, 1, atol=1e-1)
+            assert_allclose(np.dot(s2_, s2) / n_samples, 1, atol=1e-1)
+
+    # Test FastICA class
+    _, _, sources_fun = fastica(
+        m.T, fun=nl, algorithm=algo, random_state=global_random_seed
+    )
+    ica = FastICA(fun=nl, algorithm=algo, random_state=global_random_seed)
+    sources = ica.fit_transform(m.T)
+    assert ica.components_.shape == (2, 2)
+    assert sources.shape == (1000, 2)
+
+    assert_allclose(sources_fun, sources)
+    # Set atol to account for the different magnitudes of the elements in sources
+    # (from 1e-4 to 1e1).
+    atol = np.max(np.abs(sources)) * (1e-5 if global_dtype == np.float32 else 1e-7)
+    assert_allclose(sources, ica.transform(m.T), atol=atol)
+
+    assert ica.mixing_.shape == (2, 2)
+
+    ica = FastICA(fun=np.tanh, algorithm=algo)
+    with pytest.raises(ValueError):
+        ica.fit(m.T)
+
+
+def test_fastica_nowhiten():
+    m = [[0, 1], [1, 0]]
+
+    # test for issue #697
+    ica = FastICA(n_components=1, whiten=False, random_state=0)
+    warn_msg = "Ignoring n_components with whiten=False."
+    with pytest.warns(UserWarning, match=warn_msg):
+        ica.fit(m)
+    assert hasattr(ica, "mixing_")
+
+
+def test_fastica_convergence_fail():
+    # Test the FastICA algorithm on very simple data
+    # (see test_non_square_fastica).
+    # Ensure a ConvergenceWarning raised if the tolerance is sufficiently low.
+    rng = np.random.RandomState(0)
+
+    n_samples = 1000
+    # Generate two sources:
+    t = np.linspace(0, 100, n_samples)
+    s1 = np.sin(t)
+    s2 = np.ceil(np.sin(np.pi * t))
+    s = np.c_[s1, s2].T
+    center_and_norm(s)
+
+    # Mixing matrix
+    mixing = rng.randn(6, 2)
+    m = np.dot(mixing, s)
+
+    # Do fastICA with tolerance 0. to ensure failing convergence
+    warn_msg = (
+        "FastICA did not converge. Consider increasing tolerance "
+        "or the maximum number of iterations."
+    )
+    with pytest.warns(ConvergenceWarning, match=warn_msg):
+        ica = FastICA(
+            algorithm="parallel", n_components=2, random_state=rng, max_iter=2, tol=0.0
+        )
+        ica.fit(m.T)
+
+
+@pytest.mark.parametrize("add_noise", [True, False])
+def test_non_square_fastica(add_noise):
+    # Test the FastICA algorithm on very simple data.
+    rng = np.random.RandomState(0)
+
+    n_samples = 1000
+    # Generate two sources:
+    t = np.linspace(0, 100, n_samples)
+    s1 = np.sin(t)
+    s2 = np.ceil(np.sin(np.pi * t))
+    s = np.c_[s1, s2].T
+    center_and_norm(s)
+    s1, s2 = s
+
+    # Mixing matrix
+    mixing = rng.randn(6, 2)
+    m = np.dot(mixing, s)
+
+    if add_noise:
+        m += 0.1 * rng.randn(6, n_samples)
+
+    center_and_norm(m)
+
+    k_, mixing_, s_ = fastica(
+        m.T, n_components=2, whiten="unit-variance", random_state=rng
+    )
+    s_ = s_.T
+
+    # Check that the mixing model described in the docstring holds:
+    assert_allclose(s_, np.dot(np.dot(mixing_, k_), m))
+
+    center_and_norm(s_)
+    s1_, s2_ = s_
+    # Check to see if the sources have been estimated
+    # in the wrong order
+    if abs(np.dot(s1_, s2)) > abs(np.dot(s1_, s1)):
+        s2_, s1_ = s_
+    s1_ *= np.sign(np.dot(s1_, s1))
+    s2_ *= np.sign(np.dot(s2_, s2))
+
+    # Check that we have estimated the original sources
+    if not add_noise:
+        assert_allclose(np.dot(s1_, s1) / n_samples, 1, atol=1e-3)
+        assert_allclose(np.dot(s2_, s2) / n_samples, 1, atol=1e-3)
+
+
+def test_fit_transform(global_random_seed, global_dtype):
+    """Test unit variance of transformed data using FastICA algorithm.
+
+    Check that `fit_transform` gives the same result as applying
+    `fit` and then `transform`.
+
+    Bug #13056
+    """
+    # multivariate uniform data in [0, 1]
+    rng = np.random.RandomState(global_random_seed)
+    X = rng.random_sample((100, 10)).astype(global_dtype)
+    max_iter = 300
+    for whiten, n_components in [["unit-variance", 5], [False, None]]:
+        n_components_ = n_components if n_components is not None else X.shape[1]
+
+        ica = FastICA(
+            n_components=n_components, max_iter=max_iter, whiten=whiten, random_state=0
+        )
+        with warnings.catch_warnings():
+            # make sure that numerical errors do not cause sqrt of negative
+            # values
+            warnings.simplefilter("error", RuntimeWarning)
+            # XXX: for some seeds, the model does not converge.
+            # However this is not what we test here.
+            warnings.simplefilter("ignore", ConvergenceWarning)
+            Xt = ica.fit_transform(X)
+        assert ica.components_.shape == (n_components_, 10)
+        assert Xt.shape == (X.shape[0], n_components_)
+
+        ica2 = FastICA(
+            n_components=n_components, max_iter=max_iter, whiten=whiten, random_state=0
+        )
+        with warnings.catch_warnings():
+            # make sure that numerical errors do not cause sqrt of negative
+            # values
+            warnings.simplefilter("error", RuntimeWarning)
+            warnings.simplefilter("ignore", ConvergenceWarning)
+            ica2.fit(X)
+        assert ica2.components_.shape == (n_components_, 10)
+        Xt2 = ica2.transform(X)
+
+        # XXX: we have to set atol for this test to pass for all seeds when
+        # fitting with float32 data. Is this revealing a bug?
+        if global_dtype:
+            atol = np.abs(Xt2).mean() / 1e6
+        else:
+            atol = 0.0  # the default rtol is enough for float64 data
+        assert_allclose(Xt, Xt2, atol=atol)
+
+
+@pytest.mark.filterwarnings("ignore:Ignoring n_components with whiten=False.")
+@pytest.mark.parametrize(
+    "whiten, n_components, expected_mixing_shape",
+    [
+        ("arbitrary-variance", 5, (10, 5)),
+        ("arbitrary-variance", 10, (10, 10)),
+        ("unit-variance", 5, (10, 5)),
+        ("unit-variance", 10, (10, 10)),
+        (False, 5, (10, 10)),
+        (False, 10, (10, 10)),
+    ],
+)
+def test_inverse_transform(
+    whiten, n_components, expected_mixing_shape, global_random_seed, global_dtype
+):
+    # Test FastICA.inverse_transform
+    n_samples = 100
+    rng = np.random.RandomState(global_random_seed)
+    X = rng.random_sample((n_samples, 10)).astype(global_dtype)
+
+    ica = FastICA(n_components=n_components, random_state=rng, whiten=whiten)
+    with warnings.catch_warnings():
+        # For some dataset (depending on the value of global_dtype) the model
+        # can fail to converge but this should not impact the definition of
+        # a valid inverse transform.
+        warnings.simplefilter("ignore", ConvergenceWarning)
+        Xt = ica.fit_transform(X)
+    assert ica.mixing_.shape == expected_mixing_shape
+    X2 = ica.inverse_transform(Xt)
+    assert X.shape == X2.shape
+
+    # reversibility test in non-reduction case
+    if n_components == X.shape[1]:
+        # XXX: we have to set atol for this test to pass for all seeds when
+        # fitting with float32 data. Is this revealing a bug?
+        if global_dtype:
+            # XXX: dividing by a smaller number makes
+            # tests fail for some seeds.
+            atol = np.abs(X2).mean() / 1e5
+        else:
+            atol = 0.0  # the default rtol is enough for float64 data
+        assert_allclose(X, X2, atol=atol)
+
+
+def test_fastica_errors():
+    n_features = 3
+    n_samples = 10
+    rng = np.random.RandomState(0)
+    X = rng.random_sample((n_samples, n_features))
+    w_init = rng.randn(n_features + 1, n_features + 1)
+    with pytest.raises(ValueError, match=r"alpha must be in \[1,2\]"):
+        fastica(X, fun_args={"alpha": 0})
+    with pytest.raises(
+        ValueError, match="w_init has invalid shape.+" r"should be \(3L?, 3L?\)"
+    ):
+        fastica(X, w_init=w_init)
+
+
+def test_fastica_whiten_unit_variance():
+    """Test unit variance of transformed data using FastICA algorithm.
+
+    Bug #13056
+    """
+    rng = np.random.RandomState(0)
+    X = rng.random_sample((100, 10))
+    n_components = X.shape[1]
+    ica = FastICA(n_components=n_components, whiten="unit-variance", random_state=0)
+    Xt = ica.fit_transform(X)
+
+    assert np.var(Xt) == pytest.approx(1.0)
+
+
+@pytest.mark.parametrize("whiten", ["arbitrary-variance", "unit-variance", False])
+@pytest.mark.parametrize("return_X_mean", [True, False])
+@pytest.mark.parametrize("return_n_iter", [True, False])
+def test_fastica_output_shape(whiten, return_X_mean, return_n_iter):
+    n_features = 3
+    n_samples = 10
+    rng = np.random.RandomState(0)
+    X = rng.random_sample((n_samples, n_features))
+
+    expected_len = 3 + return_X_mean + return_n_iter
+
+    out = fastica(
+        X, whiten=whiten, return_n_iter=return_n_iter, return_X_mean=return_X_mean
+    )
+
+    assert len(out) == expected_len
+    if not whiten:
+        assert out[0] is None
+
+
+@pytest.mark.parametrize("add_noise", [True, False])
+def test_fastica_simple_different_solvers(add_noise, global_random_seed):
+    """Test FastICA is consistent between whiten_solvers."""
+    rng = np.random.RandomState(global_random_seed)
+    n_samples = 1000
+    # Generate two sources:
+    s1 = (2 * np.sin(np.linspace(0, 100, n_samples)) > 0) - 1
+    s2 = stats.t.rvs(1, size=n_samples, random_state=rng)
+    s = np.c_[s1, s2].T
+    center_and_norm(s)
+    s1, s2 = s
+
+    # Mixing angle
+    phi = rng.rand() * 2 * np.pi
+    mixing = np.array([[np.cos(phi), np.sin(phi)], [np.sin(phi), -np.cos(phi)]])
+    m = np.dot(mixing, s)
+
+    if add_noise:
+        m += 0.1 * rng.randn(2, 1000)
+
+    center_and_norm(m)
+
+    outs = {}
+    for solver in ("svd", "eigh"):
+        ica = FastICA(random_state=0, whiten="unit-variance", whiten_solver=solver)
+        sources = ica.fit_transform(m.T)
+        outs[solver] = sources
+        assert ica.components_.shape == (2, 2)
+        assert sources.shape == (1000, 2)
+
+    # compared numbers are not all on the same magnitude. Using a small atol to
+    # make the test less brittle
+    assert_allclose(outs["eigh"], outs["svd"], atol=1e-12)
+
+
+def test_fastica_eigh_low_rank_warning(global_random_seed):
+    """Test FastICA eigh solver raises warning for low-rank data."""
+    rng = np.random.RandomState(global_random_seed)
+    A = rng.randn(10, 2)
+    X = A @ A.T
+    ica = FastICA(random_state=0, whiten="unit-variance", whiten_solver="eigh")
+    msg = "There are some small singular values"
+    with pytest.warns(UserWarning, match=msg):
+        ica.fit(X)

venv/lib/python3.10/site-packages/sklearn/decomposition/tests/test_incremental_pca.py

@@ -0,0 +1,452 @@
+"""Tests for Incremental PCA."""
+import warnings
+
+import numpy as np
+import pytest
+from numpy.testing import assert_array_equal
+
+from sklearn import datasets
+from sklearn.decomposition import PCA, IncrementalPCA
+from sklearn.utils._testing import (
+    assert_allclose_dense_sparse,
+    assert_almost_equal,
+    assert_array_almost_equal,
+)
+from sklearn.utils.fixes import CSC_CONTAINERS, CSR_CONTAINERS, LIL_CONTAINERS
+
+iris = datasets.load_iris()
+
+
+def test_incremental_pca():
+    # Incremental PCA on dense arrays.
+    X = iris.data
+    batch_size = X.shape[0] // 3
+    ipca = IncrementalPCA(n_components=2, batch_size=batch_size)
+    pca = PCA(n_components=2)
+    pca.fit_transform(X)
+
+    X_transformed = ipca.fit_transform(X)
+
+    assert X_transformed.shape == (X.shape[0], 2)
+    np.testing.assert_allclose(
+        ipca.explained_variance_ratio_.sum(),
+        pca.explained_variance_ratio_.sum(),
+        rtol=1e-3,
+    )
+
+    for n_components in [1, 2, X.shape[1]]:
+        ipca = IncrementalPCA(n_components, batch_size=batch_size)
+        ipca.fit(X)
+        cov = ipca.get_covariance()
+        precision = ipca.get_precision()
+        np.testing.assert_allclose(
+            np.dot(cov, precision), np.eye(X.shape[1]), atol=1e-13
+        )
+
+
+@pytest.mark.parametrize(
+    "sparse_container", CSC_CONTAINERS + CSR_CONTAINERS + LIL_CONTAINERS
+)
+def test_incremental_pca_sparse(sparse_container):
+    # Incremental PCA on sparse arrays.
+    X = iris.data
+    pca = PCA(n_components=2)
+    pca.fit_transform(X)
+    X_sparse = sparse_container(X)
+    batch_size = X_sparse.shape[0] // 3
+    ipca = IncrementalPCA(n_components=2, batch_size=batch_size)
+
+    X_transformed = ipca.fit_transform(X_sparse)
+
+    assert X_transformed.shape == (X_sparse.shape[0], 2)
+    np.testing.assert_allclose(
+        ipca.explained_variance_ratio_.sum(),
+        pca.explained_variance_ratio_.sum(),
+        rtol=1e-3,
+    )
+
+    for n_components in [1, 2, X.shape[1]]:
+        ipca = IncrementalPCA(n_components, batch_size=batch_size)
+        ipca.fit(X_sparse)
+        cov = ipca.get_covariance()
+        precision = ipca.get_precision()
+        np.testing.assert_allclose(
+            np.dot(cov, precision), np.eye(X_sparse.shape[1]), atol=1e-13
+        )
+
+    with pytest.raises(
+        TypeError,
+        match=(
+            "IncrementalPCA.partial_fit does not support "
+            "sparse input. Either convert data to dense "
+            "or use IncrementalPCA.fit to do so in batches."
+        ),
+    ):
+        ipca.partial_fit(X_sparse)
+
+
+def test_incremental_pca_check_projection():
+    # Test that the projection of data is correct.
+    rng = np.random.RandomState(1999)
+    n, p = 100, 3
+    X = rng.randn(n, p) * 0.1
+    X[:10] += np.array([3, 4, 5])
+    Xt = 0.1 * rng.randn(1, p) + np.array([3, 4, 5])
+
+    # Get the reconstruction of the generated data X
+    # Note that Xt has the same "components" as X, just separated
+    # This is what we want to ensure is recreated correctly
+    Yt = IncrementalPCA(n_components=2).fit(X).transform(Xt)
+
+    # Normalize
+    Yt /= np.sqrt((Yt**2).sum())
+
+    # Make sure that the first element of Yt is ~1, this means
+    # the reconstruction worked as expected
+    assert_almost_equal(np.abs(Yt[0][0]), 1.0, 1)
+
+
+def test_incremental_pca_inverse():
+    # Test that the projection of data can be inverted.
+    rng = np.random.RandomState(1999)
+    n, p = 50, 3
+    X = rng.randn(n, p)  # spherical data
+    X[:, 1] *= 0.00001  # make middle component relatively small
+    X += [5, 4, 3]  # make a large mean
+
+    # same check that we can find the original data from the transformed
+    # signal (since the data is almost of rank n_components)
+    ipca = IncrementalPCA(n_components=2, batch_size=10).fit(X)
+    Y = ipca.transform(X)
+    Y_inverse = ipca.inverse_transform(Y)
+    assert_almost_equal(X, Y_inverse, decimal=3)
+
+
+def test_incremental_pca_validation():
+    # Test that n_components is <= n_features.
+    X = np.array([[0, 1, 0], [1, 0, 0]])
+    n_samples, n_features = X.shape
+    n_components = 4
+    with pytest.raises(
+        ValueError,
+        match=(
+            "n_components={} invalid"
+            " for n_features={}, need more rows than"
+            " columns for IncrementalPCA"
+            " processing".format(n_components, n_features)
+        ),
+    ):
+        IncrementalPCA(n_components, batch_size=10).fit(X)
+
+    # Tests that n_components is also <= n_samples.
+    n_components = 3
+    with pytest.raises(
+        ValueError,
+        match=(
+            "n_components={} must be"
+            " less or equal to the batch number of"
+            " samples {}".format(n_components, n_samples)
+        ),
+    ):
+        IncrementalPCA(n_components=n_components).partial_fit(X)
+
+
+def test_n_samples_equal_n_components():
+    # Ensures no warning is raised when n_samples==n_components
+    # Non-regression test for gh-19050
+    ipca = IncrementalPCA(n_components=5)
+    with warnings.catch_warnings():
+        warnings.simplefilter("error", RuntimeWarning)
+        ipca.partial_fit(np.random.randn(5, 7))
+    with warnings.catch_warnings():
+        warnings.simplefilter("error", RuntimeWarning)
+        ipca.fit(np.random.randn(5, 7))
+
+
+def test_n_components_none():
+    # Ensures that n_components == None is handled correctly
+    rng = np.random.RandomState(1999)
+    for n_samples, n_features in [(50, 10), (10, 50)]:
+        X = rng.rand(n_samples, n_features)
+        ipca = IncrementalPCA(n_components=None)
+
+        # First partial_fit call, ipca.n_components_ is inferred from
+        # min(X.shape)
+        ipca.partial_fit(X)
+        assert ipca.n_components_ == min(X.shape)
+
+        # Second partial_fit call, ipca.n_components_ is inferred from
+        # ipca.components_ computed from the first partial_fit call
+        ipca.partial_fit(X)
+        assert ipca.n_components_ == ipca.components_.shape[0]
+
+
+def test_incremental_pca_set_params():
+    # Test that components_ sign is stable over batch sizes.
+    rng = np.random.RandomState(1999)
+    n_samples = 100
+    n_features = 20
+    X = rng.randn(n_samples, n_features)
+    X2 = rng.randn(n_samples, n_features)
+    X3 = rng.randn(n_samples, n_features)
+    ipca = IncrementalPCA(n_components=20)
+    ipca.fit(X)
+    # Decreasing number of components
+    ipca.set_params(n_components=10)
+    with pytest.raises(ValueError):
+        ipca.partial_fit(X2)
+    # Increasing number of components
+    ipca.set_params(n_components=15)
+    with pytest.raises(ValueError):
+        ipca.partial_fit(X3)
+    # Returning to original setting
+    ipca.set_params(n_components=20)
+    ipca.partial_fit(X)
+
+
+def test_incremental_pca_num_features_change():
+    # Test that changing n_components will raise an error.
+    rng = np.random.RandomState(1999)
+    n_samples = 100
+    X = rng.randn(n_samples, 20)
+    X2 = rng.randn(n_samples, 50)
+    ipca = IncrementalPCA(n_components=None)
+    ipca.fit(X)
+    with pytest.raises(ValueError):
+        ipca.partial_fit(X2)
+
+
+def test_incremental_pca_batch_signs():
+    # Test that components_ sign is stable over batch sizes.
+    rng = np.random.RandomState(1999)
+    n_samples = 100
+    n_features = 3
+    X = rng.randn(n_samples, n_features)
+    all_components = []
+    batch_sizes = np.arange(10, 20)
+    for batch_size in batch_sizes:
+        ipca = IncrementalPCA(n_components=None, batch_size=batch_size).fit(X)
+        all_components.append(ipca.components_)
+
+    for i, j in zip(all_components[:-1], all_components[1:]):
+        assert_almost_equal(np.sign(i), np.sign(j), decimal=6)
+
+
+def test_incremental_pca_batch_values():
+    # Test that components_ values are stable over batch sizes.
+    rng = np.random.RandomState(1999)
+    n_samples = 100
+    n_features = 3
+    X = rng.randn(n_samples, n_features)
+    all_components = []
+    batch_sizes = np.arange(20, 40, 3)
+    for batch_size in batch_sizes:
+        ipca = IncrementalPCA(n_components=None, batch_size=batch_size).fit(X)
+        all_components.append(ipca.components_)
+
+    for i, j in zip(all_components[:-1], all_components[1:]):
+        assert_almost_equal(i, j, decimal=1)
+
+
+def test_incremental_pca_batch_rank():
+    # Test sample size in each batch is always larger or equal to n_components
+    rng = np.random.RandomState(1999)
+    n_samples = 100
+    n_features = 20
+    X = rng.randn(n_samples, n_features)
+    all_components = []
+    batch_sizes = np.arange(20, 90, 3)
+    for batch_size in batch_sizes:
+        ipca = IncrementalPCA(n_components=20, batch_size=batch_size).fit(X)
+        all_components.append(ipca.components_)
+
+    for components_i, components_j in zip(all_components[:-1], all_components[1:]):
+        assert_allclose_dense_sparse(components_i, components_j)
+
+
+def test_incremental_pca_partial_fit():
+    # Test that fit and partial_fit get equivalent results.
+    rng = np.random.RandomState(1999)
+    n, p = 50, 3
+    X = rng.randn(n, p)  # spherical data
+    X[:, 1] *= 0.00001  # make middle component relatively small
+    X += [5, 4, 3]  # make a large mean
+
+    # same check that we can find the original data from the transformed
+    # signal (since the data is almost of rank n_components)
+    batch_size = 10
+    ipca = IncrementalPCA(n_components=2, batch_size=batch_size).fit(X)
+    pipca = IncrementalPCA(n_components=2, batch_size=batch_size)
+    # Add one to make sure endpoint is included
+    batch_itr = np.arange(0, n + 1, batch_size)
+    for i, j in zip(batch_itr[:-1], batch_itr[1:]):
+        pipca.partial_fit(X[i:j, :])
+    assert_almost_equal(ipca.components_, pipca.components_, decimal=3)
+
+
+def test_incremental_pca_against_pca_iris():
+    # Test that IncrementalPCA and PCA are approximate (to a sign flip).
+    X = iris.data
+
+    Y_pca = PCA(n_components=2).fit_transform(X)
+    Y_ipca = IncrementalPCA(n_components=2, batch_size=25).fit_transform(X)
+
+    assert_almost_equal(np.abs(Y_pca), np.abs(Y_ipca), 1)
+
+
+def test_incremental_pca_against_pca_random_data():
+    # Test that IncrementalPCA and PCA are approximate (to a sign flip).
+    rng = np.random.RandomState(1999)
+    n_samples = 100
+    n_features = 3
+    X = rng.randn(n_samples, n_features) + 5 * rng.rand(1, n_features)
+
+    Y_pca = PCA(n_components=3).fit_transform(X)
+    Y_ipca = IncrementalPCA(n_components=3, batch_size=25).fit_transform(X)
+
+    assert_almost_equal(np.abs(Y_pca), np.abs(Y_ipca), 1)
+
+
+def test_explained_variances():
+    # Test that PCA and IncrementalPCA calculations match
+    X = datasets.make_low_rank_matrix(
+        1000, 100, tail_strength=0.0, effective_rank=10, random_state=1999
+    )
+    prec = 3
+    n_samples, n_features = X.shape
+    for nc in [None, 99]:
+        pca = PCA(n_components=nc).fit(X)
+        ipca = IncrementalPCA(n_components=nc, batch_size=100).fit(X)
+        assert_almost_equal(
+            pca.explained_variance_, ipca.explained_variance_, decimal=prec
+        )
+        assert_almost_equal(
+            pca.explained_variance_ratio_, ipca.explained_variance_ratio_, decimal=prec
+        )
+        assert_almost_equal(pca.noise_variance_, ipca.noise_variance_, decimal=prec)
+
+
+def test_singular_values():
+    # Check that the IncrementalPCA output has the correct singular values
+
+    rng = np.random.RandomState(0)
+    n_samples = 1000
+    n_features = 100
+
+    X = datasets.make_low_rank_matrix(
+        n_samples, n_features, tail_strength=0.0, effective_rank=10, random_state=rng
+    )
+
+    pca = PCA(n_components=10, svd_solver="full", random_state=rng).fit(X)
+    ipca = IncrementalPCA(n_components=10, batch_size=100).fit(X)
+    assert_array_almost_equal(pca.singular_values_, ipca.singular_values_, 2)
+
+    # Compare to the Frobenius norm
+    X_pca = pca.transform(X)
+    X_ipca = ipca.transform(X)
+    assert_array_almost_equal(
+        np.sum(pca.singular_values_**2.0), np.linalg.norm(X_pca, "fro") ** 2.0, 12
+    )
+    assert_array_almost_equal(
+        np.sum(ipca.singular_values_**2.0), np.linalg.norm(X_ipca, "fro") ** 2.0, 2
+    )
+
+    # Compare to the 2-norms of the score vectors
+    assert_array_almost_equal(
+        pca.singular_values_, np.sqrt(np.sum(X_pca**2.0, axis=0)), 12
+    )
+    assert_array_almost_equal(
+        ipca.singular_values_, np.sqrt(np.sum(X_ipca**2.0, axis=0)), 2
+    )
+
+    # Set the singular values and see what we get back
+    rng = np.random.RandomState(0)
+    n_samples = 100
+    n_features = 110
+
+    X = datasets.make_low_rank_matrix(
+        n_samples, n_features, tail_strength=0.0, effective_rank=3, random_state=rng
+    )
+
+    pca = PCA(n_components=3, svd_solver="full", random_state=rng)
+    ipca = IncrementalPCA(n_components=3, batch_size=100)
+
+    X_pca = pca.fit_transform(X)
+    X_pca /= np.sqrt(np.sum(X_pca**2.0, axis=0))
+    X_pca[:, 0] *= 3.142
+    X_pca[:, 1] *= 2.718
+
+    X_hat = np.dot(X_pca, pca.components_)
+    pca.fit(X_hat)
+    ipca.fit(X_hat)
+    assert_array_almost_equal(pca.singular_values_, [3.142, 2.718, 1.0], 14)
+    assert_array_almost_equal(ipca.singular_values_, [3.142, 2.718, 1.0], 14)
+
+
+def test_whitening():
+    # Test that PCA and IncrementalPCA transforms match to sign flip.
+    X = datasets.make_low_rank_matrix(
+        1000, 10, tail_strength=0.0, effective_rank=2, random_state=1999
+    )
+    prec = 3
+    n_samples, n_features = X.shape
+    for nc in [None, 9]:
+        pca = PCA(whiten=True, n_components=nc).fit(X)
+        ipca = IncrementalPCA(whiten=True, n_components=nc, batch_size=250).fit(X)
+
+        Xt_pca = pca.transform(X)
+        Xt_ipca = ipca.transform(X)
+        assert_almost_equal(np.abs(Xt_pca), np.abs(Xt_ipca), decimal=prec)
+        Xinv_ipca = ipca.inverse_transform(Xt_ipca)
+        Xinv_pca = pca.inverse_transform(Xt_pca)
+        assert_almost_equal(X, Xinv_ipca, decimal=prec)
+        assert_almost_equal(X, Xinv_pca, decimal=prec)
+        assert_almost_equal(Xinv_pca, Xinv_ipca, decimal=prec)
+
+
+def test_incremental_pca_partial_fit_float_division():
+    # Test to ensure float division is used in all versions of Python
+    # (non-regression test for issue #9489)
+
+    rng = np.random.RandomState(0)
+    A = rng.randn(5, 3) + 2
+    B = rng.randn(7, 3) + 5
+
+    pca = IncrementalPCA(n_components=2)
+    pca.partial_fit(A)
+    # Set n_samples_seen_ to be a floating point number instead of an int
+    pca.n_samples_seen_ = float(pca.n_samples_seen_)
+    pca.partial_fit(B)
+    singular_vals_float_samples_seen = pca.singular_values_
+
+    pca2 = IncrementalPCA(n_components=2)
+    pca2.partial_fit(A)
+    pca2.partial_fit(B)
+    singular_vals_int_samples_seen = pca2.singular_values_
+
+    np.testing.assert_allclose(
+        singular_vals_float_samples_seen, singular_vals_int_samples_seen
+    )
+
+
+def test_incremental_pca_fit_overflow_error():
+    # Test for overflow error on Windows OS
+    # (non-regression test for issue #17693)
+    rng = np.random.RandomState(0)
+    A = rng.rand(500000, 2)
+
+    ipca = IncrementalPCA(n_components=2, batch_size=10000)
+    ipca.fit(A)
+
+    pca = PCA(n_components=2)
+    pca.fit(A)
+
+    np.testing.assert_allclose(ipca.singular_values_, pca.singular_values_)
+
+
+def test_incremental_pca_feature_names_out():
+    """Check feature names out for IncrementalPCA."""
+    ipca = IncrementalPCA(n_components=2).fit(iris.data)
+
+    names = ipca.get_feature_names_out()
+    assert_array_equal([f"incrementalpca{i}" for i in range(2)], names)

venv/lib/python3.10/site-packages/sklearn/decomposition/tests/test_kernel_pca.py

@@ -0,0 +1,566 @@
+import warnings
+
+import numpy as np
+import pytest
+
+import sklearn
+from sklearn.datasets import load_iris, make_blobs, make_circles
+from sklearn.decomposition import PCA, KernelPCA
+from sklearn.exceptions import NotFittedError
+from sklearn.linear_model import Perceptron
+from sklearn.metrics.pairwise import rbf_kernel
+from sklearn.model_selection import GridSearchCV
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import StandardScaler
+from sklearn.utils._testing import (
+    assert_allclose,
+    assert_array_almost_equal,
+    assert_array_equal,
+)
+from sklearn.utils.fixes import CSR_CONTAINERS
+from sklearn.utils.validation import _check_psd_eigenvalues
+
+
+def test_kernel_pca():
+    """Nominal test for all solvers and all known kernels + a custom one
+
+    It tests
+     - that fit_transform is equivalent to fit+transform
+     - that the shapes of transforms and inverse transforms are correct
+    """
+    rng = np.random.RandomState(0)
+    X_fit = rng.random_sample((5, 4))
+    X_pred = rng.random_sample((2, 4))
+
+    def histogram(x, y, **kwargs):
+        # Histogram kernel implemented as a callable.
+        assert kwargs == {}  # no kernel_params that we didn't ask for
+        return np.minimum(x, y).sum()
+
+    for eigen_solver in ("auto", "dense", "arpack", "randomized"):
+        for kernel in ("linear", "rbf", "poly", histogram):
+            # histogram kernel produces singular matrix inside linalg.solve
+            # XXX use a least-squares approximation?
+            inv = not callable(kernel)
+
+            # transform fit data
+            kpca = KernelPCA(
+                4, kernel=kernel, eigen_solver=eigen_solver, fit_inverse_transform=inv
+            )
+            X_fit_transformed = kpca.fit_transform(X_fit)
+            X_fit_transformed2 = kpca.fit(X_fit).transform(X_fit)
+            assert_array_almost_equal(
+                np.abs(X_fit_transformed), np.abs(X_fit_transformed2)
+            )
+
+            # non-regression test: previously, gamma would be 0 by default,
+            # forcing all eigenvalues to 0 under the poly kernel
+            assert X_fit_transformed.size != 0
+
+            # transform new data
+            X_pred_transformed = kpca.transform(X_pred)
+            assert X_pred_transformed.shape[1] == X_fit_transformed.shape[1]
+
+            # inverse transform
+            if inv:
+                X_pred2 = kpca.inverse_transform(X_pred_transformed)
+                assert X_pred2.shape == X_pred.shape
+
+
+def test_kernel_pca_invalid_parameters():
+    """Check that kPCA raises an error if the parameters are invalid
+
+    Tests fitting inverse transform with a precomputed kernel raises a
+    ValueError.
+    """
+    estimator = KernelPCA(
+        n_components=10, fit_inverse_transform=True, kernel="precomputed"
+    )
+    err_ms = "Cannot fit_inverse_transform with a precomputed kernel"
+    with pytest.raises(ValueError, match=err_ms):
+        estimator.fit(np.random.randn(10, 10))
+
+
+def test_kernel_pca_consistent_transform():
+    """Check robustness to mutations in the original training array
+
+    Test that after fitting a kPCA model, it stays independent of any
+    mutation of the values of the original data object by relying on an
+    internal copy.
+    """
+    # X_fit_ needs to retain the old, unmodified copy of X
+    state = np.random.RandomState(0)
+    X = state.rand(10, 10)
+    kpca = KernelPCA(random_state=state).fit(X)
+    transformed1 = kpca.transform(X)
+
+    X_copy = X.copy()
+    X[:, 0] = 666
+    transformed2 = kpca.transform(X_copy)
+    assert_array_almost_equal(transformed1, transformed2)
+
+
+def test_kernel_pca_deterministic_output():
+    """Test that Kernel PCA produces deterministic output
+
+    Tests that the same inputs and random state produce the same output.
+    """
+    rng = np.random.RandomState(0)
+    X = rng.rand(10, 10)
+    eigen_solver = ("arpack", "dense")
+
+    for solver in eigen_solver:
+        transformed_X = np.zeros((20, 2))
+        for i in range(20):
+            kpca = KernelPCA(n_components=2, eigen_solver=solver, random_state=rng)
+            transformed_X[i, :] = kpca.fit_transform(X)[0]
+        assert_allclose(transformed_X, np.tile(transformed_X[0, :], 20).reshape(20, 2))
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_kernel_pca_sparse(csr_container):
+    """Test that kPCA works on a sparse data input.
+
+    Same test as ``test_kernel_pca except inverse_transform`` since it's not
+    implemented for sparse matrices.
+    """
+    rng = np.random.RandomState(0)
+    X_fit = csr_container(rng.random_sample((5, 4)))
+    X_pred = csr_container(rng.random_sample((2, 4)))
+
+    for eigen_solver in ("auto", "arpack", "randomized"):
+        for kernel in ("linear", "rbf", "poly"):
+            # transform fit data
+            kpca = KernelPCA(
+                4,
+                kernel=kernel,
+                eigen_solver=eigen_solver,
+                fit_inverse_transform=False,
+                random_state=0,
+            )
+            X_fit_transformed = kpca.fit_transform(X_fit)
+            X_fit_transformed2 = kpca.fit(X_fit).transform(X_fit)
+            assert_array_almost_equal(
+                np.abs(X_fit_transformed), np.abs(X_fit_transformed2)
+            )
+
+            # transform new data
+            X_pred_transformed = kpca.transform(X_pred)
+            assert X_pred_transformed.shape[1] == X_fit_transformed.shape[1]
+
+            # inverse transform: not available for sparse matrices
+            # XXX: should we raise another exception type here? For instance:
+            # NotImplementedError.
+            with pytest.raises(NotFittedError):
+                kpca.inverse_transform(X_pred_transformed)
+
+
+@pytest.mark.parametrize("solver", ["auto", "dense", "arpack", "randomized"])
+@pytest.mark.parametrize("n_features", [4, 10])
+def test_kernel_pca_linear_kernel(solver, n_features):
+    """Test that kPCA with linear kernel is equivalent to PCA for all solvers.
+
+    KernelPCA with linear kernel should produce the same output as PCA.
+    """
+    rng = np.random.RandomState(0)
+    X_fit = rng.random_sample((5, n_features))
+    X_pred = rng.random_sample((2, n_features))
+
+    # for a linear kernel, kernel PCA should find the same projection as PCA
+    # modulo the sign (direction)
+    # fit only the first four components: fifth is near zero eigenvalue, so
+    # can be trimmed due to roundoff error
+    n_comps = 3 if solver == "arpack" else 4
+    assert_array_almost_equal(
+        np.abs(KernelPCA(n_comps, eigen_solver=solver).fit(X_fit).transform(X_pred)),
+        np.abs(
+            PCA(n_comps, svd_solver=solver if solver != "dense" else "full")
+            .fit(X_fit)
+            .transform(X_pred)
+        ),
+    )
+
+
+def test_kernel_pca_n_components():
+    """Test that `n_components` is correctly taken into account for projections
+
+    For all solvers this tests that the output has the correct shape depending
+    on the selected number of components.
+    """
+    rng = np.random.RandomState(0)
+    X_fit = rng.random_sample((5, 4))
+    X_pred = rng.random_sample((2, 4))
+
+    for eigen_solver in ("dense", "arpack", "randomized"):
+        for c in [1, 2, 4]:
+            kpca = KernelPCA(n_components=c, eigen_solver=eigen_solver)
+            shape = kpca.fit(X_fit).transform(X_pred).shape
+
+            assert shape == (2, c)
+
+
+def test_remove_zero_eig():
+    """Check that the ``remove_zero_eig`` parameter works correctly.
+
+    Tests that the null-space (Zero) eigenvalues are removed when
+    remove_zero_eig=True, whereas they are not by default.
+    """
+    X = np.array([[1 - 1e-30, 1], [1, 1], [1, 1 - 1e-20]])
+
+    # n_components=None (default) => remove_zero_eig is True
+    kpca = KernelPCA()
+    Xt = kpca.fit_transform(X)
+    assert Xt.shape == (3, 0)
+
+    kpca = KernelPCA(n_components=2)
+    Xt = kpca.fit_transform(X)
+    assert Xt.shape == (3, 2)
+
+    kpca = KernelPCA(n_components=2, remove_zero_eig=True)
+    Xt = kpca.fit_transform(X)
+    assert Xt.shape == (3, 0)
+
+
+def test_leave_zero_eig():
+    """Non-regression test for issue #12141 (PR #12143)
+
+    This test checks that fit().transform() returns the same result as
+    fit_transform() in case of non-removed zero eigenvalue.
+    """
+    X_fit = np.array([[1, 1], [0, 0]])
+
+    # Assert that even with all np warnings on, there is no div by zero warning
+    with warnings.catch_warnings():
+        # There might be warnings about the kernel being badly conditioned,
+        # but there should not be warnings about division by zero.
+        # (Numpy division by zero warning can have many message variants, but
+        # at least we know that it is a RuntimeWarning so lets check only this)
+        warnings.simplefilter("error", RuntimeWarning)
+        with np.errstate(all="warn"):
+            k = KernelPCA(n_components=2, remove_zero_eig=False, eigen_solver="dense")
+            # Fit, then transform
+            A = k.fit(X_fit).transform(X_fit)
+            # Do both at once
+            B = k.fit_transform(X_fit)
+            # Compare
+            assert_array_almost_equal(np.abs(A), np.abs(B))
+
+
+def test_kernel_pca_precomputed():
+    """Test that kPCA works with a precomputed kernel, for all solvers"""
+    rng = np.random.RandomState(0)
+    X_fit = rng.random_sample((5, 4))
+    X_pred = rng.random_sample((2, 4))
+
+    for eigen_solver in ("dense", "arpack", "randomized"):
+        X_kpca = (
+            KernelPCA(4, eigen_solver=eigen_solver, random_state=0)
+            .fit(X_fit)
+            .transform(X_pred)
+        )
+
+        X_kpca2 = (
+            KernelPCA(
+                4, eigen_solver=eigen_solver, kernel="precomputed", random_state=0
+            )
+            .fit(np.dot(X_fit, X_fit.T))
+            .transform(np.dot(X_pred, X_fit.T))
+        )
+
+        X_kpca_train = KernelPCA(
+            4, eigen_solver=eigen_solver, kernel="precomputed", random_state=0
+        ).fit_transform(np.dot(X_fit, X_fit.T))
+
+        X_kpca_train2 = (
+            KernelPCA(
+                4, eigen_solver=eigen_solver, kernel="precomputed", random_state=0
+            )
+            .fit(np.dot(X_fit, X_fit.T))
+            .transform(np.dot(X_fit, X_fit.T))
+        )
+
+        assert_array_almost_equal(np.abs(X_kpca), np.abs(X_kpca2))
+
+        assert_array_almost_equal(np.abs(X_kpca_train), np.abs(X_kpca_train2))
+
+
+@pytest.mark.parametrize("solver", ["auto", "dense", "arpack", "randomized"])
+def test_kernel_pca_precomputed_non_symmetric(solver):
+    """Check that the kernel centerer works.
+
+    Tests that a non symmetric precomputed kernel is actually accepted
+    because the kernel centerer does its job correctly.
+    """
+
+    # a non symmetric gram matrix
+    K = [[1, 2], [3, 40]]
+    kpca = KernelPCA(
+        kernel="precomputed", eigen_solver=solver, n_components=1, random_state=0
+    )
+    kpca.fit(K)  # no error
+
+    # same test with centered kernel
+    Kc = [[9, -9], [-9, 9]]
+    kpca_c = KernelPCA(
+        kernel="precomputed", eigen_solver=solver, n_components=1, random_state=0
+    )
+    kpca_c.fit(Kc)
+
+    # comparison between the non-centered and centered versions
+    assert_array_equal(kpca.eigenvectors_, kpca_c.eigenvectors_)
+    assert_array_equal(kpca.eigenvalues_, kpca_c.eigenvalues_)
+
+
+def test_gridsearch_pipeline():
+    """Check that kPCA works as expected in a grid search pipeline
+
+    Test if we can do a grid-search to find parameters to separate
+    circles with a perceptron model.
+    """
+    X, y = make_circles(n_samples=400, factor=0.3, noise=0.05, random_state=0)
+    kpca = KernelPCA(kernel="rbf", n_components=2)
+    pipeline = Pipeline([("kernel_pca", kpca), ("Perceptron", Perceptron(max_iter=5))])
+    param_grid = dict(kernel_pca__gamma=2.0 ** np.arange(-2, 2))
+    grid_search = GridSearchCV(pipeline, cv=3, param_grid=param_grid)
+    grid_search.fit(X, y)
+    assert grid_search.best_score_ == 1
+
+
+def test_gridsearch_pipeline_precomputed():
+    """Check that kPCA works as expected in a grid search pipeline (2)
+
+    Test if we can do a grid-search to find parameters to separate
+    circles with a perceptron model. This test uses a precomputed kernel.
+    """
+    X, y = make_circles(n_samples=400, factor=0.3, noise=0.05, random_state=0)
+    kpca = KernelPCA(kernel="precomputed", n_components=2)
+    pipeline = Pipeline([("kernel_pca", kpca), ("Perceptron", Perceptron(max_iter=5))])
+    param_grid = dict(Perceptron__max_iter=np.arange(1, 5))
+    grid_search = GridSearchCV(pipeline, cv=3, param_grid=param_grid)
+    X_kernel = rbf_kernel(X, gamma=2.0)
+    grid_search.fit(X_kernel, y)
+    assert grid_search.best_score_ == 1
+
+
+def test_nested_circles():
+    """Check that kPCA projects in a space where nested circles are separable
+
+    Tests that 2D nested circles become separable with a perceptron when
+    projected in the first 2 kPCA using an RBF kernel, while raw samples
+    are not directly separable in the original space.
+    """
+    X, y = make_circles(n_samples=400, factor=0.3, noise=0.05, random_state=0)
+
+    # 2D nested circles are not linearly separable
+    train_score = Perceptron(max_iter=5).fit(X, y).score(X, y)
+    assert train_score < 0.8
+
+    # Project the circles data into the first 2 components of a RBF Kernel
+    # PCA model.
+    # Note that the gamma value is data dependent. If this test breaks
+    # and the gamma value has to be updated, the Kernel PCA example will
+    # have to be updated too.
+    kpca = KernelPCA(
+        kernel="rbf", n_components=2, fit_inverse_transform=True, gamma=2.0
+    )
+    X_kpca = kpca.fit_transform(X)
+
+    # The data is perfectly linearly separable in that space
+    train_score = Perceptron(max_iter=5).fit(X_kpca, y).score(X_kpca, y)
+    assert train_score == 1.0
+
+
+def test_kernel_conditioning():
+    """Check that ``_check_psd_eigenvalues`` is correctly called in kPCA
+
+    Non-regression test for issue #12140 (PR #12145).
+    """
+
+    # create a pathological X leading to small non-zero eigenvalue
+    X = [[5, 1], [5 + 1e-8, 1e-8], [5 + 1e-8, 0]]
+    kpca = KernelPCA(kernel="linear", n_components=2, fit_inverse_transform=True)
+    kpca.fit(X)
+
+    # check that the small non-zero eigenvalue was correctly set to zero
+    assert kpca.eigenvalues_.min() == 0
+    assert np.all(kpca.eigenvalues_ == _check_psd_eigenvalues(kpca.eigenvalues_))
+
+
+@pytest.mark.parametrize("solver", ["auto", "dense", "arpack", "randomized"])
+def test_precomputed_kernel_not_psd(solver):
+    """Check how KernelPCA works with non-PSD kernels depending on n_components
+
+    Tests for all methods what happens with a non PSD gram matrix (this
+    can happen in an isomap scenario, or with custom kernel functions, or
+    maybe with ill-posed datasets).
+
+    When ``n_component`` is large enough to capture a negative eigenvalue, an
+    error should be raised. Otherwise, KernelPCA should run without error
+    since the negative eigenvalues are not selected.
+    """
+
+    # a non PSD kernel with large eigenvalues, already centered
+    # it was captured from an isomap call and multiplied by 100 for compacity
+    K = [
+        [4.48, -1.0, 8.07, 2.33, 2.33, 2.33, -5.76, -12.78],
+        [-1.0, -6.48, 4.5, -1.24, -1.24, -1.24, -0.81, 7.49],
+        [8.07, 4.5, 15.48, 2.09, 2.09, 2.09, -11.1, -23.23],
+        [2.33, -1.24, 2.09, 4.0, -3.65, -3.65, 1.02, -0.9],
+        [2.33, -1.24, 2.09, -3.65, 4.0, -3.65, 1.02, -0.9],
+        [2.33, -1.24, 2.09, -3.65, -3.65, 4.0, 1.02, -0.9],
+        [-5.76, -0.81, -11.1, 1.02, 1.02, 1.02, 4.86, 9.75],
+        [-12.78, 7.49, -23.23, -0.9, -0.9, -0.9, 9.75, 21.46],
+    ]
+    # this gram matrix has 5 positive eigenvalues and 3 negative ones
+    # [ 52.72,   7.65,   7.65,   5.02,   0.  ,  -0.  ,  -6.13, -15.11]
+
+    # 1. ask for enough components to get a significant negative one
+    kpca = KernelPCA(kernel="precomputed", eigen_solver=solver, n_components=7)
+    # make sure that the appropriate error is raised
+    with pytest.raises(ValueError, match="There are significant negative eigenvalues"):
+        kpca.fit(K)
+
+    # 2. ask for a small enough n_components to get only positive ones
+    kpca = KernelPCA(kernel="precomputed", eigen_solver=solver, n_components=2)
+    if solver == "randomized":
+        # the randomized method is still inconsistent with the others on this
+        # since it selects the eigenvalues based on the largest 2 modules, not
+        # on the largest 2 values.
+        #
+        # At least we can ensure that we return an error instead of returning
+        # the wrong eigenvalues
+        with pytest.raises(
+            ValueError, match="There are significant negative eigenvalues"
+        ):
+            kpca.fit(K)
+    else:
+        # general case: make sure that it works
+        kpca.fit(K)
+
+
+@pytest.mark.parametrize("n_components", [4, 10, 20])
+def test_kernel_pca_solvers_equivalence(n_components):
+    """Check that 'dense' 'arpack' & 'randomized' solvers give similar results"""
+
+    # Generate random data
+    n_train, n_test = 1_000, 100
+    X, _ = make_circles(
+        n_samples=(n_train + n_test), factor=0.3, noise=0.05, random_state=0
+    )
+    X_fit, X_pred = X[:n_train, :], X[n_train:, :]
+
+    # reference (full)
+    ref_pred = (
+        KernelPCA(n_components, eigen_solver="dense", random_state=0)
+        .fit(X_fit)
+        .transform(X_pred)
+    )
+
+    # arpack
+    a_pred = (
+        KernelPCA(n_components, eigen_solver="arpack", random_state=0)
+        .fit(X_fit)
+        .transform(X_pred)
+    )
+    # check that the result is still correct despite the approx
+    assert_array_almost_equal(np.abs(a_pred), np.abs(ref_pred))
+
+    # randomized
+    r_pred = (
+        KernelPCA(n_components, eigen_solver="randomized", random_state=0)
+        .fit(X_fit)
+        .transform(X_pred)
+    )
+    # check that the result is still correct despite the approximation
+    assert_array_almost_equal(np.abs(r_pred), np.abs(ref_pred))
+
+
+def test_kernel_pca_inverse_transform_reconstruction():
+    """Test if the reconstruction is a good approximation.
+
+    Note that in general it is not possible to get an arbitrarily good
+    reconstruction because of kernel centering that does not
+    preserve all the information of the original data.
+    """
+    X, *_ = make_blobs(n_samples=100, n_features=4, random_state=0)
+
+    kpca = KernelPCA(
+        n_components=20, kernel="rbf", fit_inverse_transform=True, alpha=1e-3
+    )
+    X_trans = kpca.fit_transform(X)
+    X_reconst = kpca.inverse_transform(X_trans)
+    assert np.linalg.norm(X - X_reconst) / np.linalg.norm(X) < 1e-1
+
+
+def test_kernel_pca_raise_not_fitted_error():
+    X = np.random.randn(15).reshape(5, 3)
+    kpca = KernelPCA()
+    kpca.fit(X)
+    with pytest.raises(NotFittedError):
+        kpca.inverse_transform(X)
+
+
+def test_32_64_decomposition_shape():
+    """Test that the decomposition is similar for 32 and 64 bits data
+
+    Non regression test for
+    https://github.com/scikit-learn/scikit-learn/issues/18146
+    """
+    X, y = make_blobs(
+        n_samples=30, centers=[[0, 0, 0], [1, 1, 1]], random_state=0, cluster_std=0.1
+    )
+    X = StandardScaler().fit_transform(X)
+    X -= X.min()
+
+    # Compare the shapes (corresponds to the number of non-zero eigenvalues)
+    kpca = KernelPCA()
+    assert kpca.fit_transform(X).shape == kpca.fit_transform(X.astype(np.float32)).shape
+
+
+def test_kernel_pca_feature_names_out():
+    """Check feature names out for KernelPCA."""
+    X, *_ = make_blobs(n_samples=100, n_features=4, random_state=0)
+    kpca = KernelPCA(n_components=2).fit(X)
+
+    names = kpca.get_feature_names_out()
+    assert_array_equal([f"kernelpca{i}" for i in range(2)], names)
+
+
+def test_kernel_pca_inverse_correct_gamma():
+    """Check that gamma is set correctly when not provided.
+
+    Non-regression test for #26280
+    """
+    rng = np.random.RandomState(0)
+    X = rng.random_sample((5, 4))
+
+    kwargs = {
+        "n_components": 2,
+        "random_state": rng,
+        "fit_inverse_transform": True,
+        "kernel": "rbf",
+    }
+
+    expected_gamma = 1 / X.shape[1]
+    kpca1 = KernelPCA(gamma=None, **kwargs).fit(X)
+    kpca2 = KernelPCA(gamma=expected_gamma, **kwargs).fit(X)
+
+    assert kpca1.gamma_ == expected_gamma
+    assert kpca2.gamma_ == expected_gamma
+
+    X1_recon = kpca1.inverse_transform(kpca1.transform(X))
+    X2_recon = kpca2.inverse_transform(kpca1.transform(X))
+
+    assert_allclose(X1_recon, X2_recon)
+
+
+def test_kernel_pca_pandas_output():
+    """Check that KernelPCA works with pandas output when the solver is arpack.
+
+    Non-regression test for:
+    https://github.com/scikit-learn/scikit-learn/issues/27579
+    """
+    pytest.importorskip("pandas")
+    X, _ = load_iris(as_frame=True, return_X_y=True)
+    with sklearn.config_context(transform_output="pandas"):
+        KernelPCA(n_components=2, eigen_solver="arpack").fit_transform(X)

venv/lib/python3.10/site-packages/sklearn/decomposition/tests/test_nmf.py

@@ -0,0 +1,1062 @@
+import re
+import sys
+import warnings
+from io import StringIO
+
+import numpy as np
+import pytest
+from scipy import linalg
+
+from sklearn.base import clone
+from sklearn.decomposition import NMF, MiniBatchNMF, non_negative_factorization
+from sklearn.decomposition import _nmf as nmf  # For testing internals
+from sklearn.exceptions import ConvergenceWarning
+from sklearn.utils._testing import (
+    assert_allclose,
+    assert_almost_equal,
+    assert_array_almost_equal,
+    assert_array_equal,
+    ignore_warnings,
+)
+from sklearn.utils.extmath import squared_norm
+from sklearn.utils.fixes import CSC_CONTAINERS, CSR_CONTAINERS
+
+
+@pytest.mark.parametrize(
+    ["Estimator", "solver"],
+    [[NMF, {"solver": "cd"}], [NMF, {"solver": "mu"}], [MiniBatchNMF, {}]],
+)
+def test_convergence_warning(Estimator, solver):
+    convergence_warning = (
+        "Maximum number of iterations 1 reached. Increase it to improve convergence."
+    )
+    A = np.ones((2, 2))
+    with pytest.warns(ConvergenceWarning, match=convergence_warning):
+        Estimator(max_iter=1, n_components="auto", **solver).fit(A)
+
+
+def test_initialize_nn_output():
+    # Test that initialization does not return negative values
+    rng = np.random.mtrand.RandomState(42)
+    data = np.abs(rng.randn(10, 10))
+    for init in ("random", "nndsvd", "nndsvda", "nndsvdar"):
+        W, H = nmf._initialize_nmf(data, 10, init=init, random_state=0)
+        assert not ((W < 0).any() or (H < 0).any())
+
+
+# TODO(1.6): remove the warning filter for `n_components`
+@pytest.mark.filterwarnings(
+    r"ignore:The multiplicative update \('mu'\) solver cannot update zeros present in"
+    r" the initialization",
+    "ignore:The default value of `n_components` will change",
+)
+def test_parameter_checking():
+    # Here we only check for invalid parameter values that are not already
+    # automatically tested in the common tests.
+
+    A = np.ones((2, 2))
+
+    msg = "Invalid beta_loss parameter: solver 'cd' does not handle beta_loss = 1.0"
+    with pytest.raises(ValueError, match=msg):
+        NMF(solver="cd", beta_loss=1.0).fit(A)
+    msg = "Negative values in data passed to"
+    with pytest.raises(ValueError, match=msg):
+        NMF().fit(-A)
+    clf = NMF(2, tol=0.1).fit(A)
+    with pytest.raises(ValueError, match=msg):
+        clf.transform(-A)
+    with pytest.raises(ValueError, match=msg):
+        nmf._initialize_nmf(-A, 2, "nndsvd")
+
+    for init in ["nndsvd", "nndsvda", "nndsvdar"]:
+        msg = re.escape(
+            "init = '{}' can only be used when "
+            "n_components <= min(n_samples, n_features)".format(init)
+        )
+        with pytest.raises(ValueError, match=msg):
+            NMF(3, init=init).fit(A)
+        with pytest.raises(ValueError, match=msg):
+            MiniBatchNMF(3, init=init).fit(A)
+        with pytest.raises(ValueError, match=msg):
+            nmf._initialize_nmf(A, 3, init)
+
+
+def test_initialize_close():
+    # Test NNDSVD error
+    # Test that _initialize_nmf error is less than the standard deviation of
+    # the entries in the matrix.
+    rng = np.random.mtrand.RandomState(42)
+    A = np.abs(rng.randn(10, 10))
+    W, H = nmf._initialize_nmf(A, 10, init="nndsvd")
+    error = linalg.norm(np.dot(W, H) - A)
+    sdev = linalg.norm(A - A.mean())
+    assert error <= sdev
+
+
+def test_initialize_variants():
+    # Test NNDSVD variants correctness
+    # Test that the variants 'nndsvda' and 'nndsvdar' differ from basic
+    # 'nndsvd' only where the basic version has zeros.
+    rng = np.random.mtrand.RandomState(42)
+    data = np.abs(rng.randn(10, 10))
+    W0, H0 = nmf._initialize_nmf(data, 10, init="nndsvd")
+    Wa, Ha = nmf._initialize_nmf(data, 10, init="nndsvda")
+    War, Har = nmf._initialize_nmf(data, 10, init="nndsvdar", random_state=0)
+
+    for ref, evl in ((W0, Wa), (W0, War), (H0, Ha), (H0, Har)):
+        assert_almost_equal(evl[ref != 0], ref[ref != 0])
+
+
+# ignore UserWarning raised when both solver='mu' and init='nndsvd'
+@ignore_warnings(category=UserWarning)
+@pytest.mark.parametrize(
+    ["Estimator", "solver"],
+    [[NMF, {"solver": "cd"}], [NMF, {"solver": "mu"}], [MiniBatchNMF, {}]],
+)
+@pytest.mark.parametrize("init", (None, "nndsvd", "nndsvda", "nndsvdar", "random"))
+@pytest.mark.parametrize("alpha_W", (0.0, 1.0))
+@pytest.mark.parametrize("alpha_H", (0.0, 1.0, "same"))
+def test_nmf_fit_nn_output(Estimator, solver, init, alpha_W, alpha_H):
+    # Test that the decomposition does not contain negative values
+    A = np.c_[5.0 - np.arange(1, 6), 5.0 + np.arange(1, 6)]
+    model = Estimator(
+        n_components=2,
+        init=init,
+        alpha_W=alpha_W,
+        alpha_H=alpha_H,
+        random_state=0,
+        **solver,
+    )
+    transf = model.fit_transform(A)
+    assert not ((model.components_ < 0).any() or (transf < 0).any())
+
+
+@pytest.mark.parametrize(
+    ["Estimator", "solver"],
+    [[NMF, {"solver": "cd"}], [NMF, {"solver": "mu"}], [MiniBatchNMF, {}]],
+)
+def test_nmf_fit_close(Estimator, solver):
+    rng = np.random.mtrand.RandomState(42)
+    # Test that the fit is not too far away
+    pnmf = Estimator(
+        5,
+        init="nndsvdar",
+        random_state=0,
+        max_iter=600,
+        **solver,
+    )
+    X = np.abs(rng.randn(6, 5))
+    assert pnmf.fit(X).reconstruction_err_ < 0.1
+
+
+def test_nmf_true_reconstruction():
+    # Test that the fit is not too far away from an exact solution
+    # (by construction)
+    n_samples = 15
+    n_features = 10
+    n_components = 5
+    beta_loss = 1
+    batch_size = 3
+    max_iter = 1000
+
+    rng = np.random.mtrand.RandomState(42)
+    W_true = np.zeros([n_samples, n_components])
+    W_array = np.abs(rng.randn(n_samples))
+    for j in range(n_components):
+        W_true[j % n_samples, j] = W_array[j % n_samples]
+    H_true = np.zeros([n_components, n_features])
+    H_array = np.abs(rng.randn(n_components))
+    for j in range(n_features):
+        H_true[j % n_components, j] = H_array[j % n_components]
+    X = np.dot(W_true, H_true)
+
+    model = NMF(
+        n_components=n_components,
+        solver="mu",
+        beta_loss=beta_loss,
+        max_iter=max_iter,
+        random_state=0,
+    )
+    transf = model.fit_transform(X)
+    X_calc = np.dot(transf, model.components_)
+
+    assert model.reconstruction_err_ < 0.1
+    assert_allclose(X, X_calc)
+
+    mbmodel = MiniBatchNMF(
+        n_components=n_components,
+        beta_loss=beta_loss,
+        batch_size=batch_size,
+        random_state=0,
+        max_iter=max_iter,
+    )
+    transf = mbmodel.fit_transform(X)
+    X_calc = np.dot(transf, mbmodel.components_)
+
+    assert mbmodel.reconstruction_err_ < 0.1
+    assert_allclose(X, X_calc, atol=1)
+
+
+@pytest.mark.parametrize("solver", ["cd", "mu"])
+def test_nmf_transform(solver):
+    # Test that fit_transform is equivalent to fit.transform for NMF
+    # Test that NMF.transform returns close values
+    rng = np.random.mtrand.RandomState(42)
+    A = np.abs(rng.randn(6, 5))
+    m = NMF(
+        solver=solver,
+        n_components=3,
+        init="random",
+        random_state=0,
+        tol=1e-6,
+    )
+    ft = m.fit_transform(A)
+    t = m.transform(A)
+    assert_allclose(ft, t, atol=1e-1)
+
+
+def test_minibatch_nmf_transform():
+    # Test that fit_transform is equivalent to fit.transform for MiniBatchNMF
+    # Only guaranteed with fresh restarts
+    rng = np.random.mtrand.RandomState(42)
+    A = np.abs(rng.randn(6, 5))
+    m = MiniBatchNMF(
+        n_components=3,
+        random_state=0,
+        tol=1e-3,
+        fresh_restarts=True,
+    )
+    ft = m.fit_transform(A)
+    t = m.transform(A)
+    assert_allclose(ft, t)
+
+
+@pytest.mark.parametrize(
+    ["Estimator", "solver"],
+    [[NMF, {"solver": "cd"}], [NMF, {"solver": "mu"}], [MiniBatchNMF, {}]],
+)
+def test_nmf_transform_custom_init(Estimator, solver):
+    # Smoke test that checks if NMF.transform works with custom initialization
+    random_state = np.random.RandomState(0)
+    A = np.abs(random_state.randn(6, 5))
+    n_components = 4
+    avg = np.sqrt(A.mean() / n_components)
+    H_init = np.abs(avg * random_state.randn(n_components, 5))
+    W_init = np.abs(avg * random_state.randn(6, n_components))
+
+    m = Estimator(
+        n_components=n_components, init="custom", random_state=0, tol=1e-3, **solver
+    )
+    m.fit_transform(A, W=W_init, H=H_init)
+    m.transform(A)
+
+
+@pytest.mark.parametrize("solver", ("cd", "mu"))
+def test_nmf_inverse_transform(solver):
+    # Test that NMF.inverse_transform returns close values
+    random_state = np.random.RandomState(0)
+    A = np.abs(random_state.randn(6, 4))
+    m = NMF(
+        solver=solver,
+        n_components=4,
+        init="random",
+        random_state=0,
+        max_iter=1000,
+    )
+    ft = m.fit_transform(A)
+    A_new = m.inverse_transform(ft)
+    assert_array_almost_equal(A, A_new, decimal=2)
+
+
+# TODO(1.6): remove the warning filter
+@pytest.mark.filterwarnings("ignore:The default value of `n_components` will change")
+def test_mbnmf_inverse_transform():
+    # Test that MiniBatchNMF.transform followed by MiniBatchNMF.inverse_transform
+    # is close to the identity
+    rng = np.random.RandomState(0)
+    A = np.abs(rng.randn(6, 4))
+    nmf = MiniBatchNMF(
+        random_state=rng,
+        max_iter=500,
+        init="nndsvdar",
+        fresh_restarts=True,
+    )
+    ft = nmf.fit_transform(A)
+    A_new = nmf.inverse_transform(ft)
+    assert_allclose(A, A_new, rtol=1e-3, atol=1e-2)
+
+
+@pytest.mark.parametrize("Estimator", [NMF, MiniBatchNMF])
+def test_n_components_greater_n_features(Estimator):
+    # Smoke test for the case of more components than features.
+    rng = np.random.mtrand.RandomState(42)
+    A = np.abs(rng.randn(30, 10))
+    Estimator(n_components=15, random_state=0, tol=1e-2).fit(A)
+
+
+@pytest.mark.parametrize(
+    ["Estimator", "solver"],
+    [[NMF, {"solver": "cd"}], [NMF, {"solver": "mu"}], [MiniBatchNMF, {}]],
+)
+@pytest.mark.parametrize("sparse_container", CSC_CONTAINERS + CSR_CONTAINERS)
+@pytest.mark.parametrize("alpha_W", (0.0, 1.0))
+@pytest.mark.parametrize("alpha_H", (0.0, 1.0, "same"))
+def test_nmf_sparse_input(Estimator, solver, sparse_container, alpha_W, alpha_H):
+    # Test that sparse matrices are accepted as input
+    rng = np.random.mtrand.RandomState(42)
+    A = np.abs(rng.randn(10, 10))
+    A[:, 2 * np.arange(5)] = 0
+    A_sparse = sparse_container(A)
+
+    est1 = Estimator(
+        n_components=5,
+        init="random",
+        alpha_W=alpha_W,
+        alpha_H=alpha_H,
+        random_state=0,
+        tol=0,
+        max_iter=100,
+        **solver,
+    )
+    est2 = clone(est1)
+
+    W1 = est1.fit_transform(A)
+    W2 = est2.fit_transform(A_sparse)
+    H1 = est1.components_
+    H2 = est2.components_
+
+    assert_allclose(W1, W2)
+    assert_allclose(H1, H2)
+
+
+@pytest.mark.parametrize(
+    ["Estimator", "solver"],
+    [[NMF, {"solver": "cd"}], [NMF, {"solver": "mu"}], [MiniBatchNMF, {}]],
+)
+@pytest.mark.parametrize("csc_container", CSC_CONTAINERS)
+def test_nmf_sparse_transform(Estimator, solver, csc_container):
+    # Test that transform works on sparse data.  Issue #2124
+    rng = np.random.mtrand.RandomState(42)
+    A = np.abs(rng.randn(3, 2))
+    A[1, 1] = 0
+    A = csc_container(A)
+
+    model = Estimator(random_state=0, n_components=2, max_iter=400, **solver)
+    A_fit_tr = model.fit_transform(A)
+    A_tr = model.transform(A)
+    assert_allclose(A_fit_tr, A_tr, atol=1e-1)
+
+
+# TODO(1.6): remove the warning filter
+@pytest.mark.filterwarnings("ignore:The default value of `n_components` will change")
+@pytest.mark.parametrize("init", ["random", "nndsvd"])
+@pytest.mark.parametrize("solver", ("cd", "mu"))
+@pytest.mark.parametrize("alpha_W", (0.0, 1.0))
+@pytest.mark.parametrize("alpha_H", (0.0, 1.0, "same"))
+def test_non_negative_factorization_consistency(init, solver, alpha_W, alpha_H):
+    # Test that the function is called in the same way, either directly
+    # or through the NMF class
+    max_iter = 500
+    rng = np.random.mtrand.RandomState(42)
+    A = np.abs(rng.randn(10, 10))
+    A[:, 2 * np.arange(5)] = 0
+
+    W_nmf, H, _ = non_negative_factorization(
+        A,
+        init=init,
+        solver=solver,
+        max_iter=max_iter,
+        alpha_W=alpha_W,
+        alpha_H=alpha_H,
+        random_state=1,
+        tol=1e-2,
+    )
+    W_nmf_2, H, _ = non_negative_factorization(
+        A,
+        H=H,
+        update_H=False,
+        init=init,
+        solver=solver,
+        max_iter=max_iter,
+        alpha_W=alpha_W,
+        alpha_H=alpha_H,
+        random_state=1,
+        tol=1e-2,
+    )
+
+    model_class = NMF(
+        init=init,
+        solver=solver,
+        max_iter=max_iter,
+        alpha_W=alpha_W,
+        alpha_H=alpha_H,
+        random_state=1,
+        tol=1e-2,
+    )
+    W_cls = model_class.fit_transform(A)
+    W_cls_2 = model_class.transform(A)
+
+    assert_allclose(W_nmf, W_cls)
+    assert_allclose(W_nmf_2, W_cls_2)
+
+
+def test_non_negative_factorization_checking():
+    # Note that the validity of parameter types and range of possible values
+    # for scalar numerical or str parameters is already checked in the common
+    # tests. Here we only check for problems that cannot be captured by simple
+    # declarative constraints on the valid parameter values.
+
+    A = np.ones((2, 2))
+    # Test parameters checking in public function
+    nnmf = non_negative_factorization
+    msg = re.escape("Negative values in data passed to NMF (input H)")
+    with pytest.raises(ValueError, match=msg):
+        nnmf(A, A, -A, 2, init="custom")
+    msg = re.escape("Negative values in data passed to NMF (input W)")
+    with pytest.raises(ValueError, match=msg):
+        nnmf(A, -A, A, 2, init="custom")
+    msg = re.escape("Array passed to NMF (input H) is full of zeros")
+    with pytest.raises(ValueError, match=msg):
+        nnmf(A, A, 0 * A, 2, init="custom")
+
+
+def _beta_divergence_dense(X, W, H, beta):
+    """Compute the beta-divergence of X and W.H for dense array only.
+
+    Used as a reference for testing nmf._beta_divergence.
+    """
+    WH = np.dot(W, H)
+
+    if beta == 2:
+        return squared_norm(X - WH) / 2
+
+    WH_Xnonzero = WH[X != 0]
+    X_nonzero = X[X != 0]
+    np.maximum(WH_Xnonzero, 1e-9, out=WH_Xnonzero)
+
+    if beta == 1:
+        res = np.sum(X_nonzero * np.log(X_nonzero / WH_Xnonzero))
+        res += WH.sum() - X.sum()
+
+    elif beta == 0:
+        div = X_nonzero / WH_Xnonzero
+        res = np.sum(div) - X.size - np.sum(np.log(div))
+    else:
+        res = (X_nonzero**beta).sum()
+        res += (beta - 1) * (WH**beta).sum()
+        res -= beta * (X_nonzero * (WH_Xnonzero ** (beta - 1))).sum()
+        res /= beta * (beta - 1)
+
+    return res
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_beta_divergence(csr_container):
+    # Compare _beta_divergence with the reference _beta_divergence_dense
+    n_samples = 20
+    n_features = 10
+    n_components = 5
+    beta_losses = [0.0, 0.5, 1.0, 1.5, 2.0, 3.0]
+
+    # initialization
+    rng = np.random.mtrand.RandomState(42)
+    X = rng.randn(n_samples, n_features)
+    np.clip(X, 0, None, out=X)
+    X_csr = csr_container(X)
+    W, H = nmf._initialize_nmf(X, n_components, init="random", random_state=42)
+
+    for beta in beta_losses:
+        ref = _beta_divergence_dense(X, W, H, beta)
+        loss = nmf._beta_divergence(X, W, H, beta)
+        loss_csr = nmf._beta_divergence(X_csr, W, H, beta)
+
+        assert_almost_equal(ref, loss, decimal=7)
+        assert_almost_equal(ref, loss_csr, decimal=7)
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_special_sparse_dot(csr_container):
+    # Test the function that computes np.dot(W, H), only where X is non zero.
+    n_samples = 10
+    n_features = 5
+    n_components = 3
+    rng = np.random.mtrand.RandomState(42)
+    X = rng.randn(n_samples, n_features)
+    np.clip(X, 0, None, out=X)
+    X_csr = csr_container(X)
+
+    W = np.abs(rng.randn(n_samples, n_components))
+    H = np.abs(rng.randn(n_components, n_features))
+
+    WH_safe = nmf._special_sparse_dot(W, H, X_csr)
+    WH = nmf._special_sparse_dot(W, H, X)
+
+    # test that both results have same values, in X_csr nonzero elements
+    ii, jj = X_csr.nonzero()
+    WH_safe_data = np.asarray(WH_safe[ii, jj]).ravel()
+    assert_array_almost_equal(WH_safe_data, WH[ii, jj], decimal=10)
+
+    # test that WH_safe and X_csr have the same sparse structure
+    assert_array_equal(WH_safe.indices, X_csr.indices)
+    assert_array_equal(WH_safe.indptr, X_csr.indptr)
+    assert_array_equal(WH_safe.shape, X_csr.shape)
+
+
+@ignore_warnings(category=ConvergenceWarning)
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_nmf_multiplicative_update_sparse(csr_container):
+    # Compare sparse and dense input in multiplicative update NMF
+    # Also test continuity of the results with respect to beta_loss parameter
+    n_samples = 20
+    n_features = 10
+    n_components = 5
+    alpha = 0.1
+    l1_ratio = 0.5
+    n_iter = 20
+
+    # initialization
+    rng = np.random.mtrand.RandomState(1337)
+    X = rng.randn(n_samples, n_features)
+    X = np.abs(X)
+    X_csr = csr_container(X)
+    W0, H0 = nmf._initialize_nmf(X, n_components, init="random", random_state=42)
+
+    for beta_loss in (-1.2, 0, 0.2, 1.0, 2.0, 2.5):
+        # Reference with dense array X
+        W, H = W0.copy(), H0.copy()
+        W1, H1, _ = non_negative_factorization(
+            X,
+            W,
+            H,
+            n_components,
+            init="custom",
+            update_H=True,
+            solver="mu",
+            beta_loss=beta_loss,
+            max_iter=n_iter,
+            alpha_W=alpha,
+            l1_ratio=l1_ratio,
+            random_state=42,
+        )
+
+        # Compare with sparse X
+        W, H = W0.copy(), H0.copy()
+        W2, H2, _ = non_negative_factorization(
+            X_csr,
+            W,
+            H,
+            n_components,
+            init="custom",
+            update_H=True,
+            solver="mu",
+            beta_loss=beta_loss,
+            max_iter=n_iter,
+            alpha_W=alpha,
+            l1_ratio=l1_ratio,
+            random_state=42,
+        )
+
+        assert_allclose(W1, W2, atol=1e-7)
+        assert_allclose(H1, H2, atol=1e-7)
+
+        # Compare with almost same beta_loss, since some values have a specific
+        # behavior, but the results should be continuous w.r.t beta_loss
+        beta_loss -= 1.0e-5
+        W, H = W0.copy(), H0.copy()
+        W3, H3, _ = non_negative_factorization(
+            X_csr,
+            W,
+            H,
+            n_components,
+            init="custom",
+            update_H=True,
+            solver="mu",
+            beta_loss=beta_loss,
+            max_iter=n_iter,
+            alpha_W=alpha,
+            l1_ratio=l1_ratio,
+            random_state=42,
+        )
+
+        assert_allclose(W1, W3, atol=1e-4)
+        assert_allclose(H1, H3, atol=1e-4)
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_nmf_negative_beta_loss(csr_container):
+    # Test that an error is raised if beta_loss < 0 and X contains zeros.
+    # Test that the output has not NaN values when the input contains zeros.
+    n_samples = 6
+    n_features = 5
+    n_components = 3
+
+    rng = np.random.mtrand.RandomState(42)
+    X = rng.randn(n_samples, n_features)
+    np.clip(X, 0, None, out=X)
+    X_csr = csr_container(X)
+
+    def _assert_nmf_no_nan(X, beta_loss):
+        W, H, _ = non_negative_factorization(
+            X,
+            init="random",
+            n_components=n_components,
+            solver="mu",
+            beta_loss=beta_loss,
+            random_state=0,
+            max_iter=1000,
+        )
+        assert not np.any(np.isnan(W))
+        assert not np.any(np.isnan(H))
+
+    msg = "When beta_loss <= 0 and X contains zeros, the solver may diverge."
+    for beta_loss in (-0.6, 0.0):
+        with pytest.raises(ValueError, match=msg):
+            _assert_nmf_no_nan(X, beta_loss)
+        _assert_nmf_no_nan(X + 1e-9, beta_loss)
+
+    for beta_loss in (0.2, 1.0, 1.2, 2.0, 2.5):
+        _assert_nmf_no_nan(X, beta_loss)
+        _assert_nmf_no_nan(X_csr, beta_loss)
+
+
+# TODO(1.6): remove the warning filter
+@pytest.mark.filterwarnings("ignore:The default value of `n_components` will change")
+@pytest.mark.parametrize("beta_loss", [-0.5, 0.0])
+def test_minibatch_nmf_negative_beta_loss(beta_loss):
+    """Check that an error is raised if beta_loss < 0 and X contains zeros."""
+    rng = np.random.RandomState(0)
+    X = rng.normal(size=(6, 5))
+    X[X < 0] = 0
+
+    nmf = MiniBatchNMF(beta_loss=beta_loss, random_state=0)
+
+    msg = "When beta_loss <= 0 and X contains zeros, the solver may diverge."
+    with pytest.raises(ValueError, match=msg):
+        nmf.fit(X)
+
+
+@pytest.mark.parametrize(
+    ["Estimator", "solver"],
+    [[NMF, {"solver": "cd"}], [NMF, {"solver": "mu"}], [MiniBatchNMF, {}]],
+)
+def test_nmf_regularization(Estimator, solver):
+    # Test the effect of L1 and L2 regularizations
+    n_samples = 6
+    n_features = 5
+    n_components = 3
+    rng = np.random.mtrand.RandomState(42)
+    X = np.abs(rng.randn(n_samples, n_features))
+
+    # L1 regularization should increase the number of zeros
+    l1_ratio = 1.0
+    regul = Estimator(
+        n_components=n_components,
+        alpha_W=0.5,
+        l1_ratio=l1_ratio,
+        random_state=42,
+        **solver,
+    )
+    model = Estimator(
+        n_components=n_components,
+        alpha_W=0.0,
+        l1_ratio=l1_ratio,
+        random_state=42,
+        **solver,
+    )
+
+    W_regul = regul.fit_transform(X)
+    W_model = model.fit_transform(X)
+
+    H_regul = regul.components_
+    H_model = model.components_
+
+    eps = np.finfo(np.float64).eps
+    W_regul_n_zeros = W_regul[W_regul <= eps].size
+    W_model_n_zeros = W_model[W_model <= eps].size
+    H_regul_n_zeros = H_regul[H_regul <= eps].size
+    H_model_n_zeros = H_model[H_model <= eps].size
+
+    assert W_regul_n_zeros > W_model_n_zeros
+    assert H_regul_n_zeros > H_model_n_zeros
+
+    # L2 regularization should decrease the sum of the squared norm
+    # of the matrices W and H
+    l1_ratio = 0.0
+    regul = Estimator(
+        n_components=n_components,
+        alpha_W=0.5,
+        l1_ratio=l1_ratio,
+        random_state=42,
+        **solver,
+    )
+    model = Estimator(
+        n_components=n_components,
+        alpha_W=0.0,
+        l1_ratio=l1_ratio,
+        random_state=42,
+        **solver,
+    )
+
+    W_regul = regul.fit_transform(X)
+    W_model = model.fit_transform(X)
+
+    H_regul = regul.components_
+    H_model = model.components_
+
+    assert (linalg.norm(W_model)) ** 2.0 + (linalg.norm(H_model)) ** 2.0 > (
+        linalg.norm(W_regul)
+    ) ** 2.0 + (linalg.norm(H_regul)) ** 2.0
+
+
+@ignore_warnings(category=ConvergenceWarning)
+@pytest.mark.parametrize("solver", ("cd", "mu"))
+def test_nmf_decreasing(solver):
+    # test that the objective function is decreasing at each iteration
+    n_samples = 20
+    n_features = 15
+    n_components = 10
+    alpha = 0.1
+    l1_ratio = 0.5
+    tol = 0.0
+
+    # initialization
+    rng = np.random.mtrand.RandomState(42)
+    X = rng.randn(n_samples, n_features)
+    np.abs(X, X)
+    W0, H0 = nmf._initialize_nmf(X, n_components, init="random", random_state=42)
+
+    for beta_loss in (-1.2, 0, 0.2, 1.0, 2.0, 2.5):
+        if solver != "mu" and beta_loss != 2:
+            # not implemented
+            continue
+        W, H = W0.copy(), H0.copy()
+        previous_loss = None
+        for _ in range(30):
+            # one more iteration starting from the previous results
+            W, H, _ = non_negative_factorization(
+                X,
+                W,
+                H,
+                beta_loss=beta_loss,
+                init="custom",
+                n_components=n_components,
+                max_iter=1,
+                alpha_W=alpha,
+                solver=solver,
+                tol=tol,
+                l1_ratio=l1_ratio,
+                verbose=0,
+                random_state=0,
+                update_H=True,
+            )
+
+            loss = (
+                nmf._beta_divergence(X, W, H, beta_loss)
+                + alpha * l1_ratio * n_features * W.sum()
+                + alpha * l1_ratio * n_samples * H.sum()
+                + alpha * (1 - l1_ratio) * n_features * (W**2).sum()
+                + alpha * (1 - l1_ratio) * n_samples * (H**2).sum()
+            )
+            if previous_loss is not None:
+                assert previous_loss > loss
+            previous_loss = loss
+
+
+def test_nmf_underflow():
+    # Regression test for an underflow issue in _beta_divergence
+    rng = np.random.RandomState(0)
+    n_samples, n_features, n_components = 10, 2, 2
+    X = np.abs(rng.randn(n_samples, n_features)) * 10
+    W = np.abs(rng.randn(n_samples, n_components)) * 10
+    H = np.abs(rng.randn(n_components, n_features))
+
+    X[0, 0] = 0
+    ref = nmf._beta_divergence(X, W, H, beta=1.0)
+    X[0, 0] = 1e-323
+    res = nmf._beta_divergence(X, W, H, beta=1.0)
+    assert_almost_equal(res, ref)
+
+
+# TODO(1.6): remove the warning filter
+@pytest.mark.filterwarnings("ignore:The default value of `n_components` will change")
+@pytest.mark.parametrize(
+    "dtype_in, dtype_out",
+    [
+        (np.float32, np.float32),
+        (np.float64, np.float64),
+        (np.int32, np.float64),
+        (np.int64, np.float64),
+    ],
+)
+@pytest.mark.parametrize(
+    ["Estimator", "solver"],
+    [[NMF, {"solver": "cd"}], [NMF, {"solver": "mu"}], [MiniBatchNMF, {}]],
+)
+def test_nmf_dtype_match(Estimator, solver, dtype_in, dtype_out):
+    # Check that NMF preserves dtype (float32 and float64)
+    X = np.random.RandomState(0).randn(20, 15).astype(dtype_in, copy=False)
+    np.abs(X, out=X)
+
+    nmf = Estimator(
+        alpha_W=1.0,
+        alpha_H=1.0,
+        tol=1e-2,
+        random_state=0,
+        **solver,
+    )
+
+    assert nmf.fit(X).transform(X).dtype == dtype_out
+    assert nmf.fit_transform(X).dtype == dtype_out
+    assert nmf.components_.dtype == dtype_out
+
+
+# TODO(1.6): remove the warning filter
+@pytest.mark.filterwarnings("ignore:The default value of `n_components` will change")
+@pytest.mark.parametrize(
+    ["Estimator", "solver"],
+    [[NMF, {"solver": "cd"}], [NMF, {"solver": "mu"}], [MiniBatchNMF, {}]],
+)
+def test_nmf_float32_float64_consistency(Estimator, solver):
+    # Check that the result of NMF is the same between float32 and float64
+    X = np.random.RandomState(0).randn(50, 7)
+    np.abs(X, out=X)
+    nmf32 = Estimator(random_state=0, tol=1e-3, **solver)
+    W32 = nmf32.fit_transform(X.astype(np.float32))
+    nmf64 = Estimator(random_state=0, tol=1e-3, **solver)
+    W64 = nmf64.fit_transform(X)
+
+    assert_allclose(W32, W64, atol=1e-5)
+
+
+# TODO(1.6): remove the warning filter
+@pytest.mark.filterwarnings("ignore:The default value of `n_components` will change")
+@pytest.mark.parametrize("Estimator", [NMF, MiniBatchNMF])
+def test_nmf_custom_init_dtype_error(Estimator):
+    # Check that an error is raise if custom H and/or W don't have the same
+    # dtype as X.
+    rng = np.random.RandomState(0)
+    X = rng.random_sample((20, 15))
+    H = rng.random_sample((15, 15)).astype(np.float32)
+    W = rng.random_sample((20, 15))
+
+    with pytest.raises(TypeError, match="should have the same dtype as X"):
+        Estimator(init="custom").fit(X, H=H, W=W)
+
+    with pytest.raises(TypeError, match="should have the same dtype as X"):
+        non_negative_factorization(X, H=H, update_H=False)
+
+
+@pytest.mark.parametrize("beta_loss", [-0.5, 0, 0.5, 1, 1.5, 2, 2.5])
+def test_nmf_minibatchnmf_equivalence(beta_loss):
+    # Test that MiniBatchNMF is equivalent to NMF when batch_size = n_samples and
+    # forget_factor 0.0 (stopping criterion put aside)
+    rng = np.random.mtrand.RandomState(42)
+    X = np.abs(rng.randn(48, 5))
+
+    nmf = NMF(
+        n_components=5,
+        beta_loss=beta_loss,
+        solver="mu",
+        random_state=0,
+        tol=0,
+    )
+    mbnmf = MiniBatchNMF(
+        n_components=5,
+        beta_loss=beta_loss,
+        random_state=0,
+        tol=0,
+        max_no_improvement=None,
+        batch_size=X.shape[0],
+        forget_factor=0.0,
+    )
+    W = nmf.fit_transform(X)
+    mbW = mbnmf.fit_transform(X)
+    assert_allclose(W, mbW)
+
+
+def test_minibatch_nmf_partial_fit():
+    # Check fit / partial_fit equivalence. Applicable only with fresh restarts.
+    rng = np.random.mtrand.RandomState(42)
+    X = np.abs(rng.randn(100, 5))
+
+    n_components = 5
+    batch_size = 10
+    max_iter = 2
+
+    mbnmf1 = MiniBatchNMF(
+        n_components=n_components,
+        init="custom",
+        random_state=0,
+        max_iter=max_iter,
+        batch_size=batch_size,
+        tol=0,
+        max_no_improvement=None,
+        fresh_restarts=False,
+    )
+    mbnmf2 = MiniBatchNMF(n_components=n_components, init="custom", random_state=0)
+
+    # Force the same init of H (W is recomputed anyway) to be able to compare results.
+    W, H = nmf._initialize_nmf(
+        X, n_components=n_components, init="random", random_state=0
+    )
+
+    mbnmf1.fit(X, W=W, H=H)
+    for i in range(max_iter):
+        for j in range(batch_size):
+            mbnmf2.partial_fit(X[j : j + batch_size], W=W[:batch_size], H=H)
+
+    assert mbnmf1.n_steps_ == mbnmf2.n_steps_
+    assert_allclose(mbnmf1.components_, mbnmf2.components_)
+
+
+def test_feature_names_out():
+    """Check feature names out for NMF."""
+    random_state = np.random.RandomState(0)
+    X = np.abs(random_state.randn(10, 4))
+    nmf = NMF(n_components=3).fit(X)
+
+    names = nmf.get_feature_names_out()
+    assert_array_equal([f"nmf{i}" for i in range(3)], names)
+
+
+# TODO(1.6): remove the warning filter
+@pytest.mark.filterwarnings("ignore:The default value of `n_components` will change")
+def test_minibatch_nmf_verbose():
+    # Check verbose mode of MiniBatchNMF for better coverage.
+    A = np.random.RandomState(0).random_sample((100, 10))
+    nmf = MiniBatchNMF(tol=1e-2, random_state=0, verbose=1)
+    old_stdout = sys.stdout
+    sys.stdout = StringIO()
+    try:
+        nmf.fit(A)
+    finally:
+        sys.stdout = old_stdout
+
+
+# TODO(1.5): remove this test
+def test_NMF_inverse_transform_W_deprecation():
+    rng = np.random.mtrand.RandomState(42)
+    A = np.abs(rng.randn(6, 5))
+    est = NMF(
+        n_components=3,
+        init="random",
+        random_state=0,
+        tol=1e-6,
+    )
+    Xt = est.fit_transform(A)
+
+    with pytest.raises(TypeError, match="Missing required positional argument"):
+        est.inverse_transform()
+
+    with pytest.raises(ValueError, match="Please provide only"):
+        est.inverse_transform(Xt=Xt, W=Xt)
+
+    with warnings.catch_warnings(record=True):
+        warnings.simplefilter("error")
+        est.inverse_transform(Xt)
+
+    with pytest.warns(FutureWarning, match="Input argument `W` was renamed to `Xt`"):
+        est.inverse_transform(W=Xt)
+
+
+@pytest.mark.parametrize("Estimator", [NMF, MiniBatchNMF])
+def test_nmf_n_components_auto(Estimator):
+    # Check that n_components is correctly inferred
+    # from the provided custom initialization.
+    rng = np.random.RandomState(0)
+    X = rng.random_sample((6, 5))
+    W = rng.random_sample((6, 2))
+    H = rng.random_sample((2, 5))
+    est = Estimator(
+        n_components="auto",
+        init="custom",
+        random_state=0,
+        tol=1e-6,
+    )
+    est.fit_transform(X, W=W, H=H)
+    assert est._n_components == H.shape[0]
+
+
+def test_nmf_non_negative_factorization_n_components_auto():
+    # Check that n_components is correctly inferred from the provided
+    # custom initialization.
+    rng = np.random.RandomState(0)
+    X = rng.random_sample((6, 5))
+    W_init = rng.random_sample((6, 2))
+    H_init = rng.random_sample((2, 5))
+    W, H, _ = non_negative_factorization(
+        X, W=W_init, H=H_init, init="custom", n_components="auto"
+    )
+    assert H.shape == H_init.shape
+    assert W.shape == W_init.shape
+
+
+# TODO(1.6): remove
+def test_nmf_n_components_default_value_warning():
+    rng = np.random.RandomState(0)
+    X = rng.random_sample((6, 5))
+    H = rng.random_sample((2, 5))
+    with pytest.warns(
+        FutureWarning, match="The default value of `n_components` will change from"
+    ):
+        non_negative_factorization(X, H=H)
+
+
+def test_nmf_n_components_auto_no_h_update():
+    # Tests that non_negative_factorization does not fail when setting
+    # n_components="auto" also tests that the inferred n_component
+    # value is the right one.
+    rng = np.random.RandomState(0)
+    X = rng.random_sample((6, 5))
+    H_true = rng.random_sample((2, 5))
+    W, H, _ = non_negative_factorization(
+        X, H=H_true, n_components="auto", update_H=False
+    )  # should not fail
+    assert_allclose(H, H_true)
+    assert W.shape == (X.shape[0], H_true.shape[0])
+
+
+def test_nmf_w_h_not_used_warning():
+    # Check that warnings are raised if user provided W and H are not used
+    # and initialization overrides value of W or H
+    rng = np.random.RandomState(0)
+    X = rng.random_sample((6, 5))
+    W_init = rng.random_sample((6, 2))
+    H_init = rng.random_sample((2, 5))
+    with pytest.warns(
+        RuntimeWarning,
+        match="When init!='custom', provided W or H are ignored",
+    ):
+        non_negative_factorization(X, H=H_init, update_H=True, n_components="auto")
+
+    with pytest.warns(
+        RuntimeWarning,
+        match="When init!='custom', provided W or H are ignored",
+    ):
+        non_negative_factorization(
+            X, W=W_init, H=H_init, update_H=True, n_components="auto"
+        )
+
+    with pytest.warns(
+        RuntimeWarning, match="When update_H=False, the provided initial W is not used."
+    ):
+        # When update_H is False, W is ignored regardless of init
+        # TODO: use the provided W when init="custom".
+        non_negative_factorization(
+            X, W=W_init, H=H_init, update_H=False, n_components="auto"
+        )
+
+
+def test_nmf_custom_init_shape_error():
+    # Check that an informative error is raised when custom initialization does not
+    # have the right shape
+    rng = np.random.RandomState(0)
+    X = rng.random_sample((6, 5))
+    H = rng.random_sample((2, 5))
+    nmf = NMF(n_components=2, init="custom", random_state=0)
+
+    with pytest.raises(ValueError, match="Array with wrong first dimension passed"):
+        nmf.fit(X, H=H, W=rng.random_sample((5, 2)))
+
+    with pytest.raises(ValueError, match="Array with wrong second dimension passed"):
+        nmf.fit(X, H=H, W=rng.random_sample((6, 3)))

venv/lib/python3.10/site-packages/sklearn/decomposition/tests/test_online_lda.py

@@ -0,0 +1,477 @@
+import sys
+from io import StringIO
+
+import numpy as np
+import pytest
+from numpy.testing import assert_array_equal
+from scipy.linalg import block_diag
+from scipy.special import psi
+
+from sklearn.decomposition import LatentDirichletAllocation
+from sklearn.decomposition._online_lda_fast import (
+    _dirichlet_expectation_1d,
+    _dirichlet_expectation_2d,
+)
+from sklearn.exceptions import NotFittedError
+from sklearn.utils._testing import (
+    assert_allclose,
+    assert_almost_equal,
+    assert_array_almost_equal,
+    if_safe_multiprocessing_with_blas,
+)
+from sklearn.utils.fixes import CSR_CONTAINERS
+
+
+def _build_sparse_array(csr_container):
+    # Create 3 topics and each topic has 3 distinct words.
+    # (Each word only belongs to a single topic.)
+    n_components = 3
+    block = np.full((3, 3), n_components, dtype=int)
+    blocks = [block] * n_components
+    X = block_diag(*blocks)
+    X = csr_container(X)
+    return (n_components, X)
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_lda_default_prior_params(csr_container):
+    # default prior parameter should be `1 / topics`
+    # and verbose params should not affect result
+    n_components, X = _build_sparse_array(csr_container)
+    prior = 1.0 / n_components
+    lda_1 = LatentDirichletAllocation(
+        n_components=n_components,
+        doc_topic_prior=prior,
+        topic_word_prior=prior,
+        random_state=0,
+    )
+    lda_2 = LatentDirichletAllocation(n_components=n_components, random_state=0)
+    topic_distr_1 = lda_1.fit_transform(X)
+    topic_distr_2 = lda_2.fit_transform(X)
+    assert_almost_equal(topic_distr_1, topic_distr_2)
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_lda_fit_batch(csr_container):
+    # Test LDA batch learning_offset (`fit` method with 'batch' learning)
+    rng = np.random.RandomState(0)
+    n_components, X = _build_sparse_array(csr_container)
+    lda = LatentDirichletAllocation(
+        n_components=n_components,
+        evaluate_every=1,
+        learning_method="batch",
+        random_state=rng,
+    )
+    lda.fit(X)
+
+    correct_idx_grps = [(0, 1, 2), (3, 4, 5), (6, 7, 8)]
+    for component in lda.components_:
+        # Find top 3 words in each LDA component
+        top_idx = set(component.argsort()[-3:][::-1])
+        assert tuple(sorted(top_idx)) in correct_idx_grps
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_lda_fit_online(csr_container):
+    # Test LDA online learning (`fit` method with 'online' learning)
+    rng = np.random.RandomState(0)
+    n_components, X = _build_sparse_array(csr_container)
+    lda = LatentDirichletAllocation(
+        n_components=n_components,
+        learning_offset=10.0,
+        evaluate_every=1,
+        learning_method="online",
+        random_state=rng,
+    )
+    lda.fit(X)
+
+    correct_idx_grps = [(0, 1, 2), (3, 4, 5), (6, 7, 8)]
+    for component in lda.components_:
+        # Find top 3 words in each LDA component
+        top_idx = set(component.argsort()[-3:][::-1])
+        assert tuple(sorted(top_idx)) in correct_idx_grps
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_lda_partial_fit(csr_container):
+    # Test LDA online learning (`partial_fit` method)
+    # (same as test_lda_batch)
+    rng = np.random.RandomState(0)
+    n_components, X = _build_sparse_array(csr_container)
+    lda = LatentDirichletAllocation(
+        n_components=n_components,
+        learning_offset=10.0,
+        total_samples=100,
+        random_state=rng,
+    )
+    for i in range(3):
+        lda.partial_fit(X)
+
+    correct_idx_grps = [(0, 1, 2), (3, 4, 5), (6, 7, 8)]
+    for c in lda.components_:
+        top_idx = set(c.argsort()[-3:][::-1])
+        assert tuple(sorted(top_idx)) in correct_idx_grps
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_lda_dense_input(csr_container):
+    # Test LDA with dense input.
+    rng = np.random.RandomState(0)
+    n_components, X = _build_sparse_array(csr_container)
+    lda = LatentDirichletAllocation(
+        n_components=n_components, learning_method="batch", random_state=rng
+    )
+    lda.fit(X.toarray())
+
+    correct_idx_grps = [(0, 1, 2), (3, 4, 5), (6, 7, 8)]
+    for component in lda.components_:
+        # Find top 3 words in each LDA component
+        top_idx = set(component.argsort()[-3:][::-1])
+        assert tuple(sorted(top_idx)) in correct_idx_grps
+
+
+def test_lda_transform():
+    # Test LDA transform.
+    # Transform result cannot be negative and should be normalized
+    rng = np.random.RandomState(0)
+    X = rng.randint(5, size=(20, 10))
+    n_components = 3
+    lda = LatentDirichletAllocation(n_components=n_components, random_state=rng)
+    X_trans = lda.fit_transform(X)
+    assert (X_trans > 0.0).any()
+    assert_array_almost_equal(np.sum(X_trans, axis=1), np.ones(X_trans.shape[0]))
+
+
+@pytest.mark.parametrize("method", ("online", "batch"))
+def test_lda_fit_transform(method):
+    # Test LDA fit_transform & transform
+    # fit_transform and transform result should be the same
+    rng = np.random.RandomState(0)
+    X = rng.randint(10, size=(50, 20))
+    lda = LatentDirichletAllocation(
+        n_components=5, learning_method=method, random_state=rng
+    )
+    X_fit = lda.fit_transform(X)
+    X_trans = lda.transform(X)
+    assert_array_almost_equal(X_fit, X_trans, 4)
+
+
+def test_lda_negative_input():
+    # test pass dense matrix with sparse negative input.
+    X = np.full((5, 10), -1.0)
+    lda = LatentDirichletAllocation()
+    regex = r"^Negative values in data passed"
+    with pytest.raises(ValueError, match=regex):
+        lda.fit(X)
+
+
+def test_lda_no_component_error():
+    # test `perplexity` before `fit`
+    rng = np.random.RandomState(0)
+    X = rng.randint(4, size=(20, 10))
+    lda = LatentDirichletAllocation()
+    regex = (
+        "This LatentDirichletAllocation instance is not fitted yet. "
+        "Call 'fit' with appropriate arguments before using this "
+        "estimator."
+    )
+    with pytest.raises(NotFittedError, match=regex):
+        lda.perplexity(X)
+
+
+@if_safe_multiprocessing_with_blas
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+@pytest.mark.parametrize("method", ("online", "batch"))
+def test_lda_multi_jobs(method, csr_container):
+    n_components, X = _build_sparse_array(csr_container)
+    # Test LDA batch training with multi CPU
+    rng = np.random.RandomState(0)
+    lda = LatentDirichletAllocation(
+        n_components=n_components,
+        n_jobs=2,
+        learning_method=method,
+        evaluate_every=1,
+        random_state=rng,
+    )
+    lda.fit(X)
+
+    correct_idx_grps = [(0, 1, 2), (3, 4, 5), (6, 7, 8)]
+    for c in lda.components_:
+        top_idx = set(c.argsort()[-3:][::-1])
+        assert tuple(sorted(top_idx)) in correct_idx_grps
+
+
+@if_safe_multiprocessing_with_blas
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_lda_partial_fit_multi_jobs(csr_container):
+    # Test LDA online training with multi CPU
+    rng = np.random.RandomState(0)
+    n_components, X = _build_sparse_array(csr_container)
+    lda = LatentDirichletAllocation(
+        n_components=n_components,
+        n_jobs=2,
+        learning_offset=5.0,
+        total_samples=30,
+        random_state=rng,
+    )
+    for i in range(2):
+        lda.partial_fit(X)
+
+    correct_idx_grps = [(0, 1, 2), (3, 4, 5), (6, 7, 8)]
+    for c in lda.components_:
+        top_idx = set(c.argsort()[-3:][::-1])
+        assert tuple(sorted(top_idx)) in correct_idx_grps
+
+
+def test_lda_preplexity_mismatch():
+    # test dimension mismatch in `perplexity` method
+    rng = np.random.RandomState(0)
+    n_components = rng.randint(3, 6)
+    n_samples = rng.randint(6, 10)
+    X = np.random.randint(4, size=(n_samples, 10))
+    lda = LatentDirichletAllocation(
+        n_components=n_components,
+        learning_offset=5.0,
+        total_samples=20,
+        random_state=rng,
+    )
+    lda.fit(X)
+    # invalid samples
+    invalid_n_samples = rng.randint(4, size=(n_samples + 1, n_components))
+    with pytest.raises(ValueError, match=r"Number of samples"):
+        lda._perplexity_precomp_distr(X, invalid_n_samples)
+    # invalid topic number
+    invalid_n_components = rng.randint(4, size=(n_samples, n_components + 1))
+    with pytest.raises(ValueError, match=r"Number of topics"):
+        lda._perplexity_precomp_distr(X, invalid_n_components)
+
+
+@pytest.mark.parametrize("method", ("online", "batch"))
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_lda_perplexity(method, csr_container):
+    # Test LDA perplexity for batch training
+    # perplexity should be lower after each iteration
+    n_components, X = _build_sparse_array(csr_container)
+    lda_1 = LatentDirichletAllocation(
+        n_components=n_components,
+        max_iter=1,
+        learning_method=method,
+        total_samples=100,
+        random_state=0,
+    )
+    lda_2 = LatentDirichletAllocation(
+        n_components=n_components,
+        max_iter=10,
+        learning_method=method,
+        total_samples=100,
+        random_state=0,
+    )
+    lda_1.fit(X)
+    perp_1 = lda_1.perplexity(X, sub_sampling=False)
+
+    lda_2.fit(X)
+    perp_2 = lda_2.perplexity(X, sub_sampling=False)
+    assert perp_1 >= perp_2
+
+    perp_1_subsampling = lda_1.perplexity(X, sub_sampling=True)
+    perp_2_subsampling = lda_2.perplexity(X, sub_sampling=True)
+    assert perp_1_subsampling >= perp_2_subsampling
+
+
+@pytest.mark.parametrize("method", ("online", "batch"))
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_lda_score(method, csr_container):
+    # Test LDA score for batch training
+    # score should be higher after each iteration
+    n_components, X = _build_sparse_array(csr_container)
+    lda_1 = LatentDirichletAllocation(
+        n_components=n_components,
+        max_iter=1,
+        learning_method=method,
+        total_samples=100,
+        random_state=0,
+    )
+    lda_2 = LatentDirichletAllocation(
+        n_components=n_components,
+        max_iter=10,
+        learning_method=method,
+        total_samples=100,
+        random_state=0,
+    )
+    lda_1.fit_transform(X)
+    score_1 = lda_1.score(X)
+
+    lda_2.fit_transform(X)
+    score_2 = lda_2.score(X)
+    assert score_2 >= score_1
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_perplexity_input_format(csr_container):
+    # Test LDA perplexity for sparse and dense input
+    # score should be the same for both dense and sparse input
+    n_components, X = _build_sparse_array(csr_container)
+    lda = LatentDirichletAllocation(
+        n_components=n_components,
+        max_iter=1,
+        learning_method="batch",
+        total_samples=100,
+        random_state=0,
+    )
+    lda.fit(X)
+    perp_1 = lda.perplexity(X)
+    perp_2 = lda.perplexity(X.toarray())
+    assert_almost_equal(perp_1, perp_2)
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_lda_score_perplexity(csr_container):
+    # Test the relationship between LDA score and perplexity
+    n_components, X = _build_sparse_array(csr_container)
+    lda = LatentDirichletAllocation(
+        n_components=n_components, max_iter=10, random_state=0
+    )
+    lda.fit(X)
+    perplexity_1 = lda.perplexity(X, sub_sampling=False)
+
+    score = lda.score(X)
+    perplexity_2 = np.exp(-1.0 * (score / np.sum(X.data)))
+    assert_almost_equal(perplexity_1, perplexity_2)
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_lda_fit_perplexity(csr_container):
+    # Test that the perplexity computed during fit is consistent with what is
+    # returned by the perplexity method
+    n_components, X = _build_sparse_array(csr_container)
+    lda = LatentDirichletAllocation(
+        n_components=n_components,
+        max_iter=1,
+        learning_method="batch",
+        random_state=0,
+        evaluate_every=1,
+    )
+    lda.fit(X)
+
+    # Perplexity computed at end of fit method
+    perplexity1 = lda.bound_
+
+    # Result of perplexity method on the train set
+    perplexity2 = lda.perplexity(X)
+
+    assert_almost_equal(perplexity1, perplexity2)
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_lda_empty_docs(csr_container):
+    """Test LDA on empty document (all-zero rows)."""
+    Z = np.zeros((5, 4))
+    for X in [Z, csr_container(Z)]:
+        lda = LatentDirichletAllocation(max_iter=750).fit(X)
+        assert_almost_equal(
+            lda.components_.sum(axis=0), np.ones(lda.components_.shape[1])
+        )
+
+
+def test_dirichlet_expectation():
+    """Test Cython version of Dirichlet expectation calculation."""
+    x = np.logspace(-100, 10, 10000)
+    expectation = np.empty_like(x)
+    _dirichlet_expectation_1d(x, 0, expectation)
+    assert_allclose(expectation, np.exp(psi(x) - psi(np.sum(x))), atol=1e-19)
+
+    x = x.reshape(100, 100)
+    assert_allclose(
+        _dirichlet_expectation_2d(x),
+        psi(x) - psi(np.sum(x, axis=1)[:, np.newaxis]),
+        rtol=1e-11,
+        atol=3e-9,
+    )
+
+
+def check_verbosity(
+    verbose, evaluate_every, expected_lines, expected_perplexities, csr_container
+):
+    n_components, X = _build_sparse_array(csr_container)
+    lda = LatentDirichletAllocation(
+        n_components=n_components,
+        max_iter=3,
+        learning_method="batch",
+        verbose=verbose,
+        evaluate_every=evaluate_every,
+        random_state=0,
+    )
+    out = StringIO()
+    old_out, sys.stdout = sys.stdout, out
+    try:
+        lda.fit(X)
+    finally:
+        sys.stdout = old_out
+
+    n_lines = out.getvalue().count("\n")
+    n_perplexity = out.getvalue().count("perplexity")
+    assert expected_lines == n_lines
+    assert expected_perplexities == n_perplexity
+
+
+@pytest.mark.parametrize(
+    "verbose,evaluate_every,expected_lines,expected_perplexities",
+    [
+        (False, 1, 0, 0),
+        (False, 0, 0, 0),
+        (True, 0, 3, 0),
+        (True, 1, 3, 3),
+        (True, 2, 3, 1),
+    ],
+)
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_verbosity(
+    verbose, evaluate_every, expected_lines, expected_perplexities, csr_container
+):
+    check_verbosity(
+        verbose, evaluate_every, expected_lines, expected_perplexities, csr_container
+    )
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_lda_feature_names_out(csr_container):
+    """Check feature names out for LatentDirichletAllocation."""
+    n_components, X = _build_sparse_array(csr_container)
+    lda = LatentDirichletAllocation(n_components=n_components).fit(X)
+
+    names = lda.get_feature_names_out()
+    assert_array_equal(
+        [f"latentdirichletallocation{i}" for i in range(n_components)], names
+    )
+
+
+@pytest.mark.parametrize("learning_method", ("batch", "online"))
+def test_lda_dtype_match(learning_method, global_dtype):
+    """Check data type preservation of fitted attributes."""
+    rng = np.random.RandomState(0)
+    X = rng.uniform(size=(20, 10)).astype(global_dtype, copy=False)
+
+    lda = LatentDirichletAllocation(
+        n_components=5, random_state=0, learning_method=learning_method
+    )
+    lda.fit(X)
+    assert lda.components_.dtype == global_dtype
+    assert lda.exp_dirichlet_component_.dtype == global_dtype
+
+
+@pytest.mark.parametrize("learning_method", ("batch", "online"))
+def test_lda_numerical_consistency(learning_method, global_random_seed):
+    """Check numerical consistency between np.float32 and np.float64."""
+    rng = np.random.RandomState(global_random_seed)
+    X64 = rng.uniform(size=(20, 10))
+    X32 = X64.astype(np.float32)
+
+    lda_64 = LatentDirichletAllocation(
+        n_components=5, random_state=global_random_seed, learning_method=learning_method
+    ).fit(X64)
+    lda_32 = LatentDirichletAllocation(
+        n_components=5, random_state=global_random_seed, learning_method=learning_method
+    ).fit(X32)
+
+    assert_allclose(lda_32.components_, lda_64.components_)
+    assert_allclose(lda_32.transform(X32), lda_64.transform(X64))

venv/lib/python3.10/site-packages/sklearn/decomposition/tests/test_pca.py

@@ -0,0 +1,987 @@
+import re
+import warnings
+
+import numpy as np
+import pytest
+import scipy as sp
+from numpy.testing import assert_array_equal
+
+from sklearn import config_context, datasets
+from sklearn.base import clone
+from sklearn.datasets import load_iris, make_classification
+from sklearn.decomposition import PCA
+from sklearn.decomposition._pca import _assess_dimension, _infer_dimension
+from sklearn.utils._array_api import (
+    _atol_for_type,
+    _convert_to_numpy,
+    yield_namespace_device_dtype_combinations,
+)
+from sklearn.utils._array_api import device as array_device
+from sklearn.utils._testing import _array_api_for_tests, assert_allclose
+from sklearn.utils.estimator_checks import (
+    _get_check_estimator_ids,
+    check_array_api_input_and_values,
+)
+from sklearn.utils.fixes import CSC_CONTAINERS, CSR_CONTAINERS
+
+iris = datasets.load_iris()
+PCA_SOLVERS = ["full", "arpack", "randomized", "auto"]
+
+# `SPARSE_M` and `SPARSE_N` could be larger, but be aware:
+# * SciPy's generation of random sparse matrix can be costly
+# * A (SPARSE_M, SPARSE_N) dense array is allocated to compare against
+SPARSE_M, SPARSE_N = 1000, 300  # arbitrary
+SPARSE_MAX_COMPONENTS = min(SPARSE_M, SPARSE_N)
+
+
+def _check_fitted_pca_close(pca1, pca2, rtol):
+    assert_allclose(pca1.components_, pca2.components_, rtol=rtol)
+    assert_allclose(pca1.explained_variance_, pca2.explained_variance_, rtol=rtol)
+    assert_allclose(pca1.singular_values_, pca2.singular_values_, rtol=rtol)
+    assert_allclose(pca1.mean_, pca2.mean_, rtol=rtol)
+    assert_allclose(pca1.n_components_, pca2.n_components_, rtol=rtol)
+    assert_allclose(pca1.n_samples_, pca2.n_samples_, rtol=rtol)
+    assert_allclose(pca1.noise_variance_, pca2.noise_variance_, rtol=rtol)
+    assert_allclose(pca1.n_features_in_, pca2.n_features_in_, rtol=rtol)
+
+
+@pytest.mark.parametrize("svd_solver", PCA_SOLVERS)
+@pytest.mark.parametrize("n_components", range(1, iris.data.shape[1]))
+def test_pca(svd_solver, n_components):
+    X = iris.data
+    pca = PCA(n_components=n_components, svd_solver=svd_solver)
+
+    # check the shape of fit.transform
+    X_r = pca.fit(X).transform(X)
+    assert X_r.shape[1] == n_components
+
+    # check the equivalence of fit.transform and fit_transform
+    X_r2 = pca.fit_transform(X)
+    assert_allclose(X_r, X_r2)
+    X_r = pca.transform(X)
+    assert_allclose(X_r, X_r2)
+
+    # Test get_covariance and get_precision
+    cov = pca.get_covariance()
+    precision = pca.get_precision()
+    assert_allclose(np.dot(cov, precision), np.eye(X.shape[1]), atol=1e-12)
+
+
+@pytest.mark.parametrize("density", [0.01, 0.1, 0.30])
+@pytest.mark.parametrize("n_components", [1, 2, 10])
+@pytest.mark.parametrize("sparse_container", CSR_CONTAINERS + CSC_CONTAINERS)
+@pytest.mark.parametrize("svd_solver", ["arpack"])
+@pytest.mark.parametrize("scale", [1, 10, 100])
+def test_pca_sparse(
+    global_random_seed, svd_solver, sparse_container, n_components, density, scale
+):
+    # Make sure any tolerance changes pass with SKLEARN_TESTS_GLOBAL_RANDOM_SEED="all"
+    rtol = 5e-07
+    transform_rtol = 3e-05
+
+    random_state = np.random.default_rng(global_random_seed)
+    X = sparse_container(
+        sp.sparse.random(
+            SPARSE_M,
+            SPARSE_N,
+            random_state=random_state,
+            density=density,
+        )
+    )
+    # Scale the data + vary the column means
+    scale_vector = random_state.random(X.shape[1]) * scale
+    X = X.multiply(scale_vector)
+
+    pca = PCA(
+        n_components=n_components,
+        svd_solver=svd_solver,
+        random_state=global_random_seed,
+    )
+    pca.fit(X)
+
+    Xd = X.toarray()
+    pcad = PCA(
+        n_components=n_components,
+        svd_solver=svd_solver,
+        random_state=global_random_seed,
+    )
+    pcad.fit(Xd)
+
+    # Fitted attributes equality
+    _check_fitted_pca_close(pca, pcad, rtol=rtol)
+
+    # Test transform
+    X2 = sparse_container(
+        sp.sparse.random(
+            SPARSE_M,
+            SPARSE_N,
+            random_state=random_state,
+            density=density,
+        )
+    )
+    X2d = X2.toarray()
+
+    assert_allclose(pca.transform(X2), pca.transform(X2d), rtol=transform_rtol)
+    assert_allclose(pca.transform(X2), pcad.transform(X2d), rtol=transform_rtol)
+
+
+@pytest.mark.parametrize("sparse_container", CSR_CONTAINERS + CSC_CONTAINERS)
+def test_pca_sparse_fit_transform(global_random_seed, sparse_container):
+    random_state = np.random.default_rng(global_random_seed)
+    X = sparse_container(
+        sp.sparse.random(
+            SPARSE_M,
+            SPARSE_N,
+            random_state=random_state,
+            density=0.01,
+        )
+    )
+    X2 = sparse_container(
+        sp.sparse.random(
+            SPARSE_M,
+            SPARSE_N,
+            random_state=random_state,
+            density=0.01,
+        )
+    )
+
+    pca_fit = PCA(n_components=10, svd_solver="arpack", random_state=global_random_seed)
+    pca_fit_transform = PCA(
+        n_components=10, svd_solver="arpack", random_state=global_random_seed
+    )
+
+    pca_fit.fit(X)
+    transformed_X = pca_fit_transform.fit_transform(X)
+
+    _check_fitted_pca_close(pca_fit, pca_fit_transform, rtol=1e-10)
+    assert_allclose(transformed_X, pca_fit_transform.transform(X), rtol=2e-9)
+    assert_allclose(transformed_X, pca_fit.transform(X), rtol=2e-9)
+    assert_allclose(pca_fit.transform(X2), pca_fit_transform.transform(X2), rtol=2e-9)
+
+
+@pytest.mark.parametrize("svd_solver", ["randomized", "full", "auto"])
+@pytest.mark.parametrize("sparse_container", CSR_CONTAINERS + CSC_CONTAINERS)
+def test_sparse_pca_solver_error(global_random_seed, svd_solver, sparse_container):
+    random_state = np.random.RandomState(global_random_seed)
+    X = sparse_container(
+        sp.sparse.random(
+            SPARSE_M,
+            SPARSE_N,
+            random_state=random_state,
+        )
+    )
+    pca = PCA(n_components=30, svd_solver=svd_solver)
+    error_msg_pattern = (
+        f'PCA only support sparse inputs with the "arpack" solver, while "{svd_solver}"'
+        " was passed"
+    )
+    with pytest.raises(TypeError, match=error_msg_pattern):
+        pca.fit(X)
+
+
+def test_no_empty_slice_warning():
+    # test if we avoid numpy warnings for computing over empty arrays
+    n_components = 10
+    n_features = n_components + 2  # anything > n_comps triggered it in 0.16
+    X = np.random.uniform(-1, 1, size=(n_components, n_features))
+    pca = PCA(n_components=n_components)
+    with warnings.catch_warnings():
+        warnings.simplefilter("error", RuntimeWarning)
+        pca.fit(X)
+
+
+@pytest.mark.parametrize("copy", [True, False])
+@pytest.mark.parametrize("solver", PCA_SOLVERS)
+def test_whitening(solver, copy):
+    # Check that PCA output has unit-variance
+    rng = np.random.RandomState(0)
+    n_samples = 100
+    n_features = 80
+    n_components = 30
+    rank = 50
+
+    # some low rank data with correlated features
+    X = np.dot(
+        rng.randn(n_samples, rank),
+        np.dot(np.diag(np.linspace(10.0, 1.0, rank)), rng.randn(rank, n_features)),
+    )
+    # the component-wise variance of the first 50 features is 3 times the
+    # mean component-wise variance of the remaining 30 features
+    X[:, :50] *= 3
+
+    assert X.shape == (n_samples, n_features)
+
+    # the component-wise variance is thus highly varying:
+    assert X.std(axis=0).std() > 43.8
+
+    # whiten the data while projecting to the lower dim subspace
+    X_ = X.copy()  # make sure we keep an original across iterations.
+    pca = PCA(
+        n_components=n_components,
+        whiten=True,
+        copy=copy,
+        svd_solver=solver,
+        random_state=0,
+        iterated_power=7,
+    )
+    # test fit_transform
+    X_whitened = pca.fit_transform(X_.copy())
+    assert X_whitened.shape == (n_samples, n_components)
+    X_whitened2 = pca.transform(X_)
+    assert_allclose(X_whitened, X_whitened2, rtol=5e-4)
+
+    assert_allclose(X_whitened.std(ddof=1, axis=0), np.ones(n_components))
+    assert_allclose(X_whitened.mean(axis=0), np.zeros(n_components), atol=1e-12)
+
+    X_ = X.copy()
+    pca = PCA(
+        n_components=n_components, whiten=False, copy=copy, svd_solver=solver
+    ).fit(X_.copy())
+    X_unwhitened = pca.transform(X_)
+    assert X_unwhitened.shape == (n_samples, n_components)
+
+    # in that case the output components still have varying variances
+    assert X_unwhitened.std(axis=0).std() == pytest.approx(74.1, rel=1e-1)
+    # we always center, so no test for non-centering.
+
+
+@pytest.mark.parametrize("svd_solver", ["arpack", "randomized"])
+def test_pca_explained_variance_equivalence_solver(svd_solver):
+    rng = np.random.RandomState(0)
+    n_samples, n_features = 100, 80
+    X = rng.randn(n_samples, n_features)
+
+    pca_full = PCA(n_components=2, svd_solver="full")
+    pca_other = PCA(n_components=2, svd_solver=svd_solver, random_state=0)
+
+    pca_full.fit(X)
+    pca_other.fit(X)
+
+    assert_allclose(
+        pca_full.explained_variance_, pca_other.explained_variance_, rtol=5e-2
+    )
+    assert_allclose(
+        pca_full.explained_variance_ratio_,
+        pca_other.explained_variance_ratio_,
+        rtol=5e-2,
+    )
+
+
+@pytest.mark.parametrize(
+    "X",
+    [
+        np.random.RandomState(0).randn(100, 80),
+        datasets.make_classification(100, 80, n_informative=78, random_state=0)[0],
+    ],
+    ids=["random-data", "correlated-data"],
+)
+@pytest.mark.parametrize("svd_solver", PCA_SOLVERS)
+def test_pca_explained_variance_empirical(X, svd_solver):
+    pca = PCA(n_components=2, svd_solver=svd_solver, random_state=0)
+    X_pca = pca.fit_transform(X)
+    assert_allclose(pca.explained_variance_, np.var(X_pca, ddof=1, axis=0))
+
+    expected_result = np.linalg.eig(np.cov(X, rowvar=False))[0]
+    expected_result = sorted(expected_result, reverse=True)[:2]
+    assert_allclose(pca.explained_variance_, expected_result, rtol=5e-3)
+
+
+@pytest.mark.parametrize("svd_solver", ["arpack", "randomized"])
+def test_pca_singular_values_consistency(svd_solver):
+    rng = np.random.RandomState(0)
+    n_samples, n_features = 100, 80
+    X = rng.randn(n_samples, n_features)
+
+    pca_full = PCA(n_components=2, svd_solver="full", random_state=rng)
+    pca_other = PCA(n_components=2, svd_solver=svd_solver, random_state=rng)
+
+    pca_full.fit(X)
+    pca_other.fit(X)
+
+    assert_allclose(pca_full.singular_values_, pca_other.singular_values_, rtol=5e-3)
+
+
+@pytest.mark.parametrize("svd_solver", PCA_SOLVERS)
+def test_pca_singular_values(svd_solver):
+    rng = np.random.RandomState(0)
+    n_samples, n_features = 100, 80
+    X = rng.randn(n_samples, n_features)
+
+    pca = PCA(n_components=2, svd_solver=svd_solver, random_state=rng)
+    X_trans = pca.fit_transform(X)
+
+    # compare to the Frobenius norm
+    assert_allclose(
+        np.sum(pca.singular_values_**2), np.linalg.norm(X_trans, "fro") ** 2
+    )
+    # Compare to the 2-norms of the score vectors
+    assert_allclose(pca.singular_values_, np.sqrt(np.sum(X_trans**2, axis=0)))
+
+    # set the singular values and see what er get back
+    n_samples, n_features = 100, 110
+    X = rng.randn(n_samples, n_features)
+
+    pca = PCA(n_components=3, svd_solver=svd_solver, random_state=rng)
+    X_trans = pca.fit_transform(X)
+    X_trans /= np.sqrt(np.sum(X_trans**2, axis=0))
+    X_trans[:, 0] *= 3.142
+    X_trans[:, 1] *= 2.718
+    X_hat = np.dot(X_trans, pca.components_)
+    pca.fit(X_hat)
+    assert_allclose(pca.singular_values_, [3.142, 2.718, 1.0])
+
+
+@pytest.mark.parametrize("svd_solver", PCA_SOLVERS)
+def test_pca_check_projection(svd_solver):
+    # Test that the projection of data is correct
+    rng = np.random.RandomState(0)
+    n, p = 100, 3
+    X = rng.randn(n, p) * 0.1
+    X[:10] += np.array([3, 4, 5])
+    Xt = 0.1 * rng.randn(1, p) + np.array([3, 4, 5])
+
+    Yt = PCA(n_components=2, svd_solver=svd_solver).fit(X).transform(Xt)
+    Yt /= np.sqrt((Yt**2).sum())
+
+    assert_allclose(np.abs(Yt[0][0]), 1.0, rtol=5e-3)
+
+
+@pytest.mark.parametrize("svd_solver", PCA_SOLVERS)
+def test_pca_check_projection_list(svd_solver):
+    # Test that the projection of data is correct
+    X = [[1.0, 0.0], [0.0, 1.0]]
+    pca = PCA(n_components=1, svd_solver=svd_solver, random_state=0)
+    X_trans = pca.fit_transform(X)
+    assert X_trans.shape, (2, 1)
+    assert_allclose(X_trans.mean(), 0.00, atol=1e-12)
+    assert_allclose(X_trans.std(), 0.71, rtol=5e-3)
+
+
+@pytest.mark.parametrize("svd_solver", ["full", "arpack", "randomized"])
+@pytest.mark.parametrize("whiten", [False, True])
+def test_pca_inverse(svd_solver, whiten):
+    # Test that the projection of data can be inverted
+    rng = np.random.RandomState(0)
+    n, p = 50, 3
+    X = rng.randn(n, p)  # spherical data
+    X[:, 1] *= 0.00001  # make middle component relatively small
+    X += [5, 4, 3]  # make a large mean
+
+    # same check that we can find the original data from the transformed
+    # signal (since the data is almost of rank n_components)
+    pca = PCA(n_components=2, svd_solver=svd_solver, whiten=whiten).fit(X)
+    Y = pca.transform(X)
+    Y_inverse = pca.inverse_transform(Y)
+    assert_allclose(X, Y_inverse, rtol=5e-6)
+
+
+@pytest.mark.parametrize(
+    "data", [np.array([[0, 1, 0], [1, 0, 0]]), np.array([[0, 1, 0], [1, 0, 0]]).T]
+)
+@pytest.mark.parametrize(
+    "svd_solver, n_components, err_msg",
+    [
+        ("arpack", 0, r"must be between 1 and min\(n_samples, n_features\)"),
+        ("randomized", 0, r"must be between 1 and min\(n_samples, n_features\)"),
+        ("arpack", 2, r"must be strictly less than min"),
+        (
+            "auto",
+            3,
+            (
+                r"n_components=3 must be between 0 and min\(n_samples, "
+                r"n_features\)=2 with svd_solver='full'"
+            ),
+        ),
+    ],
+)
+def test_pca_validation(svd_solver, data, n_components, err_msg):
+    # Ensures that solver-specific extreme inputs for the n_components
+    # parameter raise errors
+    smallest_d = 2  # The smallest dimension
+    pca_fitted = PCA(n_components, svd_solver=svd_solver)
+
+    with pytest.raises(ValueError, match=err_msg):
+        pca_fitted.fit(data)
+
+    # Additional case for arpack
+    if svd_solver == "arpack":
+        n_components = smallest_d
+
+        err_msg = (
+            "n_components={}L? must be strictly less than "
+            r"min\(n_samples, n_features\)={}L? with "
+            "svd_solver='arpack'".format(n_components, smallest_d)
+        )
+        with pytest.raises(ValueError, match=err_msg):
+            PCA(n_components, svd_solver=svd_solver).fit(data)
+
+
+@pytest.mark.parametrize(
+    "solver, n_components_",
+    [
+        ("full", min(iris.data.shape)),
+        ("arpack", min(iris.data.shape) - 1),
+        ("randomized", min(iris.data.shape)),
+    ],
+)
+@pytest.mark.parametrize("data", [iris.data, iris.data.T])
+def test_n_components_none(data, solver, n_components_):
+    pca = PCA(svd_solver=solver)
+    pca.fit(data)
+    assert pca.n_components_ == n_components_
+
+
+@pytest.mark.parametrize("svd_solver", ["auto", "full"])
+def test_n_components_mle(svd_solver):
+    # Ensure that n_components == 'mle' doesn't raise error for auto/full
+    rng = np.random.RandomState(0)
+    n_samples, n_features = 600, 10
+    X = rng.randn(n_samples, n_features)
+    pca = PCA(n_components="mle", svd_solver=svd_solver)
+    pca.fit(X)
+    assert pca.n_components_ == 1
+
+
+@pytest.mark.parametrize("svd_solver", ["arpack", "randomized"])
+def test_n_components_mle_error(svd_solver):
+    # Ensure that n_components == 'mle' will raise an error for unsupported
+    # solvers
+    rng = np.random.RandomState(0)
+    n_samples, n_features = 600, 10
+    X = rng.randn(n_samples, n_features)
+    pca = PCA(n_components="mle", svd_solver=svd_solver)
+    err_msg = "n_components='mle' cannot be a string with svd_solver='{}'".format(
+        svd_solver
+    )
+    with pytest.raises(ValueError, match=err_msg):
+        pca.fit(X)
+
+
+def test_pca_dim():
+    # Check automated dimensionality setting
+    rng = np.random.RandomState(0)
+    n, p = 100, 5
+    X = rng.randn(n, p) * 0.1
+    X[:10] += np.array([3, 4, 5, 1, 2])
+    pca = PCA(n_components="mle", svd_solver="full").fit(X)
+    assert pca.n_components == "mle"
+    assert pca.n_components_ == 1
+
+
+def test_infer_dim_1():
+    # TODO: explain what this is testing
+    # Or at least use explicit variable names...
+    n, p = 1000, 5
+    rng = np.random.RandomState(0)
+    X = (
+        rng.randn(n, p) * 0.1
+        + rng.randn(n, 1) * np.array([3, 4, 5, 1, 2])
+        + np.array([1, 0, 7, 4, 6])
+    )
+    pca = PCA(n_components=p, svd_solver="full")
+    pca.fit(X)
+    spect = pca.explained_variance_
+    ll = np.array([_assess_dimension(spect, k, n) for k in range(1, p)])
+    assert ll[1] > ll.max() - 0.01 * n
+
+
+def test_infer_dim_2():
+    # TODO: explain what this is testing
+    # Or at least use explicit variable names...
+    n, p = 1000, 5
+    rng = np.random.RandomState(0)
+    X = rng.randn(n, p) * 0.1
+    X[:10] += np.array([3, 4, 5, 1, 2])
+    X[10:20] += np.array([6, 0, 7, 2, -1])
+    pca = PCA(n_components=p, svd_solver="full")
+    pca.fit(X)
+    spect = pca.explained_variance_
+    assert _infer_dimension(spect, n) > 1
+
+
+def test_infer_dim_3():
+    n, p = 100, 5
+    rng = np.random.RandomState(0)
+    X = rng.randn(n, p) * 0.1
+    X[:10] += np.array([3, 4, 5, 1, 2])
+    X[10:20] += np.array([6, 0, 7, 2, -1])
+    X[30:40] += 2 * np.array([-1, 1, -1, 1, -1])
+    pca = PCA(n_components=p, svd_solver="full")
+    pca.fit(X)
+    spect = pca.explained_variance_
+    assert _infer_dimension(spect, n) > 2
+
+
+@pytest.mark.parametrize(
+    "X, n_components, n_components_validated",
+    [
+        (iris.data, 0.95, 2),  # row > col
+        (iris.data, 0.01, 1),  # row > col
+        (np.random.RandomState(0).rand(5, 20), 0.5, 2),
+    ],  # row < col
+)
+def test_infer_dim_by_explained_variance(X, n_components, n_components_validated):
+    pca = PCA(n_components=n_components, svd_solver="full")
+    pca.fit(X)
+    assert pca.n_components == pytest.approx(n_components)
+    assert pca.n_components_ == n_components_validated
+
+
+@pytest.mark.parametrize("svd_solver", PCA_SOLVERS)
+def test_pca_score(svd_solver):
+    # Test that probabilistic PCA scoring yields a reasonable score
+    n, p = 1000, 3
+    rng = np.random.RandomState(0)
+    X = rng.randn(n, p) * 0.1 + np.array([3, 4, 5])
+    pca = PCA(n_components=2, svd_solver=svd_solver)
+    pca.fit(X)
+
+    ll1 = pca.score(X)
+    h = -0.5 * np.log(2 * np.pi * np.exp(1) * 0.1**2) * p
+    assert_allclose(ll1 / h, 1, rtol=5e-2)
+
+    ll2 = pca.score(rng.randn(n, p) * 0.2 + np.array([3, 4, 5]))
+    assert ll1 > ll2
+
+    pca = PCA(n_components=2, whiten=True, svd_solver=svd_solver)
+    pca.fit(X)
+    ll2 = pca.score(X)
+    assert ll1 > ll2
+
+
+def test_pca_score3():
+    # Check that probabilistic PCA selects the right model
+    n, p = 200, 3
+    rng = np.random.RandomState(0)
+    Xl = rng.randn(n, p) + rng.randn(n, 1) * np.array([3, 4, 5]) + np.array([1, 0, 7])
+    Xt = rng.randn(n, p) + rng.randn(n, 1) * np.array([3, 4, 5]) + np.array([1, 0, 7])
+    ll = np.zeros(p)
+    for k in range(p):
+        pca = PCA(n_components=k, svd_solver="full")
+        pca.fit(Xl)
+        ll[k] = pca.score(Xt)
+
+    assert ll.argmax() == 1
+
+
+@pytest.mark.parametrize("svd_solver", PCA_SOLVERS)
+def test_pca_sanity_noise_variance(svd_solver):
+    # Sanity check for the noise_variance_. For more details see
+    # https://github.com/scikit-learn/scikit-learn/issues/7568
+    # https://github.com/scikit-learn/scikit-learn/issues/8541
+    # https://github.com/scikit-learn/scikit-learn/issues/8544
+    X, _ = datasets.load_digits(return_X_y=True)
+    pca = PCA(n_components=30, svd_solver=svd_solver, random_state=0)
+    pca.fit(X)
+    assert np.all((pca.explained_variance_ - pca.noise_variance_) >= 0)
+
+
+@pytest.mark.parametrize("svd_solver", ["arpack", "randomized"])
+def test_pca_score_consistency_solvers(svd_solver):
+    # Check the consistency of score between solvers
+    X, _ = datasets.load_digits(return_X_y=True)
+    pca_full = PCA(n_components=30, svd_solver="full", random_state=0)
+    pca_other = PCA(n_components=30, svd_solver=svd_solver, random_state=0)
+    pca_full.fit(X)
+    pca_other.fit(X)
+    assert_allclose(pca_full.score(X), pca_other.score(X), rtol=5e-6)
+
+
+# arpack raises ValueError for n_components == min(n_samples,  n_features)
+@pytest.mark.parametrize("svd_solver", ["full", "randomized"])
+def test_pca_zero_noise_variance_edge_cases(svd_solver):
+    # ensure that noise_variance_ is 0 in edge cases
+    # when n_components == min(n_samples, n_features)
+    n, p = 100, 3
+    rng = np.random.RandomState(0)
+    X = rng.randn(n, p) * 0.1 + np.array([3, 4, 5])
+
+    pca = PCA(n_components=p, svd_solver=svd_solver)
+    pca.fit(X)
+    assert pca.noise_variance_ == 0
+    # Non-regression test for gh-12489
+    # ensure no divide-by-zero error for n_components == n_features < n_samples
+    pca.score(X)
+
+    pca.fit(X.T)
+    assert pca.noise_variance_ == 0
+    # Non-regression test for gh-12489
+    # ensure no divide-by-zero error for n_components == n_samples < n_features
+    pca.score(X.T)
+
+
+@pytest.mark.parametrize(
+    "data, n_components, expected_solver",
+    [  # case: n_components in (0,1) => 'full'
+        (np.random.RandomState(0).uniform(size=(1000, 50)), 0.5, "full"),
+        # case: max(X.shape) <= 500 => 'full'
+        (np.random.RandomState(0).uniform(size=(10, 50)), 5, "full"),
+        # case: n_components >= .8 * min(X.shape) => 'full'
+        (np.random.RandomState(0).uniform(size=(1000, 50)), 50, "full"),
+        # n_components >= 1 and n_components < .8*min(X.shape) => 'randomized'
+        (np.random.RandomState(0).uniform(size=(1000, 50)), 10, "randomized"),
+    ],
+)
+def test_pca_svd_solver_auto(data, n_components, expected_solver):
+    pca_auto = PCA(n_components=n_components, random_state=0)
+    pca_test = PCA(
+        n_components=n_components, svd_solver=expected_solver, random_state=0
+    )
+    pca_auto.fit(data)
+    pca_test.fit(data)
+    assert_allclose(pca_auto.components_, pca_test.components_)
+
+
+@pytest.mark.parametrize("svd_solver", PCA_SOLVERS)
+def test_pca_deterministic_output(svd_solver):
+    rng = np.random.RandomState(0)
+    X = rng.rand(10, 10)
+
+    transformed_X = np.zeros((20, 2))
+    for i in range(20):
+        pca = PCA(n_components=2, svd_solver=svd_solver, random_state=rng)
+        transformed_X[i, :] = pca.fit_transform(X)[0]
+    assert_allclose(transformed_X, np.tile(transformed_X[0, :], 20).reshape(20, 2))
+
+
+@pytest.mark.parametrize("svd_solver", PCA_SOLVERS)
+def test_pca_dtype_preservation(svd_solver):
+    check_pca_float_dtype_preservation(svd_solver)
+    check_pca_int_dtype_upcast_to_double(svd_solver)
+
+
+def check_pca_float_dtype_preservation(svd_solver):
+    # Ensure that PCA does not upscale the dtype when input is float32
+    X_64 = np.random.RandomState(0).rand(1000, 4).astype(np.float64, copy=False)
+    X_32 = X_64.astype(np.float32)
+
+    pca_64 = PCA(n_components=3, svd_solver=svd_solver, random_state=0).fit(X_64)
+    pca_32 = PCA(n_components=3, svd_solver=svd_solver, random_state=0).fit(X_32)
+
+    assert pca_64.components_.dtype == np.float64
+    assert pca_32.components_.dtype == np.float32
+    assert pca_64.transform(X_64).dtype == np.float64
+    assert pca_32.transform(X_32).dtype == np.float32
+
+    # the rtol is set such that the test passes on all platforms tested on
+    # conda-forge: PR#15775
+    # see: https://github.com/conda-forge/scikit-learn-feedstock/pull/113
+    assert_allclose(pca_64.components_, pca_32.components_, rtol=2e-4)
+
+
+def check_pca_int_dtype_upcast_to_double(svd_solver):
+    # Ensure that all int types will be upcast to float64
+    X_i64 = np.random.RandomState(0).randint(0, 1000, (1000, 4))
+    X_i64 = X_i64.astype(np.int64, copy=False)
+    X_i32 = X_i64.astype(np.int32, copy=False)
+
+    pca_64 = PCA(n_components=3, svd_solver=svd_solver, random_state=0).fit(X_i64)
+    pca_32 = PCA(n_components=3, svd_solver=svd_solver, random_state=0).fit(X_i32)
+
+    assert pca_64.components_.dtype == np.float64
+    assert pca_32.components_.dtype == np.float64
+    assert pca_64.transform(X_i64).dtype == np.float64
+    assert pca_32.transform(X_i32).dtype == np.float64
+
+    assert_allclose(pca_64.components_, pca_32.components_, rtol=1e-4)
+
+
+def test_pca_n_components_mostly_explained_variance_ratio():
+    # when n_components is the second highest cumulative sum of the
+    # explained_variance_ratio_, then n_components_ should equal the
+    # number of features in the dataset #15669
+    X, y = load_iris(return_X_y=True)
+    pca1 = PCA().fit(X, y)
+
+    n_components = pca1.explained_variance_ratio_.cumsum()[-2]
+    pca2 = PCA(n_components=n_components).fit(X, y)
+    assert pca2.n_components_ == X.shape[1]
+
+
+def test_assess_dimension_bad_rank():
+    # Test error when tested rank not in [1, n_features - 1]
+    spectrum = np.array([1, 1e-30, 1e-30, 1e-30])
+    n_samples = 10
+    for rank in (0, 5):
+        with pytest.raises(ValueError, match=r"should be in \[1, n_features - 1\]"):
+            _assess_dimension(spectrum, rank, n_samples)
+
+
+def test_small_eigenvalues_mle():
+    # Test rank associated with tiny eigenvalues are given a log-likelihood of
+    # -inf. The inferred rank will be 1
+    spectrum = np.array([1, 1e-30, 1e-30, 1e-30])
+
+    assert _assess_dimension(spectrum, rank=1, n_samples=10) > -np.inf
+
+    for rank in (2, 3):
+        assert _assess_dimension(spectrum, rank, 10) == -np.inf
+
+    assert _infer_dimension(spectrum, 10) == 1
+
+
+def test_mle_redundant_data():
+    # Test 'mle' with pathological X: only one relevant feature should give a
+    # rank of 1
+    X, _ = datasets.make_classification(
+        n_features=20,
+        n_informative=1,
+        n_repeated=18,
+        n_redundant=1,
+        n_clusters_per_class=1,
+        random_state=42,
+    )
+    pca = PCA(n_components="mle").fit(X)
+    assert pca.n_components_ == 1
+
+
+def test_fit_mle_too_few_samples():
+    # Tests that an error is raised when the number of samples is smaller
+    # than the number of features during an mle fit
+    X, _ = datasets.make_classification(n_samples=20, n_features=21, random_state=42)
+
+    pca = PCA(n_components="mle", svd_solver="full")
+    with pytest.raises(
+        ValueError,
+        match="n_components='mle' is only supported if n_samples >= n_features",
+    ):
+        pca.fit(X)
+
+
+def test_mle_simple_case():
+    # non-regression test for issue
+    # https://github.com/scikit-learn/scikit-learn/issues/16730
+    n_samples, n_dim = 1000, 10
+    X = np.random.RandomState(0).randn(n_samples, n_dim)
+    X[:, -1] = np.mean(X[:, :-1], axis=-1)  # true X dim is ndim - 1
+    pca_skl = PCA("mle", svd_solver="full")
+    pca_skl.fit(X)
+    assert pca_skl.n_components_ == n_dim - 1
+
+
+def test_assess_dimesion_rank_one():
+    # Make sure assess_dimension works properly on a matrix of rank 1
+    n_samples, n_features = 9, 6
+    X = np.ones((n_samples, n_features))  # rank 1 matrix
+    _, s, _ = np.linalg.svd(X, full_matrices=True)
+    # except for rank 1, all eigenvalues are 0 resp. close to 0 (FP)
+    assert_allclose(s[1:], np.zeros(n_features - 1), atol=1e-12)
+
+    assert np.isfinite(_assess_dimension(s, rank=1, n_samples=n_samples))
+    for rank in range(2, n_features):
+        assert _assess_dimension(s, rank, n_samples) == -np.inf
+
+
+def test_pca_randomized_svd_n_oversamples():
+    """Check that exposing and setting `n_oversamples` will provide accurate results
+    even when `X` as a large number of features.
+
+    Non-regression test for:
+    https://github.com/scikit-learn/scikit-learn/issues/20589
+    """
+    rng = np.random.RandomState(0)
+    n_features = 100
+    X = rng.randn(1_000, n_features)
+
+    # The default value of `n_oversamples` will lead to inaccurate results
+    # We force it to the number of features.
+    pca_randomized = PCA(
+        n_components=1,
+        svd_solver="randomized",
+        n_oversamples=n_features,
+        random_state=0,
+    ).fit(X)
+    pca_full = PCA(n_components=1, svd_solver="full").fit(X)
+    pca_arpack = PCA(n_components=1, svd_solver="arpack", random_state=0).fit(X)
+
+    assert_allclose(np.abs(pca_full.components_), np.abs(pca_arpack.components_))
+    assert_allclose(np.abs(pca_randomized.components_), np.abs(pca_arpack.components_))
+
+
+def test_feature_names_out():
+    """Check feature names out for PCA."""
+    pca = PCA(n_components=2).fit(iris.data)
+
+    names = pca.get_feature_names_out()
+    assert_array_equal([f"pca{i}" for i in range(2)], names)
+
+
+@pytest.mark.parametrize("copy", [True, False])
+def test_variance_correctness(copy):
+    """Check the accuracy of PCA's internal variance calculation"""
+    rng = np.random.RandomState(0)
+    X = rng.randn(1000, 200)
+    pca = PCA().fit(X)
+    pca_var = pca.explained_variance_ / pca.explained_variance_ratio_
+    true_var = np.var(X, ddof=1, axis=0).sum()
+    np.testing.assert_allclose(pca_var, true_var)
+
+
+def check_array_api_get_precision(name, estimator, array_namespace, device, dtype_name):
+    xp = _array_api_for_tests(array_namespace, device)
+    iris_np = iris.data.astype(dtype_name)
+    iris_xp = xp.asarray(iris_np, device=device)
+
+    estimator.fit(iris_np)
+    precision_np = estimator.get_precision()
+    covariance_np = estimator.get_covariance()
+
+    with config_context(array_api_dispatch=True):
+        estimator_xp = clone(estimator).fit(iris_xp)
+        precision_xp = estimator_xp.get_precision()
+        assert precision_xp.shape == (4, 4)
+        assert precision_xp.dtype == iris_xp.dtype
+
+        assert_allclose(
+            _convert_to_numpy(precision_xp, xp=xp),
+            precision_np,
+            atol=_atol_for_type(dtype_name),
+        )
+        covariance_xp = estimator_xp.get_covariance()
+        assert covariance_xp.shape == (4, 4)
+        assert covariance_xp.dtype == iris_xp.dtype
+
+        assert_allclose(
+            _convert_to_numpy(covariance_xp, xp=xp),
+            covariance_np,
+            atol=_atol_for_type(dtype_name),
+        )
+
+
+@pytest.mark.parametrize(
+    "array_namespace, device, dtype_name", yield_namespace_device_dtype_combinations()
+)
+@pytest.mark.parametrize(
+    "check",
+    [check_array_api_input_and_values, check_array_api_get_precision],
+    ids=_get_check_estimator_ids,
+)
+@pytest.mark.parametrize(
+    "estimator",
+    [
+        PCA(n_components=2, svd_solver="full"),
+        PCA(n_components=0.1, svd_solver="full", whiten=True),
+        PCA(
+            n_components=2,
+            svd_solver="randomized",
+            power_iteration_normalizer="QR",
+            random_state=0,  # how to use global_random_seed here?
+        ),
+    ],
+    ids=_get_check_estimator_ids,
+)
+def test_pca_array_api_compliance(
+    estimator, check, array_namespace, device, dtype_name
+):
+    name = estimator.__class__.__name__
+    check(name, estimator, array_namespace, device=device, dtype_name=dtype_name)
+
+
+@pytest.mark.parametrize(
+    "array_namespace, device, dtype_name", yield_namespace_device_dtype_combinations()
+)
+@pytest.mark.parametrize(
+    "check",
+    [check_array_api_get_precision],
+    ids=_get_check_estimator_ids,
+)
+@pytest.mark.parametrize(
+    "estimator",
+    [
+        # PCA with mle cannot use check_array_api_input_and_values because of
+        # rounding errors in the noisy (low variance) components. Even checking
+        # the shape of the `components_` is problematic because the number of
+        # components depends on trimming threshold of the mle algorithm which
+        # can depend on device-specific rounding errors.
+        PCA(n_components="mle", svd_solver="full"),
+    ],
+    ids=_get_check_estimator_ids,
+)
+def test_pca_mle_array_api_compliance(
+    estimator, check, array_namespace, device, dtype_name
+):
+    name = estimator.__class__.__name__
+    check(name, estimator, array_namespace, device=device, dtype_name=dtype_name)
+
+    # Simpler variant of the generic check_array_api_input checker tailored for
+    # the specific case of PCA with mle-trimmed components.
+    xp = _array_api_for_tests(array_namespace, device)
+
+    X, y = make_classification(random_state=42)
+    X = X.astype(dtype_name, copy=False)
+    atol = _atol_for_type(X.dtype)
+
+    est = clone(estimator)
+
+    X_xp = xp.asarray(X, device=device)
+    y_xp = xp.asarray(y, device=device)
+
+    est.fit(X, y)
+
+    components_np = est.components_
+    explained_variance_np = est.explained_variance_
+
+    est_xp = clone(est)
+    with config_context(array_api_dispatch=True):
+        est_xp.fit(X_xp, y_xp)
+        components_xp = est_xp.components_
+        assert array_device(components_xp) == array_device(X_xp)
+        components_xp_np = _convert_to_numpy(components_xp, xp=xp)
+
+        explained_variance_xp = est_xp.explained_variance_
+        assert array_device(explained_variance_xp) == array_device(X_xp)
+        explained_variance_xp_np = _convert_to_numpy(explained_variance_xp, xp=xp)
+
+    assert components_xp_np.dtype == components_np.dtype
+    assert components_xp_np.shape[1] == components_np.shape[1]
+    assert explained_variance_xp_np.dtype == explained_variance_np.dtype
+
+    # Check that the explained variance values match for the
+    # common components:
+    min_components = min(components_xp_np.shape[0], components_np.shape[0])
+    assert_allclose(
+        explained_variance_xp_np[:min_components],
+        explained_variance_np[:min_components],
+        atol=atol,
+    )
+
+    # If the number of components differ, check that the explained variance of
+    # the trimmed components is very small.
+    if components_xp_np.shape[0] != components_np.shape[0]:
+        reference_variance = explained_variance_np[-1]
+        extra_variance_np = explained_variance_np[min_components:]
+        extra_variance_xp_np = explained_variance_xp_np[min_components:]
+        assert all(np.abs(extra_variance_np - reference_variance) < atol)
+        assert all(np.abs(extra_variance_xp_np - reference_variance) < atol)
+
+
+def test_array_api_error_and_warnings_on_unsupported_params():
+    pytest.importorskip("array_api_compat")
+    xp = pytest.importorskip("numpy.array_api")
+    iris_xp = xp.asarray(iris.data)
+
+    pca = PCA(n_components=2, svd_solver="arpack", random_state=0)
+    expected_msg = re.escape(
+        "PCA with svd_solver='arpack' is not supported for Array API inputs."
+    )
+    with pytest.raises(ValueError, match=expected_msg):
+        with config_context(array_api_dispatch=True):
+            pca.fit(iris_xp)
+
+    pca.set_params(svd_solver="randomized", power_iteration_normalizer="LU")
+    expected_msg = re.escape(
+        "Array API does not support LU factorization. Set"
+        " `power_iteration_normalizer='QR'` instead."
+    )
+    with pytest.raises(ValueError, match=expected_msg):
+        with config_context(array_api_dispatch=True):
+            pca.fit(iris_xp)
+
+    pca.set_params(svd_solver="randomized", power_iteration_normalizer="auto")
+    expected_msg = re.escape(
+        "Array API does not support LU factorization, falling back to QR instead. Set"
+        " `power_iteration_normalizer='QR'` explicitly to silence this warning."
+    )
+    with pytest.warns(UserWarning, match=expected_msg):
+        with config_context(array_api_dispatch=True):
+            pca.fit(iris_xp)

venv/lib/python3.10/site-packages/sklearn/decomposition/tests/test_truncated_svd.py

@@ -0,0 +1,212 @@
+"""Test truncated SVD transformer."""
+
+import numpy as np
+import pytest
+import scipy.sparse as sp
+
+from sklearn.decomposition import PCA, TruncatedSVD
+from sklearn.utils import check_random_state
+from sklearn.utils._testing import assert_allclose, assert_array_less
+
+SVD_SOLVERS = ["arpack", "randomized"]
+
+
+@pytest.fixture(scope="module")
+def X_sparse():
+    # Make an X that looks somewhat like a small tf-idf matrix.
+    rng = check_random_state(42)
+    X = sp.random(60, 55, density=0.2, format="csr", random_state=rng)
+    X.data[:] = 1 + np.log(X.data)
+    return X
+
+
+@pytest.mark.parametrize("solver", ["randomized"])
+@pytest.mark.parametrize("kind", ("dense", "sparse"))
+def test_solvers(X_sparse, solver, kind):
+    X = X_sparse if kind == "sparse" else X_sparse.toarray()
+    svd_a = TruncatedSVD(30, algorithm="arpack")
+    svd = TruncatedSVD(30, algorithm=solver, random_state=42, n_oversamples=100)
+
+    Xa = svd_a.fit_transform(X)[:, :6]
+    Xr = svd.fit_transform(X)[:, :6]
+    assert_allclose(Xa, Xr, rtol=2e-3)
+
+    comp_a = np.abs(svd_a.components_)
+    comp = np.abs(svd.components_)
+    # All elements are equal, but some elements are more equal than others.
+    assert_allclose(comp_a[:9], comp[:9], rtol=1e-3)
+    assert_allclose(comp_a[9:], comp[9:], atol=1e-2)
+
+
+@pytest.mark.parametrize("n_components", (10, 25, 41, 55))
+def test_attributes(n_components, X_sparse):
+    n_features = X_sparse.shape[1]
+    tsvd = TruncatedSVD(n_components).fit(X_sparse)
+    assert tsvd.n_components == n_components
+    assert tsvd.components_.shape == (n_components, n_features)
+
+
+@pytest.mark.parametrize(
+    "algorithm, n_components",
+    [
+        ("arpack", 55),
+        ("arpack", 56),
+        ("randomized", 56),
+    ],
+)
+def test_too_many_components(X_sparse, algorithm, n_components):
+    tsvd = TruncatedSVD(n_components=n_components, algorithm=algorithm)
+    with pytest.raises(ValueError):
+        tsvd.fit(X_sparse)
+
+
+@pytest.mark.parametrize("fmt", ("array", "csr", "csc", "coo", "lil"))
+def test_sparse_formats(fmt, X_sparse):
+    n_samples = X_sparse.shape[0]
+    Xfmt = X_sparse.toarray() if fmt == "dense" else getattr(X_sparse, "to" + fmt)()
+    tsvd = TruncatedSVD(n_components=11)
+    Xtrans = tsvd.fit_transform(Xfmt)
+    assert Xtrans.shape == (n_samples, 11)
+    Xtrans = tsvd.transform(Xfmt)
+    assert Xtrans.shape == (n_samples, 11)
+
+
+@pytest.mark.parametrize("algo", SVD_SOLVERS)
+def test_inverse_transform(algo, X_sparse):
+    # We need a lot of components for the reconstruction to be "almost
+    # equal" in all positions. XXX Test means or sums instead?
+    tsvd = TruncatedSVD(n_components=52, random_state=42, algorithm=algo)
+    Xt = tsvd.fit_transform(X_sparse)
+    Xinv = tsvd.inverse_transform(Xt)
+    assert_allclose(Xinv, X_sparse.toarray(), rtol=1e-1, atol=2e-1)
+
+
+def test_integers(X_sparse):
+    n_samples = X_sparse.shape[0]
+    Xint = X_sparse.astype(np.int64)
+    tsvd = TruncatedSVD(n_components=6)
+    Xtrans = tsvd.fit_transform(Xint)
+    assert Xtrans.shape == (n_samples, tsvd.n_components)
+
+
+@pytest.mark.parametrize("kind", ("dense", "sparse"))
+@pytest.mark.parametrize("n_components", [10, 20])
+@pytest.mark.parametrize("solver", SVD_SOLVERS)
+def test_explained_variance(X_sparse, kind, n_components, solver):
+    X = X_sparse if kind == "sparse" else X_sparse.toarray()
+    svd = TruncatedSVD(n_components, algorithm=solver)
+    X_tr = svd.fit_transform(X)
+    # Assert that all the values are greater than 0
+    assert_array_less(0.0, svd.explained_variance_ratio_)
+
+    # Assert that total explained variance is less than 1
+    assert_array_less(svd.explained_variance_ratio_.sum(), 1.0)
+
+    # Test that explained_variance is correct
+    total_variance = np.var(X_sparse.toarray(), axis=0).sum()
+    variances = np.var(X_tr, axis=0)
+    true_explained_variance_ratio = variances / total_variance
+
+    assert_allclose(
+        svd.explained_variance_ratio_,
+        true_explained_variance_ratio,
+    )
+
+
+@pytest.mark.parametrize("kind", ("dense", "sparse"))
+@pytest.mark.parametrize("solver", SVD_SOLVERS)
+def test_explained_variance_components_10_20(X_sparse, kind, solver):
+    X = X_sparse if kind == "sparse" else X_sparse.toarray()
+    svd_10 = TruncatedSVD(10, algorithm=solver, n_iter=10).fit(X)
+    svd_20 = TruncatedSVD(20, algorithm=solver, n_iter=10).fit(X)
+
+    # Assert the 1st component is equal
+    assert_allclose(
+        svd_10.explained_variance_ratio_,
+        svd_20.explained_variance_ratio_[:10],
+        rtol=5e-3,
+    )
+
+    # Assert that 20 components has higher explained variance than 10
+    assert (
+        svd_20.explained_variance_ratio_.sum() > svd_10.explained_variance_ratio_.sum()
+    )
+
+
+@pytest.mark.parametrize("solver", SVD_SOLVERS)
+def test_singular_values_consistency(solver):
+    # Check that the TruncatedSVD output has the correct singular values
+    rng = np.random.RandomState(0)
+    n_samples, n_features = 100, 80
+    X = rng.randn(n_samples, n_features)
+
+    pca = TruncatedSVD(n_components=2, algorithm=solver, random_state=rng).fit(X)
+
+    # Compare to the Frobenius norm
+    X_pca = pca.transform(X)
+    assert_allclose(
+        np.sum(pca.singular_values_**2.0),
+        np.linalg.norm(X_pca, "fro") ** 2.0,
+        rtol=1e-2,
+    )
+
+    # Compare to the 2-norms of the score vectors
+    assert_allclose(
+        pca.singular_values_, np.sqrt(np.sum(X_pca**2.0, axis=0)), rtol=1e-2
+    )
+
+
+@pytest.mark.parametrize("solver", SVD_SOLVERS)
+def test_singular_values_expected(solver):
+    # Set the singular values and see what we get back
+    rng = np.random.RandomState(0)
+    n_samples = 100
+    n_features = 110
+
+    X = rng.randn(n_samples, n_features)
+
+    pca = TruncatedSVD(n_components=3, algorithm=solver, random_state=rng)
+    X_pca = pca.fit_transform(X)
+
+    X_pca /= np.sqrt(np.sum(X_pca**2.0, axis=0))
+    X_pca[:, 0] *= 3.142
+    X_pca[:, 1] *= 2.718
+
+    X_hat_pca = np.dot(X_pca, pca.components_)
+    pca.fit(X_hat_pca)
+    assert_allclose(pca.singular_values_, [3.142, 2.718, 1.0], rtol=1e-14)
+
+
+def test_truncated_svd_eq_pca(X_sparse):
+    # TruncatedSVD should be equal to PCA on centered data
+
+    X_dense = X_sparse.toarray()
+
+    X_c = X_dense - X_dense.mean(axis=0)
+
+    params = dict(n_components=10, random_state=42)
+
+    svd = TruncatedSVD(algorithm="arpack", **params)
+    pca = PCA(svd_solver="arpack", **params)
+
+    Xt_svd = svd.fit_transform(X_c)
+    Xt_pca = pca.fit_transform(X_c)
+
+    assert_allclose(Xt_svd, Xt_pca, rtol=1e-9)
+    assert_allclose(pca.mean_, 0, atol=1e-9)
+    assert_allclose(svd.components_, pca.components_)
+
+
+@pytest.mark.parametrize(
+    "algorithm, tol", [("randomized", 0.0), ("arpack", 1e-6), ("arpack", 0.0)]
+)
+@pytest.mark.parametrize("kind", ("dense", "sparse"))
+def test_fit_transform(X_sparse, algorithm, tol, kind):
+    # fit_transform(X) should equal fit(X).transform(X)
+    X = X_sparse if kind == "sparse" else X_sparse.toarray()
+    svd = TruncatedSVD(
+        n_components=5, n_iter=7, random_state=42, algorithm=algorithm, tol=tol
+    )
+    X_transformed_1 = svd.fit_transform(X)
+    X_transformed_2 = svd.fit(X).transform(X)
+    assert_allclose(X_transformed_1, X_transformed_2)

venv/lib/python3.10/site-packages/sklearn/ensemble/__init__.py

@@ -0,0 +1,44 @@
+"""
+The :mod:`sklearn.ensemble` module includes ensemble-based methods for
+classification, regression and anomaly detection.
+"""
+from ._bagging import BaggingClassifier, BaggingRegressor
+from ._base import BaseEnsemble
+from ._forest import (
+    ExtraTreesClassifier,
+    ExtraTreesRegressor,
+    RandomForestClassifier,
+    RandomForestRegressor,
+    RandomTreesEmbedding,
+)
+from ._gb import GradientBoostingClassifier, GradientBoostingRegressor
+from ._hist_gradient_boosting.gradient_boosting import (
+    HistGradientBoostingClassifier,
+    HistGradientBoostingRegressor,
+)
+from ._iforest import IsolationForest
+from ._stacking import StackingClassifier, StackingRegressor
+from ._voting import VotingClassifier, VotingRegressor
+from ._weight_boosting import AdaBoostClassifier, AdaBoostRegressor
+
+__all__ = [
+    "BaseEnsemble",
+    "RandomForestClassifier",
+    "RandomForestRegressor",
+    "RandomTreesEmbedding",
+    "ExtraTreesClassifier",
+    "ExtraTreesRegressor",
+    "BaggingClassifier",
+    "BaggingRegressor",
+    "IsolationForest",
+    "GradientBoostingClassifier",
+    "GradientBoostingRegressor",
+    "AdaBoostClassifier",
+    "AdaBoostRegressor",
+    "VotingClassifier",
+    "VotingRegressor",
+    "StackingClassifier",
+    "StackingRegressor",
+    "HistGradientBoostingClassifier",
+    "HistGradientBoostingRegressor",
+]

venv/lib/python3.10/site-packages/sklearn/ensemble/_bagging.py

@@ -0,0 +1,1242 @@
+"""Bagging meta-estimator."""
+
+# Author: Gilles Louppe <[email protected]>
+# License: BSD 3 clause
+
+
+import itertools
+import numbers
+from abc import ABCMeta, abstractmethod
+from functools import partial
+from numbers import Integral
+from warnings import warn
+
+import numpy as np
+
+from ..base import ClassifierMixin, RegressorMixin, _fit_context
+from ..metrics import accuracy_score, r2_score
+from ..tree import DecisionTreeClassifier, DecisionTreeRegressor
+from ..utils import check_random_state, column_or_1d, indices_to_mask
+from ..utils._param_validation import HasMethods, Interval, RealNotInt
+from ..utils._tags import _safe_tags
+from ..utils.metadata_routing import (
+    _raise_for_unsupported_routing,
+    _RoutingNotSupportedMixin,
+)
+from ..utils.metaestimators import available_if
+from ..utils.multiclass import check_classification_targets
+from ..utils.parallel import Parallel, delayed
+from ..utils.random import sample_without_replacement
+from ..utils.validation import _check_sample_weight, check_is_fitted, has_fit_parameter
+from ._base import BaseEnsemble, _partition_estimators
+
+__all__ = ["BaggingClassifier", "BaggingRegressor"]
+
+MAX_INT = np.iinfo(np.int32).max
+
+
+def _generate_indices(random_state, bootstrap, n_population, n_samples):
+    """Draw randomly sampled indices."""
+    # Draw sample indices
+    if bootstrap:
+        indices = random_state.randint(0, n_population, n_samples)
+    else:
+        indices = sample_without_replacement(
+            n_population, n_samples, random_state=random_state
+        )
+
+    return indices
+
+
+def _generate_bagging_indices(
+    random_state,
+    bootstrap_features,
+    bootstrap_samples,
+    n_features,
+    n_samples,
+    max_features,
+    max_samples,
+):
+    """Randomly draw feature and sample indices."""
+    # Get valid random state
+    random_state = check_random_state(random_state)
+
+    # Draw indices
+    feature_indices = _generate_indices(
+        random_state, bootstrap_features, n_features, max_features
+    )
+    sample_indices = _generate_indices(
+        random_state, bootstrap_samples, n_samples, max_samples
+    )
+
+    return feature_indices, sample_indices
+
+
+def _parallel_build_estimators(
+    n_estimators,
+    ensemble,
+    X,
+    y,
+    sample_weight,
+    seeds,
+    total_n_estimators,
+    verbose,
+    check_input,
+):
+    """Private function used to build a batch of estimators within a job."""
+    # Retrieve settings
+    n_samples, n_features = X.shape
+    max_features = ensemble._max_features
+    max_samples = ensemble._max_samples
+    bootstrap = ensemble.bootstrap
+    bootstrap_features = ensemble.bootstrap_features
+    support_sample_weight = has_fit_parameter(ensemble.estimator_, "sample_weight")
+    has_check_input = has_fit_parameter(ensemble.estimator_, "check_input")
+    requires_feature_indexing = bootstrap_features or max_features != n_features
+
+    if not support_sample_weight and sample_weight is not None:
+        raise ValueError("The base estimator doesn't support sample weight")
+
+    # Build estimators
+    estimators = []
+    estimators_features = []
+
+    for i in range(n_estimators):
+        if verbose > 1:
+            print(
+                "Building estimator %d of %d for this parallel run (total %d)..."
+                % (i + 1, n_estimators, total_n_estimators)
+            )
+
+        random_state = seeds[i]
+        estimator = ensemble._make_estimator(append=False, random_state=random_state)
+
+        if has_check_input:
+            estimator_fit = partial(estimator.fit, check_input=check_input)
+        else:
+            estimator_fit = estimator.fit
+
+        # Draw random feature, sample indices
+        features, indices = _generate_bagging_indices(
+            random_state,
+            bootstrap_features,
+            bootstrap,
+            n_features,
+            n_samples,
+            max_features,
+            max_samples,
+        )
+
+        # Draw samples, using sample weights, and then fit
+        if support_sample_weight:
+            if sample_weight is None:
+                curr_sample_weight = np.ones((n_samples,))
+            else:
+                curr_sample_weight = sample_weight.copy()
+
+            if bootstrap:
+                sample_counts = np.bincount(indices, minlength=n_samples)
+                curr_sample_weight *= sample_counts
+            else:
+                not_indices_mask = ~indices_to_mask(indices, n_samples)
+                curr_sample_weight[not_indices_mask] = 0
+
+            X_ = X[:, features] if requires_feature_indexing else X
+            estimator_fit(X_, y, sample_weight=curr_sample_weight)
+        else:
+            X_ = X[indices][:, features] if requires_feature_indexing else X[indices]
+            estimator_fit(X_, y[indices])
+
+        estimators.append(estimator)
+        estimators_features.append(features)
+
+    return estimators, estimators_features
+
+
+def _parallel_predict_proba(estimators, estimators_features, X, n_classes):
+    """Private function used to compute (proba-)predictions within a job."""
+    n_samples = X.shape[0]
+    proba = np.zeros((n_samples, n_classes))
+
+    for estimator, features in zip(estimators, estimators_features):
+        if hasattr(estimator, "predict_proba"):
+            proba_estimator = estimator.predict_proba(X[:, features])
+
+            if n_classes == len(estimator.classes_):
+                proba += proba_estimator
+
+            else:
+                proba[:, estimator.classes_] += proba_estimator[
+                    :, range(len(estimator.classes_))
+                ]
+
+        else:
+            # Resort to voting
+            predictions = estimator.predict(X[:, features])
+
+            for i in range(n_samples):
+                proba[i, predictions[i]] += 1
+
+    return proba
+
+
+def _parallel_predict_log_proba(estimators, estimators_features, X, n_classes):
+    """Private function used to compute log probabilities within a job."""
+    n_samples = X.shape[0]
+    log_proba = np.empty((n_samples, n_classes))
+    log_proba.fill(-np.inf)
+    all_classes = np.arange(n_classes, dtype=int)
+
+    for estimator, features in zip(estimators, estimators_features):
+        log_proba_estimator = estimator.predict_log_proba(X[:, features])
+
+        if n_classes == len(estimator.classes_):
+            log_proba = np.logaddexp(log_proba, log_proba_estimator)
+
+        else:
+            log_proba[:, estimator.classes_] = np.logaddexp(
+                log_proba[:, estimator.classes_],
+                log_proba_estimator[:, range(len(estimator.classes_))],
+            )
+
+            missing = np.setdiff1d(all_classes, estimator.classes_)
+            log_proba[:, missing] = np.logaddexp(log_proba[:, missing], -np.inf)
+
+    return log_proba
+
+
+def _parallel_decision_function(estimators, estimators_features, X):
+    """Private function used to compute decisions within a job."""
+    return sum(
+        estimator.decision_function(X[:, features])
+        for estimator, features in zip(estimators, estimators_features)
+    )
+
+
+def _parallel_predict_regression(estimators, estimators_features, X):
+    """Private function used to compute predictions within a job."""
+    return sum(
+        estimator.predict(X[:, features])
+        for estimator, features in zip(estimators, estimators_features)
+    )
+
+
+def _estimator_has(attr):
+    """Check if we can delegate a method to the underlying estimator.
+
+    First, we check the first fitted estimator if available, otherwise we
+    check the estimator attribute.
+    """
+
+    def check(self):
+        if hasattr(self, "estimators_"):
+            return hasattr(self.estimators_[0], attr)
+        else:  # self.estimator is not None
+            return hasattr(self.estimator, attr)
+
+    return check
+
+
+class BaseBagging(BaseEnsemble, metaclass=ABCMeta):
+    """Base class for Bagging meta-estimator.
+
+    Warning: This class should not be used directly. Use derived classes
+    instead.
+    """
+
+    _parameter_constraints: dict = {
+        "estimator": [HasMethods(["fit", "predict"]), None],
+        "n_estimators": [Interval(Integral, 1, None, closed="left")],
+        "max_samples": [
+            Interval(Integral, 1, None, closed="left"),
+            Interval(RealNotInt, 0, 1, closed="right"),
+        ],
+        "max_features": [
+            Interval(Integral, 1, None, closed="left"),
+            Interval(RealNotInt, 0, 1, closed="right"),
+        ],
+        "bootstrap": ["boolean"],
+        "bootstrap_features": ["boolean"],
+        "oob_score": ["boolean"],
+        "warm_start": ["boolean"],
+        "n_jobs": [None, Integral],
+        "random_state": ["random_state"],
+        "verbose": ["verbose"],
+    }
+
+    @abstractmethod
+    def __init__(
+        self,
+        estimator=None,
+        n_estimators=10,
+        *,
+        max_samples=1.0,
+        max_features=1.0,
+        bootstrap=True,
+        bootstrap_features=False,
+        oob_score=False,
+        warm_start=False,
+        n_jobs=None,
+        random_state=None,
+        verbose=0,
+    ):
+        super().__init__(
+            estimator=estimator,
+            n_estimators=n_estimators,
+        )
+        self.max_samples = max_samples
+        self.max_features = max_features
+        self.bootstrap = bootstrap
+        self.bootstrap_features = bootstrap_features
+        self.oob_score = oob_score
+        self.warm_start = warm_start
+        self.n_jobs = n_jobs
+        self.random_state = random_state
+        self.verbose = verbose
+
+    @_fit_context(
+        # BaseBagging.estimator is not validated yet
+        prefer_skip_nested_validation=False
+    )
+    def fit(self, X, y, sample_weight=None):
+        """Build a Bagging ensemble of estimators from the training set (X, y).
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            The training input samples. Sparse matrices are accepted only if
+            they are supported by the base estimator.
+
+        y : array-like of shape (n_samples,)
+            The target values (class labels in classification, real numbers in
+            regression).
+
+        sample_weight : array-like of shape (n_samples,), default=None
+            Sample weights. If None, then samples are equally weighted.
+            Note that this is supported only if the base estimator supports
+            sample weighting.
+
+        Returns
+        -------
+        self : object
+            Fitted estimator.
+        """
+        _raise_for_unsupported_routing(self, "fit", sample_weight=sample_weight)
+        # Convert data (X is required to be 2d and indexable)
+        X, y = self._validate_data(
+            X,
+            y,
+            accept_sparse=["csr", "csc"],
+            dtype=None,
+            force_all_finite=False,
+            multi_output=True,
+        )
+        return self._fit(X, y, self.max_samples, sample_weight=sample_weight)
+
+    def _parallel_args(self):
+        return {}
+
+    def _fit(
+        self,
+        X,
+        y,
+        max_samples=None,
+        max_depth=None,
+        sample_weight=None,
+        check_input=True,
+    ):
+        """Build a Bagging ensemble of estimators from the training
+           set (X, y).
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            The training input samples. Sparse matrices are accepted only if
+            they are supported by the base estimator.
+
+        y : array-like of shape (n_samples,)
+            The target values (class labels in classification, real numbers in
+            regression).
+
+        max_samples : int or float, default=None
+            Argument to use instead of self.max_samples.
+
+        max_depth : int, default=None
+            Override value used when constructing base estimator. Only
+            supported if the base estimator has a max_depth parameter.
+
+        sample_weight : array-like of shape (n_samples,), default=None
+            Sample weights. If None, then samples are equally weighted.
+            Note that this is supported only if the base estimator supports
+            sample weighting.
+
+        check_input : bool, default=True
+            Override value used when fitting base estimator. Only supported
+            if the base estimator has a check_input parameter for fit function.
+
+        Returns
+        -------
+        self : object
+            Fitted estimator.
+        """
+        random_state = check_random_state(self.random_state)
+
+        if sample_weight is not None:
+            sample_weight = _check_sample_weight(sample_weight, X, dtype=None)
+
+        # Remap output
+        n_samples = X.shape[0]
+        self._n_samples = n_samples
+        y = self._validate_y(y)
+
+        # Check parameters
+        self._validate_estimator()
+
+        if max_depth is not None:
+            self.estimator_.max_depth = max_depth
+
+        # Validate max_samples
+        if max_samples is None:
+            max_samples = self.max_samples
+        elif not isinstance(max_samples, numbers.Integral):
+            max_samples = int(max_samples * X.shape[0])
+
+        if max_samples > X.shape[0]:
+            raise ValueError("max_samples must be <= n_samples")
+
+        # Store validated integer row sampling value
+        self._max_samples = max_samples
+
+        # Validate max_features
+        if isinstance(self.max_features, numbers.Integral):
+            max_features = self.max_features
+        elif isinstance(self.max_features, float):
+            max_features = int(self.max_features * self.n_features_in_)
+
+        if max_features > self.n_features_in_:
+            raise ValueError("max_features must be <= n_features")
+
+        max_features = max(1, int(max_features))
+
+        # Store validated integer feature sampling value
+        self._max_features = max_features
+
+        # Other checks
+        if not self.bootstrap and self.oob_score:
+            raise ValueError("Out of bag estimation only available if bootstrap=True")
+
+        if self.warm_start and self.oob_score:
+            raise ValueError("Out of bag estimate only available if warm_start=False")
+
+        if hasattr(self, "oob_score_") and self.warm_start:
+            del self.oob_score_
+
+        if not self.warm_start or not hasattr(self, "estimators_"):
+            # Free allocated memory, if any
+            self.estimators_ = []
+            self.estimators_features_ = []
+
+        n_more_estimators = self.n_estimators - len(self.estimators_)
+
+        if n_more_estimators < 0:
+            raise ValueError(
+                "n_estimators=%d must be larger or equal to "
+                "len(estimators_)=%d when warm_start==True"
+                % (self.n_estimators, len(self.estimators_))
+            )
+
+        elif n_more_estimators == 0:
+            warn(
+                "Warm-start fitting without increasing n_estimators does not "
+                "fit new trees."
+            )
+            return self
+
+        # Parallel loop
+        n_jobs, n_estimators, starts = _partition_estimators(
+            n_more_estimators, self.n_jobs
+        )
+        total_n_estimators = sum(n_estimators)
+
+        # Advance random state to state after training
+        # the first n_estimators
+        if self.warm_start and len(self.estimators_) > 0:
+            random_state.randint(MAX_INT, size=len(self.estimators_))
+
+        seeds = random_state.randint(MAX_INT, size=n_more_estimators)
+        self._seeds = seeds
+
+        all_results = Parallel(
+            n_jobs=n_jobs, verbose=self.verbose, **self._parallel_args()
+        )(
+            delayed(_parallel_build_estimators)(
+                n_estimators[i],
+                self,
+                X,
+                y,
+                sample_weight,
+                seeds[starts[i] : starts[i + 1]],
+                total_n_estimators,
+                verbose=self.verbose,
+                check_input=check_input,
+            )
+            for i in range(n_jobs)
+        )
+
+        # Reduce
+        self.estimators_ += list(
+            itertools.chain.from_iterable(t[0] for t in all_results)
+        )
+        self.estimators_features_ += list(
+            itertools.chain.from_iterable(t[1] for t in all_results)
+        )
+
+        if self.oob_score:
+            self._set_oob_score(X, y)
+
+        return self
+
+    @abstractmethod
+    def _set_oob_score(self, X, y):
+        """Calculate out of bag predictions and score."""
+
+    def _validate_y(self, y):
+        if len(y.shape) == 1 or y.shape[1] == 1:
+            return column_or_1d(y, warn=True)
+        return y
+
+    def _get_estimators_indices(self):
+        # Get drawn indices along both sample and feature axes
+        for seed in self._seeds:
+            # Operations accessing random_state must be performed identically
+            # to those in `_parallel_build_estimators()`
+            feature_indices, sample_indices = _generate_bagging_indices(
+                seed,
+                self.bootstrap_features,
+                self.bootstrap,
+                self.n_features_in_,
+                self._n_samples,
+                self._max_features,
+                self._max_samples,
+            )
+
+            yield feature_indices, sample_indices
+
+    @property
+    def estimators_samples_(self):
+        """
+        The subset of drawn samples for each base estimator.
+
+        Returns a dynamically generated list of indices identifying
+        the samples used for fitting each member of the ensemble, i.e.,
+        the in-bag samples.
+
+        Note: the list is re-created at each call to the property in order
+        to reduce the object memory footprint by not storing the sampling
+        data. Thus fetching the property may be slower than expected.
+        """
+        return [sample_indices for _, sample_indices in self._get_estimators_indices()]
+
+
+class BaggingClassifier(_RoutingNotSupportedMixin, ClassifierMixin, BaseBagging):
+    """A Bagging classifier.
+
+    A Bagging classifier is an ensemble meta-estimator that fits base
+    classifiers each on random subsets of the original dataset and then
+    aggregate their individual predictions (either by voting or by averaging)
+    to form a final prediction. Such a meta-estimator can typically be used as
+    a way to reduce the variance of a black-box estimator (e.g., a decision
+    tree), by introducing randomization into its construction procedure and
+    then making an ensemble out of it.
+
+    This algorithm encompasses several works from the literature. When random
+    subsets of the dataset are drawn as random subsets of the samples, then
+    this algorithm is known as Pasting [1]_. If samples are drawn with
+    replacement, then the method is known as Bagging [2]_. When random subsets
+    of the dataset are drawn as random subsets of the features, then the method
+    is known as Random Subspaces [3]_. Finally, when base estimators are built
+    on subsets of both samples and features, then the method is known as
+    Random Patches [4]_.
+
+    Read more in the :ref:`User Guide <bagging>`.
+
+    .. versionadded:: 0.15
+
+    Parameters
+    ----------
+    estimator : object, default=None
+        The base estimator to fit on random subsets of the dataset.
+        If None, then the base estimator is a
+        :class:`~sklearn.tree.DecisionTreeClassifier`.
+
+        .. versionadded:: 1.2
+           `base_estimator` was renamed to `estimator`.
+
+    n_estimators : int, default=10
+        The number of base estimators in the ensemble.
+
+    max_samples : int or float, default=1.0
+        The number of samples to draw from X to train each base estimator (with
+        replacement by default, see `bootstrap` for more details).
+
+        - If int, then draw `max_samples` samples.
+        - If float, then draw `max_samples * X.shape[0]` samples.
+
+    max_features : int or float, default=1.0
+        The number of features to draw from X to train each base estimator (
+        without replacement by default, see `bootstrap_features` for more
+        details).
+
+        - If int, then draw `max_features` features.
+        - If float, then draw `max(1, int(max_features * n_features_in_))` features.
+
+    bootstrap : bool, default=True
+        Whether samples are drawn with replacement. If False, sampling
+        without replacement is performed.
+
+    bootstrap_features : bool, default=False
+        Whether features are drawn with replacement.
+
+    oob_score : bool, default=False
+        Whether to use out-of-bag samples to estimate
+        the generalization error. Only available if bootstrap=True.
+
+    warm_start : bool, default=False
+        When set to True, reuse the solution of the previous call to fit
+        and add more estimators to the ensemble, otherwise, just fit
+        a whole new ensemble. See :term:`the Glossary <warm_start>`.
+
+        .. versionadded:: 0.17
+           *warm_start* constructor parameter.
+
+    n_jobs : int, default=None
+        The number of jobs to run in parallel for both :meth:`fit` and
+        :meth:`predict`. ``None`` means 1 unless in a
+        :obj:`joblib.parallel_backend` context. ``-1`` means using all
+        processors. See :term:`Glossary <n_jobs>` for more details.
+
+    random_state : int, RandomState instance or None, default=None
+        Controls the random resampling of the original dataset
+        (sample wise and feature wise).
+        If the base estimator accepts a `random_state` attribute, a different
+        seed is generated for each instance in the ensemble.
+        Pass an int for reproducible output across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    verbose : int, default=0
+        Controls the verbosity when fitting and predicting.
+
+    Attributes
+    ----------
+    estimator_ : estimator
+        The base estimator from which the ensemble is grown.
+
+        .. versionadded:: 1.2
+           `base_estimator_` was renamed to `estimator_`.
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    estimators_ : list of estimators
+        The collection of fitted base estimators.
+
+    estimators_samples_ : list of arrays
+        The subset of drawn samples (i.e., the in-bag samples) for each base
+        estimator. Each subset is defined by an array of the indices selected.
+
+    estimators_features_ : list of arrays
+        The subset of drawn features for each base estimator.
+
+    classes_ : ndarray of shape (n_classes,)
+        The classes labels.
+
+    n_classes_ : int or list
+        The number of classes.
+
+    oob_score_ : float
+        Score of the training dataset obtained using an out-of-bag estimate.
+        This attribute exists only when ``oob_score`` is True.
+
+    oob_decision_function_ : ndarray of shape (n_samples, n_classes)
+        Decision function computed with out-of-bag estimate on the training
+        set. If n_estimators is small it might be possible that a data point
+        was never left out during the bootstrap. In this case,
+        `oob_decision_function_` might contain NaN. This attribute exists
+        only when ``oob_score`` is True.
+
+    See Also
+    --------
+    BaggingRegressor : A Bagging regressor.
+
+    References
+    ----------
+
+    .. [1] L. Breiman, "Pasting small votes for classification in large
+           databases and on-line", Machine Learning, 36(1), 85-103, 1999.
+
+    .. [2] L. Breiman, "Bagging predictors", Machine Learning, 24(2), 123-140,
+           1996.
+
+    .. [3] T. Ho, "The random subspace method for constructing decision
+           forests", Pattern Analysis and Machine Intelligence, 20(8), 832-844,
+           1998.
+
+    .. [4] G. Louppe and P. Geurts, "Ensembles on Random Patches", Machine
+           Learning and Knowledge Discovery in Databases, 346-361, 2012.
+
+    Examples
+    --------
+    >>> from sklearn.svm import SVC
+    >>> from sklearn.ensemble import BaggingClassifier
+    >>> from sklearn.datasets import make_classification
+    >>> X, y = make_classification(n_samples=100, n_features=4,
+    ...                            n_informative=2, n_redundant=0,
+    ...                            random_state=0, shuffle=False)
+    >>> clf = BaggingClassifier(estimator=SVC(),
+    ...                         n_estimators=10, random_state=0).fit(X, y)
+    >>> clf.predict([[0, 0, 0, 0]])
+    array([1])
+    """
+
+    def __init__(
+        self,
+        estimator=None,
+        n_estimators=10,
+        *,
+        max_samples=1.0,
+        max_features=1.0,
+        bootstrap=True,
+        bootstrap_features=False,
+        oob_score=False,
+        warm_start=False,
+        n_jobs=None,
+        random_state=None,
+        verbose=0,
+    ):
+        super().__init__(
+            estimator=estimator,
+            n_estimators=n_estimators,
+            max_samples=max_samples,
+            max_features=max_features,
+            bootstrap=bootstrap,
+            bootstrap_features=bootstrap_features,
+            oob_score=oob_score,
+            warm_start=warm_start,
+            n_jobs=n_jobs,
+            random_state=random_state,
+            verbose=verbose,
+        )
+
+    def _validate_estimator(self):
+        """Check the estimator and set the estimator_ attribute."""
+        super()._validate_estimator(default=DecisionTreeClassifier())
+
+    def _set_oob_score(self, X, y):
+        n_samples = y.shape[0]
+        n_classes_ = self.n_classes_
+
+        predictions = np.zeros((n_samples, n_classes_))
+
+        for estimator, samples, features in zip(
+            self.estimators_, self.estimators_samples_, self.estimators_features_
+        ):
+            # Create mask for OOB samples
+            mask = ~indices_to_mask(samples, n_samples)
+
+            if hasattr(estimator, "predict_proba"):
+                predictions[mask, :] += estimator.predict_proba(
+                    (X[mask, :])[:, features]
+                )
+
+            else:
+                p = estimator.predict((X[mask, :])[:, features])
+                j = 0
+
+                for i in range(n_samples):
+                    if mask[i]:
+                        predictions[i, p[j]] += 1
+                        j += 1
+
+        if (predictions.sum(axis=1) == 0).any():
+            warn(
+                "Some inputs do not have OOB scores. "
+                "This probably means too few estimators were used "
+                "to compute any reliable oob estimates."
+            )
+
+        oob_decision_function = predictions / predictions.sum(axis=1)[:, np.newaxis]
+        oob_score = accuracy_score(y, np.argmax(predictions, axis=1))
+
+        self.oob_decision_function_ = oob_decision_function
+        self.oob_score_ = oob_score
+
+    def _validate_y(self, y):
+        y = column_or_1d(y, warn=True)
+        check_classification_targets(y)
+        self.classes_, y = np.unique(y, return_inverse=True)
+        self.n_classes_ = len(self.classes_)
+
+        return y
+
+    def predict(self, X):
+        """Predict class for X.
+
+        The predicted class of an input sample is computed as the class with
+        the highest mean predicted probability. If base estimators do not
+        implement a ``predict_proba`` method, then it resorts to voting.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            The training input samples. Sparse matrices are accepted only if
+            they are supported by the base estimator.
+
+        Returns
+        -------
+        y : ndarray of shape (n_samples,)
+            The predicted classes.
+        """
+        predicted_probabilitiy = self.predict_proba(X)
+        return self.classes_.take((np.argmax(predicted_probabilitiy, axis=1)), axis=0)
+
+    def predict_proba(self, X):
+        """Predict class probabilities for X.
+
+        The predicted class probabilities of an input sample is computed as
+        the mean predicted class probabilities of the base estimators in the
+        ensemble. If base estimators do not implement a ``predict_proba``
+        method, then it resorts to voting and the predicted class probabilities
+        of an input sample represents the proportion of estimators predicting
+        each class.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            The training input samples. Sparse matrices are accepted only if
+            they are supported by the base estimator.
+
+        Returns
+        -------
+        p : ndarray of shape (n_samples, n_classes)
+            The class probabilities of the input samples. The order of the
+            classes corresponds to that in the attribute :term:`classes_`.
+        """
+        check_is_fitted(self)
+        # Check data
+        X = self._validate_data(
+            X,
+            accept_sparse=["csr", "csc"],
+            dtype=None,
+            force_all_finite=False,
+            reset=False,
+        )
+
+        # Parallel loop
+        n_jobs, _, starts = _partition_estimators(self.n_estimators, self.n_jobs)
+
+        all_proba = Parallel(
+            n_jobs=n_jobs, verbose=self.verbose, **self._parallel_args()
+        )(
+            delayed(_parallel_predict_proba)(
+                self.estimators_[starts[i] : starts[i + 1]],
+                self.estimators_features_[starts[i] : starts[i + 1]],
+                X,
+                self.n_classes_,
+            )
+            for i in range(n_jobs)
+        )
+
+        # Reduce
+        proba = sum(all_proba) / self.n_estimators
+
+        return proba
+
+    def predict_log_proba(self, X):
+        """Predict class log-probabilities for X.
+
+        The predicted class log-probabilities of an input sample is computed as
+        the log of the mean predicted class probabilities of the base
+        estimators in the ensemble.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            The training input samples. Sparse matrices are accepted only if
+            they are supported by the base estimator.
+
+        Returns
+        -------
+        p : ndarray of shape (n_samples, n_classes)
+            The class log-probabilities of the input samples. The order of the
+            classes corresponds to that in the attribute :term:`classes_`.
+        """
+        check_is_fitted(self)
+        if hasattr(self.estimator_, "predict_log_proba"):
+            # Check data
+            X = self._validate_data(
+                X,
+                accept_sparse=["csr", "csc"],
+                dtype=None,
+                force_all_finite=False,
+                reset=False,
+            )
+
+            # Parallel loop
+            n_jobs, _, starts = _partition_estimators(self.n_estimators, self.n_jobs)
+
+            all_log_proba = Parallel(n_jobs=n_jobs, verbose=self.verbose)(
+                delayed(_parallel_predict_log_proba)(
+                    self.estimators_[starts[i] : starts[i + 1]],
+                    self.estimators_features_[starts[i] : starts[i + 1]],
+                    X,
+                    self.n_classes_,
+                )
+                for i in range(n_jobs)
+            )
+
+            # Reduce
+            log_proba = all_log_proba[0]
+
+            for j in range(1, len(all_log_proba)):
+                log_proba = np.logaddexp(log_proba, all_log_proba[j])
+
+            log_proba -= np.log(self.n_estimators)
+
+        else:
+            log_proba = np.log(self.predict_proba(X))
+
+        return log_proba
+
+    @available_if(_estimator_has("decision_function"))
+    def decision_function(self, X):
+        """Average of the decision functions of the base classifiers.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            The training input samples. Sparse matrices are accepted only if
+            they are supported by the base estimator.
+
+        Returns
+        -------
+        score : ndarray of shape (n_samples, k)
+            The decision function of the input samples. The columns correspond
+            to the classes in sorted order, as they appear in the attribute
+            ``classes_``. Regression and binary classification are special
+            cases with ``k == 1``, otherwise ``k==n_classes``.
+        """
+        check_is_fitted(self)
+
+        # Check data
+        X = self._validate_data(
+            X,
+            accept_sparse=["csr", "csc"],
+            dtype=None,
+            force_all_finite=False,
+            reset=False,
+        )
+
+        # Parallel loop
+        n_jobs, _, starts = _partition_estimators(self.n_estimators, self.n_jobs)
+
+        all_decisions = Parallel(n_jobs=n_jobs, verbose=self.verbose)(
+            delayed(_parallel_decision_function)(
+                self.estimators_[starts[i] : starts[i + 1]],
+                self.estimators_features_[starts[i] : starts[i + 1]],
+                X,
+            )
+            for i in range(n_jobs)
+        )
+
+        # Reduce
+        decisions = sum(all_decisions) / self.n_estimators
+
+        return decisions
+
+    def _more_tags(self):
+        if self.estimator is None:
+            estimator = DecisionTreeClassifier()
+        else:
+            estimator = self.estimator
+
+        return {"allow_nan": _safe_tags(estimator, "allow_nan")}
+
+
+class BaggingRegressor(_RoutingNotSupportedMixin, RegressorMixin, BaseBagging):
+    """A Bagging regressor.
+
+    A Bagging regressor is an ensemble meta-estimator that fits base
+    regressors each on random subsets of the original dataset and then
+    aggregate their individual predictions (either by voting or by averaging)
+    to form a final prediction. Such a meta-estimator can typically be used as
+    a way to reduce the variance of a black-box estimator (e.g., a decision
+    tree), by introducing randomization into its construction procedure and
+    then making an ensemble out of it.
+
+    This algorithm encompasses several works from the literature. When random
+    subsets of the dataset are drawn as random subsets of the samples, then
+    this algorithm is known as Pasting [1]_. If samples are drawn with
+    replacement, then the method is known as Bagging [2]_. When random subsets
+    of the dataset are drawn as random subsets of the features, then the method
+    is known as Random Subspaces [3]_. Finally, when base estimators are built
+    on subsets of both samples and features, then the method is known as
+    Random Patches [4]_.
+
+    Read more in the :ref:`User Guide <bagging>`.
+
+    .. versionadded:: 0.15
+
+    Parameters
+    ----------
+    estimator : object, default=None
+        The base estimator to fit on random subsets of the dataset.
+        If None, then the base estimator is a
+        :class:`~sklearn.tree.DecisionTreeRegressor`.
+
+        .. versionadded:: 1.2
+           `base_estimator` was renamed to `estimator`.
+
+    n_estimators : int, default=10
+        The number of base estimators in the ensemble.
+
+    max_samples : int or float, default=1.0
+        The number of samples to draw from X to train each base estimator (with
+        replacement by default, see `bootstrap` for more details).
+
+        - If int, then draw `max_samples` samples.
+        - If float, then draw `max_samples * X.shape[0]` samples.
+
+    max_features : int or float, default=1.0
+        The number of features to draw from X to train each base estimator (
+        without replacement by default, see `bootstrap_features` for more
+        details).
+
+        - If int, then draw `max_features` features.
+        - If float, then draw `max(1, int(max_features * n_features_in_))` features.
+
+    bootstrap : bool, default=True
+        Whether samples are drawn with replacement. If False, sampling
+        without replacement is performed.
+
+    bootstrap_features : bool, default=False
+        Whether features are drawn with replacement.
+
+    oob_score : bool, default=False
+        Whether to use out-of-bag samples to estimate
+        the generalization error. Only available if bootstrap=True.
+
+    warm_start : bool, default=False
+        When set to True, reuse the solution of the previous call to fit
+        and add more estimators to the ensemble, otherwise, just fit
+        a whole new ensemble. See :term:`the Glossary <warm_start>`.
+
+    n_jobs : int, default=None
+        The number of jobs to run in parallel for both :meth:`fit` and
+        :meth:`predict`. ``None`` means 1 unless in a
+        :obj:`joblib.parallel_backend` context. ``-1`` means using all
+        processors. See :term:`Glossary <n_jobs>` for more details.
+
+    random_state : int, RandomState instance or None, default=None
+        Controls the random resampling of the original dataset
+        (sample wise and feature wise).
+        If the base estimator accepts a `random_state` attribute, a different
+        seed is generated for each instance in the ensemble.
+        Pass an int for reproducible output across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    verbose : int, default=0
+        Controls the verbosity when fitting and predicting.
+
+    Attributes
+    ----------
+    estimator_ : estimator
+        The base estimator from which the ensemble is grown.
+
+        .. versionadded:: 1.2
+           `base_estimator_` was renamed to `estimator_`.
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    estimators_ : list of estimators
+        The collection of fitted sub-estimators.
+
+    estimators_samples_ : list of arrays
+        The subset of drawn samples (i.e., the in-bag samples) for each base
+        estimator. Each subset is defined by an array of the indices selected.
+
+    estimators_features_ : list of arrays
+        The subset of drawn features for each base estimator.
+
+    oob_score_ : float
+        Score of the training dataset obtained using an out-of-bag estimate.
+        This attribute exists only when ``oob_score`` is True.
+
+    oob_prediction_ : ndarray of shape (n_samples,)
+        Prediction computed with out-of-bag estimate on the training
+        set. If n_estimators is small it might be possible that a data point
+        was never left out during the bootstrap. In this case,
+        `oob_prediction_` might contain NaN. This attribute exists only
+        when ``oob_score`` is True.
+
+    See Also
+    --------
+    BaggingClassifier : A Bagging classifier.
+
+    References
+    ----------
+
+    .. [1] L. Breiman, "Pasting small votes for classification in large
+           databases and on-line", Machine Learning, 36(1), 85-103, 1999.
+
+    .. [2] L. Breiman, "Bagging predictors", Machine Learning, 24(2), 123-140,
+           1996.
+
+    .. [3] T. Ho, "The random subspace method for constructing decision
+           forests", Pattern Analysis and Machine Intelligence, 20(8), 832-844,
+           1998.
+
+    .. [4] G. Louppe and P. Geurts, "Ensembles on Random Patches", Machine
+           Learning and Knowledge Discovery in Databases, 346-361, 2012.
+
+    Examples
+    --------
+    >>> from sklearn.svm import SVR
+    >>> from sklearn.ensemble import BaggingRegressor
+    >>> from sklearn.datasets import make_regression
+    >>> X, y = make_regression(n_samples=100, n_features=4,
+    ...                        n_informative=2, n_targets=1,
+    ...                        random_state=0, shuffle=False)
+    >>> regr = BaggingRegressor(estimator=SVR(),
+    ...                         n_estimators=10, random_state=0).fit(X, y)
+    >>> regr.predict([[0, 0, 0, 0]])
+    array([-2.8720...])
+    """
+
+    def __init__(
+        self,
+        estimator=None,
+        n_estimators=10,
+        *,
+        max_samples=1.0,
+        max_features=1.0,
+        bootstrap=True,
+        bootstrap_features=False,
+        oob_score=False,
+        warm_start=False,
+        n_jobs=None,
+        random_state=None,
+        verbose=0,
+    ):
+        super().__init__(
+            estimator=estimator,
+            n_estimators=n_estimators,
+            max_samples=max_samples,
+            max_features=max_features,
+            bootstrap=bootstrap,
+            bootstrap_features=bootstrap_features,
+            oob_score=oob_score,
+            warm_start=warm_start,
+            n_jobs=n_jobs,
+            random_state=random_state,
+            verbose=verbose,
+        )
+
+    def predict(self, X):
+        """Predict regression target for X.
+
+        The predicted regression target of an input sample is computed as the
+        mean predicted regression targets of the estimators in the ensemble.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            The training input samples. Sparse matrices are accepted only if
+            they are supported by the base estimator.
+
+        Returns
+        -------
+        y : ndarray of shape (n_samples,)
+            The predicted values.
+        """
+        check_is_fitted(self)
+        # Check data
+        X = self._validate_data(
+            X,
+            accept_sparse=["csr", "csc"],
+            dtype=None,
+            force_all_finite=False,
+            reset=False,
+        )
+
+        # Parallel loop
+        n_jobs, _, starts = _partition_estimators(self.n_estimators, self.n_jobs)
+
+        all_y_hat = Parallel(n_jobs=n_jobs, verbose=self.verbose)(
+            delayed(_parallel_predict_regression)(
+                self.estimators_[starts[i] : starts[i + 1]],
+                self.estimators_features_[starts[i] : starts[i + 1]],
+                X,
+            )
+            for i in range(n_jobs)
+        )
+
+        # Reduce
+        y_hat = sum(all_y_hat) / self.n_estimators
+
+        return y_hat
+
+    def _validate_estimator(self):
+        """Check the estimator and set the estimator_ attribute."""
+        super()._validate_estimator(default=DecisionTreeRegressor())
+
+    def _set_oob_score(self, X, y):
+        n_samples = y.shape[0]
+
+        predictions = np.zeros((n_samples,))
+        n_predictions = np.zeros((n_samples,))
+
+        for estimator, samples, features in zip(
+            self.estimators_, self.estimators_samples_, self.estimators_features_
+        ):
+            # Create mask for OOB samples
+            mask = ~indices_to_mask(samples, n_samples)
+
+            predictions[mask] += estimator.predict((X[mask, :])[:, features])
+            n_predictions[mask] += 1
+
+        if (n_predictions == 0).any():
+            warn(
+                "Some inputs do not have OOB scores. "
+                "This probably means too few estimators were used "
+                "to compute any reliable oob estimates."
+            )
+            n_predictions[n_predictions == 0] = 1
+
+        predictions /= n_predictions
+
+        self.oob_prediction_ = predictions
+        self.oob_score_ = r2_score(y, predictions)
+
+    def _more_tags(self):
+        if self.estimator is None:
+            estimator = DecisionTreeRegressor()
+        else:
+            estimator = self.estimator
+        return {"allow_nan": _safe_tags(estimator, "allow_nan")}

venv/lib/python3.10/site-packages/sklearn/ensemble/_base.py

@@ -0,0 +1,301 @@
+"""Base class for ensemble-based estimators."""
+
+# Authors: Gilles Louppe
+# License: BSD 3 clause
+
+from abc import ABCMeta, abstractmethod
+from typing import List
+
+import numpy as np
+from joblib import effective_n_jobs
+
+from ..base import BaseEstimator, MetaEstimatorMixin, clone, is_classifier, is_regressor
+from ..utils import Bunch, _print_elapsed_time, check_random_state
+from ..utils._tags import _safe_tags
+from ..utils.metaestimators import _BaseComposition
+
+
+def _fit_single_estimator(
+    estimator, X, y, sample_weight=None, message_clsname=None, message=None
+):
+    """Private function used to fit an estimator within a job."""
+    if sample_weight is not None:
+        try:
+            with _print_elapsed_time(message_clsname, message):
+                estimator.fit(X, y, sample_weight=sample_weight)
+        except TypeError as exc:
+            if "unexpected keyword argument 'sample_weight'" in str(exc):
+                raise TypeError(
+                    "Underlying estimator {} does not support sample weights.".format(
+                        estimator.__class__.__name__
+                    )
+                ) from exc
+            raise
+    else:
+        with _print_elapsed_time(message_clsname, message):
+            estimator.fit(X, y)
+    return estimator
+
+
+def _set_random_states(estimator, random_state=None):
+    """Set fixed random_state parameters for an estimator.
+
+    Finds all parameters ending ``random_state`` and sets them to integers
+    derived from ``random_state``.
+
+    Parameters
+    ----------
+    estimator : estimator supporting get/set_params
+        Estimator with potential randomness managed by random_state
+        parameters.
+
+    random_state : int, RandomState instance or None, default=None
+        Pseudo-random number generator to control the generation of the random
+        integers. Pass an int for reproducible output across multiple function
+        calls.
+        See :term:`Glossary <random_state>`.
+
+    Notes
+    -----
+    This does not necessarily set *all* ``random_state`` attributes that
+    control an estimator's randomness, only those accessible through
+    ``estimator.get_params()``.  ``random_state``s not controlled include
+    those belonging to:
+
+        * cross-validation splitters
+        * ``scipy.stats`` rvs
+    """
+    random_state = check_random_state(random_state)
+    to_set = {}
+    for key in sorted(estimator.get_params(deep=True)):
+        if key == "random_state" or key.endswith("__random_state"):
+            to_set[key] = random_state.randint(np.iinfo(np.int32).max)
+
+    if to_set:
+        estimator.set_params(**to_set)
+
+
+class BaseEnsemble(MetaEstimatorMixin, BaseEstimator, metaclass=ABCMeta):
+    """Base class for all ensemble classes.
+
+    Warning: This class should not be used directly. Use derived classes
+    instead.
+
+    Parameters
+    ----------
+    estimator : object
+        The base estimator from which the ensemble is built.
+
+    n_estimators : int, default=10
+        The number of estimators in the ensemble.
+
+    estimator_params : list of str, default=tuple()
+        The list of attributes to use as parameters when instantiating a
+        new base estimator. If none are given, default parameters are used.
+
+    Attributes
+    ----------
+    estimator_ : estimator
+        The base estimator from which the ensemble is grown.
+
+    estimators_ : list of estimators
+        The collection of fitted base estimators.
+    """
+
+    # overwrite _required_parameters from MetaEstimatorMixin
+    _required_parameters: List[str] = []
+
+    @abstractmethod
+    def __init__(
+        self,
+        estimator=None,
+        *,
+        n_estimators=10,
+        estimator_params=tuple(),
+    ):
+        # Set parameters
+        self.estimator = estimator
+        self.n_estimators = n_estimators
+        self.estimator_params = estimator_params
+
+        # Don't instantiate estimators now! Parameters of estimator might
+        # still change. Eg., when grid-searching with the nested object syntax.
+        # self.estimators_ needs to be filled by the derived classes in fit.
+
+    def _validate_estimator(self, default=None):
+        """Check the base estimator.
+
+        Sets the `estimator_` attributes.
+        """
+        if self.estimator is not None:
+            self.estimator_ = self.estimator
+        else:
+            self.estimator_ = default
+
+    def _make_estimator(self, append=True, random_state=None):
+        """Make and configure a copy of the `estimator_` attribute.
+
+        Warning: This method should be used to properly instantiate new
+        sub-estimators.
+        """
+        estimator = clone(self.estimator_)
+        estimator.set_params(**{p: getattr(self, p) for p in self.estimator_params})
+
+        if random_state is not None:
+            _set_random_states(estimator, random_state)
+
+        if append:
+            self.estimators_.append(estimator)
+
+        return estimator
+
+    def __len__(self):
+        """Return the number of estimators in the ensemble."""
+        return len(self.estimators_)
+
+    def __getitem__(self, index):
+        """Return the index'th estimator in the ensemble."""
+        return self.estimators_[index]
+
+    def __iter__(self):
+        """Return iterator over estimators in the ensemble."""
+        return iter(self.estimators_)
+
+
+def _partition_estimators(n_estimators, n_jobs):
+    """Private function used to partition estimators between jobs."""
+    # Compute the number of jobs
+    n_jobs = min(effective_n_jobs(n_jobs), n_estimators)
+
+    # Partition estimators between jobs
+    n_estimators_per_job = np.full(n_jobs, n_estimators // n_jobs, dtype=int)
+    n_estimators_per_job[: n_estimators % n_jobs] += 1
+    starts = np.cumsum(n_estimators_per_job)
+
+    return n_jobs, n_estimators_per_job.tolist(), [0] + starts.tolist()
+
+
+class _BaseHeterogeneousEnsemble(
+    MetaEstimatorMixin, _BaseComposition, metaclass=ABCMeta
+):
+    """Base class for heterogeneous ensemble of learners.
+
+    Parameters
+    ----------
+    estimators : list of (str, estimator) tuples
+        The ensemble of estimators to use in the ensemble. Each element of the
+        list is defined as a tuple of string (i.e. name of the estimator) and
+        an estimator instance. An estimator can be set to `'drop'` using
+        `set_params`.
+
+    Attributes
+    ----------
+    estimators_ : list of estimators
+        The elements of the estimators parameter, having been fitted on the
+        training data. If an estimator has been set to `'drop'`, it will not
+        appear in `estimators_`.
+    """
+
+    _required_parameters = ["estimators"]
+
+    @property
+    def named_estimators(self):
+        """Dictionary to access any fitted sub-estimators by name.
+
+        Returns
+        -------
+        :class:`~sklearn.utils.Bunch`
+        """
+        return Bunch(**dict(self.estimators))
+
+    @abstractmethod
+    def __init__(self, estimators):
+        self.estimators = estimators
+
+    def _validate_estimators(self):
+        if len(self.estimators) == 0:
+            raise ValueError(
+                "Invalid 'estimators' attribute, 'estimators' should be a "
+                "non-empty list of (string, estimator) tuples."
+            )
+        names, estimators = zip(*self.estimators)
+        # defined by MetaEstimatorMixin
+        self._validate_names(names)
+
+        has_estimator = any(est != "drop" for est in estimators)
+        if not has_estimator:
+            raise ValueError(
+                "All estimators are dropped. At least one is required "
+                "to be an estimator."
+            )
+
+        is_estimator_type = is_classifier if is_classifier(self) else is_regressor
+
+        for est in estimators:
+            if est != "drop" and not is_estimator_type(est):
+                raise ValueError(
+                    "The estimator {} should be a {}.".format(
+                        est.__class__.__name__, is_estimator_type.__name__[3:]
+                    )
+                )
+
+        return names, estimators
+
+    def set_params(self, **params):
+        """
+        Set the parameters of an estimator from the ensemble.
+
+        Valid parameter keys can be listed with `get_params()`. Note that you
+        can directly set the parameters of the estimators contained in
+        `estimators`.
+
+        Parameters
+        ----------
+        **params : keyword arguments
+            Specific parameters using e.g.
+            `set_params(parameter_name=new_value)`. In addition, to setting the
+            parameters of the estimator, the individual estimator of the
+            estimators can also be set, or can be removed by setting them to
+            'drop'.
+
+        Returns
+        -------
+        self : object
+            Estimator instance.
+        """
+        super()._set_params("estimators", **params)
+        return self
+
+    def get_params(self, deep=True):
+        """
+        Get the parameters of an estimator from the ensemble.
+
+        Returns the parameters given in the constructor as well as the
+        estimators contained within the `estimators` parameter.
+
+        Parameters
+        ----------
+        deep : bool, default=True
+            Setting it to True gets the various estimators and the parameters
+            of the estimators as well.
+
+        Returns
+        -------
+        params : dict
+            Parameter and estimator names mapped to their values or parameter
+            names mapped to their values.
+        """
+        return super()._get_params("estimators", deep=deep)
+
+    def _more_tags(self):
+        try:
+            allow_nan = all(
+                _safe_tags(est[1])["allow_nan"] if est[1] != "drop" else True
+                for est in self.estimators
+            )
+        except Exception:
+            # If `estimators` does not comply with our API (list of tuples) then it will
+            # fail. In this case, we assume that `allow_nan` is False but the parameter
+            # validation will raise an error during `fit`.
+            allow_nan = False
+        return {"preserves_dtype": [], "allow_nan": allow_nan}

venv/lib/python3.10/site-packages/sklearn/ensemble/_gb.py

@@ -0,0 +1,2168 @@
+"""Gradient Boosted Regression Trees.
+
+This module contains methods for fitting gradient boosted regression trees for
+both classification and regression.
+
+The module structure is the following:
+
+- The ``BaseGradientBoosting`` base class implements a common ``fit`` method
+  for all the estimators in the module. Regression and classification
+  only differ in the concrete ``LossFunction`` used.
+
+- ``GradientBoostingClassifier`` implements gradient boosting for
+  classification problems.
+
+- ``GradientBoostingRegressor`` implements gradient boosting for
+  regression problems.
+"""
+
+# Authors: Peter Prettenhofer, Scott White, Gilles Louppe, Emanuele Olivetti,
+#          Arnaud Joly, Jacob Schreiber
+# License: BSD 3 clause
+
+import math
+import warnings
+from abc import ABCMeta, abstractmethod
+from numbers import Integral, Real
+from time import time
+
+import numpy as np
+from scipy.sparse import csc_matrix, csr_matrix, issparse
+
+from .._loss.loss import (
+    _LOSSES,
+    AbsoluteError,
+    ExponentialLoss,
+    HalfBinomialLoss,
+    HalfMultinomialLoss,
+    HalfSquaredError,
+    HuberLoss,
+    PinballLoss,
+)
+from ..base import ClassifierMixin, RegressorMixin, _fit_context, is_classifier
+from ..dummy import DummyClassifier, DummyRegressor
+from ..exceptions import NotFittedError
+from ..model_selection import train_test_split
+from ..preprocessing import LabelEncoder
+from ..tree import DecisionTreeRegressor
+from ..tree._tree import DOUBLE, DTYPE, TREE_LEAF
+from ..utils import check_array, check_random_state, column_or_1d
+from ..utils._param_validation import HasMethods, Interval, StrOptions
+from ..utils.multiclass import check_classification_targets
+from ..utils.stats import _weighted_percentile
+from ..utils.validation import _check_sample_weight, check_is_fitted
+from ._base import BaseEnsemble
+from ._gradient_boosting import _random_sample_mask, predict_stage, predict_stages
+
+_LOSSES = _LOSSES.copy()
+_LOSSES.update(
+    {
+        "quantile": PinballLoss,
+        "huber": HuberLoss,
+    }
+)
+
+
+def _safe_divide(numerator, denominator):
+    """Prevents overflow and division by zero."""
+    # This is used for classifiers where the denominator might become zero exatly.
+    # For instance for log loss, HalfBinomialLoss, if proba=0 or proba=1 exactly, then
+    # denominator = hessian = 0, and we should set the node value in the line search to
+    # zero as there is no improvement of the loss possible.
+    # For numerical safety, we do this already for extremely tiny values.
+    if abs(denominator) < 1e-150:
+        return 0.0
+    else:
+        # Cast to Python float to trigger Python errors, e.g. ZeroDivisionError,
+        # without relying on `np.errstate` that is not supported by Pyodide.
+        result = float(numerator) / float(denominator)
+        # Cast to Python float to trigger a ZeroDivisionError without relying
+        # on `np.errstate` that is not supported by Pyodide.
+        result = float(numerator) / float(denominator)
+        if math.isinf(result):
+            warnings.warn("overflow encountered in _safe_divide", RuntimeWarning)
+        return result
+
+
+def _init_raw_predictions(X, estimator, loss, use_predict_proba):
+    """Return the initial raw predictions.
+
+    Parameters
+    ----------
+    X : ndarray of shape (n_samples, n_features)
+        The data array.
+    estimator : object
+        The estimator to use to compute the predictions.
+    loss : BaseLoss
+        An instance of a loss function class.
+    use_predict_proba : bool
+        Whether estimator.predict_proba is used instead of estimator.predict.
+
+    Returns
+    -------
+    raw_predictions : ndarray of shape (n_samples, K)
+        The initial raw predictions. K is equal to 1 for binary
+        classification and regression, and equal to the number of classes
+        for multiclass classification. ``raw_predictions`` is casted
+        into float64.
+    """
+    # TODO: Use loss.fit_intercept_only where appropriate instead of
+    # DummyRegressor which is the default given by the `init` parameter,
+    # see also _init_state.
+    if use_predict_proba:
+        # Our parameter validation, set via _fit_context and _parameter_constraints
+        # already guarantees that estimator has a predict_proba method.
+        predictions = estimator.predict_proba(X)
+        if not loss.is_multiclass:
+            predictions = predictions[:, 1]  # probability of positive class
+        eps = np.finfo(np.float32).eps  # FIXME: This is quite large!
+        predictions = np.clip(predictions, eps, 1 - eps, dtype=np.float64)
+    else:
+        predictions = estimator.predict(X).astype(np.float64)
+
+    if predictions.ndim == 1:
+        return loss.link.link(predictions).reshape(-1, 1)
+    else:
+        return loss.link.link(predictions)
+
+
+def _update_terminal_regions(
+    loss,
+    tree,
+    X,
+    y,
+    neg_gradient,
+    raw_prediction,
+    sample_weight,
+    sample_mask,
+    learning_rate=0.1,
+    k=0,
+):
+    """Update the leaf values to be predicted by the tree and raw_prediction.
+
+    The current raw predictions of the model (of this stage) are updated.
+
+    Additionally, the terminal regions (=leaves) of the given tree are updated as well.
+    This corresponds to the line search step in "Greedy Function Approximation" by
+    Friedman, Algorithm 1 step 5.
+
+    Update equals:
+        argmin_{x} loss(y_true, raw_prediction_old + x * tree.value)
+
+    For non-trivial cases like the Binomial loss, the update has no closed formula and
+    is an approximation, again, see the Friedman paper.
+
+    Also note that the update formula for the SquaredError is the identity. Therefore,
+    in this case, the leaf values don't need an update and only the raw_predictions are
+    updated (with the learning rate included).
+
+    Parameters
+    ----------
+    loss : BaseLoss
+    tree : tree.Tree
+        The tree object.
+    X : ndarray of shape (n_samples, n_features)
+        The data array.
+    y : ndarray of shape (n_samples,)
+        The target labels.
+    neg_gradient : ndarray of shape (n_samples,)
+        The negative gradient.
+    raw_prediction : ndarray of shape (n_samples, n_trees_per_iteration)
+        The raw predictions (i.e. values from the tree leaves) of the
+        tree ensemble at iteration ``i - 1``.
+    sample_weight : ndarray of shape (n_samples,)
+        The weight of each sample.
+    sample_mask : ndarray of shape (n_samples,)
+        The sample mask to be used.
+    learning_rate : float, default=0.1
+        Learning rate shrinks the contribution of each tree by
+         ``learning_rate``.
+    k : int, default=0
+        The index of the estimator being updated.
+    """
+    # compute leaf for each sample in ``X``.
+    terminal_regions = tree.apply(X)
+
+    if not isinstance(loss, HalfSquaredError):
+        # mask all which are not in sample mask.
+        masked_terminal_regions = terminal_regions.copy()
+        masked_terminal_regions[~sample_mask] = -1
+
+        if isinstance(loss, HalfBinomialLoss):
+
+            def compute_update(y_, indices, neg_gradient, raw_prediction, k):
+                # Make a single Newton-Raphson step, see "Additive Logistic Regression:
+                # A Statistical View of Boosting" FHT00 and note that we use a slightly
+                # different version (factor 2) of "F" with proba=expit(raw_prediction).
+                # Our node estimate is given by:
+                #    sum(w * (y - prob)) / sum(w * prob * (1 - prob))
+                # we take advantage that: y - prob = neg_gradient
+                neg_g = neg_gradient.take(indices, axis=0)
+                prob = y_ - neg_g
+                # numerator = negative gradient = y - prob
+                numerator = np.average(neg_g, weights=sw)
+                # denominator = hessian = prob * (1 - prob)
+                denominator = np.average(prob * (1 - prob), weights=sw)
+                return _safe_divide(numerator, denominator)
+
+        elif isinstance(loss, HalfMultinomialLoss):
+
+            def compute_update(y_, indices, neg_gradient, raw_prediction, k):
+                # we take advantage that: y - prob = neg_gradient
+                neg_g = neg_gradient.take(indices, axis=0)
+                prob = y_ - neg_g
+                K = loss.n_classes
+                # numerator = negative gradient * (k - 1) / k
+                # Note: The factor (k - 1)/k appears in the original papers "Greedy
+                # Function Approximation" by Friedman and "Additive Logistic
+                # Regression" by Friedman, Hastie, Tibshirani. This factor is, however,
+                # wrong or at least arbitrary as it directly multiplies the
+                # learning_rate. We keep it for backward compatibility.
+                numerator = np.average(neg_g, weights=sw)
+                numerator *= (K - 1) / K
+                # denominator = (diagonal) hessian = prob * (1 - prob)
+                denominator = np.average(prob * (1 - prob), weights=sw)
+                return _safe_divide(numerator, denominator)
+
+        elif isinstance(loss, ExponentialLoss):
+
+            def compute_update(y_, indices, neg_gradient, raw_prediction, k):
+                neg_g = neg_gradient.take(indices, axis=0)
+                # numerator = negative gradient = y * exp(-raw) - (1-y) * exp(raw)
+                numerator = np.average(neg_g, weights=sw)
+                # denominator = hessian = y * exp(-raw) + (1-y) * exp(raw)
+                # if y=0: hessian = exp(raw) = -neg_g
+                #    y=1: hessian = exp(-raw) = neg_g
+                hessian = neg_g.copy()
+                hessian[y_ == 0] *= -1
+                denominator = np.average(hessian, weights=sw)
+                return _safe_divide(numerator, denominator)
+
+        else:
+
+            def compute_update(y_, indices, neg_gradient, raw_prediction, k):
+                return loss.fit_intercept_only(
+                    y_true=y_ - raw_prediction[indices, k],
+                    sample_weight=sw,
+                )
+
+        # update each leaf (= perform line search)
+        for leaf in np.nonzero(tree.children_left == TREE_LEAF)[0]:
+            indices = np.nonzero(masked_terminal_regions == leaf)[
+                0
+            ]  # of terminal regions
+            y_ = y.take(indices, axis=0)
+            sw = None if sample_weight is None else sample_weight[indices]
+            update = compute_update(y_, indices, neg_gradient, raw_prediction, k)
+
+            # TODO: Multiply here by learning rate instead of everywhere else.
+            tree.value[leaf, 0, 0] = update
+
+    # update predictions (both in-bag and out-of-bag)
+    raw_prediction[:, k] += learning_rate * tree.value[:, 0, 0].take(
+        terminal_regions, axis=0
+    )
+
+
+def set_huber_delta(loss, y_true, raw_prediction, sample_weight=None):
+    """Calculate and set self.closs.delta based on self.quantile."""
+    abserr = np.abs(y_true - raw_prediction.squeeze())
+    # sample_weight is always a ndarray, never None.
+    delta = _weighted_percentile(abserr, sample_weight, 100 * loss.quantile)
+    loss.closs.delta = float(delta)
+
+
+class VerboseReporter:
+    """Reports verbose output to stdout.
+
+    Parameters
+    ----------
+    verbose : int
+        Verbosity level. If ``verbose==1`` output is printed once in a while
+        (when iteration mod verbose_mod is zero).; if larger than 1 then output
+        is printed for each update.
+    """
+
+    def __init__(self, verbose):
+        self.verbose = verbose
+
+    def init(self, est, begin_at_stage=0):
+        """Initialize reporter
+
+        Parameters
+        ----------
+        est : Estimator
+            The estimator
+
+        begin_at_stage : int, default=0
+            stage at which to begin reporting
+        """
+        # header fields and line format str
+        header_fields = ["Iter", "Train Loss"]
+        verbose_fmt = ["{iter:>10d}", "{train_score:>16.4f}"]
+        # do oob?
+        if est.subsample < 1:
+            header_fields.append("OOB Improve")
+            verbose_fmt.append("{oob_impr:>16.4f}")
+        header_fields.append("Remaining Time")
+        verbose_fmt.append("{remaining_time:>16s}")
+
+        # print the header line
+        print(("%10s " + "%16s " * (len(header_fields) - 1)) % tuple(header_fields))
+
+        self.verbose_fmt = " ".join(verbose_fmt)
+        # plot verbose info each time i % verbose_mod == 0
+        self.verbose_mod = 1
+        self.start_time = time()
+        self.begin_at_stage = begin_at_stage
+
+    def update(self, j, est):
+        """Update reporter with new iteration.
+
+        Parameters
+        ----------
+        j : int
+            The new iteration.
+        est : Estimator
+            The estimator.
+        """
+        do_oob = est.subsample < 1
+        # we need to take into account if we fit additional estimators.
+        i = j - self.begin_at_stage  # iteration relative to the start iter
+        if (i + 1) % self.verbose_mod == 0:
+            oob_impr = est.oob_improvement_[j] if do_oob else 0
+            remaining_time = (
+                (est.n_estimators - (j + 1)) * (time() - self.start_time) / float(i + 1)
+            )
+            if remaining_time > 60:
+                remaining_time = "{0:.2f}m".format(remaining_time / 60.0)
+            else:
+                remaining_time = "{0:.2f}s".format(remaining_time)
+            print(
+                self.verbose_fmt.format(
+                    iter=j + 1,
+                    train_score=est.train_score_[j],
+                    oob_impr=oob_impr,
+                    remaining_time=remaining_time,
+                )
+            )
+            if self.verbose == 1 and ((i + 1) // (self.verbose_mod * 10) > 0):
+                # adjust verbose frequency (powers of 10)
+                self.verbose_mod *= 10
+
+
+class BaseGradientBoosting(BaseEnsemble, metaclass=ABCMeta):
+    """Abstract base class for Gradient Boosting."""
+
+    _parameter_constraints: dict = {
+        **DecisionTreeRegressor._parameter_constraints,
+        "learning_rate": [Interval(Real, 0.0, None, closed="left")],
+        "n_estimators": [Interval(Integral, 1, None, closed="left")],
+        "criterion": [StrOptions({"friedman_mse", "squared_error"})],
+        "subsample": [Interval(Real, 0.0, 1.0, closed="right")],
+        "verbose": ["verbose"],
+        "warm_start": ["boolean"],
+        "validation_fraction": [Interval(Real, 0.0, 1.0, closed="neither")],
+        "n_iter_no_change": [Interval(Integral, 1, None, closed="left"), None],
+        "tol": [Interval(Real, 0.0, None, closed="left")],
+    }
+    _parameter_constraints.pop("splitter")
+    _parameter_constraints.pop("monotonic_cst")
+
+    @abstractmethod
+    def __init__(
+        self,
+        *,
+        loss,
+        learning_rate,
+        n_estimators,
+        criterion,
+        min_samples_split,
+        min_samples_leaf,
+        min_weight_fraction_leaf,
+        max_depth,
+        min_impurity_decrease,
+        init,
+        subsample,
+        max_features,
+        ccp_alpha,
+        random_state,
+        alpha=0.9,
+        verbose=0,
+        max_leaf_nodes=None,
+        warm_start=False,
+        validation_fraction=0.1,
+        n_iter_no_change=None,
+        tol=1e-4,
+    ):
+        self.n_estimators = n_estimators
+        self.learning_rate = learning_rate
+        self.loss = loss
+        self.criterion = criterion
+        self.min_samples_split = min_samples_split
+        self.min_samples_leaf = min_samples_leaf
+        self.min_weight_fraction_leaf = min_weight_fraction_leaf
+        self.subsample = subsample
+        self.max_features = max_features
+        self.max_depth = max_depth
+        self.min_impurity_decrease = min_impurity_decrease
+        self.ccp_alpha = ccp_alpha
+        self.init = init
+        self.random_state = random_state
+        self.alpha = alpha
+        self.verbose = verbose
+        self.max_leaf_nodes = max_leaf_nodes
+        self.warm_start = warm_start
+        self.validation_fraction = validation_fraction
+        self.n_iter_no_change = n_iter_no_change
+        self.tol = tol
+
+    @abstractmethod
+    def _encode_y(self, y=None, sample_weight=None):
+        """Called by fit to validate and encode y."""
+
+    @abstractmethod
+    def _get_loss(self, sample_weight):
+        """Get loss object from sklearn._loss.loss."""
+
+    def _fit_stage(
+        self,
+        i,
+        X,
+        y,
+        raw_predictions,
+        sample_weight,
+        sample_mask,
+        random_state,
+        X_csc=None,
+        X_csr=None,
+    ):
+        """Fit another stage of ``n_trees_per_iteration_`` trees."""
+        original_y = y
+
+        if isinstance(self._loss, HuberLoss):
+            set_huber_delta(
+                loss=self._loss,
+                y_true=y,
+                raw_prediction=raw_predictions,
+                sample_weight=sample_weight,
+            )
+        # TODO: Without oob, i.e. with self.subsample = 1.0, we could call
+        # self._loss.loss_gradient and use it to set train_score_.
+        # But note that train_score_[i] is the score AFTER fitting the i-th tree.
+        # Note: We need the negative gradient!
+        neg_gradient = -self._loss.gradient(
+            y_true=y,
+            raw_prediction=raw_predictions,
+            sample_weight=None,  # We pass sample_weights to the tree directly.
+        )
+        # 2-d views of shape (n_samples, n_trees_per_iteration_) or (n_samples, 1)
+        # on neg_gradient to simplify the loop over n_trees_per_iteration_.
+        if neg_gradient.ndim == 1:
+            neg_g_view = neg_gradient.reshape((-1, 1))
+        else:
+            neg_g_view = neg_gradient
+
+        for k in range(self.n_trees_per_iteration_):
+            if self._loss.is_multiclass:
+                y = np.array(original_y == k, dtype=np.float64)
+
+            # induce regression tree on the negative gradient
+            tree = DecisionTreeRegressor(
+                criterion=self.criterion,
+                splitter="best",
+                max_depth=self.max_depth,
+                min_samples_split=self.min_samples_split,
+                min_samples_leaf=self.min_samples_leaf,
+                min_weight_fraction_leaf=self.min_weight_fraction_leaf,
+                min_impurity_decrease=self.min_impurity_decrease,
+                max_features=self.max_features,
+                max_leaf_nodes=self.max_leaf_nodes,
+                random_state=random_state,
+                ccp_alpha=self.ccp_alpha,
+            )
+
+            if self.subsample < 1.0:
+                # no inplace multiplication!
+                sample_weight = sample_weight * sample_mask.astype(np.float64)
+
+            X = X_csc if X_csc is not None else X
+            tree.fit(
+                X, neg_g_view[:, k], sample_weight=sample_weight, check_input=False
+            )
+
+            # update tree leaves
+            X_for_tree_update = X_csr if X_csr is not None else X
+            _update_terminal_regions(
+                self._loss,
+                tree.tree_,
+                X_for_tree_update,
+                y,
+                neg_g_view[:, k],
+                raw_predictions,
+                sample_weight,
+                sample_mask,
+                learning_rate=self.learning_rate,
+                k=k,
+            )
+
+            # add tree to ensemble
+            self.estimators_[i, k] = tree
+
+        return raw_predictions
+
+    def _set_max_features(self):
+        """Set self.max_features_."""
+        if isinstance(self.max_features, str):
+            if self.max_features == "auto":
+                if is_classifier(self):
+                    max_features = max(1, int(np.sqrt(self.n_features_in_)))
+                else:
+                    max_features = self.n_features_in_
+            elif self.max_features == "sqrt":
+                max_features = max(1, int(np.sqrt(self.n_features_in_)))
+            else:  # self.max_features == "log2"
+                max_features = max(1, int(np.log2(self.n_features_in_)))
+        elif self.max_features is None:
+            max_features = self.n_features_in_
+        elif isinstance(self.max_features, Integral):
+            max_features = self.max_features
+        else:  # float
+            max_features = max(1, int(self.max_features * self.n_features_in_))
+
+        self.max_features_ = max_features
+
+    def _init_state(self):
+        """Initialize model state and allocate model state data structures."""
+
+        self.init_ = self.init
+        if self.init_ is None:
+            if is_classifier(self):
+                self.init_ = DummyClassifier(strategy="prior")
+            elif isinstance(self._loss, (AbsoluteError, HuberLoss)):
+                self.init_ = DummyRegressor(strategy="quantile", quantile=0.5)
+            elif isinstance(self._loss, PinballLoss):
+                self.init_ = DummyRegressor(strategy="quantile", quantile=self.alpha)
+            else:
+                self.init_ = DummyRegressor(strategy="mean")
+
+        self.estimators_ = np.empty(
+            (self.n_estimators, self.n_trees_per_iteration_), dtype=object
+        )
+        self.train_score_ = np.zeros((self.n_estimators,), dtype=np.float64)
+        # do oob?
+        if self.subsample < 1.0:
+            self.oob_improvement_ = np.zeros((self.n_estimators), dtype=np.float64)
+            self.oob_scores_ = np.zeros((self.n_estimators), dtype=np.float64)
+            self.oob_score_ = np.nan
+
+    def _clear_state(self):
+        """Clear the state of the gradient boosting model."""
+        if hasattr(self, "estimators_"):
+            self.estimators_ = np.empty((0, 0), dtype=object)
+        if hasattr(self, "train_score_"):
+            del self.train_score_
+        if hasattr(self, "oob_improvement_"):
+            del self.oob_improvement_
+        if hasattr(self, "oob_scores_"):
+            del self.oob_scores_
+        if hasattr(self, "oob_score_"):
+            del self.oob_score_
+        if hasattr(self, "init_"):
+            del self.init_
+        if hasattr(self, "_rng"):
+            del self._rng
+
+    def _resize_state(self):
+        """Add additional ``n_estimators`` entries to all attributes."""
+        # self.n_estimators is the number of additional est to fit
+        total_n_estimators = self.n_estimators
+        if total_n_estimators < self.estimators_.shape[0]:
+            raise ValueError(
+                "resize with smaller n_estimators %d < %d"
+                % (total_n_estimators, self.estimators_[0])
+            )
+
+        self.estimators_ = np.resize(
+            self.estimators_, (total_n_estimators, self.n_trees_per_iteration_)
+        )
+        self.train_score_ = np.resize(self.train_score_, total_n_estimators)
+        if self.subsample < 1 or hasattr(self, "oob_improvement_"):
+            # if do oob resize arrays or create new if not available
+            if hasattr(self, "oob_improvement_"):
+                self.oob_improvement_ = np.resize(
+                    self.oob_improvement_, total_n_estimators
+                )
+                self.oob_scores_ = np.resize(self.oob_scores_, total_n_estimators)
+                self.oob_score_ = np.nan
+            else:
+                self.oob_improvement_ = np.zeros(
+                    (total_n_estimators,), dtype=np.float64
+                )
+                self.oob_scores_ = np.zeros((total_n_estimators,), dtype=np.float64)
+                self.oob_score_ = np.nan
+
+    def _is_fitted(self):
+        return len(getattr(self, "estimators_", [])) > 0
+
+    def _check_initialized(self):
+        """Check that the estimator is initialized, raising an error if not."""
+        check_is_fitted(self)
+
+    @_fit_context(
+        # GradientBoosting*.init is not validated yet
+        prefer_skip_nested_validation=False
+    )
+    def fit(self, X, y, sample_weight=None, monitor=None):
+        """Fit the gradient boosting model.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            The input samples. Internally, it will be converted to
+            ``dtype=np.float32`` and if a sparse matrix is provided
+            to a sparse ``csr_matrix``.
+
+        y : array-like of shape (n_samples,)
+            Target values (strings or integers in classification, real numbers
+            in regression)
+            For classification, labels must correspond to classes.
+
+        sample_weight : array-like of shape (n_samples,), default=None
+            Sample weights. If None, then samples are equally weighted. Splits
+            that would create child nodes with net zero or negative weight are
+            ignored while searching for a split in each node. In the case of
+            classification, splits are also ignored if they would result in any
+            single class carrying a negative weight in either child node.
+
+        monitor : callable, default=None
+            The monitor is called after each iteration with the current
+            iteration, a reference to the estimator and the local variables of
+            ``_fit_stages`` as keyword arguments ``callable(i, self,
+            locals())``. If the callable returns ``True`` the fitting procedure
+            is stopped. The monitor can be used for various things such as
+            computing held-out estimates, early stopping, model introspect, and
+            snapshotting.
+
+        Returns
+        -------
+        self : object
+            Fitted estimator.
+        """
+        if not self.warm_start:
+            self._clear_state()
+
+        # Check input
+        # Since check_array converts both X and y to the same dtype, but the
+        # trees use different types for X and y, checking them separately.
+
+        X, y = self._validate_data(
+            X, y, accept_sparse=["csr", "csc", "coo"], dtype=DTYPE, multi_output=True
+        )
+        sample_weight_is_none = sample_weight is None
+        sample_weight = _check_sample_weight(sample_weight, X)
+        if sample_weight_is_none:
+            y = self._encode_y(y=y, sample_weight=None)
+        else:
+            y = self._encode_y(y=y, sample_weight=sample_weight)
+        y = column_or_1d(y, warn=True)  # TODO: Is this still required?
+
+        self._set_max_features()
+
+        # self.loss is guaranteed to be a string
+        self._loss = self._get_loss(sample_weight=sample_weight)
+
+        if self.n_iter_no_change is not None:
+            stratify = y if is_classifier(self) else None
+            (
+                X_train,
+                X_val,
+                y_train,
+                y_val,
+                sample_weight_train,
+                sample_weight_val,
+            ) = train_test_split(
+                X,
+                y,
+                sample_weight,
+                random_state=self.random_state,
+                test_size=self.validation_fraction,
+                stratify=stratify,
+            )
+            if is_classifier(self):
+                if self.n_classes_ != np.unique(y_train).shape[0]:
+                    # We choose to error here. The problem is that the init
+                    # estimator would be trained on y, which has some missing
+                    # classes now, so its predictions would not have the
+                    # correct shape.
+                    raise ValueError(
+                        "The training data after the early stopping split "
+                        "is missing some classes. Try using another random "
+                        "seed."
+                    )
+        else:
+            X_train, y_train, sample_weight_train = X, y, sample_weight
+            X_val = y_val = sample_weight_val = None
+
+        n_samples = X_train.shape[0]
+
+        # First time calling fit.
+        if not self._is_fitted():
+            # init state
+            self._init_state()
+
+            # fit initial model and initialize raw predictions
+            if self.init_ == "zero":
+                raw_predictions = np.zeros(
+                    shape=(n_samples, self.n_trees_per_iteration_),
+                    dtype=np.float64,
+                )
+            else:
+                # XXX clean this once we have a support_sample_weight tag
+                if sample_weight_is_none:
+                    self.init_.fit(X_train, y_train)
+                else:
+                    msg = (
+                        "The initial estimator {} does not support sample "
+                        "weights.".format(self.init_.__class__.__name__)
+                    )
+                    try:
+                        self.init_.fit(
+                            X_train, y_train, sample_weight=sample_weight_train
+                        )
+                    except TypeError as e:
+                        if "unexpected keyword argument 'sample_weight'" in str(e):
+                            # regular estimator without SW support
+                            raise ValueError(msg) from e
+                        else:  # regular estimator whose input checking failed
+                            raise
+                    except ValueError as e:
+                        if (
+                            "pass parameters to specific steps of "
+                            "your pipeline using the "
+                            "stepname__parameter"
+                            in str(e)
+                        ):  # pipeline
+                            raise ValueError(msg) from e
+                        else:  # regular estimator whose input checking failed
+                            raise
+
+                raw_predictions = _init_raw_predictions(
+                    X_train, self.init_, self._loss, is_classifier(self)
+                )
+
+            begin_at_stage = 0
+
+            # The rng state must be preserved if warm_start is True
+            self._rng = check_random_state(self.random_state)
+
+        # warm start: this is not the first time fit was called
+        else:
+            # add more estimators to fitted model
+            # invariant: warm_start = True
+            if self.n_estimators < self.estimators_.shape[0]:
+                raise ValueError(
+                    "n_estimators=%d must be larger or equal to "
+                    "estimators_.shape[0]=%d when "
+                    "warm_start==True" % (self.n_estimators, self.estimators_.shape[0])
+                )
+            begin_at_stage = self.estimators_.shape[0]
+            # The requirements of _raw_predict
+            # are more constrained than fit. It accepts only CSR
+            # matrices. Finite values have already been checked in _validate_data.
+            X_train = check_array(
+                X_train,
+                dtype=DTYPE,
+                order="C",
+                accept_sparse="csr",
+                force_all_finite=False,
+            )
+            raw_predictions = self._raw_predict(X_train)
+            self._resize_state()
+
+        # fit the boosting stages
+        n_stages = self._fit_stages(
+            X_train,
+            y_train,
+            raw_predictions,
+            sample_weight_train,
+            self._rng,
+            X_val,
+            y_val,
+            sample_weight_val,
+            begin_at_stage,
+            monitor,
+        )
+
+        # change shape of arrays after fit (early-stopping or additional ests)
+        if n_stages != self.estimators_.shape[0]:
+            self.estimators_ = self.estimators_[:n_stages]
+            self.train_score_ = self.train_score_[:n_stages]
+            if hasattr(self, "oob_improvement_"):
+                # OOB scores were computed
+                self.oob_improvement_ = self.oob_improvement_[:n_stages]
+                self.oob_scores_ = self.oob_scores_[:n_stages]
+                self.oob_score_ = self.oob_scores_[-1]
+        self.n_estimators_ = n_stages
+        return self
+
+    def _fit_stages(
+        self,
+        X,
+        y,
+        raw_predictions,
+        sample_weight,
+        random_state,
+        X_val,
+        y_val,
+        sample_weight_val,
+        begin_at_stage=0,
+        monitor=None,
+    ):
+        """Iteratively fits the stages.
+
+        For each stage it computes the progress (OOB, train score)
+        and delegates to ``_fit_stage``.
+        Returns the number of stages fit; might differ from ``n_estimators``
+        due to early stopping.
+        """
+        n_samples = X.shape[0]
+        do_oob = self.subsample < 1.0
+        sample_mask = np.ones((n_samples,), dtype=bool)
+        n_inbag = max(1, int(self.subsample * n_samples))
+
+        if self.verbose:
+            verbose_reporter = VerboseReporter(verbose=self.verbose)
+            verbose_reporter.init(self, begin_at_stage)
+
+        X_csc = csc_matrix(X) if issparse(X) else None
+        X_csr = csr_matrix(X) if issparse(X) else None
+
+        if self.n_iter_no_change is not None:
+            loss_history = np.full(self.n_iter_no_change, np.inf)
+            # We create a generator to get the predictions for X_val after
+            # the addition of each successive stage
+            y_val_pred_iter = self._staged_raw_predict(X_val, check_input=False)
+
+        # Older versions of GBT had its own loss functions. With the new common
+        # private loss function submodule _loss, we often are a factor of 2
+        # away from the old version. Here we keep backward compatibility for
+        # oob_scores_ and oob_improvement_, even if the old way is quite
+        # inconsistent (sometimes the gradient is half the gradient, sometimes
+        # not).
+        if isinstance(
+            self._loss,
+            (
+                HalfSquaredError,
+                HalfBinomialLoss,
+            ),
+        ):
+            factor = 2
+        else:
+            factor = 1
+
+        # perform boosting iterations
+        i = begin_at_stage
+        for i in range(begin_at_stage, self.n_estimators):
+            # subsampling
+            if do_oob:
+                sample_mask = _random_sample_mask(n_samples, n_inbag, random_state)
+                y_oob_masked = y[~sample_mask]
+                sample_weight_oob_masked = sample_weight[~sample_mask]
+                if i == 0:  # store the initial loss to compute the OOB score
+                    initial_loss = factor * self._loss(
+                        y_true=y_oob_masked,
+                        raw_prediction=raw_predictions[~sample_mask],
+                        sample_weight=sample_weight_oob_masked,
+                    )
+
+            # fit next stage of trees
+            raw_predictions = self._fit_stage(
+                i,
+                X,
+                y,
+                raw_predictions,
+                sample_weight,
+                sample_mask,
+                random_state,
+                X_csc=X_csc,
+                X_csr=X_csr,
+            )
+
+            # track loss
+            if do_oob:
+                self.train_score_[i] = factor * self._loss(
+                    y_true=y[sample_mask],
+                    raw_prediction=raw_predictions[sample_mask],
+                    sample_weight=sample_weight[sample_mask],
+                )
+                self.oob_scores_[i] = factor * self._loss(
+                    y_true=y_oob_masked,
+                    raw_prediction=raw_predictions[~sample_mask],
+                    sample_weight=sample_weight_oob_masked,
+                )
+                previous_loss = initial_loss if i == 0 else self.oob_scores_[i - 1]
+                self.oob_improvement_[i] = previous_loss - self.oob_scores_[i]
+                self.oob_score_ = self.oob_scores_[-1]
+            else:
+                # no need to fancy index w/ no subsampling
+                self.train_score_[i] = factor * self._loss(
+                    y_true=y,
+                    raw_prediction=raw_predictions,
+                    sample_weight=sample_weight,
+                )
+
+            if self.verbose > 0:
+                verbose_reporter.update(i, self)
+
+            if monitor is not None:
+                early_stopping = monitor(i, self, locals())
+                if early_stopping:
+                    break
+
+            # We also provide an early stopping based on the score from
+            # validation set (X_val, y_val), if n_iter_no_change is set
+            if self.n_iter_no_change is not None:
+                # By calling next(y_val_pred_iter), we get the predictions
+                # for X_val after the addition of the current stage
+                validation_loss = factor * self._loss(
+                    y_val, next(y_val_pred_iter), sample_weight_val
+                )
+
+                # Require validation_score to be better (less) than at least
+                # one of the last n_iter_no_change evaluations
+                if np.any(validation_loss + self.tol < loss_history):
+                    loss_history[i % len(loss_history)] = validation_loss
+                else:
+                    break
+
+        return i + 1
+
+    def _make_estimator(self, append=True):
+        # we don't need _make_estimator
+        raise NotImplementedError()
+
+    def _raw_predict_init(self, X):
+        """Check input and compute raw predictions of the init estimator."""
+        self._check_initialized()
+        X = self.estimators_[0, 0]._validate_X_predict(X, check_input=True)
+        if self.init_ == "zero":
+            raw_predictions = np.zeros(
+                shape=(X.shape[0], self.n_trees_per_iteration_), dtype=np.float64
+            )
+        else:
+            raw_predictions = _init_raw_predictions(
+                X, self.init_, self._loss, is_classifier(self)
+            )
+        return raw_predictions
+
+    def _raw_predict(self, X):
+        """Return the sum of the trees raw predictions (+ init estimator)."""
+        check_is_fitted(self)
+        raw_predictions = self._raw_predict_init(X)
+        predict_stages(self.estimators_, X, self.learning_rate, raw_predictions)
+        return raw_predictions
+
+    def _staged_raw_predict(self, X, check_input=True):
+        """Compute raw predictions of ``X`` for each iteration.
+
+        This method allows monitoring (i.e. determine error on testing set)
+        after each stage.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            The input samples. Internally, it will be converted to
+            ``dtype=np.float32`` and if a sparse matrix is provided
+            to a sparse ``csr_matrix``.
+
+        check_input : bool, default=True
+            If False, the input arrays X will not be checked.
+
+        Returns
+        -------
+        raw_predictions : generator of ndarray of shape (n_samples, k)
+            The raw predictions of the input samples. The order of the
+            classes corresponds to that in the attribute :term:`classes_`.
+            Regression and binary classification are special cases with
+            ``k == 1``, otherwise ``k==n_classes``.
+        """
+        if check_input:
+            X = self._validate_data(
+                X, dtype=DTYPE, order="C", accept_sparse="csr", reset=False
+            )
+        raw_predictions = self._raw_predict_init(X)
+        for i in range(self.estimators_.shape[0]):
+            predict_stage(self.estimators_, i, X, self.learning_rate, raw_predictions)
+            yield raw_predictions.copy()
+
+    @property
+    def feature_importances_(self):
+        """The impurity-based feature importances.
+
+        The higher, the more important the feature.
+        The importance of a feature is computed as the (normalized)
+        total reduction of the criterion brought by that feature.  It is also
+        known as the Gini importance.
+
+        Warning: impurity-based feature importances can be misleading for
+        high cardinality features (many unique values). See
+        :func:`sklearn.inspection.permutation_importance` as an alternative.
+
+        Returns
+        -------
+        feature_importances_ : ndarray of shape (n_features,)
+            The values of this array sum to 1, unless all trees are single node
+            trees consisting of only the root node, in which case it will be an
+            array of zeros.
+        """
+        self._check_initialized()
+
+        relevant_trees = [
+            tree
+            for stage in self.estimators_
+            for tree in stage
+            if tree.tree_.node_count > 1
+        ]
+        if not relevant_trees:
+            # degenerate case where all trees have only one node
+            return np.zeros(shape=self.n_features_in_, dtype=np.float64)
+
+        relevant_feature_importances = [
+            tree.tree_.compute_feature_importances(normalize=False)
+            for tree in relevant_trees
+        ]
+        avg_feature_importances = np.mean(
+            relevant_feature_importances, axis=0, dtype=np.float64
+        )
+        return avg_feature_importances / np.sum(avg_feature_importances)
+
+    def _compute_partial_dependence_recursion(self, grid, target_features):
+        """Fast partial dependence computation.
+
+        Parameters
+        ----------
+        grid : ndarray of shape (n_samples, n_target_features)
+            The grid points on which the partial dependence should be
+            evaluated.
+        target_features : ndarray of shape (n_target_features,)
+            The set of target features for which the partial dependence
+            should be evaluated.
+
+        Returns
+        -------
+        averaged_predictions : ndarray of shape \
+                (n_trees_per_iteration_, n_samples)
+            The value of the partial dependence function on each grid point.
+        """
+        if self.init is not None:
+            warnings.warn(
+                "Using recursion method with a non-constant init predictor "
+                "will lead to incorrect partial dependence values. "
+                "Got init=%s."
+                % self.init,
+                UserWarning,
+            )
+        grid = np.asarray(grid, dtype=DTYPE, order="C")
+        n_estimators, n_trees_per_stage = self.estimators_.shape
+        averaged_predictions = np.zeros(
+            (n_trees_per_stage, grid.shape[0]), dtype=np.float64, order="C"
+        )
+        for stage in range(n_estimators):
+            for k in range(n_trees_per_stage):
+                tree = self.estimators_[stage, k].tree_
+                tree.compute_partial_dependence(
+                    grid, target_features, averaged_predictions[k]
+                )
+        averaged_predictions *= self.learning_rate
+
+        return averaged_predictions
+
+    def apply(self, X):
+        """Apply trees in the ensemble to X, return leaf indices.
+
+        .. versionadded:: 0.17
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            The input samples. Internally, its dtype will be converted to
+            ``dtype=np.float32``. If a sparse matrix is provided, it will
+            be converted to a sparse ``csr_matrix``.
+
+        Returns
+        -------
+        X_leaves : array-like of shape (n_samples, n_estimators, n_classes)
+            For each datapoint x in X and for each tree in the ensemble,
+            return the index of the leaf x ends up in each estimator.
+            In the case of binary classification n_classes is 1.
+        """
+
+        self._check_initialized()
+        X = self.estimators_[0, 0]._validate_X_predict(X, check_input=True)
+
+        # n_classes will be equal to 1 in the binary classification or the
+        # regression case.
+        n_estimators, n_classes = self.estimators_.shape
+        leaves = np.zeros((X.shape[0], n_estimators, n_classes))
+
+        for i in range(n_estimators):
+            for j in range(n_classes):
+                estimator = self.estimators_[i, j]
+                leaves[:, i, j] = estimator.apply(X, check_input=False)
+
+        return leaves
+
+
+class GradientBoostingClassifier(ClassifierMixin, BaseGradientBoosting):
+    """Gradient Boosting for classification.
+
+    This algorithm builds an additive model in a forward stage-wise fashion; it
+    allows for the optimization of arbitrary differentiable loss functions. In
+    each stage ``n_classes_`` regression trees are fit on the negative gradient
+    of the loss function, e.g. binary or multiclass log loss. Binary
+    classification is a special case where only a single regression tree is
+    induced.
+
+    :class:`sklearn.ensemble.HistGradientBoostingClassifier` is a much faster
+    variant of this algorithm for intermediate datasets (`n_samples >= 10_000`).
+
+    Read more in the :ref:`User Guide <gradient_boosting>`.
+
+    Parameters
+    ----------
+    loss : {'log_loss', 'exponential'}, default='log_loss'
+        The loss function to be optimized. 'log_loss' refers to binomial and
+        multinomial deviance, the same as used in logistic regression.
+        It is a good choice for classification with probabilistic outputs.
+        For loss 'exponential', gradient boosting recovers the AdaBoost algorithm.
+
+    learning_rate : float, default=0.1
+        Learning rate shrinks the contribution of each tree by `learning_rate`.
+        There is a trade-off between learning_rate and n_estimators.
+        Values must be in the range `[0.0, inf)`.
+
+    n_estimators : int, default=100
+        The number of boosting stages to perform. Gradient boosting
+        is fairly robust to over-fitting so a large number usually
+        results in better performance.
+        Values must be in the range `[1, inf)`.
+
+    subsample : float, default=1.0
+        The fraction of samples to be used for fitting the individual base
+        learners. If smaller than 1.0 this results in Stochastic Gradient
+        Boosting. `subsample` interacts with the parameter `n_estimators`.
+        Choosing `subsample < 1.0` leads to a reduction of variance
+        and an increase in bias.
+        Values must be in the range `(0.0, 1.0]`.
+
+    criterion : {'friedman_mse', 'squared_error'}, default='friedman_mse'
+        The function to measure the quality of a split. Supported criteria are
+        'friedman_mse' for the mean squared error with improvement score by
+        Friedman, 'squared_error' for mean squared error. The default value of
+        'friedman_mse' is generally the best as it can provide a better
+        approximation in some cases.
+
+        .. versionadded:: 0.18
+
+    min_samples_split : int or float, default=2
+        The minimum number of samples required to split an internal node:
+
+        - If int, values must be in the range `[2, inf)`.
+        - If float, values must be in the range `(0.0, 1.0]` and `min_samples_split`
+          will be `ceil(min_samples_split * n_samples)`.
+
+        .. versionchanged:: 0.18
+           Added float values for fractions.
+
+    min_samples_leaf : int or float, default=1
+        The minimum number of samples required to be at a leaf node.
+        A split point at any depth will only be considered if it leaves at
+        least ``min_samples_leaf`` training samples in each of the left and
+        right branches.  This may have the effect of smoothing the model,
+        especially in regression.
+
+        - If int, values must be in the range `[1, inf)`.
+        - If float, values must be in the range `(0.0, 1.0)` and `min_samples_leaf`
+          will be `ceil(min_samples_leaf * n_samples)`.
+
+        .. versionchanged:: 0.18
+           Added float values for fractions.
+
+    min_weight_fraction_leaf : float, default=0.0
+        The minimum weighted fraction of the sum total of weights (of all
+        the input samples) required to be at a leaf node. Samples have
+        equal weight when sample_weight is not provided.
+        Values must be in the range `[0.0, 0.5]`.
+
+    max_depth : int or None, default=3
+        Maximum depth of the individual regression estimators. The maximum
+        depth limits the number of nodes in the tree. Tune this parameter
+        for best performance; the best value depends on the interaction
+        of the input variables. If None, then nodes are expanded until
+        all leaves are pure or until all leaves contain less than
+        min_samples_split samples.
+        If int, values must be in the range `[1, inf)`.
+
+    min_impurity_decrease : float, default=0.0
+        A node will be split if this split induces a decrease of the impurity
+        greater than or equal to this value.
+        Values must be in the range `[0.0, inf)`.
+
+        The weighted impurity decrease equation is the following::
+
+            N_t / N * (impurity - N_t_R / N_t * right_impurity
+                                - N_t_L / N_t * left_impurity)
+
+        where ``N`` is the total number of samples, ``N_t`` is the number of
+        samples at the current node, ``N_t_L`` is the number of samples in the
+        left child, and ``N_t_R`` is the number of samples in the right child.
+
+        ``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum,
+        if ``sample_weight`` is passed.
+
+        .. versionadded:: 0.19
+
+    init : estimator or 'zero', default=None
+        An estimator object that is used to compute the initial predictions.
+        ``init`` has to provide :term:`fit` and :term:`predict_proba`. If
+        'zero', the initial raw predictions are set to zero. By default, a
+        ``DummyEstimator`` predicting the classes priors is used.
+
+    random_state : int, RandomState instance or None, default=None
+        Controls the random seed given to each Tree estimator at each
+        boosting iteration.
+        In addition, it controls the random permutation of the features at
+        each split (see Notes for more details).
+        It also controls the random splitting of the training data to obtain a
+        validation set if `n_iter_no_change` is not None.
+        Pass an int for reproducible output across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    max_features : {'sqrt', 'log2'}, int or float, default=None
+        The number of features to consider when looking for the best split:
+
+        - If int, values must be in the range `[1, inf)`.
+        - If float, values must be in the range `(0.0, 1.0]` and the features
+          considered at each split will be `max(1, int(max_features * n_features_in_))`.
+        - If 'sqrt', then `max_features=sqrt(n_features)`.
+        - If 'log2', then `max_features=log2(n_features)`.
+        - If None, then `max_features=n_features`.
+
+        Choosing `max_features < n_features` leads to a reduction of variance
+        and an increase in bias.
+
+        Note: the search for a split does not stop until at least one
+        valid partition of the node samples is found, even if it requires to
+        effectively inspect more than ``max_features`` features.
+
+    verbose : int, default=0
+        Enable verbose output. If 1 then it prints progress and performance
+        once in a while (the more trees the lower the frequency). If greater
+        than 1 then it prints progress and performance for every tree.
+        Values must be in the range `[0, inf)`.
+
+    max_leaf_nodes : int, default=None
+        Grow trees with ``max_leaf_nodes`` in best-first fashion.
+        Best nodes are defined as relative reduction in impurity.
+        Values must be in the range `[2, inf)`.
+        If `None`, then unlimited number of leaf nodes.
+
+    warm_start : bool, default=False
+        When set to ``True``, reuse the solution of the previous call to fit
+        and add more estimators to the ensemble, otherwise, just erase the
+        previous solution. See :term:`the Glossary <warm_start>`.
+
+    validation_fraction : float, default=0.1
+        The proportion of training data to set aside as validation set for
+        early stopping. Values must be in the range `(0.0, 1.0)`.
+        Only used if ``n_iter_no_change`` is set to an integer.
+
+        .. versionadded:: 0.20
+
+    n_iter_no_change : int, default=None
+        ``n_iter_no_change`` is used to decide if early stopping will be used
+        to terminate training when validation score is not improving. By
+        default it is set to None to disable early stopping. If set to a
+        number, it will set aside ``validation_fraction`` size of the training
+        data as validation and terminate training when validation score is not
+        improving in all of the previous ``n_iter_no_change`` numbers of
+        iterations. The split is stratified.
+        Values must be in the range `[1, inf)`.
+        See
+        :ref:`sphx_glr_auto_examples_ensemble_plot_gradient_boosting_early_stopping.py`.
+
+        .. versionadded:: 0.20
+
+    tol : float, default=1e-4
+        Tolerance for the early stopping. When the loss is not improving
+        by at least tol for ``n_iter_no_change`` iterations (if set to a
+        number), the training stops.
+        Values must be in the range `[0.0, inf)`.
+
+        .. versionadded:: 0.20
+
+    ccp_alpha : non-negative float, default=0.0
+        Complexity parameter used for Minimal Cost-Complexity Pruning. The
+        subtree with the largest cost complexity that is smaller than
+        ``ccp_alpha`` will be chosen. By default, no pruning is performed.
+        Values must be in the range `[0.0, inf)`.
+        See :ref:`minimal_cost_complexity_pruning` for details.
+
+        .. versionadded:: 0.22
+
+    Attributes
+    ----------
+    n_estimators_ : int
+        The number of estimators as selected by early stopping (if
+        ``n_iter_no_change`` is specified). Otherwise it is set to
+        ``n_estimators``.
+
+        .. versionadded:: 0.20
+
+    n_trees_per_iteration_ : int
+        The number of trees that are built at each iteration. For binary classifiers,
+        this is always 1.
+
+        .. versionadded:: 1.4.0
+
+    feature_importances_ : ndarray of shape (n_features,)
+        The impurity-based feature importances.
+        The higher, the more important the feature.
+        The importance of a feature is computed as the (normalized)
+        total reduction of the criterion brought by that feature.  It is also
+        known as the Gini importance.
+
+        Warning: impurity-based feature importances can be misleading for
+        high cardinality features (many unique values). See
+        :func:`sklearn.inspection.permutation_importance` as an alternative.
+
+    oob_improvement_ : ndarray of shape (n_estimators,)
+        The improvement in loss on the out-of-bag samples
+        relative to the previous iteration.
+        ``oob_improvement_[0]`` is the improvement in
+        loss of the first stage over the ``init`` estimator.
+        Only available if ``subsample < 1.0``.
+
+    oob_scores_ : ndarray of shape (n_estimators,)
+        The full history of the loss values on the out-of-bag
+        samples. Only available if `subsample < 1.0`.
+
+        .. versionadded:: 1.3
+
+    oob_score_ : float
+        The last value of the loss on the out-of-bag samples. It is
+        the same as `oob_scores_[-1]`. Only available if `subsample < 1.0`.
+
+        .. versionadded:: 1.3
+
+    train_score_ : ndarray of shape (n_estimators,)
+        The i-th score ``train_score_[i]`` is the loss of the
+        model at iteration ``i`` on the in-bag sample.
+        If ``subsample == 1`` this is the loss on the training data.
+
+    init_ : estimator
+        The estimator that provides the initial predictions. Set via the ``init``
+        argument.
+
+    estimators_ : ndarray of DecisionTreeRegressor of \
+            shape (n_estimators, ``n_trees_per_iteration_``)
+        The collection of fitted sub-estimators. ``n_trees_per_iteration_`` is 1 for
+        binary classification, otherwise ``n_classes``.
+
+    classes_ : ndarray of shape (n_classes,)
+        The classes labels.
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    n_classes_ : int
+        The number of classes.
+
+    max_features_ : int
+        The inferred value of max_features.
+
+    See Also
+    --------
+    HistGradientBoostingClassifier : Histogram-based Gradient Boosting
+        Classification Tree.
+    sklearn.tree.DecisionTreeClassifier : A decision tree classifier.
+    RandomForestClassifier : A meta-estimator that fits a number of decision
+        tree classifiers on various sub-samples of the dataset and uses
+        averaging to improve the predictive accuracy and control over-fitting.
+    AdaBoostClassifier : A meta-estimator that begins by fitting a classifier
+        on the original dataset and then fits additional copies of the
+        classifier on the same dataset where the weights of incorrectly
+        classified instances are adjusted such that subsequent classifiers
+        focus more on difficult cases.
+
+    Notes
+    -----
+    The features are always randomly permuted at each split. Therefore,
+    the best found split may vary, even with the same training data and
+    ``max_features=n_features``, if the improvement of the criterion is
+    identical for several splits enumerated during the search of the best
+    split. To obtain a deterministic behaviour during fitting,
+    ``random_state`` has to be fixed.
+
+    References
+    ----------
+    J. Friedman, Greedy Function Approximation: A Gradient Boosting
+    Machine, The Annals of Statistics, Vol. 29, No. 5, 2001.
+
+    J. Friedman, Stochastic Gradient Boosting, 1999
+
+    T. Hastie, R. Tibshirani and J. Friedman.
+    Elements of Statistical Learning Ed. 2, Springer, 2009.
+
+    Examples
+    --------
+    The following example shows how to fit a gradient boosting classifier with
+    100 decision stumps as weak learners.
+
+    >>> from sklearn.datasets import make_hastie_10_2
+    >>> from sklearn.ensemble import GradientBoostingClassifier
+
+    >>> X, y = make_hastie_10_2(random_state=0)
+    >>> X_train, X_test = X[:2000], X[2000:]
+    >>> y_train, y_test = y[:2000], y[2000:]
+
+    >>> clf = GradientBoostingClassifier(n_estimators=100, learning_rate=1.0,
+    ...     max_depth=1, random_state=0).fit(X_train, y_train)
+    >>> clf.score(X_test, y_test)
+    0.913...
+    """
+
+    _parameter_constraints: dict = {
+        **BaseGradientBoosting._parameter_constraints,
+        "loss": [StrOptions({"log_loss", "exponential"})],
+        "init": [StrOptions({"zero"}), None, HasMethods(["fit", "predict_proba"])],
+    }
+
+    def __init__(
+        self,
+        *,
+        loss="log_loss",
+        learning_rate=0.1,
+        n_estimators=100,
+        subsample=1.0,
+        criterion="friedman_mse",
+        min_samples_split=2,
+        min_samples_leaf=1,
+        min_weight_fraction_leaf=0.0,
+        max_depth=3,
+        min_impurity_decrease=0.0,
+        init=None,
+        random_state=None,
+        max_features=None,
+        verbose=0,
+        max_leaf_nodes=None,
+        warm_start=False,
+        validation_fraction=0.1,
+        n_iter_no_change=None,
+        tol=1e-4,
+        ccp_alpha=0.0,
+    ):
+        super().__init__(
+            loss=loss,
+            learning_rate=learning_rate,
+            n_estimators=n_estimators,
+            criterion=criterion,
+            min_samples_split=min_samples_split,
+            min_samples_leaf=min_samples_leaf,
+            min_weight_fraction_leaf=min_weight_fraction_leaf,
+            max_depth=max_depth,
+            init=init,
+            subsample=subsample,
+            max_features=max_features,
+            random_state=random_state,
+            verbose=verbose,
+            max_leaf_nodes=max_leaf_nodes,
+            min_impurity_decrease=min_impurity_decrease,
+            warm_start=warm_start,
+            validation_fraction=validation_fraction,
+            n_iter_no_change=n_iter_no_change,
+            tol=tol,
+            ccp_alpha=ccp_alpha,
+        )
+
+    def _encode_y(self, y, sample_weight):
+        # encode classes into 0 ... n_classes - 1 and sets attributes classes_
+        # and n_trees_per_iteration_
+        check_classification_targets(y)
+
+        label_encoder = LabelEncoder()
+        encoded_y_int = label_encoder.fit_transform(y)
+        self.classes_ = label_encoder.classes_
+        n_classes = self.classes_.shape[0]
+        # only 1 tree for binary classification. For multiclass classification,
+        # we build 1 tree per class.
+        self.n_trees_per_iteration_ = 1 if n_classes <= 2 else n_classes
+        encoded_y = encoded_y_int.astype(float, copy=False)
+
+        # From here on, it is additional to the HGBT case.
+        # expose n_classes_ attribute
+        self.n_classes_ = n_classes
+        if sample_weight is None:
+            n_trim_classes = n_classes
+        else:
+            n_trim_classes = np.count_nonzero(np.bincount(encoded_y_int, sample_weight))
+
+        if n_trim_classes < 2:
+            raise ValueError(
+                "y contains %d class after sample_weight "
+                "trimmed classes with zero weights, while a "
+                "minimum of 2 classes are required." % n_trim_classes
+            )
+        return encoded_y
+
+    def _get_loss(self, sample_weight):
+        if self.loss == "log_loss":
+            if self.n_classes_ == 2:
+                return HalfBinomialLoss(sample_weight=sample_weight)
+            else:
+                return HalfMultinomialLoss(
+                    sample_weight=sample_weight, n_classes=self.n_classes_
+                )
+        elif self.loss == "exponential":
+            if self.n_classes_ > 2:
+                raise ValueError(
+                    f"loss='{self.loss}' is only suitable for a binary classification "
+                    f"problem, you have n_classes={self.n_classes_}. "
+                    "Please use loss='log_loss' instead."
+                )
+            else:
+                return ExponentialLoss(sample_weight=sample_weight)
+
+    def decision_function(self, X):
+        """Compute the decision function of ``X``.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            The input samples. Internally, it will be converted to
+            ``dtype=np.float32`` and if a sparse matrix is provided
+            to a sparse ``csr_matrix``.
+
+        Returns
+        -------
+        score : ndarray of shape (n_samples, n_classes) or (n_samples,)
+            The decision function of the input samples, which corresponds to
+            the raw values predicted from the trees of the ensemble . The
+            order of the classes corresponds to that in the attribute
+            :term:`classes_`. Regression and binary classification produce an
+            array of shape (n_samples,).
+        """
+        X = self._validate_data(
+            X, dtype=DTYPE, order="C", accept_sparse="csr", reset=False
+        )
+        raw_predictions = self._raw_predict(X)
+        if raw_predictions.shape[1] == 1:
+            return raw_predictions.ravel()
+        return raw_predictions
+
+    def staged_decision_function(self, X):
+        """Compute decision function of ``X`` for each iteration.
+
+        This method allows monitoring (i.e. determine error on testing set)
+        after each stage.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            The input samples. Internally, it will be converted to
+            ``dtype=np.float32`` and if a sparse matrix is provided
+            to a sparse ``csr_matrix``.
+
+        Yields
+        ------
+        score : generator of ndarray of shape (n_samples, k)
+            The decision function of the input samples, which corresponds to
+            the raw values predicted from the trees of the ensemble . The
+            classes corresponds to that in the attribute :term:`classes_`.
+            Regression and binary classification are special cases with
+            ``k == 1``, otherwise ``k==n_classes``.
+        """
+        yield from self._staged_raw_predict(X)
+
+    def predict(self, X):
+        """Predict class for X.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            The input samples. Internally, it will be converted to
+            ``dtype=np.float32`` and if a sparse matrix is provided
+            to a sparse ``csr_matrix``.
+
+        Returns
+        -------
+        y : ndarray of shape (n_samples,)
+            The predicted values.
+        """
+        raw_predictions = self.decision_function(X)
+        if raw_predictions.ndim == 1:  # decision_function already squeezed it
+            encoded_classes = (raw_predictions >= 0).astype(int)
+        else:
+            encoded_classes = np.argmax(raw_predictions, axis=1)
+        return self.classes_[encoded_classes]
+
+    def staged_predict(self, X):
+        """Predict class at each stage for X.
+
+        This method allows monitoring (i.e. determine error on testing set)
+        after each stage.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            The input samples. Internally, it will be converted to
+            ``dtype=np.float32`` and if a sparse matrix is provided
+            to a sparse ``csr_matrix``.
+
+        Yields
+        ------
+        y : generator of ndarray of shape (n_samples,)
+            The predicted value of the input samples.
+        """
+        if self.n_classes_ == 2:  # n_trees_per_iteration_ = 1
+            for raw_predictions in self._staged_raw_predict(X):
+                encoded_classes = (raw_predictions.squeeze() >= 0).astype(int)
+                yield self.classes_.take(encoded_classes, axis=0)
+        else:
+            for raw_predictions in self._staged_raw_predict(X):
+                encoded_classes = np.argmax(raw_predictions, axis=1)
+                yield self.classes_.take(encoded_classes, axis=0)
+
+    def predict_proba(self, X):
+        """Predict class probabilities for X.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            The input samples. Internally, it will be converted to
+            ``dtype=np.float32`` and if a sparse matrix is provided
+            to a sparse ``csr_matrix``.
+
+        Returns
+        -------
+        p : ndarray of shape (n_samples, n_classes)
+            The class probabilities of the input samples. The order of the
+            classes corresponds to that in the attribute :term:`classes_`.
+
+        Raises
+        ------
+        AttributeError
+            If the ``loss`` does not support probabilities.
+        """
+        raw_predictions = self.decision_function(X)
+        return self._loss.predict_proba(raw_predictions)
+
+    def predict_log_proba(self, X):
+        """Predict class log-probabilities for X.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            The input samples. Internally, it will be converted to
+            ``dtype=np.float32`` and if a sparse matrix is provided
+            to a sparse ``csr_matrix``.
+
+        Returns
+        -------
+        p : ndarray of shape (n_samples, n_classes)
+            The class log-probabilities of the input samples. The order of the
+            classes corresponds to that in the attribute :term:`classes_`.
+
+        Raises
+        ------
+        AttributeError
+            If the ``loss`` does not support probabilities.
+        """
+        proba = self.predict_proba(X)
+        return np.log(proba)
+
+    def staged_predict_proba(self, X):
+        """Predict class probabilities at each stage for X.
+
+        This method allows monitoring (i.e. determine error on testing set)
+        after each stage.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            The input samples. Internally, it will be converted to
+            ``dtype=np.float32`` and if a sparse matrix is provided
+            to a sparse ``csr_matrix``.
+
+        Yields
+        ------
+        y : generator of ndarray of shape (n_samples,)
+            The predicted value of the input samples.
+        """
+        try:
+            for raw_predictions in self._staged_raw_predict(X):
+                yield self._loss.predict_proba(raw_predictions)
+        except NotFittedError:
+            raise
+        except AttributeError as e:
+            raise AttributeError(
+                "loss=%r does not support predict_proba" % self.loss
+            ) from e
+
+
+class GradientBoostingRegressor(RegressorMixin, BaseGradientBoosting):
+    """Gradient Boosting for regression.
+
+    This estimator builds an additive model in a forward stage-wise fashion; it
+    allows for the optimization of arbitrary differentiable loss functions. In
+    each stage a regression tree is fit on the negative gradient of the given
+    loss function.
+
+    :class:`sklearn.ensemble.HistGradientBoostingRegressor` is a much faster
+    variant of this algorithm for intermediate datasets (`n_samples >= 10_000`).
+
+    Read more in the :ref:`User Guide <gradient_boosting>`.
+
+    Parameters
+    ----------
+    loss : {'squared_error', 'absolute_error', 'huber', 'quantile'}, \
+            default='squared_error'
+        Loss function to be optimized. 'squared_error' refers to the squared
+        error for regression. 'absolute_error' refers to the absolute error of
+        regression and is a robust loss function. 'huber' is a
+        combination of the two. 'quantile' allows quantile regression (use
+        `alpha` to specify the quantile).
+
+    learning_rate : float, default=0.1
+        Learning rate shrinks the contribution of each tree by `learning_rate`.
+        There is a trade-off between learning_rate and n_estimators.
+        Values must be in the range `[0.0, inf)`.
+
+    n_estimators : int, default=100
+        The number of boosting stages to perform. Gradient boosting
+        is fairly robust to over-fitting so a large number usually
+        results in better performance.
+        Values must be in the range `[1, inf)`.
+
+    subsample : float, default=1.0
+        The fraction of samples to be used for fitting the individual base
+        learners. If smaller than 1.0 this results in Stochastic Gradient
+        Boosting. `subsample` interacts with the parameter `n_estimators`.
+        Choosing `subsample < 1.0` leads to a reduction of variance
+        and an increase in bias.
+        Values must be in the range `(0.0, 1.0]`.
+
+    criterion : {'friedman_mse', 'squared_error'}, default='friedman_mse'
+        The function to measure the quality of a split. Supported criteria are
+        "friedman_mse" for the mean squared error with improvement score by
+        Friedman, "squared_error" for mean squared error. The default value of
+        "friedman_mse" is generally the best as it can provide a better
+        approximation in some cases.
+
+        .. versionadded:: 0.18
+
+    min_samples_split : int or float, default=2
+        The minimum number of samples required to split an internal node:
+
+        - If int, values must be in the range `[2, inf)`.
+        - If float, values must be in the range `(0.0, 1.0]` and `min_samples_split`
+          will be `ceil(min_samples_split * n_samples)`.
+
+        .. versionchanged:: 0.18
+           Added float values for fractions.
+
+    min_samples_leaf : int or float, default=1
+        The minimum number of samples required to be at a leaf node.
+        A split point at any depth will only be considered if it leaves at
+        least ``min_samples_leaf`` training samples in each of the left and
+        right branches.  This may have the effect of smoothing the model,
+        especially in regression.
+
+        - If int, values must be in the range `[1, inf)`.
+        - If float, values must be in the range `(0.0, 1.0)` and `min_samples_leaf`
+          will be `ceil(min_samples_leaf * n_samples)`.
+
+        .. versionchanged:: 0.18
+           Added float values for fractions.
+
+    min_weight_fraction_leaf : float, default=0.0
+        The minimum weighted fraction of the sum total of weights (of all
+        the input samples) required to be at a leaf node. Samples have
+        equal weight when sample_weight is not provided.
+        Values must be in the range `[0.0, 0.5]`.
+
+    max_depth : int or None, default=3
+        Maximum depth of the individual regression estimators. The maximum
+        depth limits the number of nodes in the tree. Tune this parameter
+        for best performance; the best value depends on the interaction
+        of the input variables. If None, then nodes are expanded until
+        all leaves are pure or until all leaves contain less than
+        min_samples_split samples.
+        If int, values must be in the range `[1, inf)`.
+
+    min_impurity_decrease : float, default=0.0
+        A node will be split if this split induces a decrease of the impurity
+        greater than or equal to this value.
+        Values must be in the range `[0.0, inf)`.
+
+        The weighted impurity decrease equation is the following::
+
+            N_t / N * (impurity - N_t_R / N_t * right_impurity
+                                - N_t_L / N_t * left_impurity)
+
+        where ``N`` is the total number of samples, ``N_t`` is the number of
+        samples at the current node, ``N_t_L`` is the number of samples in the
+        left child, and ``N_t_R`` is the number of samples in the right child.
+
+        ``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum,
+        if ``sample_weight`` is passed.
+
+        .. versionadded:: 0.19
+
+    init : estimator or 'zero', default=None
+        An estimator object that is used to compute the initial predictions.
+        ``init`` has to provide :term:`fit` and :term:`predict`. If 'zero', the
+        initial raw predictions are set to zero. By default a
+        ``DummyEstimator`` is used, predicting either the average target value
+        (for loss='squared_error'), or a quantile for the other losses.
+
+    random_state : int, RandomState instance or None, default=None
+        Controls the random seed given to each Tree estimator at each
+        boosting iteration.
+        In addition, it controls the random permutation of the features at
+        each split (see Notes for more details).
+        It also controls the random splitting of the training data to obtain a
+        validation set if `n_iter_no_change` is not None.
+        Pass an int for reproducible output across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    max_features : {'sqrt', 'log2'}, int or float, default=None
+        The number of features to consider when looking for the best split:
+
+        - If int, values must be in the range `[1, inf)`.
+        - If float, values must be in the range `(0.0, 1.0]` and the features
+          considered at each split will be `max(1, int(max_features * n_features_in_))`.
+        - If "sqrt", then `max_features=sqrt(n_features)`.
+        - If "log2", then `max_features=log2(n_features)`.
+        - If None, then `max_features=n_features`.
+
+        Choosing `max_features < n_features` leads to a reduction of variance
+        and an increase in bias.
+
+        Note: the search for a split does not stop until at least one
+        valid partition of the node samples is found, even if it requires to
+        effectively inspect more than ``max_features`` features.
+
+    alpha : float, default=0.9
+        The alpha-quantile of the huber loss function and the quantile
+        loss function. Only if ``loss='huber'`` or ``loss='quantile'``.
+        Values must be in the range `(0.0, 1.0)`.
+
+    verbose : int, default=0
+        Enable verbose output. If 1 then it prints progress and performance
+        once in a while (the more trees the lower the frequency). If greater
+        than 1 then it prints progress and performance for every tree.
+        Values must be in the range `[0, inf)`.
+
+    max_leaf_nodes : int, default=None
+        Grow trees with ``max_leaf_nodes`` in best-first fashion.
+        Best nodes are defined as relative reduction in impurity.
+        Values must be in the range `[2, inf)`.
+        If None, then unlimited number of leaf nodes.
+
+    warm_start : bool, default=False
+        When set to ``True``, reuse the solution of the previous call to fit
+        and add more estimators to the ensemble, otherwise, just erase the
+        previous solution. See :term:`the Glossary <warm_start>`.
+
+    validation_fraction : float, default=0.1
+        The proportion of training data to set aside as validation set for
+        early stopping. Values must be in the range `(0.0, 1.0)`.
+        Only used if ``n_iter_no_change`` is set to an integer.
+
+        .. versionadded:: 0.20
+
+    n_iter_no_change : int, default=None
+        ``n_iter_no_change`` is used to decide if early stopping will be used
+        to terminate training when validation score is not improving. By
+        default it is set to None to disable early stopping. If set to a
+        number, it will set aside ``validation_fraction`` size of the training
+        data as validation and terminate training when validation score is not
+        improving in all of the previous ``n_iter_no_change`` numbers of
+        iterations.
+        Values must be in the range `[1, inf)`.
+        See
+        :ref:`sphx_glr_auto_examples_ensemble_plot_gradient_boosting_early_stopping.py`.
+
+        .. versionadded:: 0.20
+
+    tol : float, default=1e-4
+        Tolerance for the early stopping. When the loss is not improving
+        by at least tol for ``n_iter_no_change`` iterations (if set to a
+        number), the training stops.
+        Values must be in the range `[0.0, inf)`.
+
+        .. versionadded:: 0.20
+
+    ccp_alpha : non-negative float, default=0.0
+        Complexity parameter used for Minimal Cost-Complexity Pruning. The
+        subtree with the largest cost complexity that is smaller than
+        ``ccp_alpha`` will be chosen. By default, no pruning is performed.
+        Values must be in the range `[0.0, inf)`.
+        See :ref:`minimal_cost_complexity_pruning` for details.
+
+        .. versionadded:: 0.22
+
+    Attributes
+    ----------
+    n_estimators_ : int
+        The number of estimators as selected by early stopping (if
+        ``n_iter_no_change`` is specified). Otherwise it is set to
+        ``n_estimators``.
+
+    n_trees_per_iteration_ : int
+        The number of trees that are built at each iteration. For regressors, this is
+        always 1.
+
+        .. versionadded:: 1.4.0
+
+    feature_importances_ : ndarray of shape (n_features,)
+        The impurity-based feature importances.
+        The higher, the more important the feature.
+        The importance of a feature is computed as the (normalized)
+        total reduction of the criterion brought by that feature.  It is also
+        known as the Gini importance.
+
+        Warning: impurity-based feature importances can be misleading for
+        high cardinality features (many unique values). See
+        :func:`sklearn.inspection.permutation_importance` as an alternative.
+
+    oob_improvement_ : ndarray of shape (n_estimators,)
+        The improvement in loss on the out-of-bag samples
+        relative to the previous iteration.
+        ``oob_improvement_[0]`` is the improvement in
+        loss of the first stage over the ``init`` estimator.
+        Only available if ``subsample < 1.0``.
+
+    oob_scores_ : ndarray of shape (n_estimators,)
+        The full history of the loss values on the out-of-bag
+        samples. Only available if `subsample < 1.0`.
+
+        .. versionadded:: 1.3
+
+    oob_score_ : float
+        The last value of the loss on the out-of-bag samples. It is
+        the same as `oob_scores_[-1]`. Only available if `subsample < 1.0`.
+
+        .. versionadded:: 1.3
+
+    train_score_ : ndarray of shape (n_estimators,)
+        The i-th score ``train_score_[i]`` is the loss of the
+        model at iteration ``i`` on the in-bag sample.
+        If ``subsample == 1`` this is the loss on the training data.
+
+    init_ : estimator
+        The estimator that provides the initial predictions. Set via the ``init``
+        argument.
+
+    estimators_ : ndarray of DecisionTreeRegressor of shape (n_estimators, 1)
+        The collection of fitted sub-estimators.
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    max_features_ : int
+        The inferred value of max_features.
+
+    See Also
+    --------
+    HistGradientBoostingRegressor : Histogram-based Gradient Boosting
+        Classification Tree.
+    sklearn.tree.DecisionTreeRegressor : A decision tree regressor.
+    sklearn.ensemble.RandomForestRegressor : A random forest regressor.
+
+    Notes
+    -----
+    The features are always randomly permuted at each split. Therefore,
+    the best found split may vary, even with the same training data and
+    ``max_features=n_features``, if the improvement of the criterion is
+    identical for several splits enumerated during the search of the best
+    split. To obtain a deterministic behaviour during fitting,
+    ``random_state`` has to be fixed.
+
+    References
+    ----------
+    J. Friedman, Greedy Function Approximation: A Gradient Boosting
+    Machine, The Annals of Statistics, Vol. 29, No. 5, 2001.
+
+    J. Friedman, Stochastic Gradient Boosting, 1999
+
+    T. Hastie, R. Tibshirani and J. Friedman.
+    Elements of Statistical Learning Ed. 2, Springer, 2009.
+
+    Examples
+    --------
+    >>> from sklearn.datasets import make_regression
+    >>> from sklearn.ensemble import GradientBoostingRegressor
+    >>> from sklearn.model_selection import train_test_split
+    >>> X, y = make_regression(random_state=0)
+    >>> X_train, X_test, y_train, y_test = train_test_split(
+    ...     X, y, random_state=0)
+    >>> reg = GradientBoostingRegressor(random_state=0)
+    >>> reg.fit(X_train, y_train)
+    GradientBoostingRegressor(random_state=0)
+    >>> reg.predict(X_test[1:2])
+    array([-61...])
+    >>> reg.score(X_test, y_test)
+    0.4...
+    """
+
+    _parameter_constraints: dict = {
+        **BaseGradientBoosting._parameter_constraints,
+        "loss": [StrOptions({"squared_error", "absolute_error", "huber", "quantile"})],
+        "init": [StrOptions({"zero"}), None, HasMethods(["fit", "predict"])],
+        "alpha": [Interval(Real, 0.0, 1.0, closed="neither")],
+    }
+
+    def __init__(
+        self,
+        *,
+        loss="squared_error",
+        learning_rate=0.1,
+        n_estimators=100,
+        subsample=1.0,
+        criterion="friedman_mse",
+        min_samples_split=2,
+        min_samples_leaf=1,
+        min_weight_fraction_leaf=0.0,
+        max_depth=3,
+        min_impurity_decrease=0.0,
+        init=None,
+        random_state=None,
+        max_features=None,
+        alpha=0.9,
+        verbose=0,
+        max_leaf_nodes=None,
+        warm_start=False,
+        validation_fraction=0.1,
+        n_iter_no_change=None,
+        tol=1e-4,
+        ccp_alpha=0.0,
+    ):
+        super().__init__(
+            loss=loss,
+            learning_rate=learning_rate,
+            n_estimators=n_estimators,
+            criterion=criterion,
+            min_samples_split=min_samples_split,
+            min_samples_leaf=min_samples_leaf,
+            min_weight_fraction_leaf=min_weight_fraction_leaf,
+            max_depth=max_depth,
+            init=init,
+            subsample=subsample,
+            max_features=max_features,
+            min_impurity_decrease=min_impurity_decrease,
+            random_state=random_state,
+            alpha=alpha,
+            verbose=verbose,
+            max_leaf_nodes=max_leaf_nodes,
+            warm_start=warm_start,
+            validation_fraction=validation_fraction,
+            n_iter_no_change=n_iter_no_change,
+            tol=tol,
+            ccp_alpha=ccp_alpha,
+        )
+
+    def _encode_y(self, y=None, sample_weight=None):
+        # Just convert y to the expected dtype
+        self.n_trees_per_iteration_ = 1
+        y = y.astype(DOUBLE, copy=False)
+        return y
+
+    def _get_loss(self, sample_weight):
+        if self.loss in ("quantile", "huber"):
+            return _LOSSES[self.loss](sample_weight=sample_weight, quantile=self.alpha)
+        else:
+            return _LOSSES[self.loss](sample_weight=sample_weight)
+
+    def predict(self, X):
+        """Predict regression target for X.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            The input samples. Internally, it will be converted to
+            ``dtype=np.float32`` and if a sparse matrix is provided
+            to a sparse ``csr_matrix``.
+
+        Returns
+        -------
+        y : ndarray of shape (n_samples,)
+            The predicted values.
+        """
+        X = self._validate_data(
+            X, dtype=DTYPE, order="C", accept_sparse="csr", reset=False
+        )
+        # In regression we can directly return the raw value from the trees.
+        return self._raw_predict(X).ravel()
+
+    def staged_predict(self, X):
+        """Predict regression target at each stage for X.
+
+        This method allows monitoring (i.e. determine error on testing set)
+        after each stage.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            The input samples. Internally, it will be converted to
+            ``dtype=np.float32`` and if a sparse matrix is provided
+            to a sparse ``csr_matrix``.
+
+        Yields
+        ------
+        y : generator of ndarray of shape (n_samples,)
+            The predicted value of the input samples.
+        """
+        for raw_predictions in self._staged_raw_predict(X):
+            yield raw_predictions.ravel()
+
+    def apply(self, X):
+        """Apply trees in the ensemble to X, return leaf indices.
+
+        .. versionadded:: 0.17
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            The input samples. Internally, its dtype will be converted to
+            ``dtype=np.float32``. If a sparse matrix is provided, it will
+            be converted to a sparse ``csr_matrix``.
+
+        Returns
+        -------
+        X_leaves : array-like of shape (n_samples, n_estimators)
+            For each datapoint x in X and for each tree in the ensemble,
+            return the index of the leaf x ends up in each estimator.
+        """
+
+        leaves = super().apply(X)
+        leaves = leaves.reshape(X.shape[0], self.estimators_.shape[0])
+        return leaves

venv/lib/python3.10/site-packages/sklearn/ensemble/_hist_gradient_boosting/__init__.py

@@ -0,0 +1,5 @@
+"""This module implements histogram-based gradient boosting estimators.
+
+The implementation is a port from pygbm which is itself strongly inspired
+from LightGBM.
+"""