22.c

神经网络的一个重要应用

//#include "stdafx.h"
#include  <string.h>
#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#define random(x)(rand()%x)
#define randomize() srand(time(NULL)) 
 // #pragma   argsused

  void   clearwc(void) ;  //清除网络权值变化量wc
  void   clearbc(void) ;     //清除网络阀值变化量bc
  void   netout(int   m,int   n)  ; //计算网络隐含层和输出层的输出
  void   calculdiffer(void)   ;      //计算NN网络单个样本误差
  void   calculd(int   m,int   n)  ;  //计算网络的反向传播误差
  void   calculwc(int   m,int   n) ;   //计算网络权值的调整量
  void   calculbc(int   m,int   n)  ;    //计算网络阀值的调整量
  void   calculis(void) ;                //计算NN网络全体样本误差
  void   initialb(void) ;                 //初始化NN网络阀值
  void   trainNN(void);                   //训练NN网络
  void   initialw(void);                   //初始化NN网络权值W
  void   changew(int   m,int   n)  ;         //调整网络权值
  void   changeb(int   m,int   n) ;      //调整网络阀值




// double   o[4][10] ;

 /* int   main()
  {
      char     ch;
      double   result;

      int   m,test[4]; */
   // float test[4];
  int   main()
  {   
      double   result;
      //double   o[3][3] ;
       double   o[4][10] ;
      int   m;

      float test[3];

      char   ch='y';
       FILE *fp1;
       FILE *fp4;
       FILE *fp5;
       fp1=fopen("F:\\BP\\result.txt","w");
       // fp4=fopen("F:\\BP\\is.txt","w");
         fp5=fopen("F:\\BP\\复件 目标样本.txt","r");
         for(m=1;m<=3;m++)
         {test[m]=0;}
      /*FILE *fp2;
       FILE *fp3;
      // FILE *fp4;
fp1=fopen("F:\\BP\\result.txt","w");
 fp2=fopen("F:\\BP\\yin.txt","w");
 fp3=fopen("F:\\BP\\shu.txt","w");
// fp4=fopen("F:\\BP\\is.txt","w");  */
      //cout<<"Please   wait   for   the   train   of   NN:"<<endl;
      trainNN();   
      //out<<"Now,this   modular   network   can   work   for   you."<<endl;
    
      while(ch=='y'   ||   ch=='Y')   
      {   
        //cout<<"Please   input   data   to   be   tested."<<endl;

          for   (m=1;m<=3;m++)
           {
           //scanf("%f",&test[m]);
           fscanf(fp5,"%f",&test[m]);
            }

           //printf("o[3][1]=%f\n",o[3][1]);
          //cin>>test[m];
          ch=getchar();   
          o[1][1]=test[1];   
          o[1][2]=test[2];   
          o[1][3]=test[3];   
          netout(8,1);   
          result=o[3][1];

          //printf("o[3][1]=%f\n",o[3][1]);
         //getch();
          fprintf(fp1,"%f \n",result);
          //printf("Final   result   is   %f.\n",result);
         // printf("Still   test?[Yes]   or   [No]\n");
          //ch=getchar();
           fclose(fp1);
           fclose(fp4);
           fclose(fp5);
      }   
    
    
                  return   0;   
  }   








    
  float   Aa=30.0;
  float   B=10.0;
  float   MAX=500;               //最大训练次数
  float   COEF=0.035;   //网络的学习效率
  float   BCOEF=0.01;//网络的阀值调整效率
  float   ERROR=0.002     ;   //   网络训练中的允许误差
  float   ACCURACY=0.0005;//网络要求精度
  double    w[4][10][10],wc[4][10][10],b[4][10],bc[4][10];
  double    o[4][10],netin[4][10],d[4][10],differ;//单个样本的误差
  double    is;   //全体样本均方差
  int       count,a;
  double    sample[41][4]={
{0,0,0,0},
{5,1,4,19.020},
{5,3,3,14.150},   
{5,5,2,14.360},
{5,3,3,14.150},
{5,3,2,15.390},   
{5,3,2,15.390},
{5,5,1,19.680},
{5,1,2,21.060},   
{5,3,3,14.150},
{5,5,4,12.680},
{5,5,2,14.360},   
{5,1,3,19.610},
{5,3,4,13.650},
{5,5,5,12.430},   
{5,1,4,19.020},
{5,1,4,19.020},
{5,3,5,13.390},   
{5,5,4,12.680},
{5,1,3,19.610},
{5,3,2,15.390},   
{1,3,1,11.110},
{1,5,2,6.521},
{1,1,3,10.190},   
{1,3,4,6.043},
{1,5,5,5.242},
{1,5,3,5.724},   
{1,1,4,9.766},
{1,3,5,5.870},
{1,5,4,5.406},   
{1,1,3,10.190},
{1,1,5,9.545},
{1,3,4,6.043},   
{1,5,3,5.724},
{1,1,2,11.250},
{1,3,1,11.110},   
{1,3,3,6.380},
{1,5,2,6.521},
{1,1,1,16.000},   
{1,3,2,7.219},
{1,5,3,5.724}
};   
    



    /*训练网络*/   
  void  trainNN(void)
  {   


      long   int   time;   
      int   i,x[4];
     FILE *fp4;
fp4=fopen("F:\\BP\\is.txt","w");
      initialw();
      initialb();
    
      for   (time=1;time<=MAX;time++)   
      {   
          count=0;   
          while(count<=40)   
          {   
              o[1][1]=sample[count][0];   
              o[1][2]=sample[count][1];   
              o[1][3]=sample[count][2];   
    
              count=count+1;   
              clearwc();   
              clearbc();   
              netout(8,1);   
              calculdiffer();      
              while(differ>ERROR)   
              {   
                  calculd(8,1);   
                  calculwc(8,1);   
                  calculbc(8,1);   
                  changew(8,1);   
                  changeb(8,1);   
                  netout(8,1);   
                  calculdiffer();   
              }   
          }   
          //printf("This   is   %d   times   training   NN...\n",time);
          calculis();   
        fprintf(fp4,"%f \n",is);
         // printf("is==%f\n",is);
          if   (is<ACCURACY)   break;   
      }   
  }  


   /*初始化网络权值W*/   
  void  initialw(void)
  {   
      int   i,j,k;


      double   weight, x ;
      for   (i=0;i<4;i++)
          for   (j=0;j<10;j++)
              for   (k=0;k<10;k++)   
              {   
                  randomize();
                  x=100+random(400);   
                  weight=x/5000.00;
                  w[i][j][k]=weight;
                 // printf("i=%d,j=%d,k=%d,w[i][j][k]=%f\n",i,j,k,w[i][j][k]);


              }
  }
    
  /*初始化网络阀值*/   
 void  initialb(void)
  {   
      int   i,j,x,k;
      double   fazhi;   
      for   (i=0;i<4;i++)   
        for   (j=0;j<10;j++)   
        {   
           randomize();
             x=100+random(400); 
          /*  for   (int   k=0;k<12;k++)
            {   
                x=100+random(400);   
            }  */
            fazhi=x/50000.00;
            b[i][j]=fazhi;   
             //printf("i=%d,j=%d,b[i][j]=%f\n",i,j,b[i][j]);
        }
  }

  /*清除网络权值变化量wc*/

  void   clearwc(void)   
  {     int i,j,k;
      for   (   i=0;i<4;i++)
          for   ( j=0;j<10;j++)
              for   ( k=0;k<10;k++)
                  wc[i][j][k]=0.00;   
                   //printf("i=%d,j=%d,k=%d,wc[i][j][k]=%f\n",i,j,k,wc[i][j][k]);
  }
    
  /*清除网络阀值变化量*/   
  void   clearbc(void)   
  {       int i,j;
      for   (   i=0;i<4;i++)
          for   (  j=0;j<10;j++)
              bc[i][j]=0.00;   
  }   
    
    



