【机器学习】逻辑回归(LogisticRegression)原理与实战

- 日理万妓 2022-11-27 15:59 383阅读 0赞

### 文章目录 ###

*  前言
 *  一、什么是逻辑回归
 *   *  1.1 逻辑回归基础概念
     *  1.2 逻辑回归核心概念
 *  二、逻辑回归Demo
 *   *  2.1 数据准备
     *  2.2 创建逻辑回归分类器
     *  2.3 分类器预测
 *  三、逻辑回归实战
 *   *  3.1 数据准备
     *  3.2 数据划分与模型创建
     *  3.3 预测数据评估模型
 *  四、参数选择
 *  五、总结
 *  六、参考资料

本文属于我的机器学习/深度学习系列文章，[点此查看系列文章目录][Link 1]

# 前言 #

本文主要通过文字和代码样例讲述**逻辑回归**的原理（包含逻辑回归的基础概念与推导）和实如何在实践中使用逻辑回归，并用`sklearn`库实现在实际数据上分类的测试。

# 一、什么是逻辑回归 #

## 1.1 逻辑回归基础概念 ##

**逻辑回归属于线性分类器，通过`Logistic`函数(`Sigmoid`函数)，将数据特征映射到0～1区间的一个概率值（样本属于正例的可能性），通过与0.5的比对得出数据所属的分类。**

*  `Logistic`函数表达式  
     f ( z ) = 1 1 + e − z z = w T x + w 0 f(\\mathbf z) = \\frac\{1\}\{1+e^\{-\\mathbf z\}\}\\\\ \\mathbf z = \\mathbf w^T \\mathbf x + w\_0 f(z)=1\+e−z1z=wTx\+w0  
    其中， x \\mathbf x x是数据的特征向量( x 0 , x 1 , . . . , x n x\_0,x\_1,...,x\_n x0,x1,...,xn)， w \\mathbf w w是参数向量（需要数据拟合）， w 0 w\_0 w0是偏置。关于第二行表达式的含义具体可以参考[机器学习：线性分类问题（基础知识）][Link 2]。
    
    > `Logistic`相当于在原始用超平面划分数据的情况下多了一层映射，这层映射的好处在于对于靠近0附近的数据可以将其拉开更大的间隔提高区分度。
 *  `Logistic`函数图像  
    ![在这里插入图片描述][20200816142832108.png_pic_center]

上述计算得到了在给定数据点后，通过`Logistic`函数计算得到的预测值，显然一开始预测值与真实值是有偏差的，通过**损失函数**计算偏差，**优化算法**缩小偏差，最终得到模型适合的参数。

## 1.2 逻辑回归核心概念 ##

搞懂逻辑回归需要弄懂以下几个点：

*  **逻辑回归为什么要使用`sigmoid`函数**
 *  **为什么`sigmoid`激活后的值是分类的概率**
 *  **逻辑回归的损失函数如何推导**
 *  **逻辑回归优化参数的过程**

注意这几个问题是有先后逻辑关系的，一个个来。

--------------------

