hd dZddlZddlmZddlmZmZddlZddl m Z ddl m Z ddl mZmZmZdd lmZdd lmZmZdd lmZmZmZmZdd lmZmZd dlmZm Z m!Z!dZ"d%dZ# d&dZ$edgej%geed dddgeeddddgdedhgdgdgdgddddddddddZ&dddddddddZ'Gdd eeeZ( d'd"Z)Gd#d$eeZ*dS)(z'Orthogonal matching pursuit algorithms N)sqrt)IntegralReal)linalg)get_lapack_funcs)MultiOutputMixinRegressorMixin _fit_context)check_cv)as_float_array check_array)HiddenInterval StrOptionsvalidate_params)Paralleldelayed) LinearModel_deprecate_normalize_pre_fitzOrthogonal matching pursuit ended prematurely due to linear dependence in the dictionary. The requested precision might not have been met.TFc$|r|d}ntj|}tj|jj}t jd|f\}}td|f\} tj |j |} |} tj d} d} tj |j d}| |j dn|}tj ||f|j}|rtj|} tjtjtj |j | }|| ks| |d z|kr#t#jt&t(d n| dkrtj |ddd| fj |dd|f|| d| f<t j|d| d| f|| d| fdddd ||| d| fd z}t j|dd|fd z|z }||kr#t#jt&t(d nt/||| | f<n!t j|dd|f|d <||j | |j |\|j | <|j |<| || | c| | <| |<|||| c|| <||<| dz } | |d| d| f| d| dd \} }|r | |d| | dz f<|tj |ddd| f| z } ||| d z|krn | |krn\|r| |d| |ddd| f| fS| |d| | fS)aOrthogonal Matching Pursuit step using the Cholesky decomposition. Parameters ---------- X : ndarray of shape (n_samples, n_features) Input dictionary. Columns are assumed to have unit norm. y : ndarray of shape (n_samples,) Input targets. n_nonzero_coefs : int Targeted number of non-zero elements. tol : float, default=None Targeted squared error, if not None overrides n_nonzero_coefs. copy_X : bool, default=True Whether the design matrix X must be copied by the algorithm. A false value is only helpful if X is already Fortran-ordered, otherwise a copy is made anyway. return_path : bool, default=False Whether to return every value of the nonzero coefficients along the forward path. Useful for cross-validation. Returns ------- gamma : ndarray of shape (n_nonzero_coefs,) Non-zero elements of the solution. idx : ndarray of shape (n_nonzero_coefs,) Indices of the positions of the elements in gamma within the solution vector. coef : ndarray of shape (n_features, n_nonzero_coefs) The first k values of column k correspond to the coefficient value for the active features at that step. The lower left triangle contains garbage. Only returned if ``return_path=True``. n_active : int Number of active features at convergence. Fnrm2swappotrsrrNdtypeTr stacklevelFtranslower overwrite_b check_finiterrr&r')copynpasfortranarrayfinfor!epsrget_blas_funcsrdotTemptyarangeshape empty_likeargmaxabswarningswarn prematureRuntimeWarningsolve_triangularnormr)Xyn_nonzero_coefstolcopy_X return_path min_floatrrralpharesidualgamman_activeindices max_featuresLcoefslamvLkk_s a/var/www/html/services/rag-service/venv/lib/python3.11/site-packages/sklearn/linear_model/_omp.py _cholesky_omprSsV! FF3KK  a !!%I&'7!>>JD$ QD11HU F13NNEH HQKKEHi ##G!$171::oL , -QW===A! a  +irvac8445566 >>U3Z1_y88 M)^ B B B B  a<<%'VAaaa(lO,=qCy%I%IAh  ! "  #)8)YhY&'(IXI%& "     Qx(*+,,1A+a3i((A-1Ci iAFFFF$(IIAh ! !k!AAAsF),,AdG"&$qs8}ac#h"?"?H qs3x&+Cj%/#hs*1#,8I'73<A 5 ixi(" #U9H9%5Tu   q  3-2E)8)X\) *rva9H9 ou555 ?ttH~~2c99   % % W+Z3gixi(%9H9 *=xGGgixi((22c0|r|dntj|}|s |jjs|}tj|jj}tj d|f\} } td|f\} tj t|} |} |}d}tj d}d}|t|n|}tj ||f|j}d|d<|rtj|} tjtj| }||ks| |d z|kr#t#jt&t(d n|dkr||d|f||d|f<tj|d|d|f||d|fdd d d| ||d|fd z}|||f|z }||kr#t#jt&t(d nYt-||||f<nt-|||f|d<| ||||\||<||<| |j||j|\|j|<|j|<| || |c| |<| |<||||c||<||<|d z }| |d|d|f|d|d d\}}|r ||d||d z f<tj|ddd|f|}||z } |<||z }tj||d|}||z}t!||krn n||krnN|r|| d||ddd|f|fS|| d||fS)aOrthogonal Matching Pursuit step on a precomputed Gram matrix. This function uses the Cholesky decomposition method. Parameters ---------- Gram : ndarray of shape (n_features, n_features) Gram matrix of the input data matrix. Xy : ndarray of shape (n_features,) Input targets. n_nonzero_coefs : int Targeted number of non-zero elements. tol_0 : float, default=None Squared norm of y, required if tol is not None. tol : float, default=None Targeted squared error, if not None overrides n_nonzero_coefs. copy_Gram : bool, default=True Whether the gram matrix must be copied by the algorithm. A false value is only helpful if it is already Fortran-ordered, otherwise a copy is made anyway. copy_Xy : bool, default=True Whether the covariance vector Xy must be copied by the algorithm. If False, it may be overwritten. return_path : bool, default=False Whether to return every value of the nonzero coefficients along the forward path. Useful for cross-validation. Returns ------- gamma : ndarray of shape (n_nonzero_coefs,) Non-zero elements of the solution. idx : ndarray of shape (n_nonzero_coefs,) Indices of the positions of the elements in gamma within the solution vector. coefs : ndarray of shape (n_features, n_nonzero_coefs) The first k values of column k correspond to the coefficient value for the active features at that step. The lower left triangle contains garbage. Only returned if ``return_path=True``. n_active : int Number of active features at convergence. rrrrNr g?r)Trr"rFr$r*)r+r,r-flags writeabler.r!r/rr0rr4lenr3r6r7r8r9r:r;r<r=rr2r1inner)GramXyrAtol_0rB copy_Gramcopy_XyrDrErrrrJrFtol_currdeltarHrIrKrLrMrNrOrPrQbetas rR _gram_omprcs*z' C499S>>>B,=d,C,CDbh( WWYY$$(I&'7$AAJD$ TG44HUiD ""G EH E HQKKEH #3t999_L , -TZ@@@AAdG! a  -iu && >>U3Z1_y88 M)^ B B B B  a<<%)#yy.%9Ah  ! "  #)8)YhY&'(IXI%& "     Qx(*+,,1AsCx.1$Ci iAFFFF$(IIAh ! !4S>**AdG$(Dhc$C$C!XS (,TVH-=tvc{(K(K%x$&+*1#,8I'73< "3H8 bgA 5 ixi(" #R  ]$E   q  3-2E)8)X\) *vd111ixi<(%00T  ?  HHUD(O44E  H8}}##$  % % [-^3gixi(%9H9 *=xGGgixi((22rTz array-likeleftclosedbooleanauto)r?r@rArB precomputerCrD return_n_iterprefer_skip_nested_validation)rArBrirCrDrjc lt|d|}d}|jdkr|dd}t|}|jddkrd}|-|+t t d|jdzd}| ||jdkrt d |d kr|jd |jdk}|r}tj|j |}tj |}tj|j |} |tj |d zd } nd} t|| ||| |d|S|r9tj |jd|jd|jdf} n,tj |jd|jdf} g} t|jdD]} t||dd| f||||}|r^|\}}}}| dddddt!|f} t#|j D]#\}}|d|dz| |d|dz| |f<$n |\}}}|| || f<| ||jddkr| d } |rtj| | fStj| S)a1 Orthogonal Matching Pursuit (OMP). Solves n_targets Orthogonal Matching Pursuit problems. An instance of the problem has the form: When parametrized by the number of non-zero coefficients using `n_nonzero_coefs`: argmin ||y - X\gamma||^2 subject to ||\gamma||_0 <= n_{nonzero coefs} When parametrized by error using the parameter `tol`: argmin ||\gamma||_0 subject to ||y - X\gamma||^2 <= tol Read more in the :ref:`User Guide `. Parameters ---------- X : array-like of shape (n_samples, n_features) Input data. Columns are assumed to have unit norm. y : ndarray of shape (n_samples,) or (n_samples, n_targets) Input targets. n_nonzero_coefs : int, default=None Desired number of non-zero entries in the solution. If None (by default) this value is set to 10% of n_features. tol : float, default=None Maximum squared norm of the residual. If not None, overrides n_nonzero_coefs. precompute : 'auto' or bool, default=False Whether to perform precomputations. Improves performance when n_targets or n_samples is very large. copy_X : bool, default=True Whether the design matrix X must be copied by the algorithm. A false value is only helpful if X is already Fortran-ordered, otherwise a copy is made anyway. return_path : bool, default=False Whether to return every value of the nonzero coefficients along the forward path. Useful for cross-validation. return_n_iter : bool, default=False Whether or not to return the number of iterations. Returns ------- coef : ndarray of shape (n_features,) or (n_features, n_targets) Coefficients of the OMP solution. If `return_path=True`, this contains the whole coefficient path. In this case its shape is (n_features, n_features) or (n_features, n_targets, n_features) and iterating over the last axis generates coefficients in increasing order of active features. n_iters : array-like or int Number of active features across every target. Returned only if `return_n_iter` is set to True. See Also -------- OrthogonalMatchingPursuit : Orthogonal Matching Pursuit model. orthogonal_mp_gram : Solve OMP problems using Gram matrix and the product X.T * y. lars_path : Compute Least Angle Regression or Lasso path using LARS algorithm. sklearn.decomposition.sparse_encode : Sparse coding. Notes ----- Orthogonal matching pursuit was introduced in S. Mallat, Z. Zhang, Matching pursuits with time-frequency dictionaries, IEEE Transactions on Signal Processing, Vol. 41, No. 12. (December 1993), pp. 3397-3415. (https://www.di.ens.fr/~mallat/papiers/MallatPursuit93.pdf) This implementation is based on Rubinstein, R., Zibulevsky, M. and Elad, M., Efficient Implementation of the K-SVD Algorithm using Batch Orthogonal Matching Pursuit Technical Report - CS Technion, April 2008. https://www.cs.technion.ac.il/~ronrubin/Publications/KSVD-OMP-v2.pdf rorderr+FrTN皙?>The number of atoms cannot be more than the number of featuresrhrraxis)rArB norms_squaredr^r_rD)rCrD)rndimreshaper5maxint ValueErrorr,r1r2r-sumorthogonal_mp_gramzerosrangerSrY enumerateappendsqueeze)r?r@rArBrirCrDrjGr\rucoefn_iterskoutrQidxrMn_iterrIxs rR orthogonal_mprsJ ASv...A Fv{{ IIb!  AAwqzA~~3;c# "233Q77 {33 L   VWQZ!'!*,  F13NN  a  VAC^^ ?FAqD222MM M! +'#    2xQWQZ<==xQWQZ011G 171:     qAwV     $' !AsE6111jCj()D(11 K K !9:>X\>9JS8a<(!X566 K!NAsFDaLvwqzQ!* z$((z$rT)rArBrur^r_rDrjc Bt|d|}tj|}|jdkr|jddkrd}|jdkr|ddtjf}||g}|s |jjs|}|!|tdt|z}||td||dkrtd ||dkrtd |"|t|krtd |rDtj t||jdt|f|j } n5tj t||jdf|j } g} t|jdD]} t||dd| f|||| nd||d |} |r^| \} }}}| dddddt|f} t!|jD]#\}}|d|dz| |d|dz| |f<$n | \}}}|| || f<| ||jddkr| d} |rtj| | fStj| S)a Gram Orthogonal Matching Pursuit (OMP). Solves n_targets Orthogonal Matching Pursuit problems using only the Gram matrix X.T * X and the product X.T * y. Read more in the :ref:`User Guide `. Parameters ---------- Gram : ndarray of shape (n_features, n_features) Gram matrix of the input data: X.T * X. Xy : ndarray of shape (n_features,) or (n_features, n_targets) Input targets multiplied by X: X.T * y. n_nonzero_coefs : int, default=None Desired number of non-zero entries in the solution. If None (by default) this value is set to 10% of n_features. tol : float, default=None Maximum squared norm of the residual. If not `None`, overrides `n_nonzero_coefs`. norms_squared : array-like of shape (n_targets,), default=None Squared L2 norms of the lines of y. Required if tol is not None. copy_Gram : bool, default=True Whether the gram matrix must be copied by the algorithm. A false value is only helpful if it is already Fortran-ordered, otherwise a copy is made anyway. copy_Xy : bool, default=True Whether the covariance vector Xy must be copied by the algorithm. If False, it may be overwritten. return_path : bool, default=False Whether to return every value of the nonzero coefficients along the forward path. Useful for cross-validation. return_n_iter : bool, default=False Whether or not to return the number of iterations. Returns ------- coef : ndarray of shape (n_features,) or (n_features, n_targets) Coefficients of the OMP solution. If `return_path=True`, this contains the whole coefficient path. In this case its shape is (n_features, n_features) or (n_features, n_targets, n_features) and iterating over the last axis yields coefficients in increasing order of active features. n_iters : array-like or int Number of active features across every target. Returned only if `return_n_iter` is set to True. See Also -------- OrthogonalMatchingPursuit : Orthogonal Matching Pursuit model (OMP). orthogonal_mp : Solves n_targets Orthogonal Matching Pursuit problems. lars_path : Compute Least Angle Regression or Lasso path using LARS algorithm. sklearn.decomposition.sparse_encode : Generic sparse coding. Each column of the result is the solution to a Lasso problem. Notes ----- Orthogonal matching pursuit was introduced in G. Mallat, Z. Zhang, Matching pursuits with time-frequency dictionaries, IEEE Transactions on Signal Processing, Vol. 41, No. 12. (December 1993), pp. 3397-3415. (https://www.di.ens.fr/~mallat/papiers/MallatPursuit93.pdf) This implementation is based on Rubinstein, R., Zibulevsky, M. and Elad, M., Efficient Implementation of the K-SVD Algorithm using Batch Orthogonal Matching Pursuit Technical Report - CS Technion, April 2008. https://www.cs.technion.ac.il/~ronrubin/Publications/KSVD-OMP-v2.pdf rrnrTNrqzSGram OMP needs the precomputed norms in order to evaluate the error sum of squares.rzEpsilon cannot be negativez$The number of atoms must be positiverrr F)r^r_rD)rr,asarrayrvr5newaxisrWrXr+ryrYrzr}r!r~rcrr2rr)r[r\rArBrur^r_rDrjrrrrrQrrMrrIrs rRr|r|sp t3Y 7 7 7D BB w{{rx{Q  w!|| 2:  ?*OMbh( WWYY3;cCIIo.. =0 4    3775666 {!++?@@@ {T22 L   DxTBHQKT;4:NNNxTBHQK0 CCCG 28A;    qqq!tH  #M!  T #      $' !AsE6111jCj()D(11 K K !9:>X\>9JS8a<(!X566 K!NAsFDaLv x{a!* z$((z$rTc eZdZUdZeeddddgeeddddgdgdeedhged hdgd Z e e d <ddd dd d d Z e d dZdS)OrthogonalMatchingPursuitaOrthogonal Matching Pursuit model (OMP). Read more in the :ref:`User Guide `. Parameters ---------- n_nonzero_coefs : int, default=None Desired number of non-zero entries in the solution. If None (by default) this value is set to 10% of n_features. tol : float, default=None Maximum squared norm of the residual. If not None, overrides n_nonzero_coefs. fit_intercept : bool, default=True Whether to calculate the intercept for this model. If set to false, no intercept will be used in calculations (i.e. data is expected to be centered). normalize : bool, default=False This parameter is ignored when ``fit_intercept`` is set to False. If True, the regressors X will be normalized before regression by subtracting the mean and dividing by the l2-norm. If you wish to standardize, please use :class:`~sklearn.preprocessing.StandardScaler` before calling ``fit`` on an estimator with ``normalize=False``. .. versionchanged:: 1.2 default changed from True to False in 1.2. .. deprecated:: 1.2 ``normalize`` was deprecated in version 1.2 and will be removed in 1.4. precompute : 'auto' or bool, default='auto' Whether to use a precomputed Gram and Xy matrix to speed up calculations. Improves performance when :term:`n_targets` or :term:`n_samples` is very large. Note that if you already have such matrices, you can pass them directly to the fit method. Attributes ---------- coef_ : ndarray of shape (n_features,) or (n_targets, n_features) Parameter vector (w in the formula). intercept_ : float or ndarray of shape (n_targets,) Independent term in decision function. n_iter_ : int or array-like Number of active features across every target. n_nonzero_coefs_ : int The number of non-zero coefficients in the solution. If `n_nonzero_coefs` is None and `tol` is None this value is either set to 10% of `n_features` or 1, whichever is greater. n_features_in_ : int Number of features seen during :term:`fit`. .. versionadded:: 0.24 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 -------- orthogonal_mp : Solves n_targets Orthogonal Matching Pursuit problems. orthogonal_mp_gram : Solves n_targets Orthogonal Matching Pursuit problems using only the Gram matrix X.T * X and the product X.T * y. lars_path : Compute Least Angle Regression or Lasso path using LARS algorithm. Lars : Least Angle Regression model a.k.a. LAR. LassoLars : Lasso model fit with Least Angle Regression a.k.a. Lars. sklearn.decomposition.sparse_encode : Generic sparse coding. Each column of the result is the solution to a Lasso problem. OrthogonalMatchingPursuitCV : Cross-validated Orthogonal Matching Pursuit model (OMP). Notes ----- Orthogonal matching pursuit was introduced in G. Mallat, Z. Zhang, Matching pursuits with time-frequency dictionaries, IEEE Transactions on Signal Processing, Vol. 41, No. 12. (December 1993), pp. 3397-3415. (https://www.di.ens.fr/~mallat/papiers/MallatPursuit93.pdf) This implementation is based on Rubinstein, R., Zibulevsky, M. and Elad, M., Efficient Implementation of the K-SVD Algorithm using Batch Orthogonal Matching Pursuit Technical Report - CS Technion, April 2008. https://www.cs.technion.ac.il/~ronrubin/Publications/KSVD-OMP-v2.pdf Examples -------- >>> from sklearn.linear_model import OrthogonalMatchingPursuit >>> from sklearn.datasets import make_regression >>> X, y = make_regression(noise=4, random_state=0) >>> reg = OrthogonalMatchingPursuit().fit(X, y) >>> reg.score(X, y) 0.9991... >>> reg.predict(X[:1,]) array([-78.3854...]) rNrdrerrg deprecatedrhrArB fit_intercept normalizeri_parameter_constraintsTcL||_||_||_||_||_dSNr)selfrArBrrris rR__init__z"OrthogonalMatchingPursuit.__init__s- /*"$rTrkc t|j|jj}|||dd\}}|jd}t ||d|j||jd\}}}}}}} |j dkr|ddtj f}|j -|j &ttd|zd|_n |j |_|dur)t#|||j|j ddd \} |_nK|j tj|d zd nd} t)|| |j|j | ddd \} |_| j|_|||||S)aFit the model using X, y as training data. Parameters ---------- X : array-like of shape (n_samples, n_features) Training data. y : array-like of shape (n_samples,) or (n_samples, n_targets) Target values. Will be cast to X's dtype if necessary. Returns ------- self : object Returns an instance of self. estimator_nameT) multi_output y_numericrNr+rqF)rArBrirCrjrrrs)r\rArBrur^r_rj)rr __class____name___validate_datar5rrirrvr,rrArBrxryn_nonzero_coefs_rn_iter_r{r|r2coef__set_intercept) rr?r@ _normalize n_featuresX_offsety_offsetX_scaler[r\rnorms_sqs rRfitzOrthogonalMatchingPursuit.fits"* N4>+B   ""1add"KK1WQZ 6> q$T5Gd7 7 7 31h'4 6Q;;!!!RZ- A   'DH,<%(C*,<(=(=q$A$AD ! !$($8D ! 5=="/ $ 5H "### E4<<04x/Crvad++++H"4 $ 5H&" # # # E4<W  Hh888 rT)r __module__ __qualname____doc__rrrrrrdict__annotations__rr rrTrRrr[sddN%HXq$vFFFMq$v666=# L>(B(B!C!CD!z6(++Y7 $$D  % % % % %\555>>65>>>rTrdc .|rP|}|}|}|}|rb|d}||z}||z}|d} t|d}|| z}t|d}|| z}|rYtjtj|dzd} tj| } |dd| fxx| | zcc<t|||dddd} | jd kr| ddtj f} |r*| | xx| | ddtj fzcc<tj | j |j |z S) aCompute the residues on left-out data for a full LARS path. Parameters ---------- X_train : ndarray of shape (n_samples, n_features) The data to fit the LARS on. y_train : ndarray of shape (n_samples) The target variable to fit LARS on. X_test : ndarray of shape (n_samples, n_features) The data to compute the residues on. y_test : ndarray of shape (n_samples) The target variable to compute the residues on. copy : bool, default=True Whether X_train, X_test, y_train and y_test should be copied. If False, they may be overwritten. fit_intercept : bool, default=True Whether to calculate the intercept for this model. If set to false, no intercept will be used in calculations (i.e. data is expected to be centered). normalize : bool, default=False This parameter is ignored when ``fit_intercept`` is set to False. If True, the regressors X will be normalized before regression by subtracting the mean and dividing by the l2-norm. If you wish to standardize, please use :class:`~sklearn.preprocessing.StandardScaler` before calling ``fit`` on an estimator with ``normalize=False``. .. versionchanged:: 1.2 default changed from True to False in 1.2. .. deprecated:: 1.2 ``normalize`` was deprecated in version 1.2 and will be removed in 1.4. max_iter : int, default=100 Maximum numbers of iterations to perform, therefore maximum features to include. 100 by default. Returns ------- residues : ndarray of shape (n_samples, max_features) Residues of the prediction on the test data. rrsFrrNT)rArBrirCrDr) r+meanr r,rr{ flatnonzerorrvrr1r2) X_trainy_trainX_testy_testr+rrmax_iterX_meany_meannormsnonzerosrMs rR_omp_path_residuesrsv ,,..,,..1%%6&1%% u5556U333&0wz22233>%((8 h/     E zQaaam$: h5?111bj=99 6%'68 $ $v --rTc eZdZUdZdgdgdeedhgeeddddgdgedgd gd Ze e d <d d ddddd d dZ e d dZ dS)OrthogonalMatchingPursuitCVaCross-validated Orthogonal Matching Pursuit model (OMP). See glossary entry for :term:`cross-validation estimator`. Read more in the :ref:`User Guide `. Parameters ---------- copy : bool, default=True Whether the design matrix X must be copied by the algorithm. A false value is only helpful if X is already Fortran-ordered, otherwise a copy is made anyway. fit_intercept : bool, default=True Whether to calculate the intercept for this model. If set to false, no intercept will be used in calculations (i.e. data is expected to be centered). normalize : bool, default=False This parameter is ignored when ``fit_intercept`` is set to False. If True, the regressors X will be normalized before regression by subtracting the mean and dividing by the l2-norm. If you wish to standardize, please use :class:`~sklearn.preprocessing.StandardScaler` before calling ``fit`` on an estimator with ``normalize=False``. .. versionchanged:: 1.2 default changed from True to False in 1.2. .. deprecated:: 1.2 ``normalize`` was deprecated in version 1.2 and will be removed in 1.4. max_iter : int, default=None Maximum numbers of iterations to perform, therefore maximum features to include. 10% of ``n_features`` but at least 5 if available. cv : int, cross-validation generator or iterable, default=None Determines the cross-validation splitting strategy. Possible inputs for cv are: - None, to use the default 5-fold cross-validation, - integer, to specify the number of folds. - :term:`CV splitter`, - An iterable yielding (train, test) splits as arrays of indices. For integer/None inputs, :class:`~sklearn.model_selection.KFold` is used. Refer :ref:`User Guide ` for the various cross-validation strategies that can be used here. .. versionchanged:: 0.22 ``cv`` default value if None changed from 3-fold to 5-fold. n_jobs : int, default=None Number of CPUs to use during the cross validation. ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context. ``-1`` means using all processors. See :term:`Glossary ` for more details. verbose : bool or int, default=False Sets the verbosity amount. Attributes ---------- intercept_ : float or ndarray of shape (n_targets,) Independent term in decision function. coef_ : ndarray of shape (n_features,) or (n_targets, n_features) Parameter vector (w in the problem formulation). n_nonzero_coefs_ : int Estimated number of non-zero coefficients giving the best mean squared error over the cross-validation folds. n_iter_ : int or array-like Number of active features across every target for the model refit with the best hyperparameters got by cross-validating across all folds. n_features_in_ : int Number of features seen during :term:`fit`. .. versionadded:: 0.24 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 -------- orthogonal_mp : Solves n_targets Orthogonal Matching Pursuit problems. orthogonal_mp_gram : Solves n_targets Orthogonal Matching Pursuit problems using only the Gram matrix X.T * X and the product X.T * y. lars_path : Compute Least Angle Regression or Lasso path using LARS algorithm. Lars : Least Angle Regression model a.k.a. LAR. LassoLars : Lasso model fit with Least Angle Regression a.k.a. Lars. OrthogonalMatchingPursuit : Orthogonal Matching Pursuit model (OMP). LarsCV : Cross-validated Least Angle Regression model. LassoLarsCV : Cross-validated Lasso model fit with Least Angle Regression. sklearn.decomposition.sparse_encode : Generic sparse coding. Each column of the result is the solution to a Lasso problem. Notes ----- In `fit`, once the optimal number of non-zero coefficients is found through cross-validation, the model is fit again using the entire training set. Examples -------- >>> from sklearn.linear_model import OrthogonalMatchingPursuitCV >>> from sklearn.datasets import make_regression >>> X, y = make_regression(n_features=100, n_informative=10, ... noise=4, random_state=0) >>> reg = OrthogonalMatchingPursuitCV(cv=5).fit(X, y) >>> reg.score(X, y) 0.9991... >>> reg.n_nonzero_coefs_ 10 >>> reg.predict(X[:1,]) array([-78.3854...]) rgrrNrdre cv_objectverboser+rrrcvn_jobsrrTFch||_||_||_||_||_||_||_dSrr)rr+rrrrrrs rRrz$OrthogonalMatchingPursuitCV.__init__s: *"    rTrkc  tjjjdd\t ddt jd}jsDtttdj d zd j d nj tjj  fd |D}td |D t#j fd|D}t#j|dd z}|_t-|j}t1j5t1jdt6|dddn #1swxYwY|j_|j_|j_S)a~Fit the model using X, y as training data. Parameters ---------- X : array-like of shape (n_samples, n_features) Training data. y : array-like of shape (n_samples,) Target values. Will be cast to X's dtype if necessary. Returns ------- self : object Returns an instance of self. rTr)rensure_min_featuresF)r+force_all_finite) classifierrqr)rrc 3K|]M\}}tt||||jjVNdSr)rrr+r).0traintestr?rrrr@s rR z2OrthogonalMatchingPursuitCV.fit..2s F F t (G& ' '%%$$ "   F F F F F F rTc30K|]}|jdVdS)rN)r5)rfolds rRrz2OrthogonalMatchingPursuitCV.fit..@s(@@tTZ]@@@@@@rTcRg|]#}|ddzd$S)Nrrrs)r)rrmin_early_stops rR z3OrthogonalMatchingPursuitCV.fit..Bs8 L L L4d?N?#q( . .A . 6 6 L L LrTrrs)rArrignore)categoryN) rrrrrr r rrminrxryr5rrrsplitr,arrayargminrrrrr9catch_warningsfilterwarnings FutureWarningrr intercept_r) rr?r@rcv_paths mse_foldsbest_n_nonzero_coefsomprrrs ``` @@@rRrzOrthogonalMatchingPursuitCV.fitst"* N4>+B   ""1a4Q"OO1 155 A A A dg% 0 0 0= CCagaj())1--qwqz : : :  F84; EEE F F F F F F F F  "xx{{ F F F   @@x@@@@@H L L L L8 L L L   "yQ)?)?@@1D 4'0,     $ & &    #H} E E E E GGAqMMM               Y .{  s2GGG)rrrrrrrrrrrrr rrrTrRrr|syyx # L>(B(B!C!CDXh4???FmT";$$D &\555>>65>>>rTr)NTF)NNTTF)TTFr)+rr9mathrnumbersrrnumpyr,scipyrscipy.linalg.lapackrbaser r r model_selectionr utilsr rutils._param_validationrrrrutils.parallelrr_baserrrr;rSrcndarrayrr|rrrrrTrRrs""""""""000000AAAAAAAAAA&&&&&&////////SSSSSSSSSSSS........>>>>>>>>>> q3q3q3q3p   G3G3G3G3T^j\$HXq$vFFFMq$v666= **fX"6"67+!{#  #'   "  V V V V   V z  V V V V V r}}}}} 0.+}}}J  ^.^.^.^.BXXXXX.+XXXXXrT