`sklearn.linear_model`.LassoCV¶

class sklearn.linear_model.LassoCV(*, eps=0.001, n_alphas=100, alphas=None, fit_intercept=True, normalize='deprecated', precompute='auto', max_iter=1000, tol=0.0001, copy_X=True, cv=None, verbose=False, n_jobs=None, positive=False, random_state=None, selection='cyclic')[source]¶

Lasso linear model with iterative fitting along a regularization path.

See glossary entry for 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

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

For an example, see examples/linear_model/plot_lasso_model_selection.py.

To avoid unnecessary memory duplication the X argument of the fit method should be directly passed as a Fortran-contiguous numpy array.

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...])

Methods

`fit`(X, y[, sample_weight])	Fit linear model with coordinate descent.
`get_params`([deep])	Get parameters for this estimator.
`path`(X, y, *[, eps, n_alphas, alphas, ...])	Compute Lasso path with coordinate descent.
`predict`(X)	Predict using the linear model.
`score`(X, y[, sample_weight])	Return the coefficient of determination of the prediction.
`set_params`(**params)	Set the parameters of this estimator.

fit(X, y, sample_weight=None)[source]¶

Fit 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.
yarray-like of shape (n_samples,) or (n_samples, n_targets): Target values.
sample_weightfloat 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.

Returns

selfobject: Returns an instance of fitted model.

get_params(deep=True)[source]¶

Get parameters for this estimator.

Parameters

deepbool, default=True: If True, will return the parameters for this estimator and contained subobjects that are estimators.

Returns

paramsdict: Parameter names mapped to their values.

static path(X, y, *, eps=0.001, n_alphas=100, alphas=None, precompute='auto', Xy=None, copy_X=True, coef_init=None, verbose=False, return_n_iter=False, positive=False, **params)[source]¶

Compute Lasso path with coordinate descent.

The Lasso optimization function varies for mono and multi-outputs.

For mono-output tasks it is:

(1 / (2 * n_samples)) * ||y - Xw||^2_2 + alpha * ||w||_1

For multi-output tasks it 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.

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 examples/linear_model/plot_lasso_coordinate_descent_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]]

predict(X)[source]¶

Predict using the linear model.

Parameters

Xarray-like or sparse matrix, shape (n_samples, n_features): Samples.

Returns

Carray, shape (n_samples,): Returns predicted values.

score(X, y, sample_weight=None)[source]¶

Return the coefficient of determination of the prediction.

The coefficient of determination \(R^2\) is defined as \((1 - \frac{u}{v})\), where \(u\) is the residual sum of squares ((y_true - y_pred)** 2).sum() and \(v\) is the total sum of squares ((y_true - y_true.mean()) ** 2).sum(). The best possible score is 1.0 and it can be negative (because the model can be arbitrarily worse). A constant model that always predicts the expected value of y, disregarding the input features, would get a \(R^2\) score of 0.0.

Parameters

Xarray-like of shape (n_samples, n_features): Test samples. For some estimators this may be a precomputed kernel matrix or a list of generic objects instead with shape (n_samples, n_samples_fitted), where n_samples_fitted is the number of samples used in the fitting for the estimator.
yarray-like of shape (n_samples,) or (n_samples, n_outputs): True values for X.
sample_weightarray-like of shape (n_samples,), default=None: Sample weights.

Returns

scorefloat: \(R^2\) of self.predict(X) wrt. y.

Notes

The \(R^2\) score used when calling score on a regressor uses multioutput='uniform_average' from version 0.23 to keep consistent with default value of r2_score. This influences the score method of all the multioutput regressors (except for MultiOutputRegressor).

set_params(**params)[source]¶

Set the parameters of this estimator.

The method works on simple estimators as well as on nested objects (such as Pipeline). The latter have parameters of the form <component>__<parameter> so that it’s possible to update each component of a nested object.

Parameters

**paramsdict: Estimator parameters.

Returns

selfestimator instance: Estimator instance.

Examples using `sklearn.linear_model.LassoCV`¶

sklearn.linear_model.LassoCV¶

Examples using sklearn.linear_model.LassoCV¶

`sklearn.linear_model`.LassoCV¶

Examples using `sklearn.linear_model.LassoCV`¶