码迷,mamicode.com
首页 > 其他好文 > 详细

神经网络介绍

时间:2016-06-14 17:45:57      阅读:255      评论:0      收藏:0      [点我收藏+]

标签:

1 神经网络基本原理

人工神经元是神经网络的基本元素,其原理可以用下图表示:

技术分享

图1. 人工神经元模型

图中x1~xn是从其他神经元传来的输入信号,wij表示表示从神经元j到神经元i的连接权值,θ表示一个阈值 ( threshold ),或称为偏置( bias )。则神经元i的输出与输入的关系表示为:

技术分享技术分享

图中 yi表示神经元i的输出,函数f称为激活函数 ( Activation Function )或转移函数 ( Transfer Function ) ,net称为净激活(net activation)。若将阈值看成是神经元i的一个输入x0的权重wi0,则上面的式子可以简化为:

X = [ x0 , x1 , x2 , ....... , xn ]

技术分享

则神经元的输出可以表示为向量相乘的形式:

技术分享技术分享

若神经元的净激活net为正,称该神经元处于激活状态或兴奋状态(fire),若净激活net为负,则称神经元处于抑制状态。

图1中的这种“阈值加权和”的神经元模型称为M-P模型 ( McCulloch-Pitts Model ),也称为神经网络的一个处理单元( PE, Processing Element )。

 

2. 常用激活函数

 

激活函数的选择是构建神经网络过程中的重要环节,下面简要介绍常用的激活函数。

 

(1) 线性函数 ( Liner Function )

技术分享

(2) 斜面函数 ( Ramp Function )

技术分享

(3) 阈值函数 ( Threshold Function )

技术分享

以上3个激活函数都属于线性函数,下面介绍两个常用的非线性激活函数。

 

(4) S形函数 ( Sigmoid Function )

技术分享

(5) 双极S形函数

技术分享

S形函数与双极S形函数的图像如下:

 

技术分享

图2. S形函数与双极S形函数图像

双极S形函数与S形函数主要区别在于函数的值域,双极S形函数值域是(-1,1),而S形函数值域是(0,1)。

由于S形函数与双极S形函数都是可导的(导函数是连续函数),因此适合用在BP神经网络中。(BP算法要求激活函数可导)

 

3. 神经网络模型

神经网络是由大量的神经元互联而构成的网络。根据网络中神经元的互联方式,常见网络结构主要可以分为下面3类:

(1) 前馈神经网络 ( Feedforward Neural Networks )

前馈网络也称前向网络。这种网络只在训练过程会有反馈信号,而在分类过程中数据只能向前传送,直到到达输出层,层间没有向后的反馈信号,因此被称为前馈网络。感知机( perceptron)与BP神经网络就属于前馈网络。

图3 中是一个3层的前馈神经网络,其中第一层是输入单元,第二层称为隐含层,第三层称为输出层(输入单元不是神经元,因此图中有2层神经元)。

技术分享

图3. 前馈神经网络

(2) 反馈神经网络 ( Feedback Neural Networks )

反馈型神经网络是一种从输出到输入具有反馈连接的神经网络,其结构比前馈网络要复杂得多。典型的反馈型神经网络有:Elman网络和Hopfield网络。

技术分享

图4. 反馈神经网络

(3) 自组织网络 ( SOM ,Self-Organizing Neural Networks )

自组织神经网络是一种无导师学习网络。它通过自动寻找样本中的内在规律和本质属性,自组织、自适应地改变网络参数与结构。

技术分享

图5. 自组织网络

4. 神经网络工作方式

神经网络运作过程分为学习和工作两种状态。

 

(1)神经网络的学习状态

 

网络的学习主要是指使用学习算法来调整神经元间的联接权,使得网络输出更符合实际。学习算法分为有导师学习( Supervised Learning )与无导师学习( Unsupervised Learning )两类。

       有导师学习算法将一组训练集 ( training set )送入网络,根据网络的实际输出与期望输出间的差别来调整连接权。有导师学习算法的主要步骤包括:

1)  从样本集合中取一个样本(Ai,Bi);

2)  计算网络的实际输出O;

3)  求D=Bi-O;

