annbp.c

bp神经网络 c语言程序

/*********************************************************************/
/*                                                                   */
/*             Artificial  Neurul  Net   Work   Program              */
/*********************************************************************/

 #include "stdio.h"
 #include "stdlib.h"
 #include "math.h"
 #include "ctype.h"
 #include "string.h"
 #include "graphics.h"
 #define nO1 10            /*output nodes*/
 #define nH1 19            /*hidden nodes*/
 #define nI1 6		   /*input nodes*/
 #define nP1 120
 #define c   30
 double w1[nH1][nI1];	  /*weights input-hidden layers*/
 double w2[nO1][nH1];	   /*weights hidden-output layer*/
 float out0[nP1][nI1];
 float out1[nP1][nH1];
 float out2[nP1][nO1];
 float targ[nP1][nO1];
 float out00[nP1][nI1];
 float out11[nP1][nH1];
 float out22[nP1][nO1];
 float targ1[nP1][nO1];
 float delta1[nP1][nH1];
 float delta2[nP1][nO1];
 float delw1[nH1][nI1];
 float delw2[nO1][nH1];
 float sep[120];
 float  eta;                    /*default learing rate*/
 float  alpha;                   /*default momentum factor*/
 float  Errorlevel;            /*satisfactory error level*/
 float  error;                       /*latest sum squared error value*/
 int N,nI,D,nH,M;
 int cc;

/***********************************************************/
	  void  read_patterns()
   {FILE *fp;
    int p,i,j,h;
    char fname[20],fpp[20];
     printf("\n How many input nodes?");
     scanf("%d",&nI);
     printf("\n How many hidden nodes?");
     scanf("%d",&nH);
     printf("\n How many output nodes?");
     scanf("%d",&M);
     printf("\n Tatal number of input patterns?");
     scanf("%d",&D);
     printf("\n Momentum factor(0.02---0.75)?");
     scanf("%f",&alpha);
     printf("\n Learning rate(0.1--0.9)?");
     scanf("%f",&eta);
     printf("\n Terminate when error stisfactory(0.001)?");
     scanf("%f",&Errorlevel);
     printf("\n How many time iteraction(1000)?");
     scanf("%d",&N);
     printf("\n Input patterns file name :");
     scanf("%s",fname);
     strcpy(fpp,fname);
     strcat(fpp,".dat");
     if((fp=fopen(fpp,"r"))==NULL)
     {printf("\n File %s does not exit");
		   exit(0);
     }
	for(p=0;p<D;p++)
	{for(i=0;i<nI;i++)
	 {fscanf(fp,"%f",&out0[p][i]);
	 printf("%6.3f ",out0[p][i]);
	 }
	for(j=0;j<M;j++)
    {fscanf(fp,"%f",&targ[p][j]);
   printf("%6.3f ",targ[p][j]);}
    printf("\n");
	  }
   printf("\n");
   fclose(fp);
   }
/**********************************************************/
     void data()
 {float max[10];
 int i,j,p;
 for(j=0;j<M;j++)
 {max[j]=out0[0][j];
 for(p=0;p<D;p++)
 if(out0[p][j]>max[j])
 max[j]=out0[p][j];}
 for(j=0;j<M;j++)
  {if(max[j]>0&&max[j]<=1)max[j]=1.0;
  if(max[j]>1&&max[j]<=10)max[j]=10.0;
  if(max[j]>10&&max[j]<=100)max[j]=100.0;
  if(max[j]>100&&max[j]<=1000)max[j]=1000.0;
  if(max[j]>1000&&max[j]<=10000)max[j]=10000.0;
  if(max[j]>10000&&max[j]<=100000)max[j]=100000.0;
  }
 for(j=0;j<M;j++)
 for(p=0;p<D;p++)
 out0[p][j]=out0[p][j]/max[j];
  for(p=0;p<D;p++)
    { for(j=0;j<M;j++)
     printf("%f ",out0[p][j]);
     printf("\n");}
  }
 /***************************************************************/
    void random_w()
   {long rd=568731L;
   int p,i,h,j,rand;
   for(h=0;h<nH;h++)
  for(i=0;i<=nI;i++)
   {rd=15625L*rd+22221L;
    rand=(rd>>16)&0x7FFF;
  w1[h][i]=rand/pow(2.0,15.0)-0.5;
  delw1[h][i]=0.0;
       }
 for(h=0;h<nH;h++)
   {for(i=0;i<=nI;i++)
  printf("%.3f ",w1[h][i]);
  printf("\n");}
  rd=568731L;
  for(j=0;j<M;j++)
 for(h=0;h<=nH;h++)
 {rd=15625L*rd+22221L;
 rand=(rd>>16)&0x7FFF;
 w2[j][h]=rand/pow(2.0,15.0)-0.5;
 delw2[j][h]=0.0;
      }
 for(j=0;j<M;j++)
  { for(h=0;h<=nH;h++)
  printf("%6.3f ",w2[j][h]);
    printf("\n");}
    }
 /**************************************************************/
      void net_work(int p)
 { int i,j,h;
   float sum1,sum2;
  /*hidden layer sum input to hidden layer over allinput weight combinations*/
  for(h=0;h<nH;++h)
  {sum1=w1[h][nI]*1.0;
  for(i=0;i<nI;++i)
  sum1+=w1[h][i]*out0[p][i];
  out1[p][h]=1.0/(1.0+exp(-sum1)); }
     /*output layer*/
  for(j=0;j<M;j++)
 {sum2=w2[j][nH]*1.0;
 for(h=0;h<nH;h++)
 sum2+=w2[j][h]*out1[p][h];
 out2[p][j]=1.0/(1.0+exp(-sum2));
 /*printf("%f",out2[p][j]);*/
    }
    }
 /*end net-work*/
