[机器学习]Logistic回归

最新推荐文章于 2024-09-04 23:43:50 发布

木诚子♚

最新推荐文章于 2024-09-04 23:43:50 发布

阅读量3.4k

点赞数 1

文章标签：算法 python 机器学习

本文链接：https://blog.csdn.net/qq_49192977/article/details/121455586

版权

逻辑斯蒂回归梯度上升 Sigmoid函数分类器糖尿病诊断

关键词由CSDN通过智能技术生成

1.普通梯度上升算法（在每次更新回归系数(最优参数)时，都需要遍历整个数据集。）

2.随机梯度上升算法

【实战】用Logistic回归模型诊断糖尿病

什么是逻辑斯蒂(Logistic)回归？

由于逻辑斯蒂回归的原理是用逻辑函数把线性回归的结果(-∞,∞)映射到(0,1)，故先介绍线性回归函数和逻辑函数。

1.线性回归函数

线性回归函数的数学表达式：

其中xi是自变量，y是因变量，y的值域为(-∞,∞)，θ0是常数项，θi(i=1,2,...,n)是待求系数，不同的权重θi反映了自变量对因变量不同的贡献程度。我们初中学过的一元一次方程：y=a+bx，这种只包括一个自变量和一个因变量的回归分析称为一元线性回归分析。初中学过的二元一次方程：y = a+b1x1+b2x2，三元一次方程：y = a+b1x1+b2x2+b3x3，这种回归分析中包括两个或两个以上自变量的回归分析，称为多元线性回归分析。不管是一元线性回归分析还是多元线性回归分析，都是线性回归分析。

2. 逻辑函数(Sigmoid函数)

Sigmoid函数数学表达式：

Sigmoid函数的图像：

从图像可以看到当x为0时，Sigmoid函数值为0.5。随着x的增大，对应的Sigmoid函数的值将逼近于1；而随着x的减小，Sigmoid函数的值将逼近于0，而Sigmoid函数的值域在（0，1）之间，而概率P也是在0到1之间，因此我们可以把Sigmoid的值域和概率联系起来

3. Logistic回归函数

Logistic回归的原理是用Sigmoid函数把线性回归的结果从(-∞,∞)映射到(0,1)。我们用公式描述上面这句话：

把线性回归函数的结果y，放到sigmod函数中去，就构造了Logistic回归函数。由y的值域和sigmod函数的值域知，在Logistic回归函数中用sigmod函数把线性回归的结果(-∞,∞)映射到(0,1)，得到的这个结果类似一个概率值。

我们转换一下逻辑回归函数，过程如下：

因此Logistic回归属于对数线性模型，也被称为对数几率回归。

Logistic回归分类器

为了实现logistic回归分类器，我们可以在每个分类特征上都乘以一个回归系数，然后把所有的结果值相加，将这个总和带入sigmoid函数中。进而得到一个范围在0-1之间的数值。最后设定一个阈值，在大于阈值时判定为1，否则判定为0。以上便是逻辑斯谛回归算法是思想，公式就是分类器的函数形式。确定了logistic分类函数，有了分类函数，我们输入特征向量就可以得出实例属于某个类别的概率。但这里有个问题，权重（回归系数）我们是不确定的。我们需要求得最佳的回归系数，从而使得分类器尽可能的精确。最佳回归系数的确定,可以用极大似然法、牛顿法、最优化方法（也就是梯度上升和梯度下降法）。下面重点介绍梯度上升法实现Logistic回归分类。

梯度上升算法

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

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

梯度上升算法到达每个点后都会重新估计移动的方向。从P0开始，计算完该点的梯度，函数就根据梯度移动到下一点P1。在P1点，梯度再次被重新计算，并沿新的梯度方向移动到P2.如此循环迭代，知道满足通知条件。迭代的过程中，梯度算子总是保证我们能选取到最佳的移动方向

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

该公式将一直迭代执行，直至达到某个停止条件为止，b比如迭代次数达到某个值或者算法达到某个可以允许的误差范围。如果是梯度下降法，那就是按梯度上升的反方向迭代公式即可，对应的公式如下：

