Class IncrementalPCAScikitsLearnNode

Incremental principal components analysis (IPCA).

This node has been automatically generated by wrapping the ``sklearn.decomposition.incremental_pca.IncrementalPCA`` class
from the ``sklearn`` library.  The wrapped instance can be accessed
through the ``scikits_alg`` attribute.

Linear dimensionality reduction using Singular Value Decomposition of
centered data, keeping only the most significant singular vectors to
project the data to a lower dimensional space.

Depending on the size of the input data, this algorithm can be much more
memory efficient than a PCA.

This algorithm has constant memory complexity, on the order
of ``batch_size``, enabling use of np.memmap files without loading the
entire file into memory.

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 :ref:`User Guide <IncrementalPCA>`.

**Parameters**

n_components : int or None, (default=None)
    Number of components to keep. If ``n_components `` is ``None``,
    then ``n_components`` is set to ``min(n_samples, n_features)``.

batch_size : int or None, (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.

copy : bool, (default=True)
    If False, X will be overwritten. ``copy=False`` can be used to
    save memory but is unsafe for general use.

whiten : bool, optional
    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.

**Attributes**

``components_`` : array, shape (n_components, n_features)
    Components with maximum variance.

``explained_variance_`` : array, shape (n_components,)
    Variance explained by each of the selected components.

``explained_variance_ratio_`` : array, 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

``mean_`` : array, shape (n_features,)
    Per-feature empirical mean, aggregate over calls to ``partial_fit``.

``var_`` : array, 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.

**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 http://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.`
See http://www.cs.technion.ac.il/~mic/doc/skl-ip.pdf

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.

See also

PCA
RandomizedPCA
KernelPCA
SparsePCA
TruncatedSVD

Overrides: object.__init__

Apply dimensionality reduction to X.

This node has been automatically generated by wrapping the sklearn.decomposition.incremental_pca.IncrementalPCA class from the sklearn library. The wrapped instance can be accessed through the scikits_alg attribute.

X is projected on the first principal components previously extracted from a training set.

Parameters

X : array-like, 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, shape (n_samples, n_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, copy=True, n_components=2, whiten=False)
>>> ipca.transform(X) # doctest: +SKIP

Overrides: Node.execute

Overrides: Node.is_invertible

(inherited documentation)

Overrides: Node.is_trainable

Fit the model with X, using minibatches of size batch_size.

This node has been automatically generated by wrapping the sklearn.decomposition.incremental_pca.IncrementalPCA class from the sklearn library. The wrapped instance can be accessed through the scikits_alg attribute.

Parameters

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

Training data, where n_samples is the number of samples and n_features is the number of features.

y: Passthrough for Pipeline compatibility.

Returns

self: object

Returns the instance itself.

Overrides: Node.stop_training