Toggle Menu
Prev Up Next

scikit-learn 1.3.2
Other versions

Please cite us if you use the software.

# `sklearn.decomposition`.IncrementalPCA

class sklearn.decomposition.IncrementalPCA(n_components=None, *, whiten=False, copy=True, batch_size=None)

  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.

  Read more in the User Guide.

  New in version 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 fit.

      New in version 0.24.

    feature_names_in_ndarray of shape (`n_features_in_`,)

      Names of features seen during fit. Defined only when `X` has feature names that are all strings.

      New in version 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: 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.

  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)

  Methods

  `fit`(X[, y]) | Fit the model with X, using minibatches of size batch_size.
  `fit_transform`(X[, y]) | Fit to data, then transform it.
  `get_covariance`() | Compute data covariance with the generative model.
  `get_feature_names_out`([input_features]) | Get output feature names for transformation.
  `get_metadata_routing`() | Get metadata routing of this object.
  `get_params`([deep]) | Get parameters for this estimator.
  `get_precision`() | Compute data precision matrix with the generative model.
  `inverse_transform`(X) | Transform data back to its original space.
  `partial_fit`(X[, y, check_input]) | Incremental fit with X.
  `set_output`(*[, transform]) | Set output container.
  `set_params`(**params) | Set the parameters of this estimator.
  `set_partial_fit_request`(*[, check_input]) | Request metadata passed to the `partial_fit` method.
  `transform`(X) | Apply dimensionality reduction to X.

  fit(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.

  fit_transform(X, y=None, **fit_params)

    Fit to data, then transform it.

    Fits transformer to `X` and `y` with optional parameters `fit_params` and returns a transformed version of `X`.

    Parameters:
      X array-like of shape (n_samples, n_features)

        Input samples.

      y array-like of shape (n_samples,) or (n_samples, n_outputs), default=None

        Target values (None for unsupervised transformations).

      **fit_params dict

        Additional fit parameters.

    Returns:
      X_new ndarray array of shape (n_samples, n_features_new)

        Transformed array.

  get_covariance()

    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.

  get_feature_names_out(input_features=None)

    Get output feature names for transformation.

    The feature names out will prefixed by the lowercased class name. For example, if the transformer outputs 3 features, then the feature names out are: `["class_name0", "class_name1", "class_name2"]`.

    Parameters:
      input_features array-like of str or None, default=None

        Only used to validate feature names with the names seen in `fit`.

    Returns:
      feature_names_out ndarray of str objects

        Transformed feature names.

  get_metadata_routing()

    Get metadata routing of this object.

    Please check User Guide on how the routing mechanism works.

    Returns:
      routing MetadataRequest

        A `MetadataRequest` encapsulating routing information.

  get_params(deep=True)

    Get parameters for this estimator.

    Parameters:
      deep bool, default=True

        If True, will return the parameters for this estimator and contained subobjects that are estimators.

    Returns:
      params dict

        Parameter names mapped to their values.

  get_precision()

    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.

  inverse_transform(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.

  partial_fit(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.

  set_output(*, transform=None)

    Set output container.

    See Introducing the set_output API for an example on how to use the API.

    Parameters:
      transform{“default”, “pandas”}, default=None

        Configure output of `transform` and `fit_transform`.

        - `"default"`: Default output format of a transformer

        - `"pandas"`: DataFrame output

        - `None`: Transform configuration is unchanged

    Returns:
      self estimator instance

        Estimator instance.

  set_params(**params)

    Set the parameters of this estimator.

    The method works on simple estimators as well as on nested objects (such as `Pipeline`). The latter have parameters of the form `<component>__<parameter>` so that it’s possible to update each component of a nested object.

    Parameters:
      **params dict

        Estimator parameters.

    Returns:
      self estimator instance

        Estimator instance.

  set_partial_fit_request(*, check_input: bool | None | str = '$UNCHANGED$') → IncrementalPCA

    Request metadata passed to the `partial_fit` method.

    Note that this method is only relevant if `enable_metadata_routing=True` (see `sklearn.set_config`). Please see User Guide on how the routing mechanism works.

    The options for each parameter are:

    - `True`: metadata is requested, and passed to `partial_fit` if provided. The request is ignored if metadata is not provided.

    - `False`: metadata is not requested and the meta-estimator will not pass it to `partial_fit`.

    - `None`: metadata is not requested, and the meta-estimator will raise an error if the user provides it.

    - `str`: metadata should be passed to the meta-estimator with this given alias instead of the original name.

    The default (`sklearn.utils.metadata_routing.UNCHANGED`) retains the existing request. This allows you to change the request for some parameters and not others.

    New in version 1.3.

    Note

    This method is only relevant if this estimator is used as a sub-estimator of a meta-estimator, e.g. used inside a `Pipeline`. Otherwise it has no effect.

    Parameters:
      check_input str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED

        Metadata routing for `check_input` parameter in `partial_fit`.

    Returns:
      self object

        The updated object.

  transform(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)

## Examples using `sklearn.decomposition.IncrementalPCA`

Incremental PCA

Incremental PCA