data_type.cpp

预测神经网络

// Data_type.cpp: implementation of the Data_type class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Data_type.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
Data_type::Data_type()
{useAllsample=true;
realtesting=false;
inferencing=false;
}
Data_type::~Data_type()
{if (!realtesting&&!inferencing) 
{delete [] max_output_value;
delete [] min_output_value;
}
  
}

// define functions of Data_type Class
void Data_type :: determine_sample_number(void)
{
  ifstream dfile_ptr; // pointer to a file
  dfile_ptr.open(filename, ios::in);

  float hold;
  int lock = 1;
  sample_number = 0;

  do
  {
    if(dfile_ptr.eof()){lock = 0;}
    else
    {dfile_ptr >> hold;  sample_number += 1;}
  }while(lock > 0);

  dfile_ptr.close();
  if (!inferencing) 
  sample_number 
  = int(floor(sample_number / (signal_dimensions + nodes_in_output_layer)));
  else 
	  sample_number =
	  int(floor(sample_number / signal_dimensions));
	  
}

void Data_type::specify_signal_sample_size(void)
{
	if (useAllsample)
	{ determine_sample_number();
	}

  
  load_data_into_array();
}

void Data_type::normalize_data_in_array(void)
{pNormalizeInfo=new CNormalizeInfo(signal_dimensions,nodes_in_output_layer);
  int imax, imin, trigger;
  float min, max, rmax, rmin;
  int total_dimension;
  if (realtesting||inferencing) total_dimension = signal_dimensions;
  else total_dimension = signal_dimensions + nodes_in_output_layer;
     
  int i, j;
  if (!realtesting&&!inferencing) 
  {
	  max_output_value = new float[nodes_in_output_layer];
       min_output_value = new float[nodes_in_output_layer];
  }
  

  for(j = 0; j < total_dimension; j++)
  {
    trigger = 1;
    // identify the minimum and maximum values for each dimension
    for(i = 0; i < sample_number; i++)
    {
      if(i == 0)
      {
	      max = number_of_samples[i].data_in_sample[j];
	      min = number_of_samples[i].data_in_sample[j];
	       if((j >= (total_dimension - nodes_in_output_layer)))
		   {  
		      if (!realtesting&&!inferencing) 
			  {
			    min_output_value[j - (total_dimension - nodes_in_output_layer)] = min;
	            max_output_value[j - (total_dimension - nodes_in_output_layer)] = max;
			  }
	  
		   }
      }

	  
      else// i>0
      {
	       if(number_of_samples[i].data_in_sample[j] < min)
		   {
	           min = number_of_samples[i].data_in_sample[j];
	             if(j >= (total_dimension - nodes_in_output_layer))
				 {     
		            if (!realtesting) 
					{
						min_output_value[j - (total_dimension - nodes_in_output_layer)] = min;
					}
				 }
		   }

	      if(number_of_samples[i].data_in_sample[j] > max)
		  {
	       max = number_of_samples[i].data_in_sample[j];
	       if(j >= (total_dimension - nodes_in_output_layer))
		   {
		    if (!realtesting&&!inferencing) 
			{
			   max_output_value[j - (total_dimension - nodes_in_output_layer)] = max;
			}
		   }
		  }
	  }//end else
   }//end sample number loop

      if (!realtesting&&!inferencing)
	  {
		  if (j >= (total_dimension - nodes_in_output_layer)) 
		 {
		  imax = int(max_output_value[j - (total_dimension - nodes_in_output_layer)]);
          imin = int(min_output_value[j - (total_dimension - nodes_in_output_layer)]);
          rmax = max_output_value[j - (total_dimension - nodes_in_output_layer)];
          rmin = min_output_value[j - (total_dimension - nodes_in_output_layer)];
  
            if((imax == 1) && (imin == 0) && (rmax <= 1.0) && (rmin <= 0.0))
			{trigger = 0;}
  
            if((imax == 1) && (imin == 1) && (rmax <= 1.0) && (rmin <= 1.0))
		   {trigger = 0;}
  
            if((imax == 0) && (imin == 0) && (rmax <= 0.0) && (rmin <= 0.0))
			{trigger = 0;}
		  }  
	  }

    // normalize the values in each dimension of the signal
   if(trigger != 0)
   {
    for(i = 0; i < sample_number; i++)
    {
		number_of_samples[i].data_in_sample[j] =
			(number_of_samples[i].data_in_sample[j] - min) / (max - min);
		TRACE("input%f\n",number_of_samples[i].data_in_sample[j]);

	}
   }//保存测试样本的归一化信息
   //if (realtesting||inferencing) 
	   putNormalizeInfo(j,(max - min),min );
  }//end j loop

}

void Data_type :: acquire_net_info(int signal, int no_output_nodes)
{
  signal_dimensions = signal;
  nodes_in_output_layer = no_output_nodes;
  
}


void Data_type :: load_data_into_array(void)
{
  // open the file containing the data
  ifstream file_ptr;  // pointer to a file
  int i;
  file_ptr.open(filename, ios::in);

  // create dynamic array to hold the specified number of samples
  number_of_samples = new sample_data[sample_number];
  if (realtesting) realTargetoutput= new sample_data[sample_number];
  
  for(i = 0; i < sample_number; i++)
  // create a dynamic array to hold the dimensions of each signal
  {
	  number_of_samples[i].data_in_sample = 
		  new float[signal_dimensions + nodes_in_output_layer];
	 if(realtesting)realTargetoutput[i].data_in_sample = 
		 new float[signal_dimensions + nodes_in_output_layer];
  }

  int dimensions;
  if(!inferencing)dimensions= signal_dimensions + nodes_in_output_layer;
  else dimensions= signal_dimensions;
	  
  //read in data from file and place in array
  for(i = 0; i < sample_number; i++)
  {
    for(int j = 0; j < dimensions; j++)
    {
		file_ptr >> number_of_samples[i].data_in_sample[j];
		//记录归一化前的样本数据
	
	if(realtesting)	realTargetoutput[i].data_in_sample[j]=number_of_samples[i].data_in_sample[j];
		//TRACE("%f\n",number_of_samples[i].data_in_sample[j]);
		
	}
  }
  file_ptr.close();

}

void Data_type::delete_signal_array(void)
{delete [] number_of_samples;}



void Data_type::putNormalizeInfo(int dim,float Max_min,float min)
{
pNormalizeInfo->pCoAnti[dim].Max_min=Max_min;
pNormalizeInfo->pCoAnti[dim].min=min;
}

void Data_type::gainCoAnti()
{
	pNormalizeInfo=new CNormalizeInfo(signal_dimensions,nodes_in_output_layer);
	float max,min;
	int total_dimension=signal_dimensions;;
    int i, j;
	for(j = 0; j < total_dimension; j++)
	{
		
		// identify the minimum and maximum values for each dimension
		for(i = 0; i < sample_number; i++)
		{
			if(i == 0)
			{
				max = number_of_samples[i].data_in_sample[j];
				min = number_of_samples[i].data_in_sample[j];
			}
			
			
			else// i>0
			{
				if(number_of_samples[i].data_in_sample[j] < min)
				{
					min = number_of_samples[i].data_in_sample[j];
				}
				
				if(number_of_samples[i].data_in_sample[j] > max)
				{
					max = number_of_samples[i].data_in_sample[j];
				}
			}//end else
		}//end sample number loop
		putNormalizeInfo(j,(max - min),min );//保存测试样本的归一化信息
	}//end j loop
}