*  **逻辑回归为什么要使用`sigmoid`函数&为什么`sigmoid`激活后的值是分类的概率**  
    这两个问题实际上可放在一起讨论，并不是简简单单地因为`sigmoid`值域是0-1，逻辑回归采用`sigmoid`函数的前提是我们假设所有的样本数据点服从伯努利分布，通过伯努利分布形式展开与指数簇分布形式对比发现`sigmoid`函数。具体的内容可以参考这篇文章：[逻辑回归为什么用Sigmoid？][Sigmoid]
 *  **逻辑回归的损失函数如何推导**  
    前面说了我们假设样本服从伯努利分布，在训练过程中我们通常有一堆样本点( x i , y i \\mathbf x\_i,y\_i xi,yi)，假设样本为1类的概率为p，则为0类的概率为1-p，给定样本 x i \\mathbf x\_i xi，其分类为 y i y\_i yi的概率表示如下：  
     P ( y i ∣ x i ) = p y i ( 1 − p ) 1 − y i P(y\_i|\\mathbf x\_i) =p^\{y\_i\}(1-p)^\{1-y\_i\} P(yi∣xi)=pyi(1−p)1−yi  
    由于服从伯努利分布，那么总的概率就是所有样本点概率乘积：  
     P 总 = ∏ i = 1 n P ( y i ∣ x i ) = ∏ i = 1 n p y i ( 1 − p ) ( 1 − y i ) p = 1 1 + e − w T x + w 0 P\_总 = \\prod\_\{i=1\}^nP(y\_i|\\mathbf x\_i)=\\prod\_\{i=1\}^np^\{y\_i\}(1-p)^\{(1-y\_i)\}\\\\ p=\\frac\{1\}\{1+e^\{-\\mathbf w^T\\mathbf x+w\_0\}\} P总=i=1∏nP(yi∣xi)=i=1∏npyi(1−p)(1−yi)p=1\+e−wTx\+w01  
    由于连乘不好计算，两边同时取对数得到和的表达形式：  
     F ( w ) = ln ⁡ ( P 总 ) = ∑ i = 1 n y i ln ⁡ p + ( 1 − y i ) ln ⁡ ( 1 − p ) p = 1 1 + e − w T x + w 0 F(\\mathbf w) = \\ln(P\_总)=\\sum\_\{i=1\}^ny\_i\\ln p+(1-y\_i)\\ln (1-p)\\\\ p=\\frac\{1\}\{1+e^\{-\\mathbf w^T\\mathbf x+w\_0\}\} F(w)=ln(P总)=i=1∑nyilnp\+(1−yi)ln(1−p)p=1\+e−wTx\+w01  
    上面的结果实际上是拿到所有样本后输出对应标签正确的概率，我们希望这个值越大越好，从损失函数的角度我们可以通过添加负号用于求取最小值。所以一般逻辑回归的损失函数可以取成 − F ( w ) -F(\\mathbf w) −F(w)
 *  **逻辑回归优化参数的过程**  
    有了损失函数，只需要朝着预测值与实际值贴近的角度优化参数 w \\mathbf w w即可，对损失函数的优化实际上就是极大似然估计：  
     w ∗ = − arg min ⁡ w F ( w ) \\mathbf w\* = -\\argmin\_\{\\mathbf w\} F(\\mathbf w) w∗=−wargminF(w)  
    算法中对最优解的获取最常用的就是梯度下降算法，为此需要先求出 F ( w ) F(\\mathbf w) F(w)的梯度(求解的过程中注意只有p中含有变量 w \\mathbf w w，为了方便计算，用增广表示省略 w 0 w\_0 w0)：  
     ∇ F ( w ) = ∇ ( ∑ i = 1 n y i ln ⁡ p + ( 1 − y i ) ln ⁡ ( 1 − p ) ) = ∑ i = 1 n y i p ′ p + ( 1 − y i ) − p ′ 1 − p \\nabla F(\\mathbf w) = \\nabla(\\sum\_\{i=1\}^ny\_i\\ln p+(1-y\_i)\\ln (1-p))\\\\ = \\sum\_\{i=1\}^ny\_i\\frac\{p'\}\{p\} + (1-y\_i)\\frac\{-p' \}\{1-p\} ∇F(w)=∇(i=1∑nyilnp\+(1−yi)ln(1−p))=i=1∑nyipp′\+(1−yi)1−p−p′  
    到了这一步还需要 p = 1 1 + e − w T x p=\\frac\{1\}\{1+e^\{-\\mathbf w^T\\mathbf x\}\} p=1\+e−wTx1的导数（对 w \\mathbf w w求导），这个比较好推，直接上结果 p ′ = p ( 1 − p ) x p'=p(1-p)\\mathbf x p′=p(1−p)x,接着上面的推导：  
     ∇ F ( w ) = ∑ i = 1 n y i ( 1 − p ) x + ( 1 − y i ) − p x = ∑ i = 1 n ( y i − p ) x p = 1 1 + e − w T x \\nabla F(\\mathbf w) = \\sum\_\{i=1\}^ny\_i(1-p)\\mathbf x + (1-y\_i)-p\\mathbf x\\\\ =\\sum\_\{i=1\}^n(y\_i-p)\\mathbf x\\\\ p=\\frac\{1\}\{1+e^\{-\\mathbf w^T\\mathbf x\}\} ∇F(w)=i=1∑nyi(1−p)x\+(1−yi)−px=i=1∑n(yi−p)xp=1\+e−wTx1  
    有了梯度之后，根据梯度下降算法，初始化 w \\mathbf w w，通过下式优化参数：  
     w t + 1 = w t − α ∇ F ( w ) \\mathbf w\_\{t+1\} = \\mathbf w\_t -\\alpha \\nabla F(\\mathbf w) wt\+1=wt−α∇F(w)

