java代碼實現(xiàn)深度神經(jīng)網(wǎng)絡算法

ID:192719 · 發(fā)表于 2017-4-23 16:20

對于現(xiàn)在流行的深度學習，保持學習精神是必要的——程序員尤其是架構師永遠都要對核心技術和關鍵算法保持關注和敏感，必要時要動手寫一寫掌握下來，先不用關心什么時候用到——用不用是管理問題，會不會寫是技術問題，就像軍人不關心打不打的問題，而要關心如何打贏的問題。

程序員如何學習機器學習

對程序員來說，機器學習是有一定門檻的（這個門檻也是其核心競爭力），相信很多人在學習機器學習時都會為滿是數(shù)學公式的英文論文而頭疼，甚至可能知難而退。但實際上機器學習算法落地程序并不難寫，下面是70行代碼實現(xiàn)的反向多層（BP）神經(jīng)網(wǎng)絡算法，也就是深度學習。其實不光是神經(jīng)網(wǎng)絡，邏輯回歸、決策樹C45/ID3、隨機森林、貝葉斯、協(xié)同過濾、圖計算、Kmeans、PageRank等大部分機器學習算法都能在100行單機程序內(nèi)實現(xiàn)（以后考慮分享出來）。

機器學習的真正難度在于它為什么要這么計算，它背后的數(shù)學原理是什么，怎么推導得來的公式，網(wǎng)上大部分的資料都在介紹這部分理論知識，卻很少告訴你該算法的計算過程和程序落地是怎么樣的，對于程序員來說，你需要做的僅是工程化應用，而不需要證明出一項新的數(shù)學計算方法。實際大部分機器學習工程師都是利用別人寫好的開源包或者工具軟件，輸入數(shù)據(jù)和調(diào)整計算系數(shù)來訓練結果，甚至很少自己實現(xiàn)算法過程。但是掌握每個算法的計算過程仍然非常重要，這樣你才能理解該算法讓數(shù)據(jù)產(chǎn)生了什么樣的變化，理解算法的目的是為了達到什么樣的效果。

本文重點探討反向神經(jīng)網(wǎng)絡的單機實現(xiàn)，關于神經(jīng)網(wǎng)絡的多機并行化， Fourinone 提供非常靈活完善的并行計算框架，我們只需要理解透單機程序實現(xiàn)，就能構思和設計出分布式并行化方案，如果不理解算法計算過程，一切思路將無法展開。另外，還有卷積神經(jīng)網(wǎng)絡，主要是一種降維思想，用于圖像處理，不在本文討論范圍。

延伸閱讀：

機器學習開發(fā)者的現(xiàn)代化路徑：不需要從統(tǒng)計學微積分開始
開發(fā)者成功使用機器學習的十大訣竅
機器學習溫和指南

神經(jīng)網(wǎng)絡的計算過程

神經(jīng)網(wǎng)絡結構如下圖所示，最左邊的是輸入層，最右邊的是輸出層，中間是多個隱含層，隱含層和輸出層的每個神經(jīng)節(jié)點，都是由上一層節(jié)點乘以其權重累加得到，標上“+1”的圓圈為截距項b，對輸入層外每個節(jié)點：Y=w0*x0+w1*x1+…+wn*xn+b，由此我們可以知道神經(jīng)網(wǎng)絡相當于一個多層邏輯回歸的結構。

（圖片來自 UFLDL Tutorial ）

算法計算過程：輸入層開始，從左往右計算，逐層往前直到輸出層產(chǎn)生結果。如果結果值和目標值有差距，再從右往左算，逐層向后計算每個節(jié)點的誤差，并且調(diào)整每個節(jié)點的所有權重，反向到達輸入層后，又重新向前計算，重復迭代以上步驟，直到所有權重參數(shù)收斂到一個合理值。由于計算機程序求解方程參數(shù)和數(shù)學求法不一樣，一般是先隨機選取參數(shù)，然后不斷調(diào)整參數(shù)減少誤差直到逼近正確值，所以大部分的機器學習都是在不斷迭代訓練，下面我們從程序上詳細看看該過程實現(xiàn)就清楚了。

神經(jīng)網(wǎng)絡的算法程序實現(xiàn)

神經(jīng)網(wǎng)絡的算法程序實現(xiàn)分為初始化、向前計算結果，反向修改權重三個過程。

1. 初始化過程

