数学之路(3)-机器学习(3)-机器学习算法-神经网络[10]

多层感知器利用非线性神经元做为中间隐藏层神经元，输出端可以直接使用非线性神经元，也可以使用线性神经元

在对单个样本计算的过程中分为前向计算和反向计算

前向计算根据权值矩阵由前向后一层层神经元推进，每次推进根据权值计算每层的输出值

反向计算根据输出结果与目标输出的误差来由后向前调整神经网络的权值，同时，加上运量常数，动量参数可以调整学习速度，，此外，可体现时间延迟

非线性 函数本身使用双曲正切函数，当然也要可以使用logistic函数，2个函数都是非线性的

本博客所有内容是原创，未经书面许可，严禁任何形式的转载

http://blog.csdn.net/u010255642

部分python代码如下：

def train():
        '''训练样本，多次迭代'''
        global hidelevel_count
        nowtraincount=[]
        nowtraincount.append(0)
        #sigmoid函数指定
        delta_sigfun=ann_delta_atanh
        sigmoid_func=ann_atanh
        
        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                                  
                        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:
                        #第一层隐藏层直接采用样本X加上偏置做为输出
                        my_y=myx+ann_y0*ann_wj0[nowlevel]
                        yi[nowlevel]=my_y                        
                elif nowlevel==(alllevel-1):
                        #线性输出层，使用线性激活
                        my_y=o_func(yi[nowlevel-1])
                        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)+ann_y0*ann_wj0[nowlevel,i])
                                my_y.append(temp_y)
                        yi[nowlevel]=my_y
        print "============="
        print u"***权值矩阵***"  
        print ann_w
        print u"***输出矩阵***" 
        print yi
        print "============="
        return yi[alllevel-1,:len(myd)]


        
        
train()

delta_sigfun=ann_delta_atanh
sigmoid_func=ann_atanh

i=0
for xn in x:
        print "%d===%d => "%(xn[0],xn[1])
        print simulate(xn,sigmoid_func,delta_sigfun)
        print "=====正确目标值====="
        print d[i]
        i+=1