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 }\frac{1}{2n_{samples}}||XW-Y|{|}_{Fro}^2+\alpha \rho ||W|{|}_{21}+\frac{\alpha (1-\rho )}{2}||W|{|}_{Fro}^2$$
在 MultiTaskElasticNet 类中的实现采用了坐标下降法求解参数。

在 MultiTaskElasticNetCV 中可以通过交叉验证来设置参数 alpha （ $\alpha$ ） 和 l1_ratio （ $\rho$ ） 。

sklearn.linear_model.MultiTaskElasticNet

参数	解释
alpha:float, default=1.0	乘以L1/L2项的常数。默认为1.0
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]。
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=1000	最大迭代次数
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时

属性	解释
intercept_：float or array of shape (n_targets,)	截距项
coef_：array-like of shape (n_features,)	参数向量（成本函数公式中的W）。如果在fit（非多任务使用）中传入了1D y，那么coef_就是一个1D数组。注意coef_存储W，W的转置。
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.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]

1.1.7. 最小角回归【linear_model.Lars】

最小角回归 （LARS） 是对高维数据的回归算法， 由 Bradley Efron, Trevor Hastie, Iain Johnstone 和 Robert Tibshirani 开发完成。 LARS 和逐步回归很像。在每一步，它都寻找与响应最有关联的预测。当有很多预测有相同的关联时，它并不会继续利用相同的预测，而是在这些预测中找出应该等角的方向。

LARS的优点:

• 当 p >> n，该算法数值运算上非常有效。(例如当维度的数目远超点的个数)
• 它在计算上和前向选择一样快，和普通最小二乘法有相同的运算复杂度。
• 它产生了一个完整的分段线性的解决路径，在交叉验证或者其他相似的微调模型的方法上非常有用。
• 如果两个变量对响应几乎有相等的联系，则它们的系数应该有相似的增长率。因此这个算法和我们直觉 上的判断一样，而且还更加稳定。
• 它很容易修改并为其他估算器生成解，比如Lasso。

LARS 的缺点:

• 因为 LARS 是建立在循环拟合剩余变量上的，所以它对噪声非常敏感。这个问题，在 2004 年统计年鉴的文章由 Weisberg 详细讨论。

LARS 模型可以在 Lars ，或者它的底层实现 lars_path或 lars_path_gram中被使用。

sklearn.linear_model.Lars

参数	解释
fit_intercept：bool, default=True	是否计算该模型的截距
verbose：bool or int, default=0	设置冗长量
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以保持稀疏性。
n_nonzero_coefs：int, default=500	非零系数的目标数量。使用np.inf文件没有限制。
eps：float, default=np.finfo(float).eps	Cholesky对角因子计算中的机器精度正则化。对于病态严重的系统，增加这个值。与一些基于迭代优化的算法中的tol参数不同，该参数不控制优化的容差。
copy_X：bool, default=True	若为True，X会被复制，否则被覆盖
fit_path：bool, default=True	如果为True，则完整路径存储在coef_path_属性中。如果计算一个大问题或多个目标的解，将fit_ path设置为False将导致加速，特别是对于小alpha。
jitter：float, default=None	将均匀噪声参数的上界加到y值上，以满足模型的一次一次计算的假设。可能有助于稳定。
random_state：int, RandomState instance or None, default=None	确定用于抖动的随机数生成。在多个函数调用之间传递一个int以获得可复制的输出。

属性	解释
alphas_：array-like of shape (n_alphas + 1,) or list of thereof of shape (n_targets,)	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_：list of shape (n_alphas,) or list of thereof of shape (n_targets,)	路径末端活动变量的索引。
coef_path_：array-like of shape (n_features, n_alphas + 1) or list of thereof of shape (n_targets,)	沿路径变化的系数值。如果fit_path参数为False，则不存在。
coef_：array-like of shape (n_features,)	参数向量（成本函数公式中的W）
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)	设置此估计器的参数。

例子：

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

1.1.8. LARS Lasso【linear_model.LassoLars】

LassoLars 是一个使用 LARS 算法的 lasso 模型，不同于基于坐标下降法的实现，它可以得到一个精确解，也就是一个关于自身参数标准化后的一个分段线性解。
Lars 算法提供了一个几乎无代价的沿着正则化参数的系数的完整路径，因此常利用函数lars_path或 lars_path_gram来取回路径。

sklearn.linear_model.LassoLars

参数	解释
alpha：float, default=1.0	乘以惩罚项的常数。默认为1.0。α=0相当于一个普通的最小二乘法，用线性回归法求解。由于数值原因，不建议对LassoLars对象使用alpha=0
fit_intercept：bool, default=True	是否计算该模型的截距
verbose：bool or int, default=0	设置冗长量
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会被复制，否则被覆盖
fit_path：bool, default=True	如果为True，则完整路径存储在coef_path_属性中。如果计算一个大问题或多个目标的解，将fit_ path设置为False将导致加速，特别是对于小alpha。
positive：bool, default=False	设置为True时，强制系数为正。
jitter：float, default=None	将均匀噪声参数的上界加到y值上，以满足模型的一次一次计算的假设。可能有助于稳定。
random_state：int, RandomState instance or None, default=None	确定用于抖动的随机数生成。在多个函数调用之间传递一个int以获得可复制的输出。

属性	解释
alphas_：array-like of shape (n_alphas + 1,) or list of thereof of shape (n_targets,)	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_：list of shape (n_alphas,) or list of thereof of shape (n_targets,)	路径末端活动变量的索引。
coef_path_：array-like of shape (n_features, n_alphas + 1) or list of thereof of shape (n_targets,)	沿路径变化的系数值。如果fit_path参数为False，则不存在。
coef_：array-like of shape (n_features,)	参数向量（成本函数公式中的W）
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)	设置此估计器的参数。

例子：

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

1.1.8.1. 数学表达式

该算法和逐步回归非常相似，但是它没有在每一步包含变量，它估计的参数是根据与 其他剩余变量的联系来增加的。

在 LARS 的解中，没有给出一个向量的结果，而是给出一条曲线，显示参数向量的 L1 范式的每个值的解。 完全的参数路径存在coef_path_下。它的 size 是 (n_features, max_features+1)。 其中第一列通常是全 0 列。

1.1.9. 正交匹配追踪法（OMP）【linear_model.OrthogonalMatchingPursuit】

OrthogonalMatchingPursuit(正交匹配追踪法)和 orthogonal_mp使用了 OMP 算法近似拟合了一个带限制的线性模型，该限制影响于模型的非 0 系数(例：L0 范数)。

就像最小角回归一样，作为一个前向特征选择方法，正交匹配追踪法可以近似一个固定非 0 元素的最优向量解:
$$\text{argmin}||y-X\gamma |{|}_2^2\text{ subject to }||\gamma |{|}_0\le n_{nonzer{o}_{c}oefs}$$
正交匹配追踪法也可以针对一个特殊的误差而不是一个特殊的非零系数的个数。可以表示为:
$$\text{argmin}||\gamma |{|}_0\text{ subject to }||y-X\gamma |{|}_2^2\le \text{tol}$$
OMP 是基于每一步的贪心算法，其每一步元素都是与当前残差高度相关的。它跟较为简单的匹配追踪（MP）很相似，但是相比 MP 更好，在每一次迭代中，可以利用正交投影到之前选择的字典元素重新计算残差。

sklearn.linear_model.OrthogonalMatchingPursuit

参数	解释
n_nonzero_coefs：int, default=None	解决方案中所需的非零项数。如果没有（默认情况下），此值设置为n_功能的10%。
tol：float, default=None	残差的最大范数。如果不是None，则覆盖n_nonzero_coefs。
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以保持稀疏性。

属性	解释
coef_：array-like of shape (n_features,)	参数向量（成本函数公式中的W）
intercept_：float or array of shape (n_targets,)	截距项
n_iter_：int or list of int	坐标下降解算器为达到指定公差而运行的迭代次数。
n_nonzero_coefs_：int	解中非零系数的个数。如果n_nonzero_coefs为None且tol为None，则将该值设置为n_features的10%或1，以较大者为准。

方法	解释
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 OrthogonalMatchingPursuit
>>> from sklearn.datasets import make_regression
>>> X, y = make_regression(noise=4, random_state=0)
>>> reg = OrthogonalMatchingPursuit().fit(X, y)
>>> reg.score(X, y)
0.9991...
>>> reg.predict(X[:1,])
array([-78.3854...])

1.1.10. 贝叶斯回归

贝叶斯回归可以用于在预估阶段的参数正则化: 正则化参数的选择不是通过人为的选择，而是通过手动调节数据值来实现。