/*计算NN网络隐含层和输出层的输出   */
  void   netout(int   m,int   n)   
  {   
      int   i,j,k;   

/*FILE *fp2;
      FILE *fp3;


 fp2=fopen("F:\\BP\\yin.txt","w");
 fp3=fopen("F:\\BP\\shu.txt","w");    */

    
      //隐含层各节点的的输出   
      for   (j=1,i=2;j<=m;j++)   //m为隐含层节点个数   
      {   
          netin[i][j]=0.0;   
          for(k=1;k<=3;k++)//隐含层的每个节点均有三个输入变量   
              netin[i][j]=netin[i][j]+o[i-1][k]*w[i][k][j];   
          netin[i][j]=netin[i][j]-b[i][j];   
        o[i][j]=Aa/(1+exp(-netin[i][j]/B));


      //fprintf(fp2,"%f，%f，%f\n",i，j，o[i][j]);
     // fprintf(fp2,"%f\n",o[i][j]);
        }
      //printf("o[3][1]=%f\n",o[3][1]);
         //getch();
    
      //输出层各节点的输出   
      for   (j=1,i=3;j<=n;j++)   
      {   
          netin[i][j]=0.0;   
          for   (k=1;k<=m;k++)   
              netin[i][j]=netin[i][j]+o[i-1][k]*w[i][k][j];   
          netin[i][j]=netin[i][j]-b[i][j];   
          o[i][j]=Aa/(1+exp(-netin[i][j]/B))   ;

              // fprintf(fp3,"%f\n",o[i][j]);
           // fprintf(fp3,"%f %f %f\n",i，j，o[i][j]);
              }
           // printf("o[3][1]=%f\n",o[3][1]);
          //getch();
  }   
    
