o Û?Hh¢›ã @sŒdZddlZddlmZmZddlmZmZddlZ ddl m Z ddl m Z mZmZmZmZmZddlmZdd lmZmZdd lmZmZdd lmZdd lmZmZdd l m!Z!m"Z"m#Z#gd¢Z$eedƒkroddl 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ÚsumÚ transposeÚ conjugateÚdot)ÚaÚuÚsÚvhÚtÚfactorÚcondÚrank©r5ú`/home/air/sanwanet/gpt-api/venv/lib/python3.10/site-packages/sklearn/cross_decomposition/_pls.pyÚ _pinv2_old)s   r7ÚAéôçíµ ÷Æ°>Fc st |j¡j‰zt‡fdd„|jDƒƒ}Wnty&}ztdƒ|‚d}~wwd}|dkr6t|ƒt|ƒ} } t|ƒD]z} |dkrGt  | |¡} n t  |j|¡t  ||¡} | t  t  | | ¡¡ˆ} t  || ¡} |dkrrt  | | ¡}nt  |j| ¡t  | j| ¡}|r|t  t  ||¡¡ˆ}t  ||¡t  ||¡ˆ}| |}t  ||¡|ks°|j ddkr²n| }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(r5r6Ú Hs€&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Ú StopIterationr7Úranger,ÚsqrtÚshapeÚwarningsÚwarnr)ÚXÚYÚmodeÚmax_iterÚtolÚnorm_y_weightsÚy_scoreÚeÚ x_weights_oldÚX_pinvÚY_pinvÚiÚ x_weightsÚx_scoreÚ y_weightsÚx_weights_diffÚn_iterr5r@r6Ú(_get_first_singular_vectors_power_method;s<  €ÿ    r_cCs@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,rGr)rNrOÚCÚUÚ_ÚVtr5r5r6Ú_get_first_singular_vectors_svdvs reTcCs¢|jdd}||8}|jdd}||8}|r9|jddd}d||dk<||}|jddd}d||dk<||}nt |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©ÚaxisrE)rgÚddofgð?ç)ÚmeanÚstdr%ÚonesrK)rNrOÚscaleÚx_meanÚy_meanÚx_stdÚy_stdr5r5r6Ú_center_scale_xy€s     rrcCs2t t |¡¡}t ||¡}||9}||9}dS)z7Same as svd_flip but works on 1d arrays, and is inplaceN)r%Úargmaxr=Úsign)r.ÚvÚbiggest_abs_val_idxrtr5r5r6Ú _svd_flip_1dšs rwcCs,|durt dt¡|durtdƒ‚|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.)rLrMÚ FutureWarningÚ ValueError©ÚyrOr5r5r6Ú_deprecate_Y_when_optional¥sþÿr|cCs"|dur |dur tdƒ‚t||ƒS)Nzy is required.)ryr|rzr5r5r6Ú_deprecate_Y_when_required´s r}c sêeZdZUdZeeddddgdgeddhƒged d hƒged d hƒgeeddddgeed dddgdgdœZe e d<e d$ddd d ddddœdd„ƒZ e 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 rENÚleft©ÚclosedÚbooleanÚ regressionÚ canonicalr8rDrÚnipalsr©Ú n_componentsrmÚdeflation_moderPÚ algorithmrQrRÚcopyÚ_parameter_constraintsrTr9r:)rmrˆrPr‰rQrRrŠc Cs4||_||_||_||_||_||_||_||_dSr;)r‡rˆrPrmr‰rQrRrŠ) Úselfr‡rmrˆrPr‰rQrRrŠr5r5r6Ú__init__Ös  z _PLS.__init__©Úprefer_skip_nested_validationc Cst||ƒ}t||ƒt||tjd|jdd}t|dtjd|jdd}|jdkr1d|_|  dd¡}nd|_|j d }|j d}|j d}|j }|j d krPt ||ƒnt |||ƒ}||kretd |›d |›d ƒ‚|j dk|_|j} t|||jƒ\} } |_|_|_|_t ||f¡|_t ||f¡|_t ||f¡|_t ||f¡|_t ||f¡|_t ||f¡|_g|_t | j¡j } t!|ƒD]} |j"dkrtj#t $| ¡d| kd d}d| dd…|f<zt%| | |j&|j'|j(| d\}}}Wn#t)y}zt*|ƒdkrþ‚t+ ,d| ›¡WYd}~n·d}~ww|j -|¡n |j"dkr&t.| | ƒ\}}t/||ƒt 0| |¡}| r7d}nt 0||¡}t 0| |¡|}t 0|| ¡t 0||¡}| t 1||¡8} |j dkrst 0|| ¡t 0||¡}| t 1||¡8} |j d krt 0|| ¡t 0||¡}| t 1||¡8} ||jdd…| f<||jdd…| f<||jdd…| f<||jdd…| f<||jdd…| f<||jdd…| f<q½t 0|jt2t 0|jj3|j¡dd¡|_4t 0|jt2t 0|jj3|j¡dd¡|_5t 0|j4|jj3¡|_6|j6|jj3|j|_6|j|_7|j4j d|_8|S)ádFit model to data. Parameters ---------- X : array-like of shape (n_samples, n_features) Training vectors, where `n_samples` is the number of samples and `n_features` is the number of predictors. y : array-like of shape (n_samples,) or (n_samples, n_targets) Target vectors, where `n_samples` is the number of samples and `n_targets` is the number of response variables. Y : array-like of shape (n_samples,) or (n_samples, n_targets) Target vectors, where `n_samples` is the number of samples and `n_targets` is the number of response variables. .. deprecated:: 1.5 `Y` is deprecated in 1.5 and will be removed in 1.7. Use `y` instead. Returns ------- self : object Fitted model. Tr©r"Úforce_writeablerŠÚensure_min_samplesr{F©Ú input_namer"r’rŠÚ ensure_2drEéÿÿÿÿrrƒú`n_components` upper bound is ú. Got ú instead. Reduce `n_components`.r„r…é rfriN)rPrQrRrSrBz$y residual is constant at iteration r)r)9r}rrr%Úfloat64rŠrÚndimÚ _predict_1dÚreshaperKr‡rˆÚminryÚ_norm_y_weightsrrrmÚ_x_meanÚ_y_meanÚ_x_stdÚ_y_stdÚzerosÚ x_weights_Ú y_weights_Ú _x_scoresÚ _y_scoresÚ x_loadings_Ú y_loadings_Ún_iter_r'r"r(rIr‰Úallr=r_rPrQrRrHÚstrrLrMÚappendrerwr,ÚouterrrGÚ x_rotations_Ú y_rotations_Úcoef_Ú intercept_Ú_n_features_out)rŒrNr{rOÚnÚpÚqr‡Úrank_upper_boundrSÚXkÚykÚy_epsÚkÚyk_maskrZr\r­rUÚx_scoresÚy_ssÚy_scoresÚ x_loadingsÚ y_loadingsr5r5r6ÚfitìsÖ  úú    ÿÿÿ ÿ úü €ü       þþz_PLS.fitcCs¤t||ƒ}t|ƒt|||tdd}||j8}||j}t ||j¡}|durPt |dd|td}|j dkr;|  dd¡}||j 8}||j }t ||j¡}||fS|S)aApply the dimension reduction. Parameters ---------- X : array-like of shape (n_samples, n_features) Samples to transform. y : array-like of shape (n_samples, n_targets), default=None Target vectors. Y : array-like of shape (n_samples, n_targets), default=None Target vectors. .. deprecated:: 1.5 `Y` is deprecated in 1.5 and will be removed in 1.7. Use `y` instead. copy : bool, default=True Whether to copy `X` and `Y`, or perform in-place normalization. Returns ------- x_scores, y_scores : array-like or tuple of array-like Return `x_scores` if `Y` is not given, `(x_scores, y_scores)` otherwise. F©rŠr"ÚresetNr{)r•r–rŠr"rEr—)r|rrrr¢r¤r%r,r²rrrŸr£r¥r³)rŒrNr{rOrŠrÀrÂr5r5r6Ú transform˜s"    ÿ    z_PLS.transformcCsŠt||ƒ}t|ƒt|dtd}t ||jj¡}||j9}||j 7}|durCt|dtd}t ||j j¡}||j 9}||j 7}||fS|S)a©Transform data back to its original space. Parameters ---------- X : array-like of shape (n_samples, n_components) New data, where `n_samples` is the number of samples and `n_components` is the number of pls components. y : array-like of shape (n_samples,) or (n_samples, n_components) New target, where `n_samples` is the number of samples and `n_components` is the number of pls components. Y : array-like of shape (n_samples, n_components) New target, where `n_samples` is the number of samples and `n_components` is the number of pls components. .. deprecated:: 1.5 `Y` is deprecated in 1.5 and will be removed in 1.7. Use `y` instead. Returns ------- X_reconstructed : ndarray of shape (n_samples, n_features) Return the reconstructed `X` data. y_reconstructed : ndarray of shape (n_samples, n_targets) Return the reconstructed `X` target. Only returned when `y` is given. Notes ----- This transformation will only be exact if `n_components=n_features`. rN)r•r"Nr{) r|rrrr%Úmatmulr«rGr¤r¢r¬r¥r£)rŒrNr{rOÚX_reconstructedÚy_reconstructedr5r5r6Úinverse_transformÇs     z_PLS.inverse_transformcCsHt|ƒt|||tdd}||j8}||jj|j}|jr"| ¡S|S)aUPredict targets of given samples. Parameters ---------- X : array-like of shape (n_samples, n_features) Samples. copy : bool, default=True Whether to copy `X` and `Y`, or perform in-place normalization. Returns ------- y_pred : ndarray of shape (n_samples,) or (n_samples, n_targets) Returns predicted values. Notes ----- This call requires the estimation of a matrix of shape `(n_features, n_targets)`, which may be an issue in high dimensional space. FrÆ) rrrr¢r´rGrµržÚravel)rŒrNrŠÚYpredr5r5r6Úpredictüs  z _PLS.predictcCó| ||¡ ||¡S)a£Learn and apply the dimension reduction on the train data. Parameters ---------- X : array-like of shape (n_samples, n_features) Training vectors, where `n_samples` is the number of samples and `n_features` is the number of predictors. y : array-like of shape (n_samples, n_targets), default=None Target vectors, where `n_samples` is the number of samples and `n_targets` is the number of response variables. Returns ------- self : ndarray of shape (n_samples, n_components) Return `x_scores` if `Y` is not given, `(x_scores, y_scores)` otherwise. ©rÅrÈ©rŒrNr{r5r5r6Ú fit_transformóz_PLS.fit_transformcstƒ ¡}d|j_d|j_|S)NTF)ÚsuperÚ__sklearn_tags__Úregressor_tagsÚ poor_scoreÚ target_tagsÚrequired)rŒÚtags©Ú __class__r5r6rÖ-s z_PLS.__sklearn_tags__©r©NN)NNT©Tr;)Ú__name__Ú __module__Ú __qualname__Ú__doc__rrrrr‹ÚdictÚ__annotations__rrr rÅrÈrÌrÏrÓrÖÚ __classcell__r5r5rÜr6r~ºs<     ø þö  , / 5 r~)Ú metaclasscsfeZdZUdZiej¥Zeed<dD]Ze  e¡q ddddddœ‡fd d „ Z d‡fd d „ Z ‡Z S)raÏ PLS regression. PLSRegression is also known as PLS2 or PLS1, depending on the number of targets. 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, 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`. r‹©rˆrPr‰rTr9r:©rmrQrRrŠc ó tƒj||ddd|||ddS)Nrƒr8r…r†©rÕr©rŒr‡rmrQrRrŠrÜr5r6r¦ó øzPLSRegression.__init__Ncs,t||ƒ}tƒ ||¡|j|_|j|_|S)r)r}rÕrÅr©Ú x_scores_rªÚ y_scores_)rŒrNr{rOrÜr5r6rÅ´s zPLSRegression.fitrÞrß) rárârãrär~r‹råræÚparamÚpoprrÅrçr5r5rÜr6r4s g  ÿÿrcsZeZdZUdZiej¥Zeed<dD]Ze  e¡q d dddddd œ‡fd d „ Z ‡Z S) 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) r‹)rˆrPrTr…r9r:)rmr‰rQrRrŠc s tƒj||dd||||ddS)Nr„r8r†rì)rŒr‡rmr‰rQrRrŠrÜr5r6rEs  øzPLSCanonical.__init__rÞ© rárârãrär~r‹rårærñròrrçr5r5rÜr6rÖs b  þørcsXeZdZUdZiej¥Zeed<dD]Ze  e¡q d dddddœ‡fd d „ Z ‡Z S) ÚCCAa Canonical 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) r‹rérTr9r:rêc rë)Nr„rDr…r†rìrírÜr5r6rºrîz CCA.__init__rÞrór5r5rÜr6rô[s Z ÿÿrôc@sreZdZUdZeeddddgdgdgdœZeed<dd d d œd d „Z e d dddd„ƒZ ddd„Z ddd„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)) rENrr€r‚©r‡rmrŠr‹rT)rmrŠcCs||_||_||_dSr;rõ)rŒr‡rmrŠr5r5r6rs zPLSSVD.__init__rŽc Cs0t||ƒ}t||ƒt||tjd|jdd}t|dtjd|jdd}|jdkr-| dd¡}|j }t |j d |j d|j dƒ}||krNt d |›d |›d ƒ‚t |||jƒ\}}|_|_|_|_t |j|¡}t|dd \}}} |dd…d|…f}| d|…} t|| ƒ\}} | j} ||_| |_|jj d|_|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‘r{Fr”rEr—rr˜r™ršr`N)r}rrr%rœrŠrrrŸr‡r rKryrrrmr¢r£r¤r¥r,rGrrr§r¨r¶) rŒrNr{rOr‡rºrarbr/rdÚVr5r5r6rÅsR  úú  ÿÿÿ z PLSSVD.fitcCsœt||ƒ}t|ƒt||tjdd}||j|j}t ||j¡}|durLt |ddtjd}|j dkr9|  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ÇNr{)r•r–r"rEr—)r|rrr%rœr¢r¤r,r§rrrŸr£r¥r¨)rŒrNr{rOÚXrrÀÚyrrÂr5r5r6rÈ`s   zPLSSVD.transformcCrÐ)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Òr5r5r6rÓˆrÔzPLSSVD.fit_transformrÞrßr;)rárârãrärrr‹rårærr rÅrÈrÓr5r5r5r6rÉs Dý  G(r)r8r9r:Frà)3rärLÚabcrrÚnumbersrrÚnumpyr%Ú scipy.linalgrÚbaserr r r r r Ú exceptionsrÚutilsrrÚutils._param_validationrrÚ utils.extmathrÚ utils.fixesrrÚutils.validationrrrÚ__all__rrr7r_rerrrwr|r}r~rrrôrr5r5r5r6ÚsR       ÿ;   ú|#n