上述过程可以通过引入 无信息先验 到模型中的超参数来完成。 在 岭回归中使用的 ${\ell }_2$ 正则项相当于在 w 为高斯先验条件，且此先验的精确度为 ${\lambda }^{-1}$ 时，求最大后验估计。在这里，我们没有手工调参数 lambda ，而是让他作为一个变量，通过数据中估计得到。

为了得到一个全概率模型，输出 y 也被认为是关于 X w 的高斯分布。
$$p(y|X,w,\alpha )=\mathcal{N}(y|Xw,\alpha )$$
Alpha 在这里也是作为一个变量，通过数据中估计得到。

贝叶斯回归有如下几个优点:

• 它能根据已有的数据进行改变。
• 它能在估计过程中引入正则项。
• 贝叶斯回归有如下缺点:

它的推断过程是非常耗时的。

1.1.10.1. 贝叶斯岭回归【linear_model.BayesianRidge】

BayesianRidge 利用概率模型估算了上述的回归问题，其先验参数 w 是由以下球面高斯公式得出的：
$$p(w|\lambda )=\mathcal{N}(w|0,{\lambda }^{-1}{\mathbf{I}}_{\mathbf{p}})$$
先验参数$\alpha$和 $\lambda$ 一般是服从 gamma 分布 ，这个分布与高斯成共轭先验关系。 得到的模型一般称为 贝叶斯岭回归，并且这个与传统的 Ridge 非常相似。

参数 w ，$\alpha$ 和 $\lambda$ 是在模型拟合的时候一起被估算出来的，其中参数\alpha和\lambda通过最大似然估计得到。scikit-learn的实现是基于文献（Tipping，2001）的附录A，参数\alpha和\lambda的更新是基于文献（MacKay，1992）。

剩下的超参数${\alpha }_1$，${\alpha }_2$，${\gamma }_1$以及${\gamma }_2$是关于$\alpha$和 $\lambda$ 的 gamma 分布的先验。 它们通常被选择为 无信息先验 。默认${\alpha }_1={\alpha }_2={\lambda }_1={\lambda }_2=10^{-6}$。

由于贝叶斯框架的缘故，权值与 普通最小二乘法 产生的不太一样。 但是，贝叶斯岭回归对病态问题（ill-posed）的鲁棒性要更好。

sklearn.linear_model.BayesianRidge

参数	解释
n_iter：int, default=300	最大迭代次数。应大于或等于1。
tol：float, default=1e-3	如果w已收敛，则停止算法。
alpha_1：float, default=1e-6	超参数：伽马分布在α参数之上的形状参数。
alpha_2：float, default=1e-6	超参数：α参数上伽马分布的反比例参数（速率参数）。
lambda_1：float, default=1e-6	超参数：在lambda参数之上的伽马分布的形状参数。
lambda_2：float, default=1e-6	超参数：λ参数上伽马分布的反比例参数（速率参数）。
alpha_init：float, default=None	alpha的初始值（噪波的精度）。如果未设置，alpha_init为1/Var（y）。
lambda_init：float, default=None	Initial value for lambda (precision of the weights). If not set, lambda_init is 1
compute_score：bool, default=False	如果为真，则计算每次优化迭代的对数边际似然。
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会被复制，否则被覆盖
verbose：bool or int, default=0	设置冗长量

属性	解释
coef_：array-like of shape (n_features,)	参数向量（成本函数公式中的W）
intercept_：float or array of shape (n_targets,)	截距项
alpha_：float	噪声的估计精度。
lambda_：float	估计权重的精度。
sigma_：array-like of shape (n_features, n_features)	权值的估计方差协方差矩阵
scores_：array-like of shape (n_iter_+1,)	若compute_score为True，则在每次优化迭代时的对数边际似然值（最大化）。数组从alpha和lambda的初始值获得的对数边缘似然值开始，以估计的alpha和lambda的值结束。
n_iter_：int or list of int	达到停止条件的实际迭代次数。
X_offset_：float	如果normalize=True，则将中心数据的偏移量减去为零。
X_scale_：float	如果normalize=True，用于将数据缩放为单位标准差的参数。

方法	解释
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
>>> clf = linear_model.BayesianRidge()
>>> clf.fit([[0,0], [1, 1], [2, 2]], [0, 1, 2])
BayesianRidge()
>>> clf.predict([[1, 1]])
array([1.])

1.1.10.2. 主动相关决策理论 - ARD【linear_model.ARDRegression】

ARDRegression （主动相关决策理论）和 Bayesian Ridge Regression 非常相似，但是会导致一个更加稀疏的权重w[1][2] 。

使用ARD先验函数拟合回归模型的权重。假设回归模型的权重为高斯分布。同时估计参数lambda（权重分布的精度）和alpha（噪声分布的精度）。估计是通过迭代过程（证据最大化）完成的

ARDRegression 提出了一个不同的 w 的先验假设。具体来说，就是弱化了高斯分布为球形的假设。

它采用 w 分布是与轴平行的椭圆高斯分布。

也就是说，每个权值 $w_i$ 从一个中心在 0 点，精度为 ${\lambda }_i$ 的高斯分布中采样得到的。
$$p(w|\lambda )=\mathcal{N}(w|0,A^{-1})$$
并且 $diag(A)=\lambda ={\lambda }_1,...,{\lambda }_p$.

与Bayesian Ridge Regression_不同， 每个$w_i$ 都有一个标准差 ${\lambda }_i$ 。所有 ${\lambda }_i$ 的先验分布 由超参数 ${\lambda }_1$ 、 ${\lambda }_2$ 确定的相同的 gamma 分布确定。

ARD 也被称为稀疏贝叶斯学习 或 相关向量机 [3][4]。

sklearn.linear_model.ARDRegression

参数	解释
n_iter：int, default=300	最大迭代次数。应大于或等于1。
tol：float, default=1e-3	如果w已收敛，则停止算法。
alpha_1：float, default=1e-6	超参数：伽马分布在α参数之上的形状参数。
alpha_2：float, default=1e-6	超参数：α参数上伽马分布的反比例参数（速率参数）。
lambda_1：float, default=1e-6	超参数：在lambda参数之上的伽马分布的形状参数。
lambda_2：float, default=1e-6	超参数：λ参数上伽马分布的反比例参数（速率参数）。
compute_score：bool, default=False	如果为真，则计算每次优化迭代的对数边际似然。
threshold_lambda：float, default=10 000	从计算中高精度删除（修剪）权重的阈值。
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会被复制，否则被覆盖
verbose：bool or int, default=0	设置冗长量

属性	解释
coef_：array-like of shape (n_features,)	参数向量（成本函数公式中的W）
alpha_：float	噪声的估计精度。
lambda_：float	估计权重的精度。
sigma_：array-like of shape (n_features, n_features)	权值的估计方差协方差矩阵
scores_：array-like of shape (n_iter_+1,)	如果计算，目标函数的值（最大化）
intercept_：float or array of shape (n_targets,)	截距项
X_offset_：float	如果normalize=True，则将中心数据的偏移量减去为零。
X_scale_：float	如果normalize=True，用于将数据缩放为单位标准差的参数。

方法	解释
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
>>> clf = linear_model.ARDRegression()
>>> clf.fit([[0,0], [1, 1], [2, 2]], [0, 1, 2])
ARDRegression()
>>> clf.predict([[1, 1]])
array([1.])

1.1.11. logistic 回归【linear_model.LogisticRegression】

logistic 回归，虽然名字里有 “回归” 二字，但实际上是解决分类问题的一类线性模型。在某些文献中，logistic 回归又被称作 logit 回归，maximum-entropy classification（MaxEnt，最大熵分类），或 log-linear classifier（对数线性分类器）。该模型利用函数 logistic function 将单次试验（single trial）的可能结果输出为概率。

scikit-learn 中 logistic 回归在 LogisticRegression 类中实现了二分类（binary）、一对多分类（one-vs-rest）及多项式 logistic 回归，并带有可选的 L1 和 L2 正则化。

注意，scikit-learn的逻辑回归在默认情况下使用L2正则化，这样的方式在机器学习领域是常见的，在统计分析领域是不常见的。正则化的另一优势是提升数值稳定性。scikit-learn通过将C设置为很大的值实现无正则化。

