机器学习——逻辑回归

逻辑回归（Logistic Regression）

概述

假设现在有一些数据点，用一条直线对这些点进行拟合（该线称为最佳拟合直线），这个拟合过程就称为回归。
利用逻辑回归进行分类的主要思想是：根据现有数据对分类边界线建立回归公式，以此进行分类。

算法流程

收集数据：采用任意方法收集数据
准备数据：由于需要进行距离计算，因此要求数据类型为数值型。另外，结构化数据格式则最佳
分析数据：采用任意方法对数据进行分析
训练算法：大部分时间将用于训练，训练的目的是为了找到最佳的分类回归系数
测试算法：一旦训练步骤完成，分类将会很快
使用算法：首先，需要输入一些数据，并将其转换成对应的结构化数值；接着，基于训练好的回归系数就可以对这些数值进行简单的回归计算，判定它们属于哪个类别；在这之后，就可以在输出的类别上做一些其他分析工作

基于逻辑回归和Sigmoid函数的分类

逻辑回归

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

我们想要的函数应该是，能接受所有的输入然后预测出类别。例如，对于而分类问题，该函数应该返回0或1。具有这种性质的函数称为海维塞德阶跃函数(Heaviside step function)，或直接称为单位阶跃函数。海维塞德阶跃函数的问题在于：该函数在跳跃点上从0瞬间跳跃到1，这个瞬间跳跃过程有时很难处理。
Sigmoid函数是一个S型曲线，其函数形式为：

σ(z)=11+e−z(10)$$\begin{array}{}\text{(10)}& \sigma (z)=\frac{1}{1+e^{-z}}\end{array}$$

当输入z等于0时，Sigmoid函数值为0.5。随着z的增大，对应的函数值趋近于1；随着z的减小，对应的函数值趋近于0。

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

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

梯度上升法基于的思想是：要找到某函数的最大值，最好的方法是沿着该函数的梯度方向探寻。
梯度上升法的伪代码：

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

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):
    '''
    S函数
    '''
    return 1.0 / (1 + np.exp(-inX))

def gradAscent(dataMatIn, classLabels):
    '''
    梯度上升算法
    param dataMatIn: 特征值
    param classLabels: 标签
    '''
    # 特征值矩阵
    dataMatix = np.mat(dataMatIn)

    # 标签矩阵；行向量转置为列向量
    labelMat = np.mat(classLabels).transpose()
    # 获取特征值矩阵大小
    m, n = np.shape(dataMatix)
    # 移动步长
    alpha = 0.001
    # 迭代次数
    maxCycles = 500
    # 回归系数初始化为1
    weights = np.ones((n, 1))

    for k in range(maxCycles):
        h = sigmoid(dataMatix * weights)
        error = (labelMat - h)
        weights = weights + alpha * dataMatix.transpose() * error

    return weights

dataArr, labelMat = loadDataSet()
weights = gradAscent(dataArr, labelMat)
weights
[out]
matrix([[ 4.12414349],
        [ 0.48007329],
        [-0.6168482 ]])

分析数据：画出决策边界

def plotBestFit(weights):
    '''
    画出数据集和逻辑回归最佳拟合直线
    '''
    import matplotlib.pyplot as plt
    dataMat, labelMat = loadDataSet()
    dataArr = np.array(dataMat)
    n = np.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')
    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]
    ax.plot(x, y)
    plt.xlabel('X1')
    plt.ylabel('X2')
    plt.show()

plotBestFit(weights.getA())

训练算法：随机梯度上升

梯度上升算法每次更新归回系数时都需要遍历整个数据集，数据量较小时尚可，但如果有数十亿样本和上千万特征，那么该方法的计算复杂度就太高了。一种改进方法是以此仅用一个样本点来更新回归系数，该方法称为随机梯度上升算法。由于可以在新样本到来时对分类器进行增量式更新，因而随机梯度上升算法是一个在线学习算法。与“在线学习”相对应，一次处理所有数据被称作是“批处理”。
随机梯度算法伪代码：

所有回归系数初始化为1
对数据集中每个样本
    计算该样本的梯度
    适用 alpha x 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

测试随机梯度上升算法
从结果上来看，拟合出来的直线效果还不错，但不像前面那么完美。这里的分类器错分了三分之一的样本。
但是前面的结果时迭代了500次才得到的。

dataArr, labelMat = loadDataSet()
weights = stocGradAscent0(np.array(dataArr), labelMat)
plotBestFit(weights)

对算法进行改进，增加迭代次数

import random

def stocGradAscent1(dataMatrix, classLabels, numIter=150):
    m, n = np.shape(dataMatrix)
    weights = np.ones(n)
    for j in range(numIter):
        dataIndex = range(m)
        for i in range(m):
            # 每次迭代时更新 alpha 值
            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

测试算法
发现经过默认150次迭代后，拟合直线与前面已经差不多了。

dataArr, labelMat = loadDataSet()
weights = stocGradAscent1(np.array(dataArr), labelMat)
plotBestFit(weights)

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

使用逻辑回归来预测患有疝气病的马的存活问题。
测试集
训练集

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

准备数据：处理缺失值

处理缺失值可选的做法：

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

这里选择实数0来替换所有缺失值，因为使用NumPy数据类型不允许包含缺失值，而0恰好能适用于逻辑回归。回归系数的更新公式如下：
weights=weights+alpha∗error∗dataMatrix[randindex]$weights=weights+alpha\ast error\ast dataMatrix[randindex]$
如果dataMatrix的某特征对应值为0，那么该特征的系数不做更新，即：
weights=weights$weights=weights$
另外，由于sigmoid(0) = 0.5，即它对结果的预测不具有任何倾向性，因此选择实数0作为缺失值也不会对误差项造成影响。

测试算法：用逻辑回归进行分类

def classifyVector(inX, weights):
    '''
    逻辑回归分类函数
    parameter inX: 特征向量
    parameter 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 = []

        # 导入特征值，有21个特征
        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
    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)
    print 'the error rate of this test is: %f' % errorRate

    return errorRate

def multiTest():
    '''
    调用colicTest函数10次，取错误率平均值
    '''
    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))

函数测试
10次迭代后，平均错误率为35%。这个结果并不差，因为有30%的缺失值。
如果调整colicTest()中的迭代次数和stocGradAscent1()中的步长，平均错误率还可以下降。

multiTest()
[out]
the error rate of this test is: 0.328358
the error rate of this test is: 0.358209
the error rate of this test is: 0.283582
the error rate of this test is: 0.313433
the error rate of this test is: 0.373134
the error rate of this test is: 0.373134
the error rate of this test is: 0.358209
the error rate of this test is: 0.343284
the error rate of this test is: 0.432836
the error rate of this test is: 0.388060
after 10 iterations the average error rate is: 0.355224

小结

逻辑回归的目的是寻找一个非线性函数Signmoid的最佳拟合参数，求解过程可以由最优化算法来完成。在最优化算法中，最常用的是梯度上升算法，而梯度上升算法又可以简化为随机梯度上升算法。
随机梯度上升算法与梯度上升算法的效果相当，但占用更少的计算机资源。此外，随机梯度上升算法是一个在线算法，它可以在新数据到来时完成参数更新，而不需要重新读取整个数据集来进行批处理运算。