BP神经网络

BP神经网络。今天来讲BP神经网络，神经网络在机器学习中应用比较广泛，比如函数逼近，模式识别，分类，数据压缩，数据挖掘等领域。接下来介绍BP神经网络的原理及实现。

总结：简单的描述就是，输入层将刺激传递给隐藏层，隐藏层通过神经元之间联系的强度(权重)和传递规则(激活函数)将刺激传到输出层，输出层整理隐藏层处理后的刺激产生最终结果。若有正确的结果，那么将正确的结果(相当于知道了精确答案，与这个网络算出的结果相对比，来看这个网络是否能正确计算)和产生的结果进行比较，得到误差，再逆推对神经网中的链接权重进行反馈修正，从而来完成学习的过程，这就是BP(Back Propagation)神经网的反馈机制，也正是BP名字的来源。

Contents

1. BP神经网络的认识

2. 隐含层的选取

3. 正向传递子过程

4. 反向传递子过程

5. BP神经网络的注意点

6. BP神经网络的C++实现

1. BP神经网络的认识

BP(Back Propagation)神经网络分为两个过程

(1)工作信号正向传递子过程

(2)误差信号反向传递子过程

在BP神经网络中，单个样本有

个输入，有

个输出，在输入层和输出层之间通常还有若干个隐含层。实际

上，1989年Robert Hecht-Nielsen证明了对于任何闭区间内的一个连续函数都可以用一个隐含层的BP网

络来逼近，这就是万能逼近定理。所以一个三层的BP网络就可以完成任意的

维到

维的映射。即这三层分

别是输入层(I)，隐含层(H)，输出层(O)。如下图示

2. 隐含层的选取

在BP神经网络中，输入层和输出层的节点个数都是确定的，而隐含层节点个数不确定，那么应该设置为多少

才合适呢?实际上，隐含层节点个数的多少对神经网络的性能是有影响的，有一个经验公式可以确定隐含层

节点数目，如下

其中

为隐含层节点数目，

为输入层节点数目，

为输出层节点数目，

为

之间的调节常数。

3. 正向传递子过程

现在设节点

和节点

之间的权值为

，节点

的阀值为

，每个节点的输出值为

，而每个节点的输出

值是根据上层所有节点的输出值、当前节点与上一层所有节点的权值和当前节点的阀值还有激活函数来实现

的。具体计算方法如下

其中

为激活函数，一般选取S型函数或者线性函数。

正向传递的过程比较简单，按照上述公式计算即可。在BP神经网络中，输入层节点没有阀值。

4. 反向传递子过程

在BP神经网络中，误差信号反向传递子过程比较复杂，它是基于Widrow-Hoff学习规则的。假设输出层

的所有结果为

，误差函数如下

而BP神经网络的主要目的是反复修正权值和阀值，使得误差函数值达到最小。Widrow-Hoff学习规则

是通过沿着相对误差平方和的最速下降方向，连续调整网络的权值和阀值，根据梯度下降法，权值矢量

的修正正比于当前位置上E(w,b)的梯度，对于第

个输出节点有

假设选择激活函数为

对激活函数求导，得到

那么接下来针对

有

其中有

同样对于

有

这就是著名的

学习规则，通过改变神经元之间的连接权值来减少系统实际输出和期望输出的误差，这个规

则又叫做Widrow-Hoff学习规则或者纠错学习规则。

上面是对隐含层和输出层之间的权值和输出层的阀值计算调整量，而针对输入层和隐含层和隐含层的阀值调

整量的计算更为复杂。假设

是输入层第k个节点和隐含层第i个节点之间的权值，那么有

其中有

这样对

学习规则理解更为深刻了吧。

有了上述公式，根据梯度下降法，那么对于隐含层和输出层之间的权值和阀值调整如下

而对于输入层和隐含层之间的权值和阀值调整同样有

至此BP神经网络的原理基本讲完。

5. BP神经网络的注意点

BP神经网络一般用于分类或者逼近问题。如果用于分类，则激活函数一般选用Sigmoid函数或者硬极限函

