o tBh^ @sdZddlZddlZddlmZddlmZmZm Z ddl m Z ddl m Z mZmZddlmZd d gZd d Zd dZddZddZd#ddZddZddZ d#dddddddddddd d!d ZGd"d d e eeZdS)$z 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. N)linalg) BaseEstimatorTransformerMixin _ClassNamePrefixFeaturesOutMixin)ConvergenceWarning) check_arrayas_float_arraycheck_random_state)check_is_fittedfasticaFastICAcCs,|tj||d|j|d|g8}|S)a 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 N)npr multi_dotT)wWjru/var/www/html/riverr-enterprise-integrations-main/venv/lib/python3.10/site-packages/sklearn/decomposition/_fastica.py_gs_decorrelations(rcCsTtt||j\}}tj|t|jjdd}tj |dt ||j|gS)z@Symmetric decorrelation i.e. W <- (W * W.T) ^{-1/2} * W N)a_mina_max?) reighrdotrclipfinfodtypetinyrsqrt)rsurrr_sym_decorrelation3s"r#cCs|jd}tj||f|jd}g}t|D]n} || ddf} | t| d} t|D]C} |t| j ||\} } || j dd| | }t ||| |t|d}t t || d}|} ||krsnq0| | d| || ddf<q|t|fS)zcDeflationary FastICA using fun approx to neg-entropy function Used internally by FastICA. rrNraxis)shaperzerosrrangecopyr sumrrmeanrabsappendmax)Xtolgfun_argsmax_iterw_init n_componentsrn_iterrrigwtxg_wtxw1limrrr_ica_defBs&     r>c Cst|}~t|jd}t|D]?}|t|||\} } tt| |j|| ddtjf|} ~ ~ tt t t t| |jd} | }| |krOnqt dt ||dfS)zCParallel FastICA. Used internally by FastICA --main loop r%Nz\FastICA did not converge. Consider increasing tolerance or the maximum number of iterations.)r#floatr(r*rrrnewaxisr0r.diagwarningswarnr) r1r2r3r4r5r6rp_iir:r;W1r=rrr_ica_pares" ,$ rGcCsh|dd}||9}t||}tj|jd|jd}t|D]\}}|d|d||<q||fS)Nalpharrr$r%r)getrtanhemptyr(r enumerater-)xr4rHgxg_xr9gx_irrr_logcoshs  rQcCs<t|d d}||}d|d|}||jddfS)Nrr%r&)rexpr-)rMr4rSrNrOrrr_expsrTcCs|dd|djddfS)NrrRr&)r-rMr4rrr_cubesrWparallelrClogcosh-C6?FT) algorithmwhitenfunr4r5r2r6 random_state return_X_meancompute_sources return_n_iterc  Csvt||||||||| d } | j|| d}| jdvr | j}| j}nd}d}|| j|g}| r1||| r9|| j|S)aPerform Fast Independent Component Analysis. The implementation is based on [1]_. Read more in the :ref:`User Guide `. 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 extract. If None no dimension reduction is performed. algorithm : {'parallel', 'deflation'}, default='parallel' Apply a parallel or deflational FASTICA algorithm. whiten : str or bool, default="warn" Specify the whitening strategy to use. If 'arbitrary-variance' (default), 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. .. deprecated:: 1.1 From version 1.3, `whiten='unit-variance'` will be used by default. `whiten=True` is deprecated from 1.1 and will raise ValueError in 1.3. Use `whiten=arbitrary-variance` instead. 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, np.mean(3 * x ** 2, 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-04 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 of dimension (n.comp,n.comp). If None (default) then an array of normal r.v.'s is used. 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 `. 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. ) r7r\r]r^r4r5r2r6r_ra) unit-variancearbitrary-varianceN)r _fit_whiten whitening_mean_ _unmixingr/n_iter_)r1r7r\r]r^r4r5r2r6r_r`rarbestSKX_meanreturned_valuesrrrr s0     c s~eZdZdZ ddddddddddfd d Zdd d ZdddZdddZdddZdddZ e ddZ ddZ Z S)r aFastICA: a fast algorithm for Independent Component Analysis. The implementation is based on [1]_. Read more in the :ref:`User Guide `. Parameters ---------- n_components : int, default=None Number of components to use. If None is passed, all are used. algorithm : {'parallel', 'deflation'}, default='parallel' Apply parallel or deflational algorithm for FastICA. whiten : str or bool, default="warn" Specify the whitening strategy to use. If 'arbitrary-variance' (default), 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. .. deprecated:: 1.1 From version 1.3 whiten='unit-variance' will be used by default. `whiten=True` is deprecated from 1.1 and will raise ValueError in 1.3. Use `whiten=arbitrary-variance` instead. 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. 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 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 Tolerance on update at each iteration. w_init : ndarray of shape (n_components, n_components), default=None The mixing matrix to be used to initialize the algorithm. 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 `. 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) NrXrCrYrZr[)r\r]r^r4r5r2r6r_c sDt||_||_||_||_||_||_||_||_ | |_ dSN) super__init__r7r\r]r^r4r5r2r6r_) selfr7r\r]r^r4r5r2r6r_ __class__rrrss  zFastICA.__init__Fcsj_jdkrtdtd_jdur"tjdtddd_j|jtjtjgddj }j d ur8inj }t j }| d d }d |krSdksXtd td jdkr`t}n-jdkrht}n%jdkrpt}ntjr|fdd}ntjtrtnt}|dj|j\} } j} js| d urd } td| d urt| | } | t| | krt| | } td| jr|jdd} || d d tjf8}tj|ddd\} }}~| |j d | }~ ~t||}|t| 9}nt |dd}j!}|d urtj"|j#| | fd|j$d}nt"|}|j| | fkr,tdd| | fij%d kr:td&j%j'||j%|d }j(d!krUt)|fi|\}}nj(d"krft*|fi|\}}ntd#~|_+|rjrtj,|||gj }n t||j }nd }jrjd$kr|stj,|||gj }tj-|d%dd&}||}||j }t||_.| _/|_0n|_.tj1j.dd'_2|_3|S)(adFit 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`. rCz@From version 1.3 whiten='unit-variance' will be used by default.reTzFrom version 1.3 whiten=True should be specified as whiten='arbitrary-variance' (its current behaviour). This behavior is deprecated in 1.1 and will raise ValueError in 1.3.r) stacklevel)r+rensure_min_samplesNrHrr%zalpha must be in [1,2]rYrScubecsj|fi|Srq)r^rVrtrrr3 szFastICA._fit..gzJUnknown function %r; should be one of 'logcosh', 'exp', 'cube' or callablez(Ignoring n_components with whiten=False.z/n_components is too large: it will be set to %srRr&F) full_matrices check_finite)r+)sizer$z/w_init has invalid shape -- should be %(shape)sr(z4max_iter should be greater than 1, got (max_iter={}))r2r3r4r5r6rX deflationzrkrstd components_rirhpinvmixing_rj)rtr1raXTr4r_rHr3exc n_features n_samplesr7ror"d_rnX1r6kwargsrr8rmS_stdrrzrrfs                       z FastICA._fitcCs|j|ddS)a5Fit 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. Trcrfrtr1yrrr fit_transform|szFastICA.fit_transformcCs|j|dd|S)aFit 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. Frcrrrrrfitsz FastICA.fitTcCsHt||j||o |jtjtjgdd}|jr||j8}t||jj S)a_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. F)r+rreset) r rrgrrrrirrrrtr1r+rrr transforms zFastICA.transformcCsHt|t||o |jtjtjgd}t||jj}|jr"||j 7}|S)a1Transform 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. )r+r) r rrgrrrrrrrirrrrinverse_transforms  zFastICA.inverse_transformcCs |jjdS)z&Number of transformed output features.r)rr(rzrrr_n_features_outs zFastICA._n_features_outcCsdtjtjgiS)Npreserves_dtype)rrrrzrrr _more_tagsszFastICA._more_tagsrq)F)T)__name__ __module__ __qualname____doc__rsrfrrrrpropertyrr __classcell__rrrurr Bs,z  *    rq)rrBnumpyrscipyrbaserrr exceptionsrutilsrr r utils.validationr __all__rr#r>rGrQrTrWr r rrrrs@    #   )