作为优化问题，带 L2罚项的二分类 logistic 回归要最小化以下代价函数（cost function）：
$$\underset{w,c}{\min }\frac{1}{2}{w}^{T}w+C\sum _{i=1}^n\log (\exp (-y_i(X_i^{T}w+c))+1).$$
类似地，带 L1 正则的 logistic 回归解决的是如下优化问题：
$$\underset{w,c}{\min }|w{|}_1+C\sum _{i=1}^n\log (\exp (-y_i(X_i^{T}w+c))+1).$$
Elastic-Net正则化是L1 和 L2的组合，来使如下代价函数最小:
$$\underset{w,c}{\min }\frac{1-\rho }{2}{w}^{T}w+\rho |w{|}_1+C\sum _{i=1}^n\log (\exp (-y_i(X_i^{T}w+c))+1).$$
其中ρ控制正则化L1与正则化L2的强度(对应于l1_ratio参数)。

注意，在这个表示法中，假定目标$y_i$在测试时应属于集合[-1,1]。我们可以发现Elastic-Net在ρ=1时与L1罚项等价,在ρ=0时与L2罚项等价

在 LogisticRegression 类中实现了这些优化算法: liblinear， newton-cg，lbfgs， sag 和 saga。

liblinear应用了坐标下降算法（Coordinate Descent, CD），并基于 scikit-learn 内附的高性能 C++ 库 LIBLINEAR library 实现。不过 CD 算法训练的模型不是真正意义上的多分类模型，而是基于 “one-vs-rest” 思想分解了这个优化问题，为每个类别都训练了一个二元分类器。因为实现在底层使用该求解器的 LogisticRegression 实例对象表面上看是一个多元分类器。 sklearn.svm.l1_min_c 可以计算使用 L1时 C 的下界，以避免模型为空（即全部特征分量的权重为零）。

lbfgs, sag 和 newton-cg 求解器只支持 L2罚项以及无罚项，对某些高维数据收敛更快。这些求解器的参数 multi_class设为 multinomial 即可训练一个真正的多项式 logistic 回归 [5] ，其预测的概率比默认的 “one-vs-rest” 设定更为准确。

sag 求解器基于平均随机梯度下降算法（Stochastic Average Gradient descent） [6]。在大数据集上的表现更快，大数据集指样本量大且特征数多。

saga 求解器 [7] 是 sag 的一类变体，它支持非平滑（non-smooth）的 L1 正则选项 penalty=“l1” 。因此对于稀疏多项式 logistic 回归 ，往往选用该求解器。saga求解器是唯一支持弹性网络正则选项的求解器。

lbfgs是一种近似于Broyden–Fletcher–Goldfarb–Shanno算法[8]的优化算法，属于准牛顿法。lbfgs求解器推荐用于较小的数据集，对于较大的数据集，它的性能会受到影响。[9]

总的来说，各求解器特点如下:

罚项	liblinear	lbfgs	newton-cg	sag	saga
多项式损失+L2罚项	×	√	√	√	√
一对剩余（One vs Rest） + L2罚项	√	√	√	√	√
多项式损失 + L1罚项	×	×	×	×	√
一对剩余（One vs Rest） + L1罚项	√	×	×	×	√
弹性网络	×	×	×	×	√
无罚项	×	√	√	√	√
表现
惩罚偏置值(差)	√	×	×	×	×
大数据集上速度快	×	×	×	√	√
未缩放数据集上鲁棒	√	√	√	×	×

默认情况下，lbfgs求解器鲁棒性占优。对于大型数据集，saga求解器通常更快。对于大数据集，还可以用 SGDClassifier ，并使用对数损失（log loss）这可能更快，但需要更多的调优。

与 liblinear的区别:
当 fit_intercept=False 拟合得到的 coef_ 或者待预测的数据为零时，用 solver=liblinear的 LogisticRegression或 LinearSVC 与直接使用外部 liblinear 库预测得分会有差异。这是因为， 对于 decision_function 为零的样本， LogisticRegression 和LinearSVC 将预测为负类，而 liblinear 预测为正类。 注意，设定了fit_intercept=False，又有很多样本使得 decision_function 为零的模型，很可能会欠拟合，其表现往往比较差。建议您设置fit_intercept=True 并增大intercept_scaling 。

注意:利用稀疏 logistic 回归进行特征选择
带 L1罚项的 logistic 回归 将得到稀疏模型（sparse model），相当于进行了特征选择（feature selection），详情参见 基于 L1 的特征选取。

LogisticRegressionCV 对 logistic 回归 的实现内置了交叉验证（cross-validation），可以找出最优的 C和l1_ratio参数 。newton-cg， sag， saga 和 lbfgs 在高维数据上更快，这是因为采用了热启动（warm-starting）。

sklearn.linear_model.LogisticRegression

参数	解释
penalty：{‘l1’, ‘l2’, ‘elasticnet’, ‘none’}, default=’l2’	用于指定惩罚中使用的规范。“newton cg”、“sag”和“lbfgs”解算器仅支持l2惩罚。“elasticnet”仅由“saga”解算器支持。如果“none”（liblinear解算器不支持），则不应用正则化。
dual：bool, default=False	双重的或原始的公式。对偶公式仅适用于使用liblinear解算器的l2惩罚。当n_samples>n_features时，preferre dual=False。
tol：float, default=1e-4	如果w已收敛，则停止算法。
C：float, default=1.0	正则化强度的倒数；必须是正浮点数。与支持向量机一样，值越小，正则化越强。
fit_intercept：bool, default=True	是否计算该模型的截距
intercept_scaling：float, default=1	仅当使用解算器“liblinear”并且self.fit_截获设置为True。在这种情况下，x变成了[x，自截获缩放]也就是说，在实例向量中附加一个“synthetic”特征，该特征值等于intercept_scaling。截距变为intercept_scaling * synthetic_feature_weight。注意！合成特征权重和所有其他特征一样，都要经过l1/l2正则化。为了减少正则化对合成特征权重（因此对截距）的影响，必须增加intercept_scaling。
random_state：int, RandomState instance, default=None	当solver==‘sag’、'saga’或’liblinear’时使用，以洗牌数据。
solver：{‘newton-cg’, ‘lbfgs’, ‘liblinear’, ‘sag’, ‘saga’}, default=’lbfgs’	用于优化问题的算法。
max_iter：int, default=100	解算器收敛所需的最大迭代次数。
multi_class：{‘auto’, ‘ovr’, ‘multinomial’}, default=’auto’	如果选择的选项是“ovr”，则每个标签都适合一个二进制问题。对于“multinomial”，损失最小化是整个概率分布的多项式损失拟合，即使数据是二进制的。当“multinomial”不可用时。如果数据是二进制的，或者如果solver=‘liblinear’，则“auto”选择“ovr”，否则选择“multinomial”。
verbose：int, default=0	对于liblinear和lbfgs解算器，将verbose设置为任意正数以表示详细性。
warm_start：bool, default=False	当设置为True时，将上一个调用的解决方案重用为fit作为初始化，否则，只需删除以前的解决方案。
n_jobs：int, default=None	线程数
l1_ratio：float, default=None	弹性网络混合参数，0<=l1<=1。仅当惩罚=“elasticnet”时使用。设置l1_ratio=0相当于使用penalty=‘l2’，而设置l1_ratio=1等同于使用penalty=‘l1’。对于0<l1_比率<1，惩罚是l1和L2的组合。

属性	解释
classes_：ndarray of shape (n_classes, )	分类器已知的类标签列表。
coef_：ndarray of shape (1, n_features) or (n_classes, n_features)	参数向量（成本函数公式中的W）
intercept_：ndarray of shape (1,) or (n_classes,)	截距项
n_iter_：ndarray of shape (n_classes,) or (1, )	所有类的实际迭代次数。如果是二进制或多项式，它只返回1个元素。对于liblinear solver，只给出所有类的最大迭代次数。

方法	解释
decision_function(X)	预测样本的置信度得分。
densify()	将系数矩阵转换为密集数组格式。
fit(X, y[, sample_weight])	拟合模型
get_params([deep])	获取此估计器的参数。
predict(X)	预测
predict_log_proba(X)	预测概率估计的对数。
predict_proba(X)	概率估计。
score(X, y[, sample_weight])	返回预测的决定系数R^2。
set_params(**params)	设置此估计器的参数。
sparsify()	将系数矩阵转换为稀疏格式。

例子：

>>> from sklearn.datasets import load_iris
>>> from sklearn.linear_model import LogisticRegression
>>> X, y = load_iris(return_X_y=True)
>>> clf = LogisticRegression(random_state=0).fit(X, y)
>>> clf.predict(X[:2, :])
array([0, 0])
>>> clf.predict_proba(X[:2, :])
array([[9.8...e-01, 1.8...e-02, 1.4...e-08],
       [9.7...e-01, 2.8...e-02, ...e-08]])
