-iDSrSSKrSSKrSSKJr SSKJrJr SSKr SSK J r J r SSK Jr SSKJrJrJr SS KJr SS KJr SS KJrJrJrJr SS KJrJrJrJ r J!r! SS K"J#r#J$r$J%r%J&r& SSK'J(r(J)r) SSK*J+r+ SSK,J-r-J.r.J/r/ SS0r0\&"\ RbS/\ RbS/\ RbS/\%"S15S\ RbS/\$"\SSSS9/\$"\SSSS9/\%"SS15/S/\$"\SSSS9S/S/S/S/S/S/S.SS9S2SSSSS\ Rd"\35RhSSSSSS . S!jj5r5\&"\ Rb/\ Rb/\$"\SSSS9/\$"\SSSS9/\$"\SSSS9/\%"SS15/S/\$"\SSSS9S/S/S/S/S/S/S". SS9SSSS\ Rd"\35RhSSSSSS#. S$j5r6SSSSSSS\ Rd"\35RhSSSSS4 S%jr7"S&S'\\\-5r8"S(S)\85r9S3S*jr:SSSSSS\ Rd"\35RhS4S+jr;"S,S-\85r<"S.S/\<5r="S0S1\95r>g)4zt Least Angle Regression algorithm. See the documentation on the Generalized Linear Model for a complete discussion. N)log)IntegralReal) interpolatelinalg)get_lapack_funcs)MultiOutputMixinRegressorMixin _fit_context)ConvergenceWarning)check_cv)Bunch arrayfuncsas_float_arraycheck_random_state)MetadataRouter MethodMapping_raise_for_params_routing_enabledprocess_routing)HiddenInterval StrOptionsvalidate_params)Paralleldelayed) validate_data) LinearModelLinearRegression_preprocess_data check_finiteFautobooleanleftclosedlarlassoneitherverboseXyXyGrammax_iter alpha_minmethodcopy_Xeps copy_Gramr, return_path return_n_iterpositiveTprefer_skip_nested_validation) r1r2r3r4r5r6r7r,r8r9r:c RUcUb [S5e[UUUUSUUUUUU U U U U S9$)aCompute Least Angle Regression or Lasso path using the LARS algorithm. The optimization objective for the case method='lasso' is:: (1 / (2 * n_samples)) * ||y - Xw||^2_2 + alpha * ||w||_1 in the case of method='lar', the objective function is only known in the form of an implicit equation (see discussion in [1]_). Read more in the :ref:`User Guide `. Parameters ---------- X : None or ndarray of shape (n_samples, n_features) Input data. If X is `None`, Gram must also be `None`. If only the Gram matrix is available, use `lars_path_gram` instead. y : None or ndarray of shape (n_samples,) Input targets. Xy : array-like of shape (n_features,), default=None `Xy = X.T @ y` that can be precomputed. It is useful only when the Gram matrix is precomputed. Gram : None, 'auto', bool, ndarray of shape (n_features, n_features), default=None Precomputed Gram matrix `X.T @ X`, if `'auto'`, the Gram matrix is precomputed from the given X, if there are more samples than features. max_iter : int, default=500 Maximum number of iterations to perform, set to infinity for no limit. alpha_min : float, default=0 Minimum correlation along the path. It corresponds to the regularization parameter `alpha` in the Lasso. method : {'lar', 'lasso'}, default='lar' Specifies the returned model. Select `'lar'` for Least Angle Regression, `'lasso'` for the Lasso. copy_X : bool, default=True If `False`, `X` is overwritten. eps : float, default=np.finfo(float).eps The machine-precision regularization in the computation of the Cholesky diagonal factors. Increase this for very ill-conditioned systems. Unlike the `tol` parameter in some iterative optimization-based algorithms, this parameter does not control the tolerance of the optimization. copy_Gram : bool, default=True If `False`, `Gram` is overwritten. verbose : int, default=0 Controls output verbosity. return_path : bool, default=True If `True`, returns the entire path, else returns only the last point of the path. return_n_iter : bool, default=False Whether to return the number of iterations. positive : bool, default=False Restrict coefficients to be >= 0. This option is only allowed with method 'lasso'. Note that the model coefficients will not converge to the ordinary-least-squares solution for small values of alpha. Only coefficients up to the smallest alpha value (`alphas_[alphas_ > 0.].min()` when fit_path=True) reached by the stepwise Lars-Lasso algorithm are typically in congruence with the solution of the coordinate descent `lasso_path` function. Returns ------- alphas : ndarray of shape (n_alphas + 1,) Maximum of covariances (in absolute value) at each iteration. `n_alphas` is either `max_iter`, `n_features`, or the number of nodes in the path with `alpha >= alpha_min`, whichever is smaller. active : ndarray of shape (n_alphas,) Indices of active variables at the end of the path. coefs : ndarray of shape (n_features, n_alphas + 1) Coefficients along the path. n_iter : int Number of iterations run. Returned only if `return_n_iter` is set to True. See Also -------- lars_path_gram : Compute LARS path in the sufficient stats mode. lasso_path : Compute Lasso path with coordinate descent. LassoLars : Lasso model fit with Least Angle Regression a.k.a. Lars. Lars : Least Angle Regression model a.k.a. LAR. LassoLarsCV : Cross-validated Lasso, using the LARS algorithm. LarsCV : Cross-validated Least Angle Regression model. sklearn.decomposition.sparse_encode : Sparse coding. References ---------- .. [1] "Least Angle Regression", Efron et al. http://statweb.stanford.edu/~tibs/ftp/lars.pdf .. [2] `Wikipedia entry on the Least-angle regression `_ .. [3] `Wikipedia entry on the Lasso `_ Examples -------- >>> from sklearn.linear_model import lars_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 = lars_path(X, y) >>> alphas.shape (3,) >>> estimated_coef array([[ 0. , 0. , 0. ], [ 0. , 0. , 0. ], [ 0. , 0. , 0. ], [ 0. , 46.96, 97.99], [ 0. , 0. , 45.70]]) NzPX cannot be None if Gram is not NoneUse lars_path_gram to avoid passing X and y.r.r/r0r1 n_samplesr2r3r4r5r6r7r,r8r9r:) ValueError_lars_path_solverr-s T/var/www/html/venv/lib/python3.13/site-packages/sklearn/linear_model/_least_angle.py lars_pathrD,s]N yT% ;     #  r0r1r@r2r3r4r5r6r7r,r8r9r:) r2r3r4r5r6r7r,r8r9r:c 0[SSUUUUUUUUUU U U U S9$)aThe lars_path in the sufficient stats mode. The optimization objective for the case method='lasso' is:: (1 / (2 * n_samples)) * ||y - Xw||^2_2 + alpha * ||w||_1 in the case of method='lar', the objective function is only known in the form of an implicit equation (see discussion in [1]_). Read more in the :ref:`User Guide `. Parameters ---------- Xy : ndarray of shape (n_features,) `Xy = X.T @ y`. Gram : ndarray of shape (n_features, n_features) `Gram = X.T @ X`. n_samples : int Equivalent size of sample. max_iter : int, default=500 Maximum number of iterations to perform, set to infinity for no limit. alpha_min : float, default=0 Minimum correlation along the path. It corresponds to the regularization parameter alpha parameter in the Lasso. method : {'lar', 'lasso'}, default='lar' Specifies the returned model. Select `'lar'` for Least Angle Regression, ``'lasso'`` for the Lasso. copy_X : bool, default=True If `False`, `X` is overwritten. eps : float, default=np.finfo(float).eps The machine-precision regularization in the computation of the Cholesky diagonal factors. Increase this for very ill-conditioned systems. Unlike the `tol` parameter in some iterative optimization-based algorithms, this parameter does not control the tolerance of the optimization. copy_Gram : bool, default=True If `False`, `Gram` is overwritten. verbose : int, default=0 Controls output verbosity. return_path : bool, default=True If `return_path==True` returns the entire path, else returns only the last point of the path. return_n_iter : bool, default=False Whether to return the number of iterations. positive : bool, default=False Restrict coefficients to be >= 0. This option is only allowed with method 'lasso'. Note that the model coefficients will not converge to the ordinary-least-squares solution for small values of alpha. Only coefficients up to the smallest alpha value (`alphas_[alphas_ > 0.].min()` when `fit_path=True`) reached by the stepwise Lars-Lasso algorithm are typically in congruence with the solution of the coordinate descent lasso_path function. Returns ------- alphas : ndarray of shape (n_alphas + 1,) Maximum of covariances (in absolute value) at each iteration. `n_alphas` is either `max_iter`, `n_features` or the number of nodes in the path with `alpha >= alpha_min`, whichever is smaller. active : ndarray of shape (n_alphas,) Indices of active variables at the end of the path. coefs : ndarray of shape (n_features, n_alphas + 1) Coefficients along the path. n_iter : int Number of iterations run. Returned only if `return_n_iter` is set to True. See Also -------- lars_path_gram : Compute LARS path. lasso_path : Compute Lasso path with coordinate descent. LassoLars : Lasso model fit with Least Angle Regression a.k.a. Lars. Lars : Least Angle Regression model a.k.a. LAR. LassoLarsCV : Cross-validated Lasso, using the LARS algorithm. LarsCV : Cross-validated Least Angle Regression model. sklearn.decomposition.sparse_encode : Sparse coding. References ---------- .. [1] "Least Angle Regression", Efron et al. http://statweb.stanford.edu/~tibs/ftp/lars.pdf .. [2] `Wikipedia entry on the Least-angle regression `_ .. [3] `Wikipedia entry on the Lasso `_ Examples -------- >>> from sklearn.linear_model import lars_path_gram >>> 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 = lars_path_gram(X.T @ y, X.T @ X, n_samples=100) >>> alphas.shape (3,) >>> estimated_coef array([[ 0. , 0. , 0. ], [ 0. , 0. , 0. ], [ 0. , 0. , 0. ], [ 0. , 46.96, 97.99], [ 0. , 0. , 45.70]]) Nr?)rBrFs rClars_path_gramrHs?z     # rEc US:XaU(a [S5eUbUO URnUc"[R"URU5nOUR 5nUbUSLaSnUc [S5eO[ U[5(aUS:XdUSLaJUSLd URSURS :a"[R"URU5nOSnOU (aUR 5nUcURS nO,URSnURUU4:wa [S 5eU(aUbUcUR S 5n[UU5n[S XX#455n[U5S :Xa[[U55nO[RnU (a3[R"US -U4US 9n[R"US -US 9nOV[R"UUS 9[R"UUS 9nn[R "S/US 9[R "S/US 9nnSunn[#5[R$"U5nn[R&"U[R(S 9nSnUc=[R&"UU4UR*S 9n [,R."SU45un!n"O<[R&"UU4UR*S 9n [,R."SU45un!n"[1SU 45un#U (aOU S :a [3S5 O=[4R6R9S5 [4R6R;5 [R<"[R>5R@n$[R<"UR*5RBn%[R<"[R>5RDn&Ub UR 5n'UR 5n(UR(anU(a[RF"U5n)O*[RF"[RH"U55n)UU)n*U(aU*n+O[RJ"U*5n+OSn+U (a:WU[RL4nWUnUUS - [RL4nUUS - nU+U- WS'USUU&-::aP[IUSU- 5U&:a-US:a"WSU- USUS- - n,WU,WU- --USS&UUS'U (aWWU'GOUU:dUU:aGOU(GdU(a[RN"W*5UU'O[RP"W*5UU'UW)U-n.n-U!"UU)US5uUU)'US'UU-UU.sUU.'UU-'Un/US SnUcU!"URU.URU-5uURU.'URU-'U""URU5S-n0[R"URUURSUR5U USU24'OWU!"UU-UU.5uUU-'UU.'U!"USS2U-4USS2U.45uUSS2U-4'USS2U.4'UUU4n0UUSU24U USU24'U(a0[,RR"U SU2SU24U USU244SS SS.[TD6 [R"U USU24U USU245n1[W[RX"[RH"U0U1- 55U 5n2U2U UU4'U2S:aR[ZR\"SUUR_5UU24-[`5 U/nSUS'U!"UU)US5uUU)'US'GMURcUU5 US - nU S :a![3U<SUS<SS<SU<SU+<3 5 US:XaRUS:aLWSUS:a@[ZR\"SUUR_5UR_5U4-[`5 GOU#"U SU2SU24USUSS9un3n4U3RS :XaU3S:Xa S U3S'Sn5GOS[RX"[Rd"U3USU-55- n5[Rf"U55(dSn6U SU2SU24R 5n7[Rf"U55(dU7RhSSUS -2==SU6-U -- ss'U#"U7USUSS9un3n4[W[Rd"U3USU-5U 5n8S[RX"U85- n5U6S - n6[Rf"U55(dMU3U5-n3UcS[R"URSURU35n9[R"URUSU95n:O*[R"USU2US24RU35n:[Rj"U:U%U:S 9 [lRn"U+U- U5U:- U$-- 5n;U(a[U;U+U5- 5n[lRn"U>5n?U?U<:a5[Rp"U>U?:H5SSSS2n@UU@*UU@'US:XaU?n`. Parameters ---------- X : None or ndarray of shape (n_samples, n_features) Input data. Note that if X is None then Gram must be specified, i.e., cannot be None or False. y : None or ndarray of shape (n_samples,) Input targets. Xy : array-like of shape (n_features,), default=None `Xy = np.dot(X.T, y)` that can be precomputed. It is useful only when the Gram matrix is precomputed. Gram : None, 'auto' or array-like of shape (n_features, n_features), default=None Precomputed Gram matrix `(X' * X)`, if ``'auto'``, the Gram matrix is precomputed from the given X, if there are more samples than features. n_samples : int or float, default=None Equivalent size of sample. If `None`, it will be `n_samples`. max_iter : int, default=500 Maximum number of iterations to perform, set to infinity for no limit. alpha_min : float, default=0 Minimum correlation along the path. It corresponds to the regularization parameter alpha parameter in the Lasso. method : {'lar', 'lasso'}, default='lar' Specifies the returned model. Select ``'lar'`` for Least Angle Regression, ``'lasso'`` for the Lasso. copy_X : bool, default=True If ``False``, ``X`` is overwritten. eps : float, default=np.finfo(float).eps The machine-precision regularization in the computation of the Cholesky diagonal factors. Increase this for very ill-conditioned systems. Unlike the ``tol`` parameter in some iterative optimization-based algorithms, this parameter does not control the tolerance of the optimization. copy_Gram : bool, default=True If ``False``, ``Gram`` is overwritten. verbose : int, default=0 Controls output verbosity. return_path : bool, default=True If ``return_path==True`` returns the entire path, else returns only the last point of the path. return_n_iter : bool, default=False Whether to return the number of iterations. positive : bool, default=False Restrict coefficients to be >= 0. This option is only allowed with method 'lasso'. Note that the model coefficients will not converge to the ordinary-least-squares solution for small values of alpha. Only coefficients up to the smallest alpha value (``alphas_[alphas_ > 0.].min()`` when fit_path=True) reached by the stepwise Lars-Lasso algorithm are typically in congruence with the solution of the coordinate descent lasso_path function. Returns ------- alphas : array-like of shape (n_alphas + 1,) Maximum of covariances (in absolute value) at each iteration. ``n_alphas`` is either ``max_iter``, ``n_features`` or the number of nodes in the path with ``alpha >= alpha_min``, whichever is smaller. active : array-like of shape (n_alphas,) Indices of active variables at the end of the path. coefs : array-like of shape (n_features, n_alphas + 1) Coefficients along the path n_iter : int Number of iterations run. Returned only if return_n_iter is set to True. See Also -------- lasso_path LassoLars Lars LassoLarsCV LarsCV sklearn.decomposition.sparse_encode References ---------- .. [1] "Least Angle Regression", Efron et al. http://statweb.stanford.edu/~tibs/ftp/lars.pdf .. [2] `Wikipedia entry on the Least-angle regression `_ .. [3] `Wikipedia entry on the Lasso `_ r)z:Positive constraint not supported for 'lar' coding method.NFz&X and Gram cannot both be unspecified.r$Trrz2The shapes of the inputs Gram and Xy do not match.Fc3B# UHocMURv M g7fNdtype).0as rC $_lars_path_solver..DsD"2Q"2srM)rr)swapnrm2)potrsz(Step Added Dropped Active set size C.r )translower overwrite_bgHz>zRegressors in active set degenerate. Dropping a regressor, after %i iterations, i.e. alpha=%.3e, with an active set of %i regressors, and the smallest cholesky pivot element being %.3e. Reduce max_iter or increase eps parameters.z r*zEarly stopping the lars path, as the residues are small and the current value of alpha is no longer well controlled. %i iterations, alpha=%.3e, previous alpha=%.3e, with an active set of %i regressors.)rY.?)decimalsout)@rAsizenpdotTcopy isinstancestrshapeminsetlennextiterfloat64zerosarraylistarangeemptyint8rNrget_blas_funcsrprintsysstdoutwriteflushfinfofloat32tiny precisionr6argmaxabsfabsnewaxis ones_likesignsolve_triangularSOLVE_TRIANGULAR_ARGSmaxsqrtwarningswarnitemr appendsumisfiniteflataroundrmin_poswhereresize zeros_likecholesky_deletepopranger_delete)Fr.r/r0r1r@r2r3r4r5r6r7r,r8r9r:Cov n_features max_featuresdtypes return_dtypecoefsalphascoef prev_coefalpha prev_alphan_itern_activeactiveindices sign_activedropLrTrUsolve_choleskytiny32 cov_precisionequality_tolerance Gram_copyCov_copyC_idxC_CssmnCov_not_shortenedcvdiag least_squares_AAiL_tmpeq_dir corr_eq_dirg1gamma_g2zz_posidx add_featuresiidrop_idxresidualtempsF rCrBrBsH8UVV&2 I zffQSS!nggi |tu} 9EF F  T3  DFNtt| 4<1771: 266!##q>DD yy{ |WWQZ YYq\ ::*j1 1QR R !-DL FF3Kx,L D1"2D DF 6{aDL) zz ,*J7|L,*,? HHZ| 4 HHZ| 4 HHcU, / HHcU, / FHfbii 3GF((((1:&q)$B$/C!,C 00K  D!  Q'%Y 3q<(+B#DD  %&<*?)LM()|mn%66L+@A)* }~&=Dfqj)II!!HJqM==&D (6M+AAV  v ## Fg%**1YhY  -A+BBG MH1452 2H5|B"2x0-1!##a&!##a!e*-E*AAE 5\rSrSr%SrS/S/S\"S15\R\"S5/\ "\ SSSS 9/\ "\ S SSS 9/S/S/\ "\ S SSS 9S/S /S . r \ \S 'SrSrSSSS\R""\5R&SSSSS . Sjr\S5rSSjr\"SS9SSj5rSrg)LarsiaCLeast Angle Regression model a.k.a. LAR. Read more in the :ref:`User Guide `. Parameters ---------- 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). verbose : bool or int, default=False Sets the verbosity amount. precompute : bool, 'auto' or array-like , 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. n_nonzero_coefs : int, default=500 Target number of non-zero coefficients. Use ``np.inf`` for no limit. eps : float, default=np.finfo(float).eps The machine-precision regularization in the computation of the Cholesky diagonal factors. Increase this for very ill-conditioned systems. Unlike the ``tol`` parameter in some iterative optimization-based algorithms, this parameter does not control the tolerance of the optimization. copy_X : bool, default=True If ``True``, X will be copied; else, it may be overwritten. fit_path : bool, default=True If True the full path is stored in the ``coef_path_`` attribute. If you compute the solution for a large problem or many targets, setting ``fit_path`` to ``False`` will lead to a speedup, especially with a small alpha. jitter : float, default=None Upper bound on a uniform noise parameter to be added to the `y` values, to satisfy the model's assumption of one-at-a-time computations. Might help with stability. .. versionadded:: 0.23 random_state : int, RandomState instance or None, default=None Determines random number generation for jittering. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Ignored if `jitter` is None. .. versionadded:: 0.23 Attributes ---------- alphas_ : array-like of shape (n_alphas + 1,) or list of such arrays Maximum of covariances (in absolute value) at each iteration. ``n_alphas`` is either ``max_iter``, ``n_features`` or the number of nodes in the path with ``alpha >= alpha_min``, whichever is smaller. If this is a list of array-like, the length of the outer list is `n_targets`. active_ : list of shape (n_alphas,) or list of such lists Indices of active variables at the end of the path. If this is a list of list, the length of the outer list is `n_targets`. coef_path_ : array-like of shape (n_features, n_alphas + 1) or list of such arrays The varying values of the coefficients along the path. It is not present if the ``fit_path`` parameter is ``False``. If this is a list of array-like, the length of the outer list is `n_targets`. coef_ : array-like of shape (n_features,) or (n_targets, n_features) Parameter vector (w in the formulation formula). intercept_ : float or array-like of shape (n_targets,) Independent term in decision function. n_iter_ : array-like or int The number of iterations taken by lars_path to find the grid of alphas for each target. 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. LarsCV : Cross-validated Least Angle Regression model. sklearn.decomposition.sparse_encode : Sparse coding. Examples -------- >>> from sklearn import linear_model >>> reg = linear_model.Lars(n_nonzero_coefs=1) >>> reg.fit([[-1, 1], [0, 0], [1, 1]], [-1.1111, 0, -1.1111]) Lars(n_nonzero_coefs=1) >>> print(reg.coef_) [ 0. -1.11] r%r,r$Nrr&r'r random_state fit_interceptr, precomputen_nonzero_coefsr6r5fit_pathjitterr_parameter_constraintsr)FTr=c pXlX lX0lX@lXPlX`lXplXlXlgrLr) selfrr,rrr6r5rrrs rC__init__ Lars.__init__s4+ $.   (rEc[US5(deUSLd?US:Xa URSURS:dUS:Xa4URSS:a![R"URU5nU$)N __array__Tr$rr)hasattrrgrarbrc)rr.r/s rC _get_gramLars._get_gram,se K00 4 f$aggaj)@f$aQJrEcURSn[XURURS9uppn URS:XaUSS2[ R 4nURSn URURX5n /Ul /Ul [ R"X4URS9Ul U(Ga/Ul/Ul[!U 5Hn UcSOUSS2U 4n[#UUSS2U 4U UURSUUR$['SUR(S- 5UUR*SSUR,S9unnnnURR/U5 URR/U5 URR/U5 URR/U5 USS2S4URU 'M U S:XaoURURURUR4Vs/sHnUSPM snuUl UlUlUl URSUl O[!U 5Hn UcSOUSS2U 4n[#UUSS2U 4U UURSUUR$['SUR(S- 5UUR*S SUR,S9unnURU 'nURR/U5 URR/U5 M U S:Xa(URSUl URSUl UR1XU 5 U$s snf) z=Auxiliary method to fit the model using X, y as training datarrrdNrMTr) r1r0r5r7r3r4r,r2r6r8r9r:r[F)rgr"rr5ndimrarrralphas_n_iter_rrrNcoef_active_ coef_path_rrDr4rr,r6r:r_set_intercept)rr.r/r2rrr0rX_offsety_offsetX_scale n_targetsr1kthis_Xyrr coef_pathrrPrs rC_fit Lars._fit7sWWQZ ,<  2 2- )h' 66Q;!RZZ- AGGAJ ~~dooq4  XXy5QWWE DL DO9%"$*$"QT(5>adG;;"#;;4<E A ]]   rE)rrrrr5r6rrrrrrrr,rL)__name__ __module__ __qualname____firstlineno____doc__rrandarrayrrrrrdict__annotations__r4r:rzfloatr6r staticmethodrrr r__static_attributes__rErCrrsk\$; *fX"6 F4LQ$Xq$vFGq$v67+KD!T&94@'( $D FH  HHUO  ).N`5/6/rErc \rSrSr%Sr0\R E\"\SSSS9/\"\ SSSS9/S/S.Er\ \ S '\RS 5 S r SS S SS\R"\5R"S S S SSS. SjjrSrg) LassoLarsiaLasso model fit with Least Angle Regression a.k.a. Lars. It is a Linear Model trained with an L1 prior as regularizer. 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 ---------- alpha : float, default=1.0 Constant that multiplies the penalty term. Defaults to 1.0. ``alpha = 0`` is equivalent to an ordinary least square, solved by :class:`LinearRegression`. For numerical reasons, using ``alpha = 0`` with the LassoLars object is not advised and you should prefer the 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). verbose : bool or int, default=False Sets the verbosity amount. precompute : bool, 'auto' or array-like, 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=500 Maximum number of iterations to perform. eps : float, default=np.finfo(float).eps The machine-precision regularization in the computation of the Cholesky diagonal factors. Increase this for very ill-conditioned systems. Unlike the ``tol`` parameter in some iterative optimization-based algorithms, this parameter does not control the tolerance of the optimization. copy_X : bool, default=True If True, X will be copied; else, it may be overwritten. fit_path : bool, default=True If ``True`` the full path is stored in the ``coef_path_`` attribute. If you compute the solution for a large problem or many targets, setting ``fit_path`` to ``False`` will lead to a speedup, especially with a small alpha. positive : bool, default=False Restrict coefficients to be >= 0. Be aware that you might want to remove fit_intercept which is set True by default. Under the positive restriction the model coefficients will not converge to the ordinary-least-squares solution for small values of alpha. Only coefficients up to the smallest alpha value (``alphas_[alphas_ > 0.].min()`` when fit_path=True) reached by the stepwise Lars-Lasso algorithm are typically in congruence with the solution of the coordinate descent Lasso estimator. jitter : float, default=None Upper bound on a uniform noise parameter to be added to the `y` values, to satisfy the model's assumption of one-at-a-time computations. Might help with stability. .. versionadded:: 0.23 random_state : int, RandomState instance or None, default=None Determines random number generation for jittering. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. Ignored if `jitter` is None. .. versionadded:: 0.23 Attributes ---------- alphas_ : array-like of shape (n_alphas + 1,) or list of such arrays Maximum of covariances (in absolute value) at each iteration. ``n_alphas`` is either ``max_iter``, ``n_features`` or the number of nodes in the path with ``alpha >= alpha_min``, whichever is smaller. If this is a list of array-like, the length of the outer list is `n_targets`. active_ : list of length n_alphas or list of such lists Indices of active variables at the end of the path. If this is a list of list, the length of the outer list is `n_targets`. coef_path_ : array-like of shape (n_features, n_alphas + 1) or list of such arrays If a list is passed it's expected to be one of n_targets such arrays. The varying values of the coefficients along the path. It is not present if the ``fit_path`` parameter is ``False``. If this is a list of array-like, the length of the outer list is `n_targets`. coef_ : array-like of shape (n_features,) or (n_targets, n_features) Parameter vector (w in the formulation formula). intercept_ : float or array-like of shape (n_targets,) Independent term in decision function. n_iter_ : array-like or int The number of iterations taken by lars_path to find the grid of alphas for each target. 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 : Linear Model trained with L1 prior as regularizer (aka the Lasso). LassoCV : Lasso linear model with iterative fitting along a regularization path. LassoLarsCV: Cross-validated Lasso, using the LARS algorithm. LassoLarsIC : Lasso model fit with Lars using BIC or AIC for model selection. sklearn.decomposition.sparse_encode : Sparse coding. Examples -------- >>> from sklearn import linear_model >>> reg = linear_model.LassoLars(alpha=0.01) >>> reg.fit([[-1, 1], [0, 0], [1, 1]], [-1, 0, -1]) LassoLars(alpha=0.01) >>> print(reg.coef_) [ 0. -0.955] rNr&r'r%)rr2r:rrr*TFr$r=) rr,rr2r6r5rr:rrc XlX lXPlX0lXlX@lXplX`lXlXl Xl grL) rrr2r,r:rr5r6rrr) rrrr,rr2r6r5rr:rrs rCrLassoLars.__init__Qs= *   $   (rE) rr5r6rrrr2r:rrr,)r])rrrrrrrrrrrrrr4rarzrr6rrr rErCr r sJX$  % %$4D89h4?@K $D 01 F) HHUO  ))rEr cjU(dURR(dUR5$U$rL)flags writeablerd)rords rC_check_copy_and_writeablerqs" 5;;((zz| LrEc [X5n[X5n[X%5n[X55nU(aBURSS9n X -nX,-nURSS9n [USS9nX-n[USS9nX=-n[UUUSSU[ SUS- 5U U U S9 upn[ R "UU5USS2[ R4- nXUUR4$)a Compute the residues on left-out data for a full LARS path Parameters ----------- X_train : array-like of shape (n_samples, n_features) The data to fit the LARS on y_train : array-like of shape (n_samples,) The target variable to fit LARS on X_test : array-like of shape (n_samples, n_features) The data to compute the residues on y_test : array-like of shape (n_samples,) The target variable to compute the residues on Gram : None, 'auto' or array-like of shape (n_features, n_features), default=None Precomputed Gram matrix (X' * X), if ``'auto'``, the Gram matrix is precomputed from the given X, if there are more samples than features copy : bool, default=True Whether X_train, X_test, y_train and y_test should be copied; if False, they may be overwritten. method : {'lar' , 'lasso'}, default='lar' Specifies the returned model. Select ``'lar'`` for Least Angle Regression, ``'lasso'`` for the Lasso. verbose : bool or int, default=False Sets the amount of verbosity 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). positive : bool, default=False Restrict coefficients to be >= 0. Be aware that you might want to remove fit_intercept which is set True by default. See reservations for using this option in combination with method 'lasso' for expected small values of alpha in the doc of LassoLarsCV and LassoLarsIC. max_iter : int, default=500 Maximum number of iterations to perform. eps : float, default=np.finfo(float).eps The machine-precision regularization in the computation of the Cholesky diagonal factors. Increase this for very ill-conditioned systems. Unlike the ``tol`` parameter in some iterative optimization-based algorithms, this parameter does not control the tolerance of the optimization. Returns -------- alphas : array-like of shape (n_alphas,) Maximum of covariances (in absolute value) at each iteration. ``n_alphas`` is either ``max_iter`` or ``n_features``, whichever is smaller. active : list Indices of active variables at the end of the path. coefs : array-like of shape (n_features, n_alphas) Coefficients along the path residues : array-like of shape (n_alphas, n_samples) Residues of the prediction on the test data raxisFrdr)r1r5r7r4r,r2r6r:N) rmeanrrDrrarbrrc)X_trainy_trainX_testy_testr1rdr4r,rr2r6r:X_meany_meanrrrresiduess rC_lars_path_residuesrwsj(6G'6G &v 4F &v 4F1%1% u5U3% Aw{#  FEvvfe$vam'<`. Parameters ---------- 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). verbose : bool or int, default=False Sets the verbosity amount. max_iter : int, default=500 Maximum number of iterations to perform. precompute : bool, 'auto' or array-like , default='auto' Whether to use a precomputed Gram matrix to speed up calculations. If set to ``'auto'`` let us decide. The Gram matrix cannot be passed as argument since we will use only subsets of X. cv : int, cross-validation generator or an 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. max_n_alphas : int, default=1000 The maximum number of points on the path used to compute the residuals in the cross-validation. n_jobs : int or None, 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. eps : float, default=np.finfo(float).eps The machine-precision regularization in the computation of the Cholesky diagonal factors. Increase this for very ill-conditioned systems. Unlike the ``tol`` parameter in some iterative optimization-based algorithms, this parameter does not control the tolerance of the optimization. copy_X : bool, default=True If ``True``, X will be copied; else, it may be overwritten. Attributes ---------- active_ : list of length n_alphas or list of such lists Indices of active variables at the end of the path. If this is a list of lists, the outer list length is `n_targets`. coef_ : array-like of shape (n_features,) parameter vector (w in the formulation formula) intercept_ : float independent term in decision function coef_path_ : array-like of shape (n_features, n_alphas) the varying values of the coefficients along the path alpha_ : float the estimated regularization parameter alpha alphas_ : array-like of shape (n_alphas,) the different values of alpha along the path cv_alphas_ : array-like of shape (n_cv_alphas,) all the values of alpha along the path for the different folds mse_path_ : array-like of shape (n_folds, n_cv_alphas) the mean square error on left-out for each fold along the path (alpha values given by ``cv_alphas``) n_iter_ : array-like or int the number of iterations run by Lars with 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 : Linear Model trained with L1 prior as regularizer (aka the Lasso). LassoCV : Lasso linear model with iterative fitting along a regularization path. LassoLars : Lasso model fit with Least Angle Regression a.k.a. Lars. LassoLarsIC : Lasso model fit with Lars using BIC or AIC for model selection. sklearn.decomposition.sparse_encode : Sparse coding. Notes ----- In `fit`, once the best parameter `alpha` is found through cross-validation, the model is fit again using the entire training set. Examples -------- >>> from sklearn.linear_model import LarsCV >>> from sklearn.datasets import make_regression >>> X, y = make_regression(n_samples=200, noise=4.0, random_state=0) >>> reg = LarsCV(cv=5).fit(X, y) >>> reg.score(X, y) 0.9996 >>> reg.alpha_ np.float64(0.2961) >>> reg.predict(X[:1,]) array([154.3996]) rNr&r' cv_objectr)r2cv max_n_alphasn_jobsr)rrrrr)TFr=r$) rr,r2rr"r#r$r6r5c \>X0lXPlX`lXpl[T U]UUUSUU SS9 g)Nr=T)rr,rrr6r5r)r2r"r#r$superr) rrr,r2rr"r#r$r6r5 __class__s rCrLarsCV.__init__sA! (  '!  rEcF>[TU]5nSURlU$NFr'__sklearn_tags__ target_tagsrrtagsr(s rCr-LarsCV.__sklearn_tags__#w')(-% rEr;c ^^^^[UTS5 [TTTSSS9umm[TTRS9m[TTRS9m[ TR SS9n[ 5(a[TS40UD6nO[[0S9S9nTRm[TS 5(a/[R"S TRR-5 S m[TR TR"S 9"UUUU4S jUR$"TT40UR&R$D655n[(R*"[-[/U655n[(R0"U5n[3[5S[3[7U5[9TR:5- 555nUSSU2n[(R<"[7U5[7U545n [?U5Hun un pU SSS2n U SSS2n U SS:wa=[(R@SU 4n [(R@U S[(RB4U 4n U SUS:wa>[(R@XS4n [(R@XS[(RB44n [DRF"XSS9"U5nUS-n[(RH"USS9U SS2U 4'M [(RJ"[(RL"U 5SS9nXnXn [(RN"U RISS95nUUnUTl(UTl)U Tl*TRWTTTRXUSSS9 T$)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. **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 self. rTrrrF) classifier)split)splitterrzXParameter "precompute" cannot be an array in %s. Automatically switch to "auto" instead.r$)r$r,c3># UHzup[[5"TUTUTUTUTSTR[STRS- 5TR TR TRTRS9 v M| g7f)Frr)r1rdr4r,rr2r6r:N) rrr4rr,rr2r6r:)rOtraintestr1r.rr/s rCrQLarsCV.fit..sF  N  ' (%%$${{At||a/0"00HH  NsBBrNr[rrr )r2rr0r)-rrrr5rr"rrrrrrrr(rrr$r,r6r7ra concatenaterkzipuniqueintrrjrr#rr enumeraterrrinterp1drallrargminalpha_ cv_alphas_ mse_path_rr2)rr.r/paramsr" routed_paramscv_paths all_alphasstridemse_pathindexrrr this_residuesmask i_best_alpha best_alphar1s``` @rCr LarsCV.fits6 &$.T1aN1 14;; / 14;; /dgg% 0   +D%B6BM!5r?;M 4 % % MM>@D@W@WX D4;; EF  "xx1M 0F0F0L0LMF  "^^Dh$89 YYz* SCJ%8I8I2J JKLM&) 88S_c(m<=/8/B +E+FAqDbD\F"~HayA~q&y)55!RZZ-!8(!BCbzZ^+v"~5655B N+C!CD'00J:VM a M!#R!@HQX 0Cvvbkk(+"5% >yyB!78  - ! $! ]]   rEc[URRS9R[ UR 5[ 5RSSS9S9nU$)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. )ownerrr6)callercallee)r7method_mapping)rr(raddrr"r)rrouters rCget_metadata_routingLarsCV.get_metadata_routingsQ dnn&=&=>BBdgg&(?..eG.LC  rE)rDr"rEr2r#rFr$)rrrrrrrrrrr parameterrr4rarzrr6rr-r rrZr __classcell__r(s@rCr r sFP$  % %$h4?@m!(AtFCDT" $DO ""9-OF   HHUO    6 5n6n`rEr c \rSrSrSr0\R ESS/0ErSrSSSS S S S \R"\ 5RSSS . S jr Sr g ) LassoLarsCVi'aCross-validated Lasso, using the LARS algorithm. See glossary entry for :term:`cross-validation estimator`. 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 ---------- 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). verbose : bool or int, default=False Sets the verbosity amount. max_iter : int, default=500 Maximum number of iterations to perform. precompute : bool or 'auto' , default='auto' Whether to use a precomputed Gram matrix to speed up calculations. If set to ``'auto'`` let us decide. The Gram matrix cannot be passed as argument since we will use only subsets of X. cv : int, cross-validation generator or an 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. max_n_alphas : int, default=1000 The maximum number of points on the path used to compute the residuals in the cross-validation. n_jobs : int or None, 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. eps : float, default=np.finfo(float).eps The machine-precision regularization in the computation of the Cholesky diagonal factors. Increase this for very ill-conditioned systems. Unlike the ``tol`` parameter in some iterative optimization-based algorithms, this parameter does not control the tolerance of the optimization. copy_X : bool, default=True If True, X will be copied; else, it may be overwritten. positive : bool, default=False Restrict coefficients to be >= 0. Be aware that you might want to remove fit_intercept which is set True by default. Under the positive restriction the model coefficients do not converge to the ordinary-least-squares solution for small values of alpha. Only coefficients up to the smallest alpha value (``alphas_[alphas_ > 0.].min()`` when fit_path=True) reached by the stepwise Lars-Lasso algorithm are typically in congruence with the solution of the coordinate descent Lasso estimator. As a consequence using LassoLarsCV only makes sense for problems where a sparse solution is expected and/or reached. Attributes ---------- coef_ : array-like of shape (n_features,) parameter vector (w in the formulation formula) intercept_ : float independent term in decision function. coef_path_ : array-like of shape (n_features, n_alphas) the varying values of the coefficients along the path alpha_ : float the estimated regularization parameter alpha alphas_ : array-like of shape (n_alphas,) the different values of alpha along the path cv_alphas_ : array-like of shape (n_cv_alphas,) all the values of alpha along the path for the different folds mse_path_ : array-like of shape (n_folds, n_cv_alphas) the mean square error on left-out for each fold along the path (alpha values given by ``cv_alphas``) n_iter_ : array-like or int the number of iterations run by Lars with the optimal alpha. active_ : list of int Indices of active variables at the end of the path. 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 : Linear Model trained with L1 prior as regularizer (aka the Lasso). LassoCV : Lasso linear model with iterative fitting along a regularization path. LassoLars : Lasso model fit with Least Angle Regression a.k.a. Lars. LassoLarsIC : Lasso model fit with Lars using BIC or AIC for model selection. sklearn.decomposition.sparse_encode : Sparse coding. Notes ----- The object solves the same problem as the :class:`~sklearn.linear_model.LassoCV` object. However, unlike the :class:`~sklearn.linear_model.LassoCV`, it find the relevant alphas values by itself. In general, because of this property, it will be more stable. However, it is more fragile to heavily multicollinear datasets. It is more efficient than the :class:`~sklearn.linear_model.LassoCV` if only a small number of features are selected compared to the total number, for instance if there are very few samples compared to the number of features. In `fit`, once the best parameter `alpha` is found through cross-validation, the model is fit again using the entire training set. Examples -------- >>> from sklearn.linear_model import LassoLarsCV >>> from sklearn.datasets import make_regression >>> X, y = make_regression(noise=4.0, random_state=0) >>> reg = LassoLarsCV(cv=5).fit(X, y) >>> reg.score(X, y) 0.9993 >>> reg.alpha_ np.float64(0.3972) >>> reg.predict(X[:1,]) array([-78.4831]) r:r%r*TFr=r$Nr% rr,r2rr"r#r$r6r5r:c |XlX lX0lX@lXPlX`lXplXlXlXl grLra) rrr,r2rr"r#r$r6r5r:s rCrLassoLarsCV.__init__s8+  $(   rE) r5r"r6rr2r#r$r:rr,)rrrrrr rr4rarzrr6rrr rErCr`r`'sj`D  ' 'YK F   HHUO  !!rEr`c .^\rSrSr%Sr0\R E\"SS15/\"\ SSSS9S/S .Er\ \ S 'S Hr \R\ 5 M SS S SS\R"\5R"S S SS.SjjrU4Sjr\"S S9SSj5rSrSrU=r$) LassoLarsICia0Lasso model fit with Lars using BIC or AIC for model selection. The optimization objective for Lasso is:: (1 / (2 * n_samples)) * ||y - Xw||^2_2 + alpha * ||w||_1 AIC is the Akaike information criterion [2]_ and BIC is the Bayes Information criterion [3]_. Such criteria are useful to select the value of the regularization parameter by making a trade-off between the goodness of fit and the complexity of the model. A good model should explain well the data while being simple. Read more in the :ref:`User Guide `. Parameters ---------- criterion : {'aic', 'bic'}, default='aic' The type of criterion to use. 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). verbose : bool or int, default=False Sets the verbosity amount. precompute : bool, 'auto' or array-like, 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=500 Maximum number of iterations to perform. Can be used for early stopping. eps : float, default=np.finfo(float).eps The machine-precision regularization in the computation of the Cholesky diagonal factors. Increase this for very ill-conditioned systems. Unlike the ``tol`` parameter in some iterative optimization-based algorithms, this parameter does not control the tolerance of the optimization. copy_X : bool, default=True If True, X will be copied; else, it may be overwritten. positive : bool, default=False Restrict coefficients to be >= 0. Be aware that you might want to remove fit_intercept which is set True by default. Under the positive restriction the model coefficients do not converge to the ordinary-least-squares solution for small values of alpha. Only coefficients up to the smallest alpha value (``alphas_[alphas_ > 0.].min()`` when fit_path=True) reached by the stepwise Lars-Lasso algorithm are typically in congruence with the solution of the coordinate descent Lasso estimator. As a consequence using LassoLarsIC only makes sense for problems where a sparse solution is expected and/or reached. noise_variance : float, default=None The estimated noise variance of the data. If `None`, an unbiased estimate is computed by an OLS model. However, it is only possible in the case where `n_samples > n_features + fit_intercept`. .. versionadded:: 1.1 Attributes ---------- coef_ : array-like of shape (n_features,) parameter vector (w in the formulation formula) intercept_ : float independent term in decision function. alpha_ : float the alpha parameter chosen by the information criterion alphas_ : array-like of shape (n_alphas + 1,) or list of such arrays Maximum of covariances (in absolute value) at each iteration. ``n_alphas`` is either ``max_iter``, ``n_features`` or the number of nodes in the path with ``alpha >= alpha_min``, whichever is smaller. If a list, it will be of length `n_targets`. n_iter_ : int number of iterations run by lars_path to find the grid of alphas. criterion_ : array-like of shape (n_alphas,) The value of the information criteria ('aic', 'bic') across all alphas. The alpha which has the smallest information criterion is chosen, as specified in [1]_. noise_variance_ : float The estimated noise variance from the data used to compute the criterion. .. versionadded:: 1.1 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 : Linear Model trained with L1 prior as regularizer (aka the Lasso). LassoCV : Lasso linear model with iterative fitting along a regularization path. LassoLars : Lasso model fit with Least Angle Regression a.k.a. Lars. LassoLarsCV: Cross-validated Lasso, using the LARS algorithm. sklearn.decomposition.sparse_encode : Sparse coding. Notes ----- The number of degrees of freedom is computed as in [1]_. To have more details regarding the mathematical formulation of the AIC and BIC criteria, please refer to :ref:`User Guide `. References ---------- .. [1] :arxiv:`Zou, Hui, Trevor Hastie, and Robert Tibshirani. "On the degrees of freedom of the lasso." The Annals of Statistics 35.5 (2007): 2173-2192. <0712.0881>` .. [2] `Wikipedia entry on the Akaike information criterion `_ .. [3] `Wikipedia entry on the Bayesian information criterion `_ Examples -------- >>> from sklearn import linear_model >>> reg = linear_model.LassoLarsIC(criterion='bic') >>> X = [[-2, 2], [-1, 1], [0, 0], [1, 1], [2, 2]] >>> y = [-2.2222, -1.1111, 0, -1.1111, -2.2222] >>> reg.fit(X, y) LassoLarsIC(criterion='bic') >>> print(reg.coef_) [ 0. -1.11] aicbicrNr&r') criterionnoise_variancer)rrrrTFr$r=)rr,rr2r6r5r:ric~XlX lXlXPlX0lXplX@lX`lSUlXl g)NT) rhrr:r2r,r5rr6rri) rrhrr,rr2r6r5r:ris rCrLassoLarsIC.__init__s:#*    $ ,rEcF>[TU]5nSURlU$r+r,r/s rCr-LassoLarsIC.__sklearn_tags__r2rEr;cUc URn[XUSSS9up[XURUS9uppEnURn[ UUUUSSSUR URURSURS9 upol URSn URS :XaS n O5URS :Xa [U 5n O[S UR<35eUSS2[R 4[R""X5- n [R$"U S -SS 9n[R&"U RS[(S9n[+U R,5H}unn[R."U5[R0"UR25R:n[R4"U5(dMd[R$"U5UU'M XlUR8c UR;XURS9UlOUR8UlU [R"S [R>-UR<-5-XR<- -X--Ul [RB"UR@5nUUUl"U SS2U4Ul#URIXEU5 U$)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,) Target values. Will be cast to X's dtype if necessary. copy_X : bool, default=None If provided, this parameter will override the choice of copy_X made at instance creation. If ``True``, X will be copied; else, it may be overwritten. Returns ------- self : object Returns an instance of self. NTr4rrSr*) r1r5r7r3r4r,r2r6r9r:rrfr rgz+criterion should be either bic or aic, got rrrM)r:)%r5rr"rrrDr,r2r6r:rrgrhrrArarrbrrnr?r@rcrrzrNanyrri_estimate_noise_variancenoise_variance_pi criterion_rCrDrr)rr.r/r5XmeanymeanXstdr1rrrr@criterion_factor residualsresiduals_sum_squaresdegrees_of_freedomrrrOn_bests rCrLassoLarsIC.fitsk, >[[FTaN#3  2 2$  eD/8 LL]]]] 0 ,J GGAJ >>U "  ^^u $"9~ =dnn=OP am$rvva'<< "y!|! <XXj&6&6q&9E .GAt66$<"((4::"6":"::D66$<<%'FF4L q !/    &#'#@#@t}}$A$D $(#6#6D  q255y4+?+??@ @#&:&:: ;3 4  4??+fo 6 *  E$/ rEcURSURSUR-::a#[SURRS35e[ USS9nUR X5RU5n[R"X%- S-5URSURS- UR- - $)aCompute an estimate of the variance with an OLS model. Parameters ---------- X : ndarray of shape (n_samples, n_features) Data to be fitted by the OLS model. We expect the data to be centered. y : ndarray of shape (n_samples,) Associated target. positive : bool, default=False Restrict coefficients to be >= 0. This should be inline with the `positive` parameter from `LassoLarsIC`. Returns ------- noise_variance : float An estimator of the noise variance of an OLS model. rrzYou are using z in the case where the number of samples is smaller than the number of features. In this setting, getting a good estimate for the variance of the noise is not possible. Provide an estimate of the noise variance in the constructor.F)r:rr ) rgrrAr(rr!rpredictrar)rr.r/r: ols_modely_preds rCrp$LassoLarsIC._estimate_noise_variance s* 771:d&8&88 8 !8!8 9: %heL q$,,Q/vvqza'( GGAJ #d&8&8 8  rE)rDrrr5rhrsr6rrr2rrirqr:rr,)rfrL)rrrrrr rrrrrrr\rrarzrr6rr-r rrprr]r^s@rCreresWr$  * *$ %01#D!T&A4H$D E ""9-E - HHUO  -0 5X6Xt" " rErerL)F)?rrvrmathrnumbersrrnumpyrascipyrrscipy.linalg.lapackrbaser r r exceptionsr model_selectionrutilsrrrrutils._metadata_requestsrrrrrutils._param_validationrrrrutils.parallelrrutils.validationr_baser r!r"rrrzrr6rDrHrBrr rrr r`rer rErCrs "%0AA+& TS.,BB'/jj$ jj$ zz4 VH%y"**dCh4?@tQV<=ug./0+q$y94@[;!{#K #'#, i       i'&iXzzl xD@Ah4?@tQV<=ug./0+q$y94@[;!{#K#'!.     [%$[B       v'z_ ^[_D p)p)n      q-hyTyx A!&A!L} )} rE