Sklearn官方文档中文整理1——监督学习之广义线性模型篇

1. 监督学习

1.1 广义线性模型

1.1.1 普通最小二乘法【linear_model.LinearRegression】

sklearn.linear_model.LinearRegression类

参数	解释
fit_intercept：bool, default=True	是否计算该模型的截距
normalize：bool, default=False	当fit_intercept=False时忽略此参数；若为True，则在回归前减去平均值并除以l2范数，对回归两X进行归一化；在normalize=False时，调用模型前，若希望标准化，使用sklearn.preprocessing.StandardScaler类
copy_X：bool, default=True	若为True，X会被复制，否则被覆盖
n_jobs：int, default=None	线程数

属性	解释
coef_：array of shape (n_features, ) or (n_targets, n_features)	估计的参数，若你和过程有多个目标，则返回格式为(n_targets, n_features)，若单个目标，则返回格式为(n_features, )
rank_：int	X的秩，只有X为稠密矩阵才有效
singular_：array of shape (min(X, y),)	Singular values of X. Only available when X is dense.
intercept_：float or array of shape (n_targets,)	截距项

方法	解释
fit(X, y[, sample_weight])	拟合模型
get_params([deep])	获取此估计器的参数。
predict(X)	预测
score(X, y[, sample_weight])	返回预测的决定系数R^2。
set_params(**params)	设置此估计器的参数。

例子：

>>> import numpy as np
>>> from sklearn.linear_model import LinearRegression
>>> X = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])
>>> # y = 1 * x_0 + 2 * x_1 + 3
>>> y = np.dot(X, np.array([1, 2])) + 3
>>> reg = LinearRegression().fit(X, y)  # 拟合模型
>>> reg.score(X, y)  # 分值，以R2的形式
1.0
>>> reg.coef_  # 查看模型属性
array([1., 2.]) 
>>> reg.intercept_  # 查看模型属性
3.0000...
>>> reg.predict(np.array([[3, 5]]))  # 预测
array([16.])

1.1.2. 岭回归和分类

1.1.2.1. 回归【linear_model.Ridge】

岭回归通过对系数大小施加惩罚来解决普通最小二乘的一些问题

sklearn.linear_model.Ridge类

参数	解释
alpha：{float, ndarray of shape (n_targets,)}, default=1.0	正则化强度，必须是正浮点数，正则化改善了问题的条件，并减少了估计的方差，值越大，正则化越强
fit_intercept：bool, default=True	是否计算该模型的截距
normalize：bool, default=False	当fit_intercept=False时忽略此参数；若为True，则在回归前减去平均值并除以l2范数，对回归两X进行归一化；在normalize=False时，调用模型前，若希望标准化，使用sklearn.preprocessing.StandardScaler类
copy_X：bool, default=True	若为True，X会被复制，否则被覆盖
max_iter：int, default=None	共轭梯度解算器最大迭代次数，对于“sparse_cg”和“lsqr”解算器，默认值由scipy.sparse.linalg决定 ，对于“sag解算器，默认1000”
tol：float, default=1e-3	结果的精度
solver：{‘auto’, ‘svd’, ‘cholesky’, ‘lsqr’, ‘sparse_cg’, ‘sag’, ‘saga’}, default=’auto’	解算器
random_state：int, RandomState instance, default=None	随机算子，当solver == ‘sag’ or ‘saga’ 需要洗牌数据时使用

属性	解释
coef_：ndarray of shape (n_features,) or (n_targets, n_features)	估计的参数
intercept_：float or array of shape (n_targets,)	截距项
n_iter_：None or ndarray of shape (n_targets,)	每个目标的实际迭代次数。仅适用于sag和lsqr解算器。其他解算器将不返回任何值。

方法	解释
fit(X, y[, sample_weight])	拟合模型
get_params([deep])	获取此估计器的参数。
predict(X)	预测
score(X, y[, sample_weight])	返回预测的决定系数R^2。
set_params(**params)	设置此估计器的参数。

