file.java

java写的神经网络程序,很实用的 欢迎下载

import java.io.*;
import java.util.Random;

class file
{    
     
public static void main(String args[]) //主程序入口
{//读取学习数据
int row=0;
     int inNum=0;
     int hideNum=0;
     int outNum=0;
     int sampleNum=0;
     int simNum=0;
     int epochs=1000;
    String str_p1="";
    String str_t1="";
    String str_p2="";
    double p1[][]=new double[sampleNum][inNum];
    double t1[][]=new double[sampleNum][outNum];
    double p2[][]=new double[simNum][inNum];
 
    
   try
    { 
      FileInputStream file=null;
      file=new FileInputStream("d:\\nndata.txt");
     DataInputStream dis=null;
   dis=new DataInputStream(file);
     String line=dis.readLine();

     row++;
     while(line!=null)
       {  //System.out.println(line);

         if (line.indexOf("inNum:")>=0)
           inNum=Integer.parseInt(line.substring(line.indexOf("inNum:")+6)); //得到输入接点数
          //System.out.println("inNum=:"+inNum);
         if (line.indexOf("hideNum:")>=0)
           hideNum=Integer.parseInt(line.substring(line.indexOf("hideNum:")+8));  //得到隐含接点数
           
         if (line.indexOf("outNum:")>=0)
           outNum=Integer.parseInt(line.substring(line.indexOf("outNum:")+7)); //得到输出接点数
         if (line.indexOf("sampleNum:")>=0)
           sampleNum=Integer.parseInt(line.substring(line.indexOf("sampleNum:")+10)); //得到学习样本数
         if (line.indexOf("simNum:")>=0)
           simNum=Integer.parseInt(line.substring(line.indexOf("simNum:")+7)); //得到仿真样本数
         if (line.indexOf("p1:")>=0)
           str_p1+=line.substring(line.indexOf("p1:")+3);
         if (line.indexOf("t1:")>=0)
           str_t1+=line.substring(line.indexOf("t1:")+3);
         if (line.indexOf("p2:")>=0)
           str_p2+=line.substring(line.indexOf("p2:")+3);
          row++;
        line=dis.readLine();
       }//end while
     p1=LoadData.readarray(sampleNum,inNum,str_p1);  //读取输入样本矩阵
     t1=LoadData.readarray(sampleNum,outNum,str_t1); //读取输出样本矩阵
     p2=LoadData.readarray(simNum,inNum,str_p2);     //读取仿真样本矩阵
    }//end try
     catch(Exception e){System.out.println(e.getMessage());}
   //*******************************************************  
  BpNet bpnet=new BpNet(inNum,hideNum,outNum);
  for (int i=0;i<epochs;i++)
  bpnet.train(p1,t1,sampleNum);//训练
  
//*****************************************/
     double p21[]=new double[inNum];
     double t2[]=new double[outNum];      
  for (int n=0;n<simNum;n++)
  {
      for(int i=0;i<inNum;i++)
        {p21[i]=p2[n][i];//
          System.out.println("p21="+p21[i]);
         }//
        t2=bpnet.sim(p21);
        
        for(int i=0;i<outNum;i++)
        System.out.println("out="+t2[i]);//
     }//end for n  
  
 } //end main method  
}//end class file

//读取数据到数组的函数
class  LoadData
{    
     
public static double[][] readarray(int r,int c,String str_array)
{
String str_flow=str_array;
String str_num="";
double array[][]=new double[r][c];
for(int i=0;i<r;i++)
    for(int j=0;j<c;j++)
        {    while ((str_flow.charAt(0)=='{' )||(str_flow.charAt(0)==',' )||(str_flow.charAt(0)=='}' ))
                   str_flow=str_flow.substring(1);
             str_num="";
             while ((str_flow.charAt(0)!='{' )&&(str_flow.charAt(0)!=',' )&&(str_flow.charAt(0)!='}' ))
                   {str_num+=str_flow.substring(0,1);
                    str_flow=str_flow.substring(1);
                    }
             array[i][j]=Double.valueOf(str_num).doubleValue();
             //System.out.println(String.valueOf(array[i][j]));
         }//end for

return array;
}//end readdarray
}


class BpNet extends Object 
{

  int inNum;  //输入接点数
  int hideNum;//隐含接点数
  int outNum;  //输出接点数

  Random R;
  int epochs;

  double x[]; //输入向量
  double x1[];//隐含接点状态值
  double x2[];//输出接点状态值

