《机器学习实战》学习笔记之第五章—— Logistic回归

第五章 Logistic回归

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

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

回归：对一些数据点，算法训练出直线参数，得到最佳拟合直线，能够对这些点很好的拟合。

训练分类器主要是寻找最佳拟合参数，故为最优化算法。

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

实现Logistic回归分类器：在每个特征上都乘以一个回归系数，然后把所有的结果值相加，总和带入sigmoid函数，其结果大于0.5分为第0类，结果小于0.5分为第0类。

Sigmoid函数公式：

sigmoid函数具有很好的性质，如其导数可以用其本身表示等等。

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

sigmoid函数输入z:

其可以写成z=w.T*x，向量x为分类器的输入数据， w为训练器寻找的最佳参数。

梯度上升法：

思想：要找到某函数的最大值，最好的方法是沿着该函数的梯度方向探寻。

函数f(x,y)的梯度：

沿x的方向移动，沿y的方向移动，最后能够到达最优点，但是f(x,y)在待计算点需要有定义并且可微。

梯度算子总是指向函数值增长最快的方向。移动方向为梯度方向，移动量大小需要乘以一个参数，称之为步长。参数迭代公式为：

公式可一直执行，直到某个条件停止为止。如迭代次数或者算法达到某个可以允许的误差范围。

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

梯度上升法伪代码：

基于上面的内容，我们来看一个Logistic回归分类器的应用例子，从图5-3可以看到我们采的数据集。
数据点：

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

# -*- coding: utf-8 -*-

from numpy import *
#下载数据
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])])   #X0=1,X1,X2
        #print(dataMat)
        labelMat.append(int(lineArr[2])) #label
        #print (labelMat)
    #print(dataMat,labelMat)
    return dataMat, labelMat

def sigmoid(inX):
    return longfloat(1.0/(1+exp(-inX)))
#梯度上升
def gradAscent(dataMatIn, classLabels):
    dataMatrix = mat(dataMatIn)             #convert to NumPy matrix
    labelMat = mat(classLabels).transpose() #convert to NumPy matrix,and 转置
    m, n = shape(dataMatrix)                #行数m=100，列数n=3
    alpha = 0.001                           #步长
    maxCycles = 500                         #迭代次数
    weights = ones((n,1))
    for k in range(maxCycles):              #heavy on matrix operations
        h = sigmoid(dataMatrix*weights)     #matrix mult
        error = (labelMat - h)              #vector subtraction
        weights = weights + alpha * dataMatrix.transpose() * error #matrix mult
        # 梯度上升
    return weights      #3*1

def plotBestFit(weights):
    import matplotlib.pyplot as plt
    dataMat, labelMat = loadDataSet()
    dataArr = array(dataMat)
    n = shape(dataArr)[0]    #行数n
    xcord1 = []; ycord1 = []
    xcord2 = []; ycord2 = []
    #统计label
    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 = arange(-3.0, 3.0, 0.1)      #（-3,3）之间间隔0.1
    # 拟合曲线为0 = w0*x0+w1*x1+w2*x2, 故x2 = (-w0*x0-w1*x1)/w2, x0为1,x1为x, x2为y,故有
    y = (-weights[0]-weights[1]*x)/weights[2]     #z等于0，是sigmiod函数的分界线
    ax.plot(x, y)
    plt.xlabel('X1')
    plt.ylabel('X2')
    plt.show()

#测试程序
datamat, labels = loadDataSet()
weights = gradAscent(datamat, labels)
#x为array格式，weights为matrix格式，故需要调用getA()方法，其将matrix()格式矩阵转为array()格式
#getA()方法，其将matrix()格式矩阵转为array()格式，type(weights),type(weights.getA())可观察到。
plotBestFit(weights.getA())

输出结果，最优分界线：

训练算法：随机梯度上升

梯度上升算法中，每次更新回归系数需要遍历整个数据集。数据量若是大了，计算复杂度较高。

改进方法：一次仅用一个样本点更新回归系数，这便是随机梯度上升算法。

伪代码：

代码：

#随机梯度上升
def stocGradAscent0(dataMatrix, classLabels):
    m,n = shape(dataMatrix)
    alpha = 0.01
    weights = ones(n)   #initialize to all ones
    for i in range(m):
        h = sigmoid(sum(dataMatrix[i]*weights))
        error = classLabels[i] - h
        weights = weights + alpha * error * dataMatrix[i]
    return weights
weights0 = stocGradAscent0(array(datamat),labels)
plotBestFit(weights0)

代码结果显示：

Figure 5-4: 随机梯度上升算法分割线

结果显示其效果还不如梯度上升算法，不过不一样，梯度上升算法，500次迭代每次都用上了所有数据，而随机梯度上升算法总共也只用了500次。需要对其进行改进：

#改进的随机梯度上升
def stocGradAscent1(dataMatrix, classLabels, numIter=150):
    m, n = shape(dataMatrix)
    weights = ones(n)   #initialize to all ones
    for j in range(numIter):
        dataIndex = range(m)
        for i in range(m):
            alpha = 4/(1.0+j+i)+0.0001    #apha decreases with iteration, does not 
            randIndex = int(random.uniform(0,len(dataIndex)))#go to 0 because of the constant
            h = sigmoid(sum(dataMatrix[randIndex]*weights))
            #print(dataMatrix[randIndex], weights)
            error = classLabels[randIndex] - h
            weights = weights + alpha * error * dataMatrix[randIndex]
            del(dataIndex[randIndex])
    return weights
weights1 = stocGradAscent1(array(datamat), labels)
plotBestFit(weights1)

Figure 5-5: 改进的随机梯度上升算法分割线

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

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

可选做法：

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

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

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):                            #21个特征，1个label
            lineArr.append(float(currLine[i]))
        trainingSet.append(lineArr)
        trainingLabels.append(float(currLine[21]))
    #print(trainingSet)
    trainWeights = stocGradAscent1(array(trainingSet), trainingLabels, 1000)
    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))

multiTest()

Figure 5-7: 测试结果

5.4 小结

Logistic回归：

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