bpnet.cpp

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

  for(int c = 1; c < number_of_inputs; c++)
  {input_value[c] = 0.0;}
  activation = 0.0;
}


void Interface_units::recompute_activation(int winning_cluster)
{activation = input_value[0] * input_weight_vector[winning_cluster];}

void Interface_units::calculate_output_value(int G1)
{
 float feedback_signal, node_output, two_thirds_rule;
 feedback_signal = 0.0;
 // calculate feedback signal through use of weighted sum
 for(int f = 0; f < number_of_inputs-1; f++)
 {feedback_signal+=input_weight_vector[f]*input_value[f+1];}

 two_thirds_rule = feedback_signal + input_value[0] + float(G1);

 // use Two Thirds Rule to determine node output
 if(two_thirds_rule >= 2.0) {node_output = 1.0;} else {node_output = 0.0;}

 // establish output vector to cluster units
 for(int p = 0; p < number_of_outputs; p++)
 {output_value[p] = node_output;}
}

Cluster_units::Cluster_units()
{cluster_tag = 0;}

void Cluster_units::establish_input_weight_vector_array(void)
{input_weight_vector = new float[number_of_inputs];}

void Cluster_units::initialize_inputs_and_weights(void)
{
  for(int c = 0; c < number_of_inputs; c++)
  {input_weight_vector[c] = 1.0 / (1.0 + number_of_inputs);}
}

void Cluster_units::calculate_net_input(void)
{
  net_input = 0.0;
  for(int n = 0; n < number_of_inputs; n++)
  {net_input += input_value[n] * input_weight_vector[n];}
}

void Cluster_units::establish_node_output(void)
{
 for(int oput = 0; oput < number_of_outputs - 1; oput++)
 if(activation >= 0.0)
 {output_value[oput] = activation;}
 else
 {output_value[oput] = 0.0;}
}


ART_Topology::ART_Topology()
{
 clustercount = 0;
 clusterange = 0;
 resetcount = 0;
}

ART_Topology::~ART_Topology()
{
  delete [] node_in_input_layer;
  delete [] node_in_interface_layer;
  delete [] node_in_cluster_layer;
}

void ART_Topology::establish_net_topology(void)
{
  weight_update_parameter = 2.0;
  node_in_input_layer = new Input_units[dimensions_of_signal];
  node_in_interface_layer = new Interface_units[dimensions_of_signal];
  node_in_cluster_layer = new Cluster_units[number_of_cluster_units];

  // Establish interface layer of ART1 network
  for(int I = 0; I < dimensions_of_signal; I++)
  {
    node_in_interface_layer[I].number_of_inputs = number_of_cluster_units + 1;
    node_in_interface_layer[I].number_of_outputs = number_of_cluster_units;
    node_in_interface_layer[I].establish_input_output_arrays();
    node_in_interface_layer[I].establish_input_weight_vector_array();
    node_in_interface_layer[I].initialize_inputs_and_weights();
  }

  // Establish cluster layer of ART1 network
  for(int C = 0; C < number_of_cluster_units; C++)
  {
    node_in_cluster_layer[C].number_of_inputs = dimensions_of_signal;
    node_in_cluster_layer[C].number_of_outputs = dimensions_of_signal + 1;
    node_in_cluster_layer[C].establish_input_output_arrays();
    node_in_cluster_layer[C].establish_input_weight_vector_array();
    node_in_cluster_layer[C].initialize_inputs_and_weights();
  }

}