python实现梯度上升算法

1.普通梯度上升算法（在每次更新回归系数(最优参数)时，都需要遍历整个数据集。）


def gradAscent(dataMatIn, classLabels):#梯度上升：dataMatIn:2维NumPy数组,100*3矩阵;classLabels:类别标签，1*100行向量
    dataMatrix = mat(dataMatIn)#特征矩阵
    labelMat = mat(classLabels).transpose()#类标签矩阵：100*1列向量
    m,n = shape(dataMatrix)
    alpha = 0.001#向目标移动的步长
    maxCycles = 500#迭代次数
    weights = ones((n,1))#n*1列向量：3行1列
    for k in range(maxCycles):
        h = sigmoid(dataMatrix*weights)#100*3*3*1=100*1,dataMatrix * weights代表不止一次乘积计算，事实上包含了300次乘积
        error = (labelMat - h)#真实类别与预测类别的差值
        weights = weights + alpha * dataMatrix.transpose()* error#w:=w+α▽wf(w)
    return weights

2.随机梯度上升算法

普通梯度上升算法，在每次更新回归系数时都需要遍历整个数据集，在数十亿样本上该算法复杂度太高。改进方法：随机梯度上升算法：一次仅用一个样本点更新回归系数。）

def stocGradAscent0(dataMatrix, classLabels):
    m, n = shape(dataMatrix)
    alpha = 0.01
    weights = ones(n)
    for i in range(m):
        h = sigmoid(sum(dataMatrix[i] * weights))
        error = classLabels[i] - h
        weights = weights + alpha * error * dataMatrix[i]
    return weights

现在我们用一个简单的数据集测试一下这两个算法的分类效果。

数据集testSet有100条样本，两个属性x1,x2

完整测试代码

#coding:utf-8
from numpy import *
import matplotlib.pyplot as plt

class func:
    def loadDataSet(self):
        dataMat = []
        labelMat = []
        fr = open('testSet.txt')
        for line in fr.readlines():
            # 矩阵的格式【标签，X1，X2】
            lineArr = line.strip().split()

            #插入X1，X2，以及初始化的回归系数（权重），全部设为1.0
            dataMat.append([1.0,float(lineArr[0]),float(lineArr[1])])

            #插入标签,
            #必须转换成int类型，因为只有两类
            labelMat.append(int(lineArr[2]))


        return dataMat,labelMat

    # 使用sigmoid函数进行分类
    def sigmoid(self,inX):
        return 1.0/(1+exp(-inX))

    #普通梯度上升
    #使用梯度上升算法进行优化，找到最佳优化系数
    #dataMatIn是训练集，三维矩阵，（-0.017612	14.053064	0）
    #classLabels是类别标签，数值型行向量，需要转置为列向量,取值是0,1
    def gradAscent(self,dataMatIn,classLabels):
        dataMatrix = mat(dataMatIn) #转换为Numpy矩阵数据类型
        labelMat = mat(classLabels).transpose() #转置矩阵,便于加权相乘
        m,n = shape(dataMatrix) #得到矩阵的行列数，便于设定权重向量的维度

        alpha = 0.001
        maxCycles = 500
        weights = ones((n,1))  #返回一个被1填满的 n * 1 矩阵，作为初始化权重
        for k in range(maxCycles):
            h = self.sigmoid(dataMatrix*weights)
            erro = (labelMat - h)   #labelMat是使用当前回归系数得到的的标签，labelMat是训练集的标签，取值是0,1
            weights = weights + alpha * dataMatrix.transpose( ) * erro  #根据使用当前权重计算的值与初始值的误差，更改weight，
                                                                        #按照误差的方向调整回归系数
        return weights

    #随机梯度上升

    def stocGradAscent0(dataMatrix, classLabels):
        m, n = shape(dataMatrix)
        alpha = 0.01
        weights = ones(n)
        for i in range(m):
            h = sigmoid(sum(dataMatrix[i] * weights))
            error = classLabels[i] - h
            weights = weights + alpha * error * dataMatrix[i]
         return weights


    def plotBestFit(self,wei):
        weights = wei.getA()
        dataMat,labelMat = self.loadDataSet()
        dataArr = array(dataMat)
        n = 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=30,c='red',marker = 's') #scatter散开
        ax.scatter(xcord2,ycord2,s=30,c='green')
        x = arange(-3.0,3.0,1)
        y = (-weights[0]-weights[1]*x)/weights[2]
        ax.plot(x,y)
        plt.xlabel('x1')
        plt.ylabel('x2')
        plt.show()




