机器学习实战第五章Logistic回归照葫芦画瓢算法实践

完成了最基本的Logistic算法的测试，手写了最简单的随机梯度上升的算法。

并基于写好的算法，利用疝气病症预测了病马的死亡率（即能否存活）

这章的代码比较短，但是由于5.1假期太浪，回来之后才补完。

# -*- coding: utf-8 -*-
"""
照葫芦画瓢完成于2017.5.2 20:30
算法名称 : Logistic回归
算法整体思路：
  利用凸优化中的随机梯度上升法来对回归系数进行调优，基于迭代完毕之后的系数，通过sigmoid函数进行分类
  然后和实际的分类结果进行比较，可以观察出错误率等相关的东西
  注意梯度的数值计算方法的求解
  注意随机梯度上升的批处理思想---->实际上就是分块
作者:
    zzt941006
"""
from numpy import *
def loadDataSet():
    dataMat = []
    labelMat = []
    fr = open('testSet.txt')
    for line in fr.readlines():
        lineArr = line.strip().split() #获取测试集中的元素的每一行，并形成一个list
        #print lineArr
        dataMat.append([1.0,float(lineArr[0]),float(lineArr[1])])#将前2个值单独取出，并在前面均加上1.0这个属性，构成数据矩阵
        labelMat.append(int(lineArr[2]))#将最后一列的元素单独取出，构成标签矩阵
    return dataMat,labelMat
#sigmoid函数的计算
#原型为 1 / （1 + e ^ -z)
def sigmoid(inX):
    return 1.0/(1+exp(-inX))
#Logistic回归梯度上升优化算法
#注意要遍历整个数据集，数据集十分大的时候效率会非常慢
def gradAscent(dataMatIn,classLabels):
    dataMatrix = mat(dataMatIn)#将list类型转化为numpy类型,矩阵维度为 100 * 3
    labelMat = mat(classLabels).transpose()#同样转化，并转置,变成 100 * 1的格式
    m,n = shape(dataMatrix)#获取矩阵行和列
    alpha = 0.001#向目标移动的步长
    maxCycles = 500#迭代次数
    weights = ones((n,1))#初始化权重（回归）矩阵，维度为 3 * 1 并且所有元素都是 1，因为 sigmoid函数中的 z  =  x * w
    #print shape(dataMatrix * weights)
    for k in range(maxCycles):
        h = sigmoid(dataMatrix * weights) #得到一个100 * 1 维的向量
        error = (labelMat - h)#计算标准分类和其进行sigmoid操作后的差
        weights = weights + alpha * dataMatrix.transpose() * error # 注意这里 dataMatrix.transpose() * error 实际上计算的就是基于当前
                                                                   # weight的梯度，只不过这是数值计算梯度的方法
    return weights
#画出数据集和Logistic回归最佳拟合直线的函数
def plotBestFit(weights):
    import matplotlib.pyplot as plt
    dataMat,labelMat=loadDataSet()
    dataArr = array(dataMat)
    n = shape(dataArr)[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 = 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 stocGradAscent0(dataMatrix,classLabels):
    m,n = shape(dataMatrix)
    weights = ones(n)
    alpha = 0.01
    for i in range(m):
        h = sigmoid(sum(dataMatrix[i] * weights))#取每一行的属性来做sigmoid操作，并更新weights
        error = classLabels[i] - h
        weights = weights + alpha * error * dataMatrix[i]
    return weights
#改进的随机梯度上升，通过设置numIter来迭代alpha的值，来进行调优
def stocGradAscent1(dataMatrix,classLabels,numIter = 150):
    m,n = shape(dataMatrix)
    weights = ones(n)
    for j in range(numIter):
        dataIndex = range(m)
        for i in range(m):
            alpha = 4 /(1.0 + j + i) + 0.01#加一个常数，防止alpha降低到0
            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
#分类函数，通过sigmoid计算，一旦大于0.5就阶跃到1，反之被分类为0
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')
       # print currLine
        lineArr = []
        for i  in range(21):
            lineArr.append(float(currLine[i]))
        trainingSet.append(lineArr)
        trainingLabels.append(float(currLine[21]))#第22列为实际标签
    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 = 20
    errorSum = 0.0
    for k in range(numTests):
        errorSum += colicTest()
    print "after %d iterations the average error rate is: %f" % (numTests,errorSum/(float(numTests)))