如何用70行Java代码实现深度神经网络算法（转）

对于如今流行的深度学习，保持学习精神是必要的——程序员尤为是架构师永远都要对核心技术和关键算法保持关注和敏感，必要时要动手写一写掌握下来，先不用关心何时用到——用不用是政治问题，会不会写是技术问题，就像军人不关心打不打的问题，而要关心如何打赢的问题。

程序员如何学习机器学习

对程序员来讲，机器学习是有必定门槛的（这个门槛也是其核心竞争力），相信不少人在学习机器学习时都会为尽是数学公式的英文论文而头疼，甚至可能 知难而退。但实际上机器学习算法落地程序并不难写，下面是70行代码实现的反向多层（BP）神经网络算法，也就是深度学习。其实不光是神经网络，逻辑回 归、决策树C45/ID三、随机森林、贝叶斯、协同过滤、图计算、Kmeans、PageRank等大部分机器学习算法都能在100行单机程序内实现（以 后考虑分享出来）。

机器学习的真正难度在于它为何要这么计算，它背后的数学原理是什么，怎么推导得来的公式，网上大部分的资料都在介绍这部分理论知识，却不多告诉 你该算法的计算过程和程序落地是怎么样的，对于程序员来讲，你须要作的仅是工程化应用，而不须要证实出一项新的数学计算方法。实际大部分机器学习工程师都 是利用别人写好的开源包或者工具软件，输入数据和调整计算系数来训练结果，甚至不多本身实现算法过程。可是掌握每一个算法的计算过程仍然很是重要，这样你才 能理解该算法让数据产生了什么样的变化，理解算法的目的是为了达到什么样的效果。

本文重点探讨反向神经网络的单机实现，关于神经网络的多机并行化， Fourinone 提供很是灵活完善的并行计算框架，咱们只须要理解透单机程序实现，就能构思和设计出分布式并行化方案，若是不理解算法计算过程，一切思路将没法展开。另外，还有卷积神经网络，主要是一种降维思想，用于图像处理，不在本文讨论范围。

延伸阅读：

• 机器学习开发者的现代化路径：不须要从统计学微积分开始
• 开发者成功使用机器学习的十大诀窍
• 机器学习温和指南

神经网络的计算过程

神经网络结构以下图所示，最左边的是输入层，最右边的是输出层，中间是多个隐含层，隐含层和输出层的每一个神经节点，都是由上一层节点乘以其权重累 加获得，标上“+1”的圆圈为截距项b，对输入层外每一个节点：Y=w0*x0+w1*x1+…+wn*xn+b，由此咱们能够知道神经网络至关于一个多层 逻辑回归的结构。

（图片来自 UFLDL Tutorial ）

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

神经网络的算法程序实现

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

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函数）。如下为原创程序，转载引用时请注明做者和出处。

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的源码：

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层有明显提高，反而计算更复杂耗时，咱们对神经网络的认识还须要多实践多体会。

做者简介：彭渊，在Java技术领域从业十多年，曾撰写多款开源软件，历任淘宝高级专家和华为中间件首席架构师。开源表明做有Fourinone（四不像）分布式核心技术框架、CoolHash并行数据库引擎等，曾出版书籍《大规模分布式系统架构与设计实战》。

责编：周建丁（zhoujd@csdn.net）

（转载）http://www.open-open.com/code/view/1455771789339