python机器学习之神经网络（二）


            由于Rosenblatt感知器的局限性，对于非线性分类的效果不理想。为了对线性分类无法区分的数据进行分类，需要构建多层感知器结构对数据进行分类，多层感知器结构如下：





该网络由输入层，隐藏层，和输出层构成，能表示种类繁多的非线性曲面，每一个隐藏层都有一个激活函数，将该单元的输入数据与权值相乘后得到的值(即诱导局部域)经过激活函数，激活函数的输出值作为该单元的输出，激活函数类似与硬限幅函数，但硬限幅函数在阈值处是不可导的，而激活函数处处可导。本次程序中使用的激活函数是tanh函数，公式如下：







tanh函数的图像如下：





程序中具体的tanh函数形式如下：





就是神经元j的诱导局部域



它的局部梯度分两种情况：

(1)神经元j没有位于隐藏层：





(2)神经元j位于隐藏层：







其中k是单元j后面相连的所有的单元。

局部梯度得到之后，根据增量梯度下降法的权值更新法则



即可得到下一次的权值w，经过若干次迭代，设定误差条件，即可找到权值空间的最小值。

python程序如下，为了能够可视化，训练数据采用二维数据，每一个隐藏层有8个节点，设置了7个隐藏层，一个输出层，输出层有2个单元：





import numpy as np 

import random 

import copy 

import matplotlib.pyplot as plt 

 

 

#x和d样本初始化 

train_x = [[1,6],[3,12],[3,9],[3,21],[2,16],[3,15]] 

d =[[1,0],[1,0],[0,1],[0,1],[1,0],[0,1]] 

warray_txn=len(train_x[0]) 

warray_n=warray_txn*4 

 

#基本参数初始化 

oldmse=10**100 

fh=1 

maxtrycount=500 

mycount=0.0 

if maxtrycount>=20: 

    r=maxtrycount/5 

else: 

    r=maxtrycount/2 

#sigmoid函数 

ann_sigfun=None 

ann_delta_sigfun=None 

#总层数初始化，比非线性导数多一层线性层 

alllevel_count=warray_txn*4 

# 非线性层数初始化 

hidelevel_count=alllevel_count-1 

 

#学习率参数  

learn_r0=0.002  

learn_r=learn_r0    

#动量参数 

train_a0=learn_r0*1.2 

train_a=train_a0 

expect_e=0.05 

#对输入数据进行预处理 

ann_max=[] 

for m_ani in xrange(0,warray_txn):       #找出训练数据中每一项的最大值 

  temp_x=np.array(train_x) 

  ann_max.append(np.max(temp_x[:,m_ani])) 

ann_max=np.array(ann_max) 

 

def getnowsx(mysx,in_w): 

    '''''生成本次的扩维输入数据 ''' 

    '''''mysx==>输入数据，in_w==>权值矩阵，每一列为一个神经元的权值向量''' 

    global warray_n 

    mysx=np.array(mysx) 

    x_end=[]   

    for i in xrange(0,warray_n): 

        x_end.append(np.dot(mysx,in_w[:,i])) 

    return x_end 

 

def get_inlw(my_train_max,w_count,myin_x): 

    '''''找出权值矩阵均值接近0，输出结果方差接近1的权值矩阵''' 

    #对随机生成的多个权值进行优化选择，选择最优的权值 

    global warray_txn 

    global warray_n 

    mylw=[] 

    y_in=[] 

    #生成测试权值 

    mylw=np.random.rand(w_count,warray_txn,warray_n) 

    for ii in xrange (0,warray_txn): 

      mylw[:,ii,:]=mylw[:,ii,:]*1/float(my_train_max[ii])-1/float(my_train_max[ii])*0.5 

 

    #计算输出 

    for i in xrange(0,w_count): 

        y_in.append([]) 

        for xj in xrange(0,len(myin_x)): 

            y_in[i].append(getnowsx(myin_x[xj],mylw[i])) 

    #计算均方差 

    mymin=10**5 

    mychoice=0 

    for i in xrange(0,w_count): 

        myvar=np.var(y_in[i]) 

        if abs(myvar-1)<mymin: 

            mymin=abs(myvar-1) 

            mychoice=i 

    #返回数据整理的权值矩阵 

    return mylw[mychoice] 

mylnww=get_inlw(ann_max,300,train_x) 

 

