Logistic 回归分类算法原理分析和实战

偏执的太偏执、 2023-02-11 03:07 144阅读 0赞

## Logistic 回归分类算法原理分析和实战 ##

## 前言 ##

前面咱们已经学习完了KNN、决策树、朴素贝叶斯算法，这些都是解决分类问题的。今天，咱们要讲的也是解决分类问题，叫做Logistic 回归分类算法。

源代码已上传至Github，有需要的自取 [Logistic 回归分类算法][Logistic]

## Logistic 回归方程原理 ##

如果大家了解线性回归，一定知道，在线性回归中，我们使用差平方和来计算损失值，使用梯度下降法来优化参数。

如果之前没有了解，没关系，咱们就说的慢一点、多一点。

### 一、梯度下降法 ###

**偏导数**

![img][]

从图中，我们可以很容易的去找到该图像的最低点，也就是图中大概T点的位置。但是，假如你不知道呢，如何去慢慢的找到这个最低点呢？咱们先来看P0点的切线斜率，也等于该点的导数值,设为α。因为这个切线与x轴的角度小于90°，所以p0点的倒数值大于0.我们有了这个讯息，相当于知道了方向，于是就有了这个公式：X = X-a \* α a 为步长。由于α>0,所以x的值在慢慢减小，逐渐靠近T。当X在T点时，该点的切线为水平线，即导数为0，所以此时X=X-a \* 0,x值不再变化，此时X为该函数的最小值的取值点。

上面说的都是x，y二维坐标系，扩展为多维坐标系时，导数的概念就变成了偏导数，但是原理都是一样的，朝着最低点的方向前进。然后上述过程在多维时就变成了**梯度下降法**。

**梯度下降法**

梯度的方向，表示图形增长最快的方向。正如上图所示，每一点的切线方向，就是函数值变化最快的方向。

举个例子，**一个想从山峰走向山底的盲人，他看不见坡谷在哪，但可以伸脚探索身边的坡度（当前点的导数值，也称为梯度）。那么，求解Loss函数最小值可以“从当前的参数取值，一步步的按照下坡的方向下降，直到走到最低点”实现。**

梯度下降公式：

![在这里插入图片描述][20200521104511826.png]

J(Θ)为代价函数，  
![在这里插入图片描述][20200521104627421.png]是线性模型的的权值,与后面公式中的w作用一样（y =w0+x \* w1+x \* w2 ）

### 二、Sigmoid函数的引入 ###

Sigmoid函数图像和公式如下图所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x6eDE1OTk1MQ_size_16_color_FFFFFF_t_70]  
从图中我们可以看到，函数值的范围在0-1之间，并且z等于0时，函数值为0.5.当变量z无限大时，函数值g趋近于1，当变量z无限小时，函数值g趋近于0.

在我们处理分类问题时，我们需要模型输出一个0-1之间的数来表示属于某一类的概率，这里我们假设某一类为第一类。当输出值大于0.5时，可认为该输入数据属于第一类，当输出值小于0.5时，可认为该输入数据不属于第一类。

\*\*为什么要使用Sigmoid函数，而不是直接判定模型值是否大于零？\*\*从公式上来看，z作为g函数的变量，同时也是模型的输出值，那么我直接判断z>0 or z<0 就好了，为什么还要使用这个Sigmoid进行转化一下呢？

1.  **方便计算损失值，衡量模型精准度**。在进行分类任务中，数据集的标签是以0、1这样的数字来表示所属的分类(这里以二分类作为例子)，如果我们不使用Sigmoid函数，模型输出值就会超过0-1之间范围。假设有一个数据属于1类，模型输出值z特别大，如果使用Sigmoid函数，输出g就会很趋近于1，计算损失值的时候就会很小。但是如果不适用这个函数的话，使用输出值z计算损失值，会很大，再进行反向优化参数的时候，就会认为模型不精准，其实并不是这样。
2.  上面我们使用Sigmoid函数处理模型最终输出值，这整个模型称之为广义线性模型。有大佬给出了一些推导，结论是当因变量(y)符合伯努利分布(y值取值在0-1)时，广义线性回归模型属于逻辑回归。[推导过程][Link 1]

### 三、代价函数 ###

在线性回归中，我们使用差平方和作为代价函数，公式为：  
![在这里插入图片描述][20200521104825129.png]  
，有的没有前面的1/2n，也没关系，这对于我们的结果没有什么影响，只是为了后面公式推导更加方便一些。