由于是n層神經(jīng)網(wǎng)絡，我們用二維數(shù)組layer記錄節(jié)點值，第一維為層數(shù)，第二維為該層節(jié)點位置，數(shù)組的值為節(jié)點值；同樣，節(jié)點誤差值layerErr也是相似方式記錄。用三維數(shù)組layer_weight記錄各節(jié)點權重，第一維為層數(shù)，第二維為該層節(jié)點位置，第三維為下層節(jié)點位置，數(shù)組的值為某節(jié)點到達下層某節(jié)點的權重值，初始值為0-1之間的隨機數(shù)。為了優(yōu)化收斂速度，這里采用動量法權值調(diào)整，需要記錄上一次權值調(diào)整量，用三維數(shù)組layer_weight_delta來記錄，截距項處理：程序里將截距的值設置為1，這樣只需要計算它的權重就可以了，

2. 向前計算結果

采用S函數(shù)1/(1+Math.exp(-z))將每個節(jié)點的值統(tǒng)一到0-1之間，再逐層向前計算直到輸出層，對于輸出層，實際上是不需要再用S函數(shù)的，我們這里將輸出結果視為0到1之間的概率值，所以也采用了S函數(shù)，這樣也有利于程序實現(xiàn)的統(tǒng)一性。

3. 反向修改權重

神經(jīng)網(wǎng)絡如何計算誤差，一般采用平方型誤差函數(shù)E，如下：

也就是將多個輸出項和對應目標值的誤差的平方累加起來，再除以2。實際上邏輯回歸的誤差函數(shù)也是這個，至于為什么要用這個函數(shù)來計算誤差，它從數(shù)學上的合理性是什么，怎么得來的，這個我建議程序員們不想當數(shù)學家的話，先不去深究了，現(xiàn)在我們要做的是如何把這個函數(shù)E誤差取它的最小值，需要對其進行求導，如果有些求導數(shù)學基礎的話，倒可以嘗試去推導下如何從函數(shù)E對權重求導得到下面這個公式的：

不會推導也沒有關系，我們只需要運用結果公式就可以了，在我們的程序里用layerErr記錄了E對權重求導后的最小化誤差，再根據(jù)最小化誤差去調(diào)整權重。

注意這里采用動量法調(diào)整，將上一次調(diào)整的經(jīng)驗考慮進來，避免陷入局部最小值，下面的k代表迭代次數(shù)，mobp為動量項，rate為學習步長：

Δw(k+1) = mobp*Δw(k)+rate*Err*Layer

也有很多使用下面的公式，效果上的差別不是太大：

Δw(k+1) = mobp*Δw(k)+(1-mobp)rate*Err*Layer

為了提升性能，注意程序實現(xiàn)是在一個while里面同時計算誤差和調(diào)整權重，先將位置定位到倒數(shù)第二層（也就是最后一層隱含層）上，然后逐層反向調(diào)整，根據(jù)L+1層算好的誤差來調(diào)整L層的權重，同時計算好L層的誤差，用于下一次循環(huán)到L-1層時計算權重，以此循環(huán)下去直到倒數(shù)第一層（輸入層）結束。

小結

在整個計算過程中，節(jié)點的值是每次計算都在變化的，不需要保存，而權重參數(shù)和誤差參數(shù)是需要保存的，需要為下一次迭代提供支持，因此，如果我們構思一個分布式的多機并行計算方案，就能理解其他框架中為什么會有一個Parameter Server的概念。

多層神經(jīng)網(wǎng)絡完整程序實現(xiàn)

下面的實現(xiàn)程序BpDeep.java可以直接拿去使用，也很容易修改為C、C#、Python等其他任何語言實現(xiàn)，因為都是使用的基本語句，沒有用到其他Java庫（除了Random函數(shù)）。以下為原創(chuàng)程序，轉載引用時請注明作者和出處。

