Logistic回归

'''
回归：拟合，要找到最佳拟合参数集（训练分类器时的做法就是在找最佳拟合参数，使用的是最优化算法）
利用Logistic回归进行分类的主要思想：根据现有数据对分类边界建立回归公式以此进行分类
优点：计算代价小，容易理解和实现
缺点：容易欠拟合，分类精度可能不高
适用数据类型：数值型和标称型数据
'''
###Sigmoid函数：σ(x)=1/(1+e^(-x))
##import numpy as np
##import matplotlib.pyplot as plt
##import math
##x=np.arange(-5,5,0.0001)
##y=(1/(1+math.e**(-x)))
##plt.plot(x,y)
##plt.show()


'''
梯度上升法基于的思想：要找到某函数的最大值，最好的方法是沿着该函数的梯度方向探寻
如果梯度记为▽，则函数f(x,y)的梯度为：▽f(x,y)=分别对x和y求偏导，f(x,y)必须在待计算的点上有定义并且可微
梯度算法到达每个点后都会重新估计移动的方向(x(y)方向移动距离为对x(y)的偏导值)
'''


from numpy import*
import math
def loadDataSet():
    dataMat=[]                           #初始化X0、X1、X2列表
    labelMat=[]                          #初始化标签列表
    fr=open('testSet.txt')               #打开文件
    for line in fr.readlines():          #读取数据
        lineArr=line.strip().split()     #切分数据
        dataMat.append([1.0,float(lineArr[0]),float(lineArr[1])])#X0=1.0,X1,X2分别为txt中的第0、第1个数据
        labelMat.append(int(lineArr[2])) #得到第三列数据列表，是对应行的标签数字
    return dataMat,labelMat              #返回X0、X1、X2构成的列表和标签列表

def sigmoid(inX):
    if inX>=0:
        return 1.0/(1+exp(-inX))
    else:
        return exp(inX)/(1+exp(inX))
'''
这里对sigmoid函数进行了优化，当inX趋于无穷大时有可能发生极大溢出，产生警告：RuntimeWarning: overflow encountered in exp
'''

def gradAscent(dataMatIn,classLabels):   #参数意义：loadDataSet()的返回值：一个数组类型矩阵和一个标签列表
    dataMatrix=mat(dataMatIn)            #将两个参数都标准矩阵化
    labelMat=mat(classLabels).transpose()#将得到标签标准矩阵进行转置(1×100转100×1)
    m,n=shape(dataMatrix)                #返回dataMatrix矩阵的行列值C:/Users/apple/Desktop/备份文件/关于Python/机器学习源代码/Ch05/testSet.txt
    alpha=0.001                          #向目标移动的步长
    maxCycles=500                        #迭代次数
    weights=ones((n,1))                  #初始化一个n×1形状的数组类型矩阵
    for k in range(maxCycles):
        h=sigmoid(dataMatrix*weights)    #计算sigmoid()函数值，其中参数是标准矩阵×数组矩阵，规则仍然是按照标准矩阵乘法运算(100*3)*(3*1)
        error=(labelMat-h)               #h是一个向量列表不是一个具体的数,这里是两个列向量进行相减
        weights=weights+alpha*dataMatrix.transpose()*error#梯度上升算法的迭代公式：w:=w+α▽f(w)   0.001×(3×100)×(100×1)
    return weights                       #(3×1)
'''
难理解地方：
Sigmoid函数的输入设为z，则z=W(T)X，其中W(T)是向量W的转置，X也是一个向量
Sigmoid函数是一个阶跃函数，将样本的每一个特征值都乘一个回归系数，然后都加起来，再带入Sigmoid函数得到结果（0或者1）
（Sigmoid 函数当x>0时函数值大于0.5，x<0时函数值小于0.5）
关于最佳系数的确定：所给定的


'''

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')  #用不同的方式表示不同标签值的点，其中marker是设置点的形状:默认为'o'圆形，'s'为正方形,'p'为五角
    ax.scatter(xcord2,ycord2,s=30,c='green',marker='*')#'*'为五角星
    x=arange(-3.0,3.0,0.1)               #设置x的显示范围
    y=(-weights[0]-weights[1]*x)/weights[2]
    ax.plot(x,y)                         #在画板上画出y，x关于上述关系的图像
    plt.xlabel('X1');plt.ylabel('X2')    #设置坐标轴名称
    plt.show()                           #显示图像

#随机梯度上升算法
def stocGradAscent0(dataMatrix,classLabels):#参数意义：loadDataSet()函数的两个返回值，(X0,X1,X2)数组矩阵和标签列表
    m,n=shape(dataMatrix)                #取得数组矩阵的行数和列数
    alpha=0.01                           #迭代步长
    weights=ones(n)                      #初始化一个数组矩阵，一行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):#参数意义：loadDataSet()函数的两个返回值、迭代次数
    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
##dataArr,labelMat=loadDataSet()
##weights=stocGradAscent1(array(dataArr),labelMat)
##plotBestFit(weights)


#Logistic回归分类函数
def classifyVector(inX,weights):
    prob=sigmoid(sum(inX*weights))
    if prob>0.5:
        return 1.0
    else:
        return 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):#训练集中一共有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)))