>>> clf.score(X, y)
0.97...

1.1.12. 随机梯度下降， SGD【linear_model.SGDClassifier 和 linear_model.SGDRegressor】

随机梯度下降是拟合线性模型的一个简单而高效的方法。在样本量（和特征数）很大时尤为有用。 方法 partial_fit可用于 online learning （在线学习）或基于 out-of-core learning （外存的学习）

SGDClassifier 和 SGDRegressor 分别用于拟合分类问题和回归问题的线性模型，可使用不同的（凸）损失函数，支持不同的罚项。 例如，设定loss="log" ，则SGDClassifier 拟合一个逻辑斯蒂回归模型，而 loss="hinge" 拟合线性支持向量机（SVM）。

sklearn.linear_model.SGDClassifier

参数	解释
loss：str, default=’hinge’	要使用的损失函数。默认为“hinge”，这将提供一个线性支持向量机。可选项有‘hinge’, ‘log’, ‘modified_huber’, ‘squared_hinge’, ‘perceptron’, 或者回归损失函数: ‘squared_loss’, ‘huber’, ‘epsilon_insensitive’, or ‘squared_epsilon_insensitive’。“hinge”损失给出了logistic回归，一种概率分类器。“modified_huber”是另一个平滑损失，它能容忍异常值和概率估计值。“squared_hinge”与hinge类似，但受到二次惩罚。“感知器”是感知器算法使用的线性损耗。其他损失是为回归而设计的，但也可以用于分类；有关说明，请参阅SGDregrestor。
penalty：{‘l1’, ‘l2’, ‘elasticnet’, ‘none’}, default=’l2’	要使用的惩罚（又名正则化术语）。默认为“l2”，这是线性SVM模型的标准正则化器。“l1”和“elasticnet”可能会给模型（特征选择）带来“l2”无法实现的稀疏性。
alpha：float, default=0.0001	乘以正则项的常数。值越大，正则化越强。当学习率设为“最优”时，也用于计算学习率。
l1_ratio：float, default=0.15	弹性网络混合参数，0<=l1<=1。l1_ratio=0对应l1_ratio，l1_ratio=1对应l1。仅当penalty为“elasticnet”时使用。
fit_intercept：bool, default=True	是否计算该模型的截距
max_iter：int, default=1000	训练数据的最大传递次数（也称为epoch）。它只影响拟合方法中的行为，而不影响部分拟合方法中的行为。
tol：float, default=1e-3	如果w已收敛，则停止算法。
shuffle：bool, default=True	在每个epoch后，训练数据是否应该被洗牌。
verbose：int, default=0	对于liblinear和lbfgs解算器，将verbose设置为任意正数以表示详细性。
epsilon：float, default=0.1	epsilon-insensitive损失函数中的Epsilon；仅当损失为“huber”、“epsilon_insensitive”或“squared_Epsilon_unsensitive”时。对于“huber”，它决定了一个阈值，在该阈值下，准确预测变得不那么重要。对于epsilon-insensitive，如果当前预测与正确标签之间的任何差异小于此阈值，则将忽略这些差异。
n_jobs：int, default=None	线程数
random_state：int, RandomState instance, default=None	当shuffle设置为True时，用于洗牌数据。在多个函数调用之间传递一个int以获得可复制的输出。
learning_rate：str, default=’optimal’	学习率
eta0：double, default=0.0	‘constant’, ‘invscaling’ or ‘adaptive’ 计划的初始学习率。默认值为0.0，因为默认计划“最优”未使用eta0。
power_t：double, default=0.5	反向缩放学习速率的指数[默认值为0.5]。
early_stopping：bool, default=False	验证分数没有提高时，是否使用提前停止终止培训。
validation_fraction：float, default=0.1	作为早期停机验证设置的培训数据的比例。必须介于0和1之间。仅在early_stopping 为True时使用。
n_iter_no_change：int, default=5	在提前停止之前没有改进的迭代次数。
class_weight：dict, {class_label: weight} or “balanced”, default=None	class_weight fit 参数的预设值。与类关联的权重。如果没有给出，所有的类都应该有一个权重。
warm_start：bool, default=False	当设置为True时，将上一个调用的解决方案重用为fit作为初始化，否则，只需删除以前的解决方案。
average：bool or int, default=False	当设置为True时，计算所有更新的平均SGD权重，并将结果存储在coef_属性中。如果设置为大于1的整数，则当看到的样本总数达到平均值时，将开始平均。所以average=10将在看到10个样本后开始平均。

属性	解释
coef_：ndarray of shape (1, n_features) if n_classes == 2 else (n_classes, n_features)	为特征指定的权重。
intercept_：ndarray of shape (1,) if n_classes == 2 else (n_classes,)	截距项
n_iter_：int	达到停止标准之前的实际迭代次数。对于多类拟合，它是每个二进制拟合的最大值。
loss_function_：concrete LossFunction
classes_：array of shape (n_classes,)
t_：int	训练期间进行的权重更新次数

方法	解释
decision_function(X)	预测样本的置信度得分。
densify()	将系数矩阵转换为密集数组格式。
fit(X, y[, sample_weight])	拟合模型
get_params([deep])	获取此估计器的参数。
partial_fit(X, y[, classes, sample_weight])	对给定样本执行一个epoch的随机梯度下降。
predict(X)	预测
score(X, y[, sample_weight])	返回预测的决定系数R^2。
set_params(**params)	设置此估计器的参数。
sparsify()	将系数矩阵转换为稀疏格式。

例子：

>>> import numpy as np
>>> from sklearn.linear_model import SGDClassifier
>>> from sklearn.preprocessing import StandardScaler
>>> from sklearn.pipeline import make_pipeline
>>> X = np.array([[-1, -1], [-2, -1], [1, 1], [2, 1]])
>>> Y = np.array([1, 1, 2, 2])
>>> # Always scale the input. The most convenient way is to use a pipeline.
>>> clf = make_pipeline(StandardScaler(),
...                     SGDClassifier(max_iter=1000, tol=1e-3))
>>> clf.fit(X, Y)
Pipeline(steps=[('standardscaler', StandardScaler()),
                ('sgdclassifier', SGDClassifier())])
>>> print(clf.predict([[-0.8, -1]]))
[1]

sklearn.linear_model.SGDRegressor

参数	解释
loss：str, default=’squared_loss’	要使用的损失函数。可能的值是’squared_loss’、‘huber’、‘epsilon_insensitive’或’squared_epsilon_insensitive’。‘squared_loss’指的是普通最小二乘拟合，“huber”修改了‘squared_loss’通过从平方损失切换到超过epsilon距离的线性损失，减少了对异常值的校正。“epsilon_unsensitive”忽略小于epsilon的错误，并且是线性的；这是SVR中使用的损失函数。‘squared_epsilon_insensitive’ 是相同的，但在ε的公差后变为平方损失。
penalty：{‘l2’, ‘l1’, ‘elasticnet’}, default=’l2’	要使用的惩罚（又名正则化术语）。默认为“l2”，这是线性SVM模型的标准正则化器。“l1”和“elasticnet”可能会给模型（特征选择）带来“l2”无法实现的稀疏性。
alpha：float, default=0.0001	乘以正则项的常数。值越大，正则化越强。当learning_rate设为“optimal”时，也用于计算学习率。
l1_ratio：float, default=0.15	弹性网络混合参数，0<=l1<=1。l1_ratio=0对应l1_ratio，l1_ratio=1对应l1。仅当penalty为“elasticnet”时使用。
fit_intercept：bool, default=True	是否计算该模型的截距
max_iter：int, default=1000	训练数据的最大传递次数（也称为epoch）。它只影响拟合方法中的行为，而不影响部分拟合方法中的行为。
tol：float, default=1e-3	如果w已收敛，则停止算法。
shuffle：bool, default=True	在每个epoch之后，训练数据是否应该被洗牌。
verbose：int, default=0	对于liblinear和lbfgs解算器，将verbose设置为任意正数以表示详细性。
epsilon：float, default=0.1	epsilon-insensitive损失函数中的Epsilon；仅当损失为“huber”、“epsilon_insensitive”或“squared_Epsilon_unsensitive”时。对于“huber”，它决定了一个阈值，在该阈值下，准确预测变得不那么重要。对于epsilon-insensitive，如果当前预测与正确标签之间的任何差异小于此阈值，则将忽略这些差异。
random_state：int, RandomState instance, default=None	当shuffle设置为True时，用于洗牌数据。在多个函数调用之间传递一个int以获得可复制的输出。
learning_rate：string, default=’invscaling’	学习率
eta0：double, default=0.0	‘constant’, ‘invscaling’ or ‘adaptive’ 计划的初始学习率。默认值为0.0，因为默认计划“最优”未使用eta0。
power_t：double, default=0.5	反向缩放学习速率的指数[默认值为0.5]。
early_stopping：bool, default=False	验证分数没有提高时，是否使用提前停止终止培训。
validation_fraction：float, default=0.1	作为早期停机验证设置的培训数据的比例。必须介于0和1之间。仅在early_stopping 为True时使用。
n_iter_no_change：int, default=5	在提前停止之前没有改进的迭代次数。
warm_start：bool, default=False	当设置为True时，将上一个调用的解决方案重用为fit作为初始化，否则，只需删除以前的解决方案。
average：bool or int, default=False	当设置为True时，计算所有更新的平均SGD权重，并将结果存储在coef_属性中。如果设置为大于1的整数，则当看到的样本总数达到平均值时，将开始平均。所以average=10将在看到10个样本后开始平均。

