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

Logistic回归介绍

优点：计算代价不高，容易理解和实现
缺点：容易欠拟合，分类精度可能不高
适用数据类型：数值型和标称型数据
Logistic回归的一般过程
1、收集数据
2、准备数据，数值型数据
3、分析数据
4、训练算法：为了找到最佳的分类回归系数
5、测试算法：一旦训练步骤完成，分类将会很快
6、使用算法

Sigmoid 函数和Logistic回归分类器

最优化理论初步
梯度下降算法
数据中的缺失项处理
回归：有一些数据点，用一条直线对这些点进行拟合，这个拟合过程成为回归。
利用logistic回归进行分类的主要思想是：根据现有数据对分类边界线建立回归公式，以此进行分类。训练分类器就是寻找最佳拟合参数，使用的是最优化算法。
数据集

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

sigmoid函数 $\sigma (z)=\frac{1}{1+e^{-z}}$

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

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

梯度上升算法：用来算函数的最大值
梯度下降法：用来算函数的最小值
系数迭代计算
weights=weights+alpha*dataMatrix.transpose()*error
公式的推导要知道，系数变化量就是步长alpha乘以损失函数对于系数的求导
损失函数就是最小二乘
损失函数的求导就是按梯度方向减少的量error乘以x

def gradAscent(dataMatIn,classLabels):
    dataMatrix=mat(dataMatIn)
    labelMat=mat(classLabels).transpose()//数据转置操作
    m,n=shape(dataMatrix)
    alpha=0.001//目标移动的步长
    maxCycles=500//迭代次数
    weights=ones((n,1))
    for k in range(maxCycles):
        h=sigmoid(dataMatrix*weights)//矩阵相乘
        error=(labelMat-h)
        weights=weights+alpha*dataMatrix.transpose()*error//梯度下降法计算公式
    return weights

分析数据，画出决策边界

def plotBestFit(weights):
    import matplotlib.pyplot as plt
    # weights=wei.getA()
    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)
    alpha=0.01
    weights=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

但仅仅对数据集迭代一次，准确率不够，要加快收敛速度，修改算法
所做的改动
1 alpha每次迭代都会调整，这回缓解数据波动，或者高频波动
2 通过随机选取样本系数，可以减少周期性波动
3 增加了迭代参数

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
            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

处理数据中的缺失值
1、使用可用特征的均值来填补缺失值
2、使用特殊值来填补缺失值，如-1
3、使用相思样本的均值添补缺失值
4、使用另外的机器学习算法预测缺失值
例子中存在缺失的分类类别则直接舍弃，存在确实的特征赋值为零，因为零不会影响logistic分类结果
以下代码：读入训练数据，测试数据，通过训练数据迭代测试得到系数weights，然后通过weights和特殊数据特征，求得分类结果，和真实值比较，返回错误率。

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=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

由于每次测试随机迭代得到的系数都未必收敛，如果系数没有收敛，最后的分类结果就会改变，多次测试，错误率在30%左右

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))