BP神经网络原理及C++实战

最新推荐文章于 2023-09-25 15:40:29 发布
最新推荐文章于 2023-09-25 15:40:29 发布
阅读量1.5k 收藏 3
点赞数
分类专栏： 神经网络 文章标签： 神经网络 c++

前一段时间做了一个数字识别的小系统，基于 BP 神经网络算法的，用 MFC 做的交互。在实现过程中也试着去找一些源码，总体上来讲，这些源码的可移植性都不好，多数将交互部分和核心算法代码杂糅在一起，这样不仅代码阅读困难，而且重要的是核心算法不具备可移植性。设计模式，设计模式的重要性啊！于是自己将 BP 神经网络的核心算法用标准 C++ 实现，这样可移植性就有保证的，然后在核心算法上实现基于不同 GUI 库的交互（ MFC ， QT ）是能很快的搭建好系统的。下面边介绍 BP 算法的原理（请看《数字图像处理与机器视觉》非常适合做工程的伙伴），边给出代码的实现，最后给出基于核心算法构建交互的例子。

1. 感知器

感知器是一种具有简单的两种输出的人工神经元，如下图所示。

wKiom1Rgu7GSltIFAAB3QPoYEJo250.jpg

2. 线性单元

只有 1 和 -1 两种输出的感知器实际上限制了其处理和分类的能力，下图是一种简单的推广，即不带阈值的感知器。

wKiom1RgvBCxfEINAABTuPlzwCA823.jpg

3. 误差准则

使用的是一个常用的误差度量标准，平方误差准则。公式如下。

wKioL1RgvN3zBlELAAAfmaBDSoM954.jpg

其中 D 为训练样本， t d 为训练观测值 d 的训练输出， o t 为观测值 d 的实际观测值。如果是个凸函数就好了（搞数学的，一听到凸函数就很高兴，呵呵！），但还是可以用梯度下降的方法求其参数 w 。

4. 梯度下降推导

在高等数学中梯度的概念实际上就是一个方向向量，也就是方向导数最大的方向，也就是说沿着这个方向，函数值的变化速度最快。我们这里是做梯度下降，那么就是沿着梯度的负方向更新参数 w 的值来快速达到 E 函数值的最小了。这样梯度下降算法的步骤基本如下：

1） 初始化参数 w （随机，或其它方法）。

2） 求梯度。

3） 沿梯度方向更新参数 w ，可以添加一个学习率，也就是按多大的步子下降。

4） 重复 1 ）， 2 ）， 3 ）直到达到设置的条件（迭代次数，或者 E 的减小量小于某个阈值）。

梯度的表达式如下：

wKiom1RgvMKyZz0PAAAsXJjofww067.jpg

那么如何求梯度呢？就是复合函数求导的过程，如下：

wKiom1RgvPfQfLmrAACfvrKC9P0674.jpg

其中 x id 为样本中第 d 个观测值对应的一个输入分量 x i 。这样，训练过程中参数 w 的更新表达式如下（其中添加了一个学习率，也就是下降的步长）：

wKiom1RgvU_zGpB8AAAflmrdQpw857.jpg

于是参数 w i 的更新增量为：

wKiom1RgvaDSzn56AAAa9yFtAlw606.jpg

对于学习率选择的问题，一般较小是能够保证收敛的，看下图吧。

wKioL1RgvmnTsw05AADqfaynL2I685.jpg

5. 增量梯度下降

对于 4 中的梯度下降算法，其缺点是有时收敛速度慢，如果在误差曲面上存在多个局部极小值，算法不能保证能够找到全局极小值。为了改善这些缺点，提出了增量梯度下降算法。增量梯度下降，与 4 中的梯度下降的不同之处在于， 4 中对参数 w 的更新是根据整个样本中的观测值的误差来计算的， 而增量梯度下降算法是根据样本中单个观测值的误差来计算 w 的更新。

6. 梯度检验

这是一个比较实用的内容，如何确定自己的代码就一定没有错呢？因为在求梯度的时候是很容易犯错误的，我就犯过了，嗨，调了两天才找出来，一个数组下表写错了，要是早一点看看斯坦福大学的深度学习基础教程就好了，这里只是截图一部分，有时间去仔细看看吧。

wKioL1RgvrOQvn2fAAIm7AJietY265.jpg

好了有了前面的基础，我们现在就可以进行实战了，构造多层神经网络。

1.Sigmoid 神经元

Sigmoid 神经元可由下图表示：

wKioL1RgvvKATld2AABv9nesXzY799.jpg

2. 神经网络层

一个三层的 BP 神经网络可由下图表示：

wKiom1Rgvr6hpCAgAAFpop9khJM994.jpg

3. 神经元和神经网络层的标准 C++ 定义

由 2 中的三层 BP 神经网络的示意图中可以看出，隐藏层和输出层是具有类似的结构的。神经元和神经网络层的定义如下：

////////////////////////////////////////////////////////
// Neuron.h
#ifndef __SNEURON_H__
#define __SNEURON_H__
 
#define NEED_MOMENTUM //if you want to addmomentum, remove the annotation
 
#define MOMENTUM 0.6 //momentumcoefficient, works on when defined NEED_MOMENTUM
 
typedef double WEIGHT_TYPE; // definedatatype of the weight
 
 
struct SNeuron{//neuron cell
  /******Data*******/
  intm_nInput; //number of inputs
  WEIGHT_TYPE*m_pWeights;  //weights array of inputs
#ifdef NEED_MOMENTUM
  WEIGHT_TYPE*m_pPrevUpdate; //record last weights update when momentum is needed
#endif
  doublem_dActivation; //output value, through Sigmoid function
  doublem_dError; //error value of neuron
 
