机器学习实战： Logistic（附数据集）

机器学习实战（4） Logistic

运行环境：Anaconda——Jupyter Notebook
Python版本为：3.6.6
数据集：horse
提取码：4epn
复制这段内容后打开百度网盘手机App，操作更方便哦)
利用Logistic回归进行分类的主要思想是：根据现有数据对分类边界线建立回归公式，以此进行分类。训练分类器时的做法就是寻找最佳拟合参数，使用的是最优化算法。

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

Logistic回归的一般过程

(1) 收集数据：采用任意方法收集数据。

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

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

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

(5) 测试算法：一旦训练步骤完成，分类将会很快。

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

Logistic回归

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

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

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

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

我们想要的函数应该是，能接受所有的输入然后预测出类别。

• 海维塞德阶跃函数，或者直接称为单位阶跃函数。然而，海维塞德阶跃函数的问题在于：该函数在跳跃点上从0瞬间跳跃到1，这个瞬间跳跃过程有时很难处理。
• 另一个函数也有类似的性质，且数学上更易处理，这就是Sigmoid函数。Sigmoid函数具体的计算公式如下：
  
  两种坐标尺度下的Sigmoid函数图:
  
  横坐标为-5到5，这时的曲线变化较为平滑；下图横坐标的尺度足够大，可以看到，在x = 0点处Sigmoid函数看起来很像阶跃函数。

为了实现Logistic回归分类器，我们可以在每个特征上都乘以一个回归系数，然后把所有的结果值相加，将这个总和代入Sigmoid函数中，进而得到一个范围在0~1之间的数值。任何大于0.5的数据被分入1类，小于0.5即被归入0类。所以，Logistic回归也可以被看成是一种概率估计。

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

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

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

如果采用向量的写法，上述公式可以写成:

它表示将这两个数值向量对应元素相乘然后全部加起来即得到z值。其中的向量x是分类器的输入数据，向量w也就是我们要找到的最佳参数（系数），从而使得分类器尽可能地精确。

1.1.1 梯度上升法

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

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

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

梯度算子总是指向函数值增长最快的方向。这里所说的是移动方向，而未提到移动量的大小。该量值称为步长，记做α。用向量来表示的话，梯度上升算法的迭代公式如下：
该公式将一直被迭代执行，直至达到某个停止条件为止，比如迭代次数达到某个指定值或算法达到某个可以允许的误差范围。

1.1.2 梯度下降算法

你最经常听到的应该是梯度下降算法，它与这里的梯度上升算法是一样的，只是公式中的加法需要变成减法。因此，对应的公式可以写成:

梯度上升算法用来求函数的最大值，而梯度下降算法用来求函数的最小值。

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

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

每个回归系数初始化为1

重复R次：

计算整个数据集的梯度

使用alpha × gradient更新回归系数的向量

返回回归系数

程序清单 Logistic 回归梯度上升优化算法

import numpy as np
import matplotlib.pyplot as plt
def loadDataSet():
    dataMat = []
    labelsMat = []
    fr = open('dataSet/testSet.txt')
    for line in fr.readlines():
        lineArr = line.strip().split()
        dataMat.append([1.0,float(lineArr[0]),float(lineArr[1])])
        labelsMat.append(int(lineArr[2]))
    return dataMat,labelsMat

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

def gradAscend(dataMatIn,classLabels):
    # 将2维NumPy数组转换为NumPy矩阵数据类型
    dataMat = np.mat(dataMatIn)
    labelsMat = np.mat(classLabels).transpose()
    m,n = np.shape(dataMat)
    weights = np.ones((n,1))
    alpha = 0.001
    mycycles = 500
    for i in range(mycycles):
        h = sigmoid(dataMat*weights)
        errors = labelsMat - h
        weights = weights + alpha*dataMat.transpose()*errors
    return weights

dataMat,labelsMat = loadDataSet() 
weights = gradAscend(dataMat,labelsMat)

数学推导：weights = weights + alpha*dataMat.transpose()*errors

具体如下：

weights

matrix([[ 4.12414349],
        [ 0.48007329],
        [-0.6168482 ]])

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

