机器学习实战——Logistic回归代码

import matplotlib.pyplot as plt
from numpy import *
#从testSet.txt读取数据，创建data和label
def createdata():
    f=open('testSet.txt')
    data=[]
    label=[]
    for line in f.readlines():
        temp=line.strip().split('\t')
        temp_l=[1.0,float(temp[0]),float(temp[1])]
        data.append(temp_l)
        label.append(int(temp[2]))
    return data,label

#定义sigomid函数，用于分类
def sigomid(intX):
    z=1.0/(1.0+exp(-intX))
    return z

#训练获得最佳回归线参数，W=[w0,w1,~~~~wn]
def tran_W(data,label):
    #转换为Numpy矩阵
    data_m=mat(data)
    label_m=mat(label)
    #获得矩阵的形状
    m,n=shape(data_m)
    #初始化回归参数为（1,1,1，，，，，1）
    w=ones((n,1))
    #转置
    h=label_m.transpose()
    #最多的迭代次数
    max_C=500
    #步长
    alpha=0.001
    for i in range(max_C):
        error=(h-sigomid(data_m*w) )              #和实际分类的偏差
        w=w+alpha*data_m.transpose()*error      #修正
    return w

#print(tran_W(createdata()[0],createdata()[1]))

#画出这些点和分界线
def plotbestFit(weight):

    if type(weight).__name__!='ndarray':
        weights=weight.getA()
    else:
        weights=weight

    data,label=createdata()
    X0=[];Y0=[]
    X1=[];Y1=[]

    n=shape(data)[0]
    for i in range(n):
        key=label[i]
        if key==1:
            X1.append(data[i][1])
            Y1.append(data[i][2])
        else:
            X0.append(data[i][1])
            Y0.append(data[i][2])
    fig=plt.figure()
    ax=fig.add_subplot(111)
    ax.scatter(X0,Y0,s=30,c='red',marker='s')
    ax.scatter(X1, Y1, 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()
    plt.close()

#data,labels=createdata()
#plotbestFit(tran_W(data,labels))

def stocGradAscent(datamatrix,labels):
    m,n=shape(datamatrix)
    w=ones(n)
    alpha=0.01
    for i in range(m):
        z=sigomid(sum(datamatrix[i]*w))
        error=labels[i]-z
        w=w+alpha*error*(datamatrix[i])
    return w

#w=stocGradAscent(array(data),labels)
#plotbestFit(w)


import random
def stocGradAscent1(datamatrix,labels,maxc=150):
    m,n=shape(datamatrix)
    w=ones(n)
    alpha=0.01
    for j in range(maxc):
        data_index=list(range(m))
        for i in range(m):
            alpha=4/(1.0+i+j)+0.01
            index=int(random.uniform(0,len(data_index)))
            z=sigomid(sum(datamatrix[index]*w))
            error=labels[index]-z
            w=w+alpha*error*(datamatrix[index])
            del(data_index[index])
    return w
#print(type(data))
#w=stocGradAscent1(array(data),labels)
#plotbestFit(w)

#分类，参数是训练得到的最佳回归参数和待分类的一个样本
def classify(weights,input):
    z=sigomid(sum(weights*input))
    if z >0.5:
        return 1
    else:
        return 0

#测试函数
#函数主要流程是，先读取tran_text文件的样本数据，得到dataset和labelset。并通过训练函数得到最佳回归参数
#然后一行一行的读取testtxt文件的测试数据，并通过classify函数分类，计算误差率
def colitest():
    #得到训练集的数据矩阵和标签向量
    frtran=open('horseColicTraining.txt')
    frtest=open('horseColicTest.txt')
    trandataset=[];tranlabelset=[]
    for line in frtran.readlines():
        line_temp=[]
        temp=line.strip().split('\t')

        for i in range(21):
            line_temp.append(float(temp[i]))
        trandataset.append(line_temp)
        tranlabelset.append(float(temp[21]))
    #训练得到最佳回归参数
    #print(type(trandataset))
    weights=stocGradAscent1(array(trandataset),tranlabelset)

    #对测试集进行测试，并计算误差率。
    error_cnt=0.0;testnum=0
    for testline in frtest.readlines():
        testnum+=1
        vec=[]
        test=testline.strip().split('\t')
        for j in range(21):
            vec.append(float(test[j]))
        if int(classify(weights,vec))!=int(test[21]):
            error_cnt+=1


    print(float(error_cnt)/testnum)
    return float(error_cnt)/testnum

#colitest()

#因为在改进版的训练函数中包含有随机成分，1.步长是变化的 2.改进版是在线学习算法，每次的样本数据是随机选择的
#所以每次运行的结果不尽相同，只有在训练函数的迭代次数内就已经完全收敛，那么每次运行才会得到一致的结果
#下面进行多次运行，并取平均值，作为我们的误差率
def multtest(num=10):
    err=0.0
    for i in range(num):
        err+=colitest()
    print('平均误差率为： %f'%(err/num))

multtest()