小川學習筆記–BP神經網路JAVA程式碼解析

闊別有些時日了，今天我就寫一篇最近學習BP神經網路JAVA程式碼的一個筆記，我們大家都知道BP神經網路是在上個世紀進行了兩次熱潮，由於反向傳播的發現從而促進了神經網路的發展。由於筆者在本科期間還未學習過JAVA，因此還在學習階段，對於一些程式碼的理解還不夠透徹，還望諸位指正。

程式碼定義：

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]+1][layernum[l+1]];
                layer_weight_delta[l]=new double[layernum[l-1]+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);
    }
    

## 主函式

    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]);
 
        //根據訓練結果來檢驗樣本資料
        System.out.println("根據訓練結果來檢驗樣本資料");
        for(int j=0;j<data.length;j++){
            double[] result = bp.computeOut(data[j]);
            System.out.println(Arrays.toString(data[j])+":"+Arrays.toString(result));
        }
 
        System.out.println("======================");
        //根據訓練結果來預測一條新資料的分類
        System.out.println("根據訓練結果來預測一條新資料的分類");
        double[] x = new double[]{3,1};
        double[] result = bp.computeOut(x);
        System.out.println(Arrays.toString(x)+":"+Arrays.toString(result));
    }
}

BP神經網路完整程式碼

package MachineLearning;


import java.util.Arrays;
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]+1][layernum[l+1]];
                layer_weight_delta[l]=new double[layernum[l-1]+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);
    }
    
    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]);
 
        //根據訓練結果來檢驗樣本資料
        System.out.println("根據訓練結果來檢驗樣本資料");
        for(int j=0;j<data.length;j++){
            double[] result = bp.computeOut(data[j]);
            System.out.println(Arrays.toString(data[j])+":"+Arrays.toString(result));
        }
 
        System.out.println("======================");
        //根據訓練結果來預測一條新資料的分類
        System.out.println("根據訓練結果來預測一條新資料的分類");
        double[] x = new double[]{3,1};
        double[] result = bp.computeOut(x);
        System.out.println(Arrays.toString(x)+":"+Arrays.toString(result));
    }
}

本週的學習就到這裡，歡迎大家批評指正。