Python机器学习库SKLearn：监督学习之广义线性模型

秒速五厘米 2022-09-29 15:52 388阅读 0赞

以下是用于回归的一组方法，其中预期目标值为输入变量的线性组合，在数学概念中，假设\{y^\}是预测值。

![334dd847bce79ed52a760f02b3efd8faefdb6e8b.png][]

其中，向量 w = (w\_1,..., w\_p) 作为一个 coef\_ （系数）and w\_0 作为 intercept\_（截距）。

1.1.1 普通最小二乘法（Ordinary Least Squares）  
LinearRegression是具有系数w =（w\_1，...，w\_p）的以最小化数据集中的观察到的值与通过线性近似预测的值之间的平方和的残差的线性模型。 数学上的形式如下：

> > > >   
> > > >

![e8e92a5482d9327d939e7a17946a8a1b98006018.png][]

![sphx_glr_plot_ols_0011.png][]

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

1.1.2 岭回归（Ridge Regression）  
Ridge回归通过对系数大小施加惩罚来解决普通最小二乘法的一些问题。 脊系数最小化受惩罚的残差平方和，

![48dbdad39c89539c714a825c0c0d5524eb526851.png][]

![sphx_glr_plot_ridge_path_0011.png][]

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

1.1.2.2 设置正则化参数：generalized交叉验证

RidgeCV使用内置的alpha参数的交叉验证实现脊回归。 该对象以与GridSearchCV相同的方式工作，除了它默认为广义交叉验证（GCV），一种高效形式的留一交叉验证：

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

1.1.3 Lasso

Lasso是一个估计稀疏系数的线性模型。 它在一些上下文中是有用的，因为其倾向于优选具有较少参数值的解，有效地减少给定解所依赖的变量的数量。 为此，Lasso及其变体对于压缩感测领域是基础。 在某些条件下，它可以恢复非零权重的确切集合（见压缩感知：用L1 prior（Lasso）进行断层重建）。  
数学上，它包括一个用![\\ell\_1][ell_1]先验作为正则化训练的线性模型。 最小化的目标函数是：

![\\underset\{w\}\{min\\,\} \{ \\frac\{1\}\{2n\_\{samples\}\} ||X w - y||\_2 ^ 2 + \\alpha ||w||\_1\}][underset_w_min_ _ _frac_1_2n_samples_ _X w - y_2 _ 2 _ _alpha _w_1]

因此， Lasso估计解决了添加了![\\alpha ||w||\_1][alpha _w_1]的最小二乘惩罚的最小化，其中\\α是常数，![||w||\_1][w_1]是参数向量的![\\ell\_1][ell_1]范数。

>>> 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 设置正则化参数

α参数控制估计的系数的稀疏程度。

1.1.3.1.1 使用交叉验证

scikit-learn通过交叉验证显示设置Lasso alpha参数的对象：LassoCV和LassoLarsCV。 LassoLarsCV基于下面解释的最小角度回归算法。  
对于具有许多共线回归的高维数据集，LassoCV是最常用的。 然而，LassoLarsCV具有探索更相关的α参数值的优点，并且如果样本的数量与观察的数量相比非常小，则通常比LassoCV更快。

[![lasso\_cv\_1][lasso_cv_1]][lasso_cv_1_lasso_cv_1] [![lasso\_cv\_2][lasso_cv_2]][lasso_cv_1_lasso_cv_1]

1.1.3.1.2 基于信息标准的模型选择  
或者，估计器LassoLarsIC建议使用Akaike信息准则（AIC）和Bayes信息准则（BIC）。 当使用k折交叉验证时，正则化路径仅计算一次而不是k + 1次，这是计算上更便宜的替代方法来找到α的最佳值。 然而，这样的标准需要对解的自由度的适当估计，针对大样本（渐近结果）导出并且假设模型是正确的，即数据实际上由该模型生成。 当问题严重失调（比特征更多的特征）时，它们也倾向于断裂。

[![../\_images/sphx\_glr\_plot\_lasso\_model\_selection\_0011.png][.._images_sphx_glr_plot_lasso_model_selection_0011.png]][lasso_cv_1_lasso_cv_1]

1.1.4. Multi-task Lasso

MultiTaskLasso是一个线性模型，用于联合估计多个回归问题的稀疏系数：y是形状的二维数组（n\_samples，n\_tasks）。 约束是所选的特征对于所有回归问题都相同，也称为任务。