属性	解释
coef_：ndarray of shape (n_features,)	为特征指定的权重。
intercept_：ndarray of shape (1,)	截距项
average_coef_：”ndarray of shape (n_features,)	分配给特征的平均权重。仅在average=True时可用
average_intercept_：ndarray of shape (1,)	平均截距项。仅在average=True时可用
t_：int	训练期间进行的权重更新次数
n_iter_：int	达到停止标准之前的实际迭代次数。对于多类拟合，它是每个二进制拟合的最大值。

方法	解释
densify()	将系数矩阵转换为密集数组格式。
fit(X, y[, sample_weight])	拟合模型
get_params([deep])	获取此估计器的参数。
partial_fit(X, y[, classes, sample_weight])	对给定样本执行一个epoch的随机梯度下降。
predict(X)	预测
score(X, y[, sample_weight])	返回预测的决定系数R^2。
set_params(**params)	设置此估计器的参数。
sparsify()	将系数矩阵转换为稀疏格式。

例子：

>>> import numpy as np
>>> from sklearn.linear_model import SGDRegressor
>>> from sklearn.pipeline import make_pipeline
>>> from sklearn.preprocessing import StandardScaler
>>> n_samples, n_features = 10, 5
>>> rng = np.random.RandomState(0)
>>> y = rng.randn(n_samples)
>>> X = rng.randn(n_samples, n_features)
>>> # Always scale the input. The most convenient way is to use a pipeline.
>>> reg = make_pipeline(StandardScaler(),
...                     SGDRegressor(max_iter=1000, tol=1e-3))
>>> reg.fit(X, y)
Pipeline(steps=[('standardscaler', StandardScaler()),
                ('sgdregressor', SGDRegressor())])

1.1.13. Perceptron（感知器）【linear_model.Perceptron】

Perceptron 是适用于大规模学习的一种简单算法。默认情况下：

• 不需要设置学习率（learning rate）。
• 不需要正则化处理。
• 仅使用错误样本更新模型。

最后一点表明使用合页损失（hinge loss）的感知机比 SGD 略快，所得模型更稀疏。

sklearn.linear_model.Perceptron

参数	解释
penalty：{‘l1’, ‘l2’, ‘elasticnet’, ‘none’}, default=’l2’	要使用的惩罚（又名正则化术语）。
alpha：float, default=0.0001	乘以正则项的常数。值越大，正则化越强。当学习率设为“最优”时，也用于计算学习率。
l1_ratio：float, default=0.15	弹性网络混合参数，0<=l1<=1。l1_ratio=0对应L2惩罚，l1_ratio=1对应l1。仅当penalty为“elasticnet”时使用。
fit_intercept：bool, default=True	是否计算该模型的截距
max_iter：int, default=1000	训练数据的最大传递次数（也称为epoch）。它只影响拟合方法中的行为，而不影响部分拟合方法中的行为。
tol：float, default=1e-3	如果w已收敛，则停止算法。
shuffle：bool, default=True	在每个历元之后，训练数据是否应该被洗牌。
verbose：int, default=0	详细程度
eta0：double, default=1	更新乘以的常数。
n_jobs：int, default=None	线程数
random_state：int, RandomState instance, default=None	当shuffle设置为True时，用于洗牌数据。在多个函数调用之间传递一个int以获得可复制的输出。
early_stopping：bool, default=False	验证分数没有提高时，是否使用提前停止终止培训。
validation_fraction：float, default=0.1	作为早期停机验证设置的培训数据的比例。必须介于0和1之间。仅在“早停”为真时使用。
n_iter_no_change：int, default=5	在提前停止之前没有改进的迭代次数。
class_weight：dict, {class_label: weight} or “balanced”, default=None	class_weight fit 参数的预设值。与类关联的权重。如果没有给出，所有的类都应该有一个权重。
warm_start：bool, default=False	当设置为True时，将上一个调用的解决方案重用为fit作为初始化，否则，只需删除以前的解决方案。

属性	解释
classes_：ndarray of shape (n_classes,)	唯一的类标签。
coef_：ndarray of shape (1, n_features) if n_classes == 2 else (n_classes, n_features)	为特征指定的权重。
intercept_：ndarray of shape (1,) if n_classes == 2 else (n_classes,)	截距项
loss_function_：concrete LossFunction	确定算法输出与目标值之间的损失或差异的函数。
n_iter_：int	达到停止标准之前的实际迭代次数。对于多类拟合，它是每个二进制拟合的最大值。
t_：int	训练期间进行的权重更新次数

方法	解释
decision_function(X)	预测样本的置信度得分。
densify()	将系数矩阵转换为密集数组格式。
fit(X, y[, sample_weight])	拟合模型
get_params([deep])	获取此估计器的参数。
partial_fit(X, y[, classes, sample_weight])	对给定样本执行一个epoch的随机梯度下降。
predict(X)	预测
score(X, y[, sample_weight])	返回预测的决定系数R^2。
set_params(**params)	设置此估计器的参数。
sparsify()	将系数矩阵转换为稀疏格式。

例子：

>>> from sklearn.datasets import load_digits
>>> from sklearn.linear_model import Perceptron
>>> X, y = load_digits(return_X_y=True)
>>> clf = Perceptron(tol=1e-3, random_state=0)
>>> clf.fit(X, y)
Perceptron()
>>> clf.score(X, y)
0.939...

1.1.14. Passive Aggressive Algorithms（被动攻击算法）【linear_model.PassiveAggressiveClassifier和linear_model.PassiveAggressiveRegressor】

被动攻击算法是大规模学习的一类算法。和感知机类似，它也不需要设置学习率，不过比感知机多出一个正则化参数 C 。

对于分类问题，PassiveAggressiveClassifier 可设定 loss='hinge'（PA-I）或 loss='squared_hinge'（PA-II）。对于回归问题， PassiveAggressiveRegressor 可设置loss='epsilon_insensitive'（PA-I）或 loss='squared_epsilon_insensitive'（PA-II）。

sklearn.linear_model.PassiveAggressiveClassifier

参数	解释
C：float, default=1.0	最大步长（正则化）。默认为1.0。
fit_intercept：bool, default=True	是否计算该模型的截距
max_iter：int, default=1000	训练数据的最大传递次数（也称为epoch）。它只影响拟合方法中的行为，而不影响部分拟合方法中的行为。
tol：float, default=1e-3	停止标准。如果不是“None”，则迭代将在（loss>previous_ loss-tol）时停止
early_stopping：bool, default=False	验证分数没有提高时，是否使用提前停止终止训练。
validation_fraction：float, default=0.1	作为早期停机验证设置的培训数据的比例。必须介于0和1之间。仅在“早停”为真时使用。
n_iter_no_change：int, default=5	在提前停止之前没有改进的迭代次数。
shuffle：bool, default=True	在每个历元之后，训练数据是否应该被洗牌。
verbose：int, default=0	详细程度
loss：string, default=”hinge”	损失函数
n_jobs：int, default=None	线程数
random_state：int, RandomState instance, default=None	当shuffle设置为True时，用于洗牌数据。在多个函数调用之间传递一个int以获得可复制的输出。
warm_start：bool, default=False	当设置为True时，将上一个调用的解决方案重用为fit作为初始化，否则，只需删除以前的解决方案。
class_weight：dict, {class_label: weight} or “balanced”, default=None	class_weight fit 参数的预设值。与类关联的权重。如果没有给出，所有的类都应该有一个权重。
average：bool or int, default=False	当设置为True时，计算平均SGD权重并将结果存储在coef_属性中。如果设置为大于1的整数，则当看到的样本总数达到平均值时，将开始平均。所以average=10将在看到10个样本后开始平均。

