java代码实现深度神经网络算法

转载自: http://geek.csdn.net/news/detail/56086

说明：我这篇博客仅仅是给上边写好的代码添加“注释”，记录并帮助学习深度网络算法的朋友。

目的：输入数据获得近似现实结果的响应（“深度神经网络”算法实现：输入的历史数据执行逻辑体以后的响应与现实结果的误差在预期范围内。）

分析：算法计算过程：输入层开始，从左往右计算，逐层往前直到输出层产生结果。若是结果值和目标值有差距，再从右往左算，逐层向后计算每一个节点的偏差，而且调整每一个节点的全部权重，反向到达输入层后，又从新向前计算，重复迭代以上步骤，直到全部权重参数收敛到一个合理值。因为计算机程序求解方程参数和数学求法不同，通常是先随机选取参数，而后不断调整参数减小偏差直到逼近正确值，因此大部分的机器学习都是在不断迭代训练，下面咱们从程序上详细看看该过程实现就清楚了。

实现：神经网络的算法程序实现分为初始化、向前计算结果，反向修改权重三个过程。

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][];    //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]];//初始化“l”层的位置信息
            layerErr[l]=new double[layernum[l]];
            if(l+1<layernum.length){
                layer_weight[l]=new double[layernum[l]+1][layernum[l+1]];//初始化权重的位置信息即“l”层的位置信息，下层节点位置，权重值。
                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();//随机初始化权重(l层数;j位置;i下层节点位置;layer_weight[l][j][i]权重值)
            }   
        }
    }
    //逐层向前计算输出(根据输入值初始化不一样层面不一样位置的节点值)
    public double[] computeOut(double[] in){
        for(int l=1;l<layer.length;l++){
            /*
             * z是截距值，针对不一样下层节点有不一样值
             * l表示层循环，j表示位置循环，i表示计算下层节点值的循环
             */
            for(int j=0;j<layer[l].length;j++){
                double z=layer_weight[l-1][layer[l-1].length][j];//第"l-1"层,第"layer[l-1].length"的位置,第"j"个下层节点的权重值,z表示截距项的值
                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);
    }
}

下面是这个测试程序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;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));
    }
}