bpnstraining.java

java编写的bp神经网络训练程序

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.text.DecimalFormat;
import java.util.Random;



public class BPNsTraining {

	
	double randseed = 0 ;
	int N = 7 ; //学习样本个数
	int IN = 7 ; //输入层神经元数目
	int HN = 23 ; //隐层神经元数目
	int HC = 3 ; //隐层层数
	int ON = 1 ; //输出层神经元数目
	int Z = 200000 ; //旧权值保存-》每次study的权值都保存下来
	double [] P = new double [IN]; //单个样本输入数据
	double Teach = 0; //单个样本教师数据
	double [][] U11 = new double [HN][IN]; //输入层至第一隐层权值
	double [][] U12 = new double [HN][HN]; //第一隐层至第二隐层权值
	double [][] U23 = new double [HN][HN]; //第二隐层至第三隐层权值
	double [] V = new double [HN]; //第三隐层至输出层权值
	double [] X1 = new double [HN]; //第一隐层的输入
	double [] X2 = new double [HN]; //第二隐层的输入
	double [] X3 = new double [HN]; //第三隐层的输入
	double Y = 0; //输出层的输入
	double [] H1 = new double [HN]; //第一隐层的输出
	double [] H2 = new double [HN]; //第二隐层的输出
	double [] H3 = new double [HN]; //第三隐层的输出
	double O = 0 ; //输出层的输出
	double [] YU_HN1 = new double [HN]; //第一隐层的阈值
	double [] YU_HN2 = new double [HN]; //第二隐层的阈值
	double [] YU_HN3 = new double [HN]; //第三隐层的阈值
	double YU_ON = 0 ; //输出层的阈值
	double [] err_m = new double [N]; //第m个样本的总误差
	double a; //学习效率
	double alpha;  //动量因子

    //	定义一个放学习样本
	//double [] input = new double [IN]; //输入在上面定义是五个	
	//double [] teach = new double [ON]; //输出在上面定义是三个


    //	bp算法用来保存每次计算的权值
	double [][] old_U11 = new double [HN][IN];  //保存输入层至隐层权值旧权
	double [][] old_U12 = new double [HN][HN]; //保存第一隐层至第二隐层权值
	double [][] old_U23 = new double [HN][HN]; //保存第二隐层至第三隐层权值
	double [] old_V   = new double [HN];  //保存第三隐层至输出层旧权
	 

	public int saveWV()
    {
		for(int i=0;i<HN;i++)
		{
			for(int j=0;j<IN;j++)
			{
				old_U11[i][j] = U11[i][j];
			}
		}

		for(int i1=0;i1<HN;i1++)
		{
			for(int j1=0;j1<HN;j1++)
			{
				old_U12[i1][j1] = U12[i1][j1];
			}
		}

		for(int i2=0;i2<HN;i2++)
		{
			for(int j2=0;j2<HN;j2++)
			{
				 old_U23[i2][j2] = U23[i2][j2];
			}
		}
		for(int j3=0;j3<HN;j3++)
		{
			old_V[j3] = V[j3];
		}
		
		return 1;
	}
///////////////////////////
//	初始化权、阈值子程序  /////
///////////////////////////
	
	public int initial()
	{
        //	隐层权、阈值初始化//
		//randseed = Math.random();
		//Random rand = new Random();

		for(int i=0;i<HN;i++)
		{
			for(int j=0;j<IN;j++)
				U11[i][j]= Math.random()*2-1; //初始化输入层到第一隐层的权值，随机模拟0 和 1 -1	
		}
		for(int i1=0;i1<HN;i1++)
		{
			for(int j1=0;j1<HN;j1++)
				U12[i1][j1]= Math.random()*2-1 ; //初始化第一隐层到第二隐层权值，随机模拟0 和 1 -1	
		}
		for(int i2=0;i2<HN;i2++)
		{
			for(int j2=0;j2<HN;j2++)
				U23[i2][j2]= Math.random()*2-1 ; //初始化第二隐层到第三隐层权值，随机模拟0 和 1 -1	
		}
		for(int j3=0;j3<HN;j3++)
		{
				V[j3]= Math.random()*2-1 ; //初始化隐层到输出层的权值，随机模拟0 和 1 -1
		}
		for(int k=0;k<HN;k++)
		{
			YU_HN1[k] = Math.random()*2-1 ;  //第一隐层阈值初始化 ,-0.01 ~ 0.01 之间
		}
		for(int k1=0;k1<HN;k1++)
		{
			YU_HN2[k1] = Math.random()*2-1 ;  //第二隐层阈值初始化 ,-0.01 ~ 0.01 之间
		}
	    for(int k2=0;k2<HN;k2++)
		{
			YU_HN3[k2] = Math.random()*2-1 ;  //第三隐层阈值初始化 ,-0.01 ~ 0.01 之间
		}
		YU_ON = Math.random()*2-1 ; //输出层阈值初始化 ,-0.01 ~ 0.01 之间
		
	  return 1;
	}//子程序initial()结束

