bpnet.cpp

BP神经网络的C++程序,里面有源程序和生成的可执行文件,希望对正在学习的朋友有用!

  // establish output layer
  node_in_output_layer = new Output_units[nodes_in_output_layer];
  for(nodes = 0; nodes < nodes_in_output_layer; nodes++)
  {
   node_in_output_layer[nodes].number_of_input_units = inputs_to_output_node;
   node_in_output_layer[nodes].establish_array_of_processing_unit_inputs();
   node_in_output_layer[nodes].establish_weight_vector_for_processing_units();
   get_ptr >> node_in_output_layer[nodes].bias;
  }
  for(nodes = 0; nodes < nodes_in_output_layer; nodes++)
  {
   for(dim = 0; dim < inputs_to_output_node; dim++)
   {get_ptr >> node_in_output_layer[nodes].weight_of_inputs[dim];}
  }

  // establish hidden layer(s)
  get_ptr >> number_of_hidden_layers;
  if(number_of_hidden_layers > 0)
  {
    hidden_layer_number = new Hidden_layer[number_of_hidden_layers];
    get_ptr >> activation_function_for_hidden_layer;
    for(hid = 0; hid < number_of_hidden_layers; hid++)
    {
      get_ptr >> hidden_layer_number[hid].nodes_in_hidden_layer;
      nodes = hidden_layer_number[hid].nodes_in_hidden_layer;
      hidden_layer_number[hid].node_in_hidden_layer = new Hidden_units[nodes];

      if(hid == 0) {inputs = signal_dimensions;}
      else
      {inputs = hidden_layer_number[0].nodes_in_hidden_layer;}

      for(nodes = 0; nodes < hidden_layer_number[hid].nodes_in_hidden_layer; nodes++)
      {
	hidden_layer_number[hid].node_in_hidden_layer[nodes].number_of_input_units = inputs;
	hidden_layer_number[hid].node_in_hidden_layer[nodes].establish_array_of_processing_unit_inputs();
	get_ptr >> hidden_layer_number[hid].node_in_hidden_layer[nodes].bias;
      }
      for(nodes = 0; nodes < hidden_layer_number[hid].nodes_in_hidden_layer; nodes++)
      {
	for(dim = 0; dim < inputs; dim++)
	{get_ptr >> hidden_layer_number[hid].node_in_hidden_layer[nodes].weight_of_inputs[dim];}
      }
    }
  }
  get_ptr.close();
}

void Back_Topology::savenet(void)
{
  char savename[13];
  ofstream save_ptr;
  int nodes, dim, inputs, hid;

  cout << "\n\n";
  cout << "Please enter the name of the file that will hold" << "\n";
  cout << "the Backpropagation network:  "; cin >> savename;

  save_ptr.open(savename, ios::out);
  save_ptr << 1 << "\n";   // network identifier number
  save_ptr << signal_dimensions << "\n";
  save_ptr << activation_function_for_output_layer << "\n";
  save_ptr << nodes_in_output_layer << "\n";

  if(number_of_hidden_layers > 0)
  {inputs = hidden_layer_number[number_of_hidden_layers - 1].nodes_in_hidden_layer;}
  else
  {inputs = signal_dimensions;}
  save_ptr << inputs << "\n";
  for(nodes = 0; nodes < nodes_in_output_layer; nodes++)
  {save_ptr << node_in_output_layer[nodes].bias << " ";}
  save_ptr << "\n";


  for(nodes = 0; nodes < nodes_in_output_layer; nodes++)
  {
    for(dim = 0; dim < inputs; dim++)
    {save_ptr << node_in_output_layer[nodes].weight_of_inputs[dim] << " ";}
    save_ptr << "\n";
  }

  save_ptr << number_of_hidden_layers << "\n";

  if(number_of_hidden_layers > 0)
  {
    save_ptr << activation_function_for_hidden_layer << "\n";

    for(hid = 0; hid < number_of_hidden_layers; hid++)
    {
      save_ptr << hidden_layer_number[hid].nodes_in_hidden_layer << "\n";
      if(hid == 0) {inputs = signal_dimensions;}
      else {inputs = hidden_layer_number[0].nodes_in_hidden_layer;}

      for(nodes = 0; nodes < hidden_layer_number[hid].nodes_in_hidden_layer; nodes++)
      {save_ptr << hidden_layer_number[hid].node_in_hidden_layer[nodes].bias << " ";}
      save_ptr << "\n";

      for(nodes = 0; nodes < hidden_layer_number[hid].nodes_in_hidden_layer; nodes++)
      {
	for(dim = 0; dim < inputs; dim++)
	{save_ptr << hidden_layer_number[hid].node_in_hidden_layer[nodes].weight_of_inputs[dim] << " ";}
	save_ptr << "\n";
      }
    }
  }
  save_ptr.close();
}

Back_Topology::~Back_Topology()
{
   delete [] hidden_layer_number;
   delete [] node_in_output_layer;
}