import java.util.Random;
public class BpDeep{
public double[][] layer;//神經(jīng)網(wǎng)絡各層節(jié)點
public double[][] layerErr;//神經(jīng)網(wǎng)絡各節(jié)點誤差
public double[][][] layer_weight;//各層節(jié)點權重
public double[][][] layer_weight_delta;//各層節(jié)點權重動量
public double mobp;//動量系數(shù)
public double rate;//學習系數(shù)
public BpDeep(int[] layernum, double rate, double mobp){
this.mobp = mobp;
this.rate = rate;
layer = new double[layernum.length][];
layerErr = new double[layernum.length][];
layer_weight = new double[layernum.length][][];
layer_weight_delta = new double[layernum.length][][];
Random random = new Random();
for(int l=0;l<layernum.length;l++){
layer[l]=new double[layernum[l]];
layerErr[l]=new double[layernum[l]];
if(l+1<layernum.length){
layer_weight[l]=new double[layernum[l]+1][layernum[l+1]];
layer_weight_delta[l]=new double[layernum[l]+1][layernum[l+1]];
for(int j=0;j<layernum[l]+1;j++)
for(int i=0;i<layernum[l+1];i++)
layer_weight[l][j][i]=random.nextDouble();//隨機初始化權重
}
}
}
//逐層向前計算輸出
public double[] computeOut(double[] in){
for(int l=1;l<layer.length;l++){
for(int j=0;j<layer[l].length;j++){
double z=layer_weight[l-1][layer[l-1].length][j];
for(int i=0;i<layer[l-1].length;i++){
layer[l-1][i]=l==1?in[i]:layer[l-1][i];
z+=layer_weight[l-1][i][j]*layer[l-1][i];
}
layer[l][j]=1/(1+Math.exp(-z));
}
}
return layer[layer.length-1];
}
//逐層反向計算誤差并修改權重
public void updateWeight(double[] tar){
int l=layer.length-1;
for(int j=0;j<layerErr[l].length;j++)
layerErr[l][j]=layer[l][j]*(1-layer[l][j])*(tar[j]-layer[l][j]);
while(l-->0){
for(int j=0;j<layerErr[l].length;j++){
double z = 0.0;
for(int i=0;i<layerErr[l+1].length;i++){
z=z+l>0?layerErr[l+1][i]*layer_weight[l][j][i]:0;
layer_weight_delta[l][j][i]= mobp*layer_weight_delta[l][j][i]+rate*layerErr[l+1][i]*layer[l][j];//隱含層動量調(diào)整
layer_weight[l][j][i]+=layer_weight_delta[l][j][i];//隱含層權重調(diào)整
if(j==layerErr[l].length-1){
layer_weight_delta[l][j+1][i]= mobp*layer_weight_delta[l][j+1][i]+rate*layerErr[l+1][i];//截距動量調(diào)整
layer_weight[l][j+1][i]+=layer_weight_delta[l][j+1][i];//截距權重調(diào)整
}
}
layerErr[l][j]=z*layer[l][j]*(1-layer[l][j]);//記錄誤差
}
}
}
public void train(double[] in, double[] tar){
double[] out = computeOut(in);
updateWeight(tar);
}
}

復制代碼

一個運用神經(jīng)網(wǎng)絡的例子

最后我們找個簡單例子來看看神經(jīng)網(wǎng)絡神奇的效果。為了方便觀察數(shù)據(jù)分布，我們選用一個二維坐標的數(shù)據(jù)，下面共有4個數(shù)據(jù)，方塊代表數(shù)據(jù)的類型為1，三角代表數(shù)據(jù)的類型為0，可以看到屬于方塊類型的數(shù)據(jù)有（1，2）和（2，1），屬于三角類型的數(shù)據(jù)有（1，1），（2，2），現(xiàn)在問題是需要在平面上將4個數(shù)據(jù)分成1和0兩類，并以此來預測新的數(shù)據(jù)的類型。

我們可以運用邏輯回歸算法來解決上面的分類問題，但是邏輯回歸得到一個線性的直線做為分界線，可以看到上面的紅線無論怎么擺放，總是有一個樣本被錯誤地劃分到不同類型中，所以對于上面的數(shù)據(jù)，僅僅一條直線不能很正確地劃分他們的分類，如果我們運用神經(jīng)網(wǎng)絡算法，可以得到下圖的分類效果，相當于多條直線求并集來劃分空間，這樣準確性更高。

下面是這個測試程序BpDeepTest.java的源碼：