4)  根据D调整权矩阵W;

5) 对每个样本重复上述过程,直到对整个样本集来说,误差不超过规定范围。

  BP算法就是一种出色的有导师学习算法。

       无导师学习抽取样本集合中蕴含的统计特性,并以神经元之间的联接权的形式存于网络中。

       Hebb学习律是一种经典的无导师学习算法。

 

(2) 神经网络的工作状态
      

神经元间的连接权不变,神经网络作为分类器、预测器等使用。

下面简要介绍一下Hebb学习率与Delta学习规则 。

Hebb算法核心思想是,当两个神经元同时处于激发状态时两者间的连接权会被加强,否则被减弱。

为了理解Hebb算法,有必要简单介绍一下条件反射实验。巴甫洛夫的条件反射实验:每次给狗喂食前都先响铃,时间一长,狗就会将铃声和食物联系起来。以后如果响铃但是不给食物,狗也会流口水。

受该实验的启发,Hebb的理论认为在同一时间被激发的神经元间的联系会被强化。比如,铃声响时一个神经元被激发,在同一时间食物的出现会激发附近的另一个神经元,那么这两个神经元间的联系就会强化,从而记住这两个事物之间存在着联系。相反,如果两个神经元总是不能同步激发,那么它们间的联系将会越来越弱。

  Hebb学习律可表示为:技术分享

       其中wij表示神经元j到神经元i的连接权,yi与yj为两个神经元的输出,a是表示学习速度的常数。若yi与yj同时被激活,即yi与yj同时为正,那么Wij将增大。若yi被激活,而yj处于抑制状态,即yi为正yj为负,那么Wij将变小。

(4) 有导师学习算法:Delta学习规则

Delta学习规则是一种简单的有导师学习算法,该算法根据神经元的实际输出与期望输出差别来调整连接权,其数学表示如下:

技术分享

其中Wij表示神经元j到神经元i的连接权,di是神经元i的期望输出,yi是神经元i的实际输出,xj表示神经元j状态,若神经元j处于激活态则xj为1,若处于抑制状态则xj为0或-1(根据激活函数而定)。a是表示学习速度的常数。假设xi为1,若di比yi大,那么Wij将增大,若di比yi小,那么Wij将变小。

Delta规则简单讲来就是:若神经元实际输出比期望输出大,则减小所有输入为正的连接的权重,增大所有输入为负的连接的权重。反之,若神经元实际输出比期望输出小,则增大所有输入为正的连接的权重,减小所有输入为负的连接的权重。这个增大或减小的幅度就根据上面的式子来计算。

 

(5)有导师学习算法:BP算法

采用BP学习算法的前馈型神经网络通常被称为BP网络

技术分享

BP网络具有很强的非线性映射能力,一个3层BP神经网络能够实现对任意非线性函数进行逼近(根据Kolrnogorov定理)。一个典型的3层BP神经网络模型如图7所示。

 

5、神经网络实现

技术分享
在训练神经网络前一般需要对数据进行预处理,一种重要的预处理手段是归一化处理。下面简要介绍归一化处理的原理与方法。

(1) 什么是归一化? 

数据归一化,就是将数据映射到[0,1]或[-1,1]区间或更小的区间,比如(0.1,0.9) 。

(2) 为什么要归一化处理? 

<1>输入数据的单位不一样,有些数据的范围可能特别大,导致的结果是神经网络收敛慢、训练时间长。

<2>数据范围大的输入在模式分类中的作用可能会偏大,而数据范围小的输入作用就可能会偏小。

<3>由于神经网络输出层的激活函数的值域是有限制的,因此需要将网络训练的目标数据映射到激活函数的值域。例如神经网络的输出层若采用S形激活函数,由于S形函数的值域限制在(0,1),也就是说神经网络的输出只能限制在(0,1),所以训练数据的输出就要归一化到[0,1]区间。

<4>S形激活函数在(0,1)区间以外区域很平缓,区分度太小。例如S形函数f(X)在参数a=1时,f(100)与f(5)只相差0.0067。

(3) 归一化算法 

  一种简单而快速的归一化算法是线性转换算法。线性转换算法常见有两种形式:

       <1>

