本文仅用作记录学习单神经元网络PID控制算法过程的心得体会及个人理解，若有错误，欢迎指正！
传送门
神经网络
关于神经网络的背景定义等诸多概念，网上有很多更权威详细的解析。这里不多赘述。
这里建议阅读维基百科关于人工神经网络的描述 维基百科-人工神经网络
神经网络的三个主要构成
-
结构 （Architecture）
结构指的是网络中的变量和它们的拓扑关系，一般情况下，神经网络具有多层网络以及由多神经元相互链接组成。一种常见的多层结构的前馈网络结构主要是由以下三部分组成：- 输入层（Input layer），众多神经元（Neuron）接受大量非线形输入消息。输入的消息称为输入向量。
- 输出层（Output layer），消息在神经元链接中传输、分析、权衡，形成输出结果。输出的消息称为输出向量。
- 隐藏层（Hidden layer），简称“隐层”，是输入层和输出层之间众多神经元和链接组成的各个层面。隐层可以有一层或多层。隐层的节点（神经元）数目不定，但数目越多神经网络的非线性越显著，从而神经网络的强健性（控制系统在一定结构、大小等的参数摄动下，维持某些性能的特性）更显著。习惯上会选输入节点1.2至1.5倍的节点。
这种网络一般称为感知器（对单隐藏层）或多层感知器（对多隐藏层），神经网络的类型已经演变出很多种，这种分层的结构也并不是对所有的神经网络都适用。
-
激励函数 （activation function）
大部分神经网络模型具有一个短时间尺度的动力学规则，来定义神经元如何根据其他神经元的活动来改变自己的激励值。一般激励函数依赖于网络中的权重（即该网络的参数）。 -
学习规则 （Learning Rule）
学习规则指定了网络中的权重如何随着时间推进而调整。这一般被看做是一种长时间尺度的动力学规则。一般情况下，学习规则依赖于神经元的激励值。它也可能依赖于监督者提供的目标值和当前权重的值。学习规则主要有以下几种分类：- 监督式学习网络（Supervised Learning Network）为主
- 无监督式学习网络（Unsupervised Learning Network）
- 混合式学习网络（Hybrid Learning Network）
- 联想式学习网络（Associate Learning Network）
- 最适化学习网络（Optimization Application Network）
神经元
其中，
a
1
a_{1}
a1-
a
n
a_{n}
an为输入向量的各个分量；
w
1
w_{1}
w1-
w
n
w_{n}
wn为神经元各个突出的权重值；
b
b
b为神经元的激励偏置；
f
f
f为神经元的传递函数，也就是前面提到的激励函数；
t
t
t为神经元的输出；其满足以下关系：
t
=
f
(
W
′
A
⃗
⃗
+
b
)
t=f(\vec{W^{'}\vec{A}}+b)
t=f(W′A+b)
在维基百科中提到，单个神经元的作用为：把一个n维向量空间用一个超平面分割成两部分（称之为判断边界），给定一个输入向量，神经元可以判断出这个向量位于超平面的哪一边。
单神经元网络PID控制算法
了解上面部分关于神经网络的内容之后，已经基本满足学习单神经元PID的内容。单神经元PID顾名思义，并没有明显的网络结构，仅一个单独的神经元参与控制计算。
优化本质：向神经元输入各项变量，神经元根据输入权重、输入量数值以及激励函数来计算控制律增量
Δ
u
\Delta u
Δu，根据学习规则来迭代优化输入权重，以此往复使损失函数达到最小。
- 优化目标
在讨论单神经元PID控制算法时，要首先明确算法优化的目标对象，并顺着这个方向去找到优化方法以及评估优化的数学标准。
在 P I D PID PID控制算法中，影响控制器性能及响应特性的参数就是三个环节的系数 k p k_{p} kp， k i k_{i} ki， k d k_{d} kd。由于传统 P I D PID PID控制算法属于线性控制算法，因此在遇到强扰动或者被控对象非线性特性明显时，无法实现高的控制性能。也就是说，传统 P I D PID PID控制算法在遇到不同的场景不同的系统状态时刻，有着对应的不同的最优 P I D PID PID参数。
因此，我们的优化目标是，使控制网络能够自己判定在当前扰动以及当前系统状态下，自身控制器的最优参数是多少，并通过不断迭代优化来达到一个最优的效果。
任务一完成：寻找优化目标， K p K_{p} Kp， K i K_{i} Ki， K d K_{d} Kd
- PID控制算法
PID控制算法主要分两种类型，位置式和增量式子，二者的控制律 u ( k ) u(k) u(k)分别为。- 位置式
u ( k ) = K p ∗ e r r o r ( k ) + K i ∗ ∑ z = 1 , 2 , . . . k n e r r o r ( z ) + K d ∗ ( e r r o r ( k ) − e r r o r ( k − 1 ) ) u(k)=K_{p}*error(k)+K_{i}*\sum^{n}_{z=1,2,...k}error(z)+K_{d}*(error(k)-error(k-1)) u(k)=Kp∗error(k)+Ki∗z=1,2,...k∑nerror(z)+Kd∗(error(k)−error(k−1)) - 增量式
Δ u ( k ) = u ( k ) − u ( k − 1 ) ⇒ Δ u ( k ) = K p ∗ ( e r r o r ( k ) − e r r o r ( k − 1 ) ) + K i ∗ e r r o r ( k ) + K d ∗ ( e r r o r ( k ) − 2 e r r o r ( k − 1 ) + e r r o r ( k − 2 ) ) \Delta u(k)=u(k)-u(k-1) \Rightarrow \Delta u(k)=K_{p}*(error(k)-error(k-1))+K_{i}*error(k)+K_{d}*(error(k)-2error(k-1)+error(k-2)) Δu(k)=u(k)−u(k−1)⇒Δu(k)=Kp∗(error(k)−error(k−1))+Ki∗error(k)+Kd∗(error(k)−2error(k−1)+error(k−2))
从表达式来看，二者同根同源，最终的控制律 u ( k ) u(k) u(k)计算相同。只不过位置式有积分项，而增量式无积分项，对于一些不同的开发场景有着各自的优缺点。
- 位置式
对于这两种PID控制算法表达形式，哪一种更加适合加入单神经元来实现新的控制算法。
这个问题在我刚学习单神经元控制算法时就已经产生，带着这个疑问翻阅相关资料以及查询网上相关帖子，要么忽略过，要么是搪塞而过。另外很想吐槽的一点是，现在网上很多人喜欢把别人的文章搬到其他论坛上发表，导致一个现象就是搜索了很多不同的帖子，内容却十分相似，有的甚至一字不差。
在此分享一篇写的很好的相关文章 相关文章
它对于为什么是增量表达式的问题描述是这样的
此图仅作为依据材料，无其他用意，侵删
这里是对于这个问题的个人理解就，无论是位置式还是增量式的PID控制算法，其本质都是对被控对象的误差进行响应，是典型的线性闭环负反馈控制器。因此在PID控制器中加入单神经元，其控制器的形式不变，整个神经网络控制器的输入依然是被控对象的误差集（例如误差时间序列或误差累加结果），输出依然是对被控对象的控制律(control law)u(k)。对于位置式和增量式不同的是，其输入到神经元的变量的内容以及其激励函数的形式不同，究其本质是一致的。具体细节继续看后续的讨论。
回到正题，我们已经明确了优化的目标就是三个环节的参数，因此将这三个参数作为神经元三条输入突触的三个权重系数，而输入对象就是该环节的输入量。
增量式
Δ
u
(
k
)
=
K
p
∗
(
e
r
r
o
r
(
k
)
−
e
r
r
o
r
(
k
−
1
)
)
+
K
i
∗
e
r
r
o
r
(
k
)
+
K
d
∗
(
e
r
r
o
r
(
k
)
−
2
e
r
r
o
r
(
k
−
1
)
+
e
r
r
o
r
(
k
−
2
)
)
\Delta u(k)=K_{p}*(error(k)-error(k-1))+K_{i}*error(k)+K_{d}*(error(k)-2error(k-1)+error(k-2))
Δu(k)=Kp∗(error(k)−error(k−1))+Ki∗error(k)+Kd∗(error(k)−2error(k−1)+error(k−2))令三个输入权重系数分别为
w
1
=
K
p
w_{1}=K_{p}
w1=Kp，
w
2
=
K
i
w_{2}=K_{i}
w2=Ki，
w
3
=
K
d
w_{3}=K_{d}
w3=Kd，那么对应的输入量就是
{
x
1
=
e
r
r
o
r
(
k
)
−
e
r
r
o
r
(
k
−
1
)
x
2
=
e
r
r
o
r
(
k
)
x
3
=
e
r
r
o
r
(
k
)
−
2
e
r
r
o
r
(
k
−
1
)
+
e
r
r
o
r
(
k
−
2
)
\left\{\begin{matrix} x_{1}=error(k)-error(k-1)\\ x_{2}=error(k)\\ x_{3}=error(k)-2error(k-1)+error(k-2) \end{matrix}\right.
⎩
⎨
⎧x1=error(k)−error(k−1)x2=error(k)x3=error(k)−2error(k−1)+error(k−2)
位置式
（此部分是个人理解，未必正确）
u
(
k
)
=
K
p
∗
e
r
r
o
r
(
k
)
+
K
i
∗
∑
z
=
1
,
2
,
.
.
.
k
n
e
r
r
o
r
(
z
)
+
K
d
∗
(
e
r
r
o
r
(
k
)
−
e
r
r
o
r
(
k
−
1
)
)
u(k)=K_{p}*error(k)+K_{i}*\sum^{n}_{z=1,2,...k}error(z)+K_{d}*(error(k)-error(k-1))
u(k)=Kp∗error(k)+Ki∗z=1,2,...k∑nerror(z)+Kd∗(error(k)−error(k−1))令三个输入权重系数分别为
w
1
=
K
p
w_{1}=K_{p}
w1=Kp，
w
2
=
K
i
w_{2}=K_{i}
w2=Ki，
w
3
=
K
d
w_{3}=K_{d}
w3=Kd，那么对应的输入量就是
{
x
1
=
e
r
r
o
r
(
k
)
x
2
=
∑
z
=
1
,
2
,
.
.
.
k
n
e
r
r
o
r
(
z
)
x
3
=
e
r
r
o
r
(
k
)
−
e
r
r
o
r
(
k
−
1
)
\left\{\begin{matrix} x_{1}=error(k)\\ x_{2}=\sum^{n}_{z=1,2,...k}error(z)\\ x_{3}=error(k)-error(k-1) \end{matrix}\right.
⎩
⎨
⎧x1=error(k)x2=∑z=1,2,...knerror(z)x3=error(k)−error(k−1)
明确了输入权重及对应的输入变量之后，开始计算神经元的输入输出变量。
神经元的输入
N
e
t
i
n
p
u
t
=
∑
i
=
1
3
w
i
′
x
i
Net_{input}=\sum_{i=1}^{3}w'_{i}x_{i}
Netinput=i=1∑3wi′xi
其中，
w
i
′
w'_{i}
wi′为输入权重，
x
i
x_{i}
xi为输入信息。
神经元的输入权重之和为1，因此需要进行归一化处理。
w i ′ = w i ∑ i = 1 3 ∣ w i ∣ w'_{i}=\frac{w_{i}}{\sum_{i=1}^{3} \left | w_{i} \right |} wi′=∑i=13∣wi∣wi
注意，参与神经元输入计算的权重值 w i ′ w'_{i} wi′和通过学习规则参与迭代的权重值 w i w_{i} wi不是同一个。
神经元网络的输出u(k)
前面提到，无论是什么类型的 P I D PID PID算法，输出的都是控制律 u ( k ) u(k) u(k)，因此对于单神经元网络 P I D PID PID控制算法而言，其神经元激活值也就是神经元PID的控制律 u ( k ) u(k) u(k)。增量式和位置式的激励函数不同，分别是：
神经元激励函数 f f f
- 以增量式为例
f k ( x k ) = K x k + ∑ i = 1 k − 1 f i ( x i ) = K ( ∑ i = 1 k x i ) f_{k}(x_{k})=Kx_{k}+\sum_{i=1}^{k-1}f_{i}(x_{i})=K(\sum_{i=1}^{k}x_{i}) fk(xk)=Kxk+i=1∑k−1fi(xi)=K(i=1∑kxi)
其中 k k k为第 k k k个迭代周期， K K K为比例系数；激励中存在一个累加环节。 - 以位置式为例
f k ( x k ) = K x k f_{k}(x_{k})=Kx_{k} fk(xk)=Kxk
其中 k k k为第 k k k个迭代周期， K K K为比例系数；激励为线性比例环节。
控制律u(k)
- 增量式
u ( k ) = f k ( ∑ i = 1 3 w i ′ ( k ) x i ( k ) ) u(k)=f_{k}(\sum_{i=1}^{3}w'_{i}(k)x_{i}(k)) u(k)=fk(i=1∑3wi′(k)xi(k))
显然， Δ u = u ( k ) − u ( k − 1 ) = K x k = K ∑ i = 1 3 w i ′ ( k ) x i ( k ) \Delta u=u(k)-u(k-1)=Kx_{k}=K\sum_{i=1}^{3}w'_{i}(k)x_{i}(k) Δu=u(k)−u(k−1)=Kxk=K∑i=13wi′(k)xi(k)
因此，可以写成以下形式：
u ( k ) = u ( k − 1 ) + Δ u = u ( k − 1 ) + K ∑ i = 1 3 w i ′ ( k ) x i ( k ) u(k)=u(k-1)+\Delta u=u(k-1)+K\sum_{i=1}^{3}w'_{i}(k)x_{i}(k) u(k)=u(k−1)+Δu=u(k−1)+Ki=1∑3wi′(k)xi(k)
其中
{ x 1 = e r r o r ( k ) − e r r o r ( k − 1 ) x 2 = e r r o r ( k ) x 3 = e r r o r ( k ) − 2 e r r o r ( k − 1 ) + e r r o r ( k − 2 ) \left\{\begin{matrix} x_{1}=error(k)-error(k-1)\\ x_{2}=error(k)\\ x_{3}=error(k)-2error(k-1)+error(k-2) \end{matrix}\right. ⎩ ⎨ ⎧x1=error(k)−error(k−1)x2=error(k)x3=error(k)−2error(k−1)+error(k−2) - 以位置式为例
u ( k ) = K ∑ i = 1 3 w i ′ ( k ) x i ( k ) u(k)=K\sum_{i=1}^{3}w'_{i}(k)x_{i}(k) u(k)=Ki=1∑3wi′(k)xi(k)
其中
{ x 1 = e r r o r ( k ) x 2 = ∑ z = 1 , 2 , . . . k n e r r o r ( z ) x 3 = e r r o r ( k ) − e r r o r ( k − 1 ) \left\{\begin{matrix} x_{1}=error(k)\\ x_{2}=\sum^{n}_{z=1,2,...k}error(z)\\ x_{3}=error(k)-error(k-1) \end{matrix}\right. ⎩ ⎨ ⎧x1=error(k)x2=∑z=1,2,...knerror(z)x3=error(k)−error(k−1)
完成以上的部分之后，还需要补充对于输入权重系数如何迭代数学方法——学习规则。
学习规则
学习规则有五种分类，在单神经元中主要用到的是无监督学习和有监督学习。
无监督Hebb学习规则
Δ
w
i
j
=
η
o
j
(
k
)
o
i
(
k
)
\Delta w_{ij}=\eta o_{j}(k)o_{i}(k)
Δwij=ηoj(k)oi(k)
其中，
η
\eta
η是学习速率，
o
j
o_{j}
oj和
o
i
o_{i}
oi是相连的两个神经元，
w
i
w_{i}
wi是连接两个神经元之间的突触权重，
Δ
w
i
\Delta w_{i}
Δwi就是权重的变化量。
简单的说，无监督Hebb学习规则就是根据两个神经元的激活值大小来优化他们之间的连接权重。即当神经元的激励越大，则提高他们之间的权重，强化二者之间的连接强度；当神经元的激励越小，则削弱他们之间的权重，弱化连接强度。
有监督Delta学习规则
Δ
w
i
j
=
η
(
d
j
(
k
)
−
o
j
(
k
)
)
o
i
(
k
)
\Delta w_{ij}=\eta (d_{j}(k) - o_{j}(k) )o_{i}(k)
Δwij=η(dj(k)−oj(k))oi(k)
有监督学习规则，顾名思义便是存在一个指导性的信号，反馈给神经元使其连接强度保持在一定合理范围内，使得神经元的输出信号和指导性信号持续保持接近，是一种带有反馈性质的学习规则。
有监督Hebb学习规则
Δ
w
i
j
=
η
(
d
j
(
k
)
−
o
j
(
k
)
)
o
j
(
k
)
o
i
(
k
)
\Delta w_{ij}=\eta (d_{j}(k) - o_{j}(k) )o_{j}(k)o_{i}(k)
Δwij=η(dj(k)−oj(k))oj(k)oi(k)
将前面二者的方法结合起来，就可以得到新的有监督学习规则。这种学习规则既注重二者的激励大小情况，又注重外部输入指导信号，二者结合起来迭代优化神经元之间的连接权重值。
以上提到的都是神经元优化时通用的学习规则，单神经元PID控制算法中可以用以上的三种学习规则来完成权重值迭代优化。
单神经元PID控制器的学习规则
- 无监督Hebb学习
Δ w i = w i ( k ) − w i ( k − 1 ) = η i u ( k ) x i ( k ) \Delta w_{i} = w_{i}(k)-w_{i}(k-1)=\eta_{i}u(k)x_{i}(k) Δwi=wi(k)−wi(k−1)=ηiu(k)xi(k)
其中， i = 1 , 2 , 3 i=1,2,3 i=1,2,3， η i \eta_{i} ηi是该输入权重的学习速率， u ( k ) u(k) u(k)神经元的输出控制律， x i ( k ) x_{i}(k) xi(k)为输入量。
学习速率是推导权重最优数学标准时引入的，涉及到了损失函数求导，动量梯度下降的相关知识，有兴趣可以深入了解。
学习速率指的是优化过程中的每一步尝试的步长，形象的讲就是当你知道前面的方向是目标点时，你会往前迈出的步伐的大小。脚步迈大了容易走过头，脚步迈小了就需要花更多时间。因此学习速率影响了控制器的控制性能，过大则会导致超调振荡，过小则会导致系统过阻尼收敛过慢，快速性降低。
类似的列出剩下的几种学习规则：
- 有监督delta学习
Δ w i = w i ( k ) − w i ( k − 1 ) = η i z ( k ) x i ( k ) \Delta w_{i} = w_{i}(k)-w_{i}(k-1)=\eta_{i}z(k)x_{i}(k) Δwi=wi(k)−wi(k−1)=ηiz(k)xi(k)
其中， z ( k ) z(k) z(k)是控制器期望输出和实际输出的差，且 z ( k ) = e r r o r ( k ) z(k)=error(k) z(k)=error(k)
个人认为在单神经元网络中，这种监督指导性信号的意义不大，因为输入本身存在着一定意义的误差信息。
- 有监督Hebb学习
Δ w i = w i ( k ) − w i ( k − 1 ) = η i z ( k ) u ( k ) x i ( k ) \Delta w_{i} = w_{i}(k)-w_{i}(k-1)=\eta_{i}z(k)u(k)x_{i}(k) Δwi=wi(k)−wi(k−1)=ηiz(k)u(k)xi(k)
除了以上通用规则，可以根据经验设计更加适合当前系统的学习规则。
实践证明，PID参数的在线学习修正主要和 e ( k ) e(k) e(k)和 Δ e ( k ) \Delta e(k) Δe(k)，基于此可将单神经元自适应PID控制算法中的加权系数学习修正部分进行修改。
Δ w i ( k ) = η i z ( k ) u ( k ) ( e ( k ) + Δ e ( k ) ) \Delta w_{i}(k)=\eta_{i}z(k)u(k)(e(k)+\Delta e(k)) Δwi(k)=ηiz(k)u(k)(e(k)+Δe(k))
Matlab仿真实例
话不多说，理论实践结合才是硬道理。
- 被控对象
y ( k ) = 0.368 y ( k − 1 ) + 0.26 y ( k − 2 ) + 0.1 u ( k − 1 ) + 0.632 u ( k − 2 ) y(k)=0.368y(k-1)+0.26y(k-2)+0.1u(k-1)+0.632u(k-2) y(k)=0.368y(k−1)+0.26y(k−2)+0.1u(k−1)+0.632u(k−2) - 输入期望
y d ( k ) = 0.5 s g n ( s i n ( 4 π t ) ) y_{d}(k)=0.5sgn(sin(4\pi t)) yd(k)=0.5sgn(sin(4πt))
设置采样间隔为1ms，将位置式和增量式形式的两种以四种不同的学习规则实现控制，观察跟踪结果对比控制器性能。
增量式单神经元PID控制算法
maltab代码如下
x = [0,0,0]';
%初始化输入向量
kP = 0.40;
kI = 0.35;
kD = 0.40;
%初始化PID的三个参数的学习速率
w_x1 = 0.1;
w_x2 = 0.1;
w_x3 = 0.1;
%初始化输入网络的三个权重系数
error_1 = 0;
error_2 = 0;
%记录上一次误差以及上上次误差
y_1 = 0;
y_2 = 0;
y_3 = 0;
%被控量的离散序列，用于计算被控对象方程以及计算误差
u_1 = 0;
u_2 = 0;
u_3 = 0;
%控制输出的离散序列，用于计算被控对象方程以及更新神经元权重系数。
ts = 0.001;
%设置迭代周期为1ms
learning_mode = 1;
%设置学习规则
for k = 1:1:1000
time(k)=k*ts;
%横轴变化
yd(k) = 0.5*sign(sin(2*2*pi*k*ts));
%输入期望的信号函数-阶跃函数
y(k)=0.368*y_1 + 0.26*y_2 + 0.1*u_1 + 0.632*u_2;
%被控对象的离散方程。 x' = Ax + Bu
error(k) = yd(k) - y(k);
%计算当前误差
if learning_mode == 1
%无监督的HEBBE学习规则
w_x1(k) = w_x1 + kP*u_1*x(1);
w_x2(k) = w_x2 + kI*u_1*x(2);
w_x3(k) = w_x3 + kD*u_1*x(3);
K = 0.06;
%无监督的HEBBE学习规则
elseif learning_mode == 2
%有监督的delta学习规则
w_x1(k) = w_x1 + kP*error(k)*x(1);
w_x2(k) = w_x2 + kI*error(k)*x(2);
w_x3(k) = w_x3 + kD*error(k)*x(3);
K = 0.12;
%有监督的delta学习规则
elseif learning_mode == 3
%有监督的hebbe学习规则
w_x1(k) = w_x1 + kP*error(k)*u_1*x(1);
w_x2(k) = w_x2 + kI*error(k)*u_2*x(2);
w_x3(k) = w_x3 + kD*error(k)*u_3*x(3);
K = 0.12;
%有监督的hebbe学习规则
elseif learning_mode == 4
%改进后的有监督的hebbe学习规则
w_x1(k) = w_x1 + kP*error(k)*u_1*(error(k) - error_1);
w_x2(k) = w_x2 + kI*error(k)*u_2*(error(k) - error_1);
w_x3(k) = w_x3 + kD*error(k)*u_3*(error(k) - error_1);
K = 0.12;
%改进后的有监督的hebbe学习规则
end
x(1) = error(k) - error_1;
x(2) = error(k);
x(3) = error(k) - 2*error_1 + error_2;
%神经元的输入
wadd(k)=abs(w_x1(k))+abs(w_x2(k))+abs(w_x3(k));
w11(k) = w_x1(k)/wadd(k);
w22(k) = w_x2(k)/wadd(k);
w33(k) = w_x3(k)/wadd(k);
w=[w11(k),w22(k),w33(k)];
%权重系数归一化操作
u(k)=u_1+K*w*x;
%控制律
error_2 = error_1;
error_1 = error(k);
%更新误差序列
u_3 = u_2;
u_2 = u_1;
u_1 = u(k);
%更新神经元输出控制律序列
y_3=y_2;
y_2=y_1;
y_1=y(k);
%更新被控对象输出序列
w_x1=w_x1(k);
w_x2=w_x2(k);
w_x3=w_x3(k);
%更新权重系数
end
figure(1);
plot(time,yd,'r',time,y,'k:','linewidth',2);
xlabel('time');ylabel('yd;y');
%打印被控对象跟踪结果
figure(2);
plot(time,u,'r','linewidth',2);
xlabel('time');ylabel('controlinput U');
%打印控制律曲线
- 无监督Hebb学习规则结果
- 有监督Delta学习规则结果
- 有监督Hebb学习规则结果
- 改进后的有监督Hebb学习规则结果
位置式单神经元PID控制算法
话不多说，直接上代码
x = [0,0,0]';
%初始化输入向量
kP = 0.40;
kI = 0.35;
kD = 0.40;
%初始化PID的三个参数的学习速率
w_x1 = 0.1;
w_x2 = 0.1;
w_x3 = 0.1;
%初始化输入网络的三个权重系数
error_1 = 0;
%记录上一次误差以及上上次误差
y_1 = 0;
y_2 = 0;
y_3 = 0;
%被控量的离散序列，用于计算被控对象方程以及计算误差
u_1 = 0;
u_2 = 0;
u_3 = 0;
%控制输出的离散序列，用于计算被控对象方程以及更新神经元权重系数。
ts = 0.001;
%设置迭代周期为1ms
learning_mode = 4;
%设置学习规则
error_integral = 0;
%积分记录
for k = 1:1:1000
time(k)=k*ts;
%横轴变化
yd(k) = 0.5*sign(sin(2*2*pi*k*ts));
%输入期望的信号函数-阶跃函数
y(k)=0.368*y_1 + 0.26*y_2 + 0.1*u_1 + 0.632*u_2;
%被控对象的离散方程。 x' = Ax + Bu
error(k) = yd(k) - y(k);
%计算当前误差
if learning_mode == 1
%无监督的HEBBE学习规则
w_x1(k) = w_x1 + kP*u_1*x(1);
w_x2(k) = w_x2 + kI*u_1*x(2);
w_x3(k) = w_x3 + kD*u_1*x(3);
K = 0.06;
%无监督的HEBBE学习规则
elseif learning_mode == 2
%有监督的delta学习规则
w_x1(k) = w_x1 + kP*error(k)*x(1);
w_x2(k) = w_x2 + kI*error(k)*x(2);
w_x3(k) = w_x3 + kD*error(k)*x(3);
K = 0.12;
%有监督的delta学习规则
elseif learning_mode == 3
%有监督的hebbe学习规则
w_x1(k) = w_x1 + kP*error(k)*u_1*x(1);
w_x2(k) = w_x2 + kI*error(k)*u_2*x(2);
w_x3(k) = w_x3 + kD*error(k)*u_3*x(3);
K = 0.12;
%有监督的hebbe学习规则
elseif learning_mode == 4
%改进后的有监督的hebbe学习规则
w_x1(k) = w_x1 + kP*error(k)*u_1*(error(k) - error_1);
w_x2(k) = w_x2 + kI*error(k)*u_2*(error(k) - error_1);
w_x3(k) = w_x3 + kD*error(k)*u_3*(error(k) - error_1);
K = 0.12;
%改进后的有监督的hebbe学习规则
end
x(1) = error(k); %比例
x(2) = error_integral; %积分
x(3) = error(k)-error_1; %微分
%神经元的输入
wadd(k)=abs(w_x1(k))+abs(w_x2(k))+abs(w_x3(k));
w11(k) = w_x1(k)/wadd(k);
w22(k) = w_x2(k)/wadd(k);
w33(k) = w_x3(k)/wadd(k);
w=[w11(k),w22(k),w33(k)];
%权重系数归一化操作
u(k)=K*w*x;
%控制律
error_1 = error(k);
%更新误差序列
error_integral = error_integral + error(k);
%更新误差积分
u_3 = u_2;
u_2 = u_1;
u_1 = u(k);
%更新神经元输出控制律序列
y_3=y_2;
y_2=y_1;
y_1=y(k);
%更新被控对象输出序列
w_x1=w_x1(k);
w_x2=w_x2(k);
w_x3=w_x3(k);
%更新权重系数
end
figure(1);
plot(time,yd,'r',time,y,'k:','linewidth',2);
xlabel('time');ylabel('yd;y');
title('track')
%打印被控对象跟踪结果
figure(2);
plot(time,u,'r','linewidth',2);
xlabel('time');ylabel('controlinput U');
title('control law')
%打印控制律曲线
- 无监督Hebb学习规则结果
- 有监督Delta学习规则结果
- 有监督Hebb学习规则结果
- 改进后的有监督Hebb学习规则结果
对比分析讨论
从上图的结果可以看出，无论是位置式还是增量式的形式，单神经元PID本质是一样的，都能起到自适应的作用。相比较之下,位置式的跟踪超调量大且出现振荡情况。这是由于学习速率和激励比例系数是针对于增量式整定过的参数。因此可以在增量式中表现出不错的跟踪效果。通过改进规则下的两个跟踪效果比对，可以看出，在不引入输入量 x i x_{i} xi的情况下，学习规则所实现的权重迭代优化都可以达到一个接近的效果。因此也可以间接表明，无论是增量式和位置式，都可以作为单神经元PID控制算法的实现形式，本质上是一致的。另外，当系统出现大的扰动或者错误时，位置式由于积分过大导致系统发生严重错误。
单神经元PID控制器中的参数整定
在单神经元PID控制器中，存在以下参数
pid参数 w i w_{i} wi，学习速率 η i \eta_{i} ηi，激励函数比例系数 K K K。
- 对于PID参数 w i w_{i} wi，只需要考虑其初始值为正实数即可。
- 对于学习速率 η i \eta_{i} ηi，初始时可以给一个较小的正实数，然后在确定了比例系数K之后再整定学习速率参数。当学习速率过快将会导致系统振荡甚至发散，较小时则收敛速度慢，在实际开发过程中，系统振荡发散都会带来非常严重甚至不可逆的危害。相比之下，系统过阻尼收敛慢带来的危害更小。
- 比例系数 K K K影响着系统的控制律 u ( k ) u(k) u(k)，因此对其的整定也应该是从小慢慢增大，使系统处于临界阻尼状态，再进一步调试学习速率使系统达到控制器设计需求。另外，为了防止系统输出过大，可以考虑在控制律输出后加入限幅，相位延时组件来降低风险。
- 另外，在调试学习速率时，可以依据控制器的各个权重收敛曲线来辅助判断。
以阶跃响应作为测试，观察各个权重即PID参数的收敛情况，以此判断学习速率是否满足要求。
以频率响应作为测试，观察各个权重即PID参数的变化情况，以此判断学习速率是否满足要求。
PID参数的稳定与否一定程度上影响了系统的控制性能，因此再整定学习速率时，也要观察神经元权重的变化情况来辅助整定工作。
总结
此文仅作为学习记录，并且对专业书中许多未注明的细节发表个人观点，帮助将这个算法的原理串联起来，并入知识网络中。文中有诸多不完善的地方，例如未进行对学习规则公式的数学推导等。并且文中可能出现错误或者键误的地方，欢迎各位同志指正！
更新补充
内容勘误
在多次仿真测试后，发现位置式的单神经元PID控制算法，在实际的仿真结果中，会在零点产生一个扰动，经过多次排查调试后，发现问题出在了对于输入权重系数的归一化算法上，因此在原有基础上，作了以下修改。
%神经元的输入
if learning_mode == 1
%无监督的HEBBE学习规则
tmp_x1 = last_w_x1 + kP*u_1*x(1);
tmp_x2 = last_w_x2 + kI*u_1*x(2);
tmp_x3 = last_w_x3 + kD*u_1*x(3);
w_x1(k) = exp(tmp_x1)/(exp(tmp_x1)+(1/exp(tmp_x1)));
w_x2(k) = exp(tmp_x2)/(exp(tmp_x2)+(1/exp(tmp_x2)));
w_x3(k) = exp(tmp_x3)/(exp(tmp_x3)+(1/exp(tmp_x3)));
K = 0.06;
%无监督的HEBBE学习规则
elseif learning_mode == 2
%有监督的delta学习规则
tmp_x1 = last_w_x1 + kP*error(k)*x(1);
tmp_x2 = last_w_x2 + kI*error(k)*x(2);
tmp_x3 = last_w_x3 + kD*error(k)*x(3);
w_x1(k) = exp(tmp_x1)/(exp(tmp_x1)+(1/exp(tmp_x1)));
w_x2(k) = exp(tmp_x2)/(exp(tmp_x2)+(1/exp(tmp_x2)));
w_x3(k) = exp(tmp_x3)/(exp(tmp_x3)+(1/exp(tmp_x3)));
K = 0.06;
%有监督的delta学习规则
elseif learning_mode == 3
%有监督的hebbe学习规则
tmp_x1 = last_w_x1 + kP*error(k)*u_1*x(1);
tmp_x2 = last_w_x2 + kI*error(k)*u_2*x(2);
tmp_x3 = last_w_x3 + kD*error(k)*u_3*x(3);
w_x1(k) = exp(tmp_x1)/(exp(tmp_x1)+(1/exp(tmp_x1)));
w_x2(k) = exp(tmp_x2)/(exp(tmp_x2)+(1/exp(tmp_x2)));
w_x3(k) = exp(tmp_x3)/(exp(tmp_x3)+(1/exp(tmp_x3)));
K = 0.12;
%有监督的hebbe学习规则
elseif learning_mode == 4
%改进后的有监督的hebbe学习规则
tmp_x1 = last_w_x1 + kP*error(k)*u_1*(error(k) - error_1);
tmp_x2 = last_w_x2 + kI*error(k)*u_2*(error(k) - error_1);
tmp_x3 = last_w_x3 + kD*error(k)*u_3*(error(k) - error_1);
w_x1(k) = exp(tmp_x1)/(exp(tmp_x1)+(1/exp(tmp_x1)));
w_x2(k) = exp(tmp_x2)/(exp(tmp_x2)+(1/exp(tmp_x2)));
w_x3(k) = exp(tmp_x3)/(exp(tmp_x3)+(1/exp(tmp_x3)));
K = 0.12;
%改进后的有监督的hebbe学习规则
end
%修改学习规则的归一化函数
%将权重系数映射到0-1范围内，这是一个很常用的归一化函数
w=[w_x1(k),w_x2(k),w_x3(k)];
%将权重系数向量更改为上面这个
测试结果
-
无监督Hebb学习规则结果
-
有监督Delta学习规则结果
-
有监督Hebb学习规则结果
-
改进后的有监督Hebb学习规则结果
这里的参数跟增量式的部分完全一致，前面提到说可能是因为参数不适用导致的振荡为错误结论，造成的误导请谅解！
学习规则公式推导
已知单神经元输入分别为(以增量式为例)：
{
x
1
=
e
r
r
o
r
(
k
)
−
e
r
r
o
r
(
k
−
1
)
x
2
=
e
r
r
o
r
(
k
)
x
3
=
e
r
r
o
r
(
k
)
−
2
e
r
r
o
r
(
k
−
1
)
+
e
r
r
o
r
(
k
−
2
)
\left\{\begin{matrix} x_{1}=error(k)-error(k-1)\\ x_{2}=error(k)\\ x_{3}=error(k)-2error(k-1)+error(k-2) \end{matrix}\right.
⎩
⎨
⎧x1=error(k)−error(k−1)x2=error(k)x3=error(k)−2error(k−1)+error(k−2)
对应的输入权重分别为
w
1
,
w
2
,
w
3
w_{1},w_{2},w_{3}
w1,w2,w3。
输出的控制律为
u
(
k
)
=
u
(
k
−
1
)
+
∑
i
=
1
3
(
w
i
x
i
)
u(k)=u(k-1)+\sum_{i=1}^{3}(w_{i}x_{i})
u(k)=u(k−1)+i=1∑3(wixi)
假设系统函数为
y
′
=
f
(
y
,
u
)
y'=f(y,u)
y′=f(y,u)
其中，
y
y
y为系统状态变量
系统误差为
e
r
r
o
r
(
k
)
=
y
d
−
y
error(k)=y_{d}-y
error(k)=yd−y
其中，
y
d
y_{d}
yd为系统输入期望。
- 无规则Hebb学习规则
其学习规则的公式为
Δ
w
i
=
w
i
(
k
)
−
w
i
(
k
−
1
)
=
−
η
i
u
(
k
)
x
i
(
k
)
\Delta w_{i} = w_{i}(k)-w_{i}(k-1)=-\eta_{i}u(k)x_{i}(k)
Δwi=wi(k)−wi(k−1)=−ηiu(k)xi(k)
可以从下往上看，当系统误差变大时，单神经元的各个输入都将增大，输入权重也会随之增大，则输出的控制律
u
(
k
)
u(k)
u(k)也会变大，以此提高输出接近输入期望；当误差变小时，单神经元的各个输入都将边下，输入权重增长速度减缓，但由于误差仍然为正，因此输入权重依旧会增长。此时输出的控制律放缓，逐渐达到峰值。当系统变量抵达输入期望并且出现超调即误差由正转负时。输入权重变小，输出的控制律最终将收敛（假设此时系统输入恒定且无噪声干扰，由于此时的去输入权重变化小，各项误差输入都较小）。
这个叙述建立在系统控制律和系统变量为正相关关系时成立，即输出增大，系统变量增大。
从学习规则上来说，这种无监督的学习规则，十分容易出现超调现象。
- 有规则Delta学习规则
Δ
w
i
=
w
i
(
k
)
−
w
i
(
k
−
1
)
=
η
i
z
(
k
)
x
i
(
k
)
=
η
i
e
r
r
o
r
(
k
)
x
i
\Delta w_{i} = w_{i}(k)-w_{i}(k-1)=\eta_{i}z(k)x_{i}(k)=\eta_{i}error(k)x_{i}
Δwi=wi(k)−wi(k−1)=ηiz(k)xi(k)=ηierror(k)xi
在有规则的学习规则中，加入了对于系统误差的因子。其推导过程为
- 定义损失函数
J
J
J来评价参数指标
J = 1 2 ( y − y d ) 2 J = \frac{1}{2}(y-y_{d})^2 J=21(y−yd)2 - 损失函数对各输入权重系数求导
∂ J ∂ w i = ∂ J ∂ y ∂ y ∂ u ∂ u ∂ w i = ( y − y d ) x i = − e r r o r ( k ) x i \frac{\partial{J}}{\partial{w_{i}}}=\frac{\partial{J}}{\partial{y}}\frac{\partial{y}}{\partial{u}}\frac{\partial{u}}{\partial{w_{i}}} =(y-y_{d})x_{i} =-error(k)x_{i} ∂wi∂J=∂y∂J∂u∂y∂wi∂u=(y−yd)xi=−error(k)xi
通常情况下， ∂ y ∂ u \frac{\partial{y}}{\partial{u}} ∂u∂y不能精确计算得出，因为有时候不清楚系统模型的精确数学模型，这里常用以下方式替代：
∂ y ∂ u = s i g n ( Δ y Δ u ) = ± 1 \frac{\partial{y}}{\partial{u}}=sign(\frac{\Delta{y}}{\Delta{u}})=\pm1 ∂u∂y=sign(ΔuΔy)=±1
用于描述系统状态和输出当前的相关关系，这个相关关系将影响到梯度方向。
对于绝大多数连续系统以及可归类的系统模型，其相关关系都是为1，因此此处直接忽略。
通俗点讲，本文案例的系统模型，都是y随u增大而增大的模型，所以这个地方就是1。
当然你要把这个东西加进去也是可以的，他就能拓展到更多复杂的系统模型。
但是对于一些复杂的非线性不可归类系统，其系统变量和控制率的相关性会发生变化，需要添加此项来补充确定正确的梯度方向。
- 梯度下降法
显然，对于损失函数，理想状态下希望 J = 0 J=0 J=0且 ∂ J ∂ w i = 0 \frac{\partial{J}}{\partial{w_{i}}}=0 ∂wi∂J=0，在工程上，这类问题通常用梯度下降法来求解。
这里给出梯度下降法的维基百科 梯度下降法
梯度下降法有很多高效率的衍生方法，这里直接给出最基本的公式
b
=
a
−
γ
∇
F
(
a
)
{\mathbf {b}}={\mathbf {a}}-\gamma \nabla F({\mathbf {a}})
b=a−γ∇F(a)
其中，
b
b
b为下降后的自变量数值，
a
a
a为当前的自变量数值，
γ
\gamma
γ为下降步长，也就是前面学习规则中的学习速率。
其定义为如果实值函数
F
(
x
)
{\displaystyle F(\mathbf {x} )}
F(x)在点
a
{\displaystyle \mathbf {a} }
a处可微且有定义，那么函数
F
(
x
)
{\displaystyle F(\mathbf {x} )}
F(x)在
a
{\displaystyle \mathbf {a} }
a点沿着梯度相反的方向
−
∇
F
(
a
)
{\displaystyle -\nabla F(\mathbf {a} )}
−∇F(a)下降最多。
因此将可以得到函数自变量增量
Δ
\Delta
Δ为
Δ
=
b
−
a
=
−
γ
∇
F
(
a
)
=
−
γ
∂
J
∂
w
i
=
−
γ
(
y
−
y
d
)
x
i
=
−
γ
(
−
e
r
r
o
r
(
k
)
)
x
i
=
γ
e
r
r
o
r
(
k
)
x
i
\Delta = \mathbf{b} -\mathbf{a} = -\gamma \nabla F(\mathbf{a})=-\gamma \frac{\partial{J}}{\partial{w_{i}}}=-\gamma (y-y_{d})x_{i}=-\gamma(-error(k))x_{i}=\gamma error(k)x_{i}
Δ=b−a=−γ∇F(a)=−γ∂wi∂J=−γ(y−yd)xi=−γ(−error(k))xi=γerror(k)xi
此处的 γ \gamma γ等同于前文的 η \eta η。
扫一扫
7363
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