如果使用图像表示的话，就是下图中黄色线的长度平方和（红色点为数据点，灰色线是我们需要拟合的直线）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x6eDE1OTk1MQ_size_16_color_FFFFFF_t_70 1]

但是在逻辑回归中，差平方和公式就不适用了，原因如下：

*  由于Sigmoid函数在自变量很大的时候，图形趋近于一条直线，表明其导数值趋近于0。如果使用差平方和公式最为代价函数，我们就需要求Sigmoid函数的偏导数，这就会导致在进行参数更新时，参数更新速度会变得非常慢。
 *  而使用交叉熵损失函数作为代价函数，不仅在求偏导中能够将Sigmoid函数给消除掉，而且该函数是凸函数，只有一个最优解。带有Sigmoid函数的差平方和公式不是一个凸函数，会有很多局部最优解。
 *  由信息论中KL散度推导出来，更能衡量数据分布与数据在模型中分布的不同。知乎大佬写的交叉熵的理解[为什么交叉熵（cross-entropy）可以用于计算代价？][cross-entropy]

### 四、参数更新公式推导 ###

Sigmoid 公式\[1\]为：

![在这里插入图片描述][20200521104913303.png]  
前面我们使用交叉熵作为损失函数，交叉熵的公式\[2\]为：  
![在这里插入图片描述][20200521104920563.png]  
损失函数公式\[3\]为：  
![在这里插入图片描述][20200521104936595.png]

梯度下降参数更新公式\[4\]为：

![在这里插入图片描述][2020052110495063.png]  
将公式1 、公式2 、公式3带入公式4中，求得最终结果公式\[5\]为：

![在这里插入图片描述][20200521105000702.png]  
具体的推导过程如下图：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x6eDE1OTk1MQ_size_16_color_FFFFFF_t_70 2]  
图中h函数为之前我们声明的Sigmoid函数G

## Logistic回归分类源代码解析 ##

### 数据介绍 ###

这里我们采用的数据共有三列，前两列为数据的属性，第三列为数据的所属类。一共由100条数据，由于数据是打乱分布的，这里我们直接去前80条数据作为实验数据，后二十条数据作为测试数据，测试模型精准度。

### 模型介绍 ###

这里我们使用的模型如下：

![在这里插入图片描述][20200521105118213.png]  
![在这里插入图片描述][20200521105125608.png]

最终函数G输出概率值。

先来看一张分类过程图  
![在这里插入图片描述][20200521105148863.gif]

### 1.导入数据 ###

def loaddata(filename):
        data = np.loadtxt(filename)
        dataset = []
        for i in range(len(data)):
            dataset.append([1,data[i,0],data[i,1],data[i,2]])
        return np.array(dataset)

由于在我们的模型中，有一个常数项w0，所以，我们需要在原来数据的基础上加一列常量1

### 2. 构造Sigmoid函数 ###

def Sigmoid(x):
        return (1/(1+np.exp(-x)))

### 3. 创建逻辑回归类以及相关类方法 ###

class Logistic:
        def __init__(self):
            self.w = np.array([1,1,1])#初始化
    
        def train(self,dataset,epoch=50,a=0.001):
            y = dataset[:,-1]#(80,1)
            data = dataset[:,:-1]#(80,3)
            print("shape(data)",np.shape(data))
            for i in range(epoch):
                h = Sigmoid(np.matmul(data,self.w))
                error = h-y#(80,1)
                self.w = self.w-a*np.matmul(data.T,error)
                if(i!=0 and i%50==0):
                    self.showimg(dataset,i)
            print("self.w0",self.w)
        def test(self,dataset):
            y = dataset[:,-1]
            data = dataset[:,:-1]
            h = Sigmoid(np.matmul(data,self.w))
            h[h>0.5]=1
            h[h<0.5]=0
            result = h
            error=0
            for i in range(len(result)):
                if(result[i]!=y[i]):
                    error+=1
            print(" the error is {}%:".format(100*error/float(len(result))))
    
        def showimg(self,dataset,i):
            x = np.arange(-3.0,3.0,0.1)
            x2 = (-self.w[0]-x*self.w[1])/self.w[2]
            plt.scatter([dataset[dataset[:,-1]==0][:,1]],[dataset[dataset[:,-1]==0][:,2]],color='',marker='o',edgecolors='green',linewidths=3)
            plt.scatter([dataset[dataset[:,-1]==1][:,1]],[dataset[dataset[:,-1]==1][:,2]],color='',marker='o',edgecolors='red',linewidths=3)
            plt.plot(x,x2)
            plt.title("迭代第{}次".format(i))
            plt.savefig('datasets/img{}.png'.format(i))
            plt.show()