例：

>>> from sklearn import linear_model
>>> reg = linear_model.Ridge(alpha=.5)  # 初始化模型
>>> reg.fit([[0, 0], [0, 0], [1, 1]], [0, .1, 1])  # 拟合模型
Ridge(alpha=0.5)
>>> reg.coef_  # 返回模型系数
array([0.34545455, 0.34545455])
>>> reg.intercept_  # 返回截距项
0.13636...

1.1.2.2. 分类【linear_model.RidgeClassifier】

该分类器首先将二进制目标转换为{-1，1}，然后将问题视为回归任务，优化与上述相同的目标。预测类对应于回归函数的预测符号。对于多类分类问题，将问题视为多输出回归，预测类对应于具有最大值的输出。

用一个（惩罚的）最小二乘损失来拟合分类模型，而不是更传统的逻辑损失或铰链损失，似乎是有问题的。然而，在实践中，所有这些模型都可能导致在准确性或精确度/召回率方面的类似交叉验证分数，而岭分类器使用的惩罚最小二乘损失允许对具有不同计算性能剖面的数值解算器进行非常不同的选择。

sklearn.linear_model.RidgeClassifier类

参数	解释
alpha：{float, ndarray of shape (n_targets,)}, default=1.0	正则化强度，必须是正浮点数，正则化改善了问题的条件，并减少了估计的方差，值越大，正则化越强
fit_intercept：bool, default=True	是否计算该模型的截距
normalize：bool, default=False	当fit_intercept=False时忽略此参数；若为True，则在回归前减去平均值并除以l2范数，对回归两X进行归一化；在normalize=False时，调用模型前，若希望标准化，使用sklearn.preprocessing.StandardScaler类
copy_X：bool, default=True	若为True，X会被复制，否则被覆盖
max_iter：int, default=None	共轭梯度解算器最大迭代次数，对于“sparse_cg”和“lsqr”解算器，默认值由scipy.sparse.linalg决定 ，对于“sag解算器，默认1000”
tol：float, default=1e-3	结果的精度
class_weight：dict or ‘balanced’, default=None	与{class_label:weight}形式的类关联的权重。如果没有给出，所有的类都应该有一个权重。“平衡”模式使用y值自动调整与输入数据中的类频率成反比的权重，如n_samples / (n_classes * np.bincount(y))
solver：{‘auto’, ‘svd’, ‘cholesky’, ‘lsqr’, ‘sparse_cg’, ‘sag’, ‘saga’}, default=’auto’	解算器
random_state：int, RandomState instance, default=None	随机算子，当solver == ‘sag’ or ‘saga’ 需要洗牌数据时使用

属性	解释
coef_：ndarray of shape (n_features,) or (n_targets, n_features)	估计的参数
intercept_：float or array of shape (n_targets,)	截距项
n_iter_：None or ndarray of shape (n_targets,)	每个目标的实际迭代次数。仅适用于sag和lsqr解算器。其他解算器将不返回任何值。
classes_：ndarray of shape (n_classes,)	类别标签

方法	解释
decision_function(X)	预测样本的置信度得分。
fit(X, y[, sample_weight])	拟合模型
get_params([deep])	获取此估计器的参数。
predict(X)	预测
score(X, y[, sample_weight])	返回预测的决定系数R^2。
set_params(**params)	设置此估计器的参数。

例：

>>> from sklearn.datasets import load_breast_cancer
>>> from sklearn.linear_model import RidgeClassifier
>>> X, y = load_breast_cancer(return_X_y=True)
>>> clf = RidgeClassifier().fit(X, y)
>>> clf.score(X, y)
0.9595...

1.1.2.3. 设置正则化参数：广义交叉验证【linear_model.RidgeCV】

RidgeCV使用alpha参数的内置交叉验证实现岭回归。该对象的工作方式与GridSearchCV相同，但它默认为通用交叉验证（GCV），这是一种有效的“省去一次”交叉验证的形式。