  /********Functions*************/
  voidInit(int nInput){
     m_nInput= nInput + 1; //add a side term,number of inputs is actual number of actualinputs plus 1
     m_pWeights= new WEIGHT_TYPE[m_nInput];//allocate for weights array
#ifdef NEED_MOMENTUM
     m_pPrevUpdate= new WEIGHT_TYPE[m_nInput];//allocate for the last weights array
#endif
     m_dActivation= 0; //output value, through SIgmoid function
     m_dError= 0;  //error value of neuron
  }
 
  ~SNeuron(){
     //releasememory
     delete[]m_pWeights;
#ifdef NEED_MOMENTUM
     delete[]m_pPrevUpdate;
#endif
  }
};//SNeuron
 
 
struct SNeuronLayer{//neuron layer
  /************Data**************/
  intm_nNeuron; //Neuron number of this layer
  SNeuron*m_pNeurons; //Neurons array
 
  /*************Functions***************/
  SNeuronLayer(intnNeuron, int nInputsPerNeuron){
     m_nNeuron= nNeuron;
     m_pNeurons= new SNeuron[nNeuron];  //allocatememory for nNeuron neurons
 
     for(inti=0; i<nNeuron; i++){
       m_pNeurons[i].Init(nInputsPerNeuron);  //initialize neuron
     }
  }
  ~SNeuronLayer(){
     delete[]m_pNeurons;  //release neurons array
  }
};//SNeuronLayer
 
#endif//__SNEURON_H__

代码中定义了一个 NEED_MOMENTUM ，它是用来解决局部极小值的问题的，其含义是本次权重的更新是依赖于上一次权重更新的。另外还有一种解决局部极小值问题的方法是，将 w 初始化为接近于 0 的随机数。

4. 反向传播（ BP ）算法

前面虽然有了神经元和神经网络层的定义，但要构造一个三层的 BP 神经网络之前，还要搞清楚 BP 算法是如何来学习神经网络的参数的。它仍采用梯度下降算法，但不同的是这里的输出是整个网络的输出，而不再是一个单元的输出，所有对误差函数 E 重新定义如下：

wKiom1Rgv6HgAO8fAAApeDEAOfM978.jpg

其中 outputs 是网络中输出层单元的集合， t kd ， o kd 是训练样本中第 d 个观测值在第 k 个输出单元的而输出值。

1 ） BP 算法推导

先引入下列符号：

wKioL1RgwE3iRiDYAADpzb0k1yg980.jpg

增量梯度下降算法中，对于每个训练样本中第 d 个观测的一个输入权重 w ij 的增量如下表示：

wKioL1RgwJnwNhTTAAAW7EB7v0w899.jpg

其中 E d 是训练样本中第 d 个观测的误差，通过对输出层所有单元的求和得到：

wKioL1RgwLuDQ4olAAAiDrGsF8E752.jpg

这里说明一下，神经网络输出层的所有单元联合一起表示一个样本观测的训练值的。假设样本观测值为 5 种，即 5 种类别，那么先验训练数据的类别表示为：1,0,0,0,0 ； 0,1,0,0,0 ； 0,0,1,0,0 ； 0,0,0,1,0 ； 0,0,0,0,1 。这样在对神经网络训练时，我们的训练输出值的表示也就是类似的，当然基于神经元的结构表示，我们也可以将先验训练数据的类别表示中的 1 换成 0.9 等。

下面我们就要求梯度了（要分层求解，输出层，隐藏层），梯度向量中的各元素求解如下：

wKiom1RgwL6QeOimAABWAfEi0B8959.jpg

1 ）当单元 j 是一个输出单元时：

wKiom1RgwOug-XAiAAAlk5dFJ-o518.jpg

wKioL1RgwXvw4gEWAAChKLD6rzc918.jpg

于是得到：

wKiom1RgwZrSlN_6AACB4pw7ljs023.jpg

2 ）当单元 j 是一个隐藏层单元时，有如下推导：

wKioL1Rgwm_xivUmAAE7AtHd_xM921.jpg

5 ．标准 C++ 构建三层 BP 神经网络

该神经网络提供了重要的两个接口。一个是一次训练训练接口 TrainingEpoch ，可用于上层算法构建训练函数时调用；另一个是计算给定一个输入神经网络的输出接口CalculateOutput ，它在一次训练函数中被调用，更重要的是，在上层算法中构建识别函数调用。

头文件：

// NeuralNet.h: interface for theCNeuralNet class.
//
//
 
#ifndef __NEURALNET_H__
#define __NEURALNET_H__
 
#include <vector>
#include <math.h>
#include "Neuron.h"
using namespace std;
 
typedef vector<double> iovector;
#define BIAS 1 //bias term's coefficient w0
 
/*************Random functions initializingweights*************/
#define WEIGHT_FACTOR 0.1 //used to confineinitial weights
 
/*Return a random float between 0 to 1*/
inline double RandFloat(){ return(rand())/(RAND_MAX+1.0); }
 
/*Return a random float between -1 to 1*/
inline double RandomClamped(){ returnWEIGHT_FACTOR*(RandFloat() - RandFloat()); }
 
class CNeuralNet{
private:
  /*Initialparameters, can not be changed throghout the whole training.*/
  intm_nInput;  //number of inputs
  intm_nOutput; //number of outputs
  intm_nNeuronsPerLyr; //unit number of hidden layer
  intm_nHiddenLayer; //hidden layer, not including the output layer
 