import java.util.Arrays;
public class BpDeepTest{
public static void main(String[] args){
//初始化神經(jīng)網(wǎng)絡的基本配置
//第一個參數(shù)是一個整型數(shù)組，表示神經(jīng)網(wǎng)絡的層數(shù)和每層節(jié)點數(shù)，比如{3,10,10,10,10,2}表示輸入層是3個節(jié)點，輸出層是2個節(jié)點，中間有4層隱含層，每層10個節(jié)點
//第二個參數(shù)是學習步長，第三個參數(shù)是動量系數(shù)
BpDeep bp = new BpDeep(new int[]{2,10,2}, 0.15, 0.8);
//設置樣本數(shù)據(jù)，對應上面的4個二維坐標數(shù)據(jù)
double[][] data = new double[][]{{1,2},{2,2},{1,1},{2,1}};
//設置目標數(shù)據(jù)，對應4個坐標數(shù)據(jù)的分類
double[][] target = new double[][]{{1,0},{0,1},{0,1},{1,0}};
//迭代訓練5000次
for(int n=0;n<5000;n++)
for(int i=0;i<data.length;i++)
bp.train(data[i], target[i]);
//根據(jù)訓練結果來檢驗樣本數(shù)據(jù)
for(int j=0;j<data.length;j++){
double[] result = bp.computeOut(data[j]);
System.out.println(Arrays.toString(data[j])+":"+Arrays.toString(result));
}
//根據(jù)訓練結果來預測一條新數(shù)據(jù)的分類
double[] x = new double[]{3,1};
double[] result = bp.computeOut(x);
System.out.println(Arrays.toString(x)+":"+Arrays.toString(result));
}
}

復制代碼

小結

以上測試程序顯示神經(jīng)網(wǎng)絡有很神奇的分類效果，實際上神經(jīng)網(wǎng)絡有一定優(yōu)勢，但也不是接近人腦的萬能算法，很多時候它可能會讓我們失望，還需要結合各種場景的數(shù)據(jù)大量運用去觀察其效果。我們可以把1層隱含層改成n層，并調(diào)整每層節(jié)點數(shù)、迭代次數(shù)、學習步長和動量系數(shù)，以獲得一個最優(yōu)化的結果。但是很多時候n層隱含層的效果并不比1層有明顯提升，反而計算更復雜耗時，我們對神經(jīng)網(wǎng)絡的認識還需要多實踐多體會。

作者簡介：彭淵，在Java技術領域從業(yè)十多年，曾撰寫多款開源軟件，歷任淘寶高級專家和華為中間件首席架構師。開源代表作有Fourinone（四不像）分布式核心技術框架、CoolHash并行數(shù)據(jù)庫引擎等，曾出版書籍《大規(guī)模分布式系統(tǒng)架構與設計實戰(zhàn)》。

ID:196521 · 發(fā)表于 2017-5-4 15:28

求指導，我用你的代碼運行一個不一樣的東西，結果很失望

import java.util.Random;
public class BpDeep{
public double[][] layer;//神經(jīng)網(wǎng)絡各層節(jié)點
public double[][] layerErr;//神經(jīng)網(wǎng)絡各節(jié)點誤差
public double[][][] layer_weight;//各層節(jié)點權重
public double[][][] layer_weight_delta;//各層節(jié)點權重動量
public double mobp;//動量系數(shù)
public double rate;//學習系數(shù)

public BpDeep(int[] layernum, double rate, double mobp){
      this.mobp = mobp;
      this.rate = rate;
      layer = new double[layernum.length][];
      layerErr = new double[layernum.length][];
      layer_weight = new double[layernum.length][][];
      layer_weight_delta = new double[layernum.length][][];
      Random random = new Random();
      for(int l=0;l<layernum.length;l++){
         layer[l]=new double[layernum[l]];
         layerErr[l]=new double[layernum[l]];
         if(l+1<layernum.length){
            layer_weight[l]=new double[layernum[l]+1][layernum[l+1]];
            layer_weight_delta[l]=new double[layernum[l]+1][layernum[l+1]];
            for(int j=0;j<layernum[l]+1;j++)
                  for(int i=0;i<layernum[l+1];i++)
                     layer_weight[l][j][i]=random.nextDouble();//隨機初始化權重
         }
      }
}
//逐層向前計算輸出
public double[] computeOut(double[] in){
      for(int l=1;l<layer.length;l++){
         for(int j=0;j<layer[l].length;j++){
            double z=layer_weight[l-1][layer[l-1].length][j];
            for(int i=0;i<layer[l-1].length;i++){
                  layer[l-1][i]=l==1?in[i]:layer[l-1][i];
                  z+=layer_weight[l-1][i][j]*layer[l-1][i];
            }
            layer[l][j]=1/(1+Math.exp(-z));
         }
      }
      return layer[layer.length-1];
}
//逐層反向計算誤差并修改權重
public void updateWeight(double[] tar){
      int l=layer.length-1;
      for(int j=0;j<layerErr[l].length;j++)
         layerErr[l][j]=layer[l][j]*(1-layer[l][j])*(tar[j]-layer[l][j]);

      while(l-->0){
         for(int j=0;j<layerErr[l].length;j++){
            double z = 0.0;
            for(int i=0;i<layerErr[l+1].length;i++){
                  z=z+l>0?layerErr[l+1][i]*layer_weight[l][j][i]:0;
                  layer_weight_delta[l][j][i]= mobp*layer_weight_delta[l][j][i]+rate*layerErr[l+1][i]*layer[l][j];//隱含層動量調(diào)整
                  layer_weight[l][j][i]+=layer_weight_delta[l][j][i];//隱含層權重調(diào)整
                  if(j==layerErr[l].length-1){
                     layer_weight_delta[l][j+1][i]= mobp*layer_weight_delta[l][j+1][i]+rate*layerErr[l+1][i];//截距動量調(diào)整
                     layer_weight[l][j+1][i]+=layer_weight_delta[l][j+1][i];//截距權重調(diào)整
                  }
            }
            layerErr[l][j]=z*layer[l][j]*(1-layer[l][j]);//記錄誤差
         }
      }
}

public void train(double[] in, double[] tar){
      double[] out = computeOut(in);
      updateWeight(tar);
}
}

