-i~SSKrSSKrSSKrSSKJrJr SSKJr SSKJrJ r SSK r SSK J r SSKJr SSKJr SS KJrJrJr SS KJr SS KJrJrJr SS KJrJrJrJ r SS K!J"r"J#r#J$r$J%r% SSK&J'r' SSK(J)r)J*r* SSK+J,r,J-r- SSK.J/r/J0r0J1r1J2r2J3r3J4r4J5r5 SSK6J7r8 SSK9J:r:J;r;J\%"SS/SS/\#"\ SSSS9/\#"\SSSS9/SS/\$"S 15S!S/SS/S!/SS/S"/S!/S!/S#. SS$9SSSS SSSS%S%S%S&. S'j5r?\%"SS/SS/\#"\ S(SS)S9/\#"\ S(SSS9/\#"\SSSS9/SS/\$"S 15S!S/SS/S!/SS/S"/S!/S!/S!/S*.SS$9S+SSSS SSSS%S%S%SS,. S-j5r@"S.S/\\\:5rA"S0S1\A5rBSCS2jrC"S3S4\\:\5rD"S5S6\\D5rE"S7S8\\D5rF"S9S:\B5rG"S;S<\G5rH"S=S>\\D5rI"S?S@\\D5rJg)DN)ABCabstractmethod)partial)IntegralReal)effective_n_jobs)sparse)metadata_routing)MultiOutputMixinRegressorMixin _fit_context)check_cv)Bunch check_array check_scalar)MetadataRouter MethodMapping_raise_for_paramsget_routing_for_object)HiddenInterval StrOptionsvalidate_params)safe_sparse_dot)_routing_enabledprocess_routing)Paralleldelayed)_check_sample_weightcheck_consistent_lengthcheck_is_fittedcheck_random_state column_or_1dhas_fit_parameter validate_data)_cd_fast) LinearModel_pre_fit_preprocess_datacpUS;a[SRU55e[R"U5n[R"U5nUbeUS:XaSOSnU(aUR USS9nO[ R "XS9nU(aUR U5nX4$[ R "XS9nX4$) aTChange the order of X and y if necessary. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Training data. y : ndarray of shape (n_samples,) Target values. order : {None, 'C', 'F'} If 'C', dense arrays are returned as C-ordered, sparse matrices in csr format. If 'F', dense arrays are return as F-ordered, sparse matrices in csc format. Returns ------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Training data with guaranteed order. y : ndarray of shape (n_samples,) Target values with guaranteed order. )NCFz`. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Training data. Pass directly as Fortran-contiguous data to avoid unnecessary memory duplication. If ``y`` is mono-output then ``X`` can be sparse. y : {array-like, sparse matrix} of shape (n_samples,) or (n_samples, n_targets) Target values. eps : float, default=1e-3 Length of the path. ``eps=1e-3`` means that ``alpha_min / alpha_max = 1e-3``. n_alphas : int, default=100 Number of alphas along the regularization path. alphas : array-like, default=None List of alphas where to compute the models. If ``None`` alphas are set automatically. precompute : 'auto', bool or array-like of shape (n_features, n_features), default='auto' Whether to use a precomputed Gram matrix to speed up calculations. If set to ``'auto'`` let us decide. The Gram matrix can also be passed as argument. Xy : array-like of shape (n_features,) or (n_features, n_targets), default=None Xy = np.dot(X.T, y) that can be precomputed. It is useful only when the Gram matrix is precomputed. copy_X : bool, default=True If ``True``, X will be copied; else, it may be overwritten. coef_init : array-like of shape (n_features, ), default=None The initial values of the coefficients. verbose : bool or int, default=False Amount of verbosity. return_n_iter : bool, default=False Whether to return the number of iterations or not. positive : bool, default=False If set to True, forces coefficients to be positive. (Only allowed when ``y.ndim == 1``). **params : kwargs Keyword arguments passed to the coordinate descent solver. Returns ------- alphas : ndarray of shape (n_alphas,) The alphas along the path where models are computed. coefs : ndarray of shape (n_features, n_alphas) or (n_targets, n_features, n_alphas) Coefficients along the path. dual_gaps : ndarray of shape (n_alphas,) The dual gaps at the end of the optimization for each alpha. n_iters : list of int The number of iterations taken by the coordinate descent optimizer to reach the specified tolerance for each alpha. See Also -------- lars_path : Compute Least Angle Regression or Lasso path using LARS algorithm. Lasso : The Lasso is a linear model that estimates sparse coefficients. LassoLars : Lasso model fit with Least Angle Regression a.k.a. Lars. LassoCV : Lasso linear model with iterative fitting along a regularization path. LassoLarsCV : Cross-validated Lasso using the LARS algorithm. sklearn.decomposition.sparse_encode : Estimator that can be used to transform signals into sparse linear combination of atoms from a fixed. Notes ----- For an example, see :ref:`examples/linear_model/plot_lasso_lasso_lars_elasticnet_path.py `. To avoid unnecessary memory duplication the X argument of the fit method should be directly passed as a Fortran-contiguous numpy array. Note that in certain cases, the Lars solver may be significantly faster to implement this functionality. In particular, linear interpolation can be used to retrieve model coefficients between the values output by lars_path Examples -------- Comparing lasso_path and lars_path with interpolation: >>> import numpy as np >>> from sklearn.linear_model import lasso_path >>> X = np.array([[1, 2, 3.1], [2.3, 5.4, 4.3]]).T >>> y = np.array([1, 2, 3.1]) >>> # Use lasso_path to compute a coefficient path >>> _, coef_path, _ = lasso_path(X, y, alphas=[5., 1., .5]) >>> print(coef_path) [[0. 0. 0.46874778] [0.2159048 0.4425765 0.23689075]] >>> # Now use lars_path and 1D linear interpolation to compute the >>> # same path >>> from sklearn.linear_model import lars_path >>> alphas, active, coef_path_lars = lars_path(X, y, method='lasso') >>> from scipy import interpolate >>> coef_path_continuous = interpolate.interp1d(alphas[::-1], ... coef_path_lars[:, ::-1]) >>> print(coef_path_continuous([5., 1., .5])) [[0. 0. 0.46915237] [0.2159048 0.4425765 0.23668876]] rB) r^r_r`rqrrr]rarsrprurt) enet_path) r:r;r_r`rqrrr]rarsrprtruparamss r? lasso_pathr{sJZ      #   rAboth)r:r;r^r_r`rqrrr]rarsrprtrurH?) r^r_r`rqrrr]rarsrprtrurHc  URSS5nURSS5nURSS5nURSS5nURSS5nURS S5nURS S 5n[U5S :a[S UR55eU (ap[ US[ R [ R/SUS9n[ USURRSSSS9nUb [ XpRRSSSS9nURunnSnURS:waSnURSnU(aU (a [S5eU(db[R"U5(aGUb%UU- n[ R"UURS9nO[ R"UURS9nU (a[!UUUUSSU S9up npgUc[#UUUUSUUSS9nO+[U5S:a[ R$"U5SSS2n[U5n[ R&"U5n/n[)U5nUS;a [S5eUS:HnU(d"[ R&"UU4URS9n O"[ R&"WUU4URS9n U c.[ R"U RSSURSS9n!O[ R*"XRS9n![-U5GHun"n#U#U-U-n$U#S U- -U-n%U(d[[R"U5(a@[.R0"U!U$U%UR2UR4UR6UUWUUUUU S!9n&OU(a[.R8"U!U$U%XUUUU5 n&O[;U[ R<5(aFU (a[ X`RRSS9n[.R>"U!U$U%UUUUUUUU 5 n&O2USLa[.R@"U!U$U%XUUUUU 5 n&O[S"U-5eU&un!n'n(n)U!U S#U"4'U'U- UU"'URCU)5 U (dGMiU S$:a[EU&5 GM}U S:a[ES%U"U4-5 GM[FRHRKS&5 GM U (aUU UU4$UU U4$)'aCompute elastic net path with coordinate descent. The elastic net optimization function varies for mono and multi-outputs. For mono-output tasks it is:: 1 / (2 * n_samples) * ||y - Xw||^2_2 + alpha * l1_ratio * ||w||_1 + 0.5 * alpha * (1 - l1_ratio) * ||w||^2_2 For multi-output tasks it is:: (1 / (2 * n_samples)) * ||Y - XW||_Fro^2 + alpha * l1_ratio * ||W||_21 + 0.5 * alpha * (1 - l1_ratio) * ||W||_Fro^2 Where:: ||W||_21 = \sum_i \sqrt{\sum_j w_{ij}^2} i.e. the sum of norm of each row. Read more in the :ref:`User Guide `. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Training data. Pass directly as Fortran-contiguous data to avoid unnecessary memory duplication. If ``y`` is mono-output then ``X`` can be sparse. y : {array-like, sparse matrix} of shape (n_samples,) or (n_samples, n_targets) Target values. l1_ratio : float, default=0.5 Number between 0 and 1 passed to elastic net (scaling between l1 and l2 penalties). ``l1_ratio=1`` corresponds to the Lasso. eps : float, default=1e-3 Length of the path. ``eps=1e-3`` means that ``alpha_min / alpha_max = 1e-3``. n_alphas : int, default=100 Number of alphas along the regularization path. alphas : array-like, default=None List of alphas where to compute the models. If None alphas are set automatically. precompute : 'auto', bool or array-like of shape (n_features, n_features), default='auto' Whether to use a precomputed Gram matrix to speed up calculations. If set to ``'auto'`` let us decide. The Gram matrix can also be passed as argument. Xy : array-like of shape (n_features,) or (n_features, n_targets), default=None Xy = np.dot(X.T, y) that can be precomputed. It is useful only when the Gram matrix is precomputed. copy_X : bool, default=True If ``True``, X will be copied; else, it may be overwritten. coef_init : array-like of shape (n_features, ), default=None The initial values of the coefficients. verbose : bool or int, default=False Amount of verbosity. return_n_iter : bool, default=False Whether to return the number of iterations or not. positive : bool, default=False If set to True, forces coefficients to be positive. (Only allowed when ``y.ndim == 1``). check_input : bool, default=True If set to False, the input validation checks are skipped (including the Gram matrix when provided). It is assumed that they are handled by the caller. **params : kwargs Keyword arguments passed to the coordinate descent solver. Returns ------- alphas : ndarray of shape (n_alphas,) The alphas along the path where models are computed. coefs : ndarray of shape (n_features, n_alphas) or (n_targets, n_features, n_alphas) Coefficients along the path. dual_gaps : ndarray of shape (n_alphas,) The dual gaps at the end of the optimization for each alpha. n_iters : list of int The number of iterations taken by the coordinate descent optimizer to reach the specified tolerance for each alpha. (Is returned when ``return_n_iter`` is set to True). See Also -------- MultiTaskElasticNet : Multi-task ElasticNet model trained with L1/L2 mixed-norm as regularizer. MultiTaskElasticNetCV : Multi-task L1/L2 ElasticNet with built-in cross-validation. ElasticNet : Linear regression with combined L1 and L2 priors as regularizer. ElasticNetCV : Elastic Net model with iterative fitting along a regularization path. Notes ----- For an example, see :ref:`examples/linear_model/plot_lasso_lasso_lars_elasticnet_path.py `. Examples -------- >>> from sklearn.linear_model import enet_path >>> from sklearn.datasets import make_regression >>> X, y, true_coef = make_regression( ... n_samples=100, n_features=5, n_informative=2, coef=True, random_state=0 ... ) >>> true_coef array([ 0. , 0. , 0. , 97.9, 45.7]) >>> alphas, estimated_coef, _ = enet_path(X, y, n_alphas=3) >>> alphas.shape (3,) >>> estimated_coef array([[ 0., 0.787, 0.568], [ 0., 1.120, 0.620], [-0., -2.129, -1.128], [ 0., 23.046, 88.939], [ 0., 10.637, 41.566]]) rcNX_scalerGtol-C6?max_iter random_state selectioncyclicrzUnexpected parameters in paramsr/r.) accept_sparsedtyper3r1F)rrr3r1 ensure_2dr-)rr3r1rr'Tz;positive=True is not allowed for multi-output (y.ndim != 1)r)rFr1rH)r]r^rFr_r`rarI)randomrz,selection should be either random or cyclic.rrr3rB)walphabetaX_data X_indicesX_indptrr;rGX_meanrrrngrruzEPrecompute should be one of True, False, 'auto' or array-like. Got %r.r zPath: %03i out of %03i.)&poplenr4keysrr8rYfloat32rtyperUrOr r6r9zerosr*rhsortemptyr#asfortranarray enumeratecd_fastsparse_enet_coordinate_descentdataindicesindptr"enet_coordinate_descent_multi_task isinstancendarrayenet_coordinate_descent_gramenet_coordinate_descentappendprintsysstderrwrite)*r:r;r^r_r`rqrrr]rarsrprtrurHrzX_offset_param X_scale_paramrGrrrrrf n_features multi_output n_targetsX_sparse_scalingrd dual_gapsn_itersrrcoefscoef_irl1_regl2_regmodel dual_gap_eps_n_iter_s* r?ryryysXZZ D1NJJy$/MJJ5M **UD !Czz*d+H::nd3L ;1I 6{Q:FKKMJJ  ::rzz*    '',,   >'',,cBGGIzLvv{ GGAJ VWW FOOA..  % . = !zz*:!''J !xx !''B (0  #) %aAz~    Vq2&6{H"IG \ *C,,GHH ( "F *h/qww?)Z:!''JSb)D!!)77;f%5!I-#.)I5 2 2::vv))+'!!E >>vvqXsCE BJJ / /(77<?   %C&Fui00 5) ##rAc@^\rSrSr%SrS\R 0r\"\ SSSS9/\"\ SSS S9/S /S S /\"\ SSSS9S/S /\"\ SSSS9/S /S /S /\ "S S15/S. r \ \S'\"\5rSSSSSSSSSSS S. Sjjr\"SS9SSj5r\S5rU4SjrU4SjrSrU=r$) ElasticNetiaLinear regression with combined L1 and L2 priors as regularizer. Minimizes the objective function:: 1 / (2 * n_samples) * ||y - Xw||^2_2 + alpha * l1_ratio * ||w||_1 + 0.5 * alpha * (1 - l1_ratio) * ||w||^2_2 If you are interested in controlling the L1 and L2 penalty separately, keep in mind that this is equivalent to:: a * ||w||_1 + 0.5 * b * ||w||_2^2 where:: alpha = a + b and l1_ratio = a / (a + b) The parameter l1_ratio corresponds to alpha in the glmnet R package while alpha corresponds to the lambda parameter in glmnet. Specifically, l1_ratio = 1 is the lasso penalty. Currently, l1_ratio <= 0.01 is not reliable, unless you supply your own sequence of alpha. Read more in the :ref:`User Guide `. Parameters ---------- alpha : float, default=1.0 Constant that multiplies the penalty terms. Defaults to 1.0. See the notes for the exact mathematical meaning of this parameter. ``alpha = 0`` is equivalent to an ordinary least square, solved by the :class:`LinearRegression` object. For numerical reasons, using ``alpha = 0`` with the ``Lasso`` object is not advised. Given this, you should use the :class:`LinearRegression` object. l1_ratio : float, default=0.5 The ElasticNet mixing parameter, with ``0 <= l1_ratio <= 1``. For ``l1_ratio = 0`` the penalty is an L2 penalty. ``For l1_ratio = 1`` it is an L1 penalty. For ``0 < l1_ratio < 1``, the penalty is a combination of L1 and L2. fit_intercept : bool, default=True Whether the intercept should be estimated or not. If ``False``, the data is assumed to be already centered. precompute : bool or array-like of shape (n_features, n_features), default=False Whether to use a precomputed Gram matrix to speed up calculations. The Gram matrix can also be passed as argument. For sparse input this option is always ``False`` to preserve sparsity. Check :ref:`an example on how to use a precomputed Gram Matrix in ElasticNet ` for details. max_iter : int, default=1000 The maximum number of iterations. copy_X : bool, default=True If ``True``, X will be copied; else, it may be overwritten. tol : float, default=1e-4 The tolerance for the optimization: if the updates are smaller than ``tol``, the optimization code checks the dual gap for optimality and continues until it is smaller than ``tol``, see Notes below. warm_start : bool, default=False When set to ``True``, reuse the solution of the previous call to fit as initialization, otherwise, just erase the previous solution. See :term:`the Glossary `. positive : bool, default=False When set to ``True``, forces the coefficients to be positive. random_state : int, RandomState instance, default=None The seed of the pseudo random number generator that selects a random feature to update. Used when ``selection`` == 'random'. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. selection : {'cyclic', 'random'}, default='cyclic' If set to 'random', a random coefficient is updated every iteration rather than looping over features sequentially by default. This (setting to 'random') often leads to significantly faster convergence especially when tol is higher than 1e-4. Attributes ---------- coef_ : ndarray of shape (n_features,) or (n_targets, n_features) Parameter vector (w in the cost function formula). sparse_coef_ : sparse matrix of shape (n_features,) or (n_targets, n_features) Sparse representation of the `coef_`. intercept_ : float or ndarray of shape (n_targets,) Independent term in decision function. n_iter_ : list of int Number of iterations run by the coordinate descent solver to reach the specified tolerance. dual_gap_ : float or ndarray of shape (n_targets,) Given param alpha, the dual gaps at the end of the optimization, same shape as each observation of y. 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 -------- ElasticNetCV : Elastic net model with best model selection by cross-validation. SGDRegressor : Implements elastic net regression with incremental training. SGDClassifier : Implements logistic regression with elastic net penalty (``SGDClassifier(loss="log_loss", penalty="elasticnet")``). Notes ----- To avoid unnecessary memory duplication the X argument of the fit method should be directly passed as a Fortran-contiguous numpy array. The precise stopping criteria based on `tol` are the following: First, check that that maximum coordinate update, i.e. :math:`\max_j |w_j^{new} - w_j^{old}|` is smaller than `tol` times the maximum absolute coefficient, :math:`\max_j |w_j|`. If so, then additionally check whether the dual gap is smaller than `tol` times :math:`||y||_2^2 / n_{ ext{samples}}`. Examples -------- >>> from sklearn.linear_model import ElasticNet >>> from sklearn.datasets import make_regression >>> X, y = make_regression(n_features=2, random_state=0) >>> regr = ElasticNet(random_state=0) >>> regr.fit(X, y) ElasticNet(random_state=0) >>> print(regr.coef_) [18.83816048 64.55968825] >>> print(regr.intercept_) 1.451 >>> print(regr.predict([[0, 0]])) [1.451] - :ref:`sphx_glr_auto_examples_linear_model_plot_lasso_and_elasticnet.py` showcases ElasticNet alongside Lasso and ARD Regression for sparse signal recovery in the presence of noise and feature correlation. rHrNrmrkr'r}rorirrr rr^rFrrrrar warm_startrurr_parameter_constraintsr~TFrr) r^rFrrrrarrrurrc XlX lX0lX@lXPlX`lXplXlXlXl Xl gNr) selfrr^rFrrrrarrrurrs r?__init__ElasticNet.__init__s=  *$  $ ("rArvclURS:Xa[R"SSS9 SnU(asUR=(a URn[ UUUSS[ R[ R/SSUSSS 9 up[USSURRSS 9nURupgURn[U[R5(aS nUb6U(a[!X1URS 9nX6[ R""U5- -nUR=(a U(+n [%UUS UR&URU UUS 9upppnU(dUb [)XSS9upUR*S:XaUS S 2[ R,4nUb'UR*S:XaUS S 2[ R,4nURSnUR.(a[1US5(d"[ R2"X4URSS9nO3UR4nUR*S:XaU[ R,S S 24n[ R2"XRS 9n/Ul5HnUb US S 2U4nOS nUR;UUS S 2U4UR<S S U/U USUUSSUR>SUR@U U URBURDURFUS9unnnnUS S 2S4UU'USUU'UR6RIUS5 M US:Xa)UR6SUlUSUlUSUl%OUUlUUl%URMXU 5 [OSUR4URP455(d [SS5eU$)aFit model with coordinate descent. Parameters ---------- X : {ndarray, sparse matrix, sparse array} of (n_samples, n_features) Data. Note that large sparse matrices and arrays requiring `int64` indices are not accepted. y : ndarray of shape (n_samples,) or (n_samples, n_targets) Target. Will be cast to X's dtype if necessary. sample_weight : float or array-like of shape (n_samples,), default=None Sample weights. Internally, the `sample_weight` vector will be rescaled to sum to `n_samples`. .. versionadded:: 0.23 check_input : bool, default=True Allow to bypass several input checking. Don't use this parameter unless you know what you do. Returns ------- self : object Fitted estimator. Notes ----- Coordinate descent is an algorithm that considers each column of data at a time hence it will automatically convert the X input as a Fortran-contiguous numpy array if necessary. To avoid memory re-allocation it is advised to allocate the initial data in memory directly using that format. rzjWith alpha=0, this algorithm does not converge well. You are advised to use the LinearRegression estimatorr ) stacklevelFr/r.T)rr3rforce_writeableaccept_large_sparser1r y_numeric)r3r1rrNr)rFr1rHrGr2r'rr)r^r_r`rqrrr]rarsrprtrurHrrcrrrrrGc3j# UH)n[R"U5R5v M+ g7fr)r8isfiniteall).0rs r? !ElasticNet.fit..cs&O1NA2;;q>%%''1Ns13zCoordinate descent iterations resulted in non-finite parameter values. The input data may contain large values and need to be preprocessed.)*rwarningswarnrarFr&r8rYrrrrrUrnumbersNumberr rRr*rrr@rOrTrhasattrrrrrangepathr^rurrrrrr_set_interceptr intercept_r4)rr:r;rGrHX_copiedrfrr should_copyrcy_offsetrrrr]rr dual_gaps_kthis_Xyrd this_coef this_dual_gap this_iters r?fitElasticNet.fitsxN ::? MM    {{9t'9'9H #zz2::. $$)! DA5 A!"   mW^^ 4 4 M  $ 4]QWW U 8* 9N-NOMkk2(l bgglArzzM"BGGAJ gdG&<&<HHi4AGG3OEJJEzzQbjj!m,XXiww7  y!A~QT(59YY!Q$w%("!HH!!....+-6?6 2Ay-0!AE!H)!,JqM LL   ! -?"B ><<?DLqDJ']DNDJ'DN H8O$**doo1NOOO$  rAcB[R"UR5$)z,Sparse representation of the fitted `coef_`.)r csr_matrixrrs r? sparse_coef_ElasticNet.sparse_coef_ms  ,,rAc>[U5 [R"U5(a+[XRR SS9UR -$[TU]!U5$)zDecision function of the linear model. Parameters ---------- X : numpy array or scipy.sparse matrix of shape (n_samples, n_features) Returns ------- T : ndarray of shape (n_samples,) The predicted decision function. TrJ) r"r r6rrrQrsuper_decision_function)rr: __class__s r?rElasticNet._decision_functionrsJ  ??1  "1jjllFX X7-a0 0rAcF>[TU]5nSURlU$NT)r__sklearn_tags__ input_tagsr rtagsrs r?rElasticNet.__sklearn_tags__s!w')!% rA)rrrarrFr^rrrurrrrrrrBr)__name__ __module__ __qualname____firstlineno____doc__r UNUSED"_ElasticNet__metadata_request__fitrrrrrdict__annotations__ staticmethodryrrrrpropertyrrr__static_attributes__ __classcell__rs@r?rrs!Z| -.>.E.EF4D89dAq89# ,/h4?F+q$v67 kK'( (H!567 $D   "D# #65G6GR--1$rArc ^\rSrSr%Sr0\R Er\\S'\RS5 \ "\ 5r SSSSSSSSS S S . U4S jjjr S rU=r$)LassoiaLinear Model trained with L1 prior as regularizer (aka the Lasso). The optimization objective for Lasso is:: (1 / (2 * n_samples)) * ||y - Xw||^2_2 + alpha * ||w||_1 Technically the Lasso model is optimizing the same objective function as the Elastic Net with ``l1_ratio=1.0`` (no L2 penalty). Read more in the :ref:`User Guide `. Parameters ---------- alpha : float, default=1.0 Constant that multiplies the L1 term, controlling regularization strength. `alpha` must be a non-negative float i.e. in `[0, inf)`. When `alpha = 0`, the objective is equivalent to ordinary least squares, solved by the :class:`LinearRegression` object. For numerical reasons, using `alpha = 0` with the `Lasso` object is not advised. Instead, you should use the :class:`LinearRegression` object. 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). precompute : bool or array-like of shape (n_features, n_features), default=False Whether to use a precomputed Gram matrix to speed up calculations. The Gram matrix can also be passed as argument. For sparse input this option is always ``False`` to preserve sparsity. copy_X : bool, default=True If ``True``, X will be copied; else, it may be overwritten. max_iter : int, default=1000 The maximum number of iterations. tol : float, default=1e-4 The tolerance for the optimization: if the updates are smaller than ``tol``, the optimization code checks the dual gap for optimality and continues until it is smaller than ``tol``, see Notes below. warm_start : bool, default=False When set to True, reuse the solution of the previous call to fit as initialization, otherwise, just erase the previous solution. See :term:`the Glossary `. positive : bool, default=False When set to ``True``, forces the coefficients to be positive. random_state : int, RandomState instance, default=None The seed of the pseudo random number generator that selects a random feature to update. Used when ``selection`` == 'random'. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. selection : {'cyclic', 'random'}, default='cyclic' If set to 'random', a random coefficient is updated every iteration rather than looping over features sequentially by default. This (setting to 'random') often leads to significantly faster convergence especially when tol is higher than 1e-4. Attributes ---------- coef_ : ndarray of shape (n_features,) or (n_targets, n_features) Parameter vector (w in the cost function formula). dual_gap_ : float or ndarray of shape (n_targets,) Given param alpha, the dual gaps at the end of the optimization, same shape as each observation of y. sparse_coef_ : sparse matrix of shape (n_features, 1) or (n_targets, n_features) Readonly property derived from ``coef_``. intercept_ : float or ndarray of shape (n_targets,) Independent term in decision function. n_iter_ : int or list of int Number of iterations run by the coordinate descent solver to reach the specified tolerance. 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 -------- lars_path : Regularization path using LARS. lasso_path : Regularization path using Lasso. LassoLars : Lasso Path along the regularization parameter using LARS algorithm. LassoCV : Lasso alpha parameter by cross-validation. LassoLarsCV : Lasso least angle parameter algorithm by cross-validation. sklearn.decomposition.sparse_encode : Sparse coding array estimator. Notes ----- The algorithm used to fit the model is coordinate descent. To avoid unnecessary memory duplication the X argument of the fit method should be directly passed as a Fortran-contiguous numpy array. Regularization improves the conditioning of the problem and reduces the variance of the estimates. Larger values specify stronger regularization. Alpha corresponds to `1 / (2C)` in other linear models such as :class:`~sklearn.linear_model.LogisticRegression` or :class:`~sklearn.svm.LinearSVC`. The precise stopping criteria based on `tol` are the following: First, check that that maximum coordinate update, i.e. :math:`\max_j |w_j^{new} - w_j^{old}|` is smaller than `tol` times the maximum absolute coefficient, :math:`\max_j |w_j|`. If so, then additionally check whether the dual gap is smaller than `tol` times :math:`||y||_2^2 / n_{\text{samples}}`. The target can be a 2-dimensional array, resulting in the optimization of the following objective:: (1 / (2 * n_samples)) * ||Y - XW||^2_F + alpha * ||W||_11 where :math:`||W||_{1,1}` is the sum of the magnitude of the matrix coefficients. It should not be confused with :class:`~sklearn.linear_model.MultiTaskLasso` which instead penalizes the :math:`L_{2,1}` norm of the coefficients, yielding row-wise sparsity in the coefficients. Examples -------- >>> from sklearn import linear_model >>> clf = linear_model.Lasso(alpha=0.1) >>> clf.fit([[0,0], [1, 1], [2, 2]], [0, 1, 2]) Lasso(alpha=0.1) >>> print(clf.coef_) [0.85 0. ] >>> print(clf.intercept_) 0.15 - :ref:`sphx_glr_auto_examples_linear_model_plot_lasso_and_elasticnet.py` compares Lasso with other L1-based regression models (ElasticNet and ARD Regression) for sparse signal recovery in the presence of noise and feature correlation. rr^TFrrNr) rFrrrarrrrurrc 4>[T U]USUUUUUUUU U S9 g)NrB) rr^rFrrrarrrrurrrr) rrrFrrrarrrrurrrs r?rLasso.__init__-s8 '!!%  rAr)rrrrrrrrrrrryrrrrr s@r?r r srUn$  + +$Dz*  "D    rAr c PXn Xn XnXnUcSunnO3X#nX$nU RSnUU[R"U5- -n[R"U5(dJX4X4X4X44H<unnUR ULdMUR S(aM-URSS9 M> URS:XaUSnOS n[U U SUUS US 9upnnnnnUR5nUUS 'UUS 'UUS 'UUS'S US'XS'UUS'SU;aXS'[U SXS9n U"X40UD6unnnA A URS:XaGU[RSS2SS24n[R"U5nUSS2[R4nUSS2[R4[R"UU5- n[UU5nUUSS2SS2[R4- nUU- nUcUS-R!SS9nO[R""US-USS9nUR!SS9$)a Returns the MSE for the models computed by 'path'. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Training data. y : array-like of shape (n_samples,) or (n_samples, n_targets) Target values. sample_weight : None or array-like of shape (n_samples,) Sample weights. train : list of indices The indices of the train set. test : list of indices The indices of the test set. path : callable Function returning a list of models on the path. See enet_path for an example of signature. path_params : dictionary Parameters passed to the path function. alphas : array-like, default=None Array of float that is used for cross-validation. If not provided, computed using 'path'. l1_ratio : float, default=1 float between 0 and 1 passed to ElasticNet (scaling between l1 and l2 penalties). For ``l1_ratio = 0`` the penalty is an L2 penalty. For ``l1_ratio = 1`` it is an L1 penalty. For ``0 < l1_ratio < 1``, the penalty is a combination of L1 and L2. X_order : {'F', 'C'}, default=None The order of the arrays expected by the path function to avoid memory copies. dtype : a numpy dtype, default=None The dtype of the arrays expected by the path function to avoid memory copies. N)NNr WRITEABLET)rr'rrF)rFr1rGr]rcrrarqrGr^r/)rrr3r rL)weightsrM)rUr8rRr r6baseflagssetflagsrOr*r1rrT atleast_1drSrmeanaverage) r:r;rGtraintestrFr path_paramsrqr^X_orderrX_trainy_trainX_testy_testsw_trainsw_testrfarray array_inputrrrcrrr]rrd intercepts X_test_coefsresiduesthis_mses r?_path_residualsr)Ns{thGhG WF WF&' '%MM!$  Ix 000 ??1   L L K K # E; zz,U[[5M5MT*#  vv{ .  DL # EAGh':r""$KK&K $K  *K !K"#+K [ "*J'eSGG< <FE1vv{bjj!Q&'==*2:: &!RZZ-(266(E+BBJ"651LfQ2::%566H HaK%%1%-::hk7C ==a=  rAc^\rSrSr%Sr\"\SSSS9/\"\SSSS9\"\ "S 155/\"\SSSS9S S\"\ "S 155/S /\ "S 15S S /\"\SSSS9/\"\SSSS9/S /S/S/\S/S /S/\ "SS15/S.r \ \ S'\ SSj5r\ S5r\ S5r\\ S55r\"SS9S Sj5rSrU4SjrSrU=r$)! LinearModelCVizCBase class for iterative model fitting along a regularization path.rNrjrkr'rm deprecatedrirrorn cv_objectrprrrr_r`rqrFrrrrracvrpn_jobsrurrrTcXlX lX0lX@lXPlX`lXplXlXlXl Xl Xl Xl Xl grr.)rr_r`rqrFrrrrrar/rpr0rurrs r?rLinearModelCV.__init__sL$  *$     ("rAcg)zBool indicating if class is meant for multidimensional target.Nrrs r? _is_multitaskLinearModelCV._is_multitaskr6rAc g)z%Compute path with coordinate descent.Nr)r:r;kwargss r?rLinearModelCV.path"r6rArvc ^^^^^#^$[UTS5 TRS:XaSTlO,[R"S[ 5 TRTl[ TR[5(aTRS:XaO:TRc[R"S[ 5 OTRTlTR=(a TRn[S[R[R/SS 9n[ T[R5(d[ R""T5(aTn[S [R[R/S SSS 9n[%TTTX4S 9umm[ R""T5(aD['US5(a2[R("UR*TR*5(dSnO[R("UT5(dSnAO=[S [R[R/SS US9n[%TTTX4S 9ummSn[-TT5 TR/5(dPTR0S:a5TR2SS:a"[5STR6R8-5e[;TS S9mO[[ R""T5(a [=S5eTR0S:Xa%[5STR6R8SS-5e[ T[>R@5(aSmTb[CTTTRDS9mTRG5n TRI5m$T$RKSS5 ST$;a"[RL"T$S5n U ST$S'OS/n T$RKSS5 T$RKSS5 [OU 5n [Q[R[TSSS9n [ TR[V5(aIU V s/sH;n [YTTU TRTRZTRTRTS 9PM= nn Oi[]TR5HunnU "US!US"35 M [R^"[R`"TR5SSS#2U S45n[OUS5nT$RcS$U05 UT$S%'[eTRf5S:aST$S%'[iTRj5n[m5(ap[oU5RqS&S'/S(9nTb#U(d[sTS'5(d [5S)5eU(aTUS''[uTS40UD6nTb[sTS'5(dSmO [w5n[w[w5S*9Ul<[{UR|"TT40URxR|D65m#[R~nUU#U$UUU4S+j[X55n[TRfTRS,S-9"U5n[R"UU [OT#5S#45n[R"USS.9n[R"[R"US/S55TlG[XU5H3un nn[R"U5nUUnUU:dM*UUnU nUnM5 WTlIWTlJ[ TR[V5(a6[R"U5TlLU S:XaTRSTlLO[R"US5TlLTRI5R5VV s0sHunn UU RI5;dMUU _M! n!nn U R"S30U!D6 UU lOUU lPXYl [TS0S5n"[ U"[5(a U"S1:XaSU lRTcU RTT5 OU RTTTS29 ['TS5(dT?IU RTlTU RTlUU RTlVU RTlWT$s sn fs sn nf)4aFit linear model with coordinate descent. Fit is on grid of alphas and best alpha estimated by cross-validation. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Training data. Pass directly as Fortran-contiguous data to avoid unnecessary memory duplication. If y is mono-output, X can be sparse. Note that large sparse matrices and arrays requiring `int64` indices are not accepted. y : array-like of shape (n_samples,) or (n_samples, n_targets) Target values. sample_weight : float or array-like of shape (n_samples,), default=None Sample weights used for fitting and evaluation of the weighted mean squared error of each cv-fold. Note that the cross validated MSE that is finally used to find the best model is the unweighted mean over the (weighted) MSEs of each test fold. **params : dict, default=None Parameters to be passed to the CV splitter. .. versionadded:: 1.4 Only available if `enable_metadata_routing=True`, which can be set by using ``sklearn.set_config(enable_metadata_routing=True)``. See :ref:`Metadata Routing User Guide ` for more details. Returns ------- self : object Returns an instance of fitted model. rr,rDa6'n_alphas' was deprecated in 1.7 and will be removed in 1.9. 'alphas' now accepts an integer value which removes the need to pass 'n_alphas'. The default value of 'alphas' will change from None to 100 in 1.9. Pass an explicit value to 'alphas' and leave 'n_alphas' to its default value to silence this warning.rNz'alphas=None' is deprecated and will be removed in 1.9, at which point the default value will be set to 100. Set 'alphas=100' to silence this warning.F)r1rrr/T)rrrr1rvalidate_separatelyrr.)rrr3rr1r'z'For multi-task outputs, use MultiTask%s)rz/X should be dense but a sparse matrix waspassedzFor mono-task outputs, use %sCV rrFr^rr/r0r|rm) target_typemin_valinclude_boundaries)r^rFr_r`rarGzalphas[]rIr`rasplitrG)methodrzzGThe CV splitter and underlying estimator do not support sample weights.)rEc3># UHYupTHMup4[[5"TT TUUT RT RTUUSTRR S9 v MO M[ g7f)r.)rqr^rrN)rr)rFrrr) r this_l1_ratio this_alphasrrr:foldsrrGrr;s r?r$LinearModelCV.fit.. sr /E* $  O $"" "&ggll  % /EsA!A$threads)r0rppreferrLr rrrn)rGr)Xrr`_alphasrr FutureWarningrrqstrrarFrr8rYrrr r6r&rmay_share_memoryrr!r8rOrUr4rrr$ TypeErrorrrr rr4 get_paramsrrrrrrrrhr_rtilerupdaterr0rr/rrconsumesr%rrsplitterlistrEinfziprrprPrsqueezemoveaxis mse_path_argmin l1_ratio_alpha_r9alphas_items set_paramsrr^getattrrrrrrrr)%rr:r;rGrzracheck_y_paramsreference_to_old_Xcheck_X_paramsr l1_ratios n_l1_ratiocheck_scalar_alphar^rqindexrr`r/splitter_supports_sample_weight routed_paramsbest_msejobs mse_pathsmean_mse l1_alphas mse_alphas i_best_alpha this_best_mse best_alpha best_l1_rationamevalue common_paramsrrrJrs%```` @@r?rLinearModelCV.fit'sN &$. ==L (DL MM@    ==DL dkk3 ' 'DKK6,A  [[ MM+   ;;DL 3!3!3rzz2::6%  a $ $(:(:!" "#zz2::. $$) N!a0PDAqq!!-v66r?R?R&++QVV@@#F(();Q??" "#zz2::. $ N!a0PDAqF1%!!##vvzaggaj1n =@W@WWQT*Aq!! QRR1 58O8OPQPR8SS mW^^ 4 4 M  $0QM##%oo'  .  $ k*&=>I&/lK #I d#$'^ $ %   dllH - -!* !*H%"&"4"4!\\;;"/ !*  F!*$,, 7 u"5GE7!*<=!8WWRWWT\\24R48:q/JFvay>J12 & H DKK (1 ,$)K !dgg    .DR.H.Q.Q'8/R/ +)7)$@@ ' /*7'+D%B6BM(1Bo22!% !GM%*%9M "RXXaCm&<&<&B&BCD66  /2).D $;;LL    JJy:s5z2*FG 7791-BKK 1a$@A/29h/O +Hi99Z0L&|4Mx'&|4 ( ( 0P'  dllH - -::f-DLQ#||A ::fQi0DL $0668 8 eu'')) D%K8  )=)  & T<6 j# & &:+?$E    IIaO IIa-I 8tZ(([[ **}}  U b sAa79a<a<c[URRS9RU5R [ UR 5[5R SSS9S9nU$)a"Get metadata routing of this object. Please check :ref:`User Guide ` on how the routing mechanism works. .. versionadded:: 1.4 Returns ------- routing : MetadataRouter A :class:`~sklearn.utils.metadata_routing.MetadataRouter` encapsulating routing information. )ownerrrE)callercallee)rWmethod_mapping)rrradd_self_requestaddrr/r)rrouters r?get_metadata_routing"LinearModelCV.get_metadata_routingis] !8!8 9  d # S!$''*,22%2P  rAc>[TU]5nUR5nU(+URlX!R lU$r)rrr8rr target_tagsr)rr multitaskrs r?rLinearModelCV.__sklearn_tags__s=w')&&( %.(1% rA)rNr`rqrarrar/rr_rFrr_rr]r`rr0rurrrrrrp)rCr,rTrnrrTNFNFNrr)rrrrrrrrrrrrrrrr4r8rrrrrrrrr s@r?r+r+sMq$y9: Xq$v 6 :|n- . Xq$v 6   :vh' (  $!6(+\9Eh4?@q$v67+m;T"K'( (H!567/$D4   ##@KKMM4456B 0rAr+cz^\rSrSrSr\"\5rSSSSSSS SS S S S S S S .U4SjjrSr Sr SU4Sjjr Sr U=r $)LassoCViaLasso linear model with iterative fitting along a regularization path. See glossary entry for :term:`cross-validation estimator`. The best model is selected by cross-validation. The optimization objective for Lasso is:: (1 / (2 * n_samples)) * ||y - Xw||^2_2 + alpha * ||w||_1 Read more in the :ref:`User Guide `. Parameters ---------- eps : float, default=1e-3 Length of the path. ``eps=1e-3`` means that ``alpha_min / alpha_max = 1e-3``. n_alphas : int, default=100 Number of alphas along the regularization path. .. deprecated:: 1.7 `n_alphas` was deprecated in 1.7 and will be removed in 1.9. Use `alphas` instead. alphas : array-like or int, default=None Values of alphas to test along the regularization path. If int, `alphas` values are generated automatically. If array-like, list of alpha values to use. .. versionchanged:: 1.7 `alphas` accepts an integer value which removes the need to pass `n_alphas`. .. deprecated:: 1.7 `alphas=None` was deprecated in 1.7 and will be removed in 1.9, at which point the default value will be set to 100. 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). precompute : 'auto', bool or array-like of shape (n_features, n_features), default='auto' Whether to use a precomputed Gram matrix to speed up calculations. If set to ``'auto'`` let us decide. The Gram matrix can also be passed as argument. max_iter : int, default=1000 The maximum number of iterations. tol : float, default=1e-4 The tolerance for the optimization: if the updates are smaller than ``tol``, the optimization code checks the dual gap for optimality and continues until it is smaller than ``tol``. copy_X : bool, default=True If ``True``, X will be copied; else, it may be overwritten. 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, - int, to specify the number of folds. - :term:`CV splitter`, - An iterable yielding (train, test) splits as arrays of indices. For int/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. verbose : bool or int, default=False Amount of verbosity. 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. positive : bool, default=False If positive, restrict regression coefficients to be positive. random_state : int, RandomState instance, default=None The seed of the pseudo random number generator that selects a random feature to update. Used when ``selection`` == 'random'. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. selection : {'cyclic', 'random'}, default='cyclic' If set to 'random', a random coefficient is updated every iteration rather than looping over features sequentially by default. This (setting to 'random') often leads to significantly faster convergence especially when tol is higher than 1e-4. Attributes ---------- alpha_ : float The amount of penalization chosen by cross validation. coef_ : ndarray of shape (n_features,) or (n_targets, n_features) Parameter vector (w in the cost function formula). intercept_ : float or ndarray of shape (n_targets,) Independent term in decision function. mse_path_ : ndarray of shape (n_alphas, n_folds) Mean square error for the test set on each fold, varying alpha. alphas_ : ndarray of shape (n_alphas,) The grid of alphas used for fitting. dual_gap_ : float or ndarray of shape (n_targets,) The dual gap at the end of the optimization for the optimal alpha (``alpha_``). n_iter_ : int Number of iterations run by the coordinate descent solver to reach the specified tolerance for the optimal alpha. 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 -------- lars_path : Compute Least Angle Regression or Lasso path using LARS algorithm. lasso_path : Compute Lasso path with coordinate descent. Lasso : The Lasso is a linear model that estimates sparse coefficients. LassoLars : Lasso model fit with Least Angle Regression a.k.a. Lars. LassoCV : Lasso linear model with iterative fitting along a regularization path. LassoLarsCV : Cross-validated Lasso using the LARS algorithm. Notes ----- In `fit`, once the best parameter `alpha` is found through cross-validation, the model is fit again using the entire training set. To avoid unnecessary memory duplication the `X` argument of the `fit` method should be directly passed as a Fortran-contiguous numpy array. For an example, see :ref:`examples/linear_model/plot_lasso_model_selection.py `. :class:`LassoCV` leads to different results than a hyperparameter search using :class:`~sklearn.model_selection.GridSearchCV` with a :class:`Lasso` model. In :class:`LassoCV`, a model for a given penalty `alpha` is warm started using the coefficients of the closest model (trained at the previous iteration) on the regularization path. It tends to speed up the hyperparameter search. Examples -------- >>> from sklearn.linear_model import LassoCV >>> from sklearn.datasets import make_regression >>> X, y = make_regression(noise=4, random_state=0) >>> reg = LassoCV(cv=5, random_state=0).fit(X, y) >>> reg.score(X, y) 0.9993 >>> reg.predict(X[:1,]) array([-78.4951]) rCr,rTrnrrNFrr.c:>[TU]UUUUUUUUU U U U U US9 g)Nr.r )rr_r`rqrFrrrrrar/rpr0rurrrs r?rLassoCV.__init__@sA$ '!%  rAc[5$r)r rs r?r4LassoCV._get_estimatorcs wrAcgNFrrs r?r8LassoCV._is_multitaskfrAc *>[TU]"X4SU0UD6$)aFit Lasso model with coordinate descent. Fit is on grid of alphas and best alpha estimated by cross-validation. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Training data. Pass directly as Fortran-contiguous data to avoid unnecessary memory duplication. If y is mono-output, X can be sparse. Note that large sparse matrices and arrays requiring `int64` indices are not accepted. y : array-like of shape (n_samples,) Target values. sample_weight : float or array-like of shape (n_samples,), default=None Sample weights used for fitting and evaluation of the weighted mean squared error of each cv-fold. Note that the cross validated MSE that is finally used to find the best model is the unweighted mean over the (weighted) MSEs of each test fold. **params : dict, default=None Parameters to be passed to the CV splitter. .. versionadded:: 1.4 Only available if `enable_metadata_routing=True`, which can be set by using ``sklearn.set_config(enable_metadata_routing=True)``. See :ref:`Metadata Routing User Guide ` for more details. Returns ------- self : object Returns an instance of fitted model. rGrrrr:r;rGrzrs r?r LassoCV.fitiLw{1G}GGGrArr)rrrrrrr{rrr4r8rrrr s@r?rrscrh  #D   !! ! F&H&HrArc^\rSrSr%Sr0\R ES\"\SSSS9S/0Er\ \ S '\ "\ 5r S S S S SSSSSSSSSSSS.SjrSrSrSU4SjjrSrU=r$) ElasticNetCViaElastic Net model with iterative fitting along a regularization path. See glossary entry for :term:`cross-validation estimator`. Read more in the :ref:`User Guide `. Parameters ---------- l1_ratio : float or list of float, default=0.5 Float between 0 and 1 passed to ElasticNet (scaling between l1 and l2 penalties). For ``l1_ratio = 0`` the penalty is an L2 penalty. For ``l1_ratio = 1`` it is an L1 penalty. For ``0 < l1_ratio < 1``, the penalty is a combination of L1 and L2 This parameter can be a list, in which case the different values are tested by cross-validation and the one giving the best prediction score is used. Note that a good choice of list of values for l1_ratio is often to put more values close to 1 (i.e. Lasso) and less close to 0 (i.e. Ridge), as in ``[.1, .5, .7, .9, .95, .99, 1]``. eps : float, default=1e-3 Length of the path. ``eps=1e-3`` means that ``alpha_min / alpha_max = 1e-3``. n_alphas : int, default=100 Number of alphas along the regularization path, used for each l1_ratio. .. deprecated:: 1.7 `n_alphas` was deprecated in 1.7 and will be removed in 1.9. Use `alphas` instead. alphas : array-like or int, default=None Values of alphas to test along the regularization path, used for each l1_ratio. If int, `alphas` values are generated automatically. If array-like, list of alpha values to use. .. versionchanged:: 1.7 `alphas` accepts an integer value which removes the need to pass `n_alphas`. .. deprecated:: 1.7 `alphas=None` was deprecated in 1.7 and will be removed in 1.9, at which point the default value will be set to 100. 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). precompute : 'auto', bool or array-like of shape (n_features, n_features), default='auto' Whether to use a precomputed Gram matrix to speed up calculations. If set to ``'auto'`` let us decide. The Gram matrix can also be passed as argument. max_iter : int, default=1000 The maximum number of iterations. tol : float, default=1e-4 The tolerance for the optimization: if the updates are smaller than ``tol``, the optimization code checks the dual gap for optimality and continues until it is smaller than ``tol``. 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, - int, to specify the number of folds. - :term:`CV splitter`, - An iterable yielding (train, test) splits as arrays of indices. For int/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. copy_X : bool, default=True If ``True``, X will be copied; else, it may be overwritten. verbose : bool or int, default=0 Amount of verbosity. 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. positive : bool, default=False When set to ``True``, forces the coefficients to be positive. random_state : int, RandomState instance, default=None The seed of the pseudo random number generator that selects a random feature to update. Used when ``selection`` == 'random'. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. selection : {'cyclic', 'random'}, default='cyclic' If set to 'random', a random coefficient is updated every iteration rather than looping over features sequentially by default. This (setting to 'random') often leads to significantly faster convergence especially when tol is higher than 1e-4. Attributes ---------- alpha_ : float The amount of penalization chosen by cross validation. l1_ratio_ : float The compromise between l1 and l2 penalization chosen by cross validation. coef_ : ndarray of shape (n_features,) or (n_targets, n_features) Parameter vector (w in the cost function formula). intercept_ : float or ndarray of shape (n_targets, n_features) Independent term in the decision function. mse_path_ : ndarray of shape (n_l1_ratio, n_alpha, n_folds) Mean square error for the test set on each fold, varying l1_ratio and alpha. alphas_ : ndarray of shape (n_alphas,) or (n_l1_ratio, n_alphas) The grid of alphas used for fitting, for each l1_ratio. dual_gap_ : float The dual gaps at the end of the optimization for the optimal alpha. n_iter_ : int Number of iterations run by the coordinate descent solver to reach the specified tolerance for the optimal alpha. 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 -------- enet_path : Compute elastic net path with coordinate descent. ElasticNet : Linear regression with combined L1 and L2 priors as regularizer. Notes ----- In `fit`, once the best parameters `l1_ratio` and `alpha` are found through cross-validation, the model is fit again using the entire training set. To avoid unnecessary memory duplication the `X` argument of the `fit` method should be directly passed as a Fortran-contiguous numpy array. The parameter `l1_ratio` corresponds to alpha in the glmnet R package while alpha corresponds to the lambda parameter in glmnet. More specifically, the optimization objective is:: 1 / (2 * n_samples) * ||y - Xw||^2_2 + alpha * l1_ratio * ||w||_1 + 0.5 * alpha * (1 - l1_ratio) * ||w||^2_2 If you are interested in controlling the L1 and L2 penalty separately, keep in mind that this is equivalent to:: a * L1 + b * L2 for:: alpha = a + b and l1_ratio = a / (a + b). For an example, see :ref:`examples/linear_model/plot_lasso_model_selection.py `. Examples -------- >>> from sklearn.linear_model import ElasticNetCV >>> from sklearn.datasets import make_regression >>> X, y = make_regression(n_features=2, random_state=0) >>> regr = ElasticNetCV(cv=5, random_state=0) >>> regr.fit(X, y) ElasticNetCV(cv=5, random_state=0) >>> print(regr.alpha_) 0.199 >>> print(regr.intercept_) 0.398 >>> print(regr.predict([[0, 0]])) [0.398] r^rr'r}rkrirr~rCr,rTrnrrNFrr^r_r`rqrFrrrrr/rarpr0rurrcXlX lX0lX@lXPlX`lXplXlXlXl Xl Xl Xl Xl Xlgrr)rr^r_r`rqrFrrrrr/rarpr0rurrs r?rElasticNetCV.__init__a sQ&!   *$     ("rAc[5$r)rrs r?r4ElasticNetCV._get_estimator s |rAcgrrrs r?r8ElasticNetCV._is_multitask rrAc *>[TU]"X4SU0UD6$)aFit ElasticNet model with coordinate descent. Fit is on grid of alphas and best alpha estimated by cross-validation. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Training data. Pass directly as Fortran-contiguous data to avoid unnecessary memory duplication. If y is mono-output, X can be sparse. Note that large sparse matrices and arrays requiring `int64` indices are not accepted. y : array-like of shape (n_samples,) Target values. sample_weight : float or array-like of shape (n_samples,), default=None Sample weights used for fitting and evaluation of the weighted mean squared error of each cv-fold. Note that the cross validated MSE that is finally used to find the best model is the unweighted mean over the (weighted) MSEs of each test fold. **params : dict, default=None Parameters to be passed to the CV splitter. .. versionadded:: 1.4 Only available if `enable_metadata_routing=True`, which can be set by using ``sklearn.set_config(enable_metadata_routing=True)``. See :ref:`Metadata Routing User Guide ` for more details. Returns ------- self : object Returns an instance of fitted model. rGrrs r?rElasticNetCV.fit rrA)rqrar/r_rFr^rr`r0rurrrrrrpr)rrrrrr+rrrrrrryrrr4r8rrrr s@r?rrsEN$  . .$XdAq8,G$D  "D    #!#F&H&HrArc ^\rSrSr%Sr0\R Er\\S'SHr \R\ 5 M SSSSSSS S S S .S jjr \ "SS9S5r U4SjrSrU=r$)MultiTaskElasticNeti aMulti-task ElasticNet model trained with L1/L2 mixed-norm as regularizer. The optimization objective for MultiTaskElasticNet is:: (1 / (2 * n_samples)) * ||Y - XW||_Fro^2 + alpha * l1_ratio * ||W||_21 + 0.5 * alpha * (1 - l1_ratio) * ||W||_Fro^2 Where:: ||W||_21 = sum_i sqrt(sum_j W_ij ^ 2) i.e. the sum of norms of each row. Read more in the :ref:`User Guide `. Parameters ---------- alpha : float, default=1.0 Constant that multiplies the L1/L2 term. Defaults to 1.0. l1_ratio : float, default=0.5 The ElasticNet mixing parameter, with 0 < l1_ratio <= 1. For l1_ratio = 1 the penalty is an L1/L2 penalty. For l1_ratio = 0 it is an L2 penalty. For ``0 < l1_ratio < 1``, the penalty is a combination of L1/L2 and L2. 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). copy_X : bool, default=True If ``True``, X will be copied; else, it may be overwritten. max_iter : int, default=1000 The maximum number of iterations. tol : float, default=1e-4 The tolerance for the optimization: if the updates are smaller than ``tol``, the optimization code checks the dual gap for optimality and continues until it is smaller than ``tol``. warm_start : bool, default=False When set to ``True``, reuse the solution of the previous call to fit as initialization, otherwise, just erase the previous solution. See :term:`the Glossary `. random_state : int, RandomState instance, default=None The seed of the pseudo random number generator that selects a random feature to update. Used when ``selection`` == 'random'. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. selection : {'cyclic', 'random'}, default='cyclic' If set to 'random', a random coefficient is updated every iteration rather than looping over features sequentially by default. This (setting to 'random') often leads to significantly faster convergence especially when tol is higher than 1e-4. Attributes ---------- intercept_ : ndarray of shape (n_targets,) Independent term in decision function. coef_ : ndarray of shape (n_targets, n_features) Parameter vector (W in the cost function formula). If a 1D y is passed in at fit (non multi-task usage), ``coef_`` is then a 1D array. Note that ``coef_`` stores the transpose of ``W``, ``W.T``. n_iter_ : int Number of iterations run by the coordinate descent solver to reach the specified tolerance. dual_gap_ : float The dual gaps at the end of the optimization. eps_ : float The tolerance scaled scaled by the variance of the target `y`. sparse_coef_ : sparse matrix of shape (n_features,) or (n_targets, n_features) Sparse representation of the `coef_`. 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 -------- MultiTaskElasticNetCV : Multi-task L1/L2 ElasticNet with built-in cross-validation. ElasticNet : Linear regression with combined L1 and L2 priors as regularizer. MultiTaskLasso : Multi-task Lasso model trained with L1/L2 mixed-norm as regularizer. Notes ----- The algorithm used to fit the model is coordinate descent. To avoid unnecessary memory duplication the X and y arguments of the fit method should be directly passed as Fortran-contiguous numpy arrays. Examples -------- >>> from sklearn import linear_model >>> clf = linear_model.MultiTaskElasticNet(alpha=0.1) >>> clf.fit([[0,0], [1, 1], [2, 2]], [[0, 0], [1, 1], [2, 2]]) MultiTaskElasticNet(alpha=0.1) >>> print(clf.coef_) [[0.45663524 0.45612256] [0.45663524 0.45612256]] >>> print(clf.intercept_) [0.0872422 0.0872422] r)rrrur~TrrFNr)r^rFrarrrrrcpX lXlX0lXPlX@lX`lXplXlXlgr) r^rrFrrarrrr) rrr^rFrarrrrrs r?rMultiTaskElasticNet.__init__: s3!  *  $("rArvc [[R[R/SSUR=(a UR S9n[SSS9n[ XX#U4S9up[X5 URUR5n[US5(aSnOS nURS :Xa[S U-5eURupgURS n[XUR SS 9uppn UR(a[US 5(d0[R "X4URR"SS9UlUR&UR(-U-n UR&SUR(- -U-n [R*"UR$5UlUR,S:Hn[.R0"UR$U U UUUR2UR4[7UR85U5 uUlUlUlUlU=R:U-slURAXU 5 U$)aIFit MultiTaskElasticNet model with coordinate descent. Parameters ---------- X : ndarray of shape (n_samples, n_features) Data. y : ndarray of shape (n_samples, n_targets) Target. Will be cast to X's dtype if necessary. Returns ------- self : object Fitted estimator. Notes ----- Coordinate descent is an algorithm that considers each column of data at a time hence it will automatically convert the X input as a Fortran-contiguous numpy array if necessary. To avoid memory re-allocation it is advised to allocate the initial data in memory directly using that format. r.T)rr3rr1F)rr3r>r^rr r'zFor mono-task outputs, use %s)rFr1rrrBr)!rr8rYrrarFr&r!astyperrrOr4rUr+rrrrrr^rrrrrrr#rrrrr)rr:r;rgre model_strrfrrrcrrrrrs r?rMultiTaskElasticNet.fitQ s6::rzz* 3!3!3   S9 Q^,L  % HHQWW  4 $ $$II 66Q;[TU]5nSURlSURlSURlU$)NFT)rrrr rr single_outputrs r?r$MultiTaskElasticNet.__sklearn_tags__ s=w')!&(,%).& rA) rrrarrrFr^rrrrrrr)rrrrrrrrrparamrrrrrrrr s@r?rr szx$  + +$D,""5), # #.5X6XtrArc \rSrSr%Sr0\R Er\\S'\RS5 SSSSSSS S S .S jjr S r g )MultiTaskLassoi aOMulti-task Lasso model trained with L1/L2 mixed-norm as regularizer. The optimization objective for Lasso is:: (1 / (2 * n_samples)) * ||Y - XW||^2_Fro + alpha * ||W||_21 Where:: ||W||_21 = \sum_i \sqrt{\sum_j w_{ij}^2} i.e. the sum of norm of each row. Read more in the :ref:`User Guide `. Parameters ---------- alpha : float, default=1.0 Constant that multiplies the L1/L2 term. Defaults to 1.0. 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). copy_X : bool, default=True If ``True``, X will be copied; else, it may be overwritten. max_iter : int, default=1000 The maximum number of iterations. tol : float, default=1e-4 The tolerance for the optimization: if the updates are smaller than ``tol``, the optimization code checks the dual gap for optimality and continues until it is smaller than ``tol``. warm_start : bool, default=False When set to ``True``, reuse the solution of the previous call to fit as initialization, otherwise, just erase the previous solution. See :term:`the Glossary `. random_state : int, RandomState instance, default=None The seed of the pseudo random number generator that selects a random feature to update. Used when ``selection`` == 'random'. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. selection : {'cyclic', 'random'}, default='cyclic' If set to 'random', a random coefficient is updated every iteration rather than looping over features sequentially by default. This (setting to 'random') often leads to significantly faster convergence especially when tol is higher than 1e-4. Attributes ---------- coef_ : ndarray of shape (n_targets, n_features) Parameter vector (W in the cost function formula). Note that ``coef_`` stores the transpose of ``W``, ``W.T``. intercept_ : ndarray of shape (n_targets,) Independent term in decision function. n_iter_ : int Number of iterations run by the coordinate descent solver to reach the specified tolerance. dual_gap_ : ndarray of shape (n_alphas,) The dual gaps at the end of the optimization for each alpha. eps_ : float The tolerance scaled scaled by the variance of the target `y`. sparse_coef_ : sparse matrix of shape (n_features,) or (n_targets, n_features) Sparse representation of the `coef_`. 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 -------- Lasso: Linear Model trained with L1 prior as regularizer (aka the Lasso). MultiTaskLassoCV: Multi-task L1 regularized linear model with built-in cross-validation. MultiTaskElasticNetCV: Multi-task L1/L2 ElasticNet with built-in cross-validation. Notes ----- The algorithm used to fit the model is coordinate descent. To avoid unnecessary memory duplication the X and y arguments of the fit method should be directly passed as Fortran-contiguous numpy arrays. Examples -------- >>> from sklearn import linear_model >>> clf = linear_model.MultiTaskLasso(alpha=0.1) >>> clf.fit([[0, 1], [1, 2], [2, 4]], [[0, 0], [1, 1], [2, 3]]) MultiTaskLasso(alpha=0.1) >>> print(clf.coef_) [[0. 0.60809415] [0. 0.94592424]] >>> print(clf.intercept_) [-0.41888636 -0.87382323] rr^TrrFNr)rFrarrrrrcrXlX lX@lX0lXPlX`lSUlXplXlg)NrB) rrFrrarrr^rr) rrrFrarrrrrs r?rMultiTaskLasso.__init__, s5 *  $ ("rA) rrarFr^rrrrrr) rrrrrrrrrrrrrrAr?rr sapd$  4 4$Dz*# ##rArc^\rSrSr%Sr0\R ES\"\SSSS9S/0Er\ \ S '\RS 5 \RS 5 \ "\ 5rS S SSSSSSSSSSSS. SjrSrSrU4SjrU4SjrSrU=r$)MultiTaskElasticNetCViC aMulti-task L1/L2 ElasticNet with built-in cross-validation. See glossary entry for :term:`cross-validation estimator`. The optimization objective for MultiTaskElasticNet is:: (1 / (2 * n_samples)) * ||Y - XW||^Fro_2 + alpha * l1_ratio * ||W||_21 + 0.5 * alpha * (1 - l1_ratio) * ||W||_Fro^2 Where:: ||W||_21 = \sum_i \sqrt{\sum_j w_{ij}^2} i.e. the sum of norm of each row. Read more in the :ref:`User Guide `. .. versionadded:: 0.15 Parameters ---------- l1_ratio : float or list of float, default=0.5 The ElasticNet mixing parameter, with 0 < l1_ratio <= 1. For l1_ratio = 1 the penalty is an L1/L2 penalty. For l1_ratio = 0 it is an L2 penalty. For ``0 < l1_ratio < 1``, the penalty is a combination of L1/L2 and L2. This parameter can be a list, in which case the different values are tested by cross-validation and the one giving the best prediction score is used. Note that a good choice of list of values for l1_ratio is often to put more values close to 1 (i.e. Lasso) and less close to 0 (i.e. Ridge), as in ``[.1, .5, .7, .9, .95, .99, 1]``. eps : float, default=1e-3 Length of the path. ``eps=1e-3`` means that ``alpha_min / alpha_max = 1e-3``. n_alphas : int, default=100 Number of alphas along the regularization path. .. deprecated:: 1.7 `n_alphas` was deprecated in 1.7 and will be removed in 1.9. Use `alphas` instead. alphas : array-like or int, default=None Values of alphas to test along the regularization path, used for each l1_ratio. If int, `alphas` values are generated automatically. If array-like, list of alpha values to use. .. versionchanged:: 1.7 `alphas` accepts an integer value which removes the need to pass `n_alphas`. .. deprecated:: 1.7 `alphas=None` was deprecated in 1.7 and will be removed in 1.9, at which point the default value will be set to 100. 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). max_iter : int, default=1000 The maximum number of iterations. tol : float, default=1e-4 The tolerance for the optimization: if the updates are smaller than ``tol``, the optimization code checks the dual gap for optimality and continues until it is smaller than ``tol``. 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, - int, to specify the number of folds. - :term:`CV splitter`, - An iterable yielding (train, test) splits as arrays of indices. For int/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. copy_X : bool, default=True If ``True``, X will be copied; else, it may be overwritten. verbose : bool or int, default=0 Amount of verbosity. n_jobs : int, default=None Number of CPUs to use during the cross validation. Note that this is used only if multiple values for l1_ratio are given. ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context. ``-1`` means using all processors. See :term:`Glossary ` for more details. random_state : int, RandomState instance, default=None The seed of the pseudo random number generator that selects a random feature to update. Used when ``selection`` == 'random'. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. selection : {'cyclic', 'random'}, default='cyclic' If set to 'random', a random coefficient is updated every iteration rather than looping over features sequentially by default. This (setting to 'random') often leads to significantly faster convergence especially when tol is higher than 1e-4. Attributes ---------- intercept_ : ndarray of shape (n_targets,) Independent term in decision function. coef_ : ndarray of shape (n_targets, n_features) Parameter vector (W in the cost function formula). Note that ``coef_`` stores the transpose of ``W``, ``W.T``. alpha_ : float The amount of penalization chosen by cross validation. mse_path_ : ndarray of shape (n_alphas, n_folds) or (n_l1_ratio, n_alphas, n_folds) Mean square error for the test set on each fold, varying alpha. alphas_ : ndarray of shape (n_alphas,) or (n_l1_ratio, n_alphas) The grid of alphas used for fitting, for each l1_ratio. l1_ratio_ : float Best l1_ratio obtained by cross-validation. n_iter_ : int Number of iterations run by the coordinate descent solver to reach the specified tolerance for the optimal alpha. dual_gap_ : float The dual gap at the end of the optimization for the optimal alpha. 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 -------- MultiTaskElasticNet : Multi-task L1/L2 ElasticNet with built-in cross-validation. ElasticNetCV : Elastic net model with best model selection by cross-validation. MultiTaskLassoCV : Multi-task Lasso model trained with L1 norm as regularizer and built-in cross-validation. Notes ----- The algorithm used to fit the model is coordinate descent. In `fit`, once the best parameters `l1_ratio` and `alpha` are found through cross-validation, the model is fit again using the entire training set. To avoid unnecessary memory duplication the `X` and `y` arguments of the `fit` method should be directly passed as Fortran-contiguous numpy arrays. Examples -------- >>> from sklearn import linear_model >>> clf = linear_model.MultiTaskElasticNetCV(cv=3) >>> clf.fit([[0,0], [1, 1], [2, 2]], ... [[0, 0], [1, 1], [2, 2]]) MultiTaskElasticNetCV(cv=3) >>> print(clf.coef_) [[0.52875032 0.46958558] [0.52875032 0.46958558]] >>> print(clf.intercept_) [0.00166409 0.00166409] r^rr'r}rkrirrrrur~rCr,rTrrNr r^r_r`rqrFrrr/rarpr0rrc XlX lX0lX@lXPlX`lXplXlXlXl Xl Xl Xl grr)rr^r_r`rqrFrrr/rarpr0rrs r?rMultiTaskElasticNetCV.__init__ sG"!   *    ("rAc[5$r)rrs r?r4$MultiTaskElasticNetCV._get_estimator& s "$$rAcgrrrs r?r8#MultiTaskElasticNetCV._is_multitask) rAcF>[TU]5nSURlU$rrrrrrs r?r&MultiTaskElasticNetCV.__sklearn_tags__, #w')).& rAc &>[TU]"X40UD6$)aFit MultiTaskElasticNet model with coordinate descent. Fit is on grid of alphas and best alpha estimated by cross-validation. Parameters ---------- X : ndarray of shape (n_samples, n_features) Training data. y : ndarray of shape (n_samples, n_targets) Training target variable. Will be cast to X's dtype if necessary. **params : dict, default=None Parameters to be passed to the CV splitter. .. versionadded:: 1.4 Only available if `enable_metadata_routing=True`, which can be set by using ``sklearn.set_config(enable_metadata_routing=True)``. See :ref:`Metadata Routing User Guide ` for more details. Returns ------- self : object Returns MultiTaskElasticNet instance. rrr:r;rzrs r?rMultiTaskElasticNetCV.fit3 6w{1*6**rA) rqrar/r_rFr^rr`r0rrrrp)rrrrrr+rrrrrrrryrrr4r8rrrrr s@r?rrC sxt$  . .$XdAq8,G$D|,z*  "D    #>%++rArc ^\rSrSr%Sr0\R Er\\S'\RS5 \RS5 \ "\ 5r SSSS S S S S S S S SS. U4Sjjr SrSrU4SjrU4SjrSrU=r$)MultiTaskLassoCViQ aMulti-task Lasso model trained with L1/L2 mixed-norm as regularizer. See glossary entry for :term:`cross-validation estimator`. The optimization objective for MultiTaskLasso is:: (1 / (2 * n_samples)) * ||Y - XW||^Fro_2 + alpha * ||W||_21 Where:: ||W||_21 = \sum_i \sqrt{\sum_j w_{ij}^2} i.e. the sum of norm of each row. Read more in the :ref:`User Guide `. .. versionadded:: 0.15 Parameters ---------- eps : float, default=1e-3 Length of the path. ``eps=1e-3`` means that ``alpha_min / alpha_max = 1e-3``. n_alphas : int, default=100 Number of alphas along the regularization path. .. deprecated:: 1.7 `n_alphas` was deprecated in 1.7 and will be removed in 1.9. Use `alphas` instead. alphas : array-like or int, default=None Values of alphas to test along the regularization path. If int, `alphas` values are generated automatically. If array-like, list of alpha values to use. .. versionchanged:: 1.7 `alphas` accepts an integer value which removes the need to pass `n_alphas`. .. deprecated:: 1.7 `alphas=None` was deprecated in 1.7 and will be removed in 1.9, at which point the default value will be set to 100. 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). max_iter : int, default=1000 The maximum number of iterations. tol : float, default=1e-4 The tolerance for the optimization: if the updates are smaller than ``tol``, the optimization code checks the dual gap for optimality and continues until it is smaller than ``tol``. copy_X : bool, default=True If ``True``, X will be copied; else, it may be overwritten. 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, - int, to specify the number of folds. - :term:`CV splitter`, - An iterable yielding (train, test) splits as arrays of indices. For int/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. verbose : bool or int, default=False Amount of verbosity. n_jobs : int, default=None Number of CPUs to use during the cross validation. Note that this is used only if multiple values for l1_ratio are given. ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context. ``-1`` means using all processors. See :term:`Glossary ` for more details. random_state : int, RandomState instance, default=None The seed of the pseudo random number generator that selects a random feature to update. Used when ``selection`` == 'random'. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. selection : {'cyclic', 'random'}, default='cyclic' If set to 'random', a random coefficient is updated every iteration rather than looping over features sequentially by default. This (setting to 'random') often leads to significantly faster convergence especially when tol is higher than 1e-4. Attributes ---------- intercept_ : ndarray of shape (n_targets,) Independent term in decision function. coef_ : ndarray of shape (n_targets, n_features) Parameter vector (W in the cost function formula). Note that ``coef_`` stores the transpose of ``W``, ``W.T``. alpha_ : float The amount of penalization chosen by cross validation. mse_path_ : ndarray of shape (n_alphas, n_folds) Mean square error for the test set on each fold, varying alpha. alphas_ : ndarray of shape (n_alphas,) The grid of alphas used for fitting. n_iter_ : int Number of iterations run by the coordinate descent solver to reach the specified tolerance for the optimal alpha. dual_gap_ : float The dual gap at the end of the optimization for the optimal alpha. 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 -------- MultiTaskElasticNet : Multi-task ElasticNet model trained with L1/L2 mixed-norm as regularizer. ElasticNetCV : Elastic net model with best model selection by cross-validation. MultiTaskElasticNetCV : Multi-task L1/L2 ElasticNet with built-in cross-validation. Notes ----- The algorithm used to fit the model is coordinate descent. In `fit`, once the best parameter `alpha` is found through cross-validation, the model is fit again using the entire training set. To avoid unnecessary memory duplication the `X` and `y` arguments of the `fit` method should be directly passed as Fortran-contiguous numpy arrays. Examples -------- >>> from sklearn.linear_model import MultiTaskLassoCV >>> from sklearn.datasets import make_regression >>> from sklearn.metrics import r2_score >>> X, y = make_regression(n_targets=2, noise=4, random_state=0) >>> reg = MultiTaskLassoCV(cv=5, random_state=0).fit(X, y) >>> r2_score(y, reg.predict(X)) 0.9994 >>> reg.alpha_ np.float64(0.5713) >>> reg.predict(X[:1,]) array([[153.7971, 94.9015]]) rrrrurCr,rTrrNFr r_r`rqrFrrrar/rpr0rrc 6>[T U]UUUUUUUUU U U U S9 g)Nrr )rr_r`rqrFrrrar/rpr0rrrs r?rMultiTaskLassoCV.__init__ s; '%  rAc[5$r)rrs r?r4MultiTaskLassoCV._get_estimator# s rAcgrrrs r?r8MultiTaskLassoCV._is_multitask& rrAcF>[TU]5nSURlU$rrrs r?r!MultiTaskLassoCV.__sklearn_tags__) rrAc &>[TU]"X40UD6$)aFit MultiTaskLasso model with coordinate descent. Fit is on grid of alphas and best alpha estimated by cross-validation. Parameters ---------- X : ndarray of shape (n_samples, n_features) Data. y : ndarray of shape (n_samples, n_targets) Target. Will be cast to X's dtype if necessary. **params : dict, default=None Parameters to be passed to the CV splitter. .. versionadded:: 1.4 Only available if `enable_metadata_routing=True`, which can be set by using ``sklearn.set_config(enable_metadata_routing=True)``. See :ref:`Metadata Routing User Guide ` for more details. Returns ------- self : object Returns an instance of fitted model. rrs r?rMultiTaskLassoCV.fit0 rrAr)rrrrrr+rrrrrr{rrr4r8rrrrr s@r?rrQ shT$  . .$D|,z*  #D     > ++rAr)r-)NrBTrCrDTN)Nr'NN)Krrrabcrr functoolsrrrnumpyr8joblibrscipyr sklearn.utilsr rr r rmodel_selectionrutilsrrrutils._metadata_requestsrrrrutils._param_validationrrrr utils.extmathrutils.metadata_routingrrutils.parallelrrutils.validationr r!r"r#r$r%r&r(r_baser)r*r+r@rhr{ryrr r)r+rrrrrrrrAr?rs #"#*AA&44 TS+/"::(d   XBvO ,O ,q$y9:h4?@&!6(+Y ET"+"D);#K #'*     k#"k\O ,O ,dCV<=sD;<h4?@&!6(+Y ET"+"D);#K!{ #'#.     D$'&D$V p!>;pn y Jy R    K!\j$k3jZ FHnmFHR^H>=^HJ z%zzL#(L#^K+NMK+\z+~}z+rA