属性	解释
coef_：array, shape = [1, n_features] if n_classes == 2 else [n_classes, n_features]	为特征指定的权重。
intercept_：ndarray of shape (1,) if n_classes == 2 else (n_classes,)	截距项
n_iter_：int	达到停止标准之前的实际迭代次数。对于多类拟合，它是每个二进制拟合的最大值。
classes_：ndarray of shape (n_classes,)	唯一的类标签。
t_：int	训练期间进行的权重更新次数
loss_function_：callable	算法使用的损失函数。

方法	解释
decision_function(X)	预测样本的置信度得分。
densify()	将系数矩阵转换为密集数组格式。
fit(X, y[, sample_weight])	拟合模型
get_params([deep])	获取此估计器的参数。
partial_fit(X, y[, classes, sample_weight])	对给定样本执行一个epoch的随机梯度下降。
predict(X)	预测
score(X, y[, sample_weight])	返回预测的决定系数R^2。
set_params(**params)	设置此估计器的参数。
sparsify()	将系数矩阵转换为稀疏格式。

例子：

>>> from sklearn.linear_model import PassiveAggressiveClassifier
>>> from sklearn.datasets import make_classification
>>> X, y = make_classification(n_features=4, random_state=0)
>>> clf = PassiveAggressiveClassifier(max_iter=1000, random_state=0,
... tol=1e-3)
>>> clf.fit(X, y)
PassiveAggressiveClassifier(random_state=0)
>>> print(clf.coef_)
[[0.26642044 0.45070924 0.67251877 0.64185414]]
>>> print(clf.intercept_)
[1.84127814]
>>> print(clf.predict([[0, 0, 0, 0]]))
[1]

sklearn.linear_model.PassiveAggressiveRegressor

参数	解释
C：float, default=1.0	最大步长（正则化）。默认为1.0。
fit_intercept：bool, default=True	是否计算该模型的截距
max_iter：int, default=1000	训练数据的最大传递次数（也称为epoch）。它只影响拟合方法中的行为，而不影响部分拟合方法中的行为。
tol：float, default=1e-3	停止标准。如果不是“None”，则迭代将在（loss>previous_ loss-tol）时停止
early_stopping：bool, default=False	验证分数没有提高时，是否使用提前停止终止训练。
validation_fraction：float, default=0.1	作为早期停机验证设置的培训数据的比例。必须介于0和1之间。仅在“早停”为真时使用。
n_iter_no_change：int, default=5	在提前停止之前没有改进的迭代次数。
shuffle：bool, default=True	在每个历元之后，训练数据是否应该被洗牌。
verbose：int, default=0	详细程度
loss：default=”epsilon_insensitive”	损失函数
epsilon：float, default=DEFAULT_EPSILON	如果当前预测与正确标签之间的差异低于此阈值，则不会更新模型。
random_state：int, RandomState instance, default=None	当shuffle设置为True时，用于洗牌数据。在多个函数调用之间传递一个int以获得可复制的输出。
warm_start：bool, default=False	当设置为True时，将上一个调用的解决方案重用为fit作为初始化，否则，只需删除以前的解决方案。
average：bool or int, default=False	当设置为True时，计算平均SGD权重并将结果存储在coef_属性中。如果设置为大于1的整数，则当看到的样本总数达到平均值时，将开始平均。所以average=10将在看到10个样本后开始平均。

属性	解释
coef_：array, shape = [1, n_features] if n_classes == 2 else [n_classes, n_features]	为特征指定的权重。
intercept_：ndarray of shape (1,) if n_classes == 2 else (n_classes,)	截距项
n_iter_：int	达到停止标准之前的实际迭代次数。对于多类拟合，它是每个二进制拟合的最大值。
t_：int	训练期间进行的权重更新次数

方法	解释
decision_function(X)	预测样本的置信度得分。
densify()	将系数矩阵转换为密集数组格式。
fit(X, y[, sample_weight])	拟合模型
get_params([deep])	获取此估计器的参数。
partial_fit(X, y[, classes, sample_weight])	对给定样本执行一个epoch的随机梯度下降。
predict(X)	预测
score(X, y[, sample_weight])	返回预测的决定系数R^2。
set_params(**params)	设置此估计器的参数。
sparsify()	将系数矩阵转换为稀疏格式。

例子：

>>> from sklearn.linear_model import PassiveAggressiveRegressor
>>> from sklearn.datasets import make_regression
>>>
>>> X, y = make_regression(n_features=4, random_state=0)
>>> regr = PassiveAggressiveRegressor(max_iter=100, random_state=0,
... tol=1e-3)
>>> regr.fit(X, y)
PassiveAggressiveRegressor(max_iter=100, random_state=0)
>>> print(regr.coef_)
[20.48736655 34.18818427 67.59122734 87.94731329]
>>> print(regr.intercept_)
[-0.02306214]
>>> print(regr.predict([[0, 0, 0, 0]]))
[-0.02306214]

1.1.15. 稳健回归（Robustness regression）: 处理离群点（outliers）和模型错误

稳健回归（robust regression）特别适用于回归模型包含损坏数据（corrupt data）的情况，如离群点或模型中的错误。

1.1.15.1. 各种使用场景与相关概念

处理包含离群点的数据时牢记以下几点:

• 离群值在 X 上还是在 y 方向上?

  • 离群值在 y 方向上
    
  • 离群值在 X 方向上
    

• 离群点的比例 vs. 错误的量级（amplitude）
  离群点的数量很重要，离群程度也同样重要。
  • 低离群点的数量
    
  • 高离群点的数量
    
    稳健拟合（robust fitting）的一个重要概念是崩溃点（breakdown point），即拟合模型（仍准确预测）所能承受的离群值最大比例。

注意，在高维数据条件下（ n_features大），一般而言很难完成稳健拟合，很可能完全不起作用。

寻找平衡： 预测器的选择 * Scikit-learn提供了三种稳健回归的预测器（estimator）: RANSAC ， Theil Sen 和 HuberRegressor

• HuberRegressor 一般快于 RANSAC 和Theil Sen ，除非样本数很大，即 n_samples >> n_features 。 这是因为 RANSAC 和 Theil Sen 都是基于数据的较小子集进行拟合。但使用默认参数时， Theil Sen 和 RANSAC 可能不如 HuberRegressor 鲁棒。
• RANSAC 比 Theil Sen 更快，在样本数量上的伸缩性（适应性）更好。
• RANSAC 能更好地处理y方向的大值离群点（通常情况下）。
• Theil Sen 能更好地处理x方向中等大小的离群点，但在高维情况下无法保证这一特点。 实在决定不了的话，请使用 RANSAC

1.1.15.2. RANSAC： 随机抽样一致性算法（RANdom SAmple Consensus）【linear_model.RANSACRegressor】

随机抽样一致性算法（RANdom SAmple Consensus， RANSAC）利用全体数据中局内点（inliers）的一个随机子集拟合模型。

RANSAC 是一种非确定性算法，以一定概率输出一个可能的合理结果，依赖于迭代次数（参数 max_trials）。这种算法主要解决线性或非线性回归问题，在计算机视觉摄影测绘领域尤为流行。

算法从全体样本输入中分出一个局内点集合，全体样本可能由于测量错误或对数据的假设错误而含有噪点、离群点。最终的模型仅从这个局内点集合中得出。

1.1.15.2.1. 算法细节

每轮迭代执行以下步骤:

1. 从原始数据中抽样 min_samples 数量的随机样本，检查数据是否合法（见is_data_valid ）。
2. 用一个随机子集拟合模型（ base_estimator.fit ）。检查模型是否合法（见 is_model_valid ）。
3. 计算预测模型的残差（residual），将全体数据分成局内点和离群点（base_estimator.predict(X) - y ）。绝对残差小于 residual_threshold 的全体数据认为是局内点。
4. 若局内点样本数最大，保存当前模型为最佳模型。以免当前模型离群点数量恰好相等（而出现未定义情况），规定仅当数值大于当前最值时认为是最佳模型。
5. 上述步骤或者迭代到最大次数（ max_trials ），或者某些终止条件满足时停下（见 stop_n_inliers 和 stop_score )。最终模型由之前确定的最佳模型的局内点样本（一致性集合，consensus set）预测。

函数 is_data_valid和is_model_valid 可以识别出随机样本子集中的退化组合（degenerate combinations）并予以丢弃（reject）。即便不需要考虑退化情况，也会使用is_data_valid ，因为在拟合模型之前调用它能得到更高的计算性能。

