机器学习实战第五章 Logistic回归

最新推荐文章于 2022-09-21 21:42:16 发布

给时光以生命_

最新推荐文章于 2022-09-21 21:42:16 发布

阅读量184

点赞数

分类专栏：机器学习

本文链接：https://blog.csdn.net/weixin_44276827/article/details/103041770

版权

机器学习专栏收录该内容

6 篇文章 0 订阅

订阅专栏

Logistic回归主要思想：根据现有数据对分类边界线建立回归公式，以此进行分类。
5.1 基于Logistic回归和Sigmoid函数的分类
我们想要的函数是，能接受所有输入然后预测出类别。例如，在两类的情况下，上述函数输出0或1。单位阶跃函数具有这种性质，但是该函数在跳跃点上从0瞬间跳跃到1，这个瞬间跳跃过程有时很难处理。幸好，另一个函数Sigmoid也有类似性质。
$\sigma(z)=\frac{1}{1+e^{-z}}$
当x为0时，Sigmoid函数值为0.5，随着x的增大，对应的Sigmoid值逼近于1；而随着x的减小，Sigmoid值将逼近于0.如果横坐标足够大，Sigmoid函数看起来像是一个阶跃函数。
在这里插入图片描述
因此为了实现Logistic回归分类器，我们可以在每个特征上都乘以一个回归系数，然后把所有的结果相加，将这个总和代入到Sigmoid函数中，进而得到一个0-1范围之间的数值。任何大于0.5的数据被分入1类，小于0.5被分入0类。所以，Logistic回归也可以看成是一种概率估计。
5.2 基于最优化方法的最佳回归系数确定
Sigmoid函数的输入记为z,由下面公式得出：
$z=w_0x_0+w_1x_1+w_2x_2+...+w_nx_n$
向量写法 $z=w^Tx$
向量w就是我们要寻找的最佳参数，从而使得分类尽可能的准确。为了寻找最佳参数，需要用到最优化理论的一些知识。
5.2.1 梯度上升法
梯度上升法的基本思想是：要找到某函数的最大值，最好的办法是沿着该函数的梯度方向探寻。如果梯度记为 $\delta$ ，则函数f(x,y)的梯度由下式表示：
$\delta f(x,y)=\begin{pmatrix} \frac{\alpha f(x,y)}{\alpha x} \\ \frac{\alpha f(x,y)}{\alpha y} \\ \end{pmatrix}$
这个梯度意味着沿x的方向移动 $\frac{\alpha f(x,y)}{\alpha x}$ ,沿y的方向移动 $\frac{\alpha f(x,y)}{\alpha y}$ 。
在这里插入图片描述
图5.2中的梯度上升算法沿梯度方向移动了一步。可以看到，梯度算子总是指向函数值增长最快的方向。这里指的移动方向，而未提到移动量的大小。该量值称为步长，记做 $\alpha$ 。用向量来表示的话，梯度上升算法的迭代公式如下：
$w:=w+\alpha \delta_w f(w)$
该公式将一直被迭代执行，直至达到某个停止条件为止，比如迭代次数达到某个指定值或算法达到某个允许的误差范围。
梯度下降法用来求函数的最小值，对应公式为：
$w:=w-\alpha \delta_w f(w)$

5.2.2 训练算法：使用梯度上升找到最佳参数
在这里插入图片描述
图5.3中有100个样本点，每个点包含两个数值型特征：X1和X2。在此数据集上，我们将通过梯度上升法找到最佳回归系数，也就是拟合出Logistic回归模型的最佳参数。
梯度上升法伪代码如下：
每个回归系数初始化为1:
重复R次：
计算整个数据集的梯度
使用alpha $\times$ gradient更行回归系数的向量
返回回归系数

import numpy as np 
from random import uniform
def loadDataset():
    dataMat=[]
    labelMat=[]
    fr=open('/Users/gemengmeng/Desktop/公开课学习资料/testSet.txt') 
    for line in fr.readlines():
        lineArr=line.strip().split('\t')
        dataMat.append([1.0,float(lineArr[0]),float(lineArr[1])])#1.0代表X0，lineArr[0]是X1，lineArr[0]是X2
        labelMat.append(int(lineArr[2]))
    return dataMat,labelMat
def sigmoid(inX):
    return 1.0/(1+np.exp(-inX))
def gradAscent(dataMatIn,classLabels):
    dataMatraix=np.mat(dataMatIn)
    labelMat=np.mat(classLabels).transpose()
    m,n=np.shape(dataMatraix)
    alpha=0.001#目标移动的步长
    maxCycles=500#迭代次数
    weights=np.ones((n,1)) 
    for k in range(maxCycles):
        h=sigmoid(dataMatraix*weights)
        error=(labelMat-h)
        weights=weights+alpha*dataMatraix.transpose()*error
    return weights