sklearn.linear_model.RidgeCV类

参数	解释
alphas：ndarray of shape (n_alphas,), default=(0.1, 1.0, 10.0)	要尝试的alpha值数组。正则化强度；必须是正浮点数。正则化改善了问题的条件，并减少了估计的方差。值越大，正则化越强。
fit_intercept：bool, default=True	是否计算该模型的截距
normalize：bool, default=False	当fit_intercept=False时忽略此参数；若为True，则在回归前减去平均值并除以l2范数，对回归两X进行归一化；在normalize=False时，调用模型前，若希望标准化，使用sklearn.preprocessing.StandardScaler类
scoring：string, callable, default=None	一个字符串（参见模型评估文档）或一个带有签名记分器（estimator，X，y）的可调用对象/函数。如果无，则cv为“自动”或“无”（即使用广义交叉验证时）时为负均方误差，否则为r2得分。
cv：int, cross-validation generator or an iterable, default=None	确定交叉验证拆分策略。
gcv_mode：{‘auto’, ‘svd’, eigen’}, default=’auto’	指示执行广义交叉验证时要使用的策略的标志。
store_cv_values：bool, default=False	指示与每个alpha对应的交叉验证值是否应存储在cv_values_u属性中的标志（见下文）。此标志仅与cv=None兼容（即使用广义交叉验证）。

属性	解释
coef_：ndarray of shape (n_features,) or (n_targets, n_features)	估计的参数
cv_values_：ndarray of shape (n_samples, n_alphas) or shape (n_samples, n_targets, n_alphas), optional	每个alpha的交叉验证值（仅当store_cv_values=True且cv=None时可用）。在调用fit（）之后，这个属性将包含均方误差（默认情况下）或{loss,score}_func函数的值（如果在构造函数中提供的话）
intercept_：float or array of shape (n_targets,)	截距项
alpha_：float	估计正则化参数。
best_score_：float	最佳α基估计量的得分。

方法	解释
fit(X, y[, sample_weight])	拟合模型
get_params([deep])	获取此估计器的参数。
predict(X)	预测
score(X, y[, sample_weight])	返回预测的决定系数R^2。
set_params(**params)	设置此估计器的参数。

>>> import numpy as np
>>> from sklearn import linear_model
>>> reg = linear_model.RidgeCV(alphas=np.logspace(-6, 6, 13))
>>> reg.fit([[0, 0], [0, 0], [1, 1]], [0, .1, 1])
RidgeCV(alphas=array([1.e-06, 1.e-05, 1.e-04, 1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01,
      1.e+02, 1.e+03, 1.e+04, 1.e+05, 1.e+06]))
>>> reg.alpha_
0.01

指定cv属性的值将触发对GridSearchCV使用交叉验证，例如cv=10表示10倍交叉验证，而不是广义交叉验证。

1.1.3. Lasso【linear_model.Lasso】

Lasso是一种估计稀疏系数的线性模型。它在某些情况下是有用的，因为它倾向于选择非零系数较少的解，从而有效地减少了给定解所依赖的特征数。因此Lasso及其变种是压缩传感领域的基础。在一定条件下，它可以恢复非零系数的精确集合。

数学上，它由一个线性模型和一个附加的正则化项组成。最小化的目标函数是：

Lasso 类的实现使用了 coordinate descent （坐标下降算法）来拟合系数。

sklearn.linear_model.Lasso