void ART_Topology::upload_network(void)
{
  char getname[13];
  ifstream get_ptr;
  int netid, node, dim;
  int dolock = 0;

  do
  {
    cout << "\n\n";
    cout << "Please enter the name of the file which holds the ART1 Network" << "\n";
    cin >> getname; cout << "\n";
    get_ptr.open(getname, ios::in);
    get_ptr >> netid;
    if(netid == 2) {dolock = 1;}
    else
    {
      cout << "Error** file contents do not match ART1 specifications" << "\n";
      cout << "try again" << "\n";
      get_ptr.close();
    }
  } while(dolock <= 0);

  get_ptr >> dimensions_of_signal;
  get_ptr >> weight_update_parameter;
  get_ptr >> vigilance_parameter;
  get_ptr >> clusterange;
  get_ptr >> clustercount;
  get_ptr >> number_of_cluster_units;

  node_in_input_layer = new Input_units[dimensions_of_signal];
  node_in_interface_layer = new Interface_units[dimensions_of_signal];
  node_in_cluster_layer = new Cluster_units[number_of_cluster_units];

  for(node = 0; node < dimensions_of_signal; node++)
  {
    node_in_interface_layer[node].number_of_inputs = number_of_cluster_units + 1;
    node_in_interface_layer[node].number_of_outputs = number_of_cluster_units;
    node_in_interface_layer[node].establish_input_output_arrays();
    node_in_interface_layer[node].establish_input_weight_vector_array();
    node_in_interface_layer[node].initialize_inputs_and_weights();
    for(dim = 1; dim < number_of_cluster_units + 1; dim++)
    {get_ptr >> node_in_interface_layer[node].input_weight_vector[dim];}
  }

  for(node = 0; node < number_of_cluster_units; node++)
  {
    node_in_cluster_layer[node].number_of_inputs = dimensions_of_signal;
    node_in_cluster_layer[node].number_of_outputs = dimensions_of_signal + 1;
    node_in_cluster_layer[node].establish_input_output_arrays();
    node_in_cluster_layer[node].establish_input_weight_vector_array();
    node_in_cluster_layer[node].initialize_inputs_and_weights();
    get_ptr >> node_in_cluster_layer[node].cluster_tag;
    for(dim = 0; dim < dimensions_of_signal; dim++)
    {get_ptr >> node_in_cluster_layer[node].input_weight_vector[dim];}
  }
  get_ptr.close();
}

void ART_Topology::transmit_pattern_to_interface(void)
{
  for(int d = 0; d < dimensions_of_signal; d++)
  {
    node_in_interface_layer[d].input_value[0] = node_in_input_layer[d].signal_value;
    node_in_interface_layer[d].activation = node_in_input_layer[d].signal_value;
  }
}

void ART_Topology::transmit_pattern_to_cluster(void)
{
   int c;
   for(int d = 0; d < dimensions_of_signal; d++)
   {
     for(c = 0; c < number_of_cluster_units; c++)
     {node_in_cluster_layer[c].input_value[d] = node_in_input_layer[d].signal_value;}
   }
}

void ART_Topology::broadcast_output_to_cluster_layer(void)
{
  int Gain_one;
  int cluster_active = 0;
  int d, c;
  for(c = 0; c < number_of_cluster_units; c++)
  {if(node_in_cluster_layer[c].activation == 1.0) {cluster_active = 1;} }
  compute_norm_of_input_vector();

  if((cluster_active != 1) && (norm_of_input_vector > 0.0))
  {Gain_one = 1;} else {Gain_one = 0;}

  // establish interface output vector
  for(d = 0; d < dimensions_of_signal; d++)
  {node_in_interface_layer[d].calculate_output_value(Gain_one);}

  //transmit interface output to units in cluster layer
  for(d = 0; d < dimensions_of_signal; d++)
  {
    for(c = 0; c < number_of_cluster_units; c++)
    {node_in_cluster_layer[c].input_value[d] = node_in_interface_layer[d].output_value[c];}
  }
}

void ART_Topology::cluster_nodes_compete_for_activation(int train_or_test)
{
  int d, cluster;
  float champion = 0.0;

  for(cluster = 0; cluster < clusterange + 1; cluster++)
  {
    if(node_in_cluster_layer[cluster].activation != -1.0)
    {
      node_in_cluster_layer[cluster].calculate_net_input();
      if(node_in_cluster_layer[cluster].net_input > champion)
      {
	champion = node_in_cluster_layer[cluster].net_input;
	cluster_champ = cluster;
      }
    }
  }
    if((node_in_cluster_layer[cluster_champ].cluster_tag == 0) && (train_or_test < 2))
    {
      node_in_cluster_layer[cluster_champ].cluster_tag = clustercount + 1;
      clustercount = clustercount + 1;
    }

  if(train_or_test < 2)
  {

    for(cluster = 0; cluster < clusterange + 1; cluster++)
    {
      if(cluster == cluster_champ)
      {node_in_cluster_layer[cluster].activation = 1.0;}
      else
      {
	if(node_in_cluster_layer[cluster].activation != -1.0)
	{node_in_cluster_layer[cluster].activation = 0.0;}
      }
      node_in_cluster_layer[cluster].establish_node_output();

      // send output signals to Interface layer
      for(d = 0; d < dimensions_of_signal; d++)
      {node_in_interface_layer[d].input_value[cluster + 1] = node_in_cluster_layer[cluster].output_value[d];}
    }
  }
}

