nn2.cpp

神经网络程序

  for (i=1; i<=Upper->Units; i++) {
    Sum = 0;
    for (j=0; j<=Lower->Units; j++) {
      Sum += Upper->Weight[i][j] * Lower->Output[j];
    }
/******************************************************************************
*   The sigmoid function needs to be changed 
******************************************************************************/    
//	Upper->Output[i] = 1 / (1 + exp(-Net->Gain * Sum));
	Upper->Output[i] = Sum;
  }
}


void PropagateNet(NET* Net)
{
  INT l;
/******************************************************************************
 *The function first should compute input layer and first hide layer ,there may be
 * lost some layer.
 ******************************************************************************/  
  for (l=0; l<NUM_LAYERS-1; l++) {
    PropagateLayer(Net, Net->Layer[l], Net->Layer[l+1]);
  }
}


/******************************************************************************
                  B A C K P R O P A G A T I N G   E R R O R S
 ******************************************************************************/


void ComputeOutputError(NET* Net, REAL Target)
{
  INT  i;
  REAL Out, Err;
   
  Net->Error = 0;
  for (i=1; i<=Net->OutputLayer->Units; i++) {
    Out = Net->OutputLayer->Output[i];
    Err = Target-Out;
/*******************************************************************************
 *  the delta and the Error is need to be changed 
 *******************************************************************************/
    Net->OutputLayer->Error[i] = Net->Gain * Err;
    Net->Error += 0.5 * sqr(Err);
  }
}


void BackpropagateLayer(NET* Net, LAYER* Upper, LAYER* Lower)
{
  INT  i,j;
  REAL Out, Err;
   
  for (i=1; i<=Lower->Units; i++) {
    Out = Lower->Output[i];
    Err = 0;
    for (j=1; j<=Upper->Units; j++) {
      Err += Upper->Weight[j][i] * Upper->Error[j];
    }
    Lower->Error[i] = Net->Gain * Err;
	//for lower error was computed need upper's error. 
  }
}


void BackpropagateNet(NET* Net)
{
  INT l;
   
  for (l=NUM_LAYERS-1; l>1; l--) {
    BackpropagateLayer(Net, Net->Layer[l], Net->Layer[l-1]);
  }
}


void AdjustWeights(NET* Net)
{
  INT  l,i,j;
  REAL Out, Err, dWeight;
   
  for (l=1; l<NUM_LAYERS; l++) {
    for (i=1; i<=Net->Layer[l]->Units; i++) {
      for (j=0; j<=Net->Layer[l-1]->Units; j++) {
        Out = Net->Layer[l-1]->Output[j];
        Err = Net->Layer[l]->Error[i];
 /***************************************************************************
 *  the arithmetic may be improvement of original arithmetic
 ***************************************************************************/
		dWeight = Net->Layer[l]->dWeight[i][j];
        Net->Layer[l]->Weight[i][j] += Net->Eta * Err * Out + Net->Alpha * dWeight;
        Net->Layer[l]->dWeight[i][j] = Net->Eta * Err * Out ;
	  }
    }
  }
}


/******************************************************************************
                      S I M U L A T I N G   T H E   N E T
 ******************************************************************************/


void SimulateNet(NET* Net, REAL* Input, REAL* Output, REAL* Target, BOOL Training)
{
  SetInput(Net, Input);
  PropagateNet(Net);
  GetOutput(Net, Output);
   
  ComputeOutputError(Net, *Target);
  if (Training) {
    BackpropagateNet(Net);
    AdjustWeights(Net);
  }
}
/**********************************************************************************
* the Epochs is sign of whether input_signal 
**********************************************************************************/

void TrainNet(NET* Net, INT Epochs,double desired_signal)
{
  INT   n;
  REAL Output[M];
  srand( ( unsigned ) time( NULL ));
  seed = rand() ;
  for (n=0; n < signal_lengh; n++) {
    makeNoise( input_signal,seed);
	if (Epochs==1)// the condition of inputing noise
	{
      for( int i = 0; i < N ; i++ )
      {
        input_signal[i]+=sin_data[n];
	  }   
	}
    SimulateNet(Net, input_signal, Output, &desired_signal, TRUE);
  }
}


