Logistic回归

最新推荐文章于 2023-05-09 09:29:57 发布

铜制匠

最新推荐文章于 2023-05-09 09:29:57 发布

阅读量456

点赞数 1

文章标签：回归逻辑回归

本文链接：https://blog.csdn.net/qq_51994140/article/details/128221728

版权

什么是Logistic回归

Logistic回归的一般过程

基于 Logistic回归和Sigmoid函数的分类

什么是Logistic回归

假设现在有一些数据点，我们用一条直线对这些点进行拟合（该线称为最佳拟合直线），这个拟合过程就称作回归。

logistic回归是一种广义线性回归，因此与多重线性回归分析有很多相同之处。它们的模型形式基本上相同，都具有w‘x+b，其中w和b是待求参数，其区别在于他们的因变量不同，多重线性回归直接将w‘x+b作为因变量，即y =w‘x+b，而logistic回归则通过函数L将w‘x+b对应一个隐状态p，p =L(w‘x+b),然后根据p 与1-p的大小决定因变量的值。如果L是logistic函数，就是logistic回归，如果L是多项式函数就是多项式回归。

logistic回归的因变量可以是二分类的，也可以是多分类的，但是二分类的更为常用，也更加容易解释，多类可以使用softmax方法进行处理。实际中最为常用的就是二分类的logistic回归。

利用Logistic回归进行分类的主要思想是：根据现有数据对分类边界线建立回归公式，以此进行分类。

Logistic回归的一般过程

1.收集数据

2.准备数据：由于需要进行距离计算，因此要求数据类型为数值型。另外，结构化数据格式则最佳。

3.分析数据

4.训练算法：训练的目的是为了找到最佳的分类回归系数

5.测试算法

6.使用算法：首先，我们需要输入一些数据，并将其转化成对应的结构化数值；接着，基于训练好的回归系数就可以对这些数值进行简单的回归计算，判定他们属于哪个类别；在这之后，我们就可以在输出的类别上做一些其他分析工作。

基于 Logistic回归和Sigmoid函数的分类

我们想要的函数应该是，能接受所有的输人然后预测出类别。例如，在两个类的情况下，上述函数输出0或 1。或许你之前接触过具有这种性质的函数，该函数称为海维塞德阶跃函数 (Heaviside step function) ,或者直接称为单位阶跃函数。然而，海维塞德阶跃函数的问题在于：该函数在跳跃点上从0瞬间跳跃到1，这个瞬间跳跃过程有时很难处理。幸好，另一个函数也有类似的性质® ，且数学上更易处理，这就是sigmoid函数，sigmoid函数具体的计算公式如下

$\sigma \left ( z \right ) =\frac{1}{1+e^{-z} }$

下图给出了Sigmoid函数在不同坐标尺度下的两条曲线图

当x 为 0时， Sigmoid 函数值为 0.5 。

随着x 的增大，对应的Sigmoid 值将逼近于 1; 而随着x 的减小， Sigmoid 值将逼近于 0 。如果横坐标刻度足够大，Sigmoid函数看起来很像一个阶跃函数。

因此，为了实现Logstic回归分类器，我们可以在每个特征上都乘以一个回归系数，然后把

所有的结果值相加，将这个总和代人Sigmoid 函数中，进而得到一个范围在 0 〜 1 之间的数值。

任何大于0.5 的数据被分入 1 类，小于 0.5 即被归入 0 类。所以，Logsitc 回归也可以被看成是一种概率估计。

确定了分类器的函数形式之后，现在的问题变成了：最佳回归系数是多少？如何确定它们

的大小？

基于最优化方法的最佳回归系数确定

Sigmoid 函数的输人记为z ，由下面公式得出：

$z=w_0x_0,+w_1x_1+w_2x_2+ \cdots+w_nx_n$

如果采用向量的写法，上述公式可以写成 $z=w^{T}x$ , 它表示将这两个数值向量对应元素相乘然后

全部加起来即得到z 值。其中的向量x是分类器的输人数据，向量w就是我们要找到的最佳参数

( 系数 ) , 从而使得分类器尽可能地精确。

下面首先介绍梯度上升的最优化方法，我们将学习到如何使用该方法求得数据集的最佳

参数。接下来，展示如何绘制梯度上升法产生的决策边界图，该图能将梯度上升法的分类效

