pittnet.cpp

神经网络c++源程序

	}
      }
      for(outnode = 0; outnode < Net_Design.nodes_in_output_layer; outnode++)
      {
	Net_Design.node_in_output_layer[outnode].calculate_output_signal(Net_Design.activation_function_for_output_layer);
	Net_Design.node_in_output_layer[outnode].calculate_output_error_information_term(Test_Data[t].number_of_samples[sig].data_in_sample[Test_Data[t].signal_dimensions + outnode], Net_Design.activation_function_for_output_layer);
      }

       // convert normalized target output data and send to file
      for(outnode = 0; outnode < Net_Design.nodes_in_output_layer; outnode++)
      {
	     real_output = Test_Data[t].min_output_value[outnode] + (Test_Data[t].number_of_samples[sig].data_in_sample[outnode + Test_Data[t].signal_dimensions] * (Test_Data[t].max_output_value[outnode] - Test_Data[t].min_output_value[outnode]));
	     savefile_ptr << real_output << " ";
      }

        savefile_ptr << " ";

      // convert normalized output data and send to file
      for(outnode = 0; outnode < Net_Design.nodes_in_output_layer; outnode++)
      {
	     real_output = Test_Data[t].min_output_value[outnode] + (Net_Design.node_in_output_layer[outnode].output_signal * (Test_Data[t].max_output_value[outnode] - Test_Data[t].min_output_value[outnode]));
	     savefile_ptr << real_output << " ";
      }

      // send absolute differences between each node and its output to a file
      for(outnode = 0; outnode < Net_Design.nodes_in_output_layer; outnode++)
      {
	real_output = (pow(Net_Design.node_in_output_layer[outnode].error_difference_squared, 0.5)) * (Test_Data[t].max_output_value[outnode] - Test_Data[t].min_output_value[outnode]);
	savefile_ptr << real_output << " ";
	real_output = pow(real_output, 2.0);
	output_error += 0.5 * real_output;
      }
	// sum square of error
	savefile_ptr << output_error << "\n";
	if(sig == Test_Data[t].sample_number - 1)
	{savefile_ptr.close();}

	sum_of_error += output_error;
    }
	Test_Data[t].average_squared_error = sum_of_error / Test_Data[t].sample_number;
	Test_Data[t].delete_signal_array();
  }
} // end test neural network function

void NeuralB::network_training_testing(int TT)
{
  int tt = TT;
  int menu_choice;

  clrscr();
  cout << "\n\n\n\n";
  cout << "**************** Operations Menu ****************" << "\n\n";
  cout << "  Please select one of the following options:" <<"\n\n";
  cout << "      1. Train Backprop network only " <<"\n\n";
  cout << "      2. Test Backprop network only " <<"\n\n";
  cout << "      3. Train and Test Backprop network" <<"\n\n";
  cout << "*************************************************" << "\n\n";
  cout << "         Your choice?: "; cin >> menu_choice;
  cout << "\n\n";
     switch(menu_choice)
     {
       case 1:
       initialize_training_storage_array(tt);
       train_net_with_backpropagation();
       break;

       case 2:
       establish_test_battery_size();
       if(number_of_tests > 0)
       {test_neural_network(tt);}
       break;

       case 3:
       initialize_training_storage_array(tt);
       train_net_with_backpropagation();
       establish_test_battery_size();
       if(number_of_tests > 0)
       {test_neural_network(tt);}
       break;

       default:network_training_testing(tt);
     }
}
// This concludes the backpropagation section of the program

//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

// (ART 1)  Define base class for Interface and Cluster units of the
//          Adaptive Resonance Theory Neural Network 1

class ART_units
{
 public:
 float *input_value;
 float *output_value;
 float *input_weight_vector;
 int number_of_inputs;
 int number_of_outputs;
 float activation;
 void establish_input_output_arrays(void);
 virtual void establish_input_weight_vector_array(void);
 virtual void initialize_inputs_and_weights(void);
 ~ART_units();
};

ART_units::~ART_units()
{
  delete [] input_value;
  delete [] output_value;
  delete [] input_weight_vector;
}

void ART_units::establish_input_output_arrays(void)
{
  input_value = new float[number_of_inputs];
  output_value = new float[number_of_outputs];
}

void ART_units::establish_input_weight_vector_array(void)
{input_weight_vector = new float[number_of_inputs - 1];}

void ART_units::initialize_inputs_and_weights(void)
{
  for(int w = 0; w < number_of_inputs - 1; w++)
  {input_weight_vector[w] = 1.0;}

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

// establish Interface node attributes
class Interface_units: public ART_units
{
  public:
  void recompute_activation(int winning_cluster);
  void calculate_output_value(int G1);
};

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

// establish Cluster node attributes
class Cluster_units: public ART_units
{
  public:
  int cluster_tag;
  float net_input;
  void establish_input_weight_vector_array(void);
  void initialize_inputs_and_weights(void);
  void calculate_net_input(void);
  void establish_node_output(void);
  Cluster_units();  // default constructor
};

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

// establish Inputs unit attributes
class Input_units {public: float signal_value;};

// establish ART1 neural network attributes
class ART_Topology
{
 public:
 char netcreate;
 int clustercount;
 int dimensions_of_signal;
 int number_of_cluster_units;
 int reset_value;
 int resetcount;
 float vigilance_parameter;
 float norm_of_activation_vector;
 float norm_of_input_vector;
 float weight_update_parameter;
 int cluster_champ;
 int clusterange;
 Input_units     *node_in_input_layer;
 Interface_units *node_in_interface_layer;
 Cluster_units   *node_in_cluster_layer;
 void establish_net_topology(void);
 void upload_network(void);
 void transmit_pattern_to_interface(void);
 void transmit_pattern_to_cluster(void);
 void broadcast_output_to_cluster_layer(void);
 void cluster_nodes_compete_for_activation(int train_or_test);
 void compute_norm_of_activation_vector(void);
 void compute_norm_of_input_vector(void);
 void recompute_activation_vector_of_interface_layer(void);
 void update_the_network(void);
 void set_cluster_activation_to_zero(void);
 void savenet(void);
 ART_Topology();
 ~ART_Topology(); // class destructor
};

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