人工神经网络及其应用实例_毕业论文

人工神经网络及其应用实例人工神经网络是在现代神经科学研究成果基础上提出的一种抽
象数学模型，它以某种简化、抽象和模拟的方式，反映了大脑功能的
若干基本特征，但并非其逼真的描写。

人工神经网络可概括定义为：由大量简单元件广泛互连而成的复
杂网络系统。

所谓简单元件，即人工神经元，是指它可用电子元件、
光学元件等模拟，仅起简单的输入输出变换y = σ (x)的作用。

下图是 3 中常用的元件类型：
线性元件：y = 0.3x，可用线性代数法分析，但是功能有限，现在已不太常用。

2
1.5
1
0.5
-0.5
-1
-1.5
-2
-6 -4 -2 0 2 4 6 连续型非线性元件：y = tanh(x)，便于解析性计算及器件模拟，是当前研究的主要元件之一。

离散型非线性元件： y = ⎨
2 1.5 1 0.5 0 -0.5 -1 -1.5 -2 -6
-4
-2
2
4
6
⎧1, x ≥ 0 ⎩-1, x < 0
，便于理论分析及阈值逻辑器件 实现，也是当前研究的主要元件之一。

2 1.5 1 0.5 0 -0.5 -1 -1.5 -2 -6
-4
-2
2
4
6
每一神经元有许多输入、输出键，各神经元之间以连接键（又称
突触）相连，它决定神经元之间的连接强度（突触强度）和性质（兴
奋或抑制），即决定神经元间相互作用的强弱和正负，共有三种类型：
兴奋型连接、抑制型连接、无连接。

这样，N个神经元（一般N很大）构成一个相互影响的复杂网络系统，通过调整网络参数，可使人工神
经网络具有所需要的特定功能，即学习、训练或自组织过程。

一个简
单的人工神经网络结构图如下所示：
上图中，左侧为输入层（输入层的神经元个数由输入的维度决定），右侧为输出层（输出层的神经元个数由输出的维度决定），输入层与
输出层之间即为隐层。

输入层节点上的神经元接收外部环境的输入模式，并由它传递给
相连隐层上的各个神经元。

隐层是神经元网络的内部处理层，这些神
经元在网络内部构成中间层，不直接与外部输入、输出打交道。

人工
神经网络所具有的模式变换能力主要体现在隐层的神经元上。

输出层
用于产生神经网络的输出模式。

多层神经网络结构中有代表性的有前向网络（BP网络）模型、
多层侧抑制神经网络模型和带有反馈的多层神经网络模型等。

本文主
要探讨前向网络模型。

多层前向神经网络不具有侧抑制和反馈的连接方式，即不具有本
层之间或指向前一层的连接弧，只有指向下一层的连接弧。

代表是
BP 神经网络：输入模式由输入层进入网络，经中间各隐层的顺序变
换，最后由输出层产生一个输出模式，如下图所示：
输入层
隐层
输出层
多层前向神经网络由隐层神经元的非线性处理衍生它的能力，这
个任务的关键在于将神经元的加权输入非线性转换成一个输出的非
线性激励函数。

下图给出了一个接收 n 个输入 x 1, x 2 , , x n 的神经元：
b
x 1
x 2
y
x n
y = σ (∑ w j j + b )
神经元的输出由下式给出：
n
x j =1
这里输入的加权和（括号内部分）由一个非线性函数传递， b 表
示与偏差输入相关的权值， w j 表示与第 j 个输入相关的权值。

使用最广泛的函数是 S 形函数，其曲线家族包括对数函数和双曲
正切函数，这些都可用来对人口动态系统、经济学系统等建模。

另外
所用的其他函数有高斯函数、正弦函数、反正切函数，在此不一一展
开介绍，本文主要使用的激励函数是对数函数，函数表达式为：
y = L (u ) =
函数曲线如下图所示：
1
0.8
0.6
0.4
0.2
1 1 + e -u
-0.2 -10
-8
-6
-4
-2
2
4
6
8
10
对于有限输入量，对数函数输出范围为 y ∈ (0,1)。

在输入为 u = 0 时，
输出值为中间值 y = 0.5。

输出在 u = 0 附近随着输入的增加以相对快的
= t -
1 + e
∂ε ∂u e -u
∂ε ∂u e -u
∆w = -β ⋅ = β ⋅ E ⋅ ⋅ x
∆b = -β ⋅ = β ⋅ E ⋅
速率增加并非常慢地到达上限。