参数	解释
alpha：float, default=1.0	乘以L1项的常数。默认为1.0。alpha=0相当于普通最小二乘法，由LinearRegression对象求解。由于数值原因，不建议对套索对象使用alpha=0。鉴于此，您应该使用LinearRegression对象。
fit_intercept：bool, default=True	是否计算该模型的截距
normalize：bool, default=False	当fit_intercept=False时忽略此参数；若为True，则在回归前减去平均值并除以l2范数，对回归两X进行归一化；在normalize=False时，调用模型前，若希望标准化，使用sklearn.preprocessing.StandardScaler类
precompute：‘auto’, bool or array-like of shape (n_features, n_features), default=False	是否使用预计算的Gram矩阵来加速计算。如果设置为“auto”，让我们决定。Gram矩阵也可以作为参数传递。对于稀疏输入，此选项始终为True以保持稀疏性。
copy_X：bool, default=True	若为True，X会被复制，否则被覆盖
max_iter：int, default=1000	最大迭代次数
tol：float, default=1e-4	优化的容差：如果更新小于tol，优化代码将检查双重间隙的最佳性，并继续进行，直到它小于tol为止。
warm_start：bool, default=False	当设置为True时，将上一个调用的解决方案重用为fit作为初始化，否则，只需删除以前的解决方案。
positive：bool, default=False	设置为True时，强制系数为正。
random_state：int, RandomState instance, default=None	选择要更新的随机特征的伪随机数生成器的种子。当selection == ‘random’时使用。
selection：{‘cyclic’, ‘random’}, default=’cyclic’	若设置成‘random’ ，随机系数在每次迭代中都会更新，而不是按顺序在特征上循环。这（设置为“随机”）通常会导致显著更快的收敛，尤其是当tol高于1e-4时。

属性	解释
coef_：ndarray of shape (n_features,) or (n_targets, n_features)	估计的参数
dual_gap_：float or ndarray of shape (n_targets,)	给定param alpha，优化结束时的双间隙，与y的每次观测形状相同。
intercept_：float or array of shape (n_targets,)	截距项
sparse_coef_：sparse matrix of shape (n_features, 1) or (n_targets, n_features)	拟合系数的稀疏表示。
n_iter_：int or list of int	坐标下降解算器为达到指定公差而运行的迭代次数。

方法	解释
fit(X, y[, sample_weight])	拟合模型
get_params([deep])	获取此估计器的参数。
predict(X)	预测
score(X, y[, sample_weight])	返回预测的决定系数R^2。
set_params(**params)	设置此估计器的参数。
path(*args, **kwargs)	用坐标下降法计算弹性网络路径。

例子：

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

>>> from sklearn import linear_model
>>> reg = linear_model.Lasso(alpha = 0.1)
>>> reg.fit([[0, 0], [1, 1]], [0, 1])
Lasso(alpha=0.1, copy_X=True, fit_intercept=True, max_iter=1000,
 normalize=False, positive=False, precompute=False, random_state=None,
 selection='cyclic', tol=0.0001, warm_start=False)
>>> reg.predict([[1, 1]])  # 预测
array([ 0.8])

1.1.3.1. 使用交叉验证 【linear_model.LassoCV和linear_model.LassoLarsCV】

scikit-learn 通过交叉验证来公开设置 Lasso alpha 参数的对象: LassoCV和LassoLarsCV。 LassoLarsCV 是基于下面将要提到的 最小角回归 算法。

对于具有许多线性回归的高维数据集， LassoCV最常见。 然而，LassoLarsCV 在寻找 alpha参数值上更具有优势，而且如果样本数量比特征数量少得多时，通常LassoLarsCV比LassoCV 要快。

sklearn.linear_model.LassoCV