果可视化地呈现出来。最后我们将学习随机梯度上升算法，以及如何对其进行修改以获得更

好的结果。

梯度上升法

梯度上升法基于的思想是：要找到某函数的最大值，最好的方法是沿着该函数的梯度方向探寻。如果梯度记为▽, 则函数f(x,y)的梯度由下式表示:

这个梯度意味着要沿x的方向移动 $\frac{\partial f(x,y)}{\partial x}$ ，沿y的方向移动 $\frac{\partial f(x,y)}{\partial y}$ ，其中，函数f(x,y)必须要在待计算的点上有定义并且可微。具体例子如下：

梯度上升算法到达每个点后都会重新估计移动的方向。从P 0 开始，计算完该点

的梯度，函数就根据梯度移动到下一点P1 。在P 1 点，梯度再次被重新计算，并

沿新的梯度方向移动到P 2 。如此循环迭代，直到满足停止条件。迭代的过程中，

梯度算子总是保证我们能选取到最佳的移动方向。

图中的梯度上升算法沿梯度方向移动了一步。可以看到，梯度算子总是指向函数值增长最快的方向。这里所说的是移动方向，而未提到移动量的大小。该量值称为步长，记做α。用向量来表示的话，梯度上升算法的迭代公式如下：w:=w+α∇wf(w)

该公式将一直被迭代执行，直至达到某个停止条件为止，比如迭代次数达到某个指定值或算

法达到某个可以允许的误差范围。

读取数据

def loadDataSet():
    dataMat = []                                                        #创建数据列表
    labelMat = []                                                        #创建标签列表
    fr = open('/学习/机器学习作业/TestSet.txt')                          #打开文件
    for line in fr.readlines():                                            #逐行读取
        lineArr = line.strip().split()                                    #去回车，放入列表
        dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])        #添加数据
        labelMat.append(int(lineArr[2]))                                #添加标签
    fr.close()                                                            #关闭文件
    return dataMat, labelMat                                            #返回

Sigmoid函数

# sigmoid函数
def sigmoid(inX):
    return 1.0 / (1 + exp(-inX))

使用梯度上升找到最佳参数

梯度上升法的伪代码如下：

每个回归系数初始化为 1

重复R次：

计算整个数据集的梯度

使用alpha x gradient 回归系数的向量

返回回归系数

普通梯度上升算法实现：

# 梯度上升算法
def gradAscent(dataMatIn, classLabels): 
    #转化为numpye矩阵数据类型                   
    dataMatrix = mat(dataMatIn)                                   
    labelMat = mat(classLabels).transpose()                        
    m, n = shape(dataMatrix)                                       
    alpha = 0.001                                                  
    maxCycles = 500                                                
    weights = ones((n, 1)) 
    #矩阵运算                                        
    for k in range(maxCycles):                                    
        h = sigmoid(dataMatrix * weights)                          
        error = (labelMat - h)                                     
        weights = weights + alpha * dataMatrix.transpose() * error 
    return weights

梯度上升算法的实际工作是在函数 gradAscent()里完成的，该函数有两个参数。第一个参数时dataMatIn，它是一个 2 维Numpy 数组，每列分别代表每个不同的特征，每行则代表每个训练样本。我们现在采用的是100 个样本的简单数据集，它包含了两个特征x 1 和x2 ，再加上第 0维特征x0，所以dataMatIn 里存放的将是100x3 的矩阵。

随机梯度上升算法实现：

普通梯度上升算法在每次更新回归数据时都需要遍历整个数据集，该方法处理100个左右的数据集尚可，但如果有数十亿的样本和成千上万的特征，那么该方法的复杂度就太高了。因此就引入了随机梯度算法。相较于普通的梯度上升算法来说，随机梯度算法一次仅用一个样本点来更新回归系数。

def stocGradAscent1(dataMatrix, classLabels, numIter=150):
    m,n = np.shape(dataMatrix)                                                #返回dataMatrix的大小。m为行数,n为列数。
    weights = np.ones(n)                                                       #参数初始化
    for j in range(numIter):
        dataIndex = list(range(m))
        for i in range(m):
            alpha = 4/(1.0+j+i)+0.01                                         #降低alpha的大小，每次减小1/(j+i)。
            randIndex = int(random.uniform(0,len(dataIndex)))                #随机选取样本
            h = sigmoid(sum(dataMatrix[randIndex]*weights))                  #选择随机选取的一个样本，计算h
            error = classLabels[randIndex] - h                                 #计算误差
            weights = weights + alpha * error * dataMatrix[randIndex]       #更新回归系数
            del(dataIndex[randIndex])                                       #删除已经使用的样本
    return weights                                                            #返回

