机器学习实战——Logistic回归

# -*- coding:utf-8 -*- 
from numpy import *  
  
#加载数据集  
def loadDataSet():  
    dataMat = []  
    labelMat = []  
    fp = open("C:\\Users\\Rainey\\Desktop\\testSet.txt")  
    for line in fp.readlines():  
        lineArr = line.strip().split() #删除文件中多余的字符  
        dataMat.append([1.0,float(lineArr[0]), float(lineArr[1])])  
        labelMat.append(float(lineArr[2]))  
  
    return dataMat,labelMat  
  
#定义Sigmoid函数  
def sigmoid(inX):  
    return 1.0/(1+exp(-inX))  
  
#定义求解最佳回归系数,Logistic回归梯度上升优化算法  
def gradAscent(dataMatIn,classLabels):  
    dataMatrix = mat(dataMatIn) #将数组转为矩阵  
    labelMat = mat(classLabels).transpose()  #转置
    m,n = shape(dataMatrix)      #返回矩阵的行和列  
    alpha = 0.001      #初始化 alpha的值  
    maxCycles = 500    #最大迭代次数  
    weights = ones((n,1)) #初始化最佳回归系数  
    for i in range(0,maxCycles):  
        #引用原书的代码，求梯度  
        #dataMatrix*weights，100×3和3×1的矩阵相乘，得到100×1的矩阵  
        h = sigmoid(dataMatrix*weights)  
        #h的取值为0~1，因而error为误差
        error = labelMat - h  
        weights = weights + alpha * dataMatrix.transpose() * error  
  
    return weights  

#随机梯度上升算法
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))           #此处h为具体数值  
        error   = classLabels[i] - h                            #error也为具体数值  
        weights = weights + alpha*error*dataMatrix[i]           #每次对一个样本进行处理，更新权值  
    return weights  

#改进的随机梯度上升算法，收敛得更快
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+i+j)+0.0001 #alpha迭代次数不断变小，1.非严格下降，2.不会到0  
            #随机选取样本更新系数weights,每次随机从列表中选取一个值，用过后删除它再进行下一次迭代              
            randIndex = int(random.uniform(0, len(dataIndex)))#每次迭代改变dataIndex,而m是不变的，故不用unifor(0, m)  
            h = sigmoid(sum(dataMatrix[randIndex]*weights))  
            error = classLabels[randIndex] - h  
            weights = weights + alpha*error*dataMatrix[randIndex]  
            del(dataIndex[randIndex])  
    return weights  

  
#分析数据，画出决策边界  
def plotBestFit(wei,dataMatrix,labelMat):  
    import matplotlib.pyplot as plt  
    weights = wei    #将矩阵wei转化为list  
    dataArr = array(dataMatrix)  #将矩阵转化为数组  
    n = shape(dataMatrix)[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)  #x为numpy.arange格式，并且以0.1为步长从-3.0到3.0切 
    #拟合曲线为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]  
    ax.plot(x,y)  
    plt.xlabel("x1")     #X轴的标签  
    plt.ylabel("x2")     #Y轴的标签  
    plt.show()  
  
if __name__=="__main__":  
    dataMatrix,labelMat = loadDataSet()  
    weight = stocGradAscent1(array(dataMatrix), labelMat)  
    plotBestFit(weight,dataMatrix,labelMat)