void ART_Topology::compute_norm_of_activation_vector(void)
{
  norm_of_activation_vector = 0.0;
  for(int d = 0; d < dimensions_of_signal; d++)
  {norm_of_activation_vector += node_in_interface_layer[d].activation;}
  compute_norm_of_input_vector();
}

void ART_Topology::compute_norm_of_input_vector(void)
{
  norm_of_input_vector = 0.0;
  for(int d = 0; d < dimensions_of_signal; d++)
  {norm_of_input_vector += node_in_input_layer[d].signal_value;}
}

void ART_Topology::recompute_activation_vector_of_interface_layer(void)
{
  for(int d = 0; d < dimensions_of_signal; d++)
  {node_in_interface_layer[d].recompute_activation(cluster_champ);}
}

void ART_Topology:: update_the_network(void)
{
  recompute_activation_vector_of_interface_layer();
  compute_norm_of_activation_vector();
  float ratio_test = norm_of_activation_vector / norm_of_input_vector;

  if(ratio_test < vigilance_parameter)
  {
   node_in_cluster_layer[cluster_champ].activation = -1.0;
   reset_value = 1;
   resetcount += reset_value;
   if(resetcount == number_of_cluster_units - 1)
   {
     clusterange = clusterange + 1;
     if(clusterange > number_of_cluster_units)
     {clusterange = number_of_cluster_units;}
   }
  }
  else
  {
    // update the weights of the champion cluster unit
    for(int u = 0; u < node_in_cluster_layer[cluster_champ].number_of_inputs; u++)
    {node_in_cluster_layer[cluster_champ].input_weight_vector[u] = (weight_update_parameter * node_in_interface_layer[u].activation * node_in_cluster_layer[cluster_champ].input_weight_vector[u]) / ((weight_update_parameter - 1.0) + norm_of_activation_vector);}
    for(int n = 0; n < dimensions_of_signal; n++)
    {node_in_interface_layer[n].input_weight_vector[cluster_champ] = node_in_interface_layer[n].input_weight_vector[cluster_champ] * node_in_interface_layer[n].activation;}

    reset_value = 0;
    resetcount = 0;
  }
}

void ART_Topology::set_cluster_activation_to_zero(void)
{
   for(int cnode = 0; cnode < clusterange + 1; cnode++)
   {node_in_cluster_layer[cnode].activation = 0.0;}
}

void ART_Topology::savenet(void)
{
  char savename[13];
  ofstream save_ptr;
  int node, dim;

  cout << "\n\n";
  cout << "Please enter the name of the file which will hold the ART network"<<"\n";
  cin >> savename; cout <<"\n";
  save_ptr.open(savename, ios::out);

  save_ptr << 2 << "\n";  //network identifier number
  save_ptr << dimensions_of_signal << "\n";
  save_ptr << weight_update_parameter << "\n";
  save_ptr << vigilance_parameter << "\n";
  save_ptr << clusterange << "\n";
  save_ptr << clustercount << "\n";
  save_ptr << number_of_cluster_units << "\n";

  for(node = 0; node < dimensions_of_signal; node++)
  {
    for(dim = 1; dim < number_of_cluster_units + 1; dim++)
    {save_ptr << node_in_interface_layer[node].input_weight_vector[dim] << " ";}
    save_ptr << "\n";
  }

  for(node = 0; node < number_of_cluster_units; node++)
  {
    save_ptr << node_in_cluster_layer[node].cluster_tag << "\n";
    for(dim = 0; dim < dimensions_of_signal; dim++)
    {save_ptr << node_in_cluster_layer[node].input_weight_vector[dim] << " ";}
    save_ptr << "\n";
  }
  save_ptr.close();
}


void ART_Training_Data::load_data_into_array(void)
{
   int d, i;
   float dimensions;

   // open the file containing the data
   ifstream Afile_ptr; // pointer to a file
   Afile_ptr.open(filename, ios::in);
   //create a dynamic array to hold the specified number of samples
   number_of_samples = new sample_data[sample_number];

   for(i = 0; i < sample_number; i++)
   {number_of_samples[i].data_in_sample = new float[signal_dimensions];}

   // read in data from file and place in array
   for(i = 0; i < sample_number; i++)
   {
     for(d = 0; d < signal_dimensions; d++)
     {
	Afile_ptr >> dimensions;
	number_of_samples[i].data_in_sample[d] = dimensions;
     }
   }
    Afile_ptr.close();
}

void ART_Training_Data :: 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;}