这部分推导并不难，建议自己手动推导一遍假设印象。

# 二、逻辑回归Demo #

逻辑回归本质上还是属于线性分类器，以二维平面角度看就是一条将不同类型的点集一分为二的直线。下面我们创建简单数据和利用`sklearn`提供的`LogisticRegression`类实现一个简要的逻辑回归过程：

## 2.1 数据准备 ##

*  必要库导入
    
        ## 基础函数库
        import numpy as np 
        
        ## 导入画图库
        import matplotlib.pyplot as plt
        import seaborn as sns
        
        ## 导入逻辑回归模型函数
        from sklearn.linear_model import LogisticRegression
 *  数据创建与可视化
    
        ## 构造数据集
        X = np.array([[-1, -2], [-2, -1], [-3, -2], [1, 3], [2, 1], [3, 2]])
        y = np.array([0, 0, 0, 1, 1, 1])
        
        ## 可视化构造的数据样本点
        fig = plt.figure(figsize=(6,5))
        plt.scatter(X[:,0],X[:,1], c=y, s=50, cmap='viridis')
        plt.title('Dataset')
        plt.show()
    
    ![在这里插入图片描述][20200816145729733.png_pic_center]
    
    > 根据我们标签设置的结果，左下角为0类，右上角为1类

## 2.2 创建逻辑回归分类器 ##

*  逻辑回归分类器创建与拟合数据点（可视化分类器决策边界）
    
        # 创建分类器
        lr = LogisticRegression()
        lr.fit(X,y)  # 拟合数据点
        
        ##查看其对应模型的w
        print('the weight(w) of Logistic Regression:',lr.coef_)
        ##查看其对应模型的w0
        print('the intercept(w0) of Logistic Regression:',lr.intercept_)
        
        # 可视化决策边界
        plt.figure()
        plt.scatter(X[:,0],X[:,1], c=y, s=50, cmap='viridis')
        plt.title('Dataset')
        
        nx, ny = 200, 100   # 指定点个数
        x_min, x_max = plt.xlim()  # x轴的边界
        y_min, y_max = plt.ylim()  # y轴的边界
        
        x_grid, y_grid = np.meshgrid(np.linspace(x_min, x_max, nx),np.linspace(y_min, y_max, ny))   # 得到所有可能坐标点组合，以linespace生成的数据点
        
        # ravel()将n*m的数组转换为(n*m,1)，np.c_([],[])按行连接两个矩阵,
        z_proba = lr.predict_proba(np.c_[x_grid.ravel(), y_grid.ravel()])   # 由此得到所有可能坐标点输入后的概率值, z_proba:(20000,2)
        z_proba = z_proba[:, 1].reshape(x_grid.shape)
        
        plt.contour(x_grid, y_grid, z_proba, 1, linewidths=2., colors='blue')  # 绘制等高线，找到所有经过逻辑回归后值相同的点，取中间的等高线
        
        plt.show()
    
    ![在这里插入图片描述][20200816150609232.png_pic_center]
    
    > 这段代码主要是通过了以`Logistic`函数映射点的结果绘制等高线，然后取一条等高线即可，线上的值通过分类器分类得到的概率值相同。