/*********************************************************************/
 void net_work1(int p)
 { int i,j,h;
 float sum1,sum2;
   /*hidden layer sum input to hidden layer over allinput weight combinations*/
  for(h=0;h<nH;++h)
  {sum1=w1[h][nI]*1.0;
  for(i=0;i<nI;++i)
  sum1+=w1[h][i]*out00[p][i];
  out11[p][h]=1.0/(1.0+exp(-sum1)); }
  /*output layer*/
  for(j=0;j<M;j++)
  {sum2=w2[j][nH]*1.0;
  for(h=0;h<nH;h++)
  sum2+=w2[j][h]*out11[p][h];
  out22[p][j]=1.0/(1.0+exp(-sum2));
      printf("%f",out22[p][j]);
    }
  /*end net-work*/
  }
  /******************************************************************/

/***********************************************************************/
   net_learning()
  {FILE *efp;
  int p,q,j,h,i,k;
  float err;
  float sep[120],ep[120][10],del2[6];
  double sum,dw;
  if((efp=fopen("error.dat","w"))==NULL)
  printf("not exit");
  err=0;
  for(q=0;q<N;q++)
  { for(p=0;p<D;p++)
  {sep[p]=0;
   net_work(p);
  /*delts output compute deltas for each output node for one epoch*/
    for(j=0;j<M;j++)
  {del2[j]=(targ[p][j]-out2[p][j]);
  delta2[p][j]=out2[p][j]*(1.0-out2[p][j])*del2[j];
  ep[p][j]=0.5*del2[j]*del2[j];
  sep[p]=sep[p]+ep[p][j];  }
   err=err+sep[p];
    /* printf("%f",err);*/
    /*delta hidden*/
  for(h=0;h<nH;h++)
  {sum=0.0;
  for(j=0;j<M;j++)
  sum+=delta2[p][j]*w2[j][h];
  delta1[p][h]=sum*out1[p][h]*(1.0-out1[p][h]);
	     }
  /* p*/
  /*adapt weights hidden:output*/
  for(j=0;j<M;j++)
  for(h=0;h<nH;h++)
  {delw2[j][h]=eta*delta2[p][j]*out1[p][h];
  w2[j][h]=w2[j][h]+delw2[j][h];
   /*calculate\ new bias weights for each output unit*/
   }
      /* calculate new weights*/
   for(h=0;h<nH;h++)
   for(i=0;i<nI;i++)
  {delw1[h][i]=eta*delta1[p][h]*out0[p][i];
   w1[h][i]=w1[h][i]+delw1[h][i];
   }
   /* adapt weights input:hidden*/
   for(h=0;h<nH;h++)
  {for(i=0;i<nI;i++)
   /*calculate new bias weights for each hidden unit*/
   dw=eta*delta1[p][h];
   w1[h][nI]+=dw;
   }/* calculate new weights*/
   for(j=0;j<M;j++)
    {
     for(h=0;h<nH;h++)
    dw=delta2[p][h]*eta;
    w2[h][nI]+=dw;
     }
     }
   err=sqrt(err/115);
  if(err<0.001)
  { printf("\n Terminate error satisfacory %f",err);
  fclose(efp);
   break;}
   }
 /*sum squared error*/
  /*end of iterminte*/
 fprintf(efp,"\n%d %f ",q,err);
  printf("iteraction stop");
 fclose(efp);}
 /*end learning*/
 /***********************************************************************/
 net_output()
 { int p,j,i,h;
 FILE *net,*fp6;
  if((net=fopen("net-w.dat","w+"))==NULL)
	{printf("\n File can not open");
	exit(0);
	}
   if((fp6=fopen("w.dat","w"))==NULL)
	{printf("\n File can not open");
	exit(0);
	}
  fprintf(net,"%d %d %d %d %f %f %f %d",nI,nH,M,D,eta,alpha,Errorlevel,N);
  fprintf(net,"\n");
  for(p=0;p<D;p++)
   {for(j=0;j<M;j++)
  {fprintf(net,"%f ",targ[p][j]);
  printf("%6.3f",targ[p][j]);
     }
   for(j=0;j<M;j++)
   {fprintf(net," %f ",out2[p][j]);
    printf("%6.3f",out2[p][j]);
    }
    fprintf(net,"\n");
     printf("\n");}
   for(h=0;h<nH;h++)
  {for(i=0;i<nI;i++)
  {fprintf(fp6,"%f ",w1[h][i]);
   printf("%f",w1[h][i]);}
  fprintf(fp6,"\n");
   printf("\n");
     }
   for(j=0;j<M;j++)
  {for(h=0;h<nH;h++)
  {printf("%f\n",w2[j][h]);
   fprintf(fp6,"%f ",w2[j][h]);}
   fprintf(fp6,"\n");
   printf("\n");
   }
   fclose(net);
      }
/**************************************************************/
   net_input()
  {int p,i,j,h;
   FILE *nett;
   if((nett=fopen("net-w.dat","r"))==NULL)
	{printf("\n File can not open");
	exit(0);
	}
   fscanf(nett,"%d %d %d %d %f %f %f %d",nI,nH,M,D,eta,alpha,Errorlevel,N);
  for(p=0;p<D;p++)
  for(j=0;j<M;j++)
  fscanf(nett,"