對于現在流行的深度學習，保持學習精神是必要的——程序員尤其是架構師永遠都要對核心技術和關鍵算法保持關注和敏感，必要時要動手寫一寫掌握下來，先不用關心什么時候用到——用不用是政治問題，會不會寫是技術問題，就像軍人不關心打不打的問題，而要關心如何打贏的問題。
程序員如何學習機器學習
對程序員來說，機器學習是有一定門檻的（這個門檻也是其核心競爭力），相信很多人在學習機器學習時都會為滿是數學公式的英文論文而頭疼，甚至可能知難而退。但實際上機器學習算法落地程序并不難寫，下面是70行代碼實現的反向多層（bp）神經網絡算法，也就是深度學習。其實不光是神經網絡，邏輯回歸、決策樹c45/id3、隨機森林、貝葉斯、協同過濾、圖計算、kmeans、pagerank等大部分機器學習算法都能在100行單機程序內實現（以后考慮分享出來）。
機器學習的真正難度在于它為什么要這么計算，它背后的數學原理是什么，怎么推導得來的公式，網上大部分的資料都在介紹這部分理論知識，卻很少告訴你該算法的計算過程和程序落地是怎么樣的，對于程序員來說，你需要做的僅是工程化應用，而不需要證明出一項新的數學計算方法。實際大部分機器學習工程師都是利用別人寫好的開源包或者工具軟件，輸入數據和調整計算系數來訓練結果，甚至很少自己實現算法過程。但是掌握每個算法的計算過程仍然非常重要，這樣你才能理解該算法讓數據產生了什么樣的變化，理解算法的目的是為了達到什么樣的效果。
本文重點探討反向神經網絡的單機實現，關于神經網絡的多機并行化， fourinone 提供非常靈活完善的并行計算框架，我們只需要理解透單機程序實現，就能構思和設計出分布式并行化方案，如果不理解算法計算過程，一切思路將無法展開。另外，還有卷積神經網絡，主要是一種降維思想，用于圖像處理，不在本文討論范圍。
神經網絡過程描述：
首先，要明確，神經網絡做的是預測任務，相信你記得高中學過的最小二乘法，我們可以以此做一個不嚴謹但比較直觀的類比：
首先，我們要得到一個數據集和數據集的標記（最小二乘法中，我們也得到了一組組x,y的值）
算法根據這個數據集和對應的標記，擬合一個能夠表達這個數據集的函數參數（也就是最小二乘法中計算a, b的公式，神經網絡中不過是這個公式沒法直接得到）
我們以此得到了擬合的函數（也就是最小二乘法中的擬合直線y^=ax+b）
接下來，帶入新的數據之后，就可以生成對應的預測值y^（在最小二乘法中，就是帶入y^=ax+b得到我們預測的y^，神經網絡算法也是的，只不過求得的函數比最小二乘法復雜得多）。
神經網絡的計算過程
神經網絡結構如下圖所示，最左邊的是輸入層，最右邊的是輸出層，中間是多個隱含層，隱含層和輸出層的每個神經節點，都是由上一層節點乘以其權重累加得到，標上“+1”的圓圈為截距項b，對輸入層外每個節點：y=w0*x0+w1*x1+…+wn*xn+b，由此我們可以知道神經網絡相當于一個多層邏輯回歸的結構。
算法計算過程：輸入層開始，從左往右計算，逐層往前直到輸出層產生結果。如果結果值和目標值有差距，再從右往左算，逐層向后計算每個節點的誤差，并且調整每個節點的所有權重，反向到達輸入層后，又重新向前計算，重復迭代以上步驟，直到所有權重參數收斂到一個合理值。由于計算機程序求解方程參數和數學求法不一樣，一般是先隨機選取參數，然后不斷調整參數減少誤差直到逼近正確值，所以大部分的機器學習都是在不斷迭代訓練，下面我們從程序上詳細看看該過程實現就清楚了。
神經網絡的算法程序實現
神經網絡的算法程序實現分為初始化、向前計算結果，反向修改權重三個過程。
1. 初始化過程
由于是n層神經網絡，我們用二維數組layer記錄節點值，第一維為層數，第二維為該層節點位置，數組的值為節點值；同樣，節點誤差值layererr也是相似方式記錄。用三維數組layer_weight記錄各節點權重，第一維為層數，第二維為該層節點位置，第三維為下層節點位置，數組的值為某節點到達下層某節點的權重值，初始值為0-1之間的隨機數。為了優化收斂速度，這里采用動量法權值調整，需要記錄上一次權值調整量，用三維數組layer_weight_delta來記錄，截距項處理：程序里將截距的值設置為1，這樣只需要計算它的權重就可以了，
2. 向前計算結果
采用s函數1/(1+math.exp(-z))將每個節點的值統一到0-1之間，再逐層向前計算直到輸出層，對于輸出層，實際上是不需要再用s函數的，我們這里將輸出結果視為0到1之間的概率值，所以也采用了s函數，這樣也有利于程序實現的統一性。
3. 反向修改權重
神經網絡如何計算誤差，一般采用平方型誤差函數e，如下：
也就是將多個輸出項和對應目標值的誤差的平方累加起來，再除以2。實際上邏輯回歸的誤差函數也是這個，至于為什么要用這個函數來計算誤差，它從數學上的合理性是什么，怎么得來的，這個我建議程序員們不想當數學家的話，先不去深究了，現在我們要做的是如何把這個函數e誤差取它的最小值，需要對其進行求導，如果有些求導數學基礎的話，倒可以嘗試去推導下如何從函數e對權重求導得到下面這個公式的：
不會推導也沒有關系，我們只需要運用結果公式就可以了，在我們的程序里用layererr記錄了e對權重求導后的最小化誤差，再根據最小化誤差去調整權重。
注意這里采用動量法調整，將上一次調整的經驗考慮進來，避免陷入局部最小值，下面的k代表迭代次數，mobp為動量項，rate為學習步長：
δw(k+1) = mobp*δw(k)+rate*err*layer
也有很多使用下面的公式，效果上的差別不是太大：
δw(k+1) = mobp*δw(k)+(1-mobp)rate*err*layer
為了提升性能，注意程序實現是在一個while里面同時計算誤差和調整權重，先將位置定位到倒數第二層（也就是最后一層隱含層）上，然后逐層反向調整，根據l+1層算好的誤差來調整l層的權重，同時計算好l層的誤差，用于下一次循環到l-1層時計算權重，以此循環下去直到倒數第一層（輸入層）結束。
小結
在整個計算過程中，節點的值是每次計算都在變化的，不需要保存，而權重參數和誤差參數是需要保存的，需要為下一次迭代提供支持，因此，如果我們構思一個分布式的多機并行計算方案，就能理解其他框架中為什么會有一個parameter server的概念。
多層神經網絡完整程序實現
下面的實現程序bpdeep.java可以直接拿去使用，也很容易修改為c、c#、python等其他任何語言實現，因為都是使用的基本語句，沒有用到其他java庫（除了random函數）。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
|
import java.util.random;public class bpdeep{ public double[][] layer;//神經網絡各層節點 public double[][] layererr;//神經網絡各節點誤差 public double[][][] layer_weight;//各層節點權重 public double[][][] layer_weight_delta;//各層節點權重動量 public double mobp;//動量系數 public double rate;//學習系數 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];//隱含層動量調整 layer_weight[l][j][i]+=layer_weight_delta[l][j][i];//隱含層權重調整 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];//截距動量調整 layer_weight[l][j+1][i]+=layer_weight_delta[l][j+1][i];//截距權重調整 } } layererr[l][j]=z*layer[l][j]*(1-layer[l][j]);//記錄誤差 } } } public void train(double[] in, double[] tar){ double[] out = computeout(in); updateweight(tar); }} |
一個運用神經網絡的例子
最后我們找個簡單例子來看看神經網絡神奇的效果。為了方便觀察數據分布，我們選用一個二維坐標的數據，下面共有4個數據，方塊代表數據的類型為1，三角代表數據的類型為0，可以看到屬于方塊類型的數據有（1，2）和（2，1），屬于三角類型的數據有（1，1），（2，2），現在問題是需要在平面上將4個數據分成1和0兩類，并以此來預測新的數據的類型。
我們可以運用邏輯回歸算法來解決上面的分類問題，但是邏輯回歸得到一個線性的直線做為分界線，可以看到上面的紅線無論怎么擺放，總是有一個樣本被錯誤地劃分到不同類型中，所以對于上面的數據，僅僅一條直線不能很正確地劃分他們的分類，如果我們運用神經網絡算法，可以得到下圖的分類效果，相當于多條直線求并集來劃分空間，這樣準確性更高。
下面是這個測試程序bpdeeptest.java的源碼：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
import java.util.arrays;public class bpdeeptest{ public static void main(string[] args){ //初始化神經網絡的基本配置 //第一個參數是一個整型數組，表示神經網絡的層數和每層節點數，比如{3,10,10,10,10,2}表示輸入層是3個節點，輸出層是2個節點，中間有4層隱含層，每層10個節點 //第二個參數是學習步長，第三個參數是動量系數 bpdeep bp = new bpdeep(new int[]{2,10,2}, 0.15, 0.8); //設置樣本數據，對應上面的4個二維坐標數據 double[][] data = new double[][]{{1,2},{2,2},{1,1},{2,1}}; //設置目標數據，對應4個坐標數據的分類 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]); //根據訓練結果來檢驗樣本數據 for(int j=0;j<data.length;j++){ double[] result = bp.computeout(data[j]); system.out.println(arrays.tostring(data[j])+":"+arrays.tostring(result)); } //根據訓練結果來預測一條新數據的分類 double[] x = new double[]{3,1}; double[] result = bp.computeout(x); system.out.println(arrays.tostring(x)+":"+arrays.tostring(result)); }} |
小結
以上測試程序顯示神經網絡有很神奇的分類效果，實際上神經網絡有一定優勢，但也不是接近人腦的萬能算法，很多時候它可能會讓我們失望，還需要結合各種場景的數據大量運用去觀察其效果。我們可以把1層隱含層改成n層，并調整每層節點數、迭代次數、學習步長和動量系數，以獲得一個最優化的結果。但是很多時候n層隱含層的效果并不比1層有明顯提升，反而計算更復雜耗時，我們對神經網絡的認識還需要多實踐多體會。
以上就是本文關于70行java代碼實現深度神經網絡算法分享的全部內容，希望對大家有所幫助。如有不足之處，歡迎留言指出。
原文鏈接：http://www.open-open.com/code/view/1455771789339
