第五章 Logistic回归

于 2021-06-12 21:35:45 发布
阅读量513 收藏 1
点赞数 1
分类专栏： 机器学习专题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_40420192/article/details/117855984
版权
本文深入探讨了Logistic回归及其与Sigmoid函数的关系，阐述了梯度上升法在寻找最佳回归系数中的作用。通过实例展示了如何处理数据中的缺失值，并利用梯度上升算法训练分类器。同时，介绍了随机梯度上升的优化方法，以及在预测病马死亡率问题上的应用。最后，代码实现进一步巩固了理论知识。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

本章内容

  • Sigmoid函数和Logistic回归分类器

  • 最优化理论初步

  • 梯度下降最优化算法

  • 数据中的缺失项处理

文章目录

Logistic回归的一般过程
  • 收集数据：采用任意方法收集数据
  • 准备数据：由于需要进行距离计算，因此要求数据类型为数值型。另外，结构化数据格式则最佳
  • 分析数据：采用任意方法对数据进行分析
  • 训练算法：大部分时间将用于训练，训练的目的是为了找到最佳的分类回归系数
  • 测试算法
  • 使用算法

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

Logistic回归

  • 优点：计算代价不高，易于理解和实现

  • 缺点：容易欠拟合，分类精度可能不高

  • 适用数据类型：数值型和标称型数据

  • Sigmoid函数： f ( x ) = 1 1 + e − x {f(x)=\frac{1}{1+e^{-x}}} f(x)=1+e−x1​

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

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

z = w 0 x 0 + w 1 x 1 + w 2 x 2 + . . . + w n x n {z=w_0x_0+w_1x_1+w_2x_2+...+w_nx_n} z=w0​x0​+w1​x1​+w2​x2​+...+wn​xn​。采用向量的写法，上述公式可以写成 z = w T x {z=w^Tx} z=wTx，表示将这两个数值向量对应元素相乘然后全部加起来即得到z值。其中的向量x是分类器的输入数据，向量w是我们要找到的最佳参数

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

image-20210607154234267

上面 公式的梯度意味着要沿x的方向移动 ∂ f ( x , y ) ∂ x {\frac{\partial f(x,y)}{\partial x}} ∂x∂f(x,y)​，沿着y方向移动 ∂ f ( x , y ) ∂ y {\frac{\partial f(x,y)}{\partial y}} ∂y∂f(x,y)​。其中，函数f(x,y)必须要在待计算的点上有定义并且可微

image-20210607162605008

  • 梯度算子总是指向函数值增长最快的方向，此处所说的是移动方向，而未提到移动量的大小。该量值称为步长，记作α，向量表示如下：

    w = w + α ▽ w f ( w ) {w=w+α▽_wf(w)} w=w+α▽w​f(w)。该公式一直被迭代执行，直到达到某个停止条件为止

梯度下降
  • 梯度下降与梯度上升算法是一样的，只是公式中的加法需要变成减法。
  • 梯度上升算法用来求函数的最大值，而梯度下降算法用来求函数的最小值
训练算法：使用梯度上升找到最佳参数

image-20210607165200146

上图中一共有100个样本点，每个点包含两个数值特征：X1和X2。在此数据集上，将通过使用梯度上升法找到最佳回归系数，也就是拟合出Logistic回归模型的最佳参数

  • 梯度上升法的伪代码如下：
每个回归系数初始化为1
重复R次：
	计算整个数据集的梯度
	使用alpha*gradient更新回归系数的向量
	返回回归系数
  • Logistic回归梯度上升优化算法
import numpy as np
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]))
    return dataMat,labelMat

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

def gradAscent(dataMatIn,classLabels):
    '''
    该函数完成梯度上升的算法
    :param dataMatIn:2维的NumPy数组，每列分别代表每个不同的特征，每行代表每个训练样本
    :param classLabels:
    :return:
    '''
    # 转换为Numpy矩阵数据类型
    dataMatrix=np.mat(dataMatIn)
    labelMat=np.mat(classLabels).transpose()
    m,n=np.shape(dataMatrix)
    alpha=0.001
    maxCycles=500
    weights=np.ones((n,1))
    for k in range(maxCycles):
        h=Sigmoid(dataMatrix*weights)
        error=(labelMat-h)
        weights=weights+alpha*dataMatrix.transpose()*error
    return weights


if __name__ == '__main__':
    dataArr,labelMat=loadDataSet()
    print(gradAscent(dataArr,labelMat))
分析数据：画出决策边界

  • 上面的代码已经解出了一组回归系数，确定了不同类别数据之间的分隔线。如何画出该分隔线，从而使得优化的过程便于理解？

  • 画出数据集合Logistic回归最佳拟合直线的函数

