Skleran-线性模型-Lasso

Lasso

sklearn.linear_model.Lasso

class sklearn.linear_model.Lasso(alpha=1.0, fit_intercept=True, normalize=False, 
precompute=False, copy_X=True, max_iter=1000, tol=0.0001, warm_start=False, positive=False, 
random_state=None, selection='cyclic')

参数：

alpha：float, optional
	乘以L1项的常数。默认为1.0。alpha=0相当于一个普通的最小二乘，由LinearRegression对象求解。
	出于数值原因，不建议使用alpha=0。
fit_intercept：boolean, optional, default True
	是否计算此模型的截距。如果设置为False，则计算中将不使用截距（即数据应居中）。
normalize：boolean, optional, default False
	当fit_intercept设置为False时，忽略此参数。如果为真，则回归前，通过减去平均值并除以l2范数，
	对回归数X进行归一化。
precompute：True | False | array-like, default=False
	是否使用预计算的程序矩阵加快计算速度。对于稀疏输入，此选项始终为True以保持稀疏性。
copy_X：boolean, optional, default True
	如果为True，将复制X；否则，可能会覆盖它。
max_iter：int, optional
	最大迭代次数
tol：float, optional
	优化公差：如果更新小于tol，则优化代码检查双间隙的最优性，并继续，直到它小于tol。
warm_start：bool, optional
	当设置为True时，重用上一个调用的解决方案以适应初始化，否则，只需删除上一个解决方案。
positive：bool, optional
	当设置为True时，强制系数为正。
random_state：int, RandomState instance or None, optional, default None
	选择要更新的随机特征的伪随机数生成器的种子。
selection：str, default ‘cyclic’
	如果设置为“随机”，则每次迭代都会更新一个随机系数，而不是默认情况下按顺序在特征上循环。
	（设置为“随机”）通常会导致显著更快的收敛，特别是当tol高于1e-4时。

属性：

coef_：array, shape (n_features,) | (n_targets, n_features)
	参数向量（成本函数公式中的w）
sparse_coef_：scipy.sparse matrix, shape (n_features, 1) | (n_targets, n_features)
	拟合系数的稀疏表示_
intercept_：float | array, shape (n_targets,)
	决策函数中的独立项。
n_iter_：int | array-like, shape (n_targets,)
	为达到指定公差而运行的迭代次数

另见：

lars_path
lasso_path
LassoLars
LassoCV
LassoLarsCV
sklearn.decomposition.sparse_encode

方法：

__init__(self, alpha=1.0, fit_intercept=True, normalize=False, precompute=False, copy_X=True, max_iter=1000, tol=0.0001, warm_start=False, positive=False, random_state=None, selection='cyclic') 

初始化
fit(self, X, y, check_input=True)
用坐标下降拟合模型。
	参数：
		X：ndarray or scipy.sparse matrix, (n_samples, n_features)
		数据
		y：ndarray, shape (n_samples,) or (n_samples, n_targets)
		标签
		check_input：boolean, (default=True)
		允许绕过多个输入检查。
get_params(self, deep=True)
获取此估计器的参数。
	参数：
	deepbool, default=True
	如果为True，则返回此估计器的参数以及包含的子对象（即估计器）。
		返回：
			params：mapping of string to any
			映射到其值的参数名。
predict(self, X)
用线性模型预测。
	参数：
		X：array_like or sparse matrix, shape (n_samples, n_features)
			样本
	返回：
		C：array, shape (n_samples,)
			预测值
score(self, X, y, sample_weight=None)
	返回预测的决定系数R^2。

	系数R^2定义为(1-u/v)，其中u是残差平方和((y_true-y_pred)**2).sum()，
	v是平方和的总和((y_true-y_true.mean())**2).sum()。最好的分数是1.0，
	它可以是负的(因为模型可以任意恶化)。一个常数模型总是预测y的期望值，
	而不考虑输入特性，则得到R^2分数为0.0。
	参数：
		X：array-like of shape (n_samples, n_features)
		测试样本。
		y：array-like of shape (n_samples,) or (n_samples, n_outputs)
		X的真值。
		sample_weight：array-like of shape (n_samples,), default=None
		样本权重。
	返回：
		scorefloat
		得分
set_params(self, **params)
设置此估计器的参数。
	参数：
		**params：dict
		估计参数
	返回：
		Self：object
		估计实例

示例
Lasso和Elastic Net(弹性网络)在稀疏信号上的表现

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2020/6/19 23:03
# @Author  : LaoChen

"""
对稀疏信号估计Lasso和弹性网回归模型进行比较。
"""

import numpy as np
import matplotlib.pyplot as plt

from sklearn.metrics import r2_score

# #############################################################################
# Generate some sparse data to play with
np.random.seed(42)

n_samples, n_features = 50, 100
X = np.random.randn(n_samples, n_features)

# Decreasing coef w. alternated signs for visualization
idx = np.arange(n_features)
coef = (-1) ** idx * np.exp(-idx / 10)
coef[10:] = 0  # sparsify coef
y = np.dot(X, coef)

# Add noise
y += 0.01 * np.random.normal(size=n_samples)

# Split data in train set and test set
n_samples = X.shape[0]
X_train, y_train = X[:n_samples // 2], y[:n_samples // 2]
X_test, y_test = X[n_samples // 2:], y[n_samples // 2:]

# #############################################################################
# Lasso
from sklearn.linear_model import Lasso

alpha = 0.1
lasso = Lasso(alpha=alpha)

y_pred_lasso = lasso.fit(X_train, y_train).predict(X_test)
r2_score_lasso = r2_score(y_test, y_pred_lasso)
print(lasso)
print("r^2 on test data : %f" % r2_score_lasso)

# #############################################################################
# ElasticNet
from sklearn.linear_model import ElasticNet

enet = ElasticNet(alpha=alpha, l1_ratio=0.7)

y_pred_enet = enet.fit(X_train, y_train).predict(X_test)
r2_score_enet = r2_score(y_test, y_pred_enet)
print(enet)
print("r^2 on test data : %f" % r2_score_enet)

m, s, _ = plt.stem(np.where(enet.coef_)[0], enet.coef_[enet.coef_ != 0],
                   markerfmt='x', label='Elastic net coefficients',
                   use_line_collection=True)
plt.setp([m, s], color="#2ca02c")
m, s, _ = plt.stem(np.where(lasso.coef_)[0], lasso.coef_[lasso.coef_ != 0],
                   markerfmt='x', label='Lasso coefficients',
                   use_line_collection=True)
plt.setp([m, s], color='#ff7f0e')
plt.stem(np.where(coef)[0], coef[coef != 0], label='true coefficients',
         markerfmt='bx', use_line_collection=True)

plt.legend(loc='best')
plt.title("Lasso $R^2$: %.3f, Elastic Net $R^2$: %.3f"
          % (r2_score_lasso, r2_score_enet))
plt.show()

sklearn.linear_model.MultiTaskLasso

class sklearn.linear_model.MultiTaskLasso(alpha=1.0, fit_intercept=True, normalize=False, 
copy_X=True, max_iter=1000, tol=0.0001, warm_start=False, random_state=None, 
selection='cyclic')

>>> from sklearn import linear_model
>>> clf = linear_model.MultiTaskLasso(alpha=0.1)
>>> clf.fit([[0,0], [1, 1], [2, 2]], [[0, 0], [1, 1], [2, 2]])
MultiTaskLasso(alpha=0.1)
>>> print(clf.coef_)
[[0.89393398 0.        ]
 [0.89393398 0.        ]]
>>> print(clf.intercept_)
[0.10606602 0.10606602]