## 2.3 分类器预测 ##

*  分类器对新数据点预测  
    取新预测点`(0,-1),(1,2)`用分类器进行预测其分类概率
    
        # 新的预测点
        x_fearures_new1 = np.array([[0, -1]])
        x_fearures_new2 = np.array([[1, 2]])
        
        # 预测分类
        y_label_new1_predict=lr.predict(x_fearures_new1)
        y_label_new2_predict=lr.predict(x_fearures_new2)
        print('The New point 1 predict class:\n',y_label_new1_predict)  # [0]
        print('The New point 2 predict class:\n',y_label_new2_predict)  # 
        
        # 预测分类概率
        y_label_new1_predict_proba=lr.predict_proba(x_fearures_new1)
        y_label_new2_predict_proba=lr.predict_proba(x_fearures_new2)
        print('The New point 1 predict Probability of each class:\n',y_label_new1_predict_proba)
        print('The New point 2 predict Probability of each class:\n',y_label_new2_predict_proba)
    
    ![> 可以发现][20200816162516925.png_pic_center]

# 三、逻辑回归实战 #

将逻辑回归分类器应用到实际问题中，实际上就是将上面Demo中特征向量和标签替换成真实数据中的结果。总的过程实际上与Demo类似，只不过添加了评估。

实战采用了`鸢尾花数据集`，它在`sklearn.datasets`包中可以直接调用，关于该数据集的介绍，网上有许多，这里给出一个[鸢尾花数据集][Link 3]。

## 3.1 数据准备 ##

from sklearn.datasets import load_iris
    import pandas as pd
    
    iris = load_iris() #得到数据特征，包含data,target,feature_names, target_names,DESCR等信息
    df_X = pd.DataFrame(data=iris.data, columns=iris.feature_names)
    y = iris.target
    df_X.describe()

`load_iris`已经很好地封装了该数据集的内容，在实际任务中我们可能需要更多地手动将特征部分和标签部分提取出来，用`DataFrame`封装数据的好处是可以利用`pandas`对数据进行方便地查看、分析和统计。

## 3.2 数据划分与模型创建 ##

from sklearn.model_selection import train_test_split
    from sklearn.linear_model import LogisticRegression
    X_train,X_test,y_train,y_test = train_test_split(df_X,y, test_size=0.2, random_state=20200816)
    
    lr = LogisticRegression()
    lr.fit(X_train,y_train)
    
    ##查看其对应的w，3分类包含三个逻辑回归的参数
    print('the weight(w) of Logistic Regression:\n',lr.coef_)
    ##查看其对应的w0
    print('the intercept(w0) of Logistic Regression:\n',lr.intercept_)

这里用到了三分类，而逻辑回归是二分类器，所以需要三个，对应的 w , w 0 \\mathbf w,w\_0 w,w0也就是三个。

## 3.3 预测数据评估模型 ##

用训练好的模型预测结果，对结果进行评估说明模型的效果，主要从

*  `Accuracy`：准确率，最直观的评价标准
 *  `confusion matrix`：混淆矩阵，每个类别被划分的情况

> 因为鸢尾花数据三个类别样本数量相近，所以这两个评估指标已经足够描述分类器性能。

from sklearn import metrics
    # 预测
    y_train_pred=lr.predict(X_train)
    y_test_pred=lr.predict(X_test)
    
    ##利用accuracy（准确度）【预测正确的样本数目占总预测样本数目的比例】评估模型效果
    print('The accuracy on train set is:',metrics.accuracy_score(y_train,y_train_pred))
    print('The accuracy on test set is:',metrics.accuracy_score(y_test,y_test_pred))
    
    # 绘制混淆矩阵
    confusion_matrix_result=metrics.confusion_matrix(y_test,y_test_pred)
    print('The confusion matrix result:\n',confusion_matrix_result)
    
    ##利用热力图对于结果进行可视化
    plt.figure(figsize=(8,6))
    sns.heatmap(confusion_matrix_result,annot=True,cmap='Blues')
    plt.xlabel('Predicted labels')
    plt.ylabel('True labels')
    plt.show()