alpha在每次迭代的时候都会调整，并且，虽然alpha会随着迭代次数不断减小，但永远不会减小到0，因为这里还存在一个常数项。必须这样做的原因是为了保证在多次迭代之后新数据仍然具有一定的影响。如果需要处理的问题是动态变化的，那么可以适当加大上述常数项，来确保新的值获得更大的回归系数。另一点值得注意的是，在降低alpha的函数中，alpha每次减少1/(j+i)，其中j是迭代次数，i是样本点的下标。第二个改进的地方在于跟新回归系数(最优参数)时，只使用一个样本点，并且选择的样本点是随机的，每次迭代不使用已经用过的样本点。这样的方法，就有效地减少了计算量，并保证了回归效果。

画出决策边界

使用Matplotlib进行绘画。代码如下

def plotBestFit(weights):
	dataMat, labelMat = loadDataSet()									
	dataArr = np.array(dataMat)									
	n = np.shape(dataMat)[0]										
	xcord1 = []; ycord1 = []											
	xcord2 = []; ycord2 = []											
	for i in range(n):	
		if int(labelMat[i]) == 1:
			xcord1.append(dataArr[i,1]); ycord1.append(dataArr[i,2])
		else:
			xcord2.append(dataArr[i,1]); ycord2.append(dataArr[i,2])
	fig = plt.figure()
	ax = fig.add_subplot(111)										
	ax.scatter(xcord1, ycord1, s = 20, c = 'red', marker = 's',alpha=.5)
	ax.scatter(xcord2, ycord2, s = 20, c = 'green',alpha=.5)
	x = np.arange(-3.0, 3.0, 0.1)
	y = (-weights[0] - weights[1] * x) / weights[2]
	ax.plot(x, y)
	plt.xlabel('X1'); plt.ylabel('X2')
	plt.show()

整体代码

from matplotlib.font_manager import FontProperties
import matplotlib.pyplot as plt
import numpy as np
import random


def loadDataSet():
    dataMat = []                                                        #创建数据列表
    labelMat = []                                                        #创建标签列表
    fr = open('/学习/机器学习作业/TestSet.txt')                                            #打开文件
    for line in fr.readlines():                                            #逐行读取
        lineArr = line.strip().split()                                    #去回车，放入列表
        dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])        #添加数据
        labelMat.append(int(lineArr[2]))                                #添加标签
    fr.close()                                                            #关闭文件
    return dataMat, labelMat                                            #返回

def sigmoid(inX):
    return 1.0 / (1 + np.exp(-inX))


def plotBestFit(weights):
	dataMat, labelMat = loadDataSet()									
	dataArr = np.array(dataMat)									
	n = np.shape(dataMat)[0]										
	xcord1 = []; ycord1 = []											
	xcord2 = []; ycord2 = []											
	for i in range(n):	
		if int(labelMat[i]) == 1:
			xcord1.append(dataArr[i,1]); ycord1.append(dataArr[i,2])
		else:
			xcord2.append(dataArr[i,1]); ycord2.append(dataArr[i,2])
	fig = plt.figure()
	ax = fig.add_subplot(111)										
	ax.scatter(xcord1, ycord1, s = 20, c = 'red', marker = 's',alpha=.5)
	ax.scatter(xcord2, ycord2, s = 20, c = 'green',alpha=.5)
	x = np.arange(-3.0, 3.0, 0.1)
	y = (-weights[0] - weights[1] * x) / weights[2]
	ax.plot(x, y)
	plt.xlabel('X1'); plt.ylabel('X2')
	plt.show()


def stocGradAscent1(dataMatrix, classLabels, numIter=150):
    m,n = np.shape(dataMatrix)                                                #返回dataMatrix的大小。m为行数,n为列数。
    weights = np.ones(n)                                                       #参数初始化
    for j in range(numIter):
        dataIndex = list(range(m))
        for i in range(m):
            alpha = 4/(1.0+j+i)+0.01                                            #降低alpha的大小，每次减小1/(j+i)。
            randIndex = int(random.uniform(0,len(dataIndex)))                #随机选取样本
            h = sigmoid(sum(dataMatrix[randIndex]*weights))                    #选择随机选取的一个样本，计算h
            error = classLabels[randIndex] - h                                 #计算误差
            weights = weights + alpha * error * dataMatrix[randIndex]       #更新回归系数
            del(dataIndex[randIndex])                                         #删除已经使用的样本
    return weights                                                            #返回

