a ù»j< ã @sŠdZddlZddlmZmZddlmZmZddlZ ddl mZddlm Z mZmZmZmZmZddlmZdd lmZmZdd lmZmZddlmZddlmZmZdd l m!Z!m"Z"m#Z#gd¢Z$eedƒkrÞddl m%Z&nddl m&Z&dd„Z'd0dd„Z(dd„Z)d1dd„Z*dd „Z+d!d"„Z,d#d$„Z-Gd%d&„d&eeeee ed'Z.Gd(d)„d)e.ƒZ/Gd*d+„d+e.ƒZ0Gd,d-„d-e.ƒZ1Gd.d/„d/eee ƒZ2dS)2zG The :mod:`sklearn.pls` module implements Partial Least Squares (PLS). éN)ÚABCMetaÚabstractmethod)ÚIntegralÚReal)Úsvdé)Ú BaseEstimatorÚClassNamePrefixFeaturesOutMixinÚMultiOutputMixinÚRegressorMixinÚTransformerMixinÚ_fit_context)ÚConvergenceWarning)Úcheck_arrayÚcheck_consistent_length)ÚIntervalÚ StrOptions)Úsvd_flip)Ú parse_versionÚ sp_version)ÚFLOAT_DTYPESÚcheck_is_fittedÚ validate_data)ÚPLSCanonicalÚ PLSRegressionÚPLSSVDz1.7)Úpinv)Úpinv2c Csšt|ddd\}}}|jj ¡}dddœ}t |¡||t |¡j}t ||k¡}|dd…d|…f}||d|…}t t t ||d|…¡¡¡S)NF)Ú full_matricesÚcheck_finiteg@@g€„.A)ÚfÚd)rÚdtypeÚcharÚlowerÚnpÚmaxÚfinfoÚepsÚsumZ transposeÚ conjugateÚdot)ÚaÚuÚsZvhÚtÚfactorZcondZrank©r1úFE:\soccer\ml_env\Lib\site-packages\sklearn/cross_decomposition/_pls.pyÚ _pinv2_old)s r3ÚAéôçíµ ÷Æ°>Fc s¦t |j¡j‰zt‡fdd„|jDƒƒ}Wn.tyX}ztdƒ|‚WYd}~n d}~00d}|dkrxt|ƒt|ƒ} } t|ƒD]ü}|dkršt | |¡}nt |j|¡t ||¡}|t t ||¡¡ˆ}t ||¡} |dkrðt | | ¡}nt |j| ¡t | j| ¡}|r,|t t ||¡¡ˆ}t ||¡t ||¡ˆ}||}t ||¡|ksr|jddkrxq~|}q€|d}||krœt dt¡|||fS) a?Return the first left and right singular vectors of X'Y. Provides an alternative to the svd(X'Y) and uses the power method instead. With norm_y_weights to True and in mode A, this corresponds to the algorithm section 11.3 of the Wegelin's review, except this starts at the "update saliences" part. c3s&|]}t t |¡ˆk¡r|VqdS©N)r%ÚanyÚabs)Ú.0Úcol©r(r1r2Ú Hóz;_get_first_singular_vectors_power_method..úy residual is constantNédÚBéz$Maximum number of iterations reached)r%r'r"r(ÚnextÚTÚ StopIterationr3Úranger+ÚsqrtÚshapeÚwarningsÚwarnr)ÚXÚYÚmodeÚmax_iterÚtolÚnorm_y_weightsZy_scoreÚeZ x_weights_oldZX_pinvZY_pinvÚiÚ x_weightsZx_scoreÚ y_weightsZx_weights_diffZn_iterr1r<r2Ú(_get_first_singular_vectors_power_method;s8 " rUcCs@t |j|¡}t|dd\}}}|dd…df|ddd…ffS)zbReturn the first left and right singular vectors of X'Y. Here the whole SVD is computed. F©rNr)r%r+rDr)rKrLÚCÚUÚ_ÚVtr1r1r2Ú_get_first_singular_vectors_svdvsr[TcCs¢|jdd}||8}|jdd}||8}|rr|jddd}d||dk<||}|jddd}d||dk<||}n t |jd¡}t |jd¡}||||||fS)z{Center X, Y and scale if the scale parameter==True Returns ------- X, Y, x_mean, y_mean, x_std, y_std r©ÚaxisrB)r]Zddofgð?ç)ÚmeanZstdr%ZonesrH)rKrLÚscaleZx_meanZy_meanZx_stdZy_stdr1r1r2Ú_center_scale_xy€s racCs2t t |¡¡}t ||¡}||9}||9}dS)z7Same as svd_flip but works on 1d arrays, and is inplaceN)r%Zargmaxr9Úsign)r-ÚvZbiggest_abs_val_idxrbr1r1r2Ú_svd_flip_1dšsrdcCs,|dur(t dt¡|dur$tdƒ‚|S|S)NzE`Y` is deprecated in 1.5 and will be removed in 1.7. Use `y` instead.z?Cannot use both `y` and `Y`. Use only `y` as `Y` is deprecated.)rIrJÚ FutureWarningÚ ValueError©ÚyrLr1r1r2Ú_deprecate_Y_when_optional¥sþÿricCs"|dur|durtdƒ‚t||ƒS)Nzy is required.)rfrirgr1r1r2Ú_deprecate_Y_when_required´srjcsèeZdZUdZeeddddgdgeddhƒged d hƒgeddhƒgeeddddgeed dddgdgdœZe e d<ed$ddd dddddœdd„ƒZe ddd%dd„ƒZd&dd„Zd'dd„Zd(dd„Zd)d d!„Z‡fd"d#„Z‡ZS)*Ú_PLSaPartial Least Squares (PLS) This class implements the generic PLS algorithm. Main ref: Wegelin, a survey of Partial Least Squares (PLS) methods, with emphasis on the two-block case https://stat.uw.edu/sites/default/files/files/reports/2000/tr371.pdf rBNÚleft©ÚclosedÚbooleanÚ regressionÚ canonicalr4rArÚnipalsr©Ún_componentsr`Údeflation_moderMÚ algorithmrNrOÚcopyÚ_parameter_constraintsrTr5r6)r`rurMrvrNrOrwc Cs4||_||_||_||_||_||_||_||_dSr7)rtrurMr`rvrNrOrw) Úselfrtr`rurMrvrNrOrwr1r1r2Ú__init__Ös z _PLS.__init__©Zprefer_skip_nested_validationcCs*t||ƒ}t||ƒt||tjd|jdd}t|dtjd|jdd}|jdkrbd|_| dd¡}nd|_|j d }|j d}|j d}|j}|jd kr t ||ƒn t |||ƒ}||krÊtd|›d|›d ƒ‚|jdk|_|j} t|||jƒ\} }|_|_|_|_t ||f¡|_t ||f¡|_t ||f¡|_t ||f¡|_t ||f¡|_t ||f¡|_g|_t |j¡j }t!|ƒD]} |j"dkrBtj#t $|¡d|kd d}d|dd…|f<z$t%| ||j&|j'|j(| d\}}}WnVt)y2}z`. .. versionadded:: 0.8 Parameters ---------- n_components : int, default=2 Number of components to keep. Should be in `[1, n_features]`. scale : bool, default=True Whether to scale `X` and `Y`. max_iter : int, default=500 The maximum number of iterations of the power method when `algorithm='nipals'`. Ignored otherwise. tol : float, default=1e-06 The tolerance used as convergence criteria in the power method: the algorithm stops whenever the squared norm of `u_i - u_{i-1}` is less than `tol`, where `u` corresponds to the left singular vector. copy : bool, default=True Whether to copy `X` and `Y` in :term:`fit` before applying centering, and potentially scaling. If `False`, these operations will be done inplace, modifying both arrays. Attributes ---------- x_weights_ : ndarray of shape (n_features, n_components) The left singular vectors of the cross-covariance matrices of each iteration. y_weights_ : ndarray of shape (n_targets, n_components) The right singular vectors of the cross-covariance matrices of each iteration. x_loadings_ : ndarray of shape (n_features, n_components) The loadings of `X`. y_loadings_ : ndarray of shape (n_targets, n_components) The loadings of `Y`. x_scores_ : ndarray of shape (n_samples, n_components) The transformed training samples. y_scores_ : ndarray of shape (n_samples, n_components) The transformed training targets. x_rotations_ : ndarray of shape (n_features, n_components) The projection matrix used to transform `X`. y_rotations_ : ndarray of shape (n_targets, n_components) The projection matrix used to transform `Y`. coef_ : ndarray of shape (n_target, n_features) The coefficients of the linear model such that `Y` is approximated as `Y = X @ coef_.T + intercept_`. intercept_ : ndarray of shape (n_targets,) The intercepts of the linear model such that `Y` is approximated as `Y = X @ coef_.T + intercept_`. .. versionadded:: 1.1 n_iter_ : list of shape (n_components,) Number of iterations of the power method, for each component. n_features_in_ : int Number of features seen during :term:`fit`. 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 -------- PLSCanonical : Partial Least Squares transformer and regressor. Examples -------- >>> from sklearn.cross_decomposition import PLSRegression >>> X = [[0., 0., 1.], [1.,0.,0.], [2.,2.,2.], [2.,5.,4.]] >>> y = [[0.1, -0.2], [0.9, 1.1], [6.2, 5.9], [11.9, 12.3]] >>> pls2 = PLSRegression(n_components=2) >>> pls2.fit(X, y) PLSRegression() >>> Y_pred = pls2.predict(X) For a comparison between PLS Regression and :class:`~sklearn.decomposition.PCA`, see :ref:`sphx_glr_auto_examples_cross_decomposition_plot_pcr_vs_pls.py`. rx©rurMrvrTr5r6©r`rNrOrwc s tƒj||ddd|||ddS)Nrpr4rrrs©r±rz©ryrtr`rNrOrwrµr1r2rz¦søzPLSRegression.__init__Ncs,t||ƒ}tƒ ||¡|j|_|j|_|S)r|)rjr±r§r’Z x_scores_r“Z y_scores_)ryrKrhrLrµr1r2r§´s zPLSRegression.fit)r)NN) r·r¸r¹rºrkrxr»r¼ÚparamÚpoprzr§r½r1r1rµr2r4s g ÿÿrcsXeZdZUdZiej¥Zeed<dD]Ze e¡q$ddddddd œ‡fd d„Z ‡ZS) ra^ Partial Least Squares transformer and regressor. For a comparison between other cross decomposition algorithms, see :ref:`sphx_glr_auto_examples_cross_decomposition_plot_compare_cross_decomposition.py`. Read more in the :ref:`User Guide `. .. versionadded:: 0.8 Parameters ---------- n_components : int, default=2 Number of components to keep. Should be in `[1, min(n_samples, n_features, n_targets)]`. scale : bool, default=True Whether to scale `X` and `Y`. algorithm : {'nipals', 'svd'}, default='nipals' The algorithm used to estimate the first singular vectors of the cross-covariance matrix. 'nipals' uses the power method while 'svd' will compute the whole SVD. max_iter : int, default=500 The maximum number of iterations of the power method when `algorithm='nipals'`. Ignored otherwise. tol : float, default=1e-06 The tolerance used as convergence criteria in the power method: the algorithm stops whenever the squared norm of `u_i - u_{i-1}` is less than `tol`, where `u` corresponds to the left singular vector. copy : bool, default=True Whether to copy `X` and `Y` in fit before applying centering, and potentially scaling. If False, these operations will be done inplace, modifying both arrays. Attributes ---------- x_weights_ : ndarray of shape (n_features, n_components) The left singular vectors of the cross-covariance matrices of each iteration. y_weights_ : ndarray of shape (n_targets, n_components) The right singular vectors of the cross-covariance matrices of each iteration. x_loadings_ : ndarray of shape (n_features, n_components) The loadings of `X`. y_loadings_ : ndarray of shape (n_targets, n_components) The loadings of `Y`. x_rotations_ : ndarray of shape (n_features, n_components) The projection matrix used to transform `X`. y_rotations_ : ndarray of shape (n_targets, n_components) The projection matrix used to transform `Y`. coef_ : ndarray of shape (n_targets, n_features) The coefficients of the linear model such that `Y` is approximated as `Y = X @ coef_.T + intercept_`. intercept_ : ndarray of shape (n_targets,) The intercepts of the linear model such that `Y` is approximated as `Y = X @ coef_.T + intercept_`. .. versionadded:: 1.1 n_iter_ : list of shape (n_components,) Number of iterations of the power method, for each component. Empty if `algorithm='svd'`. n_features_in_ : int Number of features seen during :term:`fit`. 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 -------- CCA : Canonical Correlation Analysis. PLSSVD : Partial Least Square SVD. Examples -------- >>> from sklearn.cross_decomposition import PLSCanonical >>> X = [[0., 0., 1.], [1.,0.,0.], [2.,2.,2.], [2.,5.,4.]] >>> y = [[0.1, -0.2], [0.9, 1.1], [6.2, 5.9], [11.9, 12.3]] >>> plsca = PLSCanonical(n_components=2) >>> plsca.fit(X, y) PLSCanonical() >>> X_c, y_c = plsca.transform(X, y) rx)rurMrTrrr5r6)r`rvrNrOrwc s tƒj||dd||||ddS)Nrqr4rsrÁ)ryrtr`rvrNrOrwrµr1r2rzEs øzPLSCanonical.__init__)r©r·r¸r¹rºrkrxr»r¼rÃrÄrzr½r1r1rµr2rÖs bþørcsVeZdZUdZiej¥Zeed<dD]Ze e¡q$ddddddœ‡fd d „Z ‡ZS)ÚCCAaCanonical Correlation Analysis, also known as "Mode B" PLS. For a comparison between other cross decomposition algorithms, see :ref:`sphx_glr_auto_examples_cross_decomposition_plot_compare_cross_decomposition.py`. Read more in the :ref:`User Guide `. Parameters ---------- n_components : int, default=2 Number of components to keep. Should be in `[1, min(n_samples, n_features, n_targets)]`. scale : bool, default=True Whether to scale `X` and `Y`. max_iter : int, default=500 The maximum number of iterations of the power method. tol : float, default=1e-06 The tolerance used as convergence criteria in the power method: the algorithm stops whenever the squared norm of `u_i - u_{i-1}` is less than `tol`, where `u` corresponds to the left singular vector. copy : bool, default=True Whether to copy `X` and `Y` in fit before applying centering, and potentially scaling. If False, these operations will be done inplace, modifying both arrays. Attributes ---------- x_weights_ : ndarray of shape (n_features, n_components) The left singular vectors of the cross-covariance matrices of each iteration. y_weights_ : ndarray of shape (n_targets, n_components) The right singular vectors of the cross-covariance matrices of each iteration. x_loadings_ : ndarray of shape (n_features, n_components) The loadings of `X`. y_loadings_ : ndarray of shape (n_targets, n_components) The loadings of `Y`. x_rotations_ : ndarray of shape (n_features, n_components) The projection matrix used to transform `X`. y_rotations_ : ndarray of shape (n_targets, n_components) The projection matrix used to transform `Y`. coef_ : ndarray of shape (n_targets, n_features) The coefficients of the linear model such that `Y` is approximated as `Y = X @ coef_.T + intercept_`. intercept_ : ndarray of shape (n_targets,) The intercepts of the linear model such that `Y` is approximated as `Y = X @ coef_.T + intercept_`. .. versionadded:: 1.1 n_iter_ : list of shape (n_components,) Number of iterations of the power method, for each component. n_features_in_ : int Number of features seen during :term:`fit`. 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 -------- PLSCanonical : Partial Least Squares transformer and regressor. PLSSVD : Partial Least Square SVD. Examples -------- >>> from sklearn.cross_decomposition import CCA >>> X = [[0., 0., 1.], [1.,0.,0.], [2.,2.,2.], [3.,5.,4.]] >>> y = [[0.1, -0.2], [0.9, 1.1], [6.2, 5.9], [11.9, 12.3]] >>> cca = CCA(n_components=1) >>> cca.fit(X, y) CCA(n_components=1) >>> X_c, Y_c = cca.transform(X, y) rxr¿rTr5r6rÀc s tƒj||ddd|||ddS)NrqrArrrsrÁrÂrµr1r2rzºsøzCCA.__init__)rrÅr1r1rµr2rÆ[s ZÿÿrÆc@sreZdZUdZeeddddgdgdgdœZeed<dd d dœdd „Z e d dddd„ƒZddd„Zddd„Z dS)ra¹Partial Least Square SVD. This transformer simply performs a SVD on the cross-covariance matrix `X'Y`. It is able to project both the training data `X` and the targets `Y`. The training data `X` is projected on the left singular vectors, while the targets are projected on the right singular vectors. Read more in the :ref:`User Guide `. .. versionadded:: 0.8 Parameters ---------- n_components : int, default=2 The number of components to keep. Should be in `[1, min(n_samples, n_features, n_targets)]`. scale : bool, default=True Whether to scale `X` and `Y`. copy : bool, default=True Whether to copy `X` and `Y` in fit before applying centering, and potentially scaling. If `False`, these operations will be done inplace, modifying both arrays. Attributes ---------- x_weights_ : ndarray of shape (n_features, n_components) The left singular vectors of the SVD of the cross-covariance matrix. Used to project `X` in :meth:`transform`. y_weights_ : ndarray of (n_targets, n_components) The right singular vectors of the SVD of the cross-covariance matrix. Used to project `X` in :meth:`transform`. n_features_in_ : int Number of features seen during :term:`fit`. 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 -------- PLSCanonical : Partial Least Squares transformer and regressor. CCA : Canonical Correlation Analysis. Examples -------- >>> import numpy as np >>> from sklearn.cross_decomposition import PLSSVD >>> X = np.array([[0., 0., 1.], ... [1., 0., 0.], ... [2., 2., 2.], ... [2., 5., 4.]]) >>> y = np.array([[0.1, -0.2], ... [0.9, 1.1], ... [6.2, 5.9], ... [11.9, 12.3]]) >>> pls = PLSSVD(n_components=2).fit(X, y) >>> X_c, y_c = pls.transform(X, y) >>> X_c.shape, y_c.shape ((4, 2), (4, 2)) rBNrlrmro©rtr`rwrxrT)r`rwcCs||_||_||_dSr7rÇ)ryrtr`rwr1r1r2rzszPLSSVD.__init__r{cCs0t||ƒ}t||ƒt||tjd|jdd}t|dtjd|jdd}|jdkrZ| dd¡}|j }t |jd |jd|jdƒ}||krœtd |›d|›dƒ‚t |||jƒ\}}|_|_|_|_t |j|¡}t|dd \}}} |dd…d|…f}| d|…} t|| ƒ\}} | j} ||_| |_|jjd|_|S)aFit model to data. Parameters ---------- X : array-like of shape (n_samples, n_features) Training samples. y : array-like of shape (n_samples,) or (n_samples, n_targets) Targets. Y : array-like of shape (n_samples,) or (n_samples, n_targets) Targets. .. deprecated:: 1.5 `Y` is deprecated in 1.5 and will be removed in 1.7. Use `y` instead. Returns ------- self : object Fitted estimator. Trr}rhFrrBr‚rrƒr„r…rVN)rjrrr%r‡rwrrˆrŠrtr‹rHrfrar`rŒrrŽrr+rDrrrr‘rŸ)ryrKrhrLrtr£rWrXr.rZÚVr1r1r2r§sR úú ÿÿÿz PLSSVD.fitcCsœt||ƒ}t|ƒt||tjdd}||j|j}t ||j¡}|dur˜t |ddtjd}|j dkrr| dd¡}||j|j }t ||j¡}||fS|S)aú Apply the dimensionality reduction. Parameters ---------- X : array-like of shape (n_samples, n_features) Samples to be transformed. y : array-like of shape (n_samples,) or (n_samples, n_targets), default=None Targets. Y : array-like of shape (n_samples,) or (n_samples, n_targets), default=None Targets. .. deprecated:: 1.5 `Y` is deprecated in 1.5 and will be removed in 1.7. Use `y` instead. Returns ------- x_scores : array-like or tuple of array-like The transformed data `X_transformed` if `Y is not None`, `(X_transformed, Y_transformed)` otherwise. F)r"r©Nrh)r€rr"rBr‚)rirrr%r‡rŒrŽr+rrrˆrŠrrr‘)ryrKrhrLZXrr¥Úyrr¦r1r1r2rª`s zPLSSVD.transformcCs| ||¡ ||¡S)aüLearn and apply the dimensionality reduction. Parameters ---------- X : array-like of shape (n_samples, n_features) Training samples. y : array-like of shape (n_samples,) or (n_samples, n_targets), default=None Targets. Returns ------- out : array-like or tuple of array-like The transformed data `X_transformed` if `Y is not None`, `(X_transformed, Y_transformed)` otherwise. r®r¯r1r1r2r°ˆszPLSSVD.fit_transform)r)NN)NN)N)r·r¸r¹rºrrrxr»r¼rzr r§rªr°r1r1r1r2rÉs DýG (r)r4r5r6F)T)3rºrIÚabcrrÚnumbersrrÚnumpyr%Zscipy.linalgrÚbaserr r rrr Ú exceptionsrÚutilsrrZutils._param_validationrrZ utils.extmathrZutils.fixesrrZutils.validationrrrÚ__all__rrr3rUr[rardrirjrkrrrÆrr1r1r1r2ÚsP ÿ ; ú|#n