{Kg dZddlZddlmZmZddlmZmZddlZ ddl m Z ddl m Z mZmZmZmZmZddlmZdd lmZmZdd lmZmZdd lmZdd lmZmZdd l m!Z!m"Z"gdZ#eedk\rddl m$Z%nddl m%Z%dZ& d$dZ'dZ(d%dZ)dZ*dZ+dZ,Gddeeeee eZ-Gdde-Z.Gdde-Z/Gd d!e-Z0Gd"d#eee Z1y)&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\}}}|jjj}ddd}t j |||zt j |jz}t j||kD}|ddd|f}||d|z}t jt jt j||d|S)NF) full_matrices check_finiteg@@g.A)fd) rdtypecharlowernpmaxfinfoepssum transpose conjugatedot)ausvhtfactorcondranks d/home/alanp/www/video.onchill/myenv/lib/python3.12/site-packages/sklearn/cross_decomposition/_pls.py _pinv2_oldr7)s 1E>HAq"  AS !F 66!9vay 288A;?? 2D 66!d( D !UdU( A5DMA << RVVAr%4y%9: ;;ctj|jj t fd|j D}d}|dk(rt|t|} } t|D]} |dk(rtj |} n7tj|j |tj||z } | tjtj| | zz} tj|| } |dk(rtj | }nAtj|j | tj| j | z }|r/|tjtj||zz}tj||tj||zz }| |z }tj|||ks|jddk(rn| } dz}||k(rtjdt |fS#t $r}t d|d}~wwxYw)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. c3zK|]2}tjtj|kDs/|4ywN)r&anyabs).0colr)s r6 z;_get_first_singular_vectors_power_method..Hs*GcsRVVBFF3K#4E-Fscs0;;y 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_methodr^;s ((177   C=GaccGGM s{$A 1  8_ 3;vw/IqssG,rvvgw/GGIRWWRVVIy9:S@@ &&I& 3;vw/IqssG,rvvgii/III   9!=>D DI&&I&"&&I*F*LM"]2 66.. 1C 71771:? ! -0UF  <>PQ i ''U =451<=sH,, I5 IIctj|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-rFr)rMrNCU_Vts r6_get_first_singular_vectors_svdrevsD qssAA1E*HAq" QT7Bq!tH r8c||jd}||z}|jd}||z}|rA|jdd}d||dk(<||z}|jdd}d||dk(<||z}nDtj|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 raxisrD)rhddofg?)meanstdr&onesrJ)rMrNscalex_meany_meanx_stdy_stds r6_center_scale_xyrssVVV^FKA VVV^FKA 11%!esl U 11%!esl U  # # a --r8ctjtj|}tj||}||z}||z}y)z7Same as svd_flip but works on 1d arrays, and is inplaceN)r&argmaxr=sign)r/vbiggest_abs_val_idxrvs r6 _svd_flip_1drysA))BFF1I. 771() *DIAIAr8c\|)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.)rKrL FutureWarning ValueErroryrNs r6_deprecate_Y_when_optionalrs<} S   =Q  Hr8c8| | tdt||S)Nzy is required.)r|rr}s r6_deprecate_Y_when_requiredrs$yQY)** %a ++r8c eZdZUdZeedddgdgeddhged d hged d hgeedddgeed ddgdgdZe e d<e dddd d dddddZ e dddZddZddZddZd dZdZy)!_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 rDNleftclosedboolean regression canonicalArCrnipalsr n_componentsrndeflation_moderO algorithmrPrQcopy_parameter_constraintsTư>)rnrrOrrPrQrct||_||_||_||_||_||_||_||_yr;)rrrOrnrrPrQr) selfrrnrrOrrPrQrs r6__init__z _PLS.__init__s>),  "   r8prefer_skip_nested_validationc  t||}t|||j|tjd|j d}t |dtjd|j d}|jdk(rd|_|jdd}nd|_|jd }|jd}|jd}|j}|jd k(r|n t|||}||kDrtd |d |d |jdk(|_|j} t!|||j"\} } |_|_|_|_tj,||f|_tj,||f|_tj,||f|_tj,||f|_tj,||f|_tj,||f|_g|_tj<| j>j@} tC|D]q} |jDdk(rtjFtjH| d| zkd }d| dd|f< tK| | |jL|jN|jP| \}}}|j:j[|n|jDdk(rt]| | \}}t_tj`| |}| rd}ntj`||}tj`| ||z }tj`|| tj`||z }| tjb||z} |jdk(rFtj`|| tj`||z }| tjb||z} |jd k(rFtj`|| tj`||z }| tjb||z} ||j.dd| f<||j0dd| f<||j2dd| f<||j4dd| f<||j6dd| f<|j8dd| f<ttj`|j.tetj`|j6jf|j.d|_4tj`|j0tetj`|j8jf|j0d|_5tj`|jh|j8jf|_6|jl|j*zjf|j(z |_6|j&|_7|jhjd|_8|S#tR$r3}tU|dk7rtWjXd| Yd}~d}~wwxYw)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_samplesr~F input_namer#rr ensure_2drDrr`n_components` upper bound is . Got instead. Reduce `n_components`.rr rgrjN)rOrPrQrRrAz$y residual is constant at iteration r)r )9rr_validate_datar&float64rrndim _predict_1dreshaperJrrminr|_norm_y_weightsrsrn_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)rHrallr=r^rOrPrQrGstrrKrLappendreryr-outerrrF x_rotations_ y_rotations_coef_ intercept__n_features_out)rrMr~rNnpqrrank_upper_boundrRXkyky_epskyk_maskrYr[rrTx_scoresy_ssy_scores x_loadings y_loadingss r6fitz_PLS.fitsm4 'q! ,1%    **     **    66Q;#D  "a A$D  GGAJ GGAJ GGAJ(( !% 3 3| C1QPQST * *01A0BC#n$DF  $22kA--HX q$**H DB dlDK((A|#45((A|#451l"341l"3488Q $5688Q $56 "&&|$A~~)&&b5j!8qA!$1g: A!YY!% HH'5  !! ##G,5('Fr2'N$ 9 I .vvb),Hvvi3vvb),t3H"-x0JJJ "((8Z0 0B""k1VVHb1BFF8X4NN bhhx44""l2VVHb1BFF8X4NN bhhx44$-DOOAqD !$-DOOAqD !#+DNN1a4 #+DNN1a4 %/D  QT "%/D  QT "{%LFF OO "&&))++T__=E R FF OO "&&))++T__=E R VVD--t/?/?/A/AB jj4;;.11DKK? ,,#0066q9 {%1v!99MM$H"LM s3X Y$'YYct||}t||j||td}||jz}||j z}t j||j}|wt|dd|t}|jdk(r|jdd}||jz}||jz}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#resetr~)rrrr#rDr)rrrrrrr&r-rrrrrrr)rrMr~rNrrrs r6 transformz_PLS.transforms2 'q! ,   L  N T\\ T[[66!T../ =cU\Avv{IIb!$  A  Avva!2!23HX% %r8ct||}t|t|dt}t j ||j j}||jz}||jz }|^t|dt}t j ||jj}||jz}||jz }||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`. rM)rr#r~) rrrrr&matmulrrFrrrrr)rrMr~rNX_reconstructedy_reconstructeds r6inverse_transformz_PLS.inverse_transforms@ 'q! , c >))At'7'7'9'9:4;;&4<<' =A#\BA ii4+;+;+=+=>O t{{ *O t|| +O"O3 3r8ct||j||td}||jz}||jj z|j z}|jr|jS|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) rrrrrrFrrravel)rrMrYpreds r6predictz _PLS.predictsg,    L  N T\\DJJLL 4??2 $ 0 0u{{};e;r8cF|j||j||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. rrrrMr~s r6 fit_transformz_PLS.fit_transform!$xx1~''1--r8c dddS)NTF) poor_score requires_y)rs r6 _more_tagsz_PLS._more_tags*s "%88r8rNN)NNTTr;)__name__ __module__ __qualname____doc__rrrrrdict__annotations__rrrrrrrrrrr8r6rrs"(AtFCD%|[&ABCS#J'( %!234h4?@q$v67  $D #   *5f6fP-^3j<:.(9r8r) metaclassceZdZUdZiej Zeed<dD]Zeje 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`. rrrOrTrrrnrPrQrc 4t|||ddd|||y)NrrrrsuperrrrrnrPrQr __class__s r6rzPLSRegression.__init__s/ %'  r8ct||}t| |||j|_|j |_|S)r)rrrr x_scores_r y_scores_)rrMr~rNrs r6rzPLSRegression.fits:2 'q! ,  Aq r8rr) rrrrrrrrparampoprr __classcell__rs@r6rr.s]eN$Cd&A&A#BDB8""5)9  '+cu4  r8rceZdZUdZiej Zeed<dD]Zeje d ddddddfd 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)rrOTrrr)rnrrPrQrc 4t|||dd||||y)Nrrrr)rrrnrrPrQrrs r6rzPLSCanonical.__init__?s/ %&  r8r rrrrrrrrrrrrrs@r6rrs``D$Cd&A&A#BDB+""5),     r8rceZdZUdZiej Zeed<dD]Zeje 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) rrTrrrc 4t|||ddd|||y)NrrCrrrrs r6rz CCA.__init__s/ %&  r8rrrs@r6rrUsXXt$Cd&A&A#BDB8""5)9  '+cu4   r8rceZdZUdZeedddgdgdgdZeed<dd d d d Z e d dd Z ddZ ddZ y)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)) rDNrrrrrnrrT)rnrc.||_||_||_yr;r)rrrnrs r6rzPLSSVD.__init__ s(  r8rcHt||}t|||j|tjd|j d}t |dtjd|j d}|jdk(r|jdd}|j}t|jd |jd|jd}||kDrtd |d |d t|||j\}}|_|_|_|_tj&|j(|}t+|d \}}} |ddd|f}| d|} t-|| \}} | j(} ||_| |_|j.jd|_|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. Trrr~FrrDrrrrrr`N)rrrr&rrrrrrrrJr|rsrnrrrrr-rFrrrrr) rrMr~rNrrrarbr0rdVs r6rz PLSSVD.fits. 'q! ,1%    **     **    66Q; "a A (( qwwqz1771:qwwqzB * *01A0BC#n$DF  FV q$**F B1dlDL$+t{ FF133Nq.1b a,    B2 DD#44Q7 r8ct||}t||j|tjd}||j z |j z }tj||j}|~t|ddtj}|jdk(r|jdd}||jz |jz }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#rr~)rrr#rDr)rrrr&rrrr-rrrrrrr)rrMr~rNXrryrrs r6rzPLSSVD.transformYs4 'q! ,   5  A$,,$++ -66"doo. =A#bjjQAvv{IIb!$dll"dkk1Bvvb$//2HX% %r8cF|j||j||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;)rrrrrrrrrrrrrrrr8r6rrsjAH"(AtFCD $D 4 5D6DL&P.r8r)rrrFr)2rrKabcrrnumbersrrnumpyr& scipy.linalgrbaser r r r r r exceptionsrutilsrrutils._param_validationrr utils.extmathr utils.fixesrrutils.validationrr__all__rrr7r^rersryrrrrrrrrr8r6rs'",8:$3< 5u%%+"<&=B8(v.4  , q9# q9h _D_DB 4B Jk $k \P. ,.> P.r8