void Back_Topology::establish_activation_functions(void)
{
  int bchoice, count;
  int dolock = 1;

  for(count = 0; count < 2; count++)
  {
    cout << "\n";
    if((count == 0) && (number_of_hidden_layers > 0))
    {cout << "For the nodes in the hidden layer(s):" << "\n";}
    else
    {cout << "For the output layer:" << "\n";}
    do
    {
      cout << "please select the type of activation function you wish the nodes to use" << "\n\n";
      cout << "1.  Binary Sigmoid Function " << "\n";
      cout << "2.  Bipolar Sigmoid Function " << "\n\n";
      cout << "Your Selection "; cin >> bchoice;
      cout << "\n\n";
      if((bchoice == 1) || (bchoice == 2)) {dolock = 0;}
    } while(dolock >= 1);

    if((count == 0) && (number_of_hidden_layers > 0))
    {activation_function_for_hidden_layer = bchoice;}
    else
    {activation_function_for_output_layer = bchoice;}
  }
}

sample_data:: ~sample_data()
{delete [] data_in_sample;}


Data_type::~Data_type()
{
  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();
  sample_number = int(sample_number / (signal_dimensions + nodes_in_output_layer));
}

void Data_type::specify_signal_sample_size(void)
{
  char tchoice;
  int dolock = 1;
  do
  {
    cout <<"\n";
    cout << "Please select the number of samples you wish to use" << "\n\n";
    cout << "	A.  All samples in the file" << "\n";
    cout << "	S.  Specific number of samples"<< "\n\n";
    cout << "	Your Selection: "; cin >> tchoice;
    cout << "\n\n";
    tchoice = toupper(tchoice);
    if((tchoice == 'A') || (tchoice == 'S')) {dolock = 0;}
  } while(dolock >= 1);
  cout <<"\n";
  if(tchoice == 'A') {determine_sample_number();}
  else
  {
    cout << "\n";
    cout << "please enter the number of testing samples you wish to use: ";
    cin >> sample_number;
    cout << "\n";
  }
  load_data_into_array();
}

void Data_type::normalize_data_in_array(void)
{
  int imax, imin, trigger;
  float min, max, rmax, rmin;
  int total_dimension = signal_dimensions + nodes_in_output_layer;
  int i, j;
  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)))
	{
	  min_output_value[j - (total_dimension - nodes_in_output_layer)] = min;
	  max_output_value[j - (total_dimension - nodes_in_output_layer)] = max;
	}
      }
      else
      {
	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))
	  {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))
	  {max_output_value[j - (total_dimension - nodes_in_output_layer)] = max;}
	}
      }
    }

    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);}
   }
  }
}

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];

  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];}

  int dimensions = signal_dimensions + nodes_in_output_layer;

  //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];}
  }
  file_ptr.close();
  cout << "\n";
}

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


Training::~Training()
{
  delete [] signalpoint;
  delete [] max_output_value;
  delete [] min_output_value;
}


void Training::request_training_data(int net_no)
{
  cout << "Please enter the file name containing the training data for neural net no. "<< net_no << "\n";
  cin >> filename;
  specify_signal_sample_size();
  signalpoint = new signal_data[sample_number];
  for(int i = 0; i < sample_number; i++) {signalpoint[i].signal_value = i;}
  normalize_data_in_array();
}

void Training::scramble_data_in_array(void)
{
  int swap1, swap2, hold_sample;
  float hold_rank;

  // randomly assign rank to all signals
  for(int sig = 0; sig < sample_number; sig ++)
  {signalpoint[sig].signal_rank = bedlam((long*)(&gaset));}

  // reorder signals according to rank
  for(swap1 = 0; swap1 < sample_number - 1; swap1++)
  {
    for(swap2 = swap1 + 1; swap2 < sample_number; swap2++)
    {
      if(signalpoint[swap1].signal_rank > signalpoint[swap2].signal_rank)
      {
	hold_sample = signalpoint[swap2].signal_value;
	hold_rank = signalpoint[swap2].signal_rank;
	signalpoint[swap2].signal_value = signalpoint[swap1].signal_value;
	signalpoint[swap2].signal_rank = signalpoint[swap1].signal_rank;
	signalpoint[swap1].signal_value = hold_sample;
	signalpoint[swap1].signal_rank = hold_rank;
      }
    }
  }
}

void Training::delete_signal_data_array(void)
{
  delete [] signalpoint;
  delete_signal_array();
}

void Testing::request_testing_data(int net_no, int test)
{
  cout << "Please enter the file name containing the testing data for neural net no. "<< net_no << "\n\n";
  cin >> filename;
  cout << "\n\n";
  cout << "For test #" << test + 1  << ":";
  cout << "\n\n";
  specify_signal_sample_size();
  normalize_data_in_array();
}


//************************************************************************//

// these Neural class member function transmits data from the topology
// to the data storage arrays

NeuralB:: ~NeuralB()
{delete [] Test_Data;}

void NeuralB :: initialize_training_storage_array(int N)
{
   Training_Data.acquire_net_info(Net_Design.signal_dimensions, Net_Design.nodes_in_output_layer);
   Training_Data.request_training_data(N);
}