import java.util.Arrays;
public class MyBPtest1{
public static void main(String[] args){
      //初始化神經(jīng)網(wǎng)絡的基本配置
      //第一個參數(shù)是一個整型數(shù)組，表示神經(jīng)網(wǎng)絡的層數(shù)和每層節(jié)點數(shù)，比如{3,10,10,10,10,2}表示輸入層是3個節(jié)點，輸出層是2個節(jié)點，中間有4層隱含層，每層10個節(jié)點
      /////////第二個參數(shù)是學習步長（過小會使收斂速度太慢；過大則會使預測不準，跳過一些細節(jié)），
/////////第三個參數(shù)是動量系數(shù)（使波動小的預測重新振蕩起來）
      BpDeep bp = new BpDeep(new int[]{5,5,1}, 0.15, 0.9);

      ////////對于輸入樣本如果只有一個數(shù)。沒關系，大不了{,}第二項里的data和target全為0,,,,!!!!這理解是錯誤
      ////////因為我們設定了輸入層為2，才會有兩個輸入（{，}，{，}}這樣的東西；同理輸入層也為如此
      ////////所以說如果是5個輸入，一個輸出對于data就{{，，，，}，{，，，，}。。。。。。}；；；；；對于target{，，，，}
      double[][] data = new double[][]{{192,195,194,193,193},
        {195,194,193,193,195},{194,193,193,195,201},
        {193,193,195,201,205},{193,195,201,205,205},
        {195,201,205,205,203},{201,205,205,203,203},
        {205,205,203,203,202},{205,203,203,202,206},
        {203,203,202,206,204},{203,202,206,204,204},
        {202,206,204,204,203},{206,204,204,203,199},
        {204,204,203,199,195},{204,203,199,195,182},
        {203,199,195,182,179},{199,195,182,179,178},
        {195,182,179,178,176},{182,179,178,176,175},
        {179,178,176,175,173},{178,176,175,173,175},
        {176,175,173,175,182},{175,173,175,182,183},
        {173,175,182,183,185},{175,182,183,185,179}};
      //設置目標數(shù)據(jù)，對應4個坐標數(shù)據(jù)的分類
      double[][] target = new double[][]{{195},{201},{205},{205},{203},
                 {203},{202},{206},{204},{204},{203},{199},{195},{182},{179},
                 {178},{176},{175},{173},{175},{182},{183},{185},{179},{182}};

      //迭代訓練5000次
      ///////這里我們沒有設置訓練到了某一精確度自動停止，而是實打實的訓練這些次數(shù)
      for(int n=0;n<5000;n++)
         for(int i=0;i<data.length;i++)
            bp.train(data[i], target[i]);

      //根據(jù)訓練結果來檢驗樣本數(shù)據(jù)
      for(int j=0;j<data.length;j++){
         double[] result = bp.computeOut(data[j]);
         System.out.println(Arrays.toString(data[j])+":"+Arrays.toString(result));
      }

      //根據(jù)訓練結果來預測一條新數(shù)據(jù)的分類
      double[] x = new double[]{192,195,194,193,193};
      double[] result = bp.computeOut(x);
      System.out.println(Arrays.toString(x)+":"+Arrays.toString(result));
}
}

帳號		自動登錄	找回密碼
密碼			立即注冊

java代碼實現(xiàn)深度神經(jīng)網(wǎng)絡算法

相關帖子