C++中的模板
template&typename T1, typename T2&
int CompareNums(T1 num1, T2 num2) { && &if(num1 & num2) && &{ && &&& &return 1; && &} && &else if(num2 & num1) && &{ && &&& &return -1; && &}
&& &return 0; }
template&class T1, class T2& struct Fuck_gt { && &T1& ch_1; && &T2& ch_2; };
void main() { && &int a1 = 66; && &float b1 = 77.0f; &&&&int ncmp = CompareNums(a1, b1); && &std::cout&&&ncmp &&&ncmp&&std::
&& &Fuck_gt&int, float&& fuck_ && &fuck_gts.ch_1 = 1.0f; && &fuck_gts.ch_2 = 22.5f;
&& &std::cout&&&ch_1 &&&fuck_gts.ch_1&&std:: && &std::cout&&&ch_2 &&&fuck_gts.ch_2&&std:: }
假设现在我们完成这样的函数，给定两个数x和y求式子x^2 + y^2 +　x * y的值 .考虑到x和y可能是 int ， float 或者double类型，那么我们就要完成三个函数：
int fun(int x,int y);
float fun(float x,float y);
double fun(double x,double y);
并且每个fun函数内部所要完成的操作也是极其的相似。如下：
1 int fun(int x,int y)
int tmp = x *x + y * y + x *
6 float fun(float x,float y)
float tmp = x *x + y * y + x *
11 double fun(double x,double y)
double tmp = x *x + y * y + x *
可以看出，上面的三个函数体除了类型不一样之外，其他的完全一样，那么如果能够只写一个函数就能完成上面的三个函数的功能该多好呢？如果从这三个函数提炼出一个通用函数，而它又适用于这三种不同类型的数据，这样会使代码的重用率大大提高。实际上C++中的模板正好就是来解决这个问题的。模板可以实现类型的参数化(把类型定义为参数)，从而实现了真正的代码可重用性。C++中的模板可分为函数模板和类模板，而把函数模板的具体化称为模板函数，把类模板的具体化成为模板类。下面让我们分别看看什么是函数模板和类模板吧~~~
2.模板函数
实际上我们利用函数模板，只需要一个函数就可能完成上面的三个函数了，千言万语不如看代码：&
1 #include &iostream&
3 using namespace
5 template &typename T&
6 T fun(T x,T y)
T tmp = x *x + y * y + x *
11 int main()
int x1 = 1,y1 = 4;
float x2 = 1.1 , y2 = 2.2;
double x3 = 2.0 , y3 = 3.1;
cout&&fun(x1,y1)&&
cout&&fun(x2,y2)&&
cout&&fun(x3,y3)&&
运行结果：
如此利用模板，我们很轻而易举的达到了我们的目的，而这也大大的提高了代码的可重用性，这也让我们想起了STL中的那些算法了吧，这些算法使用多种的数据类型。实际上STL即使模板的重要应用了。
现在我们想，如果上面的代码这样调用fun(x1,y2)会怎么样呢？点击编译会出现这样的错误：
可以看到编译编译出现问题的是fun(x1,y2)，说的意思就是没有对应的函数，要么x1和y2都是int型，要么x1和y2都是float型。那么我为什么要说一下这样一种情况呢？主要是为了引出模板也可以同时使用两个：
1 #include &iostream&
3 using namespace
6 template &typename T1 , typename T2&
7 T2 fun(T1 x,T2 y)
T2 tmp = x *x + y * y + x *
12 int main()
int x1 = 1,y1 = 4;
float x2 = 1.1 , y2 = 2.2;
double x3 = 2.0 , y3 = 3.1;
cout&&fun(x1,y1)&&
cout&&fun(x2,y2)&&
cout&&fun(x3,y3)&&
cout&&fun(x1,y2)&&
运行结果：
当使用两个模板时，为什么fun(x1,y1)也能正确运行呢？因为当进行这个调用时，T1 = int ，T2 = int。所以这种调用也是没有问题的。
提到函数想到重载是很自然的吧，那么模板函数能不能重载呢？显然是能的了，还是看代码：
1 #include &iostream&
3 using namespace
6 template &typename T1 , typename T2&
7 T2 fun(T1 x,T2 y)
cout&&&调用了两个个参数的 fun 函数 ^^ &&&
T2 tmp = x *x + y * y + x *
13 template &typename T&
14 T fun(T x , T y , T z)
cout&&&调用了三个参数的 fun 函数 ^^ &&&
T tmp = x * x + y * y + z * z + x * y *
20 int main()
int x1 = 1 , y1 = 4 , z1 = 5;
float x2 = 1.1 , y2 = 2.2;
double x3 = 2.0 , y3 = 3.1;
cout&&fun(x1,y1)&&
cout&&fun(x2,y2)&&
cout&&fun(x3,y3)&&
cout&&fun(x1,y2)&&
cout&&fun(x1,y1,z1)&&
运行结果：
<img src="http://img.a扫一扫下载手机客户端
扫描我，关注团购信息，享更多优惠
||网络安全
| | | | | | | | | | | | | | | |
||电子电工
汽车交通| | | | | | | | | |
||投资理财
| | | | | | | | | | | | | | | | |
| | | | | | |
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
||外语考试
| | | | | | | | |
| 视频教程|
C++ 程序设计经典300例
定价：￥59.00
校园优惠价：￥50.15 (85折)
促销活动：
此商品暂时缺货（可留下联系方式，到货将第一时间通知您）
如果您急需团购，可点击“团购急调”按钮将此书加入购物车，由客服人员为您协调调货！
电话号码：
*邮箱地址：
ISBN：3上架时间：出版日期：2014 年6月开本：16开页码：362版次：1-1
所属分类：
《C++ 程序设计经典300例》针对C++语言的各个应用方向，分为3 篇共16 章，一共收集了300 个典型实例。第1 篇涉及C++语言的基础语法、数组、字符串、内存、指针、函数及类的应用等基础知识。第2 篇涵盖泛型编程技术、输入/输出系统及如何解决各类经典出错案例。第3 篇重点针对各类应用展开介绍，如一些基础技术的复杂应用实例、Socket 网络及进程间通信、算法、多线程、动态链接库技术的应用等，最后还通过实例演示了数字图像处理技术和三维仿真技术的相关应用。
《C++ 程序设计经典300例》实例具有代表性，能直接应用于真实的开发实践中，可作为自学C++语言和大中专院校师生提高编程实践能力的指导教材，也可作为在职C++开发人员的参考书。
毕业于西北工业大学，获信号与信息处理硕士学位，研究方向为虚拟现实的三维建模。硕士研究生期间一直致力于三维虚拟场景的编码工作，毕业后加入对口公司进行三维虚拟系统的开发。对C++和VC++有透彻、深入的理解。
《C++ 程序设计经典300例》
C++入门案例
从最简单的案例讲述C++ 1
在屏幕上输出内容 1
难度指数 ★☆☆☆☆
规格不同的箱子（变量） 2
难度指数 ★★☆☆☆
物品存放（变量） 3
难度指数 ★★☆☆☆
交换物品（变量） 4
难度指数 ★★☆☆☆
消失的重量（隐式类型转换） 4
难度指数 ★★☆☆☆
游泳池的容量 5
难度指数 ★★☆☆☆
显式转换（类型转换） 6
难度指数 ★★☆☆☆
单片机应用（位操作） 7
难度指数 ★★☆☆☆
房间面积（*） 8
　　对于正在学习C++语言的读者来说，模仿大量的案例并学习其详细的解析是一个必不可少的过程。本书精心选择了300个实例，对C++语言的常见应用进行了举例说明，其中不仅涵盖C++语言的各类基础知识，还包括高级应用及结合第三方库综合应用。本书凝聚了笔者多年学习并实践C++语言的开发经验和技巧。
　　本书的实例以最直观、最经典并紧密结合相关知识点的概念传授C++语言的编程知识和开发思想。在学习这300个实例的过程中，读者可以慢慢体会C++语言的编程套路，并形成自己的编程思维。书中的所有程序都已在Visual Studio开发平台下调试并通过，最后两章内容需要结合所介绍的相应版本库开发使用。
　　本书特点
　　本书选择的实例都是C++语言在开发应用过程中经常会遇到的编程问题，从实践的角度阐述如何运用C++语言的各个特性实现不同项目的开发。全书讲解由浅入深，内容全面，兼顾深度和广度，以期循序渐进地引导读者完成C++语言的学习。全书在内容安排和实例讲解上的主要特点如下。
　　前两篇的实例涵盖了C++语言的基本知识点，并且从实际应用出发使读者精通各个案例的发生背景。
　　讲解方式细致体贴，力求用准确的语言描述实例应用背景，用规范、精简的代码实现功能，用重点突出的方式提供注释介绍。
　　本书的实例代码长度适中，实现过程及思路有助于读者进一步领会新功能。
　　对于重要知识点，书中给出了详细的说明，以使读者做到触类旁通。
　　尽可能地体现C++语言在当前的应用思想，比如多线程、网络和算法应用等。
　　除了基本的C++语言应用，本书在最后两章介绍了使用OpenCV和OSG语言实现数字图像处理和三维仿真技术的开发，有助于读者了解这些专题的项目需求。
　　本书内容及知识体系
　　第1篇 C++入门案例（第1章～第7章），涵盖C++语言的基本语法知识、典型的变量类型，学习本篇有助于读者更深入地了解C++语言如何与计算机的内存进行“沟通”。
　　本篇包括128个实例，主要涉及C++语言的基础语法、数组、字符串、内存、指针、函数及类的应用等基础知识。
　　第2篇 C++进阶案例（第8章～第10章），介绍了相对高级的C++语言应用，以形成C++编程的抽象思维。
　　本篇包括68个实例，主要涉及泛型编程技术、输入/输出系统及如何解决各类经典出错案例。读者通过对这些案例的学习，为后续的大型项目应用提供了关键性的承上启下作用。
　　第3篇 C++高级案例（第11章～第16章），主要介绍一些C++语言的分支应用，通过对本篇的学习，使读者明确今后的发展方向。
　　本篇包括104个实例，主要涉及基础高级应用、Socket网络及进程间通信、算法、多线程、动态链接库技术的应用，最后包含数字图像处理技术和三维仿真技术两个专题。
　　本书约定
　　【实例描述】对实例的应用背景给出说明，部分实例给出运行效果。
　　【实现过程】给出解决问题的步骤和代码。
同类热销商品￥35.00￥24.50
订单处理配送
北京奥维博世图书发行有限公司 china-pub,All Rights ReservedBP神经网络原理及C++实战 - 推酷
BP神经网络原理及C++实战
前一段时间做了一个数字识别的小系统，基于 BP 神经网络算法的，用 MFC 做的交互。在实现过程中也试着去找一些源码，总体上来讲，这些源码的可移植性都不好，多数将交互部分和核心算法代码杂糅在一起，这样不仅代码阅读困难，而且重要的是核心算法不具备可移植性。设计模式，设计模式的重要性啊！于是自己将 BP 神经网络的核心算法用标准 C++ 实现，这样可移植性就有保证的，然后在核心算法上实现基于不同 GUI 库的交互（ MFC ， QT ）是能很快的搭建好系统的。下面边介绍 BP 算法的原理（请看《数字图像处理与机器视觉》非常适合做工程的伙伴），边给出代码的实现，最后给出基于核心算法构建交互的例子。
感知器是一种具有简单的两种输出的人工神经元，如下图所示。
只有 1 和 -1 两种输出的感知器实际上限制了其处理和分类的能力，下图是一种简单的推广，即不带阈值的感知器。
使用的是一个常用的误差度量标准，平方误差准则。公式如下。
其中 D 为训练样本， t d 为训练观测值 d 的训练输出， o t 为观测值 d 的实际观测值。如果是个凸函数就好了（搞数学的，一听到凸函数就很高兴，呵呵！），但还是可以用梯度下降的方法求其参数 w 。
梯度下降推导
在高等数学中梯度的概念实际上就是一个方向向量，也就是方向导数最大的方向，也就是说沿着这个方向，函数值的变化速度最快。我们这里是做梯度下降，那么就是沿着梯度的负方向更新参数 w 的值来快速达到 E 函数值的最小了。这样梯度下降算法的步骤基本如下：
初始化参数 w （随机，或其它方法）。
沿梯度方向更新参数 w ，可以添加一个学习率，也就是按多大的步子下降。
重复 1 ）， 2 ）， 3 ）直到达到设置的条件（迭代次数，或者 E 的减小量小于某个阈值）。
梯度的表达式如下：
那么如何求梯度呢？就是复合函数求导的过程，如下：
其中 x id 为样本中第 d 个观测值对应的一个输入分量 x i 。这样，训练过程中参数 w 的更新表达式如下（其中添加了一个学习率，也就是下降的步长）：
于是参数 w i
的更新增量为：
对于学习率选择的问题，一般较小是能够保证收敛的，看下图吧。
增量梯度下降
对于 4 中的梯度下降算法，其缺点是有时收敛速度慢，如果在误差曲面上存在多个局部极小值，算法不能保证能够找到全局极小值。为了改善这些缺点，提出了增量梯度下降算法。增量梯度下降，与 4 中的梯度下降的不同之处在于， 4 中对参数 w 的更新是根据整个样本中的观测值的误差来计算的， 而增量梯度下降算法是根据样本中单个观测值的误差来计算 w 的更新。
这是一个比较实用的内容，如何确定自己的代码就一定没有错呢？因为在求梯度的时候是很容易犯错误的，我就犯过了，嗨，调了两天才找出来，一个数组下表写错了，要是早一点看看斯坦福大学的深度学习基础教程就好了，这里只是截图一部分，有时间去仔细看看吧。
好了有了前面的基础，我们现在就可以进行实战了，构造多层神经网络。
Sigmoid 神经元可由下图表示：
神经网络层
一个三层的 BP 神经网络可由下图表示：
神经元和神经网络层的标准 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_nI //number of inputs
WEIGHT_TYPE*m_pW
//weights array of inputs
#ifdef NEED_MOMENTUM
WEIGHT_TYPE*m_pPrevU //record last weights update when momentum is needed
doublem_dA //output value, through Sigmoid function
doublem_dE //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
m_dActivation= 0; //output value, through SIgmoid function
m_dError= 0;
//error value of neuron
~SNeuron(){
//releasememory
delete[]m_pW
#ifdef NEED_MOMENTUM
delete[]m_pPrevU
};//SNeuron
struct SNeuronLayer{//neuron layer
/************Data**************/
intm_nN //Neuron number of this layer
SNeuron*m_pN //Neurons array
/*************Functions***************/
SNeuronLayer(intnNeuron, int nInputsPerNeuron){
m_nNeuron= nN
m_pNeurons= new SNeuron[nNeuron];
//allocatememory for nNeuron neurons
for(inti=0; i&nN i++){
m_pNeurons[i].Init(nInputsPerNeuron);
//initialize neuron
~SNeuronLayer(){
delete[]m_pN
//release neurons array
};//SNeuronLayer
#endif//__SNEURON_H__
代码中定义了一个 NEED_MOMENTUM ，它是用来解决局部极小值的问题的，其含义是本次权重的更新是依赖于上一次权重更新的。另外还有一种解决局部极小值问题的方法是，将 w 初始化为接近于 0 的随机数。
反向传播（ BP
前面虽然有了神经元和神经网络层的定义，但要构造一个三层的 BP 神经网络之前，还要搞清楚 BP 算法是如何来学习神经网络的参数的。它仍采用梯度下降算法，但不同的是这里的输出是整个网络的输出，而不再是一个单元的输出，所有对误差函数 E 重新定义如下：
其中 outputs 是网络中输出层单元的集合， t kd ， o kd 是训练样本中第 d 个观测值在第 k 个输出单元的而输出值。
1 ） BP 算法推导
先引入下列符号：
增量梯度下降算法中，对于每个训练样本中第 d 个观测的一个输入权重 w ij 的增量如下表示：
其中 E d 是训练样本中第 d 个观测的误差，通过对输出层所有单元的求和得到：
这里说明一下，神经网络输出层的所有单元联合一起表示一个样本观测的训练值的。假设样本观测值为 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 等。
下面我们就要求梯度了（要分层求解，输出层，隐藏层），梯度向量中的各元素求解如下：
1 ）当单元 j 是一个输出单元时：
于是得到：
2 ）当单元 j 是一个隐藏层单元时，有如下推导：
．标准 C++
构建三层 BP
该神经网络提供了重要的两个接口。一个是一次训练训练接口 TrainingEpoch ，可用于上层算法构建训练函数时调用；另一个是计算给定一个输入神经网络的输出接口 CalculateOutput ，它在一次训练函数中被调用，更重要的是，在上层算法中构建识别函数调用。
// NeuralNet.h: interface for theCNeuralNet class.
//////////////////////////////////////////////////////////////////////
#ifndef __NEURALNET_H__
#define __NEURALNET_H__
#include &vector&
#include &math.h&
#include &Neuron.h&
typedef vector&double&
#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{
/*Initialparameters, can not be changed throghout the whole training.*/
//number of inputs
intm_nO //number of outputs
intm_nNeuronsPerL //unit number of hidden layer
intm_nHiddenL //hidden layer, not including the output layer
/***Dinamicparameters****/
doublem_dErrorS
//one epoch's sum-error
SNeuronLayer*m_pHiddenL
//hidden layer
SNeuronLayer*m_pOutL
//output layer
*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_dErrorS }
SNeuronLayer*GetHiddenLyr(){ return m_pHiddenL }
SNeuronLayer*GetOutLyr(){ return m_pOutL }
*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= nI
m_nOutput= nO
m_nNeuronsPerLyr= nNeuronsPerL
if(nHiddenLayer!= 1)
m_nHiddenLayer= 1;
m_nHiddenLayer= nHiddenL //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_pHiddenL
if(m_pOutLyr!= NULL)
deletem_pOutL
void CNeuralNet::CreateNetwork(){
m_pHiddenLyr= new SNeuronLayer(m_nNeuronsPerLyr, m_nInput);
m_pOutLyr= new SNeuronLayer(m_nOutput, m_nNeuronsPerLyr);
void CNeuralNet::InitializeNetwork(){
//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_nN i++){
for(j=0;j&m_pHiddenLyr-&m_pNeurons[i].m_nI 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;
/*initializeoutput layer's weights*/
for(i=0;i&m_pOutLyr-&m_nN i++){
for(intj=0; j&m_pOutLyr-&m_pNeurons[i].m_nI 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;
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
doublenInputS
//sum term
/*computehidden layer output*/
for(i=0;i&m_pHiddenLyr-&m_nN 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_nN 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_dA
/*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);
bool CNeuralNet::TrainingEpoch(vector&iovector&&SetIn, vector&iovector&& SetOut, double LearningRate){
doubleWeightU
//weight's update value
//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++){
iovectorvecO
/*forwardlyspread inputs through network*/
if(!CalculateOutput(SetIn[i],vecOutputs)){
/*updatethe output layer's weights*/
for(j=0;j&m_pOutLyr-&m_nN j++){
/*computeerror term*/
err= ((double)SetOut[i][j]-vecOutputs[j])*vecOutputs[j]*(1-vecOutputs[j]);
m_pOutLyr-&m_pNeurons[j].m_dError=
//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_dA
#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]= WeightU
/*updateunit weights*/
m_pOutLyr-&m_pNeurons[j].m_pWeights[k]+= WeightU
/*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]= WeightU
/*updatebias*/
m_pOutLyr-&m_pNeurons[j].m_pWeights[k]+= WeightU
}//for out layer
/*updatethe hidden layer's weights*/
for(j=0;j&m_pHiddenLyr-&m_nN j++){
for(intk=0; k&m_pOutLyr-&m_nN 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=
//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]= WeightU
m_pHiddenLyr-&m_pNeurons[j].m_pWeights[k]+= WeightU
/*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]= WeightU
/*updatebias*/
m_pHiddenLyr-&m_pNeurons[j].m_pWeights[k]+= WeightU
}//forhidden layer
}//forone epoch
核心算法构建 MVC
到此为止我们的核心算法已经构建出来了，再应用两次 Strategy 设计模式，我们就很容易构建出一个 MVC 框架（ see also ： http://remyspot./4484 ）。下面给出一个应用 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{
/*network*/
CNeuralNet*m_oNetW
/*network'sparameter*/
intm_nNeuronsPerL
intm_nHiddenL
/*trainingconfiguration*/
intm_nMaxE
// max training epoch times
doublem_dMinE // error threshold
doublem_dLearningR
/*dinamiccurrent parameter*/
doublem_dE
//mean error of oneepoch(m_dErrorSum/(num-of-samples * num-of-output))
boolm_bS //control whether stop or not during the training
vector&double& m_vecE
//record each epoch'straining error, used for drawing error curve
COperateOnNeuralNet();
~COperateOnNeuralNet();
voidSetNetWorkParameter(int nInput, int nOutput, int nNeuronsPerLyr, intnHiddenLayer);
boolCreatNetWork();
voidSetTrainConfiguration(int nMaxEpoch, double dMinError, double dLearningRate);
voidSetStopFlag(bool bStop) { m_bStop = bS }
doubleGetError(){ return m_dE }
intGetEpoch(){ return m_nE }
intGetNumNeuronsPerLyr(){ return m_nNeuronsPerL }
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{
//version imformation
/*initialparameters*/
//number of inputs
intm_nO //number of outputs
intm_nNeuronsPerL //unit number of hidden layer
intm_nHiddenL //hidden layer, not including the output layer
/*trainingconfiguration*/
intm_nMaxE
// max training epoch times
doublem_dMinE // error threshold
doublem_dLearningR
/*dinamiccurrent parameter*/
doublem_dE
//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()
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;
COperateOnNeuralNet::~COperateOnNeuralNet(){
if(m_oNetWork)
deletem_oNetW
voidCOperateOnNeuralNet::SetNetWorkParameter(int nInput, int nOutput, intnNeuronsPerLyr, int nHiddenLayer){
assert(nInput&0 && nOutput&0 && nNeuronsPerLyr&0 &&nHiddenLayer&0 );
m_nInput= nI
m_nOutput= nO
m_nNeuronsPerLyr= nNeuronsPerL
m_nHiddenLayer= nHiddenL
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)
voidCOperateOnNeuralNet::SetTrainConfiguration(int nMaxEpoch, double dMinError,double dLearningRate){
assert(nMaxEpoch&0&& !(dMinError&0) && dLearningRate!=0);
m_nMaxEpoch= nMaxE
m_dMinError= dMinE
m_dLearningRate= dLearningR
boolCOperateOnNeuralNet::Train(vector&iovector&& SetIn, vector&iovector&&SetOut){
//no stop during training
CStringstrOutM
/*trainone epoch*/
if(!m_oNetWork-&TrainingEpoch(SetIn, SetOut, m_dLearningRate) ){
strOutMsg.Format(&Erroroccured at training %dth epoch!&,m_nEpochs+1);
AfxMessageBox(strOutMsg);
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){
/*stopin loop to chech wether user's action made or message sent, mostly for changem_bStop */
WaitForIdle();
if(m_bStop){
}while(--m_nMaxEpoch& 0);
boolCOperateOnNeuralNet::SaveTrainResultToFile(const char* lpszFileName, boolbCreate){
if(bCreate){
if(!file.Open(lpszFileName,CFile::modeWrite|CFile::modeCreate))
if(!file.Open(lpszFileName,CFile::modeWrite))
file.SeekToEnd();
//add to end of file
/*createnetwork head information*/
/*initialparameter*/
NEURALNET_HEADERheader = {0};
header.dwVersion= NEURALNET_VERSION;
header.m_nInput= m_nI
header.m_nOutput= m_nO
header.m_nNeuronsPerLyr= m_nNeuronsPerL
header.m_nHiddenLayer= m_nHiddenL
/*trainingconfiguration*/
header.m_nMaxEpoch= m_nMaxE
header.m_dMinError= m_dMinE
header.m_dLearningRate= m_dLearningR
/*dinamiccurrent parameter*/
header.m_nEpochs= m_nE
header.m_dErr= m_dE
file.Write(&header,sizeof(header));
/*writeweight information to file*/
/*hiddenlayer weight*/
for(i=0;i&m_oNetWork-&GetHiddenLyr()-&m_nN 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_nI 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_nN 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_nI j++){
file.Write(&m_oNetWork-&GetOutLyr()-&m_pNeurons[i].m_pWeights[j],
sizeof(m_oNetWork-&GetOutLyr()-&m_pNeurons[i].m_pWeights[j]));
file.Close();
boolCOperateOnNeuralNet::LoadTrainResultFromFile(const char* lpszFileName, DWORDdwStartPos){
if(!file.Open(lpszFileName,CFile::modeRead)){
file.Seek(dwStartPos,CFile::begin);
//point to dwStartPos
/*readin NeuralNet_Head infomation*/
NEURALNET_HEADERheader = {0};
if(file.Read(&header, sizeof(header)) != sizeof(header) ){
/*chechversion*/
if(header.dwVersion!= NEURALNET_VERSION){
/*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 ){
/*dynamicparameters*/
m_nEpochs= header.m_nE
//update trainingepochs
m_dErr= header.m_dE
//update training error
/*readin NetWork's weights*/
/*readin hidden layer weights*/
for(i=0;i&m_oNetWork-&GetHiddenLyr()-&m_nN 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_nI 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_nN 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_nI j++){
file.Read(&m_oNetWork-&GetOutLyr()-&m_pNeurons[i].m_pWeights[j],
sizeof(m_oNetWork-&GetOutLyr()-&m_pNeurons[i].m_pWeights[j]));
int COperateOnNeuralNet::Recognize(CStringstrPathName, CRect rt, double &dConfidence){
//category number
doubledMaxOut1 = 0; //max output
doubledMaxOut2 = 0; //second max output
if(!gray.AttachFromFile(strPathName)){
/*convert the picture waitiong for being recognized to vector*/
vector&double&vecToR
for(intj=rt. j&rt. j+= RESAMPLE_LEN){
for(inti=rt. i&rt. 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&
if(!m_oNetWork-&CalculateOutput(vecToRec,outputs)){
AfxMessageBox(&Recfailed!&);
/*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=
dConfidence= dMaxOut1 - dMaxOut2;
//compute beliefdegree
returnnBestM
本文出自 “Remys” 博客，谢绝转载！
已发表评论数()
请填写推刊名
描述不能大于100个字符!
权限设置： 公开
仅自己可见
正文不准确
标题不准确
排版有问题
主题不准确
没有分页内容
图片无法显示
视频无法显示
与原文不一致