def get_inputx(mytrain_x,myin_w): 

    '''''将训练数据经过权值矩阵，形成扩维数据''' 

    end_trainx=[] 

    for i in xrange(0,len(mytrain_x)): 

        end_trainx.append(getnowsx(mytrain_x[i],myin_w))     

    return end_trainx 

     

x=get_inputx(train_x,mylnww)#用于输入的扩维数据 

#对测试数据进行扩维 

def get_siminx(sim_x): 

    global mylnww 

    myxx=np.array(sim_x) 

    return get_inputx(myxx,mylnww) 

#计算一层的初始化权值矩阵 

def getlevelw(myin_x,wo_n,wi_n,w_count): 

    mylw=[] 

    y_in=[] 

    #生成测试权值 

    mylw=np.random.rand(w_count,wi_n,wo_n) 

    mylw=mylw*2.-1 

 

    #计算输出 

    for i in xrange(0,w_count): 

        y_in.append([]) 

        for xj in xrange(0,len(myin_x)): 

          x_end=[]   

          for myii in xrange(0,wo_n): 

            x_end.append(np.dot(myin_x[xj],mylw[i,:,myii])) 

          y_in[i].append(x_end) 

    #计算均方差 

    mymin=10**3 

    mychoice=0 

    for i in xrange(0,w_count): 

        myvar=np.var(y_in[i]) 

        if abs(myvar-1)<mymin: 

            mymin=abs(myvar-1) 

            mychoice=i 

    #返回数据整理的权值矩阵 

    csmylw=mylw[mychoice] 

    return csmylw,y_in[mychoice]     

ann_w=[] 

def init_annw(): 

  global x 

  global hidelevel_count 

  global warray_n 

  global d 

  global ann_w 

  ann_w=[] 

  

  lwyii=np.array(x) 

  #初始化每层的w矩阵 

  for myn in xrange(0,hidelevel_count):         

    #层数 

    ann_w.append([])  

    if myn==hidelevel_count-1: 

      for iii in xrange(0,warray_n): 

        ann_w[myn].append([]) 

        for jjj in xrange(0,warray_n): 

                ann_w[myn][iii].append(0.0) 

    elif myn==hidelevel_count-2:       

      templw,lwyii=getlevelw(lwyii,len(d[0]),warray_n,200) 

      for xii in xrange(0,warray_n): 

        ann_w[myn].append([]) 

        for xjj in xrange(0,len(d[0])):  

          ann_w[myn][xii].append(templw[xii,xjj])  

        for xjj in xrange(len(d[0]),warray_n): 

          ann_w[myn][xii].append(0.0) 

    else:  

      templw,lwyii=getlevelw(lwyii,warray_n,warray_n,200) 

      for xii in xrange(0,warray_n): 

        ann_w[myn].append([]) 

        for xjj in xrange(0,warray_n):  

          ann_w[myn][xii].append(templw[xii,xjj])         

  ann_w=np.array(ann_w) 

 

def generate_lw(trycount): 

  global ann_w 

  print u"产生权值初始矩阵",        

  meanmin=1  

  myann_w=ann_w     

  alltry=30 

  tryc=0 

  while tryc<alltry: 

    for i_i in range(trycount): 

      print ".", 

      init_annw() 

      if abs(np.mean(np.array(ann_w)))<meanmin: 

        meanmin=abs(np.mean(np.array(ann_w))) 

        myann_w=ann_w 

    tryc+=1 

    if abs(np.mean(np.array(myann_w)))<0.008:break 

     

  ann_w=myann_w 

  print 

  print u"权值矩阵平均:%f"%(np.mean(np.array(ann_w))) 

  print u"权值矩阵方差:%f"%(np.var(np.array(ann_w)))    

generate_lw(15) 

 

#前次训练的权值矩阵 

ann_oldw=copy.deepcopy(ann_w) 

#梯度初始化 

#输入层即第一层隐藏层不需要，所以第一层的空间无用 

ann_delta=[] 

for i in xrange(0,hidelevel_count): 

    ann_delta.append([])    

    for j in xrange(0,warray_n): 

        ann_delta[i].append(0.0) 

ann_delta=np.array(ann_delta) 

 

#输出矩阵yi初始化 

ann_yi=[] 

for i in xrange(0,alllevel_count): 

    #第一维是层数，从0开始 

    ann_yi.append([]) 

    for j in xrange(0,warray_n): 

        #第二维是神经元 

        ann_yi[i].append(0.0) 