参数	解释
eps：float, default=1e-3	路径的长度。eps=1e-3表示α_min/alpha_max=1e-3。
n_alphas：int, default=100	沿正则化路径的alpha数目。
alphas：ndarray, default=None	计算模型的alphas列表。如果没有自动设置
fit_intercept：bool, default=True	是否计算该模型的截距
normalize：bool, default=False	当fit_intercept=False时忽略此参数；若为True，则在回归前减去平均值并除以l2范数，对回归两X进行归一化；在normalize=False时，调用模型前，若希望标准化，使用sklearn.preprocessing.StandardScaler类
precompute：‘auto’, bool or array-like of shape (n_features, n_features), default=’auto’	是否使用预计算的Gram矩阵来加速计算。如果设置为“auto”，让我们决定。Gram矩阵也可以作为参数传递。对于稀疏输入，此选项始终为True以保持稀疏性。
copy_X：bool, default=True	若为True，X会被复制，否则被覆盖
max_iter：int, default=1000	最大迭代次数
tol：float, default=1e-4	优化的容差：如果更新小于tol，优化代码将检查双重间隙的最佳性，并继续进行，直到它小于tol为止。
positive：bool, default=False	设置为True时，强制系数为正。
random_state：int, RandomState instance, default=None	选择要更新的随机特征的伪随机数生成器的种子。当selection == ‘random’时使用。
selection：{‘cyclic’, ‘random’}, default=’cyclic’	若设置成‘random’ ，随机系数在每次迭代中都会更新，而不是按顺序在特征上循环。这（设置为“随机”）通常会导致显著更快的收敛，尤其是当tol高于1e-4时。
cv：int, cross-validation generator or iterable, default=None	确定交叉验证拆分策略。
verbose：bool or int, default=False	冗长的程度。
n_jobs：int, default=None	线程数

属性	解释
alpha_：float	通过交叉验证选择的惩罚参数
mse_path_：ndarray of shape (n_alphas, n_folds)	每个折叠上测试集的中误差，α变化。
alphas_：ndarray of shape (n_alphas,)	用于装配的字母网格。
coef_：ndarray of shape (n_features,) or (n_targets, n_features)	估计的参数
dual_gap_：float or ndarray of shape (n_targets,)	给定param alpha，优化结束时的双间隙，与y的每次观测形状相同。
intercept_：float or array of shape (n_targets,)	截距项
n_iter_：int or list of int	坐标下降解算器为达到指定公差而运行的迭代次数。

方法	解释
fit(X, y[, sample_weight])	拟合模型
get_params([deep])	获取此估计器的参数。
predict(X)	预测
score(X, y[, sample_weight])	返回预测的决定系数R^2。
set_params(**params)	设置此估计器的参数。
path(*args, **kwargs)	用坐标下降法计算弹性网络路径。

例子：

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

sklearn.linear_model.LassoLarsCV

参数	解释
fit_intercept：bool, default=True	是否计算该模型的截距
verbose：bool or int, default=False	设置冗长量
max_iter：int, default=500	最大迭代次数
normalize：bool, default=False	当fit_intercept=False时忽略此参数；若为True，则在回归前减去平均值并除以l2范数，对回归两X进行归一化；在normalize=False时，调用模型前，若希望标准化，使用sklearn.preprocessing.StandardScaler类
precompute：‘auto’, bool or array-like of shape (n_features, n_features), default=’auto’	是否使用预计算的Gram矩阵来加速计算。如果设置为“auto”，让我们决定。Gram矩阵也可以作为参数传递。对于稀疏输入，此选项始终为True以保持稀疏性。
cv：int, cross-validation generator or iterable, default=None	确定交叉验证拆分策略。
max_n_alphas：int, default=1000	路径上用于计算交叉验证中残差的最大点数
n_jobs：int, default=None	线程数
eps：float, default=np.finfo(float).eps	Cholesky对角因子计算中的机器精度正则化。对于病态严重的系统，增加这个值。与一些基于迭代优化的算法中的tol参数不同，该参数不控制优化的容差。
copy_X：bool, default=True	若为True，X会被复制，否则被覆盖
positive：bool, default=False	设置为True时，强制系数为正。

属性	解释
coef_：array-like of shape (n_features,)	估计的参数
intercept_：float or array of shape (n_targets,)	截距项
coef_path_：array-like of shape (n_features, n_alphas)	沿路径变化的系数值
alpha_：float	通过交叉验证选择的惩罚参数
alphas_：ndarray of shape (n_alphas,)	用于装配的字母网格。
cv_alphas_：array-like of shape (n_cv_alphas,)	沿路径不同折叠的所有alpha值
mse_path_：ndarray of shape (n_alphas, n_folds)	每个折叠上测试集的中误差，α变化。
n_iter_：int or list of int	坐标下降解算器为达到指定公差而运行的迭代次数。
active_：list of int	路径末端的活动变量的索引。

