-i2@SrSSKJr SSKrSSKJrJr SSKJ r SSK J r SSK J r SS KJr SS KJrJr SS KJr S S KJr "SS\5rg)z*Incremental Principal Components Analysis.)IntegralN)linalgsparse)metadata_routing) _fit_context) gen_batches)Interval)_incremental_mean_and_varsvd_flip) validate_data)_BasePCAc ^\rSrSr%SrS\R 0r\"\ SSSS9S/S/S/\"\ SSSS9S/S .r \ \ S 'SS S SS .Sjjr \"S S9SSj5r\"S S9SSj5rU4SjrU4SjrSrU=r$)IncrementalPCAahIncremental 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 `. .. 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) check_inputrNleft)closedboolean n_componentswhitencopy batch_size_parameter_constraintsFT)rrrc4XlX lX0lX@lgNr)selfrrrrs Y/var/www/html/venv/lib/python3.13/site-packages/sklearn/decomposition/_incremental_pca.py__init__IncrementalPCA.__init__s(  $)prefer_skip_nested_validationc .SUlSUlSUlSUlSUlSUlSUlSUl[UU/SQUR[R[R/SS9nURup4URc SU-UlOURUl[!X0RUR"=(d SS9HBnXn[$R&"U5(aUR)5nUR+US S 9 MD U$) aFit 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. Nr)csrcsclilT) accept_sparserdtypeforce_writeablemin_batch_sizeF)r) components_n_samples_seen_mean_var_singular_values_explained_variance_explained_variance_ratio_noise_variance_r rnpfloat64float32shaper batch_size_r rrissparsetoarray partial_fit)rXy n_samples n_featuresbatchX_batchs r fitIncrementalPCA.fits$    $#' )-&#   /::rzz*  !" ?? " :~D #D  ''8I8I8NQ EhGw''!//+   W%  8   r#c p[US5(+nU(a\[R"U5(a [S5e[ UUUR [ R[ R/SUS9nURupVU(aSUl URc=URc[XV5Ul OURRSUl OnURU::d[SURU4-5eURU:a#U(a[SURS US 35eURUl URbXURRSUR:wa1[S URRSUR4-5e[US 5(dSUlS UlS Ul[%UUR UR"[ R&"URURS5S9upxn U Sn URS:XaX-nO[ R("USS9n X-n[ R*"URU - U-5UR U - -n [ R,"UR.R1S5UR-UU 45n[2R4"USSS9upn[7XSS9upU S-U S- - nU S-[ R8"X-5- nXlUSURUl U SURUlXplXlUSURUlUSURUlURXV4;a#XRSR)5UlU$S UlU$)aIncremental 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. r0zIncrementalPCA.partial_fit does not support sparse input. Either convert data to dense or use IncrementalPCA.fit to do so in batches.T)rr+r,resetNrzdn_components=%r invalid for n_features=%d, need more rows than columns for IncrementalPCA processingz n_components=z6 must be less or equal to the batch number of samples z for the first partial_fit call.z{Number of input features has changed from %i to %i between calls to partial_fit! Try setting n_components to a fixed value.r1r&r) last_mean last_variancelast_sample_count)axis)rF) full_matrices check_finite)u_based_decisionr) hasattrrr= TypeErrorr rr8r9r:r;r0rmin n_components_ ValueErrorr1r2r3r repeatmeansqrtvstackr4reshapersvdr sumr5r6r7)rr@rAr first_passrBrCcol_meancol_varn_total_samplescol_batch_meanmean_correctionUSVtexplained_varianceexplained_variance_ratios r r?IncrementalPCA.partial_fits*!}55 q!!E YYzz2::. $ A!" #D     $'%(%?"%)%5%5%;%;A%>"""j0 $ 1 1:>?     *z 1 123//8k:$$  "&!2!2D     (    " "1 %);); ;9##))!,d.@.@AB t.//#$D DJDI.G jj)) ii(<([R"U5(aURSn/n[X RUR =(d SS9H1nUR [TU]!XR555 M3 [R"U5$[TU]!U5$)aIApply 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 rr.) rr=r;r r<rappendsuper transformr>r8rZ)rr@rBoutputrD __class__s r rmIncrementalPCA.transform}s< ??1   IF$++D[TU]5nSURlU$NT)rl__sklearn_tags__ input_tagsr)rtagsros r rsIncrementalPCA.__sklearn_tags__s!w')!% r#)rr<r0rr5r6r2rrUr1r7r4r3rrrr)__name__ __module__ __qualname____firstlineno____doc__rUNUSED._IncrementalPCA__metadata_request__partial_fitr rrdict__annotations__r!rrFr?rmrs__static_attributes__ __classcell__)ros@r rrseN(56F6M6M&N#"(AtFCTJ+ !T&A4H $D%EQU% 5161f5z6zx'(Rr#r)r{numbersrnumpyr8scipyrr sklearn.utilsrbaserutilsr utils._param_validationr utils.extmathr r utils.validationr _baserrr#r rs60  *.?,UXUr#