bpnet.java

BP神经网络的训练和预测程序

package bpnet;
import java.util.*;
import java.io.*;

class BPNet{
    /*
     * 神经网络常量和变量定义
     */
    int InCode;//输入层节点个数；
    int HideCode;//隐层节点个数；
    int OutCode;//输出层节点个数；
    int SampleNum=0;//样本数据的个数
    final int MAX=1000;
    //final int MIN=1000;
    double W_I_H[][];
    double W_H_O[][];//隐层到输出层的权值
    double Bias_H[];//隐层的阈值
    double Bias_O[];//输出层的阈值
    double I_Hide[];//隐层的纯输入
    double I_Out[];//输出层的纯输入
    double O_In[];//输入层的输出
    double O_Hide[];//隐层的输出
    double O_Out[];//输出层的输出
    double Err_Hide[];//隐层的误差
    double Err_Out[];//输出层的误差
    int T[];//网络的实际输出  
    double O_Middle[];//记录样本数据中每一行的值
    double Study_Efficient;//记录神经网络学习效率
    //String SampleData[];//存储每一行样本数据
    int classNum=0;//记录被正确分类的样本数据个数
    String TestData[];
    public int Echo_Num;//记录BP算法运行次数
    public double Precision;//记录BP算法运行的精度
    String[] t;
    public int echo;
    public double[] prerate;
    public int InputPara;//输入参数个数
    public static String argspre;
    /*
     * 初始化神经网络的权值和阈值
     */
    public void initial(){
        Random rnd=new Random();
        //System.out.println(InCode);
        //System.out.println(HideCode);         
        W_I_H=new double[InCode][HideCode];
        W_H_O=new double[HideCode][OutCode];
        Bias_H=new double[HideCode];
        Bias_O=new double[OutCode];
        for(int i=0;i<InCode;i++){//输入层到隐层的权值
            for(int j=0;j<HideCode;j++){
                W_I_H[i][j]=(rnd.nextInt(21)-10)/10.0;
                //System.out.println("W["+i+"]["+j+"]="+W_I_H[i][j]);
            }
        }
        for(int i=0;i<HideCode;i++){//隐层到输出层的权值
        	for(int j=0;j<OutCode;j++){
        		W_H_O[i][j]=(rnd.nextInt(21)-10)/10.0;
        		//System.out.println("W["+i+"]["+j+"]="+W_H_O[i][j]);
        	}
        }
        for(int i=0;i<HideCode;i++){//隐层的阈值
        	Bias_H[i]=(rnd.nextInt(21)-10)/10.0;
        	//System.out.println("Bias_H["+i+"]="+Bias_H[i]);
        }
        for(int j=0;j<OutCode;j++){//输出层的阈值
        	Bias_O[j]=(rnd.nextInt(21)-10)/10.0;
        	//System.out.println("Bias_O["+j+"]="+Bias_O[j]);
        }
    }
    /*
     * 读取样本数据的行数
     */
    public int sampleNum(FileInputStream fis){
        String s;
        try{
            InputStreamReader isr=new InputStreamReader(fis);
            BufferedReader br=new BufferedReader(isr);
            while((s=br.readLine())!=null){
                SampleNum++;
            }
            br.close(); 
        }catch(IOException ie){System.out.println(ie.toString());}        
        return SampleNum;
    }
    /*
     *读取样本数据集中每一行的值
     */
    public void readSample(String s) throws Exception{
        InputPara=0;
        try{           
            //O_Middle=new double[InCode+1];
            //T=new int[SampleNum];
            O_In=new double[InCode+1];           
            StringTokenizer stok=new StringTokenizer(s);
            //System.out.println(s);
            for(int i=0;stok.hasMoreTokens();i++){
                O_In[i]=Double.parseDouble(stok.nextToken());             
                InputPara++;
                //System.out.println(O_In[i]);
            }                 
        }catch(Exception e){System.out.println(e.toString());}       
    }    
   
