BP实验报告.docx

1、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)各做一次调整，重复这个循环，

2、直到Ep（所有样本的误差之和）。用输出层的误差调整输出层权矩阵，并用此误差估计输出层的直接前导层的误差，再用输出层前导层误差估计更前一层的误差。如此获得所有其它各层的误差估计，并用这些估计实现对权矩阵的修改。形成将输出端表现出的误差沿着与输入信号相反的方向逐级向输入端传递的过程。基本过程是：样本：(输入向量，理想输出向量)1、权初始化：“小随机数”与饱和状态；“不同”的权值保证网络可以学。2、向前传播阶段：（1）从样本集中取一个样本(Xp，Yp)，将Xp输入网络；（2）计算相应的实际输出Op：Op=FL(F2(F1(XpW(1)W(2)W(L)3、向后传播阶段误差传播阶段：（1）计算实际输出O

3、p与相应的理想输出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、如果网络误差足够小，则

4、停止训练。否则重复第2、3步。本次实验采用的是三层感知器模型，如下图；其中有40个权值需要初始化，在这里，每个权值都各不相同。3 实验结果 其中，纵轴代表误差，横轴代表样本的次数。可以看到，随着训练次数的增加，误差逐渐靠近x轴，逐渐减小。4 实验源代码主程序：/package BackPropagation;import java.util.Vector;public class BackPropagation double leaning_rate = 0.7;/表示学习速率 double min_error = 0.0001;/足够小的误差 double weight;/用于存放生成的所有

5、权值 VectorVector vc1,vc2,vc3;/用于存放不同层的权值 double ep = new double400;/用于存放每个训练样本的误差 double ep2 = new double100;/用于存放每个学习样本的误差 Sample sa = new Sample();/学习样本的初始化 double input = new double4;/用于存放输入层每个神经元总的输入 double in_output = new double4;/用于存放输入层的输出结果 double hidden_in = new double3;/用于存放隐层每个神经元总的输入 doub

6、le hidden_output = new double3;/用于存放隐层的输出结果 double o_in = new double2;/用于存放输出层每个神经元总的输入 double o_put = new double2;/用于存放输出层输出结果 BackPropagation() init_weight(); practice(400); study(100); public boolean isInarr(double arr,int n,double a)/判断a是否在数组arr的前n个元素中 int temp = 0; for(int i=0;in;i+) if(arri =

7、a) temp = 1; break; if(temp = 1) return true;/如果在则返回true else return false; public void init_weight()/初始化各层神经元的权值 int i,j=0,k; weight = new double30; for(i=0;i30;i+) weighti = Math.random(); while(isInarr(weight,i,weighti)/使初始化的各个权值各不相同 weighti = Math.random(); vc1 = new VectorVector(4);/向量 vc2 = ne

8、w VectorVector(3); vc3 = new VectorVector(2); for(i=0;i4;i+)/存放第一层的权值 Vector vc11 = new Vector(3); for(k=0;k3;k+) vc11.add(weightj+);/末尾增加double vc1.add(vc11);/增加向量 for(i=0;i3;i+)/存放第二层的权值 Vector vc22 = new Vector(4); for(k=0;k4;k+) vc22.add(weightj+); vc2.add(vc22); for(i=0;i2;i+)/存放第三层的权值 Vector v

9、c33 = new Vector(3); for(k=0;k3;k+) vc33.add(weightj+); vc3.add(vc33); public void output(double aa)/根据输入向量aa产生最后的输出,三层的输出 double x1,x2,x3; int j=0; x1 = aa0; x2 = aa1; x3 = aa2; for(j=0;j4;j+)/计算input,in_output/三个输入乘以权值的相加 inputj = x1*(Vector)vc1.get(j).get(0).doubleValue()+ x2*(Vector)vc1.get(j).g

10、et(1).doubleValue()+ x3*(Vector)vc1.get(j).get(2).doubleValue(); in_outputj = 1/(1+Math.pow(Math.E, -inputj);/s形函数 for(j=0;j3;j+)/计算hidden_in,hidden_output hidden_inj = in_output0*(Vector)vc2.get(j).get(0).doubleValue()+ in_output1*(Vector)vc2.get(j).get(1).doubleValue()+ in_output2*(Vector)vc2.get(

11、j).get(2).doubleValue()+ in_output3*(Vector)vc2.get(j).get(3).doubleValue(); hidden_outputj = 1/(1+Math.pow(Math.E, -hidden_inj); for(j=0;j2;j+) o_inj = hidden_output0*(Vector)vc3.get(j).get(0).doubleValue()+ hidden_output1*(Vector)vc3.get(j).get(1).doubleValue()+ hidden_output2*(Vector)vc3.get(j).g

12、et(2).doubleValue(); o_putj = 1/(1+Math.pow(Math.E, -o_inj); public double calculate_ep(double output1,int n)/根据第n个样本的实际输出output1计算输出误差 double expect = (double) (Vector)sa.hashmap.get(n).get(1); double ep1; ep1 = (Math.pow(output10-expect0,2)+Math.pow(output11-expect1,2)/2;/7-13公式 return ep1; public

13、 double adjust_outputlevel_weight(int n)/根据第n个样本来调整输出层的权值 根据7-15 double output_error = new double2;/用于存放输出层每个神经元的输出误差 double temp = (double )(Vector)sa.hashmap.get(n).get(1);/得到期望输出 Vector vctemp = new Vector(); double increment = 0.0;/表示权值的增量 double weight_temp; output(double )(Vector)sa.hashmap.ge

14、t(n).get(0);/得到实际输出 for(int i=0;i2;i+)/对于第i个神经元 vctemp = (Vector)vc3.get(i); output_errori = o_puti*(1-o_puti)*(tempi-o_puti); for(int j=0;j3;j+) increment = leaning_rate*output_errori*hidden_outputj; weight_temp =(Double) vctemp.get(j).doubleValue()+increment; vctemp.add(j, weight_temp); return out

15、put_error; public double adjust_secondlevel_weight(int n)/根据第n个样本来调整隐层的权值 根据7-16 7-17 int i=0,j=0; double output_error = new double3;/用于存放隐层每个神经元的输出误差 double temp = adjust_outputlevel_weight(n);/得到输出层每个神经元的输出误差 for(i=0;i3;i+) output_errori = hidden_outputi*(1-hidden_outputi)* (Double)(Vector)vc3.get

16、(0).get(i).doubleValue()*temp0+ (Double)(Vector)vc3.get(1).get(i).doubleValue()*temp1); Vector vctemp; double increment; for(i=0;i3;i+) vctemp = (Vector)vc2.get(i); for(j=0;j4;j+) increment = leaning_rate*output_errori*in_outputj; vctemp.add(j,(Double)vctemp.get(j).doubleValue()+increment); return o

17、utput_error; public void adjust_firstlevle_weight(int n)/根据第n个样本来调整输入层的权值 7-16和7-17 int i=0,j=0; double output_error = new double4;/用于存放输入层每个神经元的输出误差 double temp = adjust_secondlevel_weight(n);/得到隐层每个神经元的输出误差 for(i=0;i4;i+) output_errori = in_outputi*(1-in_outputi)* (Double)(Vector)vc2.get(0).get(i)

18、.doubleValue()*temp0+ (Double)(Vector)vc2.get(1).get(i).doubleValue()*temp1+ (Double)(Vector)vc2.get(2).get(i).doubleValue()*temp2); Vector vctemp; double increment; double num; for(i=0;i4;i+) vctemp = (Vector)vc1.get(i); for(j=0;j3;j+) num = (double )(Vector)sa.hashmap.get(n).get(0); increment = le

19、aning_rate*output_errori*numj; vctemp.add(j,(Double)vctemp.get(j).doubleValue()+increment); /return output_error; public void practice(int n)/n表示样本数量 训练过程 int i = 0; int t = 0;/临时变量,用于select_small()的返回值,表示第t个样本 double sum = 1;/表示样本集误差总和 int s=0; double temp =0; while(summin_error) sum = 0; for(i=0;i

20、n;i+) output(Vector)sa.hashmap.get(i).get(0); temp = calculate_ep(o_put,i); sum += temp; if(s=0) epi = temp; adjust_firstlevle_weight(i); s+; /*for(i=0;i400;i+) System.out.println(epi); */ public void study(int n)/测试 for(int i=0;in;i+) output(Vector)sa.hashmap2.get(i).get(0); ep2i = calculate_ep(o_p

21、ut,i); System.out.println(ep2i); 样本和测试程序：/package BackPropagation;import java.util.HashMap;import java.util.Map;import java.util.Vector;public class Sample Vector z; double x,y; MapInteger,Vector hashmap; MapInteger,Vector hashmap2; Sample() x = new double3; y = new double2; z = new Vector(2); hashm

22、ap = new HashMapInteger,Vector(400);/400个训练样本 hashmap2 = new HashMapInteger,Vector(100);/100个测试样本 for(int i=0;i400;i+)/400个样本 for(int j=0;j3;j+) xj = Math.random()*100; for(int k=0;k2;k+) yk = Math.random()*100; z.add(x); z.add(y); hashmap.put(i,z); for(int i=0;i100;i+) for(int j=0;j3;j+) xj = Math.

23、random(); for(int k=0;k2;k+) yk = Math.random(); z.add(x); z.add(y); hashmap2.put(i,z); 作图程序：/package BackPropagation;import java.awt.Color;import java.awt.Frame;import java.awt.Graphics;public class Curve extends Frame BackPropagation bp = new BackPropagation(); double temp = bp.ep; public void pai

24、nt(Graphics g) this.setBackground(Color.GRAY); g.setColor(Color.BLACK); for(int i=0;i100;i+) g.drawLine(i*10,(int)(tempi*10000),(i+1)*10,(int)(tempi+1*10000); /System.out.println(int)(tempi*10000); /g.drawLine(0,325,600,125); public static void main(String args) Curve curve = new Curve(); curve.setSize(600,600); curve.setLocation(100,100); curve.setVisible(true);