python机器学习之神经网络(二)
来自：http://blog.csdn.NET/cui134/article/details/
由于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 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]
THE END