  /***Dinamicparameters****/
  doublem_dErrorSum;  //one epoch's sum-error
 
  SNeuronLayer*m_pHiddenLyr;  //hidden layer
  SNeuronLayer*m_pOutLyr;     //output layer
 
public:
  /*
  *Constructorand Destructor.
  */
  CNeuralNet(intnInput, int nOutput, int nNeuronsPerLyr, int nHiddenLayer);
  ~CNeuralNet();
  /*
  *Computeoutput of network, feedforward.
  */
  bool CalculateOutput(vector<double> input,vector<double>& output);
  /*
  *Trainingan Epoch, backward adjustment.
  */
  bool TrainingEpoch(vector<iovector>& SetIn,vector<iovector>& SetOut, double LearningRate);
  /*
  *Geterror-sum.
  */
  doubleGetErrorSum(){ return m_dErrorSum; }
  SNeuronLayer*GetHiddenLyr(){ return m_pHiddenLyr; }
  SNeuronLayer*GetOutLyr(){ return m_pOutLyr; }
 
private:
  /*
  *Biuldnetwork, allocate memory for each layer.
  */
  voidCreateNetwork();
  /*
  *Initializenetwork.
  */
  voidInitializeNetwork();
  /*
  *Sigmoidencourage fuction.
  */
  doubleSigmoid(double netinput){
     doubleresponse = 1.0;  //control steep degreeof sigmoid function
     return(1 / ( 1 + exp(-netinput / response) ) );
  }       
};
 
#endif //__NEURALNET_H__

实现文件：

// NeuralNet.cpp: implementation of theCNeuralNet class.
//
//
#include "stdafx.h"
#include "NeuralNet.h"
#include <assert.h>
 
CNeuralNet::CNeuralNet(int nInput, intnOutput, int nNeuronsPerLyr, int nHiddenLayer){
  assert(nInput>0 && nOutput>0 && nNeuronsPerLyr>0 &&nHiddenLayer>0 );
  m_nInput= nInput;
  m_nOutput= nOutput;
  m_nNeuronsPerLyr= nNeuronsPerLyr;
  if(nHiddenLayer!= 1)
     m_nHiddenLayer= 1;
  else
     m_nHiddenLayer= nHiddenLayer; //temporarily surpport only one hidden layer
 
  m_pHiddenLyr= NULL;
  m_pOutLyr= NULL;
 
  CreateNetwork();   //allocate for each layer
  InitializeNetwork();  //initialize the whole network
}
 
CNeuralNet::~CNeuralNet(){
  if(m_pHiddenLyr!= NULL)
     deletem_pHiddenLyr;
  if(m_pOutLyr!= NULL)
     deletem_pOutLyr;
}
 
void CNeuralNet::CreateNetwork(){
  m_pHiddenLyr= new SNeuronLayer(m_nNeuronsPerLyr, m_nInput);
  m_pOutLyr= new SNeuronLayer(m_nOutput, m_nNeuronsPerLyr);
}
 
void CNeuralNet::InitializeNetwork(){
  inti, j;  //variables for loop
 
  /*usepresent time as random seed, so every time runs this programm can producedifferent random sequence*/
  //srand((unsigned)time(NULL) );
 
  /*initializehidden layer's weights*/
  for(i=0;i<m_pHiddenLyr->m_nNeuron; i++){
     for(j=0;j<m_pHiddenLyr->m_pNeurons[i].m_nInput; j++){
       m_pHiddenLyr->m_pNeurons[i].m_pWeights[j]= RandomClamped();
       #ifdefNEED_MOMENTUM
       /*whenthe first epoch train started, there is no previous weights update*/
       m_pHiddenLyr->m_pNeurons[i].m_pPrevUpdate[j]= 0;
       #endif
     }       
  }
  /*initializeoutput layer's weights*/
  for(i=0;i<m_pOutLyr->m_nNeuron; i++){
     for(intj=0; j<m_pOutLyr->m_pNeurons[i].m_nInput; j++){
       m_pOutLyr->m_pNeurons[i].m_pWeights[j]= RandomClamped();
       #ifdefNEED_MOMENTUM
       /*whenthe first epoch train started, there is no previous weights update*/
       m_pOutLyr->m_pNeurons[i].m_pPrevUpdate[j]= 0;
       #endif
     }
  }
 
  m_dErrorSum= 9999.0;  //initialize a large trainingerror, it will be decreasing with training
}
 
boolCNeuralNet::CalculateOutput(vector<double> input,vector<double>& output){
  if(input.size()!= m_nInput){ //input feature vector's dimention not equals to input of network
     returnfalse;
  }
  inti, j;
  doublenInputSum;  //sum term
 
  /*computehidden layer output*/
  for(i=0;i<m_pHiddenLyr->m_nNeuron; i++){
     nInputSum= 0;
     for(j=0;j<m_pHiddenLyr->m_pNeurons[i].m_nInput-1; j++){
       nInputSum+= m_pHiddenLyr->m_pNeurons[i].m_pWeights[j] * input[j];
     }
     /*plusbias term*/
     nInputSum+= m_pHiddenLyr->m_pNeurons[i].m_pWeights[j] * BIAS;
     /*computesigmoid fuction's output*/
     m_pHiddenLyr->m_pNeurons[i].m_dActivation= Sigmoid(nInputSum);
  }
 
  /*computeoutput layer's output*/
  for(i=0;i<m_pOutLyr->m_nNeuron; i++){
     nInputSum= 0;
     for(j=0;j<m_pOutLyr->m_pNeurons[i].m_nInput-1; j++){
       nInputSum+= m_pOutLyr->m_pNeurons[i].m_pWeights[j]
         *m_pHiddenLyr->m_pNeurons[j].m_dActivation;
     }
     /*plusbias term*/
     nInputSum+= m_pOutLyr->m_pNeurons[i].m_pWeights[j] * BIAS;
     /*computesigmoid fuction's output*/
     m_pOutLyr->m_pNeurons[i].m_dActivation= Sigmoid(nInputSum);
     /*saveit to the output vector*/
     output.push_back(m_pOutLyr->m_pNeurons[i].m_dActivation);
  }
  returntrue;
}
 