sklearn.linear_model.RANSACRegressor

参数	解释
base_estimator：object, default=None	基本估计器对象，实现以方法fit(X, y)，score(X, y)，predict(X)，如果 base_estimator是None，则对数据类型float的目标值使用线性回归。注意，当前的实现只支持回归估计。
min_samples：int (>= 1) or float ([0, 1]), default=None	从原始数据中随机选择的最小样本数。对于min_samples>=1，视为绝对样本数；对于min_samples<1，则视为相对数ceil（min_samples*X.shape[0]）。通常情况下，选择最小样本数作为估计基。
residual_threshold：float, default=None	要分类为内联线的数据样本的最大残差。默认情况下，阈值被选为目标值y的MAD（中值绝对偏差）。
is_data_valid：callable, default=None	在模型拟合之前，使用随机选择的数据调用此函数：is_data_valid（X，y）。如果返回值为False，则跳过当前随机选择的子样本。
is_model_valid：callable, default=None	使用估计模型和随机选择的数据调用此函数：is_model_valid(model, X, y)，如果返回值为False，则跳过当前随机选择的子样本。使用此函数拒绝样本比使用is_data_valid计算成本更高。因此，只有在作出拒绝决定需要估计的模型时，才应使用is_model_valid。
max_trials：int, default=100	随机样本选择的最大迭代次数。
max_skips：int, default=np.inf	由于找到由is_data_valid定义的零内接程序或无效数据而可以跳过的最大迭代次数。
stop_n_inliers：int, default=np.inf	如果找到至少这个数量的内联线，则停止迭代。
stop_score：float, default=np.inf	如果分数大于此阈值，则停止迭代。
stop_probability：float in range [0, 1], default=0.99	若在RANSAC中至少有一个无离群点的训练数据集被采样，则RANSAC迭代停止。这需要至少生成N个样本（迭代）：$N>=log(1-probability)/log(1-e\ast \ast m)$，其中，概率（置信度）通常设置为高值，例如0.99（默认值），e是内联线的当前分数w.r.t.样本总数。
loss：string, callable, default=’absolute_loss’	支持字符串输入“absolute_loss”和“squared_loss”，分别计算每个样本的绝对损失和平方损失。如果loss是一个可调用的函数，那么它应该是一个以两个数组作为输入的函数，即真值和预测值，并返回一个一维数组，该数组的第i个值对应于X[i]上的损失。如果样本的损失大于残差阈值，则该样本被归类为异常值。
random_state：int, RandomState instance, default=None	用来初始化中心的生成器。在多个函数调用之间传递一个int以获得可复制的输出。

属性	解释
estimator_：object	最佳拟合模型（基本估计对象的副本）。
n_trials_：int	随机选择试验的次数，直到满足其中一个停止标准。它总是<=max_trials
inlier_mask_：bool array of shape [n_samples]	分类为True的inliner的布尔掩码。
n_skips_no_inliers_：int	由于找到零内接程序而跳过的迭代数。
n_skips_invalid_data_：int	由is_data_valid定义的无效数据而跳过的迭代次数
n_skips_invalid_model_：int	由于is_model_valid定义的模型无效而跳过的迭代次数。

方法	解释
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 RANSACRegressor
>>> from sklearn.datasets import make_regression
>>> X, y = make_regression(
...     n_samples=200, n_features=2, noise=4.0, random_state=0)
>>> reg = RANSACRegressor(random_state=0).fit(X, y)
>>> reg.score(X, y)
0.9885...
>>> reg.predict(X[:1,])
array([-31.9417...])

1.1.15.3. Theil-Sen 预估器: 广义中值估计器（generalized-median-based estimator）【linear_model.TheilSenRegressor】

TheilSenRegressor 估计器：使用中位数在多个维度泛化，对多元异常值更具有鲁棒性，但问题是，随着维数的增加，估计器的准确性在迅速下降。准确性的丢失，导致在高维上的估计值比不上普通的最小二乘法。

1.1.15.3.1. 算法理论细节

TheilSenRegressor 在渐近效率和无偏估计方面足以媲美 Ordinary Least Squares (OLS) （普通最小二乘法（OLS））。与 OLS 不同的是， Theil-Sen 是一种非参数方法，这意味着它没有对底层数据的分布假设。由于 Theil-Sen 是基于中值的估计，它更适合于损坏的数据即离群值。 在单变量的设置中，Theil-Sen 在简单的线性回归的情况下，其崩溃点大约 29.3% ，这意味着它可以容忍任意损坏的数据高达 29.3% 。
scikit-learn 中实现的 TheilSenRegressor 是多元线性回归模型的推广 [8] ，利用了空间中值方法，它是多维中值的推广 [9] 。

关于时间复杂度和空间复杂度，Theil-Sen 的尺度根据
$$\left(\genfrac{}{}{0ex}{}{n_{samples}}{n_{subsamples}}\right)$$
这使得它不适用于大量样本和特征的问题。因此，可以选择一个亚群的大小来限制时间和空间复杂度，只考虑所有可能组合的随机子集。

sklearn.linear_model.TheilSenRegressor

参数	解释
fit_intercept：bool, default=True	是否计算该模型的截距
copy_X：bool, default=True	如果为True，X将被复制；否则，它可能被覆盖。
max_subpopulation：int, default=1e4	与其用一组基数“n choose k”计算，其中n是样本数，k是子样本数（至少是特征数），如果“n choose k”大于max_subpopulation，则只考虑给定最大大小的随机子种群。对于较小的问题大小，如果n_subsamples没有改变，此参数将确定内存使用和运行时。
n_subsamples：int, default=None	计算参数的样本数。这至少是特征数（如果fit_intercept=True，则加1）和最大样本数。数值越小，击穿点越高，效率越低；数值越大，击穿点越低，效率越高。如果没有，则取最小数量的子样本，以获得最大的鲁棒性。如果n_subsamples设置为n_samples，则Theil Sen与最小二乘法相同。
max_iter：int, default=300	计算空间中值的最大迭代次数。
tol：float, default=1.e-3	计算空间中值时的公差。
random_state：int, RandomState instance, default=None	一个随机数生成器实例，用于定义随机排列生成器的状态。在多个函数调用之间传递一个int以获得可复制的输出。
n_jobs：int, default=None	线程数，交叉验证期间要使用的CPU数。
verbose：int, default=0	详细程度

属性	解释
coef_：ndarray of shape (n_features,)	为特征指定的权重。
intercept_：float	截距项
breakdown_：float	近似崩溃点。
n_iter_：int	达到停止标准之前的实际迭代次数。对于多类拟合，它是每个二进制拟合的最大值。
n_subpopulation_：int	从“n选择k”中考虑的组合数，其中n是样本数，k是子样本数。

方法	解释
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 TheilSenRegressor
>>> from sklearn.datasets import make_regression
>>> X, y = make_regression(
...     n_samples=200, n_features=2, noise=4.0, random_state=0)
>>> reg = TheilSenRegressor(random_state=0).fit(X, y)
>>> reg.score(X, y)
0.9884...
>>> reg.predict(X[:1,])
array([-31.5871...])

1.1.15.4. Huber 回归【linear_model.HuberRegresso】

HuberRegressor与 Ridge 不同，因为它对于被分为异常值的样本应用了一个线性损失。如果这个样品的绝对误差小于某一阈值，样品就被分为内围值。 它不同于 TheilSenRegressor 和 RANSACRegressor ，因为它没有忽略异常值的影响，并分配给它们较小的权重。

