:iLg0SrSSKrSSKJrJr SSKrSSKJr SSK J r J r J r J r SSKJr SSKJrJrJr SS KJrJrJrJr SS KJr S S /rS rSrSrSrS#Sjr Sr!Sr"\"S/S/S/S/S.SS9S#SSSSSSSSSSSSS . S!jj5r#"S"S \ \ \ 5r$g)$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)IntegralReal)linalg) BaseEstimatorClassNamePrefixFeaturesOutMixinTransformerMixin _fit_context)ConvergenceWarning)as_float_array check_arraycheck_random_state)IntervalOptions StrOptionsvalidate_params)check_is_fittedfasticaFastICAcnU[RRXSURUSU/5-nU$)aU 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)wWjs a/srv/projetos/modelo_ml_acdoc/venv/lib/python3.13/site-packages/sklearn/decomposition/_fastica.py_gs_decorrelationr s7*  a2A!BQ%0 11A Hcv[R"[R"XR55up[R "U[R "UR5RSS9n[RRUS[R"U5- -URU/5$)z8Symmetric decorrelation i.e. W <- (W * W.T) ^{-1/2} * W N)a_mina_max?) reighrdotrclipfinfodtypetinyrsqrt)rsus r_sym_decorrelationr-9s{ ;;rvva~ &DA !''*//trc [U5nA[URS5n[U5HnU"[R "X`5U5up[[R "XR 5U- U SS2[R4U-- 5n A A [[[[R"SX55S- 55n U nX:dM O [R"S[5 UWS-4$)z;Parallel FastICA. Used internally by FastICA --main loop r0Nzij,ij->iz\FastICA did not converge. Consider increasing tolerance or the maximum number of iterations.)r-floatr3r5rr%rnewaxisr;r9einsumwarningswarnr ) r<r=r>r?r@rArp_iirErFW1rHs r_ica_parrSks 6"A qwwqz BHoq h/  tSS 1B 6q"**}9MPQ9Q Q R %#c"))J67!;<=  9   A    b1f9rcURSS5nX-n[R"X5n[R"URSUR S9n[ U5H upVUSUS-- -R5XE'M" X44$)Nalphar#rr/r0r)getrtanhemptyr3r( enumerater8)xr?rUgxg_xrDgx_is r_logcoshr^sv LL# &EJA B ((1771:QWW -CR=1tQw;'--/! 7Nrcz[R"US-*S- 5nX-nSUS-- U-nX4RSS94$)Nrr0r1)rexpr8)rZr?rar[r\s r_exprbsG &&1a41 C B q!t8s C xxRx  rc6US-SUS--RSS94$)Nrr`r1)r8)rZr?s r_cuberes$ a4!ad(b) ))r array-likeboolean)r< return_X_meancompute_sources return_n_iterFprefer_skip_nested_validationparallel unit-variancelogcosh-C6?svdT) algorithmwhitenfunr?r@r=rA whiten_solver random_staterhrirjc T[UUUUUUUUU U S9 nUR5 URX S9nURS;aURnUR nOSnSnUUR U/nU (aURU5 U (aURUR5 U$)aWPerform 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 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 `. 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) rBrsrtrur?r@r=rArvrwri)rnarbitrary-varianceN) r_validate_params_fit_transformrt whitening_mean_ _unmixingr:n_iter_)r<rBrsrtrur?r@r=rArvrwrhrirjestSKX_meanreturned_valuess rrrsZ !  #! C 1>A zz<< NN #--+Ov&s{{+ rc t^\rSrSr%Sr\"\SSSS9S/\"SS15/\"S S 15\"\ S 15/\"1S k5\ /\ S/\"\SSSS9/\"\ S SSS9/SS/\"SS15/S/S. r \ \S'S#SS SSSSSSSS. U4SjjjrS$Sjr\"SS9S#Sj5r\"SS9S#Sj5rS%SjrS%Sjr\S 5rS!rS"rU=r$)&ripaYFastICA: 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' 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 `. 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) r0Nleft)closedrm deflationr{rnF>racuberogrfr$rrrwry_parameter_constraintsrorprq) rsrtrur?r@r=rArvrwc >[T U]5 XlX lX0lX@lXPlX`lXplXl Xl Xl gN) super__init__rBrsrtrur?r@r=rArvrw) selfrBrsrtrur?r@r=rArvrw __class__s rrFastICA.__init__sE ("    *(rc ^TRUTR[R[R/SS9R nTR c0O TR n[TR5nURSS5nSUs=::aS::d O [S5eTRS:Xa[nONTRS :Xa[nO7TRS :Xa[nO [TR5(aU4S jnUR upTR"n TR(dU bSn [$R&"S 5 U c [)X5n U [)X5:a$[)X5n [$R&"S U -5 TR(GaUR+SS9n X;SS2[R,4-nTR.S:Xa[0R2"UR5U55up[R6"U 5SSS2n[R8"U R:5R<S-nX:n[R>"U5(a[$R&"S5 XU'[R@"XS9 XU SS2U4pO+TR.S:XaB"USSS9SSupW [RD"U S5-n U W - R SU nA A [R4"UU5nU[R@"U 5-nO [GUSS9nTRHnUc.[RJ"URMX4S9UR:S9nO8[RJ"U5nUR X4:wa[SSX40-5eTRNWUTRPUS.nTRRS:Xa[UU40UD6unnOTRRS:Xa[WU40UD6unnAWTl,U(a`TR(a-[R0R[WWU/5R nO$[R4"WU5R nOSnTR(aTRS :Xa]U(d,[R0R[WWU/5R n[R\"USS!S"9nUU-nWUR -n[R4"WW5Tl/W Tl0UTl1OWTl/[0Rd"TR^SS#9Tl3UTl4U$)$aFit 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`. r)r6r(ensure_min_samplesNrUr#r0zalpha must be in [1,2]rorarc*>TR"U40UD6$r)ru)rZr?rs rr>!FastICA._fit_transform..gFsxx.X..rz(Ignoring n_components with whiten=False.z/n_components is too large: it will be set to %sr`r1r$ zfThere are some small singular values, using whiten_solver = 'svd' might lead to more accurate results.)outrrF) full_matrices check_finiter)r6)sizer/z/w_init has invalid shape -- should be %(shape)sr3)r=r>r?r@rArmrrnT)r2keepdims)r)5_validate_datartrfloat64float32rr?rrwrV ValueErrorrur^rbrecallabler3rBrNrOminr8rLrvrr$r%argsortr'r(epsanyr*rrsignr rAasarraynormalr=r@rsrSrIrrstd components_rr~pinvmixing_r)rr<riXTr?rwrUr> n_features n_samplesrBrdr, sort_indicesrdegenerate_idxrX1rAkwargsrrCrS_stds` rr}FastICA._fit_transform"su$ DKK BJJ'?TU! ! .2DMM)$*;*;<  Wc*EQ56 6 88y A XX A XX A dhh   /!# (( {{|7L MMD E  y5L #i4 4y5L MMALP  ;;;WW"W%F BJJ' 'B!!V+{{266!9-!zz!}TrT2 hhqww'++b0!"66.))MM, %(.!!!\/(:1##u,zz"ENrPQR 1 AQ -<(A12B "'')$ $B /B >ZZ##,)E#FbhhF ZZ'F|| ;; E <=> 88     >>Z ' .v.IAv ^^{ * .v.IAv  {{II''Ar 355FF1bMOOA ;;{{o-& ++Q2J799Aqq48U UWW !vva|D DJDO D {{4#3#3%H rTrkc"URUSS9$)aFit 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. Trzr}rr<ys r fit_transformFastICA.fit_transforms&""1d";;rc&URUSS9 U$)aOFit 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. Frzrrs rfit FastICA.fits$ Au5 rc.[U5 URX=(a UR[R[R /SS9nUR(aXR -n[R"XRR5$)aRecover 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)r6r(reset) rrrtrrrrr%rrrr<r6s r transformFastICA.transformsn$     )dkk2::rzz2JRW   ;; OAvva))++,,rc$[U5 [X=(a UR[R[R /S9n[R "XRR5nUR(aXR- nU$)aTransform 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. )r6r() rr rtrrrr%rrrrs rinverse_transformFastICA.inverse_transforms[  !5$++rzz2::>V W FF1llnn % ;; OArc4URRS$)z&Number of transformed output features.r)rr3rs r_n_features_outFastICA._n_features_outs%%a((rcFS[R[R/0$)Npreserves_dtype)rrrrs r _more_tagsFastICA._more_tagss!BJJ #;< ? D5' " 56A4Lh4?@sD89&$fe_56'($D$)  ))4Rh5<6<(56(-82))==rr)%rrNnumbersrrnumpyrscipyrbaserrr r exceptionsr utilsr r rutils._param_validationrrrrutils.validationr__all__rr-rIrSr^rbrerrrrrs" ,CCTT. i  2 A FD !*^#%;#  #(@    @@Fk=-/?k=r