y = ( x - min )/( max - min )

  其中min为x的最小值,max为x的最大值,输入向量为x,归一化后的输出向量为y 。上式将数据归一化到 [ 0 , 1 ]区间,当激活函数采用S形函数时(值域为(0,1))时这条式子适用。

       <2>

y = 2 * ( x - min ) / ( max - min ) - 1

       这条公式将数据归一化到 [ -1 , 1 ] 区间。当激活函数采用双极S形函数(值域为(-1,1))时这条式子适用。
归一化

 

BP神经网络JAVA代码样例

技术分享
import java.util.Arrays;
import java.util.Random;

public class BPNet {

    public static final int INNODE = 3; // 输入结点的数量
    public static final int HIDENODE = 15; // 隐含结点的数量
    public static final int OUTNODE = 1; // 输出结点的数量

    public static final double ALPHA = -1; // 激活函数调节参数
    public static final double rate_w1 = 0.9; // 输入->隐含层的学习率
    public static final double rate_w2 = 0.9; // 隐含层->输出层的学习率
    public static final double error_max = 0.0001; // 训练最大误差
    public static final int train_maxcnt = 100000; // 训练最大次数

    public static double[] hidethresholds = new double[HIDENODE]; // 隐含层阈值,初始值为0
    public static double[] outthresholds = new double[OUTNODE]; // 输出层阈值,初始值为0

    public static double[][] w1 = new double[INNODE][HIDENODE]; // 输入->隐含层的权重
    public static double[][] w2 = new double[HIDENODE][OUTNODE]; // 隐含层->输出层权重

    public static double[][] input = { { 0, 0, 0 }, { 0, 0, 1 }, { 0, 1, 0 },
            { 0, 1, 1 }, { 1, 0, 0 }, { 1, 0, 1 }, { 1, 1, 0 }, { 1, 1, 1 } }; // 输入样本,feature
    public static double[][] output = { { 0 }, { 0.1429 }, { 0.2857 },
            { 0.4286 }, { 0.5714 }, { 0.7143 }, { 0.8571 }, { 1.0000 } }; // 输出值,target

    public static void main(String[] args) {

        init(); // 权重初始化
        trainBP(); // 训练权重,阈值
        testBP(new double[] { 0, 0, 0 }, new double[] { 0 }); // 测试样本结果
        testBP(new double[] { 0, 0, 1 }, new double[] { 0.1429 }); // 测试样本结果
        testBP(new double[] { 0, 1, 0 }, new double[] { 0.2857 }); // 测试样本结果
        testBP(new double[] { 0, 1, 1 }, new double[] { 0.4286 }); // 测试样本结果
        testBP(new double[] { 1, 0, 0 }, new double[] { 0.5714 }); // 测试样本结果
        testBP(new double[] { 1, 0, 1 }, new double[] { 0.7143 }); // 测试样本结果
        testBP(new double[] { 1, 1, 0 }, new double[] { 0.8571 }); // 测试样本结果
        testBP(new double[] { 1, 1, 1 }, new double[] { 1.0000 }); // 测试样本结果
    }

    /**
     * 随机初始化各层的权重
     */
    public static void init() {

        System.out.println("初始化开始...");
        Random ra = new Random();
        ra.setSeed(25); // 随机初始化的权重直接影响结果

        for (int i = 0; i < INNODE; i++) {
            for (int j = 0; j < HIDENODE; j++) {
                w1[i][j] = ra.nextDouble();
            }
        }
        for (int i = 0; i < HIDENODE; i++) {
            for (int j = 0; j < OUTNODE; j++) {
                w2[i][j] = ra.nextDouble();
            }
        }
        System.out.println("初始化结束.");
    }

    /**
     * 激活函数
     * 
     * @param input
     * @return
     */
    public static double actfuction(double input) {
        double out = 1.0 / (Math.exp(-1 * input * ALPHA) + 1.0);
        return out;
    }