数，如果用于函数逼近，则输出层节点用线性函数，即

。

BP神经网络在训练数据时可以采用增量学习或者批量学习。

增量学习要求输入模式要有足够的随机性，对输入模式的噪声比较敏感，即对于剧烈变化的输入模式，训

练效果比较差，适合在线处理。批量学习不存在输入模式次序问题，稳定性好，但是只适合离线处理。

标准BP神经网络的缺陷：

(1)容易形成局部极小值而得不到全局最优值。

BP神经网络中极小值比较多，所以很容易陷入局部极小值，这就要求对初始权值和阀值有要求，要使

得初始权值和阀值随机性足够好，可以多次随机来实现。

(2)训练次数多使得学习效率低，收敛速度慢。

(3)隐含层的选取缺乏理论的指导。

(4)训练时学习新样本有遗忘旧样本的趋势。

BP算法的改进：

(1)增加动量项

引入动量项是为了加速算法收敛，即如下公式

动量因子

一般选取

。

(2)自适应调节学习率

(3)引入陡度因子

通常BP神经网络在训练之前会对数据归一化处理，即将数据映射到更小的区间内，比如[0,1]或[-1,1]。

6. BP神经网络的C++实现

BP神经网络的C++文件如下

BP.h：

1. #ifndef_BP_H_
2. #define_BP_H_
3.  
4. #include
5.  
6. #defineLAYER3//三层神经网络
7. #defineNUM10//每层的最多节点数
8.  
9. #defineA30.0
10. #defineB10.0//A和B是S型函数的参数
11. #defineITERS1000//最大训练次数
12. #defineETA_W0.0035//权值调整率
13. #defineETA_B0.001//阀值调整率
14. #defineERROR0.002//单个样本允许的误差
15. #defineACCU0.005//每次迭代允许的误差
16.  
17. #defineTypedouble
18. #defineVectorstd::vector
19.  
20. structData
21. {
22. Vectorx;//输入数据
23. Vectory;//输出数据
24. };
25.  
26. classBP{
27.  
28. public:
29.  
30. voidGetData(constVector);
31. voidTrain();
32. VectorForeCast(constVector);
33.  
34. private:
35.  
36. voidInitNetWork();//初始化网络
37. voidGetNums();//获取输入、输出和隐含层节点数
38. voidForwardTransfer();//正向传播子过程
39. voidReverseTransfer(int);//逆向传播子过程
40. voidCalcDelta(int);//计算w和b的调整量
41. voidUpdateNetWork();//更新权值和阀值
42. TypeGetError(int);//计算单个样本的误差
43. TypeGetAccu();//计算所有样本的精度
44. TypeSigmoid(constType);//计算Sigmoid的值
45.  
46. private:
47. intin_num;//输入层节点数
48. intou_num;//输出层节点数
49. inthd_num;//隐含层节点数
50.  
51. Vectordata;//输入输出数据
52.  
53. Typew[LAYER][NUM][NUM];//BP网络的权值
54. Typeb[LAYER][NUM];//BP网络节点的阀值
55.  
56. Typex[LAYER][NUM];//每个神经元的值经S型函数转化后的输出值，输入层就为原值
57. Typed[LAYER][NUM];//记录delta学习规则中delta的值
58. };
59.  
60. #endif//_BP_H_

    
    BP.cpp：

    view plaincopy
     
    1. #include
    2. #include
    3. #include
    4. #include
    5. #include"BP.h"
    6.  
    7. //获取训练所有样本数据
    8. voidBP::GetData(constVector_data)
    9. {
    10. data=_data;
    11. }
    12.  
    13. //开始进行训练
    14. voidBP::Train()
    15. {
    16. printf("BegintotrainBPNetWork!\n");
    17. GetNums();
    18. InitNetWork();
    19. intnum=data.size();
    20.  
    21. for(intiter=0;iter<=ITERS;iter++)
    22. {
    23. for(intcnt=0;cnt<>
    24. {
    26. //第一层输入节点赋值
    27. for(inti=0;i<>
    28. x[0][i]=data.at(cnt).x[i];
    30.  
    31. while(1)
    32. {
    33. ForwardTransfer();
    34. if(GetError(cnt) break;
    35. ReverseTransfer(cnt);
    36. }
    37. }
    38. printf("Thisisthe%dthtrainningNetWork!\n",iter);
    39.  
    40. Typeaccu=GetAccu();
    41. printf("AllSamplesAccuracyis%lf\n",accu);
    42. if(accu<>
    43. }
    45. printf("TheBPNetWorktrainEnd!\n");
    46. }
    47.  
    48. //根据训练好的网络来预测输出值
    49. VectorBP::ForeCast(constVectordata)
    50. {
    51. intn=data.size();
    52. assert(n==in_num);
    53. for(inti=0;i<>
    54. x[0][i]=data[i];
    56.  
    57. ForwardTransfer();
    58. Vectorv;
    59. for(inti=0;i<>
    60. v.push_back(x[2][i]);
    62. returnv;
    63. }
    64.  
    65. //获取网络节点数
    66. voidBP::GetNums()
    67. {
    68. in_num=data[0].x.size();//获取输入层节点数
    69. ou_num=data[0].y.size();//获取输出层节点数
    70. hd_num=(int)sqrt((in_num+ou_num)*1.0)+5;//获取隐含层节点数
    71. if(hd_num>NUM)hd_num=NUM;//隐含层数目不能超过最大设置
    72. }
    73.  
    74. //初始化网络
    75. voidBP::InitNetWork()
    76. {
    77. memset(w,0,sizeof(w));//初始化权值和阀值为0，也可以初始化随机值
    78. memset(b,0,sizeof(b));
    79. }
    80.  
    81. //工作信号正向传递子过程
    82. voidBP::ForwardTransfer()
    83. {
    84. //计算隐含层各个节点的输出值
    85. for(intj=0;j<>
    86. {
    88. Typet=0;
    89. for(inti=0;i<>
    90. t+=w[1][i][j]*x[0][i];
    92. t+=b[1][j];
    93. x[1][j]=Sigmoid(t);
    94. }
    95.  
    96. //计算输出层各节点的输出值
    97. for(intj=0;j<>
    98. {
    100. Typet=0;
    101. for(inti=0;i<>
    102. t+=w[2][i][j]*x[1][i];
    104. t+=b[2][j];
    105. x[2][j]=Sigmoid(t);
    106. }
    107. }
    108.  
    109. //计算单个样本的误差
    110. TypeBP::GetError(intcnt)
    111. {
    112. Typeans=0;
    113. for(inti=0;i<>
    114. ans+=0.5*(x[2][i]-data.at(cnt).y[i])*(x[2][i]-data.at(cnt).y[i]);
    116. returnans;
    117. }
    118.  
    119. //误差信号反向传递子过程
    120. voidBP::ReverseTransfer(intcnt)
    121. {
    122. CalcDelta(cnt);
    123. UpdateNetWork();
    124. }
    125.  
    126. //计算所有样本的精度
    127. TypeBP::GetAccu()
    128. {
    129. Typeans=0;
    130. intnum=data.size();
    131. for(inti=0;i<>
    132. {
    134. intm=data.at(i).x.size();
    135. for(intj=0;j<>
    136. x[0][j]=data.at(i).x[j];
    138. ForwardTransfer();
    139. intn=data.at(i).y.size();
    140. for(intj=0;j<>
    141. ans+=0.5*(x[2][j]-data.at(i).y[j])*(x[2][j]-data.at(i).y[j]);
    143. }
    144. returnans/num;
    145. }
    146.  
    147. //计算调整量
    148. voidBP::CalcDelta(intcnt)
    149. {
    150. //计算输出层的delta值
    151. for(inti=0;i<>
    152. d[2][i]=(x[2][i]-data.at(cnt).y[i])*x[2][i]*(A-x[2][i])/(A*B);
    154. //计算隐含层的delta值
    155. for(inti=0;i<>
    156. {
    158. Typet=0;
    159. for(intj=0;j<>
    160. t+=w[2][i][j]*d[2][j];
    162. d[1][i]=t*x[1][i]*(A-x[1][i])/(A*B);
    163. }
    164. }
    165.  
    166. //根据计算出的调整量对BP网络进行调整
    167. voidBP::UpdateNetWork()
    168. {
    169. //隐含层和输出层之间权值和阀值调整
    170. for(inti=0;i<>
    171. {
    173. for(intj=0;j<>
    174. w[2][i][j]-=ETA_W*d[2][j]*x[1][i];
    176. }
    177. for(inti=0;i<>
    178. b[2][i]-=ETA_B*d[2][i];
    180.  
    181. //输入层和隐含层之间权值和阀值调整
    182. for(inti=0;i<>
    183. {
    185. for(intj=0;j<>
    186. w[1][i][j]-=ETA_W*d[1][j]*x[0][i];
    188. }
    189. for(inti=0;i<>
    190. b[1][i]-=ETA_B*d[1][i];
    192. }
    193.  
    194. //计算Sigmoid函数的值
    195. TypeBP::Sigmoid(constTypex)
    196. {
    197. returnA/(1+exp(-x/B));
    198. }

         Test.cpp：

         view plaincopy
          
         1. #include
         2. #include
         3. #include
         4.  
         5. #include"BP.h"
         6.  
         7. usingnamespacestd;
         8.  
         9. doublesample[41][4]=
         10. {
         11. {0,0,0,0},
         12. {5,1,4,19.020},
         13. {5,3,3,14.150},
         14. {5,5,2,14.360},
         15. {5,3,3,14.150},
         16. {5,3,2,15.390},
         17. {5,3,2,15.390},
         18. {5,5,1,19.680},
         19. {5,1,2,21.060},
         20. {5,3,3,14.150},
         21. {5,5,4,12.680},
         22. {5,5,2,14.360},
         23. {5,1,3,19.610},
         24. {5,3,4,13.650},
         25. {5,5,5,12.430},
         26. {5,1,4,19.020},
         27. {5,1,4,19.020},
         28. {5,3,5,13.390},
         29. {5,5,4,12.680},
         30. {5,1,3,19.610},
         31. {5,3,2,15.390},
         32. {1,3,1,11.110},
         33. {1,5,2,6.521},
         34. {1,1,3,10.190},
         35. {1,3,4,6.043},
         36. {1,5,5,5.242},
         37. {1,5,3,5.724},
         38. {1,1,4,9.766},
         39. {1,3,5,5.870},
         40. {1,5,4,5.406},
         41. {1,1,3,10.190},
         42. {1,1,5,9.545},
         43. {1,3,4,6.043},
         44. {1,5,3,5.724},
         45. {1,1,2,11.250},
         46. {1,3,1,11.110},
         47. {1,3,3,6.380},
         48. {1,5,2,6.521},
         49. {1,1,1,16.000},
         50. {1,3,2,7.219},
         51. {1,5,3,5.724}
         52. };
         53.  
         54. intmain()
         55. {
         56. Vectordata;
         57. for(inti=0;i<41;i++)
         58. {
         59. Datat;
         60. for(intj=0;j<3;j++)
         61. t.x.push_back(sample[i][j]);
         62. t.y.push_back(sample[i][3]);
         63. data.push_back(t);
         64. }
         65. BP*bp=newBP();
         66. bp->GetData(data);
         67. bp->Train();
         68.  
         69. while(1)
         70. {
         71. Vectorin;
         72. for(inti=0;i<3;i++)
         73. {
         74. Typev;
         75. scanf("%lf",&v);
         76. in.push_back(v);
         77. }
         78. Vectorou;
         79. ou=bp->ForeCast(in);
         80. printf("%lf\n",ou[0]);
         81. }
         82. return0;
         83. }

             Makefile：

             view plaincopy
              
             1. Test:BP.hBP.cppTest.cpp
             2. g++BP.cppTest.cpp-oTest
             3.  
             4. clean:
             5. rmTest