对于 u < 0 ，输出起初减少得很快，然
后随着下限的接近将会变慢。

训练神经元的规则有很多种，这里首先介绍利用 delta 规则的学
习，神经元选择为一个单输入单输出的简单情形，数学描述如下：
u = wx + b , y =
1 1 + e -u
该神经元具有一个输入 x ，权重为 w ，偏差输入为 b ，目标输出
为 t ，预报输出为 y 。

则预报误差为：
E = t - y = t -
1 1
1 + e -u 1 + e - wx -b
为消除当误差在整个输入模式上求和时引起的误差符号问题，在
delta 规则里使用的误差指示是平方误差，定义为：
1 1
2 2
1
- wx -b
)2
根据 delta 规则，最优权值（使平方误差最小）可以在训练过程
中从初始权值出发，沿负梯度方向下降得到。

将平方误差对 w , b （神
经元的可调整参数）进行微分，得：
∂ε ∂u
= -E ⋅ e -u -u 2
∂ε ∂w ∂ε ∂b = ⋅ = - E ⋅ ⋅ x ∂u ∂w (1 + e -u )2 = ⋅ = - E ⋅
∂u ∂b (1 + e -u )2
根据 delta 原则，权值改变应与误差梯度的负值成比例，引入学
习率 β ，每次迭代中的权值改变可表示为：
∂ε e -u
∂w (1 + e -u )2 ∂ε
∂b e -u (1 + e -u )2
w
ij ji
+ β ⋅ E ⋅
= w
学习率 β 决定了沿梯度方向的移动速度，以确定新的权值。

大的
β 值会加快权值的改变，小的 β 值则减缓了权值的改变。

第 i 次迭代
后的新权值可表示为：
w i +1 = w i + β ⋅ E ⋅
e -u (1 + e -u )2 ⋅ x
b i +1 = b i + β ⋅ E ⋅
e -u
(1 + e -u )2
如果将偏差输入 b 视为输入 x 的一部分，令 x 0 = 1, w 0 = b ，可以得到
对于多输入神经元的权值修正式：
+1
e -u
(1 + e -u )2
⋅ x j , j = 0,1, 2, , n
总之，利用 delta 规则的有监督的学习可以按如下方法来实现：
一个输入模式（ x 0 , x 1, x 2 , , x n ）通过连接被传递，它的初始权值被设置
为任意值。

对加权的输入求和，产生输出 y ，然后 y 与给定的目标输
出 t 做比较决定此模式的平方误差 ε 。

输入和目标输出不断地被提出，
在每一次迭代或每一个训练时间后利用 delta 规则进行权值调整直到
得到可能的最小平方误差。

delta 规则在每一步中通过导数寻找在误差平面中某个特定点局
部区域的斜率，它总是应用这个斜率从而试图减小局部误差，因此，
delta 规则不能区分误差空间中的全局最小点和局部最小点，它本身
不能克服单层神经网络的局限，无法直接应用到多层神经网络（易陷
入局部最小点），但它的一般形式是多层神经网络中的学习算法——
反传算法的核心。

在多层前向神经网络的训练过程中，误差导数或关于权值的误差
, u i = ∑ a ji j , i = 1, 2, z = v , v = ∑ b i i y
表面的斜率对权值的调整是至关重要的，在网络训练期间，所有的输
出神经元和隐含神经元权值必须同时调整，因此，有必要找出关于所
有权值的误差导数。

由于网络层数增多，平方误差 ε 与权值的连接没
有之前单个神经元时那么直接，故可以使用链式规则的概念来找到导
数。

