-il \SrSSKrSSKJrJr SSKJrJr SSKr SSK J r J r SSK JrJrJrJrJrJr SSKJr SS KJrJr SS KJrJr SS KJr SS KJrJ r J!r! /S Qr"Sr#SSjr$Sr%SSjr&Sr'"SS\\\\\\S9r("SS\(5r)"SS\(5r*"SS\(5r+"SS\\\5r,g) zG The :mod:`sklearn.pls` module implements Partial Least Squares (PLS). N)ABCMetaabstractmethod)IntegralReal)pinvsvd) BaseEstimatorClassNamePrefixFeaturesOutMixinMultiOutputMixinRegressorMixinTransformerMixin _fit_context)ConvergenceWarning) check_arraycheck_consistent_length)Interval StrOptions)svd_flip) FLOAT_DTYPEScheck_is_fitted validate_data)PLSSVD PLSCanonical PLSRegressionc [USSS9upnURRR5nSSS.n[R "U5XT-[R "U5R-n[R"X&:5nUSS2SU24nXSU-n[R"[R"[R"XSU555$)NF) full_matrices check_finiteg@@g.A)fd) rdtypecharlowernpmaxfinfoepssum transpose conjugatedot)ausvhtfactorcondranks S/var/www/html/venv/lib/python3.13/site-packages/sklearn/cross_decomposition/_pls.py _pinv2_oldr5 s 1E>HA"  AS !F 66!9vy 288A;?? 2D 66!( D !UdU( A5DMA << RVVA%4y%9: ;;c^[R"UR5Rm[ U4SjUR 55nSnUS:Xa[U5[U5p[U5GHn US:Xa[R"W U5n O8[R"UR U5[R"Xf5- n U [R"[R"X55T--n [R"X 5n US:Xa[R"W U 5nOC[R"UR U 5[R"U R U 5- nU(a0U[R"[R"X55T--n[R"X5[R"X5T-- nX- n[R"X5U:dURSS:Xa OU nGM W S-nUU:Xa[R"S[5 W WU4$![ an[ S5UeSnAff=f)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. c3># UH;n[R"[R"U5T:5(dM7Uv M= g7fN)r$anyabs).0colr's r4 ;_get_first_singular_vectors_power_method..?s+GcsRVVBFF3K#4E-Fsscs 6A Ay residual is constantNdBz$Maximum number of iterations reached)r$r&r!r'nextT StopIterationr5ranger+sqrtshapewarningswarnr)Xymodemax_itertolnorm_y_weightsy_scoree x_weights_oldX_pinvy_pinvi x_weightsx_score y_weightsx_weights_diffn_iterr's @r4(_get_first_singular_vectors_power_methodr]2s ((177   C=GaccGGM s{$A 1  8_ 3;vw/IqssG,rvvg/GGIRWWRVVI9:S@@ &&& 3;vw/IqssG,rvvgii/III   !=>D DI&&&"&&*F*LM"2 66. 1C 71771:? ! -0UF  <>PQ i ''U =451<=sI I IIc[R"URU5n[USS9up4nUSS2S4USSS244$)zZReturn the first left and right singular vectors of X'y. Here the whole SVD is computed. FrNr)r$r+rEr)rLrMCU_Vts r4_get_first_singular_vectors_svdrdmsB qssAA1E*HA" QT7Bq!tH r6c`URSS9nX-nURSS9nX-nU(a7URSSS9nSXUS:H'X-nURSSS9nSXfS:H'X-nOF[R"URS5n[R"URS5nXX4XV4$)zkCenter X, y and scale if the scale parameter==True Returns ------- X, y, x_mean, y_mean, x_std, y_std raxisrC)rgddofg?)meanstdr$onesrI)rLrMscalex_meany_meanx_stdy_stds r4_center_scale_xyrrwsVVV^FKA VVV^FKA 11%!sl 11%!sl  # #  --r6c[R"[R"U55n[R"X5nX-nX-ng)z7Same as svd_flip but works on 1d arrays, and is inplaceN)r$argmaxr;sign)r-vbiggest_abs_val_idxrus r4 _svd_flip_1drxs:))BFF1I. 771) *DIAIAr6c "^\rSrSr%Sr\"\SSSS9/S/\"SS 15/\"S S 15/\"S S 15/\"\SSSS9/\"\SSSS9/S/S.r \ \ S'\ SSSS S SSSS.Sjj5r \"SS9S5rSSjrS SjrS!SjrS SjrU4SjrSrU=r$)"_PLSzPartial 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 rCNleftclosedboolean regression canonicalArBrnipalsr n_componentsrmdeflation_moderN algorithmrOrPcopy_parameter_constraintsTư>)rmrrNrrOrPrcdXlX0lX@lX lXPlX`lXplXlgr9)rrrNrmrrOrPr) selfrrmrrNrrOrPrs r4__init__ _PLS.__init__s.),  "  r6prefer_skip_nested_validationc  [X5 [UU[RSURSS9n[ US[RSURSS9nUR S:XaSUlURSS5nOSUlURS nURSnURSnURnURS :Xa [X45O [X4U5nXg:a[S US US 35eURS:HUlURn[XUR 5upUlUlUlUl[R*"XF45Ul[R*"XV45Ul[R*"X645Ul[R*"X645Ul[R*"XF45Ul[R*"XV45Ul/Ul[R:"U R<5R>n [AU5GH|n URBS:Xa[RD"[RF"U 5SU -:S S9n SU SS2U 4'[IU U URJURLURNUS9unnnUR8RYU5 OURBS:Xa [[X5up[]WW5 [R^"X5nU(aSnO[R^"X5n[R^"X5U- n[R^"UU 5[R^"UU5- nU [R`"UU5-n URS:XaI[R^"UU 5[R^"UU5- nU [R`"UU5-n URS :XaI[R^"UU 5[R^"UU5- nU [R`"UU5-n XR,SS2U 4'XR.SS2U 4'UUR0SS2U 4'UUR2SS2U 4'UUR4SS2U 4'WUR6SS2U 4'GM [R^"UR,[c[R^"UR4RdUR,5SS95Ul3[R^"UR.[c[R^"UR6RdUR.5SS95Ul4[R^"URfUR6Rd5Ul5URjUR(-RdUR&- Ul5UR$Ul6URfRSUl7U$![Pa6n[SU5S:wae[TRV"SU 35 SnA GMSnAff=f)Fit 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. Returns ------- self : object Fitted model. Tr r!force_writeablerensure_min_samplesrMF input_namer!rr ensure_2drCrr`n_components` upper bound is . Got instead. Reduce `n_components`.rr rfriN)rNrOrPrQr@z$y residual is constant at iteration r)r)8rrr$float64rrndim _predict_1dreshaperIrrmin ValueError_norm_y_weightsrrrm_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'rGrallr;r]rNrOrPrFstrrJrKappendrdrxr+outerrrE x_rotations_ y_rotations_coef_ intercept__n_features_out)rrLrMnpqrrank_upper_boundrQXkyky_epskyk_maskrXrZrrSx_scoresy_ssy_scores x_loadings y_loadingss r4fit_PLS.fits:& %   **     **    66Q;#D  "a A$D  GGAJ GGAJ GGAJ(( ,, ))A'7'7'9'9:;;&<<' =A#\BA ii+;+;+=+=>O {{ *O || +O"3 3r6c[U5 [XU[SS9nXR-nXRR -UR -nUR(aUR5$U$)aPredict targets of given samples. Parameters ---------- X : array-like of shape (n_samples, n_features) Samples. copy : bool, default=True Whether to copy `X` 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) rrrrrrErrravel)rrLry_preds r4predict _PLS.predictsZ,  $L N \\ZZ\\!DOO3!%!1!1v||~=v=r6cBURX5RX5$)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. rrrrLrMs r4 fit_transform_PLS.fit_transform$xx~''--r6ch>[TU]5nSURlSURlU$)NTF)super__sklearn_tags__regressor_tags poor_score target_tagsrequired)rtags __class__s r4r_PLS.__sklearn_tags__s1w'))-&$)! r6)rrrrrrrrrrrrrrrOrNrrrmrPrrrrrrr )NTr9T)__name__ __module__ __qualname____firstlineno____doc__rrrrrdict__annotations__rrrrrrrrr__static_attributes__ __classcell__rs@r4rzrzs"(AtFCD%|[&ABCS#J'( %!234h4?@q$v67  $D #   *5`6`D%N*X>:.(r6rz) metaclassc^\rSrSr%Sr0\R Er\\S'SHr \R\ 5 M S SSSSS.U4S jjjr U4S jr S r U=r$) ria 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`. rrrNrTrrrmrOrPrc .>[TU]UUSSSUUUS9 g)NrrrrrrrrrmrOrPrrs r4rPLSRegression.__init__ms/ %'  r6cj>[TU]X5 URUlURUlU$)r)rrr x_scores_r y_scores_)rrLrMrs r4rPLSRegression.fit{s,$  A r6)rrr)rrrrrrzrrrparampoprrrrrs@r4rrsbeN$Cd&A&A#BDB8""5)9  '+cu4   r6rc^\rSrSr%Sr0\R Er\\S'SHr \R\ 5 M S SSSSSS .U4S jjjr S r U=r $) ria> 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)rrNTrrr)rmrrOrPrc .>[TU]UUSSUUUUS9 g)Nrrrr)rrrmrrOrPrrs r4rPLSCanonical.__init__s/ %&  r6rrrrrrrzrrrrrrrrrs@r4rrs``D$Cd&A&A#BDB+""5),     r6rc^\rSrSr%Sr0\R Er\\S'SHr \R\ 5 M S SSSSS.U4S jjjr S r U=r $) CCAia 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 .>[TU]UUSSSUUUS9 g)NrrBrrrrs r4r CCA.__init__xs/ %&  r6rrr rs@r4r r sXXt$Cd&A&A#BDB8""5)9  '+cu4   r6r c\rSrSr%Sr\"\SSSS9/S/S/S.r\\ S 'SS S S .S jjr \ "S S 9S5r SSjr SSjrSrg)riaPartial 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)) rCNr|r}rrrmrrT)rmrc(XlX lX0lgr9r)rrrmrs r4rPLSSVD.__init__s(  r6rc [X5 [UU[RSURSS9n[ US[RSURSS9nUR S:XaURSS5nURn[URS URSURS5nX4:a[S US US 35e[XUR5upUlUlUlUl[R$"UR&U5n[)USS 9upgnUSS2SU24nUSUn[+Xh5uphUR&n X`lXlUR,RSUlU$)zFit 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. Returns ------- self : object Fitted estimator. Tr rrMFrrCrrrrrr_N)rrr$rrrrrrrrIrrrrmrrrrr+rErrrrr) rrLrMrrr`rar.rcVs r4r PLSSVD.fits" %   **     **    66Q; "a A (( qwwqz1771:qwwqzB  *01A0BC#n$DF  FV $**F BdlDL$+t{ FF133Nq.b a,     DD#44Q7 r6c[U5 [X[RSS9nXR- UR - n[R "X0R5nUbz[USS[RS9nURS:XaURSS5nX R- UR- n[R "XPR5nXF4$U$)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. 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!rrM)rrr!rCr)rrr$rrrr+rrrrrrr)rrLrMXrryrrs r4rPLSSVD.transforms&  $5 A,,$++ -66"oo. =A#bjjQAvv{IIb!$ll"dkk1Bvvb//2H% %r6cBURX5RX5$)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 r4rPLSSVD.fit_transform7rr6) rrrrrrrrmrrrr9)rrrrrrrrrrrrrrrrrr6r4rrshAH"(AtFCD $D 4 5>6>@@.r6r)rrrFr)-rrJabcrrnumbersrrnumpyr$ scipy.linalgrrbaser r r r rr exceptionsrutilsrrutils._param_validationrr utils.extmathrutils.validationrrr__all__r5r]rdrrrxrzrrr rrr6r4r&s'"",8:$KK 5<&=B8(v.4]# ]@ VDVrB 4B Jk $k \B. ,.> B.r6