bool CNeuralNet::TrainingEpoch(vector<iovector>&SetIn, vector<iovector>& SetOut, double LearningRate){
  inti, j, k;
  doubleWeightUpdate;  //weight's update value
  doubleerr;  //error term
 
  /*increment'sgradient decrease(update weights according to each training sample)*/
  m_dErrorSum= 0;  // sum of error term
  for(i=0;i<SetIn.size(); i++){
     iovectorvecOutputs;
     /*forwardlyspread inputs through network*/
     if(!CalculateOutput(SetIn[i],vecOutputs)){
       returnfalse;
     }
 
     /*updatethe output layer's weights*/
     for(j=0;j<m_pOutLyr->m_nNeuron; j++){
 
       /*computeerror term*/
       err= ((double)SetOut[i][j]-vecOutputs[j])*vecOutputs[j]*(1-vecOutputs[j]);
       m_pOutLyr->m_pNeurons[j].m_dError= err;  //record this unit's error
 
       /*updatesum error*/
       m_dErrorSum+= ((double)SetOut[i][j] - vecOutputs[j]) * ((double)SetOut[i][j] -vecOutputs[j]);
 
       /*updateeach input's weight*/
       for(k=0;k<m_pOutLyr->m_pNeurons[j].m_nInput-1; k++){
         WeightUpdate= err * LearningRate * m_pHiddenLyr->m_pNeurons[k].m_dActivation;
#ifdef NEED_MOMENTUM
         /*updateweights with momentum*/
         m_pOutLyr->m_pNeurons[j].m_pWeights[k]+=
            WeightUpdate+ m_pOutLyr->m_pNeurons[j].m_pPrevUpdate[k] * MOMENTUM;
         m_pOutLyr->m_pNeurons[j].m_pPrevUpdate[k]= WeightUpdate;
#else
         /*updateunit weights*/
         m_pOutLyr->m_pNeurons[j].m_pWeights[k]+= WeightUpdate;
#endif
       }
       /*biasupdate volume*/
       WeightUpdate= err * LearningRate * BIAS;
#ifdef NEED_MOMENTUM
       /*updatebias with momentum*/
       m_pOutLyr->m_pNeurons[j].m_pWeights[k]+=
         WeightUpdate+ m_pOutLyr->m_pNeurons[j].m_pPrevUpdate[k] * MOMENTUM;
       m_pOutLyr->m_pNeurons[j].m_pPrevUpdate[k]= WeightUpdate;
#else
       /*updatebias*/
       m_pOutLyr->m_pNeurons[j].m_pWeights[k]+= WeightUpdate;
#endif
     }//for out layer
 
     /*updatethe hidden layer's weights*/
     for(j=0;j<m_pHiddenLyr->m_nNeuron; j++){
 
       err= 0;
       for(intk=0; k<m_pOutLyr->m_nNeuron; k++){
         err+= m_pOutLyr->m_pNeurons[k].m_dError *m_pOutLyr->m_pNeurons[k].m_pWeights[j];
       }
       err*= m_pHiddenLyr->m_pNeurons[j].m_dActivation * (1 -m_pHiddenLyr->m_pNeurons[j].m_dActivation);
       m_pHiddenLyr->m_pNeurons[j].m_dError= err;  //record this unit's error
 
       /*updateeach input's weight*/
       for(k=0;k<m_pHiddenLyr->m_pNeurons[j].m_nInput-1; k++){
         WeightUpdate= err * LearningRate * SetIn[i][k];
#ifdef NEED_MOMENTUM
         /*updateweights with momentum*/
         m_pHiddenLyr->m_pNeurons[j].m_pWeights[k]+=
            WeightUpdate+ m_pHiddenLyr->m_pNeurons[j].m_pPrevUpdate[k] * MOMENTUM;
         m_pHiddenLyr->m_pNeurons[j].m_pPrevUpdate[k]= WeightUpdate;
#else
         m_pHiddenLyr->m_pNeurons[j].m_pWeights[k]+= WeightUpdate;
#endif
       }
       /*biasupdate volume*/
       WeightUpdate= err * LearningRate * BIAS;
#ifdef NEED_MOMENTUM
       /*updatebias with momentum*/
       m_pHiddenLyr->m_pNeurons[j].m_pWeights[k]+=
         WeightUpdate+ m_pHiddenLyr->m_pNeurons[j].m_pPrevUpdate[k] * MOMENTUM;
       m_pHiddenLyr->m_pNeurons[j].m_pPrevUpdate[k]= WeightUpdate;
#else
       /*updatebias*/
       m_pHiddenLyr->m_pNeurons[j].m_pWeights[k]+= WeightUpdate;
#endif
     }//forhidden layer
  }//forone epoch
  returntrue;
}

6. 基于 BP 核心算法构建 MVC 框架