if __name__ == '__main__':
    dataMat, labelMat = loadDataSet()
    weights = stocGradAscent1(np.array(dataMat), labelMat)
    plotBestFit(weights)

数据集

-0.017612 14.053064 0
-1.395634 4.662541 1
-0.752157 6.538620 0
-1.322371 7.152853 0
0.423363 11.054677 0
0.406704 7.067335 1
0.667394 12.741452 0
-2.460150 6.866805 1
0.569411 9.548755 0
-0.026632 10.427743 0
0.850433 6.920334 1
1.347183 13.175500 0
1.176813 3.167020 1
-1.781871 9.097953 0
-0.566606 5.749003 1
0.931635 1.589505 1
-0.024205 6.151823 1
-0.036453 2.690988 1
-0.196949 0.444165 1
1.014459 5.754399 1
1.985298 3.230619 1
-1.693453 -0.557540 1
-0.576525 11.778922 0
-0.346811 -1.678730 1
-2.124484 2.672471 1
1.217916 9.597015 0
-0.733928 9.098687 0
-3.642001 -1.618087 1
0.315985 3.523953 1
1.416614 9.619232 0
-0.386323 3.989286 1
0.556921 8.294984 1
1.224863 11.587360 0
-1.347803 -2.406051 1
1.196604 4.951851 1
0.275221 9.543647 0
0.470575 9.332488 0
-1.889567 9.542662 0
-1.527893 12.150579 0
-1.185247 11.309318 0
-0.445678 3.297303 1
1.042222 6.105155 1
-0.618787 10.320986 0
1.152083 0.548467 1
0.828534 2.676045 1
-1.237728 10.549033 0
-0.683565 -2.166125 1
0.229456 5.921938 1
-0.959885 11.555336 0
0.492911 10.993324 0
0.184992 8.721488 0
-0.355715 10.325976 0
-0.397822 8.058397 0
0.824839 13.730343 0
1.507278 5.027866 1
0.099671 6.835839 1
-0.344008 10.717485 0
1.785928 7.718645 1
-0.918801 11.560217 0
-0.364009 4.747300 1
-0.841722 4.119083 1
0.490426 1.960539 1
-0.007194 9.075792 0
0.356107 12.447863 0
0.342578 12.281162 0
-0.810823 -1.466018 1
2.530777 6.476801 1
1.296683 11.607559 0
0.475487 12.040035 0
-0.783277 11.009725 0
0.074798 11.023650 0
-1.337472 0.468339 1
-0.102781 13.763651 0
-0.147324 2.874846 1
0.518389 9.887035 0
1.015399 7.571882 0
-1.658086 -0.027255 1
1.319944 2.171228 1
2.056216 5.019981 1
-0.851633 4.375691 1
-1.510047 6.061992 0
-1.076637 -3.181888 1
1.821096 10.283990 0
3.010150 8.401766 1
-1.099458 1.688274 1
-0.834872 -1.733869 1
-0.846637 3.849075 1
1.400102 12.628781 0
1.752842 5.468166 1
0.078557 0.059736 1
0.089392 -0.715300 1
1.825662 12.693808 0
0.197445 9.744638 0
0.126117 0.922311 1
-0.679797 1.220530 1
0.677983 2.556666 1
0.761349 10.693862 0
-2.168791 0.143632 1
1.388610 9.341997 0
0.317029 14.739025 0

铜制匠

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Logistic回归

目录什么是Logistic回归Logistic回归的一般过程基于 Logistic回归和Sigmoid函数的分类基于最优化方法的最佳回归系数确定梯度上升法读取数据Sigmoid函数使用梯度上升找到最佳参数普通梯度上升算法实现：随机梯度上升算法实现：画出决策边界整体代码数据集我们想要的函数应该是，能接受所有的输人然后预测出类别。例如，在两个类的情况下，上述函数输出0或 1。或许你之前接触过具有这种性质的函数，该函数称为海维塞德阶跃函数 (Heaviside step function) ,或者直接称为单位
复制链接

扫一扫