方法	解释
fit(X, y[, sample_weight])	拟合模型
get_params([deep])	获取此估计器的参数。
predict(X)	预测
score(X, y[, sample_weight])	返回预测的决定系数R^2。
set_params(**params)	设置此估计器的参数。

例子：

>>> 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.9992...
>>> reg.alpha_
0.0484...
>>> reg.predict(X[:1,])
array([-77.8723...])

1.1.3.2. 基于信息标准的模型选择【 linear_model.LassoLarsIC】

有多种选择时，估计器LassoLarsIC 建议使用 Akaike information criterion （Akaike 信息判据）（AIC）或 Bayes Information criterion （贝叶斯信息判据）（BIC）。 当使用 k-fold 交叉验证时，正则化路径只计算一次而不是 k + 1 次，所以找到 α 的最优值是一种计算上更经济的替代方法。 然而，这样的判据需要对解决方案的自由度进行适当的估计，它会假设模型是正确的，对大样本（渐近结果）进行导出，即数据实际上是由该模型生成的。 当问题严重受限（比样本更多的特征）时，它们也容易崩溃。

sklearn.linear_model.LassoLarsIC

参数	解释
criterion：{‘bic’ , ‘aic’}, default=’aic’	要使用的标准类型。
fit_intercept：bool, default=True	是否计算该模型的截距
verbose：bool or int, default=False	设置冗长量
normalize：bool, default=False	当fit_intercept=False时忽略此参数；若为True，则在回归前减去平均值并除以l2范数，对回归两X进行归一化；在normalize=False时，调用模型前，若希望标准化，使用sklearn.preprocessing.StandardScaler类
precompute：‘auto’, bool or array-like of shape (n_features, n_features), default=’auto’	是否使用预计算的Gram矩阵来加速计算。如果设置为“auto”，让我们决定。Gram矩阵也可以作为参数传递。对于稀疏输入，此选项始终为True以保持稀疏性。
max_iter：int, default=500	最大迭代次数
eps：float, default=np.finfo(float).eps	Cholesky对角因子计算中的机器精度正则化。对于病态严重的系统，增加这个值。与一些基于迭代优化的算法中的tol参数不同，该参数不控制优化的容差。
copy_X：bool, default=True	若为True，X会被复制，否则被覆盖
positive：bool, default=False	设置为True时，强制系数为正。

属性	解释
coef_：array-like of shape (n_features,)	估计的参数
intercept_：float or array of shape (n_targets,)	截距项
coef_path_：array-like of shape (n_features, n_alphas)	沿路径变化的系数值
alpha_：float	通过交叉验证选择的惩罚参数
alphas_：ndarray of shape (n_alphas,)	用于装配的字母网格。
n_iter_：int or list of int	坐标下降解算器为达到指定公差而运行的迭代次数。
criterion_：array-like of shape (n_alphas,)	所有alphas中信息标准（“aic”、“bic”）的值

方法	解释
fit(X, y[, sample_weight])	拟合模型
get_params([deep])	获取此估计器的参数。
predict(X)	预测
score(X, y[, sample_weight])	返回预测的决定系数R^2。
set_params(**params)	设置此估计器的参数。

例子：

>>> from sklearn import linear_model
>>> reg = linear_model.LassoLarsIC(criterion='bic')
>>> reg.fit([[-1, 1], [0, 0], [1, 1]], [-1.1111, 0, -1.1111])
LassoLarsIC(criterion='bic')
>>> print(reg.coef_)
[ 0.  -1.11...]

1.1.4. 多任务Lasso 【linear_model.MultiTaskLasso】