def plotBestFit(wei):
    weights = wei.getA()
    dataMat,labelsMat = loadDataSet()
    dataArr = np.array(dataMat)
    # n为样本数
    n = np.shape(dataArr)[0]
    xcord1 = []
    ycord1 = []
    xcord2 = []
    ycord2 = []
    for i in range(n):
        if labelsMat[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 = plt.subplot(111)
    ax.scatter(xcord1,ycord1,s=30,c='red',marker='s')
    ax.scatter(xcord2,ycord2,s=30,c='blue')
    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()

plotBestFit(weights)

尽管例子简单且数据集很小，这个方法却需要大量的计算（300次乘法）。因此下一节将对该算法稍作改进，从而使它可以用在真实数据集上。

• mat.getA()

将自身矩阵变量转化为ndarray类型的变量。

• mat.getA1()

将自身矩阵变换为一维的ndarray类型。

• mat.getH()

返回自身(如果是复数矩阵)对偶转置矩阵，如果为实数矩阵，则等价于np.transpose(self)

• mat.getI()

返回可逆矩阵的逆。

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

随机梯度上升算法可以写成如下的伪代码：

所有回归系数初始化为1

对数据集中每个样本

计算该样本的梯度

使用alpha × gradient更新回归系数值

返回回归系数值

程序清单 随机梯度上升算法

def stocGradAscend0(dataMatIn,classLabels):
    # #把处理后的列表转化为数组或矩阵，否则会出现can't multiply sequence by non-int of type 'float'错误
    dataMatIn = np.array(dataMat)
    m,n = np.shape(dataMatIn)
    alpha = 0.001
    weights = np.ones(n)
    for i in range(m):
        h = sigmoid(np.sum(dataMatIn[i]*weights))
        error = classLabels[i] - h
        weights = weights + alpha * error * dataMatIn[i]
    # 这个目的是方便下面plotBestFit()函数中,wei.getA()的操作，其中的wei只能为矩阵,'numpy.ndarray' object has no attribute 'getA'
    weights=np.mat(weights).reshape((n,1))
    return weights

dataArr,labelsMat = loadDataSet()

weights = stocGradAscend0(dataArr,labelsMat)

plotBestFit(weights)

程序清单 改进的随机梯度上升算法

import random
def stocGradAscend1(dataMatIn,classLabels,numIters=150):
    # 把处理后的列表转化为数组或矩阵，否则会出现can't multiply sequence by non-int of type 'float'错误
    dataMatIn = np.array(dataMat)
    m,n = np.shape(dataMatIn)
    weights = np.ones(n)
    for i in range(numIters):      
        dataIndex = range(m)         
        for j in range(m):
            # alpha 每次迭代时需要调整
            alpha = 4/(1.0+i+j) + 0.01
            # 随机选取更新
            randIndex = int(random.uniform(0,len(dataIndex)))
            h = sigmoid(np.sum(dataMatIn[randIndex]*weights))
            error = classLabels[randIndex] - h
            weights = weights + alpha * error * dataMatIn[randIndex]
            # del (dataIndex[randIndex]),TypeError: 'range' object doesn't support item deletion
            del (list(dataIndex)[randIndex])
    # 这个目的是方便下面plotBestFit()函数中,wei.getA()的操作，其中的wei只能为矩阵,'numpy.ndarray' object has no attribute 'getA'
    weights=np.mat(weights).reshape(n,1)
    return weights

weights = stocGradAscend1(dataArr,labelsMat,numIters=150)

weights

matrix([[15.17456309],
        [ 1.43706209],
        [-2.07909064]])

plotBestFit(weights)

2 示例：从疝气病症预测病马的死亡率

示例：使用Logistic回归估计马疝病的死亡率

(1) 收集数据：给定数据文件。

(2) 准备数据：用Python解析文本文件并填充缺失值。

(3) 分析数据：可视化并观察数据。

(4) 训练算法：使用优化算法，找到最佳的系数。

(5) 测试算法：为了量化回归的效果，需要观察错误率。根据错误率决定是否回退到训练阶段，通过改变迭代的次数和步长等参数来得到更好的回归系数。

(6) 使用算法：实现一个简单的命令行程序来收集马的症状并输出预测结果并非难事，这可以做为留给读者的一道习题。

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

对于数据中的缺失值,下面给出了一些可选的做法：

• 使用可用特征的均值来填补缺失值；
• 使用特殊值来填补缺失值，如-1；
• 忽略有缺失值的样本；
• 使用相似样本的均值添补缺失值；
• 使用另外的机器学习算法预测缺失值。

在预处理阶段需要做两件事：

• 第一，所有的缺失值必须用一个实数值来替换，因为我们使用的NumPy数据类型不允许包含缺失值。这里选择实数0来替换所有缺失值，恰好能适用于Logistic回归。

由于sigmoid(0)=0.5，即它对结果的预测不具有任何倾向性，因此上述做法也不会对误差项造成任何影响。基于上述原因，将缺失值用0代替既可以保留现有
　数据，也不需要对优化算法进行修改。此外，该数据集中的特征取值一般不为0，因此在某种意义上说它也满足“特殊值”这个要求。

• 预处理中做的第二件事是，如果在测试数据集中发现了一条数据的类别标签已经缺失，那么我们的简单做法是将该条数据丢弃。这是因为类别标签与特征不同，很难确定采用某个合适的值来替换。

def classify(inX,weights):
    prob = sigmoid(np.sum(inX*weights))
    if prob > 0.5:
        return 1.0
    else:
        return 0.0
    
def coliTest():
    frTrain = open('dataSet/horseColicTraining.txt')
    frTest = open('dataSet/horseColicTest.txt')
    trainingSet = []
    trainingLabels = []
    for line in frTrain.readlines():
        currentLine = line.strip().split('\t')
        lineArr = []
        for i in range(21):
            lineArr.append(float(currentLine[i]))
        trainingSet.append(lineArr)
        trainingLabels.append(float(currentLine[21]))
    trainWeights = stocGradAscend1(np.array(trainingSet),trainingLabels,500)
    print(np.shape(trainWeights))
    errorCount = 0.0
    numTestVec = 0.0
    for line in frTest.readlines():
        numTestVec += 1
        currentLine = line.strip().split('\t')
        lineArr = []
        for i in range(21): 
            lineArr.append(float(currentLine[i]))
        if int(classify(np.array(lineArr),trainWeights)) != int(currentLine[21]):
            errorCount += 1
    errorRate = errorCount/float(numTestVec)
    print('the error rate is: %f' % errorRate)
    return errorRate

def multiTest():
    num = 10
    errorSum = 0.0 
    for i in range(num):
        errorSum += coliTest()
    errorRate = float(errorSum/num)
    print('the %d iterations is %f' %(num,errorRate))

coliTest()