到此为止我们的核心算法已经构建出来了，再应用两次 Strategy 设计模式，我们就很容易构建出一个 MVC 框架（ see also ：http://remyspot.blog.51cto.com/8218746/1574484 ）。下面给出一个应用Strategy 设计模式基于 CNeuralNet 类构建一个 Controller ，在 Controller 中我们就可以开始依赖特定的 GUI 库了。下面的这个 Controller 是不能直接使用的，你所要做的是参考该代码（ 重点参看

boolTrain(vector<iovector>& SetIn, vector<iovector>& SetOut);

bool SaveTrainResultToFile(const char* lpszFileName, boolbCreate);

bool LoadTrainResultFromFile(const char* lpszFileName, DWORDdwStartPos);

int Recognize(CString strPathName, CRect rt, double&dConfidence);

接口的实现 ）， 然后基于前面的核心 BP 算构建你自己的 Controller ，然后在该 Controller 的上层实现你自己的交互功能。

说明一下， Train 接口中的 SetIn 是训练数据的特征， SetOut 是训练数据的类别表示。

头文件：

#ifndef __OPERATEONNEURALNET_H__
#define __OPERATEONNEURALNET_H__
 
#include "NeuralNet.h"
#define NEURALNET_VERSION 1.0
#define RESAMPLE_LEN 4
 
class COperateOnNeuralNet{
private:
  /*network*/
  CNeuralNet*m_oNetWork;
 
  /*network'sparameter*/
  intm_nInput;
  intm_nOutput;
  intm_nNeuronsPerLyr;
  intm_nHiddenLayer;
 
  /*trainingconfiguration*/
  intm_nMaxEpoch;  // max training epoch times
  doublem_dMinError; // error threshold
  doublem_dLearningRate;
 
  /*dinamiccurrent parameter*/
  intm_nEpochs;
  doublem_dErr;  //mean error of oneepoch(m_dErrorSum/(num-of-samples * num-of-output))
  boolm_bStop; //control whether stop or not during the training
  vector<double> m_vecError;   //record each epoch'straining error, used for drawing error curve
 
public:
  COperateOnNeuralNet();
  ~COperateOnNeuralNet();
 
  voidSetNetWorkParameter(int nInput, int nOutput, int nNeuronsPerLyr, intnHiddenLayer);
  boolCreatNetWork();
  voidSetTrainConfiguration(int nMaxEpoch, double dMinError, double dLearningRate);
  voidSetStopFlag(bool bStop) { m_bStop = bStop; }
 
  doubleGetError(){ return m_dErr; }
  intGetEpoch(){ return m_nEpochs; }
  intGetNumNeuronsPerLyr(){ return m_nNeuronsPerLyr; }
 
  boolTrain(vector<iovector>& SetIn, vector<iovector>& SetOut);
  bool SaveTrainResultToFile(const char* lpszFileName, boolbCreate);
  bool LoadTrainResultFromFile(const char* lpszFileName, DWORDdwStartPos);
  int Recognize(CString strPathName, CRect rt, double&dConfidence);
};
/*
* Can be used when saving or readingtraining result.
*/
struct NEURALNET_HEADER{
  DWORDdwVersion;  //version imformation
        
  /*initialparameters*/
  intm_nInput;  //number of inputs
  intm_nOutput; //number of outputs
  intm_nNeuronsPerLyr; //unit number of hidden layer
  intm_nHiddenLayer; //hidden layer, not including the output layer
 
  /*trainingconfiguration*/
  intm_nMaxEpoch;  // max training epoch times
  doublem_dMinError; // error threshold
  doublem_dLearningRate;
 
  /*dinamiccurrent parameter*/
  intm_nEpochs;
  doublem_dErr;  //mean error of oneepoch(m_dErrorSum/(num-of-samples * num-of-output))
};
#endif //__OPERATEONNEURALNET_H__

实现文件：

// OperateOnNeuralNet.cpp: implementationof the COperateOnNeuralNet class.
//
//
 
#include "stdafx.h"
#include "MyDigitRec.h"
#include "OperateOnNeuralNet.h"
#include "Img.h"
#include <assert.h>
 
/*
*Handle message during waiting.
*/
void WaitForIdle()
{
  MSGmsg; 
  while(::PeekMessage(&msg,NULL, 0, 0, PM_REMOVE))
  {
     ::TranslateMessage(&msg);
     ::DispatchMessage(&msg);
  }
}
 
COperateOnNeuralNet::COperateOnNeuralNet(){
  m_nInput= 0;
  m_nOutput= 0;
  m_nNeuronsPerLyr= 0;
  m_nHiddenLayer= 0;
 
  m_nMaxEpoch= 0;
  m_dMinError= 0;
  m_dLearningRate= 0;
 
  m_oNetWork= 0;
 
  m_nEpochs= 0;
  m_dErr= 0;
  m_bStop= false;
}
 
COperateOnNeuralNet::~COperateOnNeuralNet(){
  if(m_oNetWork)
     deletem_oNetWork;
}
 
voidCOperateOnNeuralNet::SetNetWorkParameter(int nInput, int nOutput, intnNeuronsPerLyr, int nHiddenLayer){
  assert(nInput>0 && nOutput>0 && nNeuronsPerLyr>0 &&nHiddenLayer>0 );
  m_nInput= nInput;
  m_nOutput= nOutput;
  m_nNeuronsPerLyr= nNeuronsPerLyr;
  m_nHiddenLayer= nHiddenLayer;
}
 
bool COperateOnNeuralNet::CreatNetWork(){
  assert(m_nInput>0 && m_nOutput>0 && m_nNeuronsPerLyr>0&& m_nHiddenLayer>0 );
  m_oNetWork= new CNeuralNet(m_nInput, m_nOutput, m_nNeuronsPerLyr, m_nHiddenLayer);
  if(m_oNetWork)
     returntrue;
  else
     returnfalse;
}
 