dataArr,labelMat=loadDataset() 
aa=gradAscent(dataArr,labelMat) 
aa
#matrix([[ 4.12414349],
#        [ 0.48007329],
#        [-0.6168482 ]])

5.2.3画出决策边界

#画出决策边界
#画出决策边界
def plotBestFit(weights): 
    import matplotlib.pyplot as plt
    #weights=wei.getA()#与mat()作用相反，是将一个矩阵转换为array数组
    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]#设置sigmoid函数为0，0=w0x0+w1x1+w2x2,然后解出x1和x2的关系，注意x0=1
    ax.plot(x,y)
    plt.xlabel('X1')
    plt.ylabel('X2')
    plt.show()

dataArr,labelMat=loadDataset() 
aa = gradAscent(dataArr,labelMat) 
plotBestFit(aa.getA())

在这里插入图片描述
5.2.4 训练算法：随机梯度上升
梯度上升算法在每次更新回归系数时都需要遍历整个数据集，该方法在处理100个左右的数据集时尚可，但如果有数十亿样本和成千上万的特征，那么该方法的计算复杂度久太高了。一种改进方法是一次仅用一个样本点来更新回归系数，该方法称为随机梯度上升算法。由于可以在新样本到来时对分类器进行增量式更新，因而随机梯度上升算法是一个在线学习算法。与“在线学习”相对应，一次处理所有数据被称为是“批处理”。
随机梯度上升算法伪代码如下：
所有回归系数初始化为1:
对数据集中每个样本：
计算该样本的梯度
使用alpha $\times$ gradient更行回归系数的向量
返回回归系数

def stocGradAscent0(dataMatrix,classLabels):
    m,n=np.shape(dataMatrix)
    alpha=0.01
    weights=np.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

dataArr,labelMat=loadDataset()
weight1=stocGradAscent0(np.array(dataArr),labelMat)
plotBestFit(weight1)

在这里插入图片描述
执行代码得到拟合直线，拟合直线效果不如梯度上升算法，分类错误率明显高于梯度上升算法。
随机梯度上升算法与梯度上升算法的区别：
第一，随机梯度上升算法的变量h和error都是数值；梯度上升算法的变量h和error都是向量
第二，随机梯度上升算法没有矩阵转换的过程，所有的数据类型都是Numpy数组
但是直接比较stocGradAscent0()和gradAscent()的结果是不公平的，因为gradAscent()是迭代500次的结果。下面我们对随机梯度上升算法进行修改，使其迭代200次。

def stocGradAscent1(dataMatrix,classLabels,numIter=150):#默认迭代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
            randIndex=int(random.uniform(0,len(dataIndex)))
            h=sigmoid(sum(dataMatrix[randIndex]*weights))
            error=classLabels[randIndex]-h
            weights=weights+alpha*error*dataMatrix[randIndex]
            del(dataIndex[randIndex])

    return weights

stocGradAscent1()相比stocGradAscent0()有两处改进，
第一处改进：alpha每次迭代都会调整，这会缓解回归系数的波动；因为常数项的存在，alpha永远不会减少到0，这样做可以保证在多次迭代之后新数据仍然具有一定的影响。
第二处改进：通过随机选取样本来更新回归系数，这种方法将减少回归系数周期性波动。

dataArr,labelMat=loadDataset()
weight2=stocGradAscent1(np.array(dataArr),labelMat)
plotBestFit(weight2)

在这里插入图片描述
运行程序得到上图，效果与gradAscent()差不多，但是计算量更少。
5.3 示例：从疝气病症预测病马的死亡率

def classifyVector(inX,weights):
    prob=sigmoid(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,500)#计算回归系数
    errorCount=0.0
    numTestVec=0.0
    for line in frTest.readlines():
        numTestVec+=1.0
        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)*100
    print "the error rate of this test is:%.2f%%" % errorRate
    return errorRate
def multiTest():#调用10次colicTest并求结果的平均值
    numTests=10
    errorSum=0.0
    for k in range(numTests):
        errorSum+=colicTest()
    print "after %d iterations the average error rate is:%.2f%%"%(numTests,errorSum/float(numTests))

运行后得到错误率竟然有70.15%。。。

给时光以生命_

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
机器学习实战第五章 Logistic回归

Logistic回归主要思想：根据现有数据对分类边界线建立回归公式，以此进行分类。5.1 基于Logistic回归和Sigmoid函数的分类我们想要的函数是，能接受所有输入然后预测出类别。例如，在两类的情况下，上述函数输出0或1。单位阶跃函数具有这种性质，但是该函数在跳跃点上从0瞬间跳跃到1，这个瞬间跳跃过程有时很难处理。幸好，另一个函数Sigmoid也有类似性质。$$...
复制链接

扫一扫

专栏目录