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. 神经网络模型
神经网络是由大量的神经元互联而构成的网络。根据网络中神经元的互联方式，常见网络结构主要可以分为下面３类：(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。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