下图比较了用简单Lasso或MultiTaskLasso获得的W中非零的位置。 Lasso估计产生分散的非零，而MultiTaskLasso的非零是完整列。

[![multi\_task\_lasso\_1][multi_task_lasso_1]][multi_task_lasso_1_multi_task_lasso_1] [![multi\_task\_lasso\_2][multi_task_lasso_2]][multi_task_lasso_1_multi_task_lasso_1]

1.1.8. LARS Lasso

LassoLars是一个使用LARS算法实现的套索模型，与基于coordinate\_descent的实现不同，这产生了精确的解，它是作为其系数范数的函数的分段线性。

[![../\_images/sphx\_glr\_plot\_lasso\_lars\_0011.png][.._images_sphx_glr_plot_lasso_lars_0011.png]][.._images_sphx_glr_plot_lasso_lars_0011.png_.._images_sphx_glr_plot_lasso_lars_0011.png]

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

1.1.10. Bayesian Regression 贝叶斯回归

1.1.10.1. Bayesian Ridge Regression

贝叶斯岭回归用于回归：

>>>

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

在拟合之后，该模型可以用于预测新值：

>>>

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

模型的权重w可以获得：

>>>

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

1.1.11. Logistic regression

逻辑回归从名字上看起来像回归模型，但是逻辑回归是一个分类的线性分类模型而不是一个回归模型。 逻辑回归在文献中也称为logit回归，最大熵分类（MaxEnt）或对数线性分类器。 在这个模型中，描述单个试验的可能结果的概率使用逻辑函数建模。  
scikit-learn中逻辑回归的实现可以从LogisticRegression类访问。 此实现可以适用于二元，可选的L2或L1正则化的One-vs- Rest或多项Logistic回归。  
作为优化问题，二元类L2惩罚逻辑回归使以下成本函数最小化：

