o tBh0 @sxdZddlZddlZddlmZmZddlZddlm Z ddl m Z m Z m Z ddl mZddl mZdd lmZmZmZdd lmZdd lmZdd lmZdd lmZmZddlmZgdZeedkrmddlmZ nddlm Z ddZ! d-ddZ"ddZ#d.ddZ$d d!Z%Gd"d#d#ee e ee ed$Z&Gd%d&d&e&Z'Gd'd(d(e&Z(Gd)d*d*e&Z)Gd+d,d,ee e Z*dS)/zG The :mod:`sklearn.pls` module implements Partial Least Squares (PLS). N)ABCMetaabstractmethod)svd) BaseEstimatorRegressorMixinTransformerMixin)MultiOutputMixin) _ClassNamePrefixFeaturesOutMixin) check_array check_scalarcheck_consistent_length) sp_version) parse_version)svd_flip)check_is_fitted FLOAT_DTYPES)ConvergenceWarning) PLSCanonical PLSRegressionPLSSVDz1.7)pinv)pinv2c Cst|ddd\}}}|jj}ddd}t|||t|j}t||k}|ddd|f}||d|}t t t ||d|S)NF) full_matrices check_finiteg@@g.A)fd) rdtypecharlowernpmaxfinfoepssum transpose conjugatedot)ausvhtfactorcondrankr0w/var/www/html/riverr-enterprise-integrations-main/venv/lib/python3.10/site-packages/sklearn/cross_decomposition/_pls.py _pinv2_old$s   r2Aư>Fc st|jjztfdd|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 ddkrn| }q:| d}||krt 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(|]}tt|kr|VqdSN)r anyabs).0colr#r0r1 Cs&z;_get_first_singular_vectors_power_method..Y residual is constantNdBz$Maximum number of iterations reached)r r"rr#nextT StopIterationr2ranger'sqrtshapewarningswarnr)XYmodemax_itertolnorm_y_weightsy_scoree x_weights_oldX_pinvY_pinvi x_weightsx_score y_weightsx_weights_diffn_iterr0r;r1(_get_first_singular_vectors_power_method6s<      rZcCs@t|j|}t|dd\}}}|dddf|dddffS)zbReturn the first left and right singular vectors of X'Y. Here the whole SVD is computed. FrNr)r r'rBr)rIrJCU_Vtr0r0r1_get_first_singular_vectors_svdqs r`TcCs|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 raxisr@)rbddofg?)meanstdr onesrF)rIrJscalex_meany_meanx_stdy_stdr0r0r1_center_scale_xy{s     rmcCs2tt|}t||}||9}||9}dS)z7Same as svd_flip but works on 1d arrays, and is inplaceN)r argmaxr8sign)r)vbiggest_abs_val_idxror0r0r1 _svd_flip_1ds rrc @sveZdZdZe ddddddddd d d Zd d ZdddZdddZdddZ dddZ e ddZ ddZ dS)_PLSa Partial 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://www.stat.washington.edu/research/reports/2000/tr371.pdf rT regressionr3nipalsr4r5)rhdeflation_moderK algorithmrLrMcopyc Cs4||_||_||_||_||_||_||_||_dSr6) n_componentsrvrKrhrwrLrMrx) selfryrhrvrKrwrLrMrxr0r0r1__init__s  z _PLS.__init__c Cst|||j|tj|jdd}t|dtj|jdd}|jdkr&|dd}|jd}|jd}|jd}|j }|j d krJ|}t |d t j d|d nt|||}t |d t j d|d |jd vrhtd |jd|j dk|_|j}t|||j\} } |_|_|_|_t||f|_t||f|_t||f|_t||f|_t||f|_t||f|_g|_t | j!j"} t#|D]} |jdkrtj$t%| d| kdd} d| dd| f<zt&| | |j'|j(|j)|d\}}}Wn$t*y}zt+|dkrt,-d| WYd}~nd}~ww|j.|n |jdkr*t/| | \}}t0||t1| |}|r;d}nt1||}t1| ||}t1|| t1||}| t2||8} |j dkrwt1|| t1||}| t2||8} |j d krt1|| t1||}| t2||8} ||jdd| f<||jdd| f<||jdd| f<||jdd| f<||jdd| f<||jdd| f<qt1|jt3t1|jj4|jdd|_5t1|jt3t1|jj4|jdd|_6t1|j5|jj4|_7|j7|jj4|_7|j|_8|j5jd|_9|S)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. rrrxensure_min_samplesrJF input_namerrx ensure_2dr@rrtrymin_valmax_val)rruz+algorithm should be 'svd' or 'nipals', got . canonicalru rardN)rKrLrMrNr=z$Y residual is constant at iteration r)r):r _validate_datar float64rxr ndimreshaperFryrvr numbersIntegralminrw ValueError_norm_y_weightsrmrh_x_mean_y_mean_x_std_y_stdzeros x_weights_ y_weights_ _x_scores _y_scores x_loadings_ y_loadings_n_iter_r"rr#rDallr8rZrKrLrMrCstrrGrHappendr`rrr'outerrrB x_rotations_ y_rotations__coef_ intercept__n_features_out)rzrIrJnpqryrank_upper_boundrNXkYkY_epskYk_maskrUrWrrPx_scoresy_ssy_scores x_loadings y_loadingsr0r0r1fits                     z_PLS.fitNcCst||j||tdd}||j8}||j}t||j}|durKt|dd|td}|j dkr6| dd}||j 8}||j }t||j }||fS|S)a.Apply 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. 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. FrxrresetNrJ)rrrxrr@r)rrrrrr r'rr rrrrr)rzrIrJrxrrr0r0r1 transformms        z_PLS.transformcCst|t|dtd}t||jj}||j9}||j7}|dur>t|dtd}t||j j}||j 9}||j 7}||fS|S)aeTransform 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, n_components) New target, where `n_samples` is the number of samples and `n_components` is the number of pls components. 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`. rI)rrNrJ) rr rr matmulrrBrrrrr)rzrIrJX_reconstructedY_reconstructedr0r0r1inverse_transforms    z_PLS.inverse_transformcCsDt||j||tdd}||j8}||j}||jj}||jS)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)rrrrrrrBr)rzrIrxYpredr0r0r1predicts     z _PLS.predictcC|||||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. rrrzrIyr0r0r1 fit_transformz_PLS.fit_transformcCs0t|drt|ddrtdtd|_|jjS)z%The coefficients of the linear model.r _coef_warningTzThe attribute `coef_` will be transposed in version 1.3 to be consistent with other linear models in scikit-learn. Currently, `coef_` has a shape of (n_features, n_targets) and in the future it will have a shape of (n_targets, n_features).F)hasattrgetattrrGrH FutureWarningrrrBrzr0r0r1coef_sz _PLS.coef_cCs dddS)NTF) poor_score requires_yr0rr0r0r1 _more_tagss z_PLS._more_tagsr)NTr6T)__name__ __module__ __qualname____doc__rr{rrrrrpropertyrrr0r0r0r1rss,  ( ' ,   rs) metaclasscs<eZdZdZ d dddddfdd Zfd d ZZS) ra PLS regression. PLSRegression is also known as PLS2 or PLS1, depending on the number of targets. 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`. 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_features, n_components) The projection matrix used to transform `Y`. coef_ : ndarray of shape (n_features, n_targets) The coefficients of the linear model such that `Y` is approximated as `Y = X @ coef_ + intercept_`. intercept_ : ndarray of shape (n_targets,) The intercepts of the linear model such that `Y` is approximated as `Y = X @ coef_ + 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) rTr4r5rhrLrMrxc  tj||ddd|||ddS)Nrtr3ruryrhrvrKrwrLrMrxsuperr{rzryrhrLrMrx __class__r0r1r{t zPLSRegression.__init__cs"t|||j|_|j|_|S)r|)rrr x_scores_r y_scores_)rzrIrJrr0r1rszPLSRegression.fitr)rrrrr{r __classcell__r0r0rr1r sircs2eZdZdZ d ddddddfdd ZZS) ra Partial Least Squares transformer and regressor. 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_features, n_components) The projection matrix used to transform `Y`. coef_ : ndarray of shape (n_features, n_targets) The coefficients of the linear model such that `Y` is approximated as `Y = X @ coef_ + intercept_`. intercept_ : ndarray of shape (n_targets,) The intercepts of the linear model such that `Y` is approximated as `Y = X @ coef_ + 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) rTrur4r5)rhrwrLrMrxc s tj||dd||||ddS)Nrr3rr)rzryrhrwrLrMrxrr0r1r{s  zPLSCanonical.__init__rrrrrr{rr0r0rr1rsircs0eZdZdZ d dddddfdd ZZS) CCAap Canonical Correlation Analysis, also known as "Mode B" PLS. 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_features, n_components) The projection matrix used to transform `Y`. coef_ : ndarray of shape (n_features, n_targets) The coefficients of the linear model such that `Y` is approximated as `Y = X @ coef_ + intercept_`. intercept_ : ndarray of shape (n_targets,) The intercepts of the linear model such that `Y` is approximated as `Y = X @ coef_ + 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) rTr4r5rc r)Nrr?rurrrrr0r1r{qrz CCA.__init__rrr0r0rr1rs Xrc@s>eZdZdZddddddZddZdd d Zdd d Zd S)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)) rT)rhrxcCs||_||_||_dSr6)ryrhrx)rzryrhrxr0r0r1r{s zPLSSVD.__init__c Cst|||j|tj|jdd}t|dtj|jdd}|jdkr&|dd}|j}t |j d|j d|j d}t |d t j d|d t|||j\}}|_|_|_|_t|j|}t|dd \}}}|d d d |f}|d |}t||\}}|j} ||_| |_|jj d|_|S) aJFit 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. rr}rJFrr@rrryrr[N)r rr rrxr rrryrrFr rrrmrhrrrrr'rBrrrrr) rzrIrJryrr\r]r*r_Vr0r0r1rs>     z PLSSVD.fitNcCst||j|tjdd}||j|j}t||j}|durGt|ddtjd}|j dkr4| 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. Returns ------- x_scores : array-like or tuple of array-like The transformed data `X_tranformed` if `Y is not None`, `(X_transformed, Y_transformed)` otherwise. F)rrNrJ)rrrr@r)rrr rrrr'rr rrrrr)rzrIrJXrrYrrr0r0r1rs  zPLSSVD.transformcCr)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_tranformed` if `Y is not None`, `(X_transformed, Y_transformed)` otherwise. rrr0r0r1r!rzPLSSVD.fit_transformrr6)rrrrr{rrrr0r0r0r1rs C 8 r)r3r4r5Fr)+rrrGabcrrnumpyr scipy.linalgrbaserrrr r utilsr r r utils.fixesrr utils.extmathrutils.validationrr exceptionsr__all__rrr2rZr`rmrrrsrrrrr0r0r0r1sP          ;  n~g