机器学习之Logistic回归(五)

最新推荐文章于 2022-04-07 12:38:11 发布

凌岸_鸿

最新推荐文章于 2022-04-07 12:38:11 发布

阅读量872

点赞数

分类专栏：机器学习文章标签：机器学习逻辑回归

本文链接：https://blog.csdn.net/lingan_Hong/article/details/77527979

版权

机器学习专栏收录该内容

12 篇文章 0 订阅

订阅专栏

主要内容
● Sigmoid函数和Logistoc回归分类器
● 最优化理论初步
● 梯度下降最优化算法
● 数据中的缺失项处理

我们将介绍最优化算法，并利用他们训练出一个非线性函数用于分类。

利用Logistic回归的主要思想是：根据现有的数据对分类边界线建立回归公式，以此进行分类。
“回归”一词源于最佳拟合，表示要找到最佳拟合参数，使用的是最优化算法。

Logistic回归一般过程：
1. 收集数据：采用任意方法收集数据
2. 准备数据：由于需要进行距离计算，因此要求数据类型为数值型，另外，结构化数据为最佳。
3. 分析数据：采用任意方法对于数据进行分析
4. 训练算法：大部分时间将用于训练，并将其转换为对应的结构化数据
5. 测试算法：一旦训练步骤完成，分类将会很快；
6. 使用算法：第一，我们需要输入一些数据，并将其转换为对应的结构化数值；第二，基于训练好的回归系数就可以对这些数值进行简单的回归计算，判断他们属于哪个类别，在这之后，我们就可以输出的类别上做一些其他分析工作。

5.1 基于logistic回归和sigmoid函数的分类

logistic回归：
优点：计算代价不高，易于理解和实现；
缺点：容易欠拟合，分类精度可能不高。
适用数据类型：数值型和标称型数据。

下面进入数学理论部分：

我们想要的是能接受所有的输入然后预测出类别。该函数被称之为海维塞德阶跃迁函数或者单位跃迁函数。
有一个有类似于可以输出0或者1这种性质的函数，就是Sigmoid函数。
Sigmoid计算公式如下：
这里写图片描述

下图给出了Sigmoid函数在不同坐标尺下的曲线图，当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，公式如下：
这里写图片描述

其中x是分类器的输入数据，向量w是我们要找的最佳参数。

为了寻找最佳参数，我们介绍一下梯度上升的最优化方法。我们将使用梯度上升的最优化方法来寻找最佳参数。

5.2.1 梯度上升法

梯度上升法基本思想：要找到某函数的最大值，最好的方法就是沿着该函数的梯度方向探寻。如果梯度为 ▽ ，则函数f(x,y)的梯度如下表示：
这里写图片描述

梯度要沿着x的方向移动 (∂f(x+y))/∂x

梯度要沿着y的方向移动 (∂f(x+y))/∂y

这里写图片描述
梯度上升算法的迭代公式：

w: = w + α▽f(w)

5.2.2 训练算法：使用梯度上升找到最佳参数

图5-3 有100个样本点：每个点包含两个数值型特征：X1和X2.。我们将通过使用梯度上升法找到最佳回归系数，也就是拟合出 Logistic回归模型的最佳参数。

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

每个回归系数初始化为1
重复R次：
       计算整个数据集的梯度
       使用alpha * gradient 更新回归系数的向量
       返回回归系数

下面的代码是梯度上升算法的具体实现，创建名为 logRegres.py的文件，输入代码：
程序5-1 Logistic回归梯度上升最优化算法

import math
from numpy import *