void TestNet(NET* Net, BOOL addSignal, double desired_signal)
{
  INT  i=0;
  REAL Output[M];

  TrainError = 0;
  srand( (unsigned)time( NULL ) );
  seed = rand() ;
  for (int n = 0 ; n < signal_lengh ; n++ ) {
    makeNoise( input_signal ,seed ); 
    if ( addSignal == TRUE )  // the condition of inputing noise
	{
       for ( int i = 0 ; i < N ;i++ )
       {
          input_signal[i] += sin_data[n];
	   }   
	}
    SimulateNet( Net, input_signal, Output, &desired_signal, FALSE );
    TrainError += Net->Error;
  }
//   TrainError = Net->Error/TrainError;
//   TestError = 0;
//   for (Year=TEST_LWB; Year<=TEST_UPB; Year++) {
//   SimulateNet(Net, &(Sunspots[Year-N]), Output, &(Sunspots[Year]), FALSE);
//   TestError += Net->Error;
  
//   fprintf(f, "\nNMSE is %0.3f on Training Set and %0.3f on Test Set",
//             TrainError / TrainErrorPredictingMean,
//             TestError / TestErrorPredictingMean);
}


void EvaluateNet(NET* Net, double * output, BOOL sig)
{
  INT  i,j;
  double output_signal[M]  ;
  if (sig == FALSE)
  {
    saveSignal_1 = fopen("saveSignal_1.txt", "w");
    saveOut_1= fopen("saveOut_1.txt","w");
  }
  else
  { 
    saveSignal_2 = fopen("saveSignal_2.txt", "w");
	saveSignal_3 = fopen("saveSignal_3.txt", "w");
    saveOut_2= fopen("saveOut_2.txt","w");
  }
  srand( (unsigned)time( NULL ) );
  seed = rand() ; 
  
  for (i = 0; i<signal_lengh; i++) 
  {
	  
	  makeNoise( input_signal,seed);
	 
	 if ( sig == TRUE )// the condition of inputing noise
	 {
       for ( j = 0 ; j < N ; j ++ )
	   {
          input_signal[j] += (sin_data[i]/100);
	   }   
	 } 
     if (sig == FALSE)
     {
        for ( j = 0 ; j < N ; j++ )
        {
           fprintf(saveSignal_1 , "%f\n",input_signal[j]);
		}
	 }
	 else
	 {
         fprintf(saveSignal_3 , "%f\n",input_signal[2])	 ;   
		 for ( j = 0 ; j < N ; j++ )
        {
  // the way of output have been changed ;          
			fprintf(saveSignal_2 , "%f\n",input_signal[j]);
		}
	    
	 }
	 SimulateNet(Net, input_signal, output_signal,  &desired_signal[0], FALSE);
	 fprintf(f,"%f",output_signal[0]);
     
	 if (sig == FALSE)
     {
       fprintf(saveOut_1, "%f\n",output_signal[0]);
	 }
	 else
	 {
	   fprintf(saveOut_2, "%f\n",output_signal[0]);
	 }
   }
   
  if(sig == FALSE)
   { 
	   fclose(saveSignal_1);
       fclose(saveOut_1);
   } 
   else
   {
	   fclose(saveSignal_2);
	   fclose(saveSignal_3);
       fclose(saveOut_2);
   }
}


/******************************************************************************
                                    M A I N
 ******************************************************************************/