MultiTaskLasso 是一个估计多元回归稀疏系数的线性模型： y 是一个形状为(n_samples, n_tasks) 的二维数组，其约束条件和其他回归问题（也称为任务）是一样的，都是所选的特征值。

下图比较了通过使用简单的Lasso或MultiTaskLasso 得到的 W 中非零的位置。 Lasso估计产生分散的非零值，而 MultiTaskLasso 的一整列都是非零的。


在数学上，它由一个线性模型组成，以混合的 \ell_1 \ell_2 作为正则化器进行训练。目标函数最小化是：

其中 Fro 表示 Frobenius 标准：

并且 \ell_1 \ell_2 读取为:

MultiTaskLasso 类的实现使用了坐标下降作为拟合系数的算法。

sklearn.linear_model.MultiTaskLasso

参数	解释
alpha：float, default=1.0	乘以L1/L2项的常数。默认为1.0。
fit_intercept：bool, default=True	是否计算该模型的截距
normalize：bool, default=False	当fit_intercept=False时忽略此参数；若为True，则在回归前减去平均值并除以l2范数，对回归两X进行归一化；在normalize=False时，调用模型前，若希望标准化，使用sklearn.preprocessing.StandardScaler类
copy_X：bool, default=True	若为True，X会被复制，否则被覆盖
tol：float, default=1e-4	优化的容差：如果更新小于tol，优化代码将检查双重间隙的最佳性，并继续进行，直到它小于tol为止。
warm_start：bool, default=False	当设置为True时，重用上一个调用的解决方案以适应初始化，否则，只需擦除上一个解决方案。
random_state：int, RandomState instance, default=None	选择要更新的随机特征的伪随机数生成器的种子。当selection == ‘random’时使用。
selection：{‘cyclic’, ‘random’}, default=’cyclic’	如果设置为“随机”，随机系数在每次迭代时都会更新，而不是按顺序在特征上循环。这（设置为“随机”）通常会导致显著更快的收敛，尤其是当tol高于1e-4时

属性	解释
coef_：array-like of shape (n_features,)	估计的参数
intercept_：float or array of shape (n_targets,)	截距项
n_iter_：int or list of int	坐标下降解算器为达到指定公差而运行的迭代次数。
dual_gap_：ndarray of shape (n_alphas,)	每个alpha优化结束时的双间隙
eps_：float	由目标y的方差缩放的公差。
sparse_coef_：sparse matrix of shape (n_features,) or (n_tasks, n_features)	拟合系数的稀疏表示。

方法	解释
fit(X, y[, sample_weight])	拟合模型
get_params([deep])	获取此估计器的参数。
predict(X)	预测
score(X, y[, sample_weight])	返回预测的决定系数R^2。
set_params(**params)	设置此估计器的参数。
path(*args, **kwargs)	用坐标下降法计算弹性网络路径。

例子：

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

1.1.5. 弹性网络【linear_model.ElasticNetCV 】

弹性网络 是一种使用 L1， L2 范数作为先验正则项训练的线性回归模型。 这种组合允许拟合到一个只有少量参数是非零稀疏的模型，就像 Lasso 一样，但是它仍然保持了一些类似于 Ridge 的正则性质。我们可利用l1_ratio参数控制 L1 和 L2 的凸组合。

弹性网络在很多特征互相联系的情况下是非常有用的。Lasso 很可能只随机考虑这些特征中的一个，而弹性网络更倾向于选择两个。

在实践中，Lasso 和 Ridge 之间权衡的一个优势是它允许在循环过程（Under rotate）中继承 Ridge 的稳定性。

在这里，最小化的目标函数是

ElasticNetCV 类可以通过交叉验证来设置参数 alpha和l1_ratio。

sklearn.linear_model.ElasticNetCV