![在这里插入图片描述][20200816185915550.png_pic_center]

# 四、参数选择 #

前面对`LogisticRegression`的使用都是非常简单的，没有对参数进行设置，实际应用中可能会根据数据的需要对模型参数进行调整，这里主要说明`LogisticRegression`的几个重要参数：

*  `penalty`：正则项，防止模型过拟合，可以选`l1`,`l2`(默认)
 *  `C`：正则化项强度的倒数，数值越小，正则化强度越大，实际上就是对模型的惩罚力度越大，默认1.0
 *  `fit_intercept`：是否添加偏置 w 0 w\_0 w0，默认`True`
 *  `solver`：优化算法，不同的优化算法对应于不同的样本数(优化算法用于减少误差)，具体有：
    
     *  `liblinear`：默认，适合小数据量
     *  `sag/saga`:在大数据集上运行更快
     *  `lbfgs`：拟牛顿法  
        更具体的信息如下表：  
        ![在这里插入图片描述][20200816192532888.png_pic_center]
    
    > 也可以参考[这篇文章][Link 4]对这几个参数选择的建议
 *  `max_iter`：最大迭代次数，默认100，这个参数在数据量多，数据特征多的情况下需要调整尽可能大，保证最佳的拟合效果

剩余的参数大多可以默认，具体情况具体分析，对于参数的选择还是要多动手多测试才有经验。

# 五、总结 #

本文介绍了逻辑回归的原理，本质上是在线性回归外加了一层映射函数，获得类别的概率，同时通过Demo和实战使用了`sklearn`中的`LogisticRegression`，归结使用逻辑回归对数据集进行分类预测的步骤：

1.  导入必要数据包(`numpy`,`pandas`,`matplotlib.pyplot`,`seaborn`)
2.  导入数据：若是来自文件的数据(csv)，用`pandas`导入有利于对数据特征进行统计、分析
3.  创建模型拟合数据:借助`sklearn`包能够快速创建`LogisticRegression`分类器，根据实际的需要设置参数，`fit`传入特征和标签数据
4.  预测结果并评估：从`Accuracy`,`Precession`,`Recall`,`Confusion matrix`等角度入手。

# 六、参考资料 #

*  [阿里云天池][Link 5]
 *  [sklearn中文文档][sklearn]
 *  [逻辑回归 logistics regression 公式推导][logistics regression]

[Link 1]: https://www.gentlecp.com/articles/465.html
[Link 2]: https://blog.csdn.net/GentleCP/article/details/101626181
[20200816142832108.png_pic_center]: /images/20221124/2f7965d14a8a4d9c852d40d25cfdc7cb.png
[Sigmoid]: https://zhuanlan.zhihu.com/p/59137998
[20200816145729733.png_pic_center]: /images/20221124/38ea8a4e5f064cf9b8c390f557b65fa6.png
[20200816150609232.png_pic_center]: /images/20221124/17a92a10aae9476c91a72172e862c9b4.png
[20200816162516925.png_pic_center]: /images/20221124/a9a2bb4cecc94d159c55c970e2a49d93.png
[Link 3]: https://www.jianshu.com/p/6ada344f91ce
[20200816185915550.png_pic_center]: /images/20221124/38bd4a4775ef48f4b14a840b3356bc05.png
[20200816192532888.png_pic_center]: /images/20221124/d584ca2f376b4f6db46850ba6aae5799.png
[Link 4]: https://www.cnblogs.com/webRobot/p/11781078.html
[Link 5]: https://developer.aliyun.com/ai/scenario/9ad3416619b1423180f656d1c9ae44f7
[sklearn]: https://sklearn.apachecn.org/
[logistics regression]: https://zhuanlan.zhihu.com/p/44591359