误差反向传播算法——BP算法

[color=green]BP网结构图[/color][img]http://dl.iteye.com/upload/attachment/436174/026c08bb-d89c-33a4-a12f-274cc3f6a662.png[/img]

[color=green]学习规则[/color]
[list=1]
[*]开始
[*]连接权值及阈值的初始化
给各连接权{ wkj}、{ vji }及阈值{γj}、{θk }赋予（-1，+1）间的随机值。
[*]学习模式对提供给网络
随机选取一组模式对Zk = (z1k z2k…….zIk)，Dk = (d1k d2k …….dKk) 提供给网络。
[*]计算中间层各单元的输入、输出
[img]http://dl.iteye.com/upload/attachment/436183/601117ea-4174-3154-86be-9f96c7e6518f.png[/img]
[*]计算输出层各单元的输入、输出
[img]http://dl.iteye.com/upload/attachment/436185/4d3de1cf-dceb-3a6f-a8db-6220cd8e59fd.png[/img]
[*]计算输出层各单元的一般化误差
δok =（dk-ok）ok（1-ok）
[*]计算中间层各单元的一般化误差
[img]http://dl.iteye.com/upload/attachment/436187/99ec76b9-3521-3c4a-8d16-b6a1afdf8817.png[/img]
[*]调整中间层至输出层之间的连接权值，
及输出层各单元的阈值
wkj ( n + 1) = wkj (n) + ηδokyj
θk (n+1 ) =θk (n) -ηδok
[*]调整输入层至中间层之间的连接权值，及中间层各单元的阈值
vji (n + 1) = vji (n ) +ηδyjzi
γj (n + 1) =γj (n ) –ηδyj
[*]随机选取下一个学习模式对提供给网络，返回到第3）步，直到全部M个模式训练完
[*]更新学习次数，返回到第3）步，直到规定的学习次数N完成
[*]结束
[/list]

public class BP {

	/**
	 * @param args
	 */

	static double[] objectPattern={0.757874015748031,1};
	static double[] finalOutput=new double[2];
	double [][] initInput={{1.08333333333333,1.58333333333333,2.08333333333333},{1.33333333333333,1.83333333333333,2.33333333333333}};
	int inputNum=3,middleNum=10,outputNum=1;
	double [][] v=new double [middleNum][inputNum];
	double [] w =new double [middleNum];
	double [] r=new double[middleNum];//中间层阈值
	double [] y=new double[middleNum];//中间层输出值
	static double q=0;//输出层输出值
	double e=Math.random()*2-1;//输出层阈值
	double a=0.1;//权调节系数
	double b=0.1;//阈调节系数
	static int count=1;
	boolean [] allLearned=new boolean[2];

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BP bp=new BP();
		bp.init();

		while(count<100000){
			bp.calculate();
		}
		for(int i=0;i<objectPattern.length;i++){
			System.out.print("初始，模式"+i+"="+objectPattern[i]+"     ");
		}
		System.out.println();
		for(int i=0;i<finalOutput.length;i++){
			System.out.print("学习结果，模式"+i+"="+finalOutput[i]+"     ");
		}
	}

	private void init() {
		// TODO Auto-generated method stub
		for(int i=0;i<inputNum;i++)
			for(int j=0;j<middleNum;j++){
				v[j][i]=Math.random()*2-1;
				w[j]=Math.random()*2-1;
				r[j]=Math.random()*2-1;
			}
	}

	private void calculate(){
		while(!allLearned[0] || !allLearned[1]){
			this.learn((int) (Math.random()*2));
		}
		count++;
		allLearned[0]=false;
		allLearned[1]=false;
	}

	private void learn(int start){
		if(start==0){
			allLearned[0]=true;
		}
		if(start==1){
			allLearned[1]=true;
		}
		double[] inputOfThisTime=initInput[start];
		double objectOfThisTime=objectPattern[start];
		double errorOfOutput=0;//输出层各单元误差
		double [] errorOfMiddle=new double[middleNum];//中间层各单元误差
		double temp=0;
		for(int j=0;j<v.length;j++){
			for(int i=0;i<v[0].length;i++ ){
				temp+=v[j][i]*inputOfThisTime[i];
			}
		y[j]=1/(1+Math.exp((-1)*(temp-r[j])));
		}
		temp=0;
		for(int i =0;i<w.length;i++){
			temp+=w[i]*y[i];
		}
		finalOutput[start]=1/(1+Math.exp((-1)*(temp-e)));
		errorOfOutput=(objectOfThisTime-finalOutput[start])*finalOutput[start]*(1-finalOutput[start]);
		for(int i=0;i<middleNum;i++){
			errorOfMiddle[i]=(errorOfOutput*w[i])*y[i]*(1-y[i]);
		}
		e=e-b*errorOfOutput;
		for(int i=0;i<w.length;i++){
			w[i]=w[i]+a*errorOfOutput*y[i];
			r[i]=r[i]-b*errorOfMiddle[i];
		}
		for(int j=0;j<v.length;j++)
			for(int i=0;i<v[0].length;i++ ){
				v[j][i]=v[j][i]+a*errorOfMiddle[j]*inputOfThisTime[i];
			}

	}

}