参数	解释
l1_ratio：float or list of float, default=0.5	传递给ElasticNet的介于0和1之间的浮动（在l1和l2惩罚之间缩放）。对于l1_ratio=0，惩罚为L2惩罚。对于l1_ratio=1，则为l1惩罚。对于0<l1_ratio<1，惩罚是l1和L2的组合。此参数可以是一个列表，在这种情况下，通过交叉验证测试不同的值，并使用给出最佳预测分数的值。请注意，l1_ratio的值列表的一个好选择通常是将更多的值放在接近1（即套索）而不是接近0（即脊线），如[.1，.5，.7，.9，.95，.99，1]。
eps：float, default=1e-3	路径的长度。eps=1e-3表示α_min/alpha_max=1e-3
n_alphas：int, default=100	沿正则化路径的字母数，用于每个l1_ratio。
alphas：ndarray, default=None	计算模型的alphas列表。如果没有自动设置
fit_intercept：bool, default=True	是否计算该模型的截距
normalize：bool, default=False	当fit_intercept=False时忽略此参数；若为True，则在回归前减去平均值并除以l2范数，对回归两X进行归一化；在normalize=False时，调用模型前，若希望标准化，使用sklearn.preprocessing.StandardScaler类
precompute：‘auto’, bool or array-like of shape (n_features, n_features), default=’auto’	是否使用预计算的Gram矩阵来加速计算。如果设置为“auto”，让我们决定。Gram矩阵也可以作为参数传递。对于稀疏输入，此选项始终为True以保持稀疏性。
max_iter：int, default=1000	最大迭代次数
tol：float, default=1e-4	优化的容差：如果更新小于tol，优化代码将检查双重间隙的最佳性，并继续进行，直到它小于tol为止。
cv：int, cross-validation generator or iterable, default=None	确定交叉验证拆分策略。
verbose：bool or int, default=False	冗长的程度。
copy_X：bool, default=True	若为True，X会被复制，否则被覆盖
verbose：bool or int, default=0	设置冗长量
n_jobs：int, default=None	线程数
positive：bool, default=False	设置为True时，强制系数为正。
random_state：int, RandomState instance, default=None	选择要更新的随机特征的伪随机数生成器的种子。当selection == ‘random’时使用。
selection：{‘cyclic’, ‘random’}, default=’cyclic’	如果设置为“随机”，随机系数在每次迭代时都会更新，而不是按顺序在特征上循环。这（设置为“随机”）通常会导致显著更快的收敛，尤其是当tol高于1e-4时

属性	解释
alpha_：float	通过交叉验证选择的惩罚参数。
l1_ratio_：float	通过交叉验证选择l1和l2惩罚之间的折衷。
coef_：array-like of shape (n_features,)	估计的参数
intercept_：float or array of shape (n_targets,)	截距项
mse_path_：ndarray of shape (n_alphas, n_folds)	改变l1_ratio和alpha时对于每个折叠的平均方差
alphas_：ndarray of shape (n_alphas,) or (n_l1_ratio, n_alphas)	对于每个l1_ratio用于拟合的alphas网格
dual_gap_：ndarray of shape (n_alphas,)	每个alpha优化结束时的双间隙
n_iter_：int or list of int	坐标下降解算器为达到指定公差而运行的迭代次数。

方法	解释
fit(X, y[, sample_weight])	拟合模型
get_params([deep])	获取此估计器的参数。
predict(X)	预测
score(X, y[, sample_weight])	返回预测的决定系数R^2。
set_params(**params)	设置此估计器的参数。
path(*args, **kwargs)	用坐标下降法计算弹性网络路径。

例子：

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

1.1.6. 多任务弹性网络【linear_model.MultiTaskElasticNet】

MultiTaskElasticNet 是一个对多回归问题估算稀疏参数的弹性网络: Y 是一个二维数组，形状是 (n_samples,n_tasks)。 其限制条件是和其他回归问题一样，是选择的特征，也称为 tasks 。

从数学上来说， 它包含一个混合的 ${\ell }_1{\ell }_2$ 先验和 ${\ell }_2$ 先验为正则项训练的线性模型 目标函数就是最小化:
$$\underset{W}{\min }$$