ann_yi=np.array(ann_yi)    

 

 

    

#输出层函数     

def o_func(myy): 

    myresult=[] 

    mymean=np.mean(myy) 

    for i in xrange(0,len(myy)): 

        if myy[i]>=mymean: 

            myresult.append(1.0) 

        else: 

            myresult.append(0.0) 

    return np.array(myresult) 

     

def get_e(myd,myo): 

    return np.array(myd-myo) 

def ann_atanh(myv): 

    atanh_a=1.7159#>0 

    atanh_b=2/float(3)#>0 

    temp_rs=atanh_a*np.tanh(atanh_b*myv) 

    return temp_rs 

def ann_delta_atanh(myy,myd,nowlevel,level,n,mydelta,myw): 

  anndelta=[] 

  atanh_a=1.7159#>0 

  atanh_b=2/float(3)#>0  

  if nowlevel==level: 

    #输出层 

    anndelta=(float(atanh_b)/atanh_a)*(myd-myy)*(atanh_a-myy)*(atanh_a+myy) 

  else: 

    #隐藏层 

    anndelta=(float(atanh_b)/atanh_a)*(atanh_a-myy)*(atanh_a+myy)       

    temp_rs=[] 

    for j in xrange(0,n): 

        temp_rs.append(sum(myw[j]*mydelta))         

    anndelta=anndelta*temp_rs     

  return anndelta 

 

def sample_train(myx,myd,n,sigmoid_func,delta_sigfun): 

    '''''一个样本的前向和后向计算''' 

    global ann_yi 

    global ann_delta 

    global ann_w 

    global ann_wj0 

    global ann_y0 

    global hidelevel_count 

    global alllevel_count 

    global learn_r 

    global train_a 

    global ann_oldw 

    level=hidelevel_count 

    allevel=alllevel_count 

     

    #清空yi输出信号数组     

    hidelevel=hidelevel_count 

    alllevel=alllevel_count 

    for i in xrange(0,alllevel): 

        #第一维是层数，从0开始 

        for j in xrange(0,n): 

            #第二维是神经元 

            ann_yi[i][j]=0.0 

    ann_yi=np.array(ann_yi) 

    yi=ann_yi 

 

    #清空delta矩阵 

    for i in xrange(0,hidelevel-1):   

        for j in xrange(0,n): 

            ann_delta[i][j]=0.0 

    delta=ann_delta    

    #保留W的拷贝，以便下一次迭代 

    ann_oldw=copy.deepcopy(ann_w) 

    oldw=ann_oldw 

    #前向计算 

 

    #对输入变量进行预处理        

    myo=np.array([]) 

    for nowlevel in xrange(0,alllevel): 

        #一层层向前计算 

        #计算诱导局部域 

        my_y=[] 

        myy=yi[nowlevel-1]  

        myw=ann_w[nowlevel-1]         

        if nowlevel==0: 

            #第一层隐藏层 

            my_y=myx 

            yi[nowlevel]=my_y             

        elif nowlevel==(alllevel-1): 

            #输出层 

            my_y=o_func(yi[nowlevel-1,:len(myd)]) 

            yi[nowlevel,:len(myd)]=my_y 

        elif nowlevel==(hidelevel-1): 

            #最后一层输出层 

            for i in xrange(0,len(myd)): 

                temp_y=sigmoid_func(np.dot(myw[:,i],myy)) 

                my_y.append(temp_y)             

            yi[nowlevel,:len(myd)]=my_y  

        else: 

            #中间隐藏层 

            for i in xrange(0,len(myy)): 

                temp_y=sigmoid_func(np.dot(myw[:,i],myy)) 

                my_y.append(temp_y) 

            yi[nowlevel]=my_y 

 

    

    #计算误差与均方误差 

    myo=yi[hidelevel-1][:len(myd)] 

    myo_end=yi[alllevel-1][:len(myd)] 

    mymse=get_e(myd,myo_end) 

  

    #反向计算 

    #输入层不需要计算delta,输出层不需要计算W 

 

 

    #计算delta 

    for nowlevel in xrange(level-1,0,-1): 

        if nowlevel==level-1: 

            mydelta=delta[nowlevel] 

            my_n=len(myd) 

        else: 

            mydelta=delta[nowlevel+1] 

            my_n=n 

        myw=ann_w[nowlevel]         

        if nowlevel==level-1: 

            #输出层 

            mydelta=delta_sigfun(myo,myd,None,None,None,None,None) 