    /**
     * 根据误差,训练参数
     */
    public static void trainBP() {
        int len_input = input.length; // 训练样本的数量
        int train_cnt = 0;
        double error = Double.POSITIVE_INFINITY;

        System.out.println("训练开始...");
        while (train_cnt < train_maxcnt && error > error_max) {
            error = 0;
            for (int i = 0; i < len_input; i++) {

                double[] innode = input[i];
                double[] outnode = output[i];

                // 输入->隐含层
                double[] hidenodes = new double[HIDENODE];
                for (int j = 0; j < HIDENODE; j++) {
                    double nodeSum = 0;
                    for (int m = 0; m < INNODE; m++) {
                        nodeSum += w1[m][j] * innode[m];
                    }
                    nodeSum -= hidethresholds[j];
                    hidenodes[j] = actfuction(nodeSum);
                }

                // 隐含层->输出层
                double[] outnodes = new double[OUTNODE];
                for (int j = 0; j < OUTNODE; j++) {
                    double nodeSum = 0;
                    for (int m = 0; m < HIDENODE; m++) {
                        nodeSum += w2[m][j] * hidenodes[m];
                    }
                    nodeSum -= outthresholds[j];
                    outnodes[j] = actfuction(nodeSum);
                }
                double[] outerrors = new double[OUTNODE];

                // 计算误差,更新权重
                for (int j = 0; j < OUTNODE; j++) {
                    outerrors[j] = (outnode[j] - outnodes[j]) * outnodes[j]
                            * (1 - outnodes[j]);
                    for (int m = 0; m < HIDENODE; m++) {
                        w2[m][j] += rate_w2 * outerrors[j] * outnodes[j];
                    }
                }

                // 计算误差,更新权重
                double[] hiderrors = new double[HIDENODE];
                for (int j = 0; j < HIDENODE; j++) {
                    for (int m = 0; m < OUTNODE; m++) {
                        hiderrors[j] += outerrors[m] * w2[j][m];
                    }
                    hiderrors[j] = hiderrors[j] * hidenodes[j]
                            * (1 - hidenodes[j]);
                    for (int m = 0; m < INNODE; m++) {
                        w1[m][j] += rate_w1 * hiderrors[j] * innode[m];
                    }
                }

                // 更新阈值
                for (int j = 0; j < HIDENODE; j++) {
                    hidethresholds[j] += rate_w1 * hiderrors[j];
                }

                // 更新阈值和计算误差
                for (int j = 0; j < OUTNODE; j++) {
                    error += Math.pow(Math.abs(outnodes[j] - outnode[j]), 2); // 计算均方差
                    outthresholds[j] += rate_w2 * outerrors[j];
                }
            }
            train_cnt++;
        }
        System.out.println("训练完毕.");
    }

    /**
     * 根据训练好的参数,测试训练结果
     */
    public static void testBP(double[] input, double[] act) {

        double[] hidenodes = new double[HIDENODE];
        for (int j = 0; j < HIDENODE; j++) {
            double nodeSum = 0;
            for (int m = 0; m < INNODE; m++) {
                nodeSum += w1[m][j] * input[m];
            }
            nodeSum -= hidethresholds[j];
            hidenodes[j] = actfuction(nodeSum);
        }
        double[] outnodes = new double[OUTNODE];
        for (int j = 0; j < OUTNODE; j++) {
            double nodeSum = 0;
            for (int m = 0; m < HIDENODE; m++) {
                nodeSum += w2[m][j] * hidenodes[m];
            }
            nodeSum -= outthresholds[j];
            outnodes[j] = actfuction(nodeSum);
        }
        System.out.println("pre = " + Arrays.toString(outnodes));
        System.out.println("act = " + Arrays.toString(act));
        System.out.println("----------------------------------");
    }
}
netBP

 

运行输出:

技术分享

 

后记, 本文只为理解基本的工作原理。实际工作学习中,请直接调用相关的API。

 

6 参考资料

1 神经网络编程入门 http://www.cnblogs.com/heaad/archive/2011/03/07/1976443.html

2 BP人工神经网络的介绍与实现 http://www.cnblogs.com/luxiaoxun/archive/2012/12/10/2811309.html

 

神经网络介绍

标签:

原文地址:http://www.cnblogs.com/hdu-2010/p/5584681.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!