python机器学习之神经网络(二)

来自：http://blog.csdn.net/cui134/article/details/26823101

由于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]