下面对一个含有一层隐含神经元的 BP 网络进行讨论，网络结构
如下图所示：
x x
x
x 各个神经元的输入输出关系为：
y i =
1
1 + e -u i
n j =0
x
, m m
i =0
设目标输出为 t ，则平方误差 ε 定义为：
= ⋅ y i , i = 0,1, 2, = ⋅ b i , i = 1, 2, ∂ε∂ε∂∂ε∂ε ∂u i ∂ε
∂u i ∂a ji ∂u i
= -(t - z ) ⋅ b i ⋅ ⋅ x j , i = 1, 2,
1 2
使用链式法则，分别列出平方误差 ε 对所有网络参数的导数：
∂ε ∂v
= -(t - z )
∂ε
∂b i ∂ε
∂v
, m
∂ε
∂y i
∂ε
∂v
, m
= ⋅ = ⋅
∂u i ∂y i ∂u i ∂y i (1+ e -u i )2 , i = 1, 2,
, m
∂ε ∂a ji
= ⋅ = ⋅ x j , i = 1, 2, , m , j = 0,1, 2,
, n
在实际的编程过程中，我们需要的是 ∂ε
∂b i
和
∂ε ∂a ji
，所以如果有需要，
也可以直接采用以下整理之后的形式：
∂ε
∂b i
= -(t - z ) ⋅ y i , i = 0,1, 2, , m
∂ε ∂a ji
e -u i
(1 + e -u i )2
, m , j = 0,1, 2,
, n
研究表明，两层网络在其隐层中使用 S 形激励函数，在输出层中
使用线性传输函数，就几乎可以以任意精度逼近任意感兴趣的函数，
只要隐层中有足够的单元可用。