if __name__=="__main__":
    #普通梯度上升
    logRegres = func()
    dataArr,labelMat = logRegres.loadDataSet()
    weights = logRegres.gradAscent(dataArr,labelMat)
    logRegres.plotBestFit(weights)


    #随机梯度上升
    logRegres = func()
    dataArr,labelMat = logRegres.loadDataSet()
    weights =stocGradAscent0(array(dataArr),labelMat)
    plotBestFit(weights)

运行结果

普通梯度上升

分类结果是很不错，虽然这里是简单且数据集很小，但是这个方法却需要大量的计算（300次乘法）。

随机梯度上升

拟合效果没有普通梯度上升算法好。这里的分类器错分了三分之一的样本。但是普通梯度上升算法的计算量较大，时间较长，其结果是在整个数据集上迭代了500次才能得到的。而随机梯度上升在整个数据集上只需迭代200次，所以现在还不能分辨哪个算法更好。通常判断优化算法优劣的可靠方法是看它是否收敛，也就是说参数是否达到稳定值，是否不断地变化。下图展示随机梯度上升算法在 200 次迭代过程中回归系数的变化情况。其中的系数2，也就是 X2 只经过了 50 次迭代就达到了稳定值，但系数 1 和 0 则需要更多次的迭代。

针对欠拟合这个问题，我们对随机梯度上升算法进行优化

# 随机梯度上升算法（优化）
def stocGradAscent1(dataMatrix, classLabels, numIter=150):
    m,n = shape(dataMatrix)
    weights = ones(n)   
    
    for j in range(numIter):
        # [0, 1, 2 .. m-1]
        dataIndex = list(range(m))
        for i in range(m):
          
            alpha = 4/(1.0+j+i)+0.0001   
           
            randIndex = int(random.uniform(0,len(dataIndex)))
            # sum(dataMatrix[i]*weights)为了求 f(x)的值， f(x)=a1*x1+b2*x2+..+nn*xn
            h = sigmoid(sum(dataMatrix[randIndex]*weights))
            error = classLabels[randIndex] - h
            # print weights, '__h=%s' % h, '__'*20, alpha, '__'*20, error, '__'*20, dataMatrix[randIndex]
            weights = weights + alpha * error * dataMatrix[randIndex]
            del(dataIndex[randIndex])
    return weights

运行后效果

现在随机的alpha比固定的alpha收敛速度更快。主要归功于：1.stocGradAscent1()的样本随机机制避免周期性波动；2.stocGradAscent1()收敛更快。这次的随机梯度上升算法仅对数据集做了20次遍历，而之前的普通梯度上升算法是500次。

因此，通常数据集较小时，选用梯度上升算法就能达到我们想要的数据分类效果；当数据集较大时，为有效地减少了计算量，提高收敛速度，我们选用随机梯度上升算法。

【实战】用Logistic回归模型诊断糖尿病

Logistic回归的一般过程

(1)收集数据: 可以使用任何方法。

(2)准备数据: 由于需要进行距离计算，因此要求数据类型为数值型。当然，结构化数据格式最佳。

(3)分析数据: 采用任意方法对数据进行分析。

(4)训练算法: 大部分时间将用于训练，训练的目的是为了找到最佳的分类回归系数。

(5)测试算法: 一旦训练阶段完成，分类将很快完成。

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

数据样本收集

本次数据集一共765条样本，每条数据样本记录着健康人员和糖尿病患者的8个身体状况特征值，接下来我们使用Logistic回归模型对样本进行分类。数据收集来源：http://archive.ics.uci.edu/ml/index.php） 1是糖尿病患者，0是健康人员。