这个HuberRegressor最小化的损失函数是：
$$\underset{w,\sigma }{\min }\sum _{i=1}^n\left(\sigma +H_m\left(\frac{X_{i}w-y_i}{\sigma }\right)\sigma \right)+\alpha {||w|{|}_2}^2$$
其中
$$H_m(z)=\{\begin{array}{llc}{z}^2,& \text{if }|z|<ϵ,2ϵ|z|-{ϵ}^2,& \text{otherwise}\end{array}$$
建议设置参数 epsilon 为 1.35 以实现 95% 统计效率。

sklearn.linear_model.HuberRegressor

参数	解释
epsilon：float, greater than 1.0, default=1.35	参数epsilon控制应归类为异常值的样本数。epsilon越小，它对异常值的鲁棒性就越强。
max_iter：int, default=100	计算空间中值的最大迭代次数。
alpha：float, default=0.0001	正则化参数。
warm_start：bool, default=False	当设置为True时，将上一个调用的解决方案重用为fit作为初始化，否则，只需删除以前的解决方案。
fit_intercept：bool, default=True	是否计算该模型的截距
tol：float, default=1.e-05	当$max\Vert proj{g}_i\Vert i=1,...,n<=tol$时，迭代将停止，其中pg_i是投影梯度的第i个分量。

属性	解释
coef_：ndarray of shape (n_features,)	为特征指定的权重。
intercept_：float	偏差
scale_：float	按比例缩小$\Vert y-X^{\prime }w-c\Vert$的值。
n_iter_：int	迭代次数scipy.optimize.minimize.最小化（method=“L-BFGS-B”）已运行。
outliers_:array, shape (n_samples,)	设置为真的布尔掩码，其中样本被标识为离群值。

方法	解释
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 HuberRegressor, LinearRegression
>>> from sklearn.datasets import make_regression
>>> rng = np.random.RandomState(0)
>>> X, y, coef = make_regression(
...     n_samples=200, n_features=2, noise=4.0, coef=True, random_state=0)
>>> X[:4] = rng.uniform(10, 20, (4, 2))
>>> y[:4] = rng.uniform(10, 20, 4)
>>> huber = HuberRegressor().fit(X, y)
>>> huber.score(X, y)
-7.284...
>>> huber.predict(X[:1,])
array([806.7200...])
>>> linear = LinearRegression().fit(X, y)
>>> print("True coefficients:", coef)
True coefficients: [20.4923...  34.1698...]
>>> print("Huber coefficients:", huber.coef_)
Huber coefficients: [17.7906... 31.0106...]
>>> print("Linear Regression coefficients:", linear.coef_)
Linear Regression coefficients: [-1.9221...  7.0226...]

1.1.15.5. 注意

HuberRegressor 与将损失设置为 huber的 SGDRegressor 并不相同，体现在以下方面的使用方式上。

• HuberRegressor 是标度不变性的. 一旦设置了 epsilon ， 通过不同的值向上或向下缩放 X 和 y ，就会跟以前一样对异常值产生同样的鲁棒性。相比 SGDRegressor 其中epsilon 在 X 和 y 被缩放的时候必须再次设置。
• HuberRegressor 应该更有效地使用在小样本数据，同时SGDRegressor 需要一些训练数据的passes 来产生一致的鲁棒性。

1.1.16. 多项式回归：用基函数展开线性模型【preprocessing.PolynomialFeatures】

机器学习中一种常见的模式，是使用线性模型训练数据的非线性函数。这种方法保持了一般快速的线性方法的性能，同时允许它们适应更广泛的数据范围。

例如，可以通过构造系数的 polynomial features 来扩展一个简单的线性回归。在标准线性回归的情况下，你可能有一个类似于二维数据的模型:
$$\hat{y}(w,x)=w_0+w_1{x}_1+w_2{x}_2$$
如果我们想把抛物面拟合成数据而不是平面，我们可以结合二阶多项式的特征，使模型看起来像这样:
$$\hat{y}(w,x)=w_0+w_1{x}_1+w_2{x}_2+w_3{x}_1{x}_2+w_4{x}_1^2+w_5{x}_2^2$$
观察到这 还是一个线性模型 （这有时候是令人惊讶的）: 看到这个，想象创造一个新的变量
$$z=[x_1,x_2,x_1{x}_2,x_1^2,x_2^2]$$
有了这些重新标记的数据，我们可以将问题写成
$$\hat{y}(w,x)=w_0+w_1{z}_1+w_2{z}_2+w_3{z}_3+w_4{z}_4+w_5{z}_5$$
我们看到，所得的 polynomial regression 与我们上文所述线性模型是同一类（即关于 w 是线性的），因此可以用同样的方法解决。通过用这些基函数建立的高维空间中的线性拟合，该模型具有灵活性，可以适应更广泛的数据范围。

这里是一个例子，使用不同程度的多项式特征将这个想法应用于一维数据:

这个图是使用 PolynomialFeatures 预创建。该预处理器将输入数据矩阵转换为给定度的新数据矩阵。使用方法如下:

>>> from sklearn.preprocessing import PolynomialFeatures
>>> import numpy as np
>>> X = np.arange(6).reshape(3, 2)
>>> X
array([[0, 1],
 [2, 3],
 [4, 5]])
>>> poly = PolynomialFeatures(degree=2)
>>> poly.fit_transform(X)
array([[  1.,   0.,   1.,   0.,   0.,   1.],
 [  1.,   2.,   3.,   4.,   6.,   9.],
 [  1.,   4.,   5.,  16.,  20.,  25.]])

X 的特征已经从 $[x_1,x_2]$ 转换到$[1,x_1,x_2,x_1^2,x_1{x}_2,x_2^2]$, 并且现在可以用在任何线性模型。
这种预处理可以通过 Pipeline 工具进行简化。可以创建一个表示简单多项式回归的单个对象，使用方法如下所示:

>>> from sklearn.preprocessing import PolynomialFeatures
>>> from sklearn.linear_model import LinearRegression
>>> from sklearn.pipeline import Pipeline
>>> import numpy as np
>>> model = Pipeline([('poly', PolynomialFeatures(degree=3)),
...                   ('linear', LinearRegression(fit_intercept=False))])
>>> # fit to an order-3 polynomial data
>>> x = np.arange(5)
>>> y = 3 - 2 * x + x ** 2 - x ** 3
>>> model = model.fit(x[:, np.newaxis], y)
>>> model.named_steps['linear'].coef_
array([ 3., -2.,  1., -1.])

利用多项式特征训练的线性模型能够准确地恢复输入多项式系数。

在某些情况下，没有必要包含任何单个特征的更高的幂，只需要相乘最多 d 个不同的特征即可，所谓 interaction features（交互特征） 。这些可通过设定 PolynomialFeatures 的 interaction_only=True 得到。

例如，当处理布尔属性，对于所有 $n{x}_i^n=x_i$ ，因此是无用的；但 $x_i{x}_j$ 代表两布尔结合。这样我们就可以用线性分类器解决异或问题:

>>> from sklearn.linear_model import Perceptron
>>> from sklearn.preprocessing import PolynomialFeatures
>>> import numpy as np
>>> X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
>>> y = X[:, 0] ^ X[:, 1]
>>> y
array([0, 1, 1, 0])
>>> X = PolynomialFeatures(interaction_only=True).fit_transform(X).astype(int)
>>> X
array([[1, 0, 0, 0],
 [1, 0, 1, 0],
 [1, 1, 0, 0],
 [1, 1, 1, 1]])
>>> clf = Perceptron(fit_intercept=False, max_iter=10, tol=None,
...                  shuffle=False).fit(X, y)

分类器的 “predictions” 是完美的:

>>> clf.predict(X)
array([0, 1, 1, 0])
>>> clf.score(X, y)
1.0

sklearn.preprocessing.PolynomialFeatures

参数	解释
degree：int, default=2	多项式特征的次数。
interaction_only：bool, default=False	如果为true，则只生成交互特性
include_bias：bool, default=True	如果为True（默认值），则包含一个bias列，其中所有多项式幂均为零的特征（即1列-在线性模型中充当截距项）。
order：{‘C’, ‘F’}, default=’C’

属性	解释
powers_：ndarray of shape (n_output_features, n_input_features)	powers_[i，j]是第i个输出中第j个输入的指数。
n_input_features_：int	输入特征的总数。
n_output_features_：int	多项式输出特征的总数。输出特征的数量是通过迭代输入特征的所有适当大小的组合来计算的。

方法	解释
fit(X, y[, sample_weight])	拟合模型
fit_transform(X[, y])	拟合数据，然后转换它。
get_feature_names([input_features])	返回输出特征的名称
get_params([deep])	获取此估计器的参数。
set_params(**params)	设置此估计器的参数。
transform(X)	将数据转换为多项式特征

例子：

>>> import numpy as np
>>> from sklearn.preprocessing import PolynomialFeatures
>>> X = np.arange(6).reshape(3, 2)
>>> X
array([[0, 1],
       [2, 3],
       [4, 5]])
>>> poly = PolynomialFeatures(2)
>>> poly.fit_transform(X)
array([[ 1.,  0.,  1.,  0.,  0.,  1.],
       [ 1.,  2.,  3.,  4.,  6.,  9.],
       [ 1.,  4.,  5., 16., 20., 25.]])
>>> poly = PolynomialFeatures(interaction_only=True)
>>> poly.fit_transform(X)
array([[ 1.,  0.,  1.,  0.],
       [ 1.,  2.,  3.,  6.],
       [ 1.,  4.,  5., 20.]])