2.md

{% raw %}
# 1.1\. 广义线性模型

校验者:
        [@专业吹牛逼的小明](https://github.com/apachecn/scikit-learn-doc-zh)
        [@Gladiator](https://github.com/apachecn/scikit-learn-doc-zh)
翻译者:
        [@瓜牛](https://github.com/apachecn/scikit-learn-doc-zh)
        [@年纪大了反应慢了](https://github.com/apachecn/scikit-learn-doc-zh)
        [@Hazekiah](https://github.com/apachecn/scikit-learn-doc-zh)
        [@BWM-蜜蜂](https://github.com/apachecn/scikit-learn-doc-zh)

下面是一组用于回归的方法，其中目标值 y 是输入变量 x 的线性组合。 在数学概念中，如果 ![\hat{y}](img/047826f1c2e6f2687b304cb5217be8d8.jpg) 是预测值。

![\hat{y}(w, x) = w_0 + w_1 x_1 + ... + w_p x_p](img/4ee9f6c666393981b6458e54c3ec89d0.jpg)

在整个模块中，我们定义向量 ![w = (w_1,..., w_p)](img/b003858334d1ad594207911e84219151.jpg) 作为 `coef_` ，定义 ![w_0](img/57e15e43b846791e47a202e1a9a5d8ce.jpg) 作为 `intercept_` 。

如果需要使用广义线性模型进行分类，请参阅 [logistic 回归](#logistic-regression) 。

## 1.1.1\. 普通最小二乘法

[`LinearRegression`](generated/sklearn.linear_model.LinearRegression.html#sklearn.linear_model.LinearRegression "sklearn.linear_model.LinearRegression") 拟合一个带有系数 ![w = (w_1, ..., w_p)](img/3f5adc0c9b0e51a0759ed6ac49f94431.jpg) 的线性模型，使得数据集实际观测数据和预测数据（估计值）之间的残差平方和最小。其数学表达式为:

![\underset{w}{min\,} {|| X w - y||_2}^2](img/1b6228a71a038f66ac7b8a2743adf4e7.jpg)

[![http://sklearn.apachecn.org/cn/0.19.0/_images/sphx_glr_plot_ols_0011.png](img/af7b81123e6cdf0b42acec802041beef.jpg)](../auto_examples/linear_model/plot_ols.html)

[`LinearRegression`](generated/sklearn.linear_model.LinearRegression.html#sklearn.linear_model.LinearRegression "sklearn.linear_model.LinearRegression") 会调用 `fit` 方法来拟合数组 X， y，并且将线性模型的系数 ![w](img/8a58e8df6a985a3273e39bac7dd72b1f.jpg) 存储在其成员变量 `coef_` 中:

```py
>>> from sklearn import linear_model
>>> reg = linear_model.LinearRegression()
>>> reg.fit ([[0, 0], [1, 1], [2, 2]], [0, 1, 2])
LinearRegression(copy_X=True, fit_intercept=True, n_jobs=1, normalize=False)
>>> reg.coef_
array([ 0.5,  0.5])

```

然而，对于普通最小二乘的系数估计问题，其依赖于模型各项的相互独立性。当各项是相关的，且设计矩阵 ![X](img/43c1fea57579e54f80c0535bc582626f.jpg) 的各列近似线性相关，那么，设计矩阵会趋向于奇异矩阵，这会导致最小二乘估计对于随机误差非常敏感，产生很大的方差。例如，在没有实验设计的情况下收集到的数据，这种多重共线性（multicollinearity）的情况可能真的会出现。

示例:

*   [Linear Regression Example](../auto_examples/linear_model/plot_ols.html#sphx-glr-auto-examples-linear-model-plot-ols-py)

### 1.1.1.1\. 普通最小二乘法复杂度

该方法使用 X 的奇异值分解来计算最小二乘解。如果 X 是一个 size 为 (n, p) 的矩阵，设 ![n \geq p](img/7a7a32bd2dd0da3d117c39efc7e35dd3.jpg) ，则该方法的复杂度为 ![O(n p^2)](img/e761380fca8200d40164e77965652982.jpg)

## 1.1.2\. 岭回归

[`Ridge`](generated/sklearn.linear_model.Ridge.html#sklearn.linear_model.Ridge "sklearn.linear_model.Ridge") 回归通过对系数的大小施加惩罚来解决 [普通最小二乘法](#ordinary-least-squares) 的一些问题。 岭系数最小化的是带罚项的残差平方和，

![\underset{w}{min\,} {{|| X w - y||_2}^2 + \alpha {||w||_2}^2}](img/c7e49892dca2f0df35d1261a276693f2.jpg)

其中， ![\alpha \geq 0](img/a4775baaa990a4fbffcfc2688e3b5578.jpg) 是控制系数收缩量的复杂性参数： ![\alpha](img/d8b3d5242d513369a44f8bf0c6112744.jpg) 的值越大，收缩量越大，这样系数对共线性的鲁棒性也更强。

[![http://sklearn.apachecn.org/cn/0.19.0/_images/sphx_glr_plot_ridge_path_0011.png](img/a4a20739f22e7059a927ba615ec373da.jpg)](../auto_examples/linear_model/plot_ridge_path.html)

与其他线性模型一样， [`Ridge`](generated/sklearn.linear_model.Ridge.html#sklearn.linear_model.Ridge "sklearn.linear_model.Ridge") 用 `fit` 方法将模型系数 ![w](img/8a58e8df6a985a3273e39bac7dd72b1f.jpg) 存储在其 `coef_` 成员中:

```py
>>> 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, copy_X=True, fit_intercept=True, max_iter=None,
 normalize=False, random_state=None, solver='auto', tol=0.001)
>>> reg.coef_
array([ 0.34545455,  0.34545455])
>>> reg.intercept_ 
0.13636...

```

示例:

*   :ref:[`](#id5)sphx_glr_auto_examples_linear_model_plot_ridge_path.py`( 作为正则化的函数，绘制岭系数 )
*   :ref:[`](#id7)sphx_glr_auto_examples_text_document_classification_20newsgroups.py`( 使用稀疏特征的文本文档分类 )

### 1.1.2.1\. 岭回归的复杂度

这种方法与 [普通最小二乘法](#ordinary-least-squares) 的复杂度是相同的.

### 1.1.2.2\. 设置正则化参数：广义交叉验证

[`RidgeCV`](generated/sklearn.linear_model.RidgeCV.html#sklearn.linear_model.RidgeCV "sklearn.linear_model.RidgeCV") 通过内置的 Alpha 参数的交叉验证来实现岭回归。 该对象与 GridSearchCV 的使用方法相同，只是它默认为 Generalized Cross-Validation(广义交叉验证 GCV)，这是一种有效的留一验证方法（LOO-CV）:

```py
>>> from sklearn import linear_model
>>> reg = linear_model.RidgeCV(alphas=[0.1, 1.0, 10.0])
>>> reg.fit([[0, 0], [0, 0], [1, 1]], [0, .1, 1])       
RidgeCV(alphas=[0.1, 1.0, 10.0], cv=None, fit_intercept=True, scoring=None,
 normalize=False)
>>> reg.alpha_                                      
0.1

```

参考

*   “Notes on Regularized Least Squares”, Rifkin & Lippert ([technical report](http://cbcl.mit.edu/projects/cbcl/publications/ps/MIT-CSAIL-TR-2007-025.pdf), [course slides](http://www.mit.edu/~9.520/spring07/Classes/rlsslides.pdf)).

## 1.1.3\. Lasso

The [`Lasso`](generated/sklearn.linear_model.Lasso.html#sklearn.linear_model.Lasso "sklearn.linear_model.Lasso") 是估计稀疏系数的线性模型。 它在一些情况下是有用的，因为它倾向于使用具有较少参数值的情况，有效地减少给定解决方案所依赖变量的数量。 因此，Lasso 及其变体是压缩感知领域的基础。 在一定条件下，它可以恢复一组非零权重的精确集（见 [Compressive sensing: tomography reconstruction with L1 prior (Lasso)](../auto_examples/applications/plot_tomography_l1_reconstruction.html#sphx-glr-auto-examples-applications-plot-tomography-l1-reconstruction-py) ）。

在数学公式表达上，它由一个带有 ![\ell_1](img/3bf32d926cdf24f440b6b831f0d9cc37.jpg) 先验的正则项的线性模型组成。 其最小化的目标函数是:

![\underset{w}{min\,} { \frac{1}{2n_{samples}} ||X w - y||_2 ^ 2 + \alpha ||w||_1}](img/187eddee2de4e12860dc001c5f74b2b4.jpg)

lasso estimate 解决了加上罚项 ![\alpha ||w||_1](img/b2ea359213f8f5b01eead0821e29e856.jpg) 的最小二乘法的最小化，其中， ![\alpha](img/d8b3d5242d513369a44f8bf0c6112744.jpg) 是一个常数， ![||w||_1](img/62eb544f1f6e234c61099fea1517300b.jpg) 是参数向量的 ![\ell_1](img/3bf32d926cdf24f440b6b831f0d9cc37.jpg)-norm 范数。

[`Lasso`](generated/sklearn.linear_model.Lasso.html#sklearn.linear_model.Lasso "sklearn.linear_model.Lasso") 类的实现使用了 coordinate descent （坐标下降算法）来拟合系数。 查看 [最小角回归](#least-angle-regression) ，这是另一种方法:

```py
>>> 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])

```

对于较低级别的任务，同样有用的是函数 [`lasso_path`](generated/sklearn.linear_model.lasso_path.html#sklearn.linear_model.lasso_path "sklearn.linear_model.lasso_path") 。它能够通过搜索所有可能的路径上的值来计算系数。

举例:

*   [Lasso and Elastic Net for Sparse Signals](../auto_examples/linear_model/plot_lasso_and_elasticnet.html#sphx-glr-auto-examples-linear-model-plot-lasso-and-elasticnet-py) （稀疏信号的 lasso 和弹性网）
*   [Compressive sensing: tomography reconstruction with L1 prior (Lasso)](../auto_examples/applications/plot_tomography_l1_reconstruction.html#sphx-glr-auto-examples-applications-plot-tomography-l1-reconstruction-py) （压缩感知：L1 先验（Lasso）的断层扫描重建）

Note

**Feature selection with Lasso（使用 Lasso 进行特征选择）**

由于 Lasso 回归产生稀疏模型，因此可以用于执行特征选择，详见 [基于 L1 的特征选取](feature_selection.html#l1-feature-selection) （基于 L1 的特征选择）。

### 1.1.3.1\. 设置正则化参数

> `alpha` 参数控制估计系数的稀疏度。

#### 1.1.3.1.1\. 使用交叉验证

scikit-learn 通过交叉验证来公开设置 Lasso `alpha` 参数的对象: [`LassoCV`](generated/sklearn.linear_model.LassoCV.html#sklearn.linear_model.LassoCV "sklearn.linear_model.LassoCV") 和 [`LassoLarsCV`](generated/sklearn.linear_model.LassoLarsCV.html#sklearn.linear_model.LassoLarsCV "sklearn.linear_model.LassoLarsCV")。 [`LassoLarsCV`](generated/sklearn.linear_model.LassoLarsCV.html#sklearn.linear_model.LassoLarsCV "sklearn.linear_model.LassoLarsCV") 是基于下面解释的 [最小角回归](#least-angle-regression) 算法。

对于具有许多线性回归的高维数据集， [`LassoCV`](generated/sklearn.linear_model.LassoCV.html#sklearn.linear_model.LassoCV "sklearn.linear_model.LassoCV") 最常见。 然而，[`LassoLarsCV`](generated/sklearn.linear_model.LassoLarsCV.html#sklearn.linear_model.LassoLarsCV "sklearn.linear_model.LassoLarsCV") 在寻找 &lt;cite&gt;alpha&lt;/cite&gt; 参数值上更具有优势，而且如果样本数量与特征数量相比非常小时，通常 [`LassoLarsCV`](generated/sklearn.linear_model.LassoLarsCV.html#sklearn.linear_model.LassoLarsCV "sklearn.linear_model.LassoLarsCV") 比 [`LassoCV`](generated/sklearn.linear_model.LassoCV.html#sklearn.linear_model.LassoCV "sklearn.linear_model.LassoCV") 要快。

**[![lasso_cv_1](img/035f009eecfdebf82b493f797843a919.jpg)](../auto_examples/linear_model/plot_lasso_model_selection.html) [![lasso_cv_2](img/ab2096ee4087e644cca732d92d241edf.jpg)](../auto_examples/linear_model/plot_lasso_model_selection.html)**

#### 1.1.3.1.2\. 基于信息标准的模型选择

有多种选择时，估计器 [`LassoLarsIC`](generated/sklearn.linear_model.LassoLarsIC.html#sklearn.linear_model.LassoLarsIC "sklearn.linear_model.LassoLarsIC") 建议使用 Akaike information criterion （Akaike 信息准则）（AIC）和 Bayes Information criterion （贝叶斯信息准则）（BIC）。 当使用 k-fold 交叉验证时，正则化路径只计算一次而不是 k + 1 次，所以找到 α 的最优值是一种计算上更便宜的替代方法。 然而，这样的标准需要对解决方案的自由度进行适当的估计，对于大样本（渐近结果）导出，并假设模型是正确的，即数据实际上是由该模型生成的。 当问题严重受限（比样本更多的特征）时，他们也倾向于打破。

[![http://sklearn.apachecn.org/cn/0.19.0/_images/sphx_glr_plot_lasso_model_selection_0011.png](img/e7a07569c8c6af174aa061b9f8921065.jpg)](../auto_examples/linear_model/plot_lasso_model_selection.html)

示例:

*   :ref:[`](#id15)sphx_glr_auto_examples_linear_model_plot_lasso_model_selection.py`(Lasso 型号选择：交叉验证/AIC/BIC)

#### 1.1.3.1.3\. 与 SVM 的正则化参数的比较

`alpha` 和 SVM 的正则化参数``C`` 之间的等式关系是 `alpha = 1 / C` 或者 `alpha = 1 / (n_samples * C)` ，并依赖于估计器和模型优化的确切的目标函数。 .. _multi_task_lasso:

## 1.1.4\. 多任务 Lasso

> [`MultiTaskLasso`](generated/sklearn.linear_model.MultiTaskLasso.html#sklearn.linear_model.MultiTaskLasso "sklearn.linear_model.MultiTaskLasso") 是一个估计多元回归稀疏系数的线性模型： `y` 是一个 `(n_samples, n_tasks)` 的二维数组，其约束条件和其他回归问题（也称为任务）是一样的，都是所选的特征值。

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

**[![multi_task_lasso_1](img/0449a2a9bce6d759e7253da7d17fa938.jpg)](../auto_examples/linear_model/plot_multi_task_lasso_support.html) [![multi_task_lasso_2](img/3b1e10150e98ef95e977c12ad0607620.jpg)](../auto_examples/linear_model/plot_multi_task_lasso_support.html)**

**拟合 time-series model （时间序列模型），强制任何活动的功能始终处于活动状态。**

示例:

*   [Joint feature selection with multi-task Lasso](../auto_examples/linear_model/plot_multi_task_lasso_support.html#sphx-glr-auto-examples-linear-model-plot-multi-task-lasso-support-py) （联合功能选择与多任务 Lasso）

在数学上，它由一个线性模型组成，以混合的 ![\ell_1](img/3bf32d926cdf24f440b6b831f0d9cc37.jpg) ![\ell_2](img/8851bd0fe9749b4841b30cee41fb040d.jpg) 作为正则化器进行训练。目标函数最小化是：

![\underset{w}{min\,} { \frac{1}{2n_{samples}} ||X W - Y||_{Fro} ^ 2 + \alpha ||W||_{21}}](img/aba64ff85b1f99c5d1c4f8e1ace15f89.jpg)

其中 ![Fro](img/987fc6b717a40e57a95fb79a8e809309.jpg) 表示 Frobenius 标准：

![||A||_{Fro} = \sqrt{\sum_{ij} a_{ij}^2}](img/9259b19a18f30f67db9e45b8c0b361c7.jpg)

并且 ![\ell_1](img/3bf32d926cdf24f440b6b831f0d9cc37.jpg) ![\ell_2](img/8851bd0fe9749b4841b30cee41fb040d.jpg) 读取为:

![||A||_{2 1} = \sum_i \sqrt{\sum_j a_{ij}^2}](img/2f373d871220ee042a8c2ee44e6fff3a.jpg)

[`MultiTaskLasso`](generated/sklearn.linear_model.MultiTaskLasso.html#sklearn.linear_model.MultiTaskLasso "sklearn.linear_model.MultiTaskLasso") 类的实现使用了坐标下降作为拟合系数的算法。

## 1.1.5\. 弹性网络

`弹性网络` 是一种使用 L1， L2 范数作为先验正则项训练的线性回归模型。 这种组合允许学习到一个只有少量参数是非零稀疏的模型，就像 [`Lasso`](generated/sklearn.linear_model.Lasso.html#sklearn.linear_model.Lasso "sklearn.linear_model.Lasso") 一样，但是它仍然保持 一些像 [`Ridge`](generated/sklearn.linear_model.Ridge.html#sklearn.linear_model.Ridge "sklearn.linear_model.Ridge") 的正则性质。我们可利用 `l1_ratio` 参数控制 L1 和 L2 的凸组合。

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

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

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


![\underset{w}{min\,} { \frac{1}{2n_{samples}} ||X w - y||_2 ^ 2 + \alpha \rho ||w||_1 +
\frac{\alpha(1-\rho)}{2} ||w||_2 ^ 2}](img/9b9ee41d276ad49322856b95cb6c7e43.jpg)


![https://scikit-learn.org/stable/_images/sphx_glr_plot_lasso_coordinate_descent_path_001.png:target:../auto_examples/linear_model/plot_lasso_coordinate_descent_path.html:align:center:scale:50%](../Images/aa0c61cd560f0fdab4fe10c7b12e5082.jpg)

[`ElasticNetCV`](generated/sklearn.linear_model.ElasticNetCV.html#sklearn.linear_model.ElasticNetCV "sklearn.linear_model.ElasticNetCV") 类可以通过交叉验证来设置参数 `alpha` （ ![\alpha](img/d8b3d5242d513369a44f8bf0c6112744.jpg) ） 和 `l1_ratio` （ ![\rho](img/b91e4507d9fd7068b02f689d697f8714.jpg) ） 。

示例:

*   [Lasso and Elastic Net for Sparse Signals](../auto_examples/linear_model/plot_lasso_and_elasticnet.html#sphx-glr-auto-examples-linear-model-plot-lasso-and-elasticnet-py)
*   [Lasso and Elastic Net](../auto_examples/linear_model/plot_lasso_coordinate_descent_path.html#sphx-glr-auto-examples-linear-model-plot-lasso-coordinate-descent-path-py)

## 1.1.6\. 多任务弹性网络

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

从数学上来说， 它包含一个混合的 ![\ell_1](img/3bf32d926cdf24f440b6b831f0d9cc37.jpg) ![\ell_2](img/8851bd0fe9749b4841b30cee41fb040d.jpg) 先验和 ![\ell_2](img/8851bd0fe9749b4841b30cee41fb040d.jpg) 先验为正则项训练的线性模型 目标函数就是最小化:


![\underset{W}{min\,} { \frac{1}{2n_{samples}} ||X W - Y||_{Fro}^2 + \alpha \rho ||W||_{2 1} +
\frac{\alpha(1-\rho)}{2} ||W||_{Fro}^2}](img/a1670c1fcb5b7ad10830f43812ed50da.jpg)


在 [`MultiTaskElasticNet`](generated/sklearn.linear_model.MultiTaskElasticNet.html#sklearn.linear_model.MultiTaskElasticNet "sklearn.linear_model.MultiTaskElasticNet") 类中的实现采用了坐标下降法求解参数。

在 [`MultiTaskElasticNetCV`](generated/sklearn.linear_model.MultiTaskElasticNetCV.html#sklearn.linear_model.MultiTaskElasticNetCV "sklearn.linear_model.MultiTaskElasticNetCV") 中可以通过交叉验证来设置参数 `alpha` （ ![\alpha](img/d8b3d5242d513369a44f8bf0c6112744.jpg) ） 和 `l1_ratio` （ ![\rho](img/b91e4507d9fd7068b02f689d697f8714.jpg) ） 。

## 1.1.7\. 最小角回归

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

LARS的优点:

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

LARS 的缺点:

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

LARS 模型可以在 [`Lars`](generated/sklearn.linear_model.Lars.html#sklearn.linear_model.Lars "sklearn.linear_model.Lars") ，或者它的底层实现 [`lars_path`](generated/sklearn.linear_model.lars_path.html#sklearn.linear_model.lars_path "sklearn.linear_model.lars_path") 中被使用。

## 1.1.8\. LARS Lasso

[`LassoLars`](generated/sklearn.linear_model.LassoLars.html#sklearn.linear_model.LassoLars "sklearn.linear_model.LassoLars") 是一个使用 LARS 算法的 lasso 模型，不同于基于坐标下降法的实现，它可以得到一个精确解，也就是一个关于自身参数标准化后的一个分段线性解。

[![http://sklearn.apachecn.org/cn/0.19.0/_images/sphx_glr_plot_lasso_lars_0011.png](img/05459a925be9207abbb2f72203e48cf2.jpg)](../auto_examples/linear_model/plot_lasso_lars.html)

```py
>>> from sklearn import linear_model
>>> reg = linear_model.LassoLars(alpha=.1)
>>> reg.fit([[0, 0], [1, 1]], [0, 1])  
LassoLars(alpha=0.1, copy_X=True, eps=..., fit_intercept=True,
 fit_path=True, max_iter=500, normalize=True, positive=False,
 precompute='auto', verbose=False)
>>> reg.coef_    
array([ 0.717157...,  0\.        ])

```

示例:

*   [Lasso path using LARS](../auto_examples/linear_model/plot_lasso_lars.html#sphx-glr-auto-examples-linear-model-plot-lasso-lars-py)

Lars 算法提供了一个几乎无代价的沿着正则化参数的系数的完整路径，因此常利用函数 [`lars_path`](generated/sklearn.linear_model.lars_path.html#sklearn.linear_model.lars_path "sklearn.linear_model.lars_path") 来取回路径。

### 1.1.8.1\. 数学表达式

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

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

参考文献:

*   Original Algorithm is detailed in the paper [Least Angle Regression](http://www-stat.stanford.edu/~hastie/Papers/LARS/LeastAngle_2002.pdf) by Hastie et al.

## 1.1.9\. 正交匹配追踪法（OMP）

> [`OrthogonalMatchingPursuit`](generated/sklearn.linear_model.OrthogonalMatchingPursuit.html#sklearn.linear_model.OrthogonalMatchingPursuit "sklearn.linear_model.OrthogonalMatchingPursuit") (正交匹配追踪法)和 [`orthogonal_mp`](generated/sklearn.linear_model.orthogonal_mp.html#sklearn.linear_model.orthogonal_mp "sklearn.linear_model.orthogonal_mp")

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

就像最小角回归一样，作为一个前向特征选择方法，正交匹配追踪法可以近似一个固定非 0 元素的最优向量解:


![\text{arg\,min\,} ||y - X\gamma||_2^2 \text{ subject to } \
||\gamma||_0 \leq n_{nonzero\_coefs}](img/ed70b000f50fb169ffe20ca2979e4a75.jpg)


正交匹配追踪法也可以针对一个特殊的误差而不是一个特殊的非零系数的个数。可以表示为:


![\text{arg\,min\,} ||\gamma||_0 \text{ subject to } ||y-X\gamma||_2^2 \
\leq \text{tol}](img/6b7248d635f4161b925734dbc60de37a.jpg)


OMP 是基于每一步的贪心算法，其每一步元素都是与当前残差高度相关的。它跟较为简单的匹配追踪（MP）很相似，但是相比 MP 更好，在每一次迭代中，可以利用正交投影到之前选择的字典元素重新计算残差。

示例:

*   [Orthogonal Matching Pursuit](../auto_examples/linear_model/plot_omp.html#sphx-glr-auto-examples-linear-model-plot-omp-py)

参考文献:

*   [http://www.cs.technion.ac.il/~ronrubin/Publications/KSVD-OMP-v2.pdf](http://www.cs.technion.ac.il/~ronrubin/Publications/KSVD-OMP-v2.pdf)
*   [Matching pursuits with time-frequency dictionaries](http://blanche.polytechnique.fr/~mallat/papiers/MallatPursuit93.pdf), S. G. Mallat, Z. Zhang,

## 1.1.10\. 贝叶斯回归

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

上述过程可以通过引入 [无信息先验](https://en.wikipedia.org/wiki/Non-informative_prior#Uninformative_priors) 于模型中的超参数来完成。 在 &lt;cite&gt;岭回归&lt;/cite&gt; 中使用的 ![\ell_{2}](img/e473a2606f078eaa7b86800b11f4d62b.jpg) 正则项相当于在 ![w](img/8a58e8df6a985a3273e39bac7dd72b1f.jpg) 为高斯先验条件下，且此先验的精确度为 ![\lambda^{-1}](img/7f35ead97a9f7be07b87ff7b860bcab9.jpg) 求最大后验估计。在这里，我们没有手工调参数 lambda ，而是让他作为一个变量，通过数据中估计得到。

为了得到一个全概率模型，输出 ![y](img/0775c03fc710a24df297dedcec515aaf.jpg) 也被认为是关于 ![X w](img/827de4e90947894fc96dd0432ff0d7dd.jpg) 的高斯分布。

![p(y|X,w,\alpha) = \mathcal{N}(y|X w,\alpha)](img/eaf558e2c8d1fbd5426664c1698d80bd.jpg)

Alpha 在这里也是作为一个变量，通过数据中估计得到。

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

> *   它能根据已有的数据进行改变。
> *   它能在估计过程中引入正则项。

贝叶斯回归有如下缺点:

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

参考文献

*   一个对于贝叶斯方法的很好的介绍 C. Bishop: Pattern Recognition and Machine learning
*   详细介绍原创算法的一本书 &lt;cite&gt;Bayesian learning for neural networks&lt;/cite&gt; by Radford M. Neal

### 1.1.10.1\. 贝叶斯岭回归

> [`BayesianRidge`](generated/sklearn.linear_model.BayesianRidge.html#sklearn.linear_model.BayesianRidge "sklearn.linear_model.BayesianRidge") 利用概率模型估算了上述的回归问题，其先验参数 ![w](img/8a58e8df6a985a3273e39bac7dd72b1f.jpg) 是由以下球面高斯公式得出的：


![p(w|\lambda) =
\mathcal{N}(w|0,\lambda^{-1}\bold{I_{p}})](img/971b86cde9801a3bb1a80af70bd05466.jpg)


先验参数 ![\alpha](img/d8b3d5242d513369a44f8bf0c6112744.jpg) 和 ![\lambda](img/0f92bc682b050115d03c625ce770c77d.jpg) 一般是服从 [gamma 分布](https://en.wikipedia.org/wiki/Gamma_distribution) ， 这个分布与高斯成共轭先验关系。

得到的模型一般称为 _贝叶斯岭回归_， 并且这个与传统的 [`Ridge`](generated/sklearn.linear_model.Ridge.html#sklearn.linear_model.Ridge "sklearn.linear_model.Ridge") 非常相似。参数 ![w](img/8a58e8df6a985a3273e39bac7dd72b1f.jpg) ， ![\alpha](img/d8b3d5242d513369a44f8bf0c6112744.jpg) 和 ![\lambda](img/0f92bc682b050115d03c625ce770c77d.jpg) 是在模型拟合的时候一起被估算出来的。 剩下的超参数就是 关于:math:&lt;cite&gt;alpha&lt;/cite&gt; 和 ![\lambda](img/0f92bc682b050115d03c625ce770c77d.jpg) 的 gamma 分布的先验了。 它们通常被选择为 _无信息先验_ 。模型参数的估计一般利用最大 _边缘似然对数估计_ 。

默认 ![\alpha_1 = \alpha_2 =  \lambda_1 = \lambda_2 = 10^{-6}](img/76530e85b09bd8385fad05337b968caf.jpg).

[![http://sklearn.apachecn.org/cn/0.19.0/_images/sphx_glr_plot_bayesian_ridge_0011.png](img/947ae691edda29c53c3b962665b052c6.jpg)](../auto_examples/linear_model/plot_bayesian_ridge.html)

贝叶斯岭回归用来解决回归问题:

```py
>>> from sklearn import linear_model
>>> X = [[0., 0.], [1., 1.], [2., 2.], [3., 3.]]
>>> Y = [0., 1., 2., 3.]
>>> reg = linear_model.BayesianRidge()
>>> reg.fit(X, Y)
BayesianRidge(alpha_1=1e-06, alpha_2=1e-06, compute_score=False, copy_X=True,
 fit_intercept=True, lambda_1=1e-06, lambda_2=1e-06, n_iter=300,
 normalize=False, tol=0.001, verbose=False)

```

在模型训练完成后，可以用来预测新值:

```py
>>> reg.predict ([[1, 0.]])
array([ 0.50000013])

```

权值 ![w](img/8a58e8df6a985a3273e39bac7dd72b1f.jpg) 可以被这样访问:

```py
>>> reg.coef_
array([ 0.49999993,  0.49999993])

```

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

示例:

*   [Bayesian Ridge Regression](../auto_examples/linear_model/plot_bayesian_ridge.html#sphx-glr-auto-examples-linear-model-plot-bayesian-ridge-py)

参考文献

*   更多细节可以参考 [Bayesian Interpolation](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.27.9072&rep=rep1&type=pdf) by MacKay, David J. C.

### 1.1.10.2\. 主动相关决策理论 - ARD

> [`ARDRegression`](generated/sklearn.linear_model.ARDRegression.html#sklearn.linear_model.ARDRegression "sklearn.linear_model.ARDRegression") （主动相关决策理论）和 [`Bayesian Ridge Regression`_](#id51) 非常相似，

```py
但是会导致一个更加稀疏的权重  [1] [2] 。
```

[`ARDRegression`](generated/sklearn.linear_model.ARDRegression.html#sklearn.linear_model.ARDRegression "sklearn.linear_model.ARDRegression") 提出了一个不同的 ![w](img/8a58e8df6a985a3273e39bac7dd72b1f.jpg) 的先验假设。具体来说，就是弱化了高斯分布为球形的假设。

它采用 ![w](img/8a58e8df6a985a3273e39bac7dd72b1f.jpg) 分布是与轴平行的椭圆高斯分布。

也就是说，每个权值 ![w_{i}](img/848835d5b40c5bd74a6e592a65eed5d6.jpg) 从一个中心在 0 点，精度为 ![\lambda_{i}](img/fcf31635bf1c46833111df71ab92b68e.jpg) 的高斯分布中采样得到的。

![p(w|\lambda) = \mathcal{N}(w|0,A^{-1})](img/7afe3c56e3473a3a7f18cf983ed5e79c.jpg)

并且 ![diag \; (A) = \lambda = \{\lambda_{1},...,\lambda_{p}\}](img/5db611c8f58fbd9a9776c013656a16ff.jpg).

与 [`Bayesian Ridge Regression`_](#id53) 不同， 每个 ![w_{i}](img/848835d5b40c5bd74a6e592a65eed5d6.jpg) 都有一个标准差 ![\lambda_i](img/fc333385a9012524b39bc23303de30d4.jpg) 。所有 ![\lambda_i](img/fc333385a9012524b39bc23303de30d4.jpg) 的先验分布 由超参数 ![\lambda_1](img/a6334506478d6feb4025038294ccfa00.jpg) 、 ![\lambda_2](img/535f86af715e90b9c394e3cbf53d99eb.jpg) 确定的相同的 gamma 分布确定。

[![http://sklearn.apachecn.org/cn/0.19.0/_images/sphx_glr_plot_ard_0011.png](img/8aca5aa85ff13bf8e8687220b137f9d3.jpg)](../auto_examples/linear_model/plot_ard.html)

ARD 也被称为 _稀疏贝叶斯学习_ 或 _相关向量机_ [[3]](#id32) [[4]](#id33) 。

示例:

*   [Automatic Relevance Determination Regression (ARD)](../auto_examples/linear_model/plot_ard.html#sphx-glr-auto-examples-linear-model-plot-ard-py)

参考文献:

| [[1]](#id26) | Christopher M. Bishop: Pattern Recognition and Machine Learning, Chapter 7.2.1 |

| [[2]](#id27) | David Wipf and Srikantan Nagarajan: [A new view of automatic relevance determination](http://papers.nips.cc/paper/3372-a-new-view-of-automatic-relevance-determination.pdf) |

| [[3]](#id28) | Michael E. Tipping: [Sparse Bayesian Learning and the Relevance Vector Machine](http://www.jmlr.org/papers/volume1/tipping01a/tipping01a.pdf) |

| [[4]](#id29) | Tristan Fletcher: [Relevance Vector Machines explained](http://www.tristanfletcher.co.uk/RVM%20Explained.pdf) |

## 1.1.11\. logistic 回归

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

scikit-learn 中 logistic 回归在 [`LogisticRegression`](generated/sklearn.linear_model.LogisticRegression.html#sklearn.linear_model.LogisticRegression "sklearn.linear_model.LogisticRegression") 类中实现了二分类（binary）、一对多分类（one-vs-rest）及多项式 logistic 回归，并带有可选的 L1 和 L2 正则化。

作为优化问题，带 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) .](img/203c5a2c58d6567a86dbc86faa92209e.jpg)

类似地，带 L1 正则的 logistic 回归解决的是如下优化问题：

![\underset{w, c}{min\,} \|w\|_1 + C \sum_{i=1}^n \log(\exp(- y_i (X_i^T w + c)) + 1) .](img/d7ff3091308658ce388554d420581459.jpg)

在 [`LogisticRegression`](generated/sklearn.linear_model.LogisticRegression.html#sklearn.linear_model.LogisticRegression "sklearn.linear_model.LogisticRegression") 类中实现了这些优化算法: “liblinear”， “newton-cg”， “lbfgs”， “sag” 和 “saga”。

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

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

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

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

一言以蔽之，选用求解器可遵循如下规则:

| Case | Solver |
| --- | --- |
| L1正则 | “liblinear” or “saga” |
| 多项式损失（multinomial loss） | “lbfgs”, “sag”, “saga” or “newton-cg” |
| 大数据集（&lt;cite&gt;n_samples&lt;/cite&gt;） | “sag” or “saga” |

“saga” 一般都是最佳的选择，但出于一些历史遗留原因默认的是 “liblinear” 。

对于大数据集，还可以用 [`SGDClassifier`](generated/sklearn.linear_model.SGDClassifier.html#sklearn.linear_model.SGDClassifier "sklearn.linear_model.SGDClassifier") ，并使用对数损失（’log’ loss）

示例：

*   [L1 Penalty and Sparsity in Logistic Regression](../auto_examples/linear_model/plot_logistic_l1_l2_sparsity.html#sphx-glr-auto-examples-linear-model-plot-logistic-l1-l2-sparsity-py)
*   [Path with L1- Logistic Regression](../auto_examples/linear_model/plot_logistic_path.html#sphx-glr-auto-examples-linear-model-plot-logistic-path-py)
*   [Plot multinomial and One-vs-Rest Logistic Regression](../auto_examples/linear_model/plot_logistic_multinomial.html#sphx-glr-auto-examples-linear-model-plot-logistic-multinomial-py)
*   [Multiclass sparse logisitic regression on newgroups20](../auto_examples/linear_model/plot_sparse_logistic_regression_20newsgroups.html#sphx-glr-auto-examples-linear-model-plot-sparse-logistic-regression-20newsgroups-py)
*   [MNIST classfification using multinomial logistic + L1](../auto_examples/linear_model/plot_sparse_logistic_regression_mnist.html#sphx-glr-auto-examples-linear-model-plot-sparse-logistic-regression-mnist-py)

与 liblinear 的区别:

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

Note

**利用稀疏 logistic 回归进行特征选择**

> 带 L1 罚项的 logistic 回归 将得到稀疏模型（sparse model），相当于进行了特征选择（feature selection），详情参见 [基于 L1 的特征选取](feature_selection.html#l1-feature-selection) 。

[`LogisticRegressionCV`](generated/sklearn.linear_model.LogisticRegressionCV.html#sklearn.linear_model.LogisticRegressionCV "sklearn.linear_model.LogisticRegressionCV") 对 logistic 回归 的实现内置了交叉验证（cross-validation），可以找出最优的参数 C 。”newton-cg”， “sag”， “saga” 和 “lbfgs” 在高维数据上更快，因为采用了热启动（warm-starting）。 在多分类设定下，若 &lt;cite&gt;multi_class&lt;/cite&gt; 设为 “ovr” ，会为每类求一个最佳的 C 值；若 &lt;cite&gt;multi_class&lt;/cite&gt; 设为 “multinomial” ，会通过交叉熵损失（cross-entropy loss）求出一个最佳 C 值。

参考文献：

| [[5]](#id36) | Christopher M. Bishop: Pattern Recognition and Machine Learning, Chapter 4.3.4 |

| [[6]](#id37) | Mark Schmidt, Nicolas Le Roux, and Francis Bach: [Minimizing Finite Sums with the Stochastic Average Gradient.](https://hal.inria.fr/hal-00860051/document) |

| [[7]](#id38) | Aaron Defazio, Francis Bach, Simon Lacoste-Julien: [SAGA: A Fast Incremental Gradient Method With Support for Non-Strongly Convex Composite Objectives.](https://arxiv.org/abs/1407.0202) |

## 1.1.12\. 随机梯度下降， SGD

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

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

参考文献

*   [随机梯度下降](sgd.html#sgd)

## 1.1.13\. Perceptron（感知器）

[`Perceptron`](generated/sklearn.linear_model.Perceptron.html#sklearn.linear_model.Perceptron "sklearn.linear_model.Perceptron") 是适用于大规模学习的一种简单算法。默认情况下：

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

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

## 1.1.14\. Passive Aggressive Algorithms（被动攻击算法）

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

对于分类问题， [`PassiveAggressiveClassifier`](generated/sklearn.linear_model.PassiveAggressiveClassifier.html#sklearn.linear_model.PassiveAggressiveClassifier "sklearn.linear_model.PassiveAggressiveClassifier") 可设定 `loss='hinge'` （PA-I）或 `loss='squared_hinge'` （PA-II）。对于回归问题， [`PassiveAggressiveRegressor`](generated/sklearn.linear_model.PassiveAggressiveRegressor.html#sklearn.linear_model.PassiveAggressiveRegressor "sklearn.linear_model.PassiveAggressiveRegressor") 可设置 `loss='epsilon_insensitive'` （PA-I）或 `loss='squared_epsilon_insensitive'` （PA-II）。

参考文献：

*   [“Online Passive-Aggressive Algorithms”](http://jmlr.csail.mit.edu/papers/volume7/crammer06a/crammer06a.pdf) K. Crammer, O. Dekel, J. Keshat, S. Shalev-Shwartz, Y. Singer - JMLR 7 (2006)

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

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

[![http://sklearn.apachecn.org/cn/0.19.0/_images/sphx_glr_plot_theilsen_0011.png](img/9d2e3befcfa08a4b6a7cfed8dadbd5c0.jpg)](../auto_examples/linear_model/plot_theilsen.html)

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

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

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

    | 离群值在 y 方向上 | 离群值在 X 方向上 |
    | --- | --- |
    | [![y_outliers](img/51d70ae60903891457d75099cc46e450.jpg)](../auto_examples/linear_model/plot_robust_fit.html) | [![X_outliers](img/bee2cb707f91d8e36ae11638b6698fe4.jpg)](../auto_examples/linear_model/plot_robust_fit.html) |

*   **离群点的比例 vs. 错误的量级（amplitude）**

    离群点的数量很重要，离群程度也同样重要。

稳健拟合（robust fitting）的一个重要概念是崩溃点（breakdown point），即拟合模型（仍准确预测）所能承受的离群值最大比例。

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

**折中： 预测器的选择**

> Scikit-learn提供了三种稳健回归的预测器（estimator）: [RANSAC](#ransac-regression) ， [Theil Sen](#theil-sen-regression) 和 [HuberRegressor](#huber-regression)
> 
> *   [HuberRegressor](#huber-regression) 一般快于 [RANSAC](#ransac-regression) 和 [Theil Sen](#theil-sen-regression) ，除非样本数很大，即 `n_samples` &gt;&gt; `n_features` 。 这是因为 [RANSAC](#ransac-regression) 和 [Theil Sen](#theil-sen-regression) 都是基于数据的较小子集进行拟合。但使用默认参数时， [Theil Sen](#theil-sen-regression) 和 [RANSAC](#ransac-regression) 可能不如 [HuberRegressor](#huber-regression) 鲁棒。
> *   [RANSAC](#ransac-regression) 比 [Theil Sen](#theil-sen-regression) 更快，在样本数量上的伸缩性（适应性）更好。
> *   [RANSAC](#ransac-regression) 能更好地处理y方向的大值离群点（通常情况下）。
> *   [Theil Sen](#theil-sen-regression) 能更好地处理x方向中等大小的离群点，但在高维情况下无法保证这一特点。

实在决定不了的话，请使用 [RANSAC](#ransac-regression)

### 1.1.15.2\. RANSAC： 随机抽样一致性算法（RANdom SAmple Consensus）

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

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

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

[![http://sklearn.apachecn.org/cn/0.19.0/_images/sphx_glr_plot_ransac_0011.png](img/658840c7508dc5a73ca6180323904862.jpg)](../auto_examples/linear_model/plot_ransac.html)

#### 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` 的全体数据认为是局内点。

1.  若局内点样本数最大，保存当前模型为最佳模型。以免当前模型离群点数量恰好相等（而出现未定义情况），规定仅当数值大于当前最值时认为是最佳模型。

上述步骤或者迭代到最大次数（ `max_trials` ），或者某些终止条件满足时停下（见 `stop_n_inliers` 和 `stop_score` )。最终模型由之前确定的最佳模型的局内点样本（一致性集合，consensus set）预测。

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

示例：

*   [Robust linear model estimation using RANSAC](../auto_examples/linear_model/plot_ransac.html#sphx-glr-auto-examples-linear-model-plot-ransac-py)
*   [Robust linear estimator fitting](../auto_examples/linear_model/plot_robust_fit.html#sphx-glr-auto-examples-linear-model-plot-robust-fit-py)

参考文献：

*   [https://en.wikipedia.org/wiki/RANSAC](https://en.wikipedia.org/wiki/RANSAC)
*   [“Random Sample Consensus: A Paradigm for Model Fitting with Applications to Image Analysis and Automated Cartography”](http://www.cs.columbia.edu/~belhumeur/courses/compPhoto/ransac.pdf) Martin A. Fischler and Robert C. Bolles - SRI International (1981)
*   [“Performance Evaluation of RANSAC Family”](http://www.bmva.org/bmvc/2009/Papers/Paper355/Paper355.pdf) Sunglok Choi, Taemin Kim and Wonpil Yu - BMVC (2009)

### 1.1.15.3\. Theil-Sen 预估器: 广义中值估计器（generalized-median-based estimator）

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

示例:

*   [Theil-Sen Regression](../auto_examples/linear_model/plot_theilsen.html#sphx-glr-auto-examples-linear-model-plot-theilsen-py)
*   [Robust linear estimator fitting](../auto_examples/linear_model/plot_robust_fit.html#sphx-glr-auto-examples-linear-model-plot-robust-fit-py)

参考文献:

*   [https://en.wikipedia.org/wiki/Theil%E2%80%93Sen_estimator](https://en.wikipedia.org/wiki/Theil%E2%80%93Sen_estimator)

#### 1.1.15.3.1\. 算法理论细节

[`TheilSenRegressor`](generated/sklearn.linear_model.TheilSenRegressor.html#sklearn.linear_model.TheilSenRegressor "sklearn.linear_model.TheilSenRegressor") 在渐近效率和无偏估计方面足以媲美 [Ordinary Least Squares (OLS)](#ordinary-least-squares) （普通最小二乘法（OLS））。与 OLS 不同的是， Theil-Sen 是一种非参数方法，这意味着它没有对底层数据的分布假设。由于 Theil-Sen 是基于中值的估计，它更适合于损坏的数据即离群值。 在单变量的设置中，Theil-Sen 在简单的线性回归的情况下，其崩溃点大约 29.3% ，这意味着它可以容忍任意损坏的数据高达 29.3% 。

[![http://sklearn.apachecn.org/cn/0.19.0/_images/sphx_glr_plot_theilsen_0011.png](img/9d2e3befcfa08a4b6a7cfed8dadbd5c0.jpg)](../auto_examples/linear_model/plot_theilsen.html)

scikit-learn 中实现的 [`TheilSenRegressor`](generated/sklearn.linear_model.TheilSenRegressor.html#sklearn.linear_model.TheilSenRegressor "sklearn.linear_model.TheilSenRegressor") 是多元线性回归模型的推广 [[8]](#f1) ，利用了空间中值方法，它是多维中值的推广 [[9]](#f2) 。

关于时间复杂度和空间复杂度，Theil-Sen 的尺度根据

![\binom{n_{samples}}{n_{subsamples}}](img/00af2cbeb1deda7098a17d0491060339.jpg)

这使得它不适用于大量样本和特征的问题。因此，可以选择一个亚群的大小来限制时间和空间复杂度，只考虑所有可能组合的随机子集。

示例:

*   [Theil-Sen Regression](../auto_examples/linear_model/plot_theilsen.html#sphx-glr-auto-examples-linear-model-plot-theilsen-py)

参考文献:

| [[8]](#id46) | Xin Dang, Hanxiang Peng, Xueqin Wang and Heping Zhang: [Theil-Sen Estimators in a Multiple Linear Regression Model.](http://home.olemiss.edu/~xdang/papers/MTSE.pdf) |

| [[9]](#id47) | 

1.  Kärkkäinen and S. Äyrämö: [On Computation of Spatial Median for Robust Data Mining.](http://users.jyu.fi/~samiayr/pdf/ayramo_eurogen05.pdf)

 |

### 1.1.15.4\. Huber 回归

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

[![http://sklearn.apachecn.org/cn/0.19.0/_images/sphx_glr_plot_huber_vs_ridge_001.png](img/d06a11a8d6ed2efac238ab0bdbd33326.jpg)](../auto_examples/linear_model/plot_huber_vs_ridge.html)

这个 [`HuberRegressor`](generated/sklearn.linear_model.HuberRegressor.html#sklearn.linear_model.HuberRegressor "sklearn.linear_model.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}](img/dfab82d3a21680e5b6d3898a02dc6e01.jpg)

其中


![H_m(z) = \begin{cases}
       z^2, & \text {if } |z| &lt; \epsilon, \\
       2\epsilon|z| - \epsilon^2, & \text{otherwise}
\end{cases}](img/37e4251726a37bc02df4ef4390572e9a.jpg)


建议设置参数 `epsilon` 为 1.35 以实现 95% 统计效率。

### 1.1.15.5\. 注意

[`HuberRegressor`](generated/sklearn.linear_model.HuberRegressor.html#sklearn.linear_model.HuberRegressor "sklearn.linear_model.HuberRegressor") 与将损失设置为 &lt;cite&gt;huber&lt;/cite&gt; 的 [`SGDRegressor`](generated/sklearn.linear_model.SGDRegressor.html#sklearn.linear_model.SGDRegressor "sklearn.linear_model.SGDRegressor") 并不相同，体现在以下方面的使用方式上。

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

示例:

*   [HuberRegressor vs Ridge on dataset with strong outliers](../auto_examples/linear_model/plot_huber_vs_ridge.html#sphx-glr-auto-examples-linear-model-plot-huber-vs-ridge-py)

参考文献:

*   Peter J. Huber, Elvezio M. Ronchetti: Robust Statistics, Concomitant scale estimates, pg 172

另外，这个估计是不同于 R 实现的 Robust Regression ([http://www.ats.ucla.edu/stat/r/dae/rreg.htm](http://www.ats.ucla.edu/stat/r/dae/rreg.htm)) ，因为 R 实现加权最小二乘，权重考虑到每个样本并基于残差大于某一阈值的量。

## 1.1.16\. 多项式回归：用基函数展开线性模型

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

例如，可以通过构造系数的 **polynomial features** 来扩展一个简单的线性回归。在标准线性回归的情况下，你可能有一个类似于二维数据的模型:

![\hat{y}(w, x) = w_0 + w_1 x_1 + w_2 x_2](img/76814b51cd880ede8da9a2b5ad3d4143.jpg)

如果我们想把抛物面拟合成数据而不是平面，我们可以结合二阶多项式的特征，使模型看起来像这样:

![\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](img/5656d5270c0ee866d09e2b271ed04a67.jpg)

观察到这 _还是一个线性模型_ （这有时候是令人惊讶的）: 看到这个，想象创造一个新的变量

![z = [x_1, x_2, x_1 x_2, x_1^2, x_2^2]](img/642372b631f22b9db0dc4f30d9ab67e6.jpg)

有了这些重新标记的数据，我们可以将问题写成

![\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](img/b2996ad4866e8a26c7ba42c0229385af.jpg)

我们看到，所得的 _polynomial regression_ 与我们上文所述线性模型是同一类（即关于 ![w](img/8a58e8df6a985a3273e39bac7dd72b1f.jpg) 是线性的），因此可以用同样的方法解决。通过用这些基函数建立的高维空间中的线性拟合，该模型具有灵活性，可以适应更广泛的数据范围。

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

[![http://sklearn.apachecn.org/cn/0.19.0/_images/sphx_glr_plot_polynomial_interpolation_0011.png](img/cda529a3abe8af421f1f218b1a390091.jpg)](../auto_examples/linear_model/plot_polynomial_interpolation.html)

这个图是使用 [`PolynomialFeatures`](generated/sklearn.preprocessing.PolynomialFeatures.html#sklearn.preprocessing.PolynomialFeatures "sklearn.preprocessing.PolynomialFeatures") 预创建。该预处理器将输入数据矩阵转换为给定度的新数据矩阵。使用方法如下:

```py
>>> 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]](img/58d06eb9b8003c392af19e09ce5ab1a4.jpg) 转换到 ![[1, x_1, x_2, x_1^2, x_1 x_2, x_2^2]](img/6b474f60cd7fcc77b4a950334fc6483f.jpg), 并且现在可以用在任何线性模型。

这种预处理可以通过 [Pipeline](pipeline.html#pipeline) 工具进行简化。可以创建一个表示简单多项式回归的单个对象，使用方法如下所示:

```py
>>> 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](img/adf83056bc2bd05628e24c40cb728b3d.jpg) 个不同的特征即可，所谓 _interaction features（交互特征）_ 。这些可通过设定 [`PolynomialFeatures`](generated/sklearn.preprocessing.PolynomialFeatures.html#sklearn.preprocessing.PolynomialFeatures "sklearn.preprocessing.PolynomialFeatures") 的 `interaction_only=True` 得到。

例如，当处理布尔属性，对于所有 ![n](img/c87d9110f3d32ffa5fa08671e4af11fb.jpg) ![x_i^n = x_i](img/4d1bc681619acee3db7da4d570bcb4cd.jpg) ，因此是无用的；但 ![x_i x_j](img/53fd9843c9af9a7ea05df92bce997456.jpg) 代表两布尔结合。这样我们就可以用线性分类器解决异或问题:

```py
>>> 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” 是完美的:

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

```
{% endraw %}