java實現神經網路bp演算法,bp神經網路演算法詳解

本文目錄一覽：

• 1、如何用70行Java代碼實現深度神經網路演算法
• 2、急求BP神經網路演算法，用java實現！！！
• 3、BP神經網路的訓練集需要大樣本嗎？一般樣本個數為多少？

如何用70行Java代碼實現深度神經網路演算法

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;llayernum.length;l++){

            layer[l]=new double[layernum[l]];

            layerErr[l]=new double[layernum[l]];

            if(l+1layernum.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;jlayernum[l]+1;j++)

                    for(int i=0;ilayernum[l+1];i++)

                        layer_weight[l][j][i]=random.nextDouble();//隨機初始化權重

            }   

        }

    }

    //逐層向前計算輸出

    public double[] computeOut(double[] in){

        for(int l=1;llayer.length;l++){

            for(int j=0;jlayer[l].length;j++){

                double z=layer_weight[l-1][layer[l-1].length][j];

                for(int i=0;ilayer[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;jlayerErr[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;jlayerErr[l].length;j++){

                double z = 0.0;

                for(int i=0;ilayerErr[l+1].length;i++){

                    z=z+l0?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);

    }

}

急求BP神經網路演算法，用java實現！！！

見附件，一個基本的用java編寫的BP網路代碼。

BP（Back Propagation）神經網路是86年由Rumelhart和McCelland為首的科學家小組提出，是一種按誤差逆傳播演算法訓練的多層前饋網路，是目前應用最廣泛的神經網路模型之一。BP網路能學習和存貯大量的輸入-輸出模式映射關係，而無需事前揭示描述這種映射關係的數學方程。它的學習規則是使用最速下降法，通過反向傳播來不斷調整網路的權值和閾值，使網路的誤差平方和最小。BP神經網路模型拓撲結構包括輸入層（input）、隱層(hidden layer)和輸出層(output layer)。

BP神經網路的訓練集需要大樣本嗎？一般樣本個數為多少？

BP神經網路的訓練集需要大樣本嗎？一般樣本個數為多少？

BP神經網路樣本數有什麼影響

學習神經網路這段時間，有一個疑問，BP神經網路中訓練的次數指的網路的迭代次數，如果有a個樣本,每個樣本訓練次數n，則網路一共迭代an次，在na 情況下 ， 網路在不停的調整權值，減小誤差，跟樣本數似乎關係不大。而且，a大了的話訓練時間必然會變長。

換一種說法，將你的數據集看成一個固定值， 那麼樣本集與測試集 也可以按照某種規格確定下來如7：3 所以如何看待 樣本集的多少與訓練結果呢？ 或者說怎麼使你的網路更加穩定，更加符合你的所需 。

我嘗試從之前的一個例子中看下區別

如何用70行Java代碼實現深度神經網路演算法

作者其實是實現了一個BP神經網路 ，不多說，看最後的例子

一個運用神經網路的例子

最後我們找個簡單例子來看看神經網路神奇的效果。為了方便觀察數據分布，我們選用一個二維坐標的數據，下面共有4個數據，方塊代表數據的類型為1，三角代表數據的類型為0，可以看到屬於方塊類型的數據有（1，2）和（2，1），屬於三角類型的數據有（1，1），（2，2），現在問題是需要在平面上將4個數據分成1和0兩類，並以此來預測新的數據的類型。



圖片描述

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



圖片描述

簡單粗暴，用作者的代碼運行後 訓練5000次 。根據訓練結果來預測一條新數據的分類（3,1）



預測值 （3,1）的結果跟（1,2）（2,1）屬於一類 屬於正方形

這時如果我們去掉 2個樣本，則樣本輸入變成如下

//設置樣本數據，對應上面的4個二維坐標數據

double[][] data = new double[][]{{1,2},{2,2}};

//設置目標數據，對應4個坐標數據的分類

double[][] target = new double[][]{{1,0},{0,1}};

1

2

3

4

1

2

3

4





則（3,1）結果變成了三角形，

如果你選前兩個點 你會發現直接一條中間線就可以區分 這時候的你的結果跟之前4個點時有區別 so 你得增加樣本 直到這些樣本按照你所想要的方式分類 ，所以樣本的多少 重要性體現在，樣本得能反映所有的特徵值（也就是輸入值） ，樣本多少或者特徵（本例子指點的位置特徵）決定的你的網路的訓練結果，！！！這是 我們反推出來的結果 。這裡距離深度學習好像近了一步。

另外，這個70行代碼的神經網路沒有保存你訓練的網路 ，所以你每次運行都是重新訓練的網路。其實，在你訓練過後 權值已經確定了下來，我們確定網路也就是根據權值，so只要把訓練後的權值保存下來，將需要分類的數據按照這種權值帶入網路，即可得到輸出值，也就是一旦網路確定， 權值也就確定，一個輸入對應一個固定的輸出，不會再次改變！個人見解。

最後附上作者的源碼，作者的文章見開頭鏈接

下面的實現程序BpDeep.java可以直接拿去使用，

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;llayernum.length;l++){

layer[l]=new double[layernum[l]];

layerErr[l]=new double[layernum[l]];

if(l+1layernum.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;jlayernum[l]+1;j++)

for(int i=0;ilayernum[l+1];i++)

layer_weight[l][j][i]=random.nextDouble();//隨機初始化權重

}

}

}

//逐層向前計算輸出

public double[] computeOut(double[] in){

for(int l=1;llayer.length;l++){

for(int j=0;jlayer[l].length;j++){

double z=layer_weight[l-1][layer[l-1].length][j];

for(int i=0;ilayer[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;jlayerErr[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;jlayerErr[l].length;j++){

double z = 0.0;

for(int i=0;ilayerErr[l+1].length;i++){

z=z+l0?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);

}

}

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

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

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

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;n5000;n++)

for(int i=0;idata.length;i++)

bp.train(data[i], target[i]);

//根據訓練結果來檢驗樣本數據

for(int j=0;jdata.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));

}

}