问题 1：
试使用 BP 神经网络去逼近正弦函数的正半周，如下：
t = sin(x ), x ∈[0,π ]
由于输入量 x 仅有一维，故 BP 神经网络结构可以设计为：
, u i = ∑ a ji j , i = 1, 2
z = v , v = ∑ b i i y
= -(t - z ) ⋅ b i ⋅ ⋅ x j , i = 1, 2, j = 0,1
b i i b k - β ⋅
= = b i + β ⋅ (t - z ) ⋅ y i , i = 0,1, 2
= a -
β ⋅ = a ji + β ⋅ (t - z ) ⋅ b i ⋅ ⋅ x j , i = 1, 2, j = 0,1 ∂a j i (1 +
各个神经元的输入输出关系为：
y i =
1 1 + e -u i
1 j =0
x 2
i =0
根据之前的推导，平方误差 ε 对所有网络参数的导数为：
∂ε
∂b i
= -(t - z ) ⋅ y i , i = 0,1, 2
∂ε ∂a ji
e -u i
(1 + e -u i )2
网络参数修正方程为：
k +1
∂ε ∂b i
k
a
k +1 ji
ji
k
∂ε k
为加快寻找最优权值的速度，可以使用动量法。

之前的方法中，
收敛到最优权值的速度取决于学习率的大小，但是过大的学习率会导
致来回震荡，不能稳定到最优权值点。

动量法的引入，使得较大的学
习率也可以具有较好的稳定性，即提供了在学习期间到达最优权值时
的稳定性。

这种方法基本上是将过去权值变化的平均值附加到每一次权值变化的新权值增量，从而使网络权值的变化更平滑。

数学表示如下：
∆w k +1 = μ ⋅ ∆w k + (1- μ ) ⋅ β ⋅ (- ∂ε
∂w
)
式中， μ是一个在0和1之间的动量参数， ∆w k是在前一个训练时间里的权值变化。

使用动量法的实际效果是：基本上，如果以前积累的变化与之前方向所暗示的是同一个方向时，动量部分就会加速当前权值改变；如果当前积累的变化是相反的方向，动量将阻止当前的变化。

据此编写MATLAB程序，源代码如下：
beta = 0.1;
miu = 0.8;
for i = 1 : 1 : 101;
x1(1, i) = (i - 1) * pi / 100;
t(1, i) = sin(x1(1, i));
end
x0 = 1;
y0 = 1;
a01 = rand();
a02 = rand();
a11 = rand();
a12 = rand();
b0 = rand();
b1 = rand();
b2 = rand();
delta_a01 = 0;
delta_a02 = 0;
delta_a11 = 0;
delta_a12 = 0;
delta_b0 = 0;
delta_b1 = 0;
delta_b2 = 0;
k = 1;
total_error = 0;
while 1
u1 = a01 * x0 + a11 * x1(1, k);
u2 = a02 * x0 + a12 * x1(1, k);
temp1 = exp(-u1) / ((1 + exp(-u1)) ^ 2);
temp2 = exp(-u2) / ((1 + exp(-u2)) ^ 2);
y1 = 1 / (1 + exp(-u1));
y2 = 1 / (1 + exp(-u2));
z = b0 * y0 + b1 * y1 + b2 * y2;
total_error = total_error + (t(1, k) - z) ^ 2 / 2;
delta_b0 = miu * delta_b0 + (1 - miu) * beta * sum((t(1, k) - z) * y0);
b0 = b0 + delta_b0;
delta_b1 = miu * delta_b1 + (1 - miu) * beta * sum((t(1, k) - z) * y1);
b1 = b1 + delta_b1;
delta_b2 = miu * delta_b2 + (1 - miu) * beta * sum((t(1, k) - z) * y2);
b2 = b2 + delta_b2;
delta_a01 = miu * delta_a01 + (1 - miu) * beta * sum((t(1, k) - z) * b1 * temp1 * x0);
a01 = a01 + delta_a01;
delta_a02 = miu * delta_a02 + (1 - miu) * beta * sum((t(1, k) - z) * b2 * temp2 * x0);
a02 = a02 + delta_a02;
delta_a11 = miu * delta_a11 + (1 - miu) * beta * sum((t(1, k) - z) * b1 * temp1 * x1(1, k));
a11 = a11 + delta_a11;
delta_a12 = miu * delta_a12 + (1 - miu) * beta * sum((t(1, k) - z) * b2 * temp2 * x1(1, k));
a12 = a12 + delta_a12;
k = k + 1;
if k == length(x1) + 1
total_error
k = 1;
if total_error < 0.001
break;
else
total_error = 0;
end
end
end
clear u1 u2 temp1 temp2 y1 y2 z x0 y0;
x0 = ones(size(x1));
y0 = ones(size(x1));
u1 = a01 * x0 + a11 * x1;
u2 = a02 * x0 + a12 * x1;
y1 = 1 ./ (1 + exp(-u1));
y2 = 1 ./ (1 + exp(-u2));
z = b0 * y0 + b1 * y1 + b2 * y2;
plot(x1, t, 'r');
hold on;
plot(x1, z, 'b');
hold off;
axis([0 pi -0.2 1.2]);
程序运行后，输出拟合曲线与原函数曲线，如下图所示：
1
0.8
0.6
0.4
0.2
-0.2
0 0.5 1 1.5 2 2.5 3
可以看出，训练后的神经网络的预报输出与目标输出已经很接近，拟合效果是较为理想的。

总的来说，神经网络的学习过程，是神经网络在外界输入样本的刺激下不断改变网络的连接权值乃至拓扑结构，以使网络的输出不断地接近期望的输出。

BP算法是多层前向神经网络的一种学习规则，核心思想是将输出误差以某种形式通过隐层向输入层逐层反传，学习的过程就是信号的正向传播与误差的反向传播交替的过程。

多层前向神经网络的主要功能有：
（1）非线性映射能力。

多层前向神经网络能学习和存储大量输入——输出模式映射关系，而无需事先了解描述这种映射关系的数学方程。

只要能提供足够多的样本模式供对神经网络进行学习训练，它便能完成由n维输入空间到m维输出空间的非线性映射。

（2）泛化能力。

当向网络输入训练时未曾见过的非样本数据时，网络也能完成由输入空间到输出空间的正确映射。

（3）容错能力。

输入样本中带有较大的误差甚至个别错误对网络的输入输出规律影响很小。

多层前向神经网络的标准BP学习算法有着以下明显的缺陷：
（1）易形成局部极小（属于贪婪算法，局部最优）而得不到全局最优；
（2）训练次数多使得学习效率低下，收敛速度慢；
（3）隐节点的选取缺乏理论支持；
（4）训练时学习新样本有遗忘旧样本的趋势。

标准BP算法的改进方法主要有：增加动量项；自适应调节学习率等。

增加动量项已经在之前进行过讨论，可以减小振荡趋势，提高
训练速度。

自适应调节学习率是指根据环境变化增大或减小学习率，
基本方法是：
设一初始学习率，若经过一批次权值调整后使总误差增大，则本
次调整无效，并令 β = α1β (α1 < 1)；若经过一批次权值调整后使总误差
减小，则本次调整有效，并令 β = α2β (α2 > 1)。

下面通过一个非线性分类问题来考察前向神经网络在模式识别
领域的应用。

问题2：
x - y平面上有200个点，分别属于两个类别。

试设计并训练一个多层前向神经网络，以完成该分类任务，使得被错误分类的样本数量
最低。

ω1类以绿色标示， ω2类以蓝色标示。

1
0.9
0.8
0.7
0.6
0.5
0.4
0.3
0.2
0.1
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
-1, u i = ∑ a ji j , i = 1, 2
-1, v = ∑ b i i ( x , y ) ∈ ⎨ 1
= ⋅ ⋅ = -(t - z ) ⋅ ⋅ y i
∂ε ∂y i i e
∂u = ⋅ ⋅ = -(t - z ) ⋅ ⋅ b i ⋅ ⋅ x j ∂y i ∂u i ∂a ji (1 + e -v ) (1 + e -u i )2
e e -u i
, q i = b i ⋅ (1 + e -v ) (1 + e -u i )2
根据题意，前向神经网络的结构设计如下：
x 0 = 1
x 1 = x
x 2 = y
网络的输入输出关系及分类策略为：
y i =
2 1 + e -u i
2 j =0
x z =
2 1 + e -v
2
i =0
y
⎧ω , z > 0
⎩ω2 , z < 0
分类误差定义为：
1 2 ⎧1, ( x , y ) ∈ω1 2 ⎩-1, ( x , y ) ∈ω2
由此可得误差量对网络参数的导数：
∂ε ∂ε ∂z ∂v e -v
∂b i ∂z ∂v ∂b i (1+ e -v )2
∂ε ∂a ji
-v
2 为简化表达式，定义：
p = -(t - z ) ⋅ -v
2 , i = 1, 2
= p ⋅ y i , 则有：
∂ε ∂ε ∂b i ∂a ji
= pq i ⋅ x j
据此编写 MATLAB 程序如下（标准 BP 算法加动量法优化）：
clear x0 x1 x2; beta = 0.1; miu = 0;
[n m ] = size (x ); for i = 1 : 1 : n
x0(1, i ) = 1; x1(1, i ) = x (i , 1); x2(1, i ) = x (i , 2); y0(1, i ) = 1; t (1, i ) = x (i , 3); end
a01 = rand (); a11 = rand (); a21 = rand (); a02 = rand (); a12 = rand (); a22 = rand (); b0 = rand (); b1 = rand (); b2 = rand (); delta_a01 = 0; delta_a11 = 0; delta_a21 = 0; delta_a02 = 0; delta_a12 = 0; delta_a22 = 0; delta_b0 = 0; delta_b1 = 0; delta_b2 = 0; l = 1; while 1
u1 = a01 * x0 + a11 * x1 + a21 * x2; u2 = a02 * x0 + a12 * x1 + a22 * x2; y1 = 2 ./ (1 + exp (-u1)) - 1; y2 = 2 ./ (1 + exp (-u2)) - 1; v = b0 * y0 + b1 * y1 + b2 * y2; z = 2 ./ (1 + exp (-v )) - 1;
error = 0;
for i = 1 : 1 : n
if (z(1, i) > 0 && t(1, i) == 1) || (z(1, i) < 0 && t(1, i) == -1) %
else
error = error + 1;
end
end
error
temp0 = -(t - z) .* exp(-v) ./ (1 + exp(-v)) .^ 2;
temp1 = b1 .* exp(-u1) ./ (1 + exp(-u1)) .^ 2;
temp2 = b2 .* exp(-u2) ./ (1 + exp(-u2)) .^ 2;
delta_b0 = miu * delta_b0 + (1 - miu) * beta * sum(-temp0 .* y0);
delta_b1 = miu * delta_b1 + (1 - miu) * beta * sum(-temp0 .* y1);
delta_b2 = miu * delta_b2 + (1 - miu) * beta * sum(-temp0 .* y2);
delta_a01 = miu * delta_a01 + (1 - miu) * beta * sum(-temp0 .* temp1 .* x0);
delta_a11 = miu * delta_a11 + (1 - miu) * beta * sum(-temp0 .* temp1 .* x1);
delta_a21 = miu * delta_a21 + (1 - miu) * beta * sum(-temp0 .* temp1 .* x2);
delta_a02 = miu * delta_a02 + (1 - miu) * beta * sum(-temp0 .* temp2 .* x0);
delta_a12 = miu * delta_a12 + (1 - miu) * beta * sum(-temp0 .* temp2 .* x1);
delta_a22 = miu * delta_a22 + (1 - miu) * beta * sum(-temp0 .* temp2 .* x2);
b0 = b0 + delta_b0;
b1 = b1 + delta_b1;
b2 = b2 + delta_b2;
a01 = a01 + delta_a01;
a11 = a11 + delta_a11;
a21 = a21 + delta_a21;
a02 = a02 + delta_a02;
a12 = a12 + delta_a12;
a22 = a22 + delta_a22;
l = l + 1;
if l == 1000
break;
end
end
j1 = 1;
j2 = 1;
k1 = 1;
k2 = 1;
for i = 1 : 1 : n
if x(i, 3) == -1
if z(1, i) < 0
x11(j1, :) = x(i, :);
j1 = j1 + 1;
else
x12(j2, :) = x(i, :);
j2 = j2 + 1;
end
else
if z(1, i) > 0
x21(k1, :) = x(i, :);
k1 = k1 + 1;
else
x22(k2, :) = x(i, :);
k2 = k2 + 1;
end
end
end
hold on;
plot(x11(:, 1), x11(:, 2), 'g*');
plot(x12(:, 1), x12(:, 2), 'r+');
plot(x21(:, 1), x21(:, 2), 'bo');
plot(x22(:, 1), x22(:, 2), 'r+');
hold off;
axis([0 1 0 1]);
程序运行结果，经过训练，该神经网络对200个样本的分类正确率达到了96.5%，分类效果较好，具体分类情况如下图所示，其中被错误分类的样本已用红色标示出，其它正确分类的样本仍用原类别对应的颜色进行标示。

1
0.9
0.8
0.7
0.6
0.5
0.4
0.3
0.2
0.1
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
之前的所有程序都是完整地按照多层前向神经网络的标准BP学习算法过程进行编写的，程序较为复杂，而且如果出现差错，也不易发现，因此应用有一定难度，下面介绍使用MATLAB的神经网络工具箱进行人工神经网络的设计与训练的方法。

关于神经网络工具箱的帮助信息，可以在Product Help中搜索“Neural Network Toolbox”获得，包含有较为详细的使用方法，可以
在需要时进行查阅。

下面以一个函数拟合的问题为例，演示如何使用神经网络工具箱。

首先介绍几个将要用到的函数：
premnmx：用于将网络的输入数据或输出数据进行归一化，归一化后的数据将分布在[ 1,1]区间内。

其语法格式为：
[Pn, minp, maxp, Tn, mint, maxt] = premnmx(P, T);
tramnmx：在训练网络是如果所用的是经过归一化的样本数据，
那么以后使用网络时所用的新数据也应该和样本数据接收相同的预
处理，tramnmx用于完成此项处理，语法格式为：
Pn_new = tramnmx(P_new,minp,maxp);
Tn_new = tramnmx(T_new,mint,maxt);
postmnmx：网络输出结果需要反归一化还原为原始数据，常用
的函数即是postmnmx，其语法格式为：
Y = postmnmx(Yn,mint,maxt);
newff：训练前馈网络的第一步是建立网络对象。

函数newff建
立一个可训练的前馈网络。

这需要4个输入参数：
第一个参数是一个Rx2的矩阵以定义R个输入向量的最小值和最大值；第二个参数是一个设定每层神经元个数的数组；第三个参数是
包含每层用到的传递函数名称的细胞数组；最后一个参数是用到的训
练函数的名称。

例如可以这样建立一个网络对象：
net = newff(minmax(PN1),[NodeNum TypeNum],{TF1 TF2}, 'trainlm');
或者可以在建立网络对象时并不设定训练函数，而是之后进行指定，如：
net = newff(minmax(PN1),[NodeNum TypeNum],{TF1 TF2});
net.trainFcn = 'trainlm';
两者是等效的。

train：BP神经网络的训练函数，其语法格式为：
net = train(net,Pn,Tn);
sim：对于给定的输入量，模拟神经网络的输出，其语法格式为：Yn = sim(net,Pn);
例如使用神经网络工具箱对一个正弦函数进行拟合，源程序如下：
clc
clear
close all
%---------------------------------------------------
%产生训练样本与测试样本
P1 = 1:2:200; %训练样本，每一列为一个样本
T1 = sin(P1*0.1); %训练目标
P2 = 2:2:200; %测试样本，每一列为一个样本
T2 = sin(P2*0.1); %测试目标
%---------------------------------------------------
%归一化
[PN1,minp,maxp,TN1,mint,maxt] = premnmx(P1,T1);
PN2 = tramnmx(P2,minp,maxp);
TN2 = tramnmx(T2,mint,maxt);
%---------------------------------------------------
%设置网络参数
NodeNum = 20; %隐层节点数
TypeNum = 1; %输出维数
TF1 = 'tansig';TF2 = 'purelin'; %判别函数(缺省值)
%TF1 = 'tansig';TF2 = 'logsig';
%TF1 = 'logsig';TF2 = 'purelin';
%TF1 = 'tansig';TF2 = 'tansig';
%TF1 = 'logsig';TF2 = 'logsig';
%TF1 = 'purelin';TF2 = 'purelin';
net = newff(minmax(PN1),[NodeNum TypeNum],{TF1 TF2});
%---------------------------------------------------
%指定训练参数
% net.trainFcn = 'traingd'; %梯度下降算法
% net.trainFcn = 'traingdm'; %动量梯度下降算法
%
% net.trainFcn = 'traingda'; %变学习率梯度下降算法
% net.trainFcn = 'traingdx'; %变学习率动量梯度下降算法
%
% (大型网络的首选算法)
% net.trainFcn = 'trainrp'; % RPROP(弹性 BP)算法,内存需求最小
%
%共轭梯度算法
% net.trainFcn = 'traincgf'; % Fletcher-Reeves修正算法
% net.trainFcn = 'traincgp'; % Polak-Ribiere修正算法,内存需求比Fletcher-Reeves修正算法略大
% net.trainFcn = 'traincgb'; % Powell-Beal复位算法,内存需求比 Polak-Ribiere 修正算法略大
% (大型网络的首选算法)
%net.trainFcn = 'trainscg'; % Scaled Conjugate Gradient算法,内存需求与Fletcher-Reeves修正算法相同,计算量比上面三种算法都小很多
%
% net.trainFcn = 'trainbfg'; % Quasi-Newton Algorithms - BFGS Algorithm,
计算量和内存需求均比共轭梯度算法大,但收敛比较快
% net.trainFcn = 'trainoss'; % One Step Secant Algorithm,计算量和内存需求均比 BFGS算法小,比共轭梯度算法略大
%
% (中型网络的首选算法)
% net.trainFcn = 'trainlm'; % Levenberg-Marquardt算法,内存需求最大,收敛速度最快
%
% net.trainFcn = 'trainbr'; %贝叶斯正则化算法
%
%有代表性的五种算法为:'traingdx','trainrp','trainscg','trainoss',
'trainlm'
%---------------------%
net.trainFcn = 'trainlm';
net.trainParam.show = 20; %训练显示间隔
net.trainParam.lr = 0.3; %学习步长 - traingd,traingdm
net.trainParam.mc = 0.95; %动量项系数 - traingdm,traingdx
net.trainParam.mem_reduc = 1; %分块计算 Hessian矩阵(仅对
Levenberg-Marquardt算法有效)
net.trainParam.epochs = 1000; %最大训练次数
net.trainParam.goal = 1e-8; %最小均方误差
net.trainParam.min_grad = 1e-20; %最小梯度
net.trainParam.time = inf; %最大训练时间
%---------------------------------------------------
%训练
net = train(net,PN1,TN1); %训练
%--------------------------------------------------- %测试
YN1 = sim(net,PN1); %训练样本实际输出
YN2 = sim(net,PN2); %测试样本实际输出
MSE1 = mean((TN1-YN1).^2) %训练均方误差
MSE2 = mean((TN2-YN2).^2) %测试均方误差
%--------------------------------------------------- %反归一化
Y2 = postmnmx(YN2,mint,maxt);
%--------------------------------------------------- %结果作图
plot(1:length(T2),T2,'r+:',1:length(Y2),Y2,'bo:') title('+为真实值，o为预测值')
参考文献：
1.人工智能及其应用，王宏生等编著，北京：国防工业出版社，2006.1
2.人工智能：复杂问题求解的结构和策略（原书第5版），Luger，
G.F.著，史忠植，张银奎，赵志崑等译，北京：机械工业出版社，
2006.10
3.计算智能中的仿生学：理论与算法，徐宗本，张讲社，郑亚林编
著，北京：科学出版社，2003.5
4.神经网络设计，Hagan M.T.等著，戴葵等译，北京：机械工业出版
社，2002.9
5.神经网络在应用科学和工程中的应用——从基本原理到复杂的模
式识别，Samarasinghe著，史晓霞等译，北京：机械工业出版社，2009.7。