voidCOperateOnNeuralNet::SetTrainConfiguration(int nMaxEpoch, double dMinError,double dLearningRate){
  assert(nMaxEpoch>0&& !(dMinError<0) && dLearningRate!=0);
  m_nMaxEpoch= nMaxEpoch;
  m_dMinError= dMinError;
  m_dLearningRate= dLearningRate;
}
 
boolCOperateOnNeuralNet::Train(vector<iovector>& SetIn, vector<iovector>&SetOut){
  m_bStop= false;  //no stop during training
  CStringstrOutMsg;
 
  do{
     /*trainone epoch*/
     if(!m_oNetWork->TrainingEpoch(SetIn, SetOut, m_dLearningRate) ){
       strOutMsg.Format("Erroroccured at training %dth epoch!",m_nEpochs+1);
       AfxMessageBox(strOutMsg);
       returnfalse;
     }else{
       m_nEpochs++;
     }
    
     /*computemean error of one epoch(m_dErrorSum/(num-of-samples * num-of-output))*/
     intsum = m_oNetWork->GetErrorSum();
     m_dErr= m_oNetWork->GetErrorSum() / ( m_nOutput * SetIn.size() );
     m_vecError.push_back(m_dErr);
     if(m_dErr< m_dMinError){
       break;
     }
 
     /*stopin loop to chech wether user's action made or message sent, mostly for changem_bStop */
     WaitForIdle();
 
     if(m_bStop){
       break;
     }
  }while(--m_nMaxEpoch> 0);
 
  returntrue;
}
 
boolCOperateOnNeuralNet::SaveTrainResultToFile(const char* lpszFileName, boolbCreate){
  CFilefile;
  if(bCreate){
     if(!file.Open(lpszFileName,CFile::modeWrite|CFile::modeCreate))
       returnfalse;
  }else{
     if(!file.Open(lpszFileName,CFile::modeWrite))
       returnfalse;
     file.SeekToEnd();  //add to end of file
  }
 
  /*createnetwork head information*/
  /*initialparameter*/
  NEURALNET_HEADERheader = {0};
  header.dwVersion= NEURALNET_VERSION;
  header.m_nInput= m_nInput;
  header.m_nOutput= m_nOutput;
  header.m_nNeuronsPerLyr= m_nNeuronsPerLyr;
  header.m_nHiddenLayer= m_nHiddenLayer;
  /*trainingconfiguration*/
  header.m_nMaxEpoch= m_nMaxEpoch;
  header.m_dMinError= m_dMinError;
  header.m_dLearningRate= m_dLearningRate;
  /*dinamiccurrent parameter*/
  header.m_nEpochs= m_nEpochs;
  header.m_dErr= m_dErr;
 
  file.Write(&header,sizeof(header));
 
  /*writeweight information to file*/
  inti, j;
  /*hiddenlayer weight*/
  for(i=0;i<m_oNetWork->GetHiddenLyr()->m_nNeuron; i++){
     file.Write(&m_oNetWork->GetHiddenLyr()->m_pNeurons[i].m_dActivation,
       sizeof(m_oNetWork->GetHiddenLyr()->m_pNeurons[i].m_dActivation));
     file.Write(&m_oNetWork->GetHiddenLyr()->m_pNeurons[i].m_dError,
       sizeof(m_oNetWork->GetHiddenLyr()->m_pNeurons[i].m_dError));
     for(j=0;j<m_oNetWork->GetHiddenLyr()->m_pNeurons[i].m_nInput; j++){
       file.Write(&m_oNetWork->GetHiddenLyr()->m_pNeurons[i].m_pWeights[j],
         sizeof(m_oNetWork->GetHiddenLyr()->m_pNeurons[i].m_pWeights[j]));
     }
  }
  /*outputlayer weight*/
  for(i=0;i<m_oNetWork->GetOutLyr()->m_nNeuron; i++){
     file.Write(&m_oNetWork->GetOutLyr()->m_pNeurons[i].m_dActivation,
       sizeof(m_oNetWork->GetOutLyr()->m_pNeurons[i].m_dActivation));
     file.Write(&m_oNetWork->GetOutLyr()->m_pNeurons[i].m_dError,
       sizeof(m_oNetWork->GetOutLyr()->m_pNeurons[i].m_dError));
     for(j=0;j<m_oNetWork->GetOutLyr()->m_pNeurons[i].m_nInput; j++){
       file.Write(&m_oNetWork->GetOutLyr()->m_pNeurons[i].m_pWeights[j],
         sizeof(m_oNetWork->GetOutLyr()->m_pNeurons[i].m_pWeights[j]));
     }
  }
 
  file.Close();
  returntrue;
}
 