![\\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) .][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正则逻辑回归解决以下优化问题：

![\\underset\{w, c\}\{min\\,\} \\|w\\|\_1 + C \\sum\_\{i=1\}^n \\log(\\exp(- y\_i (X\_i^T w + c)) + 1) .][underset_w_ c_min_ _w_1 _ C _sum_i_1_n _log_exp_- y_i _X_i_T w _ c_ _ 1_ .]

在LogisticRegression类中实现的解算器是“liblinear”，“newton-cg”，“lbfgs”和“sag”：  
求解器“liblinear”使用坐标下降（CD）算法，并依赖于优秀的C ++ LIBLINEAR库，它随scikit-learn一起提供。然而，在liblinear中实现的CD算法不能学习真正的多项式（多类）模型;相反，优化问题以“一对一”的方式分解，因此为所有类训练单独的二进制分类器。这发生在引擎盖下，因此使用此解算器的LogisticRegression实例表现为多类分类器。对于L1惩罚，sklearn.svm.l1\_min\_c允许计算C的下限，以便得到非“零”（所有特征权重为零）模型。  
“lbfgs”，“sag”和“newton-cg”求解器仅支持L2惩罚，并且发现对于一些高维数据更快地收敛。使用这些求解器将multi\_class设置为“多项”学习一个真正的多项Logistic回归模型\[5\]，这意味着其概率估计应该比默认的“一个vs休息”设置更好地校准。 “lbfgs”，“sag”和“newton-cg”求解器不能优化L1惩罚模型，因此“多项式”设置不学习稀疏模型。  
求解器“sag”使用随机平均梯度下降\[6\]。对于大型数据集，当样本数和特征数都很大时，它比其他求解器更快。  
简而言之，可以选择具有以下规则的求解器：

<table style="max-width:100%; border-collapse:collapse; border-spacing:0px; border:0px; color:rgb(29,31,34); font-family:Helvetica,Arial,sans-serif; font-size:14.4px">     
 <thead> 
  <tr style="border-style:solid none; border-width:1px 0px; border-color:rgb(221,221,221); background-color:rgb(240,247,250)"> 
   <th style="padding:1px 8px 1px 5px; border-width:0px 0px 1px; border-bottom-style:solid; border-bottom-color:rgb(170,170,170)"> Case</th> 
   <th style="padding:1px 8px 1px 5px; border-width:0px 0px 1px; border-bottom-style:solid; border-bottom-color:rgb(170,170,170)"> Solver</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr style="border-style:solid none; border-width:1px 0px; border-color:rgb(221,221,221); background-color:rgb(240,247,250)"> 
   <td style="padding:1px 8px 1px 5px; border-width:0px 0px 1px; border-color:rgb(221,221,221); border-bottom-style:solid"> Small dataset or L1 penalty</td> 
   <td style="padding:1px 8px 1px 5px; border-width:0px 0px 1px; border-color:rgb(221,221,221); border-bottom-style:solid"> “liblinear”</td> 
  </tr> 
  <tr style="border-style:solid none; border-width:1px 0px; border-color:rgb(221,221,221); background-color:rgb(253,253,253)"> 
   <td style="padding:1px 8px 1px 5px; border-width:0px 0px 1px; border-color:rgb(221,221,221); border-bottom-style:solid"> Multinomial loss or large dataset</td> 
   <td style="padding:1px 8px 1px 5px; border-width:0px 0px 1px; border-color:rgb(221,221,221); border-bottom-style:solid"> “lbfgs”, “sag” or “newton-cg”</td> 
  </tr> 
  <tr style="border-style:solid none; border-width:1px 0px; border-color:rgb(221,221,221); background-color:rgb(240,247,250)"> 
   <td style="padding:1px 8px 1px 5px; border-width:0px 0px 1px; border-color:rgb(221,221,221); border-bottom-style:solid"> Very Large dataset</td> 
   <td style="padding:1px 8px 1px 5px; border-width:0px 0px 1px; border-color:rgb(221,221,221); border-bottom-style:solid"> “sag”<br> </td> 
  </tr> 
 </tbody> 
</table>

[334dd847bce79ed52a760f02b3efd8faefdb6e8b.png]: /images/20220708/63cd15ca835c44f8b00f90ccd400a362.png
[e8e92a5482d9327d939e7a17946a8a1b98006018.png]: /images/20220708/647a8babd72c4b5ba7609066a867ef63.png
[sphx_glr_plot_ols_0011.png]: /images/20220708/ac3795d0ab0046f1bca82e5edb4ecf84.png
[48dbdad39c89539c714a825c0c0d5524eb526851.png]: /images/20220708/022a63129de844a4bda573444ee45d4b.png
[sphx_glr_plot_ridge_path_0011.png]: /images/20220708/5d683cf772e343f691d26ded1af3d340.png
[ell_1]: /images/20220708/592ede7592cb49698cea28257e250caa.png
[underset_w_min_ _ _frac_1_2n_samples_ _X w - y_2 _ 2 _ _alpha _w_1]: /images/20220708/d58680e3e582403998bf3b851f587b2a.png
[alpha _w_1]: http://scikit-learn.org/stable/_images/math/7f5743fd8d7d5f38ac1c1b69264a46a7db7c5ef8.png
[w_1]: http://scikit-learn.org/stable/_images/math/99c2ab1cc7a9538a1f081f7391fa368fa6f25799.png
[lasso_cv_1]: http://scikit-learn.org/stable/_images/sphx_glr_plot_lasso_model_selection_0021.png
[lasso_cv_1_lasso_cv_1]: /images/20220708/4dc6c0ed3e764e9c9e6fc227a4ac733c.png
[lasso_cv_2]: http://scikit-learn.org/stable/_images/sphx_glr_plot_lasso_model_selection_0031.png
[.._images_sphx_glr_plot_lasso_model_selection_0011.png]: http://scikit-learn.org/stable/_images/sphx_glr_plot_lasso_model_selection_0011.png
[multi_task_lasso_1]: http://scikit-learn.org/stable/_images/sphx_glr_plot_multi_task_lasso_support_0011.png
[multi_task_lasso_1_multi_task_lasso_1]: /images/20220708/3bdcf1e0144748bba7cbab4bb5171f89.png
[multi_task_lasso_2]: http://scikit-learn.org/stable/_images/sphx_glr_plot_multi_task_lasso_support_0021.png
[.._images_sphx_glr_plot_lasso_lars_0011.png]: http://scikit-learn.org/stable/_images/sphx_glr_plot_lasso_lars_0011.png
[.._images_sphx_glr_plot_lasso_lars_0011.png_.._images_sphx_glr_plot_lasso_lars_0011.png]: /images/20220708/9abe0802c97746fcb6f1e767852c584f.png
[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_ .]: /images/20220708/a8dad266114d4b31a1f09a3b86100371.png
[underset_w_ c_min_ _w_1 _ C _sum_i_1_n _log_exp_- y_i _X_i_T w _ c_ _ 1_ .]: /images/20220708/cf33a7563ec04b369592fa3b52b34eff.png