下面是方法的详细介绍

*  init 类的初始化方法，调用类时自动执行，里面定义了一个长度为3 numpy数组，初始化为1
 *  train 训练方法，参数epoch 为迭代次数，a为步长，也叫学习率。np.matmal 两个数组的矩阵乘积，这里我们采用矩阵的形式，直接进行求和，更加方便。

self.w = self.w-a*np.matmul(data.T,error)

这个是参数的更新，对应的就是前面公式5。可能直接看代码，数据是如何进行计算的不太好理解，下面我手动举个简单的例子说明一下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x6eDE1OTk1MQ_size_16_color_FFFFFF_t_70 3]

*  test 测试函数，用于测试训练过的模型精准度
 *  showimg() 用于显示分类情况

## 总结 ##

逻辑回归算法中涉及到很多概率论和信息论的东西，由于这部分知识只是零碎看了几篇文章，所以不好在这里给大家做系统讲解，文末会给大家一些大佬写的一些资料，有兴趣的可以去看看。

在文中，我们使用了一般的梯度下降法，还有可以尝试更多优化的梯度下降法，比如随机梯度下降法，能够消耗更小的内存达到和前者几乎一样的效果。

下一篇来介绍业界公认最好的分类器—SVM 支持向量机

**参考资料**

*  [什么是信息熵][Link 2]
 *  [关于numpy的 matmul函数 ][numpy_ matmul_]
 *  [交叉熵损失函数][Link 3]
 *  [为什么交叉熵（cross-entropy）可以用于计算代价？][cross-entropy]

[Logistic]: https://github.com/lzx1019056432/Be-Friendly-To-New-People/tree/master/Logistic%E5%9B%9E%E5%BD%92%E7%AE%97%E6%B3%95
[img]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9haS1zdHVkaW8tc3RhdGljLW9ubGluZS5jZG4uYmNlYm9zLmNvbS85NGYwNDM3ZTZhNDU0YTA2ODJmM2I4MzFjOTZhNjJiZGFmNDA4OThhZjI1MTQ1ZWM5YjViNTBiYzgwMzkxZjVj?x-oss-process=image/format,png
[20200521104511826.png]: https://img-blog.csdnimg.cn/20200521104511826.png
[20200521104627421.png]: https://img-blog.csdnimg.cn/20200521104627421.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x6eDE1OTk1MQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200521104803434.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x6eDE1OTk1MQ==,size_16,color_FFFFFF,t_70
[Link 1]: https://zhuanlan.zhihu.com/p/59137998
[20200521104825129.png]: https://img-blog.csdnimg.cn/20200521104825129.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x6eDE1OTk1MQ_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200521104849624.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x6eDE1OTk1MQ==,size_16,color_FFFFFF,t_70
[cross-entropy]: https://www.zhihu.com/question/65288314
[20200521104913303.png]: https://img-blog.csdnimg.cn/20200521104913303.png
[20200521104920563.png]: https://img-blog.csdnimg.cn/20200521104920563.png
[20200521104936595.png]: https://img-blog.csdnimg.cn/20200521104936595.png
[2020052110495063.png]: https://img-blog.csdnimg.cn/2020052110495063.png
[20200521105000702.png]: https://img-blog.csdnimg.cn/20200521105000702.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x6eDE1OTk1MQ_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200521105026181.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x6eDE1OTk1MQ==,size_16,color_FFFFFF,t_70
[20200521105118213.png]: https://img-blog.csdnimg.cn/20200521105118213.png
[20200521105125608.png]: https://img-blog.csdnimg.cn/20200521105125608.png
[20200521105148863.gif]: https://img-blog.csdnimg.cn/20200521105148863.gif
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x6eDE1OTk1MQ_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200521105221307.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x6eDE1OTk1MQ==,size_16,color_FFFFFF,t_70
[Link 2]: https://www.zhihu.com/question/22178202
[numpy_ matmul_]: https://www.runoob.com/numpy/numpy-linear-algebra.html
[Link 3]: https://zhuanlan.zhihu.com/p/35709485