// the loops have also problem;
void estimate_signal(NET* Net)
{
   REAL s = 0;
   REAL B = 0;
   REAL D = 0;
   int  i=0,j=0,k=0;
   if((saveOut_1 = fopen("saveOut_1.txt","r"))==NULL)
      printf("the openning faile\n");
   saveOut_2 = fopen("saveOut_2.txt","r");
//   saveSignal_1 = fopen("saveSignal_1.txt","r");
   saveSignal_2 = fopen("saveSignal_2.txt","r");
   FILE * final_out = fopen("finalout.txt","w");

   float output[1];
   float output_[1];
 
   
/*****************************************************************************
* C
******************************************************************************/   
   for (j=1;j<=Net->Layer[NUM_LAYERS-2]->Units;j++)
   {
      for (i=0;i<Net->Layer[NUM_LAYERS-3]->Units;i++)
      {
         B+=(Net->Layer[NUM_LAYERS-1]->WeightSave_1[1][j-1])
			*(Net->Layer[NUM_LAYERS-2]->WeightSave_1[j][i]);
	  }
   }
/**********************************************************
*  D  
**********************************************************/
   for(k = 0; k< signal_lengh; k++)
   {
  /*   D = 0.0 ;
	 s = 0.0 ;
	 for ( i = 0 ; i<Net->Layer[NUM_LAYERS-3]->Units ; i++ )
     {
        fscanf(saveSignal_2,"%f", (input+i));
	 }
	 for (j=1;j<=Net->Layer[NUM_LAYERS-2]->Units;j++)
	 {
        for (i=0;i<Net->Layer[NUM_LAYERS-3]->Units;i++)
		{
//        fscanf(saveSignal_2,"%f", input);
		  D+=Net->Layer[NUM_LAYERS-1]->WeightSave_1[1][j-1]*(Net->Layer[NUM_LAYERS-2]->WeightSave_2[j][i]
			  -Net->Layer[NUM_LAYERS-2]->WeightSave_1[j][i])*input[i];
		  D+=(Net->Layer[NUM_LAYERS-1]->WeightSave_2[1][j-1]-Net->Layer[NUM_LAYERS-1]->WeightSave_1[1][j-1])
			  *(Net->Layer[NUM_LAYERS-2]->WeightSave_2[j][i])*input[i];
		}
	 }

*/


/**********************************************************************
*  s(k) =(1/C)*(y_-y_D)
**********************************************************************/
	 fscanf(saveOut_1,"%f",output);
	 fscanf(saveOut_2,"%f",output_);
	 s = (1/B)*(output_[0]-output[0]);
	 fprintf(final_out,"%f\n",s);
   }
   fclose( saveOut_1 );
   fclose( saveOut_2 ) ;
   fclose(saveSignal_1);
   fclose(saveSignal_2);

}

void main()
{
  NET  Net;            // the struct used to store information about net
  BOOL Stop;
  REAL MinTestError;

  InitializeRandoms();
  GenerateNetwork(&Net);
  RandomWeights(&Net);
/********************************************************************
*  This function needs to be changed for detected signal  
********************************************************************/
  InitializeApplication(&Net);
  EW =fopen("ew.txt","w");
  Stop = FALSE;
  MinTestError = MAX_REAL;
 /***********************************************************************************
  *  the condition of convergence needs to be changed by Guo
  ***********************************************************************************/
 /*************************************************************************************
 *  train the net less the sin signal
 **************************************************************************************/
  REAL lastError = 1 ;
  REAL ErrorRate = 0.0 ;
  int m = 0 ;
  do {
    TrainNet(&Net, 0,desired_signal[0] );
    TestNet(&Net,FALSE,desired_signal[0] );
    if (m==0)
	{
	   lastError = TrainError;
	}
	ErrorRate = (TrainError)/(lastError);//+TrainError);
	
	
    if (ErrorRate > 0.0001||ErrorRate < -0.0001) {
//    fprintf(f, " - saving Weights ...");
      MinTestError = TestError;
      SaveWeights(&Net);
    m++;
	fprintf(EW,"%f\n",ErrorRate );
	printf("the number of loop is %d the ErrorRate%4.3f\n",m,ErrorRate);
	}
    else {
      fprintf(f, " - stopping Training and restoring Weights ...");
      Stop = TRUE;
      RestoreWeights(&Net);
	  RestoreWeights_1(&Net);
    }
  } while (NOT Stop);
   
   out_signal = (REAL *) calloc(signal_lengh, sizeof(REAL));
   /***********************************************************************************
   * There are out signal in EvaluateNet function
   ************************************************************************************/
   EvaluateNet(&Net,out_signal,FALSE);
   
  EvaluateNet(&Net,out_signal_,TRUE);

  
   estimate_signal(&Net);
  
/************************************************************************************
 * close file
 ************************************************************************************/   
  fclose(EW);
  FinalizeApplication(&Net);
  scanf("%d",&m);
}

int  makeNoise( double noise[signal_lengh],long int &seed)
{

	
	for(int i=0; i<N;i++)
	{
	  
	   noise[i] = uniform(0,1, seed);
	}
    for (i=0;i<N;i+=2)
    {
      gauss( noise[i], noise[i+1]);
	}


    return 0;
}

double uniform(int a,int b, long int &seed)
{
   double t;
   seed = 2045*(seed)+1;
   seed = seed -(seed/1048576)*1048576;
   t = seed/1048576.0;
   t= a+(b-a)*t;
   return(t);
}

void  gauss(double &uniform1, double &uniform2)
{
   double result1=0.0,result2 =0.0;
   result1 = sqrt(-2*log(uniform1))*sin(2*pi*uniform2);
   result2 = sqrt(-2*log(uniform1))*cos(2*pi*uniform2);
   uniform1 = result1;
   uniform2 = result2;
}