C++实现人工神经网络的类

这个学期我学习是神经网络课程,有很多的知识国内都不是很完善,而国外就有很大的进步,下面就是来自一本

<AI for Game>的电子版英文书.其中我就拿用面向对象写的C++类进行说明怎样编写神经网络程序.

神经网络的基本思想就是怎样去改变权值.

神经网络层类

class NeuralNetworkLayer

{
 

public:

     int               NumberOfNodes;

     int               NumberOfChildNodes;

     int               NumberOfParentNodes;

     double**          Weights;

     double**          WeightChanges;

     double*           NeuronValues;

     double*           DesiredValues;

     double*           Errors;

     double*           BiasWeights;

     double*           BiasValues;

     double            LearningRate;

     bool              LinearOutput;

     bool              UseMomentum;

     double            MomentumFactor;

     NeuralNetworkLayer*     ParentLayer;

     NeuralNetworkLayer*     ChildLayer;

     NeuralNetworkLayer();

     void     Initialize(int NumNodes,

                            NeuralNetworkLayer* parent,

                            NeuralNetworkLayer* child);

     void     CleanUp(void);

     void     RandomizeWeights(void);

     void     CalculateErrors(void);

     void     AdjustWeights(void);

     void     CalculateNeuronValues(void);

};

NumberOfNodes 层中神经元数目

NumberOfChildNodes     子层神经元数目

NumberOfParentNodes    父层神经元数目

Weights权值数组

WeightChanges 权值改变数组

NeuronValues   神经元值

DesiredValues 导师信号

Errors 误差

BiasWeights    偏差权值

LearningRate   学习效率

LinearOutput   是否线性输出

UseMomentum    是否有动力因素

MomentumFactor有动力因素的话,则动力因素大小值

ParentLayer    父层

ChildLayer     子层

构造函数

NeuralNetworkLayer::NeuralNetworkLayer()

{
 

     ParentLayer = NULL;

     ChildLayer = NULL;

     LinearOutput = false;

     UseMomentum = false;

      MomentumFactor = 0.9;

}

初始化类

void NeuralNetworkLayer::Initialize(int NumNodes,

                                               NeuralNetworkLayer* parent,

                                               NeuralNetworkLayer* child)

{
 

     int     i, j;

     // 分配内存

     NeuronValues = (double*) malloc(sizeof(double) *

                                               NumberOfNodes);

     DesiredValues = (double*) malloc(sizeof(double) *

                                               NumberOfNodes);

     Errors = (double*) malloc(sizeof(double) * NumberOfNodes);

     if(parent != NULL)

     {
 

          ParentLayer = parent;

     }

     if(child != NULL)

     {
 

          ChildLayer = child;

          Weights = (double**) malloc(sizeof(double*) *

                                              NumberOfNodes);

          WeightChanges = (double**) malloc(sizeof(double*) *

                                              NumberOfNodes);

          for(i = 0; i<NumberOfNodes; i++)

          {
 

               Weights[i] = (double*) malloc(sizeof(double) *                                                     NumberOfChildNodes);

               WeightChanges[i] = (double*) malloc(sizeof(double) *                                                         NumberOfChildNodes);

          }

          BiasValues = (double*) malloc(sizeof(double) *

                                        NumberOfChildNodes);

          BiasWeights = (double*) malloc(sizeof(double) *

                                         NumberOfChildNodes);

     } else {
 

          Weights = NULL;

          BiasValues = NULL;

          BiasWeights = NULL;

          WeightChanges = NULL;

     }

     // 确保所有归 0

     for(i=0; i<NumberOfNodes; i++)

     {
 

          NeuronValues[i] = 0;

          DesiredValues[i] = 0;

          Errors[i] = 0;

          if(ChildLayer != NULL)

               for(j=0; j<NumberOfChildNodes; j++)

               {