《机器学习实战》-Chapter5-Logistic回归

Logistic回归是非常经典的分类算法，它可以对非线性可分的数据集进行分类（当然有误分类的情况），因为这本书主要针对初学者所以只考虑的二分类问题。这章的代码没有需要改动的，python2.X和python3.X均能跑。

最开始的训练使用的是梯度上升算法来求解出拟合曲线的参数最优值，此时的计算均是矩阵运算。效果很不错：

但是梯度上升算法对于数据量小的情况还比较适用，差别没那么明显，但是一旦数据量很大计算将变得非常缓慢（每次数据集更新都要重新读取一遍数据集，而且每次都是循环全部数据集的计算，假设有10000个数据，循环10次都已经得做100000次运算了），因此之后作者考虑了随机梯度上升算法，其实本质差不多只不过是不进行矩阵相乘的运算了（矩阵相乘就代表着全体数据集的相乘），而是向量之间的运算（就是针对每一条数据集进行运算），从数据集中每次随机选一些数据进行计算，然后整体迭代n次就可以了，看起来拟合效果没差很大嘛（迭代了150次）：

最后用了这段代码预测了以下马?患疝气病之后的死亡率问题。

具体代码如下：

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

from numpy import *
import math

def loadDataSet():
    dataMat = []
    labelMat = []
    fr = open("testSet.txt")
    for lines in fr.readlines():
        lineArr = lines.strip().split()
        dataMat.append([1.0,float(lineArr[0]),float(lineArr[1])])
        labelMat.append(int(lineArr[-1]))
    #dataMat,labelMat均是List对象
    return dataMat,labelMat

def sigmoid(z):
    return 1.0/(1+exp(-z))

#梯度上升法
def gradAscent(dataMat,classLabel):
    #dataMatrix是m*n维的矩阵
    dataMatrix = mat(dataMat)
    #转置矩阵
    labelMat = mat(classLabel).transpose()
    m,n = shape(dataMatrix)  
    alpha = 0.001
    maxCycles = 500
    #weight是n*1维向量
    weight = ones((n,1))
    for k in range(maxCycles):
        #h是M*1维向量，表示所有护具和
        h = sigmoid(dataMatrix * weight)
        error = labelMat - h
        weight = weight + alpha* dataMatrix.transpose()*error
    #weight是<class 'numpy.matrixlib.defmatrix.matrix'>对象，是向量
    return weight

#随机梯度上升法
def stoGradAscent0(dataMatrix,classlabels):
    #这里传入的dataMatrix必须是nparray型对象，因为List不能和浮点数相乘，但nparray可以。
    m,n = shape(dataMatrix)
    alpha = 0.1
    weight = ones(n)
    for i in range(m):
        h = sigmoid(sum(dataMatrix[i] * weight))
        error = classlabels[i] - h
        weight = weight + alpha*error*dataMatrix[i]
    return weight

#改进的随机梯度上升法  
def stoGradAscent1(dataMatrix,classlabels,numIter=150):
    #这里传入的dataMatrix必须是nparray型对象，因为List不能和浮点数相乘，但nparray可以。
    import random
    m,n = shape(dataMatrix)
    alpha = 0.1
    weight = 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] * weight))
            error = classlabels[randIndex] - h
            weight = weight + alpha*error*dataMatrix[randIndex]
            del(dataIndex[randIndex])
    return weight
#画出决策边界
def plotBestFit(weights):
    #这里的weights必须是nparray对象，不能是matrix，否则y与x的shape会不匹配
    #一维list的shape就是[n,]但是matrix的shape是[1,n]
    import matplotlib.pyplot as plt
    dataMat,labelMat = loadDataSet()
    dataArr = array(dataMat)
    #数据个数，一共有100组数据
    n = shape(dataArr)[0]
    #xcord1,ycord1是指类别为1的数据的坐标值
    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=20,c='red',marker='s')
    ax.scatter(xcord2,ycord2,s=20,c='green')
    #生成60个点来画决策边界，太短的画可能看不出来。
    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()

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 = stoGradAscent1(array(trainingSet),trainingLabels,500)
    errorCount = 0.0
    numTestVec = 0.0
    for line in frTest.readlines():
        numTestVec += 1
        currLine = line.strip().split('\t')
        lineArr = []
        for i in range(21):
            lineArr.append(float(currLine[i]))
        label = classifyVector(array(lineArr),trainWeights)
        if int(label) != int(currLine[21]):
            errorCount  += 1
    ac = float(errorCount)/float(numTestVec)
    print("预测的错误率是：%f" % ac)
    return ac
def multTest():
    numTest = 10
    errorSum = 0.0
    for k in range(numTest):
        errorSum += colicTest()
    print('经过 %d 次迭代测试，发现该模型的平均错误率是： %f' % (numTest,errorSum/float(numTest)))