/*计算网络单个样本误差*/
  void   calculdiffer(void)   
  {   
      a=count-1;   
      differ=0.5*(o[3][1]-sample[a][3])*(o[3][1]-sample[a][3]);   
  }   



    

    
/*计算NN网络的反向传播误差*/
  void   calculd(int   m,int   n)   
  {   
        int   i,j,k;   
        double   t;   
        a=count-1;   
      d[3][1]=(o[3][1]-sample[a][3])*(Aa/B)*exp(-netin[3][1]/B)/pow(1+exp(-netin[3][1]/B),2);
    
        //隐含层的误差   
        for   (j=1,i=2;j<=m;j++)   
        {   
            t=0.00;   
            for   (k=1;k<=n;k++)   
                t=t+w[i+1][j][k]*d[i+1][k];   
                  d[i][j]=t*(Aa/B)*exp(-netin[i][j]/B)/pow(1+exp(-netin[i][j]/B),2);
        }   
  }   
    
      
 


  /*计算网络权值W的调整量*/   
  void   calculwc(int   m,int   n)   
  {   
      int   i,j,k;   
    
    //   输出层（第三层）与隐含层（第二层）之间的连接权值的调整   
      for   (i=1,k=3;i<=m;i++)   
    {
          for   (j=1;j<=n;j++)   
         {
              wc[k][i][j]=-COEF*d[k][j]*o[k-1][i]+0.5*wc[k][i][j];   
         }
          // printf("\n");
         //printf("w[3][%d][%d]=%f\n",wc[3][i][j]);
     }
      //隐含层与输入层之间的连接权值的调整   
      for   (i=1,k=2;i<=m;i++)   
      {
          for   (j=1;j<=m;j++)   
         {
              wc[k][i][j]=-COEF*d[k][j]*o[k-1][i]+0.5*wc[k][i][j];   
          }
          //printf("\n");
       //printf("w[2][%d][%d]=%f\n",wc[2][i][j]);
      }
    
  }   



  /*计算网络阀值的调整量*/   
  void   calculbc(int   m,int   n)   
  {   
      int   j;   
      for   (j=1;j<=m;j++)   
      {   
          bc[2][j]=BCOEF*d[2][j];   
      }   
      for   (j=1;j<=n;j++)   
      {   
          bc[3][j]=BCOEF*d[3][j];   
      }   
  }   
    



  /*调整网络权值*/   
  void   changew(int   m,int   n)
  {   
      int   i,j;   
      for   (i=1;i<=3;i++)   
        for   (j=1;j<=m;j++)
          {   
              w[2][i][j]=0.9*w[2][i][j]+wc[2][i][j];   
              //为了保证系统有较好的鲁棒性，计算权值时乘惯性系数0.9   
             // printf("w[2][%d][%d]=%f\n",i,j,w[2][i][j]);
           }
     for   (i=1;i<=m;i++)
          for   (j=1;j<=n;j++)
          {   
              w[3][i][j]=0.9*w[3][i][j]+wc[3][i][j];   
             // printf("w[3][%d][%d]=%f\n",i,j,w[3][i][j]);
          }
  }





  /*调整网络阀值*/   
  void   changeb(int   m,int   n)
  {   
      int   j;   
      for   (j=1;j<=m;j++)   
          b[2][j]=b[2][j]+bc[2][j];   
    
      for   (j=1;j<=n;j++)   
          b[3][j]=b[3][j]+bc[3][j];   
  }   
    




    /*全体样本均方差*/

    void   calculis(void)   
  {   
      int   i;   
      is=0.0;   
      for   (i=0;i<=19;i++)   
      {   
          o[1][1]=sample[i][0];   
          o[1][2]=sample[i][1];   
          o[1][3]=sample[i][2];   
          netout(8,1);   
          is=is+(o[3][1]-sample[i][3])*(o[3][1]-sample[i][3]);   
      }   
      is=is/20000000;
  }