http://blog.csdn.net/runatworld/article/details/50774215

BP神經網絡

Algorithm（3） 

今天來講BP神經網絡，神經網絡在機器學習中應用比較廣泛，比如函數逼近，模式識別，分類，數據壓縮，數據

挖掘等領域。接下來介紹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：

BP.cpp：

[cpp] view%20plain copy  #include <string.h>  #include <stdio.h>  #include <math.h>  #include <assert.h>  #include "BP.h"    //獲取訓練所有樣本數據  void BP::GetData(const Vector<Data> _data)  {      data = _data;  }    //開始進行訓練  void BP::Train()  {      printf("Begin to train BP NetWork!/n");      GetNums();      InitNetWork();      int num = data.size();        for(int iter = 0; iter <= ITERS; iter++)      {          for(int cnt = 0; cnt < num; cnt++)          {              //第一層輸入節點賦值              for(int i = 0; i < in_num; i++)                  x[0][i] = data.at(cnt).x[i];                while(1)              {                  ForwardTransfer();                       if(GetError(cnt) < ERROR)    //如果誤差比較小，則針對單個樣本跳出循環                      break;                  ReverseTransfer(cnt);                }          }          printf("This is the %d th trainning NetWork !/n", iter);            Type accu = GetAccu();          printf("All Samples Accuracy is %lf/n", accu);          if(accu < ACCU) break;      }      printf("The BP NetWork train End!/n");  }    //根據訓練好的網絡來預測輸出值  Vector<Type> BP::ForeCast(const Vector<Type> data)  {      int n = data.size();      assert(n == in_num);      for(int i = 0; i < in_num; i++)          x[0][i] = data[i];            ForwardTransfer();      Vector<Type> v;      for(int i = 0; i < ou_num; i++)          v.push_back(x[2][i]);      return v;  }    //獲取網絡節點數  void BP::GetNums()  {      in_num = data[0].x.size();                         //獲取輸入層節點數      ou_num = data[0].y.size();                         //獲取輸出層節點數      hd_num = (int)sqrt((in_num + ou_num) * 1.0) + 5;   //獲取隱含層節點數      if(hd_num > NUM) hd_num = NUM;                     //隱含層數目不能超過最大設置  }    //初始化網絡  void BP::InitNetWork()  {      memset(w, 0, sizeof(w));      //初始化權值和閥值為0，也可以初始化隨機值      memset(b, 0, sizeof(b));  }    //工作信號正向傳遞子過程  void BP::ForwardTransfer()  {      //計算隱含層各個節點的輸出值      for(int j = 0; j < hd_num; j++)      {          Type t = 0;          for(int i = 0; i < in_num; i++)              t += w[1][i][j] * x[0][i];          t += b[1][j];          x[1][j] = Sigmoid(t);      }        //計算輸出層各節點的輸出值      for(int j = 0; j < ou_num; j++)      {          Type t = 0;          for(int i = 0; i < hd_num; i++)              t += w[2][i][j] * x[1][i];          t += b[2][j];          x[2][j] = Sigmoid(t);      }  }    //計算單個樣本的誤差  Type BP::GetError(int cnt)  {      Type ans = 0;      for(int i = 0; i < ou_num; i++)          ans += 0.5 * (x[2][i] - data.at(cnt).y[i]) * (x[2][i] - data.at(cnt).y[i]);      return ans;  }    //誤差信號反向傳遞子過程  void BP::ReverseTransfer(int cnt)  {      CalcDelta(cnt);         UpdateNetWork();  }    //計算所有樣本的精度  Type BP::GetAccu()  {      Type ans = 0;      int num = data.size();      for(int i = 0; i < num; i++)      {          int m = data.at(i).x.size();          for(int j = 0; j < m; j++)              x[0][j] = data.at(i).x[j];          ForwardTransfer();          int n = data.at(i).y.size();          for(int j = 0; j < n; j++)              ans += 0.5 * (x[2][j] - data.at(i).y[j]) * (x[2][j] - data.at(i).y[j]);      }      return ans / num;  }    //計算調整量  void BP::CalcDelta(int cnt)  {      //計算輸出層的delta值      for(int i = 0; i < ou_num; i++)          d[2][i] = (x[2][i] - data.at(cnt).y[i]) * x[2][i] * (A - x[2][i]) / (A * B);      //計算隱含層的delta值      for(int i = 0; i < hd_num; i++)      {          Type t = 0;          for(int j = 0; j < ou_num; j++)              t += w[2][i][j] * d[2][j];          d[1][i] = t * x[1][i] * (A - x[1][i]) / (A * B);      }  }    //根據計算出的調整量對BP網絡進行調整  void BP::UpdateNetWork()  {      //隱含層和輸出層之間權值和閥值調整      for(int i = 0; i < hd_num; i++)      {          for(int j = 0; j < ou_num; j++)              w[2][i][j] -= ETA_W * d[2][j] * x[1][i];       }      for(int i = 0; i < ou_num; i++)          b[2][i] -= ETA_B * d[2][i];        //輸入層和隱含層之間權值和閥值調整      for(int i = 0; i < in_num; i++)      {          for(int j = 0; j < hd_num; j++)              w[1][i][j] -= ETA_W * d[1][j] * x[0][i];      }      for(int i = 0; i < hd_num; i++)          b[1][i] -= ETA_B * d[1][i];  }    //計算Sigmoid函數的值  Type BP::Sigmoid(const Type x)  {      return A / (1 + exp(-x / B));  }  

Test.cpp：

[cpp] view%20plain copy  #include <iostream>  #include <string.h>  #include <stdio.h>     #include "BP.h"     using namespace std;     double sample[41][4]=   {       {0,0,0,0},       {5,1,4,19.020},       {5,3,3,14.150},       {5,5,2,14.360},       {5,3,3,14.150},       {5,3,2,15.390},       {5,3,2,15.390},       {5,5,1,19.680},       {5,1,2,21.060},       {5,3,3,14.150},       {5,5,4,12.680},       {5,5,2,14.360},       {5,1,3,19.610},       {5,3,4,13.650},       {5,5,5,12.430},       {5,1,4,19.020},       {5,1,4,19.020},       {5,3,5,13.390},       {5,5,4,12.680},       {5,1,3,19.610},       {5,3,2,15.390},       {1,3,1,11.110},       {1,5,2,6.521},       {1,1,3,10.190},       {1,3,4,6.043},       {1,5,5,5.242},       {1,5,3,5.724},       {1,1,4,9.766},       {1,3,5,5.870},       {1,5,4,5.406},       {1,1,3,10.190},       {1,1,5,9.545},       {1,3,4,6.043},       {1,5,3,5.724},       {1,1,2,11.250},       {1,3,1,11.110},       {1,3,3,6.380},       {1,5,2,6.521},       {1,1,1,16.000},       {1,3,2,7.219},       {1,5,3,5.724}   };      int main()  {      Vector<Data> data;      for(int i = 0; i < 41; i++)      {          Data t;          for(int j = 0; j < 3; j++)              t.x.push_back(sample[i][j]);          t.y.push_back(sample[i][3]);          data.push_back(t);      }      BP *bp = new BP();      bp->GetData(data);      bp->Train();         while(1)      {          Vector<Type> in;          for(int i = 0; i < 3; i++)          {              Type v;              scanf("%lf", &v);              in.push_back(v);          }          Vector<Type> ou;          ou = bp->ForeCast(in);          printf("%lf/n", ou[0]);      }      return 0;  }   

Makefile：

[cpp] view%20plain copy  Test : BP.h BP.cpp Test.cpp      g++ BP.cpp Test.cpp -o Test     clean:      rm Test