机器学习实战之Logistic回归-----Python3完美运行注释后期补上

logistic回归的一般过程

（1）收集数据：采用任意方法收集数据。

（2）准备数据：由于需要进行距离计算，因此要求数据类型为数值型。另外，结构化数据格式为最佳。

（3）分析数据：采用任意方法对数据进行分析。

（4）训练算法：大部分时间将用于训练，训练的目的是为了找到最佳的分类回归系数。

（5）测试算法：一旦训练步骤完成，分类将会很快。

（6）使用算法：首先，我们需要输入一些数据，并将其转化成对应的结构化数值；

（7）基于训练好的回归系数就可以对这些数值进行简单的回归计算，判定他们属于哪个类别；然后在输出的类别上做一些其他分析工作。

使用梯度上升算法找最优参数

伪代码：

 每个回归系数初始化为1

重复R次：

        计算整个数据集的梯度

        使用alphaxgradient更新回归系数的向量

返回回归系数

import math
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])])
        labelMat.append(int(lineArr[2]))
    return dataMat,labelMat
def sigmoid(inX):
    return 1.0/(1+exp(-inX))
#输入数据特征与数据的类别标签
#返回最佳回归系数(weights)
def gradAscent(dataMatIn,classLabels):
#转换为numpy型
    dataMatrix=mat(dataMatIn)#numpy中的array转(mat)矩阵函数
    labelMat=mat(classLabels).transpose() ##numpy中的array转(mat)矩阵函数并转置
   # m->数据量，样本数 n->特征数
     m,n=shape(dataMatrix)
    alpha=0.001#步长
    maxCycles=500#迭代次数
    weights=ones((n,1))#初始化权值向量，每个维度均为1.0
    for k in range(maxCycles):
        h=sigmoid(dataMatrix * weights)  #回归系数与数据向量相乘带入Sigmoid函数中，得到h，注意h是向量
        error=(labelMat-h)
        weights=weights+alpha*dataMatrix.transpose()*error
    return weights
def plotBestFit(weights):
    import matplotlib.pyplot as plt
    dataMat,labelMat=loadDataSet()
    dataArr=array(dataMat)
    # n->数据量，样本数
    n=shape(dataArr)[0]
    #xcord1,ycord1代表正例特征
    #xcord2,ycord2代表负例特征
    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和y的值
    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()



if __name__== '__main__':
    dataArr,labelMat=loadDataSet()
    weights=gradAscent(dataArr,labelMat)
    plotBestFit(weights.getA())

其效果图如下：

随机梯度上升算法：

伪代码如下：

      所有回归系数初始化为1

      对数据集中每个样本

                      计算该样本的梯度

                      使用alphaXgradient回归系数值 

      返回回归系数值

代码如下：

def stocGradAscent0(dataMatrix,classLabels):
    import numpy as np
    dataMatrix=np.array(dataMatrix)
    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

 运行效果如下图所示：

改进的随机梯度上升算法：

def stocGradAscent1(dataMatrix,classLabels,numIter=150):
    import numpy as np
    dataMatrix=np.array(dataMatrix)
    m,n=shape(dataMatrix)
    weights=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]*weights))
            error=classLabels[randIndex]-h
            weights=weights+alpha*error*dataMatrix[randIndex]
            del(dataIndex[randIndex])
    return weights

效果图如下：

示例：使用logistic回归估计马疝病的死亡率

（1）收集数据：给定文本文件

（2）准备数据：用Python解析文本文件并填充缺失值

（3）分析数据：可视化并观察数据。

（4）训练算法：使用优化算法，找到最佳系数

（5）测试算法：观察错误率，根据错误率决定是否退回到训练阶段，通过改变迭代的次数和步长等参数来得到更好的回归系数

（6）使用算法：实现一个简单的命令行程序收集马的症状并输出预测结果

代码如下：

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