def plotBestFit(weights):
    import matplotlib.pyplot as plt
    dataMat,labelMat=loadDataSet()
    dataArr=np.array(dataMat)
    n=np.shape(dataArr)[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')
    ax.scatter(xcord2,ycord2,s=30,c='green')
    x=np.arange(-3.0,3.0,0.1)
    y=(-weights[0]-weights[1]*x)/weights[2]
    y=np.array(y).transpose()
    ax.plot(x,y)
    plt.xlabel('x1')
    plt.ylabel('x2')
    plt.show()

代码运行结果如下图所示：

image-20210610205731422

训练算法：随机梯度上升
  • 梯度上升算法在每次更新回归系数时都需要遍历整个数据集，导致复杂度过高。一种改进的方法是一次仅用一个样本点来更新回归系数，该方法称为随机梯度上升算法。由于可以在新样本到来时对分类器进行增量式更新，因而随机梯度上升算法是一个在线学习算法。与在线学习相对应，一次处理所有数据被称作批处理
  • 随机梯度上升算法可以写成如下的伪代码
所有回归系数初始化为1
对数据集中每个样本
	计算该样本的额梯度
	使用alpha*gradient更新回归系数值
返回回归系数值
  • 梯度上升算法
def stocGradAscent0(dataMatrix,classLabels):
    '''
    随机梯度下降与梯度上升算法在代码上很相似，但也有一些区别：
    第一：后者的变量h和误差error都是向量，而前者则是全是数值
    第二：前者
    :param dataMatrix:
    :param classLabels:
    :return:
    '''
    m,n=np.shape(dataMatrix)
    alpha=0.01
    weights=np.ones(n)
    for i in range(m):
        h=Sigmoid(np.sum(dataMatrix[i]*weights))
        erro=classLabels[i]-h
        weights=weights+alpha*erro*dataMatrix[i]
    return weights
# 测试随机梯度上升
weights=stocGradAscent0(np.array(dataArr),labelMat)
plotBestFit(weights)

代码运行结果如下图所示：

image-20210612194220284

  • 改进的随机梯度上升算法
def stocGradAscent1(dataMatrix,classLabels,numIter=150):
    m,n=np.shape(dataMatrix)
    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每次迭代的时候都会调整
            randIndex=int(np.random.uniform(0,len(dataIndex))) #第二处改进，随机选择。减少周期性的波动
            h=Sigmoid(np.sum(dataMatrix[randIndex]*weights))
            error=classLabels[randIndex]-h
            weights=weights+alpha*error*dataMatrix[randIndex]
            del(dataIndex[randIndex])
    return weights
    

# 测试改进的版本
weights=stocGradAscent1(np.array(dataArr),labelMat)
plotBestFit(weights)

image-20210612195559202

三、从疝气病预测病马的死亡率

准备数据：处理数据中的缺失值

  • 预处理中对缺失值用一个实数值来替换，因为使用的Numpy不允许包含缺失值。此处选择0代替缺失值

  • 回归系数的更新公式如下：

weights=weights+alpha*erro*dataMatrix[randIndex]，如果dataMatrix的某特征值为0，那么该特征值

  • 预处理的第二件事是，如果在测试数据集中发现了一条数据的类别标签已经缺失，简单的做法就是将该条数据丢弃
  • 原始的数据集和处理之后的数据集分别保存为两个文件：horseColicTest.txt和horseColicTraining.txt
测试算法：用Logistic回归进行分类
  • 需要做的是吧测试集上每个特征向量乘以最优化方法得来的回归系数，再将该乘积结果求和，最后输入到Sigmoid函数中即可。
def classifyVector(inX,weights):
    prob=Sigmoid(np.sum(inX*weights))
    if prob>0.5:return 1.0
    else:return 0.0
def colicTest():
    frTrain=open('horseColicTraining.txt')
    frTest=open('horseColicTest.txt')
    trainingSet=[];trainingLabels=[]
    for line in frTrain.readlines():
        currLine=line.strip().split('\t')
        lineArr=[]
        for i in range(21):
            lineArr.append(float(currLine[i]))
        trainingSet.append(lineArr)
        trainingLabels.append(float(currLine[21]))
    trainWeights=stocGradAscent1(np.array(trainingSet),trainingLabels)
    errorCount=0;numTestVec=0.0
    for line in frTest.readlines():
        numTestVec+=1
        currLine=line.strip().split('\t')
        lineArr=[]
        for i in range(21):
            lineArr.append(float(currLine[i]))
        if int(classifyVector(np.array(lineArr),trainWeights))!=int(currLine[21]):
            errorCount+=1
    errorRate=(float(errorCount)/numTestVec)
    print("The error rate of this test is:{}".format(errorRate))
    return errorRate

def multiTest():
    numTests=10;errorSum=0
    for k in range(numTests):
        errorSum+=colicTest()
    print("After {} iterations the average error rate is {}".format(numTests,errorSum/float(numTests)))

    
multiTest()

附录：代码

import numpy as np
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]))
    return dataMat,labelMat

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