boolCOperateOnNeuralNet::LoadTrainResultFromFile(const char* lpszFileName, DWORDdwStartPos){
  CFilefile;
  if(!file.Open(lpszFileName,CFile::modeRead)){
     returnfalse;
  }
 
  file.Seek(dwStartPos,CFile::begin);  //point to dwStartPos
 
  /*readin NeuralNet_Head infomation*/
  NEURALNET_HEADERheader = {0};
  if(file.Read(&header, sizeof(header)) != sizeof(header) ){
     returnfalse;
  }
 
  /*chechversion*/
  if(header.dwVersion!= NEURALNET_VERSION){
     returnfalse;
  }
 
  /*checkbasic NeuralNet's structure*/
  if(header.m_nInput!= m_nInput
     ||header.m_nOutput != m_nOutput
     ||header.m_nNeuronsPerLyr != m_nNeuronsPerLyr
     ||header.m_nHiddenLayer != m_nHiddenLayer
     ||header.m_nMaxEpoch != m_nMaxEpoch
     ||header.m_dMinError != m_dMinError
     ||header.m_dLearningRate != m_dLearningRate ){
     returnfalse;
  }
        
  /*dynamicparameters*/
  m_nEpochs= header.m_nEpochs;  //update trainingepochs
  m_dErr= header.m_dErr;		  //update training error
 
  /*readin NetWork's weights*/
  inti,j;
  /*readin hidden layer weights*/
  for(i=0;i<m_oNetWork->GetHiddenLyr()->m_nNeuron; i++){
     file.Read(&m_oNetWork->GetHiddenLyr()->m_pNeurons[i].m_dActivation,
       sizeof(m_oNetWork->GetHiddenLyr()->m_pNeurons[i].m_dActivation));
     file.Read(&m_oNetWork->GetHiddenLyr()->m_pNeurons[i].m_dError,
       sizeof(m_oNetWork->GetHiddenLyr()->m_pNeurons[i].m_dError));
 
     for(j=0;j<m_oNetWork->GetHiddenLyr()->m_pNeurons[i].m_nInput; j++){
       file.Read(&m_oNetWork->GetHiddenLyr()->m_pNeurons[i].m_pWeights[j],
         sizeof(m_oNetWork->GetHiddenLyr()->m_pNeurons[i].m_pWeights[j]));
     }
  }
 
  /*readin out layer weights*/
  for(i=0;i<m_oNetWork->GetOutLyr()->m_nNeuron; i++){
     file.Read(&m_oNetWork->GetOutLyr()->m_pNeurons[i].m_dActivation,
       sizeof(m_oNetWork->GetOutLyr()->m_pNeurons[i].m_dActivation));
     file.Read(&m_oNetWork->GetOutLyr()->m_pNeurons[i].m_dError,
       sizeof(m_oNetWork->GetOutLyr()->m_pNeurons[i].m_dError));
 
     for(j=0;j<m_oNetWork->GetOutLyr()->m_pNeurons[i].m_nInput; j++){
       file.Read(&m_oNetWork->GetOutLyr()->m_pNeurons[i].m_pWeights[j],
         sizeof(m_oNetWork->GetOutLyr()->m_pNeurons[i].m_pWeights[j]));
     }
  }
        
  returntrue;
}
 