##            mydelta=mymse*myo 

        elif nowlevel==level-2: 

            #输出隐藏层的前一层，因为输出结果和前一层隐藏层的神经元数目可能存在不一致 

            #所以单独处理，传相当于输出隐藏层的神经元数目的数据 

            mydelta=delta_sigfun(yi[nowlevel],myd,nowlevel,level-1,my_n,mydelta[:len(myd)],myw[:,:len(myd)]) 

        else: 

            mydelta=delta_sigfun(yi[nowlevel],myd,nowlevel,level-1,my_n,mydelta,myw) 

             

        delta[nowlevel][:my_n]=mydelta 

    #计算与更新权值W  

    for nowlevel in xrange(level-1,0,-1): 

        #每个层的权值不一样 

        if nowlevel==level-1: 

            #输出层 

            my_n=len(myd) 

            mylearn_r=learn_r*0.8 

            mytrain_a=train_a*1.6 

        elif nowlevel==1: 

            #输入层 

            my_n=len(myd) 

            mylearn_r=learn_r*0.9 

            mytrain_a=train_a*0.8             

        else: 

            #其它层 

            my_n=n 

            mylearn_r=learn_r 

            mytrain_a=train_a 

 

        pre_level_myy=yi[nowlevel-1] 

        pretrain_myww=oldw[nowlevel-1] 

        pretrain_myw=pretrain_myww[:,:my_n] 

 

        #第二个调整参数 

        temp_i=[]         

         

        for i in xrange(0,n): 

            temp_i.append([]) 

            for jj in xrange(0,my_n): 

                temp_i[i].append(mylearn_r*delta[nowlevel,jj]*pre_level_myy[i]) 

        temp_rs2=np.array(temp_i) 

        temp_rs1=mytrain_a*pretrain_myw 

        #总调整参数 

        temp_change=temp_rs1+temp_rs2         

        my_ww=ann_w[nowlevel-1]         

        my_ww[:,:my_n]+=temp_change 

 

    return mymse 

 

def train_update(level,nowtraincount,sigmoid_func,delta_sigfun): 

    '''''一次读取所有样本，然后迭代一次进行训练''' 

    #打乱样本顺序 

    global learn_r 

    global train_a 

    global train_a0 

    global learn_r0 

    global r 

    global x 

    global d 

    global maxtrycount 

    global oldmse 

    x_n=len(x) 

    ids=range(0,x_n) 

    train_ids=[] 

    sample_x=[] 

    sample_d=[] 

 

    while len(ids)>0: 

        myxz=random.randint(0,len(ids)-1) 

        train_ids.append(ids[myxz]) 

        del ids[myxz] 

             

    for i in xrange(0,len(train_ids)): 

        sample_x.append(x[train_ids[i]]) 

        sample_d.append(d[train_ids[i]]) 

    sample_x=np.array(sample_x) 

    sample_d=np.array(sample_d) 

 

         

    #读入x的每个样本，进行训练     

    totalmse=0.0 

    mymse=float(10**-10)    

    for i in xrange(0,x_n): 

         

        mymse=sample_train(sample_x[i],sample_d[i],warray_n,sigmoid_func,delta_sigfun) 

        totalmse+=sum(mymse*mymse) 

    totalmse=np.sqrt(totalmse/float(x_n)) 

    print u"误差为：%f" %(totalmse) 

    nowtraincount[0]+=1 

    learn_r=learn_r0/(1+float(nowtraincount[0])/r) 

    train_a=train_a0/(1+float(nowtraincount[0])/r) 

    if nowtraincount[0]>=maxtrycount: 

        return False,True,totalmse          

    elif totalmse<expect_e: 

    #(totalmse-oldmse)/oldmse>0.1 and (totalmse-oldmse)/oldmse<1: 

        print u"训练成功，正在进行检验" 

        totalmse=0.0 

        for i in xrange(0,x_n): 

            mytemper=(sample_d[i]-simulate(sample_x[i],sigmoid_func,delta_sigfun))             

            totalmse+=sum(mytemper*mytemper) 

        totalmse=np.sqrt(totalmse/float(x_n)) 

        if totalmse<expect_e: 

            return False,False,totalmse 

    oldmse=totalmse 

    return True,False,totalmse 

                 