def gradAscent(dataMatIn,classLabels):
    '''
    该函数完成梯度上升的算法
    :param dataMatIn:2维的NumPy数组，每列分别代表每个不同的特征，每行代表每个训练样本
    :param classLabels:
    :return:
    '''
    # 转换为Numpy矩阵数据类型
    dataMatrix=np.mat(dataMatIn)
    labelMat=np.mat(classLabels).transpose()
    m,n=np.shape(dataMatrix)
    alpha=0.001
    maxCycles=500
    weights=np.ones((n,1))
    for k in range(maxCycles):
        h=Sigmoid(dataMatrix*weights)
        error=(labelMat-h)
        weights=weights+alpha*dataMatrix.transpose()*error
    return weights


def plotBestFit(weights):
    import matplotlib.pyplot as plt
    dataMat,labelMat=loadDataSet()
    dataArr=np.array(dataMat)
    n=np.shape(dataArr)[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')
    ax.scatter(xcord2,ycord2,s=30,c='green')
    x=np.arange(-3.0,3.0,0.1)
    y=(-weights[0]-weights[1]*x)/weights[2]
    y=np.array(y).transpose()
    ax.plot(x,y)
    plt.xlabel('x1')
    plt.ylabel('x2')
    plt.show()

def stocGradAscent0(dataMatrix,classLabels):
    '''
    随机梯度下降与梯度上升算法在代码上很相似，但也有一些区别：
    第一：后者的变量h和误差error都是向量，而前者则是全是数值
    第二：前者
    :param dataMatrix:
    :param classLabels:
    :return:
    '''
    m,n=np.shape(dataMatrix)
    alpha=0.01
    weights=np.ones(n)
    for i in range(m):
        h=Sigmoid(np.sum(dataMatrix[i]*weights))
        erro=classLabels[i]-h
        weights=weights+alpha*erro*dataMatrix[i]
    return weights

def stocGradAscent1(dataMatrix,classLabels,numIter=150):
    m,n=np.shape(dataMatrix)
    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每次迭代的时候都会调整
            randIndex=int(np.random.uniform(0,len(dataIndex))) #第二处改进，随机选择。减少周期性的波动
            h=Sigmoid(np.sum(dataMatrix[randIndex]*weights))
            error=classLabels[randIndex]-h
            weights=weights+alpha*error*dataMatrix[randIndex]
            del(dataIndex[randIndex])
    return weights

def classifyVector(inX,weights):
    prob=Sigmoid(np.sum(inX*weights))
    if prob>0.5:return 1.0
    else:return 0.0
def colicTest():
    frTrain=open('horseColicTraining.txt')
    frTest=open('horseColicTest.txt')
    trainingSet=[];trainingLabels=[]
    for line in frTrain.readlines():
        currLine=line.strip().split('\t')
        lineArr=[]
        for i in range(21):
            lineArr.append(float(currLine[i]))
        trainingSet.append(lineArr)
        trainingLabels.append(float(currLine[21]))
    trainWeights=stocGradAscent1(np.array(trainingSet),trainingLabels)
    errorCount=0;numTestVec=0.0
    for line in frTest.readlines():
        numTestVec+=1
        currLine=line.strip().split('\t')
        lineArr=[]
        for i in range(21):
            lineArr.append(float(currLine[i]))
        if int(classifyVector(np.array(lineArr),trainWeights))!=int(currLine[21]):
            errorCount+=1
    errorRate=(float(errorCount)/numTestVec)
    print("The error rate of this test is:{}".format(errorRate))
    return errorRate

def multiTest():
    numTests=10;errorSum=0
    for k in range(numTests):
        errorSum+=colicTest()
    print("After {} iterations the average error rate is {}".format(numTests,errorSum/float(numTests)))



if __name__ == '__main__':

    #测试1，测试梯度上升算法
    dataArr,labelMat=loadDataSet()
    weights=gradAscent(dataArr, labelMat)
    print(gradAscent(dataArr,labelMat))

    #测试2，测试画分隔线
    plotBestFit(weights)

    # 测试随机梯度上升
    weights=stocGradAscent0(np.array(dataArr),labelMat)
    plotBestFit(weights)

    # 测试改进的版本
    weights=stocGradAscent1(np.array(dataArr),labelMat)
    plotBestFit(weights)

    # 示例
    multiTest()
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值