int COperateOnNeuralNet::Recognize(CStringstrPathName, CRect rt, double &dConfidence){
  intnBestMatch;  //category number
  doubledMaxOut1 = 0; //max output
  doubledMaxOut2 = 0; //second max output
 
  CImggray;
  if(!gray.AttachFromFile(strPathName)){
     return-1;
  }
 
  /*convert the picture waitiong for being recognized to vector*/
  vector<double>vecToRec;
  for(intj=rt.top; j<rt.bottom; j+= RESAMPLE_LEN){
     for(inti=rt.left; i<rt.right; i+=RESAMPLE_LEN){
       intnGray = 0;
       for(intmm=j; mm<j+RESAMPLE_LEN; mm++){
         for(intnn=i; nn<i+RESAMPLE_LEN; nn++)
            nGray+= gray.GetGray(nn, mm);
       }
       nGray/= RESAMPLE_LEN*RESAMPLE_LEN;
       vecToRec.push_back(nGray/255.0);
     }
  }
 
  /*computethe output result*/
  vector<double>outputs;
  if(!m_oNetWork->CalculateOutput(vecToRec,outputs)){
     AfxMessageBox("Recfailed!");
     return-1;
  }
 
  /*findthe max output unit, and its unit number is the category number*/
  nBestMatch= 0;
  for(intk=0; k<outputs.size(); k++){
     if(outputs[k]> dMaxOut1){
       dMaxOut2= dMaxOut1;
       dMaxOut1= outputs[k];
       nBestMatch= k;
     }
  }
  dConfidence= dMaxOut1 - dMaxOut2;  //compute beliefdegree
  returnnBestMatch;
}
ArthurKingYs
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一个很好的bp神经网络预测程序实例，有较好的预测精确性
12-20
一个很好的bp神经网络预测程序实例，有较好的预测精确性
C++实现的BP和CNN神经网络算法，无外源库调用，逐代码解析，手写数字识别准确率达91.6%和96.4%
最新发布
vWbEOFqak的博客
04-28 312
本文将针对基于C++的BP CNN神经网络算法展开讨论，该算法不依赖于外源库，使读者能够深入理解每一种算法的原理，并通过实际应用（手写数字识别）的准确率结果来评估算法性能。此程序里面包括BP和CNN神经网络，接近上千行代码的，由于程序不调用任何外源库，所以读者可以看清楚每一个算法的原理，要想学好神经网络，必须打好基础，不要好高骛远。探讨CNN神经网络算法的实现方法，包括卷积层、池化层和全连接层的设计思路，以及特征提取和分类的过程，使读者能够理解CNN算法在图像处理中的应用。二、基于C++的实现思路。
C++简单的BP神经网络
qq_31731573的博客
09-25 457
BP神经网络在不同学习率的情况下最终的迭代精度会有所不同，学习率较小时，达到同样精度需要更多的迭代次数，学习率过大时，则会导致迭代精度偏差较大，甚至出现震荡现象，容易导致过拟合，因此在实际情况中应该选择一个合适的学习率，或者根据迭代次数进行学习率的动态变化从而达到更好的效果。
[QT]BP神经网络
07-07
训练样本在learn中，识别样本为x.bmp 开发使用的QT版本为5.0 总体样本容量为原始样本的30倍，除却原始样本外其他为随机噪声样本 使用大样本容量+乱序方式消除样本顺序影响 S型函数选用1/(1+e^x)，有使用节点阈值，该阈值可自调整 可以修改隐藏层数量，不建议修改隐藏层节点数，可能导致程序运行时异常
c++实现的BP神经网络实例
02-25
使用C++实现BP神经网络对一组学习样本进行学习。
BP神经网络原理及应用.doc
06-20
BP 神经网络原理及应用 BP 神经网络是一种人工神经网络，模拟生物神经系统的结构和功能。它由许多相互连接的处理单元组成，每个处理单元都有多个输入、一个输出和一个激励函数。BP 神经网络的主要特性是并行分布...
BP神经网络字符识别C++.zip
06-04
在本项目"BP神经网络字符识别C++.zip"中，开发者提供了一个C++实现的BP神经网络，用于字符的训练和识别。这个项目适合对机器学习和图像处理感兴趣的开发者，尤其是那些熟悉C++编程语言并希望了解或实践神经网络应用...
C++实现神经BP神经网络
12-17
【C++实现神经BP神经网络】是通过编程语言C++来构建一个反向传播(Backpropagation)算法的神经网络模型。反向传播是监督学习中的一种常用算法，主要用于多层感知器的学习，通过梯度下降法更新网络的权重和偏置，以...
BP神经网络原理及实战.ppt
10-20
BP神经网络原理及实战 BP神经网络是人工神经网络的一种，具有广泛的应用前景。下面对BP神经网络的原理和实战进行详细的阐述。 BP神经网络的发展历程 BP神经网络的发展可以追溯到1969年，当时明斯基和佩珀特合作...
C++实现简单BP神经网络
08-19
C++实现简单BP神经网络 本文主要介绍了如何使用C++语言实现一个简单的BP神经网络，包括神经网络的基本结构、矩阵运算、训练过程和测试结果的展示。以下是对应的知识点总结： 1. BP神经网络的基本结构：BP神经网络...
BP神经网络（鸢尾花分类）C++代码
10-31
BP神经网络（鸢尾花分类）C++代码.rar 将Iris（鸢尾花）数据集分为训练集（Iris-train.txt）和测试集（Iris-test.txt），分别含75个样本，每个集合中每种花各有25个样本。
RBF神经网络C++源码
04-07
GitHub搬运，作者主页：https://github.com/osama-afifi
C++实现人工神经网络的类
hora_bird的专栏
07-03 7126
这个学期我学习是神经网络课程,有很多的知识国内都不是很完善,而国外就有很大的进步,下面就是来自一本的电子版英文书.其中我就拿用面向对象写的C++类进行说明怎样编写神经网络程序.神经网络的基本思想就是怎样去改变权值.神经网络层类class NeuralNetworkLayer{public:     int               NumberOfNodes;  
BP神经网络从理论到应用（一）：C++实现
09-30 2244
为什么基于数学原理的程序会那么难以实现？因为缺乏一定的训练。事实上，基于数学定理的算法并不比「数据结构与算法」的算法复杂更多，它们往往并不需要高级的数据结构作为支撑，也不要高级的语法特性完成某一功能，算法所赖以实现的基石仍是基本的循环分判断等机制。 为什么基于数学原理的程序会那么难以阅读？因为缺乏程序语言向数学公式的转换的训练，还是缺乏训练。
BP神经网络，C++调用matlab engine
automan的专栏
05-27 2606
前几天用BP神经网络做了一个手写体数字识别的小实验，因为界面是C++写的，训练BP网络是在MATLAB上做的。就像偷个懒看看C++能不能直接调用MATLAB的神经网络工具箱。 最早采用的方案是用MATLAB控制台把写好的.m文件编译成DLL。但是遇到一个比较大的问题：编译出来的DLL，需要传递的参数类型为mwArray，我不知道怎么将保存到本地的训练好的网络读取成mwArray。查了查资料也没有
BP神经网络原理分析及c++代码实现（下）
热门推荐
hjkhjk007的专栏
06-03 1万+
本部分主要是BP神经网络的C++代码部分，在这里简单的介绍下代码的头文件，具体代码的实现以及测试数据，请在csdn资源里下载：http://download.csdn.net/detail/hjkhjk007/5503911 为了方便广大用户的使用，本人将BP神经网络写成了一个BPNNS类，这样用户们可以很方便的将此类潜入到自己的工程当中，此类的具体的使用规则，下面会介绍。 /********
C++实现BP 神经网络两类图形分辨出来
hanshuning的专栏
01-18 1171
#include #include #include using namespace std; #define innode 9 //输入结点数 #define hidenode 10//隐含结点数 #define sample 8//BP训练样本数 class BpNet { public:
传统bp算法类C/C++实现
new_hwp028的专栏
12-24 1712
#include "stdio.h" #include "stdlib.h" #include "math.h" #include "time.h" #include "memory.h" #define BP_H class BpNet { private:     int _nInput;            //输入层节点个数     int _nHide;
BP神经网络Matlab实现详解与实战应用
本文是一系列关于考拉BP神经网络在Matlab中的实现学习教程，由论坛超级版主akjuan整理，旨在帮助初学者理解和掌握BP神经网络的基本概念、特点及其在实际应用中的注意事项。以下是五个核心部分的概要： 1. **基础...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值