bpnet.h

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

#ifndef bpnetH
#define bpnetH
//处理单元类（神经元）
class Processing_units
{
 public:
 float *processing_unit_input;
 int number_of_input_units;     //输入单元个数
 void establish_array_of_processing_unit_inputs(void);  //建立处理单元数组
 float *weight_of_inputs;       //输入权重
 void establish_weight_vector_for_processing_units(void); //建立处理单元权重向量
 float bias;     //斜率
 float output_signal;  //输出信号
 void calculate_output_signal(int activation_function); //计算输出信号
 float calculate_output_signal_derivative(int afun);    //计算输出信号的派生信号
 float error_information_term;                  //(期望输出－输出信号）*输出信号的派生信号
 void calculate_weight_and_bias_correction_terms(float learning_rate);  //计算权重和斜率修正
 float *weight_correction_term;                 //权重修正
 float bias_correction_term;                    //斜率修正
 float sum_of_weighted_inputs;                  //输入权重和
 void update_weights_and_biases(void);          //修改权重和斜率
 Processing_units();
 ~Processing_units();
};


// Declare a derived class "Hidden_units" for hidden layer of network
class Hidden_units : public Processing_units    //隐含层神经元
{
  public:
  void calculate_hidden_error_information_term(int afun);     //计算隐含错误
};

// Declare a derived class "Output_units" for output layer of network
class Output_units : public Processing_units    //输出神经元
{
 public:
 void calculate_output_error_information_term(float target_value, int af);//计算输出错误
 float absolute_error_difference;       //误差绝对值
 float error_difference_squared;        //方差：(期望值－输出信号）的平方
};

// Create classes to contain neural net specifications
//隐含层
class Hidden_layer
{
  public:
  Hidden_units  *node_in_hidden_layer;  //隐含层各个节点
  int nodes_in_hidden_layer;            //隐含层节点数
  ~Hidden_layer();
};

// The following class represents an artificial neural network containing
// the topology, weights, training performance and testing performance
//Back拓扑
class Back_Topology
{
  public:
  Hidden_layer *hidden_layer_number;    //隐含层指针
  Output_units *node_in_output_layer;   //输出节点指针
  int number_of_hidden_layers;          //隐含层数
  int activation_function_for_hidden_layer;      //隐含层激活函数类型
                                                 //1.  Binary Sigmoid Function
                                                 //2.  Bipolar Sigmoid Function
  int nodes_in_output_layer;            //输出层节点数
  int activation_function_for_output_layer;     //输出层激活函数类型
                                                 //1.  Binary Sigmoid Function
                                                 //2.  Bipolar Sigmoid Function
  int signal_dimensions;                //信号维数，输入节点数
  int number_of_tests;                  //训练次数
  void establish_activation_functions(void);    //选择隐含层和输出层激活函数类型
  void construct_and_initialize_backprop_network(void);    //构造、初始化网络
  void upload_network(void);            //从文件导入网络结构
  void savenet(void);                   //保存网络
  ~Back_Topology();
};



// Declare classes that will establish training and testing data arrays
//一组测试数据，数据个数为输入节点个数＋输出节点个数
class sample_data
{
  public:
  float *data_in_sample; // pointer to the dimensions of a single signal
  ~sample_data();
};

//训练、测试数据类
class Data_type
{
 public:
 char filename[13];                       // File containing data for network training or testing，包含训练和测试数据的神经网络文件
 char resultsname[13];                    // File containing data for results of training or testing，训练和测试结果文件
 int signal_dimensions;                   // Number of dimensions contained in signal 输入节点数
 int sample_number;                       // Number of signals in training set 训练数据组数
 int nodes_in_output_layer;               // Dimensions of test data output     输出节点数
 sample_data *number_of_samples;          // Pointer to the array containing signals 训练数据指针
 float *max_output_value;                 // 对应每一个输出节点的训练数据样本中最大的数据
 float *min_output_value;                 // 对应每一个输出节点的训练数据样本中最小的数据
 virtual void determine_sample_number(void); //计算出训练数据样本组数
 void specify_signal_sample_size(void);      //计算出训练数据样本组数，并读入训练数据
 virtual void load_data_into_array(void); // Function to place data into the array  将训练数据读入
 void acquire_net_info(int signal, int no_output_nodes);//设定本组训练数据的输入节点数和输出节点数
 void delete_signal_array(void);          // Function to free memory allocated to hold signals  释放训练数据
 virtual void normalize_data_in_array(void);    //规格化训练数据
 ~Data_type();   // class destructor
};

class signal_data // Class for randomizing the input signals
{
  public:
  int signal_value;    //一组训练数据中标号
  float signal_rank;   //一组训练数据随机产生的数据
};

class Training : public Data_type   // Derived Class For Training Data
{
  public:
  void request_training_data(int net_no); // Function to request data for training 生成网络net_no训练数据
  int number_of_epochs;
  signal_data *signalpoint;
  float rate_of_learning; // learning rate constant used by the net
  char presentation_order; // determines fixed or random signal presentation
  void scramble_data_in_array(void);
  float minimum_average_squared_error;
  void delete_signal_data_array(void);
  ~Training();
};

class Testing : public Training   // Derived Class For Testing Data
{
  public:
  void request_testing_data(int net_no, int test); // Function to request data for testing
  float average_squared_error;
};


//************************************************************************//
class NeuralB    // class containing neural net structure for backpropagation
{                // along with training and testing data
  private:
  Training Training_Data;       // file name and dynamic array for training
  Testing *Test_Data;           // files containing data to test the network
  void initialize_training_storage_array(int N);
  void establish_test_battery_size(void);
  void train_net_with_backpropagation(void);
  void test_neural_network(int BNET);
  public:
  Back_Topology Net_Design;     // specifications for backpropagating network
  int number_of_tests;
  void establish_backprop_network(void);
  void network_training_testing(int TT);
  ~NeuralB();
};
//************************************************************************//



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

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


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

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

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

// establish ART1 neural network attributes
class ART_Topology
{
 public:
 char netcreate;