def train(): 

    '''''训练样本，多次迭代''' 

    global hidelevel_count 

    nowtraincount=[] 

    nowtraincount.append(0) 

    #sigmoid函数指定 

    delta_sigfun=ann_delta_atanh 

    sigmoid_func=ann_atanh 

     

    tryerr=0     

    while True: 

        print u"-------开始第%d次训练---------"%(nowtraincount[0]+1), 

        iscontinue,iscountout,mymse=train_update(hidelevel_count,nowtraincount,sigmoid_func,delta_sigfun) 

        if not iscontinue: 

            if iscountout : 

                print u"训练次数已到,误差为：%f"%mymse  

                tryerr+=1  

                if tryerr>3: 

                  break 

                else: 

                  print u"训练失败，重新尝试第%d次"%tryerr 

                  nowtraincount[0]=0 

                  generate_lw(15+tryerr*2)                                                       

            else: 

                print u"训练成功,误差为：%f"%mymse                

                break 

        

def simulate(myx,sigmoid_func,delta_sigfun): 

    '''''一个样本的仿真计算''' 

    print u"仿真计算中"     

    global ann_yi 

    global ann_w 

    global ann_wj0 

    global ann_y0 

    global hidelevel_count 

    global alllevel_count 

    global d 

    myd=d[0] 

 

    myx=np.array(myx) 

    n=len(myx) 

 

    level=hidelevel_count 

    allevel=alllevel_count 

     

    #清空yi输出信号数组     

    hidelevel=hidelevel_count 

    alllevel=alllevel_count 

    for i in xrange(0,alllevel): 

        #第一维是层数，从0开始 

        for j in xrange(0,n): 

            #第二维是神经元 

            ann_yi[i][j]=0.0 

    ann_yi=np.array(ann_yi) 

    yi=ann_yi 

 

    #前向计算 

    myo=np.array([]) 

    myy=np.array([]) 

    for nowlevel in xrange(0,alllevel): 

        #一层层向前计算 

        #计算诱导局部域 

        my_y=[] 

        myy=yi[nowlevel-1] 

        myw=ann_w[nowlevel-1]         

        if nowlevel==0: 

            #第一层隐藏层 

            my_y=myx 

            yi[nowlevel]=my_y             

        elif nowlevel==(alllevel-1): 

            #线性输出层，使用线性激活 

            my_y=o_func(yi[nowlevel-1,:len(myd)]) 

            yi[nowlevel,:len(myd)]=my_y             

        elif nowlevel==(hidelevel-1): 

            #最后一层隐藏输出层，使用线性激活 

            for i in xrange(0,len(myd)): 

                temp_y=sigmoid_func(np.dot(myw[:,i],myy)) 

                my_y.append(temp_y)               

            yi[nowlevel,:len(myd)]=my_y  

        else: 

            #中间隐藏层 

            #中间隐藏层需要加上偏置 

            for i in xrange(0,len(myy)): 

                temp_y=sigmoid_func(np.dot(myw[:,i],myy)) 

                my_y.append(temp_y) 

            yi[nowlevel]=my_y 

 

    return yi[alllevel-1,:len(myd)]     

train() 

 

delta_sigfun=ann_delta_atanh 

sigmoid_func=ann_atanh 

 

 

for xn in xrange(0,len(x)): 

    if simulate(x[xn],sigmoid_func,delta_sigfun)[0]>0: 

        plt.plot(train_x[xn][0],train_x[xn][1],"bo") 

    else: 

        plt.plot(train_x[xn][0],train_x[xn][1],"b*") 

 

 

              

temp_x=np.random.rand(20)*10 

temp_y=np.random.rand(20)*20+temp_x 

myx=temp_x 

myy=temp_y 

plt.subplot(111) 

x_max=np.max(myx)+5 

x_min=np.min(myx)-5 

y_max=np.max(myy)+5 

y_min=np.min(myy)-5 

plt.xlim(x_min,x_max) 

plt.ylim(y_min,y_max) 

for i in xrange(0,len(myx)): 

    test=get_siminx([[myx[i],myy[i]]]) 

    if simulate(test,sigmoid_func,delta_sigfun)[0]>0:       

        plt.plot(myx[i],myy[i],"ro") 

    else: 

        plt.plot(myx[i],myy[i],"r*")  

 

plt.show() 





图中蓝色是训练数据，红色是测试数据，圈圈代表类型[1,0]，星星代表类型[0,1]。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持中文源码网。