BP实验报告文档格式.docx

BP实验报告文档格式.docx

《BP实验报告文档格式.docx》由会员分享，可在线阅读，更多相关《BP实验报告文档格式.docx（13页珍藏版）》请在冰豆网上搜索。

3、向后传播阶段——误差传播阶段：

（1）计算实际输出Op与相应的理想输出Yp的差。

（2）按极小化误差的方式调整权矩阵。

（3）累计网络关于整个样本集的误差。

4、如果网络误差足够小，则停止训练。

否则重复第2、3步。

算法伪码：

本次实验采用的是三层感知器模型，如下图；

其中有40个权值需要初始化，在这里，每个权值都各不相同。

3实验结果

其中，纵轴代表误差，横轴代表样本的次数。

可以看到，随着训练次数的增加，误差逐渐靠近x轴，逐渐减小。

4实验源代码

主程序：

//packageBackPropagation;

importjava.util.Vector;

publicclassBackPropagation{

doubleleaning_rate=0.7;

//表示学习速率

doublemin_error=0.0001;

//足够小的误差

doubleweight[];

//用于存放生成的所有权值

Vector<

Vector<

Double>

>

vc1,vc2,vc3;

//用于存放不同层的权值

doubleep[]=newdouble[400];

//用于存放每个训练样本的误差

doubleep2[]=newdouble[100];

//用于存放每个学习样本的误差

Samplesa=newSample（）;

//学习样本的初始化

doubleinput[]=newdouble[4];

//用于存放输入层每个神经元总的输入

doublein_output[]=newdouble[4];

//用于存放输入层的输出结果

doublehidden_in[]=newdouble[3];

//用于存放隐层每个神经元总的输入

doublehidden_output[]=newdouble[3];

//用于存放隐层的输出结果

doubleo_in[]=newdouble[2];

//用于存放输出层每个神经元总的输入

doubleo_put[]=newdouble[2];

//用于存放输出层输出结果

BackPropagation（）{

init_weight（）;

practice（400）;

study（100）;

}

publicbooleanisInarr（doublearr[],intn,doublea）{//判断a是否在数组arr的前n个元素中

inttemp=0;

for（inti=0;

i<

n;

i++）{

if（arr[i]==a）{

temp=1;

break;

}

}

if（temp==1）returntrue;

//如果在则返回true

elsereturnfalse;

publicvoidinit_weight（）{//初始化各层神经元的权值

inti,j=0,k;

weight=newdouble[30];

for（i=0;

30;

weight[i]=Math.random（）;

while（isInarr（weight,i,weight[i]））{//使初始化的各个权值各不相同

weight[i]=Math.random（）;

vc1=newVector<

（4）;

//向量

vc2=newVector<

（3）;

vc3=newVector<

（2）;

4;

i++）{//存放第一层的权值

Vector<

vc11=newVector<

for（k=0;

k<

3;

k++）{

vc11.add（weight[j++]）;

//末尾增加double

vc1.add（vc11）;

//增加向量

i++）{//存放第二层的权值

vc22=newVector<

vc22.add（weight[j++]）;

vc2.add（vc22）;

2;

i++）{//存放第三层的权值

vc33=newVector<

vc33.add（weight[j++]）;

vc3.add（vc33）;

publicvoidoutput（doubleaa[]）{//根据输入向量aa产生最后的输出,三层的输出

doublex1,x2,x3;

intj=0;

x1=aa[0];

x2=aa[1];

x3=aa[2];

for（j=0;

j<

j++）{//计算input[],in_output[]//三个输入乘以权值的相加

input[j]=x1*（（（Vector<

）vc1.get（j））.get（0））.doubleValue（）+

x2*（（（Vector<

）vc1.get（j））.get

（1））.doubleValue（）+

x3*（（（Vector<

）vc1.get（j））.get

（2））.doubleValue（）;

in_output[j]=1/（1+Math.pow（Math.E,-input[j]））;

//s形函数

j++）{//计算hidden_in[],hidden_output[]

hidden_in[j]=in_output[0]*（（（Vector<

）vc2.get（j））.get（0））.doubleValue（）+

in_output[1]*（（（Vector<

）vc2.get（j））.get

（1））.doubleValue（）+

in_output[2]*（（（Vector<

）vc2.get（j））.get

（2））.doubleValue（）+

in_output[3]*（（（Vector<

）vc2.get（j））.get（3））.doubleValue（）;

hidden_output[j]=1/（1+Math.pow（Math.E,-hidden_in[j]））;

j++）{

o_in[j]=hidden_output[0]*（（（Vector<

）vc3.get（j））.get（0））.doubleValue（）+

hidden_output[1]*（（（Vector<

）vc3.get（j））.get

（1））.doubleValue（）+

hidden_output[2]*（（（Vector<

）vc3.get（j））.get

（2））.doubleValue（）;

o_put[j]=1/（1+Math.pow（Math.E,-o_in[j]））;

publicdoublecalculate_ep（doubleoutput1[],intn）{//根据第n个样本的实际输出output1[]计算输出误差

doubleexpect[]=（double[]）（（（Vector<

double[]>

）sa.hashmap.get（n））.get

（1））;

doubleep1;

ep1=（Math.pow（output1[0]-expect[0],2）+Math.pow（output1[1]-expect[1],2））/2;

//7-13公式

returnep1;

publicdouble[]adjust_outputlevel_weight（intn）{//根据第n个样本来调整输出层的权值根据7-15

doubleoutput_error[]=newdouble[2];

//用于存放输出层每个神经元的输出误差

doubletemp[]=（double[]）（（Vector<

）sa.hashmap.get（n））.get

（1）;

//得到期望输出

Vector<

vctemp=newVector<

（）;

doubleincrement=0.0;

//表示权值的增量

doubleweight_temp;

output（（double[]）（（Vector<

）sa.hashmap.get（n））.get（0））;

//得到实际输出

i++）{//对于第i个神经元

vctemp=（Vector<

）vc3.get（i）;

output_error[i]=o_put[i]*（1-o_put[i]）*（temp[i]-o_put[i]）;

for（intj=0;

increment=leaning_rate*output_error[i]*hidden_output[j];

weight_temp=（（Double）vctemp.get（j））.doubleValue（）+increment;

vctemp.add（j,weight_temp）;

returnoutput_error;

publicdouble[]adjust_secondlevel_weight（intn）{//根据第n个样本来调整隐层的权值根据7-167-17

inti=0,j=0;

doubleoutput_error[]=newdouble[3];

//用于存放隐层每个神经元的输出误差

doubletemp[]=adjust_outputlevel_weight（n）;

//得到输出层每个神经元的输出误差

output_error[i]=hidden_output[i]*（1-hidden_output[i]）*

（（（Double）（（Vector<

）vc3.get（0））.get（i））.doubleValue（）*temp[0]+

（（Double）（（Vector<

）vc3.get

（1））.get（i））.doubleValue（）*temp[1]）;

vctemp;

doubleincrement;

）vc2.get（i）;

for（j=0;

increment=leaning_rate*output_error[i]*in_output[j];

vctemp.add（j,（（Double）vctemp.get（j））.doubleValue（）+increment）;

publicvoidadjust_firstlevle_weight（intn）{//根据第n个样本来调整输入层的权值7-16和7-17

doubleoutput_error[]=newdouble[4];

//用于存放输入层每个神经元的输出误差

doubletemp[]=adjust_secondlevel_weight（n）;

//得到隐层每个神经元的输出误差

output_error[i]=in_output[i]*（1-in_output[i]）*

）vc2.get（0））.get（i））.doubleValue（）*temp[0]+

（（Double）（（Vector<

）vc2.get

（1））.get（i））.doubleValue（）*temp[1]+

）vc2.get

（2））.get（i））.doubleValue（）*temp[2]）;

doublenum[];

）vc1.get（i）;

num=（double[]）（（Vector<

）sa.hashmap.get（n））.get（0）;

increment=leaning_rate*output_error[i]*num[j];

//returnoutput_error;

publicvoidpractice（intn）{//n表示样本数量训练过程

inti=0;

intt=0;

//临时变量,用于select_small（）的返回值,表示第t个样本

doublesum=1;

//表示样本集误差总和

ints=0;

doubletemp=0;

while（sum>

min_error）{

sum=0;

for（i=0;

output（（（Vector<

）sa.hashmap.get（i））.get（0））;

temp=calculate_ep（o_put,i）;

sum+=temp;

if（s==0）{

ep[i]=temp;

}

adjust_firstlevle_weight（i）;

s++;

/*for（i=0;

400;

System.out.println（ep[i]）;

}*/

publicvoidstudy（intn）{//测试

output（（（Vector<

）sa.hashmap2.get（i））.get（0））;

ep2[i]=calculate_ep（o_put,i）;

System.out.println（ep2[i]）;

}

样本和测试程序：

importjava.util.HashMap;

importjava.util.Map;

publicclassSample{

double[]>

z;

doublex[],y[];

Map<

Integer,Vector<

hashmap;

hashmap2;

Sample（）{

x=newdouble[3];

y=newdouble[2];

z=newVector<

hashmap=newHashMap<

（400）;

//400个训练样本

hashmap2=newHashMap<

（100）;

//100个测试样本

i++）{//400个样本

x[j]=Math.random（）*100;

for（intk=0;

y[k]=Math.random（）*100;

z.add（x）;

z.add（y）;

hashmap.put（i,z）;

100;

x[j]=Math.random（）;

y[k]=Math.random（）;

hashmap2.put（i,z）;

作图程序：

importjava.awt.Color;

importjava.awt.Frame;

importjava.awt.Graphics;

publicclassCurveextendsFrame{

BackPropagationbp=newBackPropagation（）;

doubletemp[]=bp.ep;

publicvoidpaint（Graphicsg）{

this.setBackground（Color.GRAY）;

g.setColor（Color.BLACK）;

g.drawLine（i*10,（int）（temp[i]*10000）,（i+1）*10,（int）（temp[i+1]*10000））;

//System.out.println（（int）（temp[i]*10000））;

//g.drawLine（0,325,600,125）;

publicstaticvoidmain（String[]args）{

Curvecurve=newCurve（）;

curve.setSize（600,600）;

curve.setLocation（100,100）;

curve.setVisible（true）;