Ug dZddlZddlmZmZddlmZmZddlZ ddl m Z ddl m Z mZmZmZmZmZddlmZdd lmZmZdd lmZmZdd lmZdd lmZmZdd l m!Z!m"Z"gdZ#eedkrddl m$Z%nddl m%Z%dZ& d)dZ'dZ(d*dZ)dZ*dZ+dZ,Gddeeeee e Z-Gd!d"e-Z.Gd#d$e-Z/Gd%d&e-Z0Gd'd(eee Z1dS)+zG The :mod:`sklearn.pls` module implements Partial Least Squares (PLS). N)ABCMetaabstractmethod)IntegralReal)svd) BaseEstimatorClassNamePrefixFeaturesOutMixinMultiOutputMixinRegressorMixinTransformerMixin _fit_context)ConvergenceWarning) check_arraycheck_consistent_length)Interval StrOptions)svd_flip) parse_version sp_version) FLOAT_DTYPEScheck_is_fitted) PLSCanonical PLSRegressionPLSSVDz1.7)pinv)pinv2c t|dd\}}}|jj}ddd}t j|||zt j|jz}t j||k}|ddd|f}||d|z}t j t j t j ||d|S)NF) full_matrices check_finiteg@@g.A)fd) rdtypecharlowernpmaxfinfoepssum transpose conjugatedot)ausvhtfactorcondranks _/var/www/surfInsights/venv3-11/lib/python3.11/site-packages/sklearn/cross_decomposition/_pls.py _pinv2_oldr7)s 1E>>>HAq"  AS ! !F 6!99vay 28A;;? 2D 6!d(  D !!!UdU( A5D5MA < RVAr%4%y%9%9:: ; ;;Aư>Fcntj|jj t fd|jD}n"#t $r}t d|d}~wwxYwd}|dkrt|t|} } t|D]r} |dkrtj | |} n0tj |j|tj ||z } | tj tj | | zz} tj || } |dkrtj | | }n5tj |j| tj | j| z }|r-|tj tj ||zz}tj ||tj ||zz }| |z }tj |||ks|j ddkrn| }t| dz}||krtj 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. c3pK|]0}tjtj|k,|V1dSN)r&anyabs).0colr)s r6 z;_get_first_singular_vectors_power_method..Hs?GGsRVBF3KK#4E-F-FGsGGGGGGr8y residual is constantNdBz$Maximum number of iterations reached)r&r(r#r)nextT StopIterationr7ranger-sqrtshapewarningswarnr)XYmodemax_itertolnorm_y_weightsy_scoree x_weights_oldX_pinvY_pinvi x_weightsx_score y_weightsx_weights_diffn_iterr)s @r6(_get_first_singular_vectors_power_methodra;s- (17   C=GGGGacGGGGG ===4551<=M s{{$A 1  8__"" 3;;vw//IIqsG,,rvgw/G/GGIRWRVIy99::S@@ &I&& 3;;vw//IIqsG,,rvgi/I/III  E  9!=!=>>D DI&I&&"&I*F*F*LM"]2 6.. 1 1C 7 7171:?? E! UF  <>PQQQ i ''s A A! AA!ctj|j|}t|d\}}}|dddf|dddffS)zbReturn the first left and right singular vectors of X'Y. Here the whole SVD is computed. FrNr)r&r-rIr)rPrQCU_Vts r6_get_first_singular_vectors_svdrhvsP qsAA1E***HAq" QQQT7Bq!!!tH r8Tc|d}||z}|d}||z}|rK|dd}d||dk<||z}|dd}d||dk<||z}n>tj|jd}tj|jd}||||||fS)z{Center X, Y and scale if the scale parameter==True Returns ------- X, Y, x_mean, y_mean, x_std, y_std raxisrG)rkddofg?)meanstdr&onesrM)rPrQscalex_meany_meanx_stdy_stds r6_center_scale_xyrvsVVV^^FKA VVV^^FKA $11%%!esl U 11%%!esl U  ## ## a --r8ctjtj|}tj||}||z}||z}dS)z7Same as svd_flip but works on 1d arrays, and is inplaceN)r&argmaxr@sign)r/vbiggest_abs_val_idxrys r6 _svd_flip_1dr|sG)BF1II.. 71() * *DIAIAAAr8cd|-tjdt|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.)rNrO FutureWarning ValueErroryrQs r6_deprecate_Y_when_optionalrsI} S     =Q  Hr8cH||tdt||S)Nzy is required.)rrrs r6_deprecate_Y_when_requiredrs*yQY)*** %a + ++r8c ReZdZUdZeedddgdgeddhged d hged d hgeedddgeed ddgdgdZe e d<e dddd d dddddZ e dddZddZddZd dZd!dZdZdS)"_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 rGNleftclosedboolean regression canonicalr9rFrnipalsr n_componentsrqdeflation_moderR algorithmrSrTcopy_parameter_constraintsrTr:r;)rqrrRrrSrTrcv||_||_||_||_||_||_||_||_dSr>)rrrRrqrrSrTr) selfrrqrrRrrSrTrs r6__init__z _PLS.__init__sB),  "   r8prefer_skip_nested_validationc X t||}t||||tjd|jd}t |dtjd|jd}|jdkrd|_| dd}nd|_|j d }|j d}|j d}|j }|j d kr|nt|||}||krtd |d |d |j dk|_|j} t!|||j\} } |_|_|_|_tj||f|_tj||f|_tj||f|_tj||f|_tj||f|_tj||f|_g|_tj| jj } tC|D]w} |j"dkrtj#tj$| d| zkd }d| dd|f< tK| | |j&|j'|j(| \}}}nD#tR$r7}tU|dkrtWj,d| Yd}~nd}~wwxYw|j-|n|j"dkrt]| | \}}t_||tj0| |}| rd}ntj0||}tj0| ||z }tj0|| tj0||z }| tj1||z} |j dkrCtj0|| tj0||z }| tj1||z} |j d krCtj0|| tj0||z }| tj1||z} ||jdd| f<||jdd| f<||jdd| f<||jdd| f<||jdd| f<||jdd| f<ytj0|jtetj0|jj3|jd|_4tj0|jtetj0|jj3|jd|_5tj0|j4|jj3|_6|j6|jzj3|jz |_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. Trr#force_writeablerensure_min_samplesrF input_namer#rr ensure_2drGrr`n_components` upper bound is . Got instead. Reduce `n_components`.rr rjrmN)rRrSrTrUrDz$y residual is constant at iteration r)r )9rr_validate_datar&float64rrndim _predict_1dreshaperMrrminr_norm_y_weightsrvrq_x_mean_y_mean_x_std_y_stdzeros x_weights_ y_weights_ _x_scores _y_scores x_loadings_ y_loadings_n_iter_r(r#r)rKrallr@rarRrSrTrJstrrNrOappendrhr|r-outerrrI x_rotations_ y_rotations_coef_ intercept__n_features_out)rrPrrQnpqrrank_upper_boundrUXkyky_epskyk_maskr\r^rrWx_scoresy_ssy_scores x_loadings y_loadingss r6fitz_PLS.fits4 'q! , ,1%%%    *      *      6Q;;#D  "a  AA$D  GAJ GAJ GAJ( !% 3| C C11QPQST * * *F1AFF#FFF  $2kA-HX q$*H H DB dlDK(A|#455(A|#4551l"3441l"3448Q $5668Q $566 ""&|$$= 0= 0A~))&b5j!8qAAA!$111g: A!Y!% H'5  !!%1vv!999M"L"L"LMMMEEEEE   ##G,,,,5(('Fr2'N'N$ 9 I . . .vb),,H 4vi33vb),,t3H"--x0J0JJJ "(8Z00 0B"k11VHb11BF8X4N4NN bhx444"l22VHb11BF8X4N4NN bhx444$-DOAAAqD !$-DOAAAqD !#+DN111a4 #+DN111a4 %/D QQQT "%/D QQQT " "F O "&)+T_==E R R R  F O "&)+T_==E R R R  VD-t/?/ABB j4;.1DK? ,#06q9 s+(J K+KKct||}t||||td}||jz}||jz}t j||j}|lt|dd|t}|j dkr| dd}||j z}||j z}t j||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. Frr#resetNr)rrrr#rGr)rrrrrrr&r-rrrrrrr)rrPrrQrrrs r6 transformz_PLS.transforms2 'q! , ,   L  N N T\ T[6!T.// =cU\Av{{IIb!$$  A  Ava!233HX% %r8cxt||}t|t|dt}t j||jj}||jz}||j z }|Nt|dt}t j||j j}||j z}||j z }||fS|S)aTransform 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`. rP)rr#Nr) rrrrr&matmulrrIrrrrr)rrPrrQX_reconstructedy_reconstructeds r6inverse_transformz_PLS.inverse_transforms@ 'q! , , c > > >)At'7'9::4;&4<' =A#\BBBA i4+;+=>>O t{ *O t| +O"O3 3r8ct||||td}||jz}||jjz|jz}|jr|n|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) rrrrrrIrrravel)rrPrYpreds r6predictz _PLS.predictsi,    L  N N T\DJL 4?2 $ 0;u{{}}}e;r8cV|||||S)aLearn 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. rrrrPrs r6 fit_transformz_PLS.fit_transform&$xx1~~''1---r8c dddS)NTF) poor_score requires_y)rs r6 _more_tagsz_PLS._more_tags*s"%888r8rNN)NNTTr>)__name__ __module__ __qualname____doc__rrrrrdict__annotations__rrrrrrrrrrr8r6rrs"(AtFCCCD%:|[&ABBCS#J''( j%!2334Xh4???@q$v6667  $ $D   #   ^*\555fff65fP----^3333j<<<<:....(99999r8r) metaclassceZdZUdZiejZeed<dD]Ze e d dddddfd Z d fd Z xZ 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`. rrrRrrTr:r;rqrSrTrc Zt||ddd|||dS)Nrr9rrsuperrrrrqrSrTr __class__s r6rzPLSRegression.__init__sH %'  r8Nct||}t|||j|_|j|_|S)r)rrrr x_scores_r y_scores_)rrPrrQrs r6rzPLSRegression.fitsC2 'q! , ,  Aq r8rr) rrrrrrrrparampoprr __classcell__rs@r6rr.seeN$Cd&A#BDBBB8**""5))))  '+cu4        r8rceZdZUdZiejZeed<dD]Ze e d dddddd fd Z xZ 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)rrRrTrr:r;)rqrrSrTrc Zt||dd||||dS)Nrr9rr)rrrqrrSrTrrs r6rzPLSCanonical.__init__?sH %&  r8r rrrrrrrrrrrrrs@r6rrs``D$Cd&A#BDBBB+**""5))))              r8rceZdZUdZiejZeed<dD]Ze e d dddddfd Z xZ 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) rrrTr:r;rc Zt||ddd|||dS)NrrFrrrrs r6rz CCA.__init__sH %&  r8rrrs@r6rrUsXXt$Cd&A#BDBBB8**""5))))  '+cu4            r8rceZdZUdZeedddgdgdgdZeed<dd d d d Z e d ddZ ddZ ddZ dS)raPartial 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)) rGNrrrrrqrrrT)rqrc0||_||_||_dSr>r)rrrqrs r6rzPLSSVD.__init__ s(  r8rc:t||}t||||tjd|jd}t |dtjd|jd}|jdkr|dd}|j }t|j d |j d|j d}||krtd |d |d t|||j\}}|_|_|_|_tj|j|}t+|d \}}} |ddd|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. TrrrFrrGrrrrrrcN)rrrr&rrrrrrrrMrrvrqrrrrr-rIrrrrr) rrPrrQrrrdrer0rgVs r6rz PLSSVD.fits. 'q! , ,1%%%    *      *      6Q;; "a  A ( qwqz171:qwqzBB * * *F1AFF#FFF  FV q$*F F B1dlDL$+t{ F13NNq...1b aaa,    B2 D#4Q7 r8ct||}t|||tjd}||jz |jz }tj||j}|nt|ddtj}|j dkr| dd}||j z |j z }tj||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#rNr)rrr#rGr)rrrr&rrrr-rrrrrrr)rrPrrQXrryrrs r6rzPLSSVD.transformYs4 'q! , ,   5  A A$,$+ -6"do.. =A#bjQQQAv{{IIb!$$dl"dk1Bvb$/22HX% %r8cV|||||S)aLearn 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. rrs r6rzPLSSVD.fit_transformrr8rrr>)rrrrrrrrrrrrrrrr8r6rrsAAH"(AtFCCCD $$D 4 \555DDD65DL&&&&P......r8r)r9r:r;Fr)2rrNabcrrnumbersrrnumpyr& scipy.linalgrbaser r r r r r exceptionsrutilsrrutils._param_validationrr utils.extmathr utils.fixesrrutils.validationrr__all__rrr7rarhrvr|rrrrrrrrr8r6rs)''''''''"""""""",+++++88888888::::::::$$$$$$33333333<<<<<<<< 5 5 5u%%%%+******""""""<<<&=B8(8(8(8(v....4    ,,, q9q9q9q9q9# q9q9q9q9h _____D___DB B B B B 4B B B Jk k k k k $k k k \P.P.P.P.P. ,.> P.P.P.P.P.r8