    /*
     * 计算隐层的纯输入和输出
     */
    public void cal_I(int m){
    	double sum_W_I=0.0;
    	I_Hide=new double[HideCode];
    	O_Hide=new double[HideCode];
    	for(int j=0;j<HideCode;j++){//隐层的纯输入
    		for(int i=0;i<InCode;i++){
    			sum_W_I+=W_I_H[i][j]*O_In[i];
    		}
    		I_Hide[j]=sum_W_I+Bias_H[j];
    		//System.out.println(I_Hide[j]);       		
    	}
	    for(int j=0;j<HideCode;j++){//隐层的输出
            O_Hide[j]=(double)(1/(1+Math.exp(-I_Hide[j])));
            //System.out.println(O_Hide[j]);
	    }   	
    }
    /*
     * 计算输出层的纯输入和输出
     */
    public void cal_O(int m){
        double sum_W_O=0.0;
        I_Out=new double[OutCode];
        O_Out=new double[OutCode];
        for(int j=0;j<OutCode;j++){//输出层的纯输入
            for(int i=0;i<HideCode;i++){
                sum_W_O+=W_H_O[i][j]*O_Hide[i];
            }
            I_Out[j]=sum_W_O+Bias_O[j];
            
        }
        for(int j=0;j<OutCode;j++){//输出层的输出
            O_Out[j]=(double)(1/(1+Math.exp(-I_Out[j])));
            //System.out.println("第"+m+"个样本数据的输出为："+O_Out[j]);
        }
    }
    /*
     * 计算输出层的误差
     */
    public void cal_Err_O(int m){
        Err_Out=new double[OutCode];
        for(int j=0;j<OutCode;j++){
            //System.out.println(O_Out[j]);
            Err_Out[j]=O_Out[j]*(1-O_Out[j])*(O_In[InCode]-O_Out[j]);
            //System.out.println("输出层的误差Err_Out["+j+"]="+Err_Out[j]);
            
            if(Math.abs(O_Out[j]-O_In[InCode])<Precision){
            	classNum++;
            	//System.out.println("第"+m+"个样本数据被正确分类！");
            }
        }
    }
    /*
     * 计算隐层的误差
     */
    public void cal_Err_H(int m){
        Err_Hide=new double[HideCode];
        double sum_W_H=0.0;
        for(int i=0;i<HideCode;i++){
            for(int j=0;j<OutCode;j++){
                sum_W_H+=Err_Out[j]*W_H_O[i][j];
            }
            Err_Hide[i]=sum_W_H*O_Hide[i]*(1-O_Hide[i]);
            //System.out.println(Err_Hide[i]);
        }              
    }
    /*
     *神经网络权值的更新
     */
    public void W_Refresh(int m){
        double[][] delta_W_I_H=new double[InCode][HideCode];
        double[][] delta_W_H_O=new double[HideCode][OutCode];
        for(int i=0;i<InCode;i++){
            for(int j=0;j<HideCode;j++){
                delta_W_I_H[i][j]=Study_Efficient*Err_Hide[j]*O_In[i];
                W_I_H[i][j]=W_I_H[i][j]+delta_W_I_H[i][j];
                //System.out.println(W_I_H[i][j]);
                //System.out.println("更新后的W["+i+"]["+j+"]="+W_I_H[i][j]);
            }
        }
        for(int i=0;i<HideCode;i++){
            for(int j=0;j<OutCode;j++){
                delta_W_H_O[i][j]=Study_Efficient*Err_Out[j]*O_Hide[i];
                W_H_O[i][j]=W_H_O[i][j]+delta_W_H_O[i][j];
                //System.out.println("更新后的W["+i+"]["+j+"]="+W_H_O[i][j]);
            }
        }       
    }
    /*
     * 神经网络阈值的更新
     */
    public void Bias_Refresh(int m){
        double[] delta_Bias_H=new double[HideCode];
        double[] delta_Bias_O=new double[OutCode];
        for(int i=0;i<HideCode;i++){
            delta_Bias_H[i]=Study_Efficient*Err_Hide[i];
            Bias_H[i]=delta_Bias_H[i]+Bias_H[i];
            //System.out.println("更新后的Bias_H["+i+"]="+Bias_H[i]);
        }
        for(int i=0;i<OutCode;i++){
            delta_Bias_O[i]=Study_Efficient*Err_Out[i];
            Bias_O[i]=delta_Bias_O[i]+Bias_O[i];
            //System.out.println("更新后的Bias_O["+i+"]="+Bias_O[i]);
        }
    }
    /*
     * 神经网络模拟输出
     */
    public void simulate() throws Exception{//通过测试数据来判断模型的准确度               
        for(int i=0;i<SampleNum;i++){
            readSample(TestData[i]);
            cal_I(i+1);
            cal_O(i+1);
            cal_Err_O(i+1);
        }
    }
    /*
     * 算法开始
     */  
    public void begin() throws Exception{

        // int k=0;
         
         String SampleData[]  = null;
         //BPNet bpnet=new BPNet("动态分析分类准确率与学习代数之间的关系");
         //BPNet bpnet=new BPNet();
         echo=0;
         
        // BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
         System.out.print("输入层节点个数: InCode= ");
         //String r=br.readLine();
         InCode=60;
         System.out.print("隐层节点个数: HideCode= ");
        // String r1=br.readLine();
         HideCode=2*InCode+1;
         System.out.print("输出层节点个数: OutCode= ");
         //String r2=br.readLine();
         OutCode=1;
         System.out.print("BP神经网络学习效率: Study_Efficient= ");
        // String r3=br.readLine();
         Study_Efficient=0.87;  
         System.out.print("BP神经网络算法运行次数: Echo_Num= ");
         //String r4=br.readLine();
         Echo_Num=500;  
         System.out.print("BP神经网络算法学习精度: Precision= ");
        // String r5=br.readLine();
         Precision=Double.parseDouble(argspre);  
        // br.close();
         try{
             FileInputStream fis=new FileInputStream("d://ceshiClass.txt");
             sampleNum(fis);
             //System.out.println(bpnet.SampleNum);
         }catch(IOException ie){System.out.println(ie.toString());}       
         try{
             SampleData=new String[SampleNum];
             FileInputStream fis1=new FileInputStream("d://ceshiClass.txt");
             InputStreamReader isr1=new InputStreamReader(fis1);
             BufferedReader br1=new BufferedReader(isr1);
             int k=0;
             String s;
             while((s=br1.readLine())!=null){
                 SampleData[k]=s;
                 //System.out.println(SampleData[k]);
                 k++;
             }
             br1.close();
         }catch(IOException ie){System.out.println(ie.toString());}
        
         prerate=new double[Echo_Num];
         FileWriter fr=new FileWriter("d://bpoutput.txt");
         BufferedWriter bw=new BufferedWriter(fr);
         initial();//初始化BP神经网络
         int q=0;
         int o=1;
         while(echo<Echo_Num){//echo的值可以通过用户输入来确定循环次数
         	classNum=0;
             for(int i=0;i<SampleNum;i++){
                 readSample(SampleData[i]);               
                 cal_I(i+1);
                 cal_O(i+1);                
                 cal_Err_O(i+1);
                 cal_Err_H(i+1);
                 W_Refresh(i+1);
                 Bias_Refresh(i+1);
             }
             System.out.println("共有"+classNum+"个样本被正确分类！");
             prerate[q]=(double)classNum/SampleNum;
             bw.write(String.valueOf(classNum));
             if(classNum==SampleNum){
             	System.out.println();
             	System.out.println("样本数据全部被正确分类！");
             	break;
             }
             else{
             	echo++;
             	
             }
             if(echo<Echo_Num){
                 bw.newLine();
             }
             o++;
             q++;
            
         }
         bw.close();
         System.out.println("*************************实验结果如下所示**************************");
         System.out.println("在第"+echo+"代算法收敛！   "+"共有"+classNum+"个样本被正确分类！");
         System.out.println("******************************************************************");
         System.out.println();
         System.out.println("训练样本被正确分类的样本个数="+classNum);
         System.out.println("训练样本总数="+SampleNum);
         
         
         classNum=0;
         SampleNum=0;
         try{
             FileInputStream fis1=new FileInputStream("d://trainClass.txt");
             sampleNum(fis1);
            // System.out.println("SampleNum="+bpnet.SampleNum);
         }catch(IOException ie){System.out.println(ie.toString());}
         TestData=new String[SampleNum];
         
         try{
             FileInputStream fis1=new FileInputStream("d://trainClass.txt");
             InputStreamReader isr1=new InputStreamReader(fis1);
             BufferedReader br1=new BufferedReader(isr1);
             int k=0;
             String s;
             while((s=br1.readLine())!=null){
                 TestData[k]=s;
                 //System.out.println(SampleData[k]);
                 k++;
             }
             br1.close();
         }catch(IOException ie){System.out.println(ie.toString());}
         System.out.println();
         System.out.println("*************************下面开始神经网络仿真运算*******************");
         /*
          * BP神经网络模拟算法开始
          */
         simulate();
         System.out.println();
         System.out.println("测试样本数据被正确分类的个数="+classNum);
         System.out.println("测试样本总数="+SampleNum);
         System.out.println("*************************神经网络模拟结果如下所示*******************");
         System.out.println("模拟正确率为="+((double)classNum/(double)SampleNum)); 
         
     
    }
    /*
     * 主程序入口处
     */
    public static void main(String[] args) throws Exception {
        BPNet bpnet=new BPNet(); 
        argspre=args[0];
        bpnet.begin();
        System.out.println("InputPara="+bpnet.InputPara);
      /*  System.out.println("Echo_Num="+bpnet.Echo_Num);
        for(int i=0;i<bpnet.Echo_Num;i++){
            System.out.println("prerate["+i+"]="+bpnet.prerate[i]);
        }*/
        //bpnet.open();
    }
}