  double o1[];
  double o2[];
  double w[][];//隐含接点权值
  double w1[][];//输出接点权值
  double rate_w; //权值学习率（输入层-隐含层)
  double rate_w1;//权值学习率 (隐含层-输出层)
  double rate_b1;//隐含层阀值学习率
  double rate_b2;//输出层阀值学习率
  double b1[];//隐含接点阀值
  double b2[];//输出接点阀值
  double pp[];
  double qq[];
  double yd[];
  double e;
  double in_rate;//输入归一化比例系数
  
public BpNet(int inNum,int hideNum,int outNum)
 {
  R=new Random();
  this.epochs=500;  //
  this.inNum=inNum;
  this.hideNum=hideNum;
  this.outNum=outNum;
  x=new double[inNum]; //输入向量
  x1=new double[hideNum];//隐含接点状态值
  x2=new double[outNum];//输出接点状态值

  o1=new double[hideNum];
  o2=new double[outNum];
  w=new double[inNum][hideNum];//隐含接点权值
  w1=new double[hideNum][outNum];//输出接点权值
  b1=new double[hideNum];//隐含接点阀值
  b2=new double[outNum];//输出接点阀值
  pp=new double[hideNum];
  qq=new double[outNum];
  yd=new double[outNum];

  for (int i=0;i<inNum;i++)
      for (int j=0;j<hideNum;j++)
      w[i][j]=R.nextDouble();
  for (int i=0;i<hideNum;i++)
      for (int j=0;j<outNum;j++)
      w1[i][j]=R.nextDouble();

  rate_w=0.05;//权值学习率（输入层-隐含层)
  rate_w1=0.05;//权值学习率 (隐含层-输出层)
  rate_b1=0.05;//隐含层阀值学习率
  rate_b2=0.05;//输出层阀值学习率
  e=0.0;
  in_rate=1.0;//输入归一化系数
  }
/**********************************/
  /*****BP神经控制器算法训练函数*****/
  public void train(double p[][],double t[][],int samplenum)
  { e=0.0;
  double pmax=0.0;
  for (int isamp=0;isamp<samplenum;isamp++){
      for (int i=0;i<inNum;i++)
          {if (Math.abs(p[isamp][i])>pmax)
              pmax=Math.abs(p[isamp][i]);
          }
      for (int j=0;j<outNum;j++)
          {if (Math.abs(t[isamp][j])>pmax)
              pmax=Math.abs(t[isamp][j]);
          }
      }//end for isamp
in_rate=pmax;
for(int isamp=0;isamp<samplenum;isamp++)//循环训练一次样本
  {
  for(int i=0;i<inNum;i++)
    x[i]=p[isamp][i]/in_rate;
  for(int i=0;i<outNum;i++)
    yd[i]=t[isamp][i]/in_rate;
//构造每个样本的输入和输出标准
 for(int j=0;j<hideNum;j++)
   {o1[j]=0.0;
    for(int i=0;i<inNum;i++)
      o1[j]=o1[j]+w[i][j]*x[i];
    x1[j]=1.0/(1.+Math.exp(-o1[j]-b1[j]));
   }
for(int k=0;k<outNum;k++)
   {o2[k]=0.0;
    for(int j=0;j<hideNum;j++)
      o2[k]=o2[k]+w1[j][k]*x1[j];
    x2[k]=1.0/(1.0+Math.exp(-o2[k]-b2[k]));
    //x2[k]=o2[k]-b2[k];
   }
 for(int k=0;k<outNum;k++)
   {qq[k]=(yd[k]-x2[k])*x2[k]*(1.-x2[k]);
  e+=Math.abs(yd[k]-x2[k])*Math.abs(yd[k]-x2[k]);//计算均方差
    for(int j=0;j<hideNum;j++)
    w1[j][k]=w1[j][k]+rate_w1*qq[k]*x1[j];
   }
for(int j=0;j<hideNum;j++)
   {
    pp[j]=0.0;
    for(int k=0;k<outNum;k++)
      pp[j]=pp[j]+qq[k]*w1[j][k];
    pp[j]=pp[j]*x1[j]*(1.-x1[j]);
    for(int i=0;i<inNum;i++)
       w[i][j]=w[i][j]+rate_w*pp[j]*x[i];
    }
 for(int k=0;k<outNum;k++)
   b2[k]=b2[k]+rate_b2*qq[k];
 for(int j=0;j<hideNum;j++)
   b1[j]=b1[j]+rate_b1*pp[j];
}//end isamp样本循环
  e=Math.sqrt(e);
}//end train
 /***************************************/
  /*****BP神经控制器算法模拟计算函数*****/
 public double[] sim(double psim[])
{
  for(int i=0;i<inNum;i++)
    x[i]=psim[i]/in_rate;
    for(int j=0;j<hideNum;j++)
   {o1[j]=0.0;
    for(int i=0;i<inNum;i++)
      o1[j]=o1[j]+w[i][j]*x[i];
    x1[j]=1.0/(1.+Math.exp(-o1[j]-b1[j]));
   }
 for(int k=0;k<outNum;k++)
   {o2[k]=0.0;
    for(int j=0;j<hideNum;j++)
       o2[k]=o2[k]+w1[j][k]*x1[j];
    x2[k]=1.0/(1.0+Math.exp(-o2[k]-b2[k]));
    //x2[k]=o2[k]-b2[k];
    x2[k]=in_rate*x2[k]; }
  return x2;
} //end sim
} //end bp class