BP实验报告.docx

BP实验报告.docx

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

BP实验报告

BP实验报告

学生姓名程战战

专业/班级计算机91

学号09055006

所在学院电信学院

指导教师鲍军鹏

提交日期2012/6/15

1实验目的

用java语言实现BP网络，解决一个简单的曲线拟合（预测）问题。

要求训练数据不少于400个点，测试数据不少于100个点。

在神经网络训练过程中要记录下误差，最后画出整个学习过程中的网络误差变化曲线。

2实验原理

基本思想是：

样本集：

S={（X1,Y1）,（X2,Y2）,…,（Xs,Ys）}

逐一地根据样本集中的样本（Xk,Yk）计算出实际输出Ok及其误差E1，然后对各层神经元的权值W

（1），W

（2），…，W（L）各做一次调整，重复这个循环，直到∑Ep<ε（所有样本的误差之和）。

用输出层的误差调整输出层权矩阵，并用此误差估计输出层的直接前导层的误差，再用输出层前导层误差估计更前一层的误差。

如此获得所有其它各层的误差估计，并用这些估计实现对权矩阵的修改。

形成将输出端表现出的误差沿着与输入信号相反的方向逐级向输入端传递的过程。

基本过程是：

样本：

（输入向量，理想输出向量）

1、权初始化：

“小随机数”与饱和状态；“不同”的权值保证网络可以学。

2、向前传播阶段：

（1）从样本集中取一个样本（Xp，Yp），将Xp输入网络；

（2）计算相应的实际输出Op：

Op=FL（…（F2（F1（XpW

（1））W

（2））…）W（L））

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

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

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

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

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

否则重复第2、3步。

算法伪码：

样本：

（输入向量，理想输出向量）

1、权初始化：

“小随机数”与饱和状态；“不同”的权值保证网络可以学。

2、向前传播阶段：

（1）从样本集中取一个样本（Xp，Yp），将Xp输入网络；

（2）计算相应的实际输出Op：

Op=FL（…（F2（F1（XpW

（1））W

（2））…）W（L））

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>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

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;i<30;i++）{

weight[i]=Math.random（）;

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

weight[i]=Math.random（）;

}

}

vc1=newVector>（4）;//向量

vc2=newVector>（3）;

vc3=newVector>

（2）;

for（i=0;i<4;i++）{//存放第一层的权值

Vectorvc11=newVector（3）;

for（k=0;k<3;k++）{

vc11.add（weight[j++]）;//末尾增加double

}

vc1.add（vc11）;//增加向量

}

for（i=0;i<3;i++）{//存放第二层的权值

Vectorvc22=newVector（4）;

for（k=0;k<4;k++）{

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

}

vc2.add（vc22）;

}

for（i=0;i<2;i++）{//存放第三层的权值

Vectorvc33=newVector（3）;

for（k=0;k<3;k++）{

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<4;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形函数

}

for（j=0;j<3;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]））;

}

for（j=0;j<2;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）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）;//得到期望输出

Vectorvctemp=newVector（）;

doubleincrement=0.0;//表示权值的增量

doubleweight_temp;

output（（double[]）（（Vector）sa.hashmap.get（n））.get（0））;//得到实际输出

for（inti=0;i<2;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;j<3;j++）{

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）;//得到输出层每个神经元的输出误差

for（i=0;i<3;i++）{

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]）;

}

Vectorvctemp;

doubleincrement;

for（i=0;i<3;i++）{

vctemp=（Vector）vc2.get（i）;

for（j=0;j<4;j++）{

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

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

}

}

returnoutput_error;

}

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

inti=0,j=0;

doubleoutput_error[]=newdouble[4];//用于存放输入层每个神经元的输出误差

doubletemp[]=adjust_secondlevel_weight（n）;//得到隐层每个神经元的输出误差

for（i=0;i<4;i++）{

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

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

（（Double）（（Vector）vc2.get

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

（（Double）（（Vector）vc2.get

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

}

Vectorvctemp;

doubleincrement;

doublenum[];

for（i=0;i<4;i++）{

vctemp=（Vector）vc1.get（i）;

for（j=0;j<3;j++）{

num=（double[]）（（Vector）sa.hashmap.get（n））.get（0）;

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

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

}

}

//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;i

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;i<400;i++）{

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

}*/

}

publicvoidstudy（intn）{//测试

for（inti=0;i

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

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

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

}

}

}

样本和测试程序：

//packageBackPropagation;

importjava.util.HashMap;

importjava.util.Map;

importjava.util.Vector;

publicclassSample{

Vectorz;

doublex[],y[];

Map>hashmap;

Map>hashmap2;

Sample（）{

x=newdouble[3];

y=newdouble[2];

z=newVector

（2）;

hashmap=newHashMap>（400）;//400个训练样本

hashmap2=newHashMap>（100）;//100个测试样本

for（inti=0;i<400;i++）{//400个样本

for（intj=0;j<3;j++）{

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

}

for（intk=0;k<2;k++）{

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

}

z.add（x）;

z.add（y）;

hashmap.put（i,z）;

}

for（inti=0;i<100;i++）{

for（intj=0;j<3;j++）{

x[j]=Math.random（）;

}

for（intk=0;k<2;k++）{

y[k]=Math.random（）;

}

z.add（x）;

z.add（y）;

hashmap2.put（i,z）;

}

}

}

作图程序：

//packageBackPropagation;

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）;

for（inti=0;i<100;i++）{

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）;

}

}