def loadDataSet():
    dataMat = []; labelMat = []
    fr = open(r'E:\ML\ML_source_code\mlia\Ch05\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+exp(-inX))

def gradAscent(dataMatIn,classLabels):
    #调用numpy函数可以将数组转行为矩阵数据类型
    dataMatrix = mat(dataMatIn)
    #将矩阵转置
    labelMat = mat(classLabels).transpose()
    #看一下dataMatrix的大小，3*100的矩阵
    m,n = shape(dataMatrix)
    #目标移动步长
    alpha = 0.01
    #迭代次数
    maxCycles =500
    #n已经赋值为3
    weights = ones((n,1))
    for k in range(maxCycles):
        h = sigmoid(dataMatrix*weights)
        error = (labelMat - h)
        weights = weights + alpha * dataMatrix.transpose() * error
    return weights

接下来测试代码，载入这个包

In [1]: import os

In [2]: os.chdir('E:\ML\ML_IA\Logistic')

In [3]: import logRegres

In [4]: import logRegres

In [5]: reload(logRegres)
Out[5]: <module 'logRegres' from 'logRegres.py'>

In [6]: a,b= logRegres.loadDataSet()

In [40]: logRegres.gradAscent(a,b)
Out[40]:
matrix([[ 4.12414349],
        [ 0.48007329],
        [-0.6168482 ]])

5.3.2 分析数据：画出决策边界

上面解出的回归系数，确定了不同类别数据之间的分割线。那么如何画出分割线呢？

程序5-2 画出数据集和Logistic 回归最佳拟合直线的曲线

import matplotlib.pyplot as plt
def plotBestFit(weights):
    dataMat,labelMat = loadDataSet()
    dataArr = array(dataMat)
    n = shape(dataArr)[0]
    xcord1 = [] ; ycord1 = []
    xcord2 = [] ; ycord2 = []
    for i in range(n):
        if int(labelMat[i]) == i:
            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 = 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()

我们最终需要解出X1和X2之间的关系式，运行代码，

In [24]: import logRegres

In [25]: reload(logRegres)
Out[25]: <module 'logRegres' from 'logRegres.py'>

In [26]: a,b = logRegres.loadDataSet()

In [27]: logRegres.gradAscent(a,b)
Out[27]:
matrix([[ 4.12414349],
        [ 0.48007329],
        [-0.6168482 ]])

In [28]: weights = logRegres.gradAscent(a,b)

In [29]: logRegres.plotBestFit(weights.getA())

这里写图片描述

梯度上升算法在500次迭代后得到的Logistic回归最佳拟合曲线

最终图上看上去是错分了2个点。
尽管例子比较简单，但是却需要大量的计算。后面我们将对算法作以改进。

5.2.4 训练算法：随机梯度上升

梯度上升算法在每次更新回归系数时都需要去遍历整个数据集，该方法在处理100个左右的数据集时速度可以，如果去处理数亿或者几千万的特征，这个方法的复杂度就太高了。
我们改进的方法就是一次仅用一个样本点来更新回归系数，这个方法叫做随机梯度上升算法。
由于可以在新样本到来时对分类器进行增量式更新，因而随机梯度上升算法是一个在线学习算法。与“在线学习”相对应，一次处理的所有数据被称之为“批处理”。
随机梯度上升算法可以写成如下的伪代码：

虽有的回归系数初始都为1
对数据集中每个样本
       计算该样本的梯度
       使用alpha*gradient更新回归系数值
返回归系数数值

程序5-3 随机梯度上升算法

# 随机梯度上升算法
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

随机梯度算法与梯度上升算法有一定的区别：
1.后者的h和误差error都是向量，而前者则是数值；
2.前者没有矩阵的转换过程，所有变量的数据类型都是Numpy数组。

In [38]: import logRegres

In [39]: reload(logRegres)
Out[39]: <module 'logRegres' from 'logRegres.pyc'>

In [40]: a,b = logRegres.loadDataSet()

In [41]: weights = logRegres.stocGradAscent1(array(a),b)

In [42]: weights
Out[42]: array([ 1.01702007,  0.85914348, -0.36579921])

In [43]: logRegres.plotBestFit(weights)

这里写图片描述

随机梯度上升算法在上述数据集上执行结果，最佳拟合直线并非最佳分类线

本次运行后的曲线如果与上面的图进行比较，其实不如上面的完美。那么主要是因为上面的图迭代了500次。

因为数据波动或者高频波动，且收敛速度较慢，所以我们需要对算法改进。

值得注意的是：主要做了三个方面的改进：
1. alpha在每次迭代的时候都会调整，这会缓解数据波动或者高频波动。
2. 通过随机选取样本来更新回归系数，这样可以减少周期性波动
3. 增加了一个迭代参数作为第三个参数，算法将按照给的新的参数值进行迭代

程序5-4 改进的随机梯度算法

# 改进的随机梯度算法
def stocGradAscent1(dataMatrix,classLabels,numIter=150):
    m,n = shape(dataMatrix)
    weights = ones(n)
       """
    i 是样本点的下标,j 是迭代次数
    """
    for j in range(numIter):         
        dataIndex = range(m)
        for i in range(m):
            alpha = 4/(1.0 + j + i) + 0.01  #alpha每次迭代时需要调整
            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

下面所用的计算量更少：

In [43]: reload(logRegres)
Out[43]: <module 'logRegres' from 'logRegres.pyc'>

In [44]: a,b = logRegres.loadDataSet()

In [45]: weights = logRegres.stocGradAscent1(array(a),b)

In [46]: logRegres.plotBestFit(weights)

这里写图片描述

5.3 例子：疝气病症预测病马的死亡率

我们将使用logistics回归来预测患有疝病的马的存活问题。该数据有部分指标主观和难以测量，而且存在30%的缺失值。

步骤：

1.收集数据：给定数据文件；
2.准备数据：用python解析文本文件并填充缺失值；
3.分析数据：可视化并观察数据；
4.训练算法：使用最优化算法，得到最佳的系数；
5.测试算法：为了量化回归的效果，我们需要观察错误率。再去根据错误率判断，我们是否需要回退到训练阶段，通过改变迭代的次数和步长等参数来得到更好的回归系数；
6.使用算法：实现一个简单的命令行程序来手机马的症状并输出预测结果。

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

数据的缺失值处理是一个非常棘手的问题，有时候复杂业务环境下数据相当昂贵，我们不能简单的去丢弃掉，或者重新获取。
方法：
● 使用可用特征的均值来填补缺失值；
● 使用特殊值来填补缺失值，如-1 ；
● 忽略有缺失值的样本；
● 使用相似的样本的均值添补缺失值；
● 使用另外的机器学习算法来预测缺失值；

我们现在要对要用的数据集做预处理。
1.所有的缺失值必须使用一个实数值来替换，因为我们使用numpy数据类型不允许包含缺失值，这里选择实数0来替换所有的缺失值，恰好使用会回归。这样做是因为需要一个在更新的时候不会影响系数的值。
回归系数更新公式如下：

weights = weights + alpha error dataMatrix[randIndex]

2.如果数据集中类别标签已经缺失，那么就丢弃。

5.3.2 测试算法：用logistic回归进行分类

程序清单5-5 logistic 回归分类函数

# 疝气病预测兵马死亡率：Logistic回归分类器

def classifyVector(inX,weights):
    """ 
    回归系数 ：inX 
    特征向量 ：weights   
    """
    prob = sigmoid(sum(inX*weights))
    if prob > 0.5:
        return 1.0
    else:
        return 0.0

def colicTest():
    frTrain = open(tem_dir + "\\" + "horseColicTraining.txt")
    frTest = open(tem_dir + "\\" + "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]))
    #stocGradAscent1计算回归系数
    trainWeights = stocGradAscent1(array(trainingSet),trainingLabels,500)
    errorCount = 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(array(lineArr),trainWeights)) != int(currLine[21]):
            errorCount += 1
    errorRate = (float(errorCount)/numTestVec)
    print "the error rate of this test is: %f" %errorRate
    return errorRate

def multiTest():
    numTests = 10;errorSum = 0.0
    for k in range(numTests):
        errorSum += colicTest()
    print "after %d iterations the average error rate is:%f" 
% (numTests,errorSum/float(numTests))

测试代码，结果如下：

In [46]: reload(logRegres)
Out[46]: <module 'logRegres' from 'logRegres.py'>

In [47]: logRegres.multiTest()
the error rate of this test is: 0.313433
the error rate of this test is: 0.313433
the error rate of this test is: 0.313433
the error rate of this test is: 0.283582
the error rate of this test is: 0.417910
the error rate of this test is: 0.328358
the error rate of this test is: 0.462687
the error rate of this test is: 0.313433
the error rate of this test is: 0.358209
the error rate of this test is: 0.388060
after 10 iterations the average error rate is:0.349254

10次迭代之后的结果是34.9% 。因为数据本身就有30%的缺失，得到的错误率结果并不差。
如果手动去调整 colicTest() 函数中的迭代次数和 stocGradAscent1() 中的步长，那么最终的平均错误率就在20%左右。

5.4 小结
Logistic 回归的目的是寻找一个非线性函数sigmoid的最佳拟合参数。求解过程可以由最优化算法来完成。在最优化的算法中，最常用的就是梯度上升算法，梯度上升算法又可以简化为随机梯度上升算法。
随机梯度上升算法和梯度上升算法的效果相当，但占用更少的计算资源。此外，随机梯度是一种在线算法，可以在数据到来时就完成参数的更新，而不需要重新读取整个数据集来进行批处理运算。
机器学习的一个重要的问题就是如何处理缺失数据，这个问题没有标准答案，取决于实际的需求。

凌岸_鸿

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
机器学习之Logistic回归(五)

主要内容 ● Sigmoid函数和Logistoc回归分类器 ● 最优化理论初步 ● 梯度下降最优化算法 ● 数据中的缺失项处理我们将介绍最优化算法，并利用他们训练出一个非线性函数用于分类。利用Logistic回归的主要思想是：根据现有的数据对分类边界线建立回归公式，以此进行分类。 “回归”一词源于最佳拟合，表示要找到最佳拟合参数，使用的是最优化算法。Logistic回归一
复制链接

扫一扫

专栏目录