	public int initial2()
	{
        //	隐层权、阈值初始化//
		//randseed = Math.random();
		Random rand = new Random();

		for(int i=0;i<HN;i++)
		{
			for(int j=0;j<IN;j++)
				U11[i][j]= rand.nextInt(2)-1 ; //初始化输入层到第一隐层的权值，随机模拟0 和 1 -1	
		}
		for(int i1=0;i1<HN;i1++)
		{
			for(int j1=0;j1<HN;j1++)
				U12[i1][j1]= rand.nextInt(2)-1 ; //初始化第一隐层到第二隐层权值，随机模拟0 和 1 -1	
		}
		for(int i2=0;i2<HN;i2++)
		{
			for(int j2=0;j2<HN;j2++)
				U23[i2][j2]= rand.nextInt(2)-1 ; //初始化第二隐层到第三隐层权值，随机模拟0 和 1 -1	
		}
		for(int j3=0;j3<HN;j3++)
		{
				V[j3]= rand.nextInt(2)-1 ; //初始化隐层到输出层的权值，随机模拟0 和 1 -1
		}
		for(int k=0;k<HN;k++)
		{
			YU_HN1[k] = (rand.nextDouble()*2-1)/10 ;  //第一隐层阈值初始化 ,-0.01 ~ 0.01 之间
		}
		for(int k1=0;k1<HN;k1++)
		{
			YU_HN2[k1] = (rand.nextDouble()*2-1)/10 ;  //第二隐层阈值初始化 ,-0.01 ~ 0.01 之间
		}
	    for(int k2=0;k2<HN;k2++)
		{
			YU_HN3[k2] = (rand.nextDouble()*2-1)/10 ;  //第三隐层阈值初始化 ,-0.01 ~ 0.01 之间
		}
		YU_ON = (rand.nextDouble()*2-1)/10 ; //输出层阈值初始化 ,-0.01 ~ 0.01 之间
		
	  return 1;
	}//子程序initial()结束
////////////////////////////////
////	第m个学习样本输入子程序  ///
///////////////////////////////
	public int input_P(double [] input)
	{
	    for (int i = 0 ; i < IN ; i++) P[i]= input[i];//获得第m个样本的数据
	    return 1;
	}//子程序input_P(m）结束

/////////////////////////////
////	第m个样本教师信号子程序//
/////////////////////////////
	public int input_T(double inputdata)
	{
	    Teach = inputdata;
	    return 1;
	}//子程序input_T(m)结束


/////////////////////////////////
//	隐层各单元输入、输出值子程序    ///
/////////////////////////////////
	public int H_I_O()
	{
	    double sigma1,sigma2,sigma3;
	    int i,i1,i2,j,j1,j2;
	    for (j=0;j<HN;j++)
		{
	        sigma1=0.0;
		    for (i=0;i<IN;i++) sigma1 += U11[j][i]*P[i];//求第一隐层内积
			
	        X1[j]=sigma1 - YU_HN1[j];//求第一隐层净输入
	        H1[j]=1.0/(1.0+Math.exp(-X1[j]));//求第一隐层输出sigmoid算法
		}
	    for (j1=0;j1<HN;j1++)
		{
	        sigma2=0.0;
	    	for (i1=0;i1<HN;i1++) sigma2 += U12[j1][i1]*H1[i1];//求第二隐层内积
			
	        X2[j1]=sigma2 - YU_HN2[j1];//求第二隐层净输入
	        H2[j1]=1.0/(1.0+Math.exp(-X2[j1]));//求第二隐层输出sigmoid算法
		}
	    for (j2=0;j2<HN;j2++)
		{
	        sigma3=0.0;
	     	for (i2=0;i2<HN;i2++) sigma3 += U23[j2][i2]*H2[i2];//求第三隐层内积
			
	        X3[j2]=sigma3 - YU_HN3[j2];//求第三隐层净输入
	        H3[j2]=1.0/(1.0+Math.exp(-X3[j2]));//求第三隐层输出sigmoid算法
		}
	    return 1;
	}//子程序H_I_O()结束


///////////////////////////////////
//	输出层各单元输入、输出值子程序    ///
///////////////////////////////////
	public int O_I_O()
	{
	    double sigma;
	    for (int k=0;k<ON;k++)
		{
	        sigma=0.0;
	         for (int j=0;j<HN;j++)
			 {
	              sigma+=V[j]*H3[k];//求输出层内积
			 }
	        Y =sigma - YU_ON; //求输出层净输入
	        O =1.0/(1.0+Math.exp(-Y));//求输出层输出
		}
	    return 1;
	}//子程序O_I_O()结束


////////////////////////////////////
//	输出层至隐层的一般化误差子程序    ////
////////////////////////////////////
	double d_err = 0 ;
	public int Err_O_H(int m)
	{
	    double abs_err = 0 ;    //每个样本的绝对误差都是从0开始的
	    double sqr_err = 0;     //每个样本的平方误差计算都是从0开始的
	    
	    abs_err = Teach - O ;             //求第m个样本下神经元的绝对误差
	    sqr_err += (abs_err)*(abs_err );  //求第m个样本下输出层的平方误差
	    d_err = abs_err * O * (1.0-O) ;       //d_err[k]输出层各神经元的一般化误差
	        
	    err_m[m] = sqr_err/2;//第m个样本下输出层的平方误差/2=第m个样本的均方误差
	    return 1;
	}//子程序Err_O_H(m)结束


//////////////////////////////////	//
//	隐层至输入层的一般化误差子程序////
//////////////////////////////////	//
	double [] e_err3 = new double [HN];//定义第三隐层各神经元的一般化误差
	double [] e_err2 = new double [HN];//定义第二隐层各神经元的一般化误差
	double [] e_err1 = new double [HN];//定义第一隐层各神经元的一般化误差
	public int Err_H_I()
	{
	    double sigma3,sigma2,sigma1;
	    for (int j3=0;j3<HN;j3++) 
		{
	        sigma3 = 0.0;
	        sigma3 = d_err*V[j3];
	        e_err3[j3] = sigma3*H3[j3]*(1-H3[j3]);//第三隐层各神经元的一般化误差
		}
	    for (int j2=0;j2<HN;j2++) 
		{
	        sigma2 = 0.0;
	        sigma2 = d_err * V[j2];
			e_err2[j2] = sigma2*H2[j2]*(1-H2[j2]);//第二隐层各神经元的一般化误差
		}
	    for (int j1=0;j1<HN;j1++) 
		{
	        sigma1=0.0;
	        sigma1 = d_err * V[j1];
			e_err1[j1] = sigma1*H1[j1]*(1-H1[j1]);//第一隐层各神经元的一般化误差
		}
	    return 1;
	}//子程序Err_H_I()结束


//////////////////////////////////////////////////////	//
//	输出层至第三隐层的权值调整、输出层阈值调整计算子程序//////
//////////////////////////////////////////////////////	//
	public int Delta_O_H3(int m,int n)
	{
	    if(n<=1)
		{
		    for (int j=0;j<HN;j++)
			{
			    	V[j] = V[j] - a*d_err *H3[j];//输出层至第三隐层的权值调整
			}
		    YU_ON -= a*d_err ; //输出层阈值调整
		}
	    else if(n>1)
		{
		    for (int j=0;j<HN;j++)
			{
				    V[j] = V[j] + a*d_err*H3[j] + alpha*(V[j] - old_V[j]);//输出层至隐层的权值调整
			}
		        YU_ON -=a*d_err ;//输出层至隐层的阈值调整
		}
	    return 1;
	}//子程序Delta_O_H3()结束