神经元PID
单神经元结构
单神经元含有n个输入，仅1个输出，每个输入端可记作
x
i
(
i
=
1
,
2
,
.
.
.
n
)
x_i (i=1,2,...n)
xi(i=1,2,...n)，若该神经元为多元组成网络中某一层（输入层/输出层/隐含层）其中的一个单元，记该神经元输出为
o
j
(
j
=
1
,
2
,
.
.
.
)
o_j(j=1,2,...)
oj(j=1,2,...)；不同输入端进入该单元的连接权值不同，记作
ω
i
j
\omega_{ij}
ωij，表示连接第
j
j
j个神经元的第
i
i
i个输入端的连接权值。
另外，神经元在接收多个输入时，应有累加-整合的过程，即先有：
n
e
t
j
=
∑
i
=
1
n
ω
i
j
⋅
x
i
j
net_j=\sum_{i=1}^n\omega_{ij}\cdot x_{ij}
netj=∑i=1nωij⋅xij，再经历：
o
j
=
f
(
n
e
t
j
)
o_j=f(net_j)
oj=f(netj)才得到输出。累加运算也可表述为矩阵运算形式如：n维权向量
ω
j
\omega_j
ωj的转置（列向量）与n维输入向量
x
j
x_j
xj（行向量）相乘，得到标量
n
e
t
j
net_j
netj，即有：
n
e
t
j
=
ω
j
T
⋅
x
j
(1)
net_j=\omega_j^T\cdot x_j\tag{1}
netj=ωjT⋅xj(1)
整合
n
e
t
j
net_j
netj的
f
f
f即称为激活函数，可选用各种有阈值限制的非线性函数，如常用的有：切换函数
f
(
n
e
t
)
=
s
g
n
(
n
e
t
)
f(net)=sgn(net)
f(net)=sgn(net)、反正切函数
f
(
n
e
t
)
=
a
t
a
n
(
n
e
t
)
f(net)=atan(net)
f(net)=atan(net)，等等。
学习规则
神经元/神经网络的学习规则，即修正（更新）连接权值所选用的算法，可分类为有监督学习或无监督学习。
无监督Hebb学习
连接权值的修正与输入
x
i
x_i
xi和输出
o
j
o_j
oj的乘积成正比，即有：
Δ
ω
i
j
(
k
)
=
η
⋅
(
x
i
(
k
)
⋅
o
j
(
k
)
)
(2)
\Delta\omega_{ij}^{(k)}=\eta\cdot (x_i^{(k)}\cdot o_j^{(k)}) \tag{2}
Δωij(k)=η⋅(xi(k)⋅oj(k))(2)
有监督Delta学习
在无监督Hebb的基础上，引入教师信号，将输出
o
j
o_j
oj替换为实际输出
o
j
o_j
oj相对期望输出
d
j
d_j
dj的误差，即有：
Δ
ω
i
j
(
k
)
=
η
⋅
[
x
i
(
k
)
⋅
(
d
j
(
k
)
−
o
j
(
k
)
)
]
(3)
\Delta\omega_{ij}^{(k)}=\eta\cdot [x_i^{(k)}\cdot (d_j^{(k)}-o_j^{(k)})] \tag{3}
Δωij(k)=η⋅[xi(k)⋅(dj(k)−oj(k))](3)
有监督Hebb学习
结合无监督Hebb和有监督Delta，即连接权更新正比于输入、输出、输出误差的乘积，即有：
Δ
ω
i
j
(
k
)
=
η
⋅
[
(
d
j
(
k
)
−
o
j
(
k
)
)
⋅
x
i
(
k
)
⋅
o
j
(
k
)
]
(4)
\Delta\omega_{ij}^{(k)}=\eta\cdot[(d_j^{(k)}-o_j^{(k)})\cdot x_i^{(k)} \cdot o_j^{(k)}] \tag{4}
Δωij(k)=η⋅[(dj(k)−oj(k))⋅xi(k)⋅oj(k)](4)
上述各式中：
上角标
(
k
)
(k)
(k)表示当前的迭代轮次；
Δ
ω
i
j
\Delta\omega_{ij}
Δωij为计算得的连接权值的修正量，即有：
ω
i
j
(
k
+
1
)
=
ω
i
j
(
k
)
+
Δ
ω
i
j
(
k
+
1
)
(5)
\omega_{ij}^{(k+1)}=\omega_{ij}^{(k)}+\Delta\omega_{ij}^{(k+1)}\tag{5}
ωij(k+1)=ωij(k)+Δωij(k+1)(5)
神经元PID控制过程
输入更新
对于单神经元PID控制而言，我们的目的是要自适应地更新三个控制器参数Kp，Ki，Kd，输入维数n=3；而PID控制器的输入量与传统PID一样，为当前被控对象的实际输出
y
(
k
)
y^{(k)}
y(k)相对目标输出
y
d
(
k
)
y_d^{(k)}
yd(k)的误差，即有：
e
(
k
)
=
y
d
(
k
)
−
y
(
k
)
(6)
e^{(k)}=y_d^{(k)}-y^{(k)}\tag{6}
e(k)=yd(k)−y(k)(6)
若PID控制器模式选用增量式PID，即$\Delta u^{(k)}=K_p \cdot (e{(k)}-e{(k-1)})+K_i \cdot
对于神经元输入
对于神经元输入
对于神经元输入x_{ij}$，应有：
x
1
j
(
k
)
=
e
(
k
)
−
e
(
k
−
1
)
x
2
j
(
k
)
=
e
(
k
)
x
3
j
(
k
)
=
e
(
k
)
−
2
e
(
k
−
1
)
+
e
(
k
−
2
)
(7)
\begin{aligned} &x_{1j}^{(k)}=e^{(k)}-e^{(k-1)}\tag{7} \\ &x_{2j}^{(k)}=e^{(k)} \\ &x_{3j}^{(k)}=e^{(k)}-2e^{(k-1)}+e^{(k-2)} \end{aligned}
x1j(k)=e(k)−e(k−1)x2j(k)=e(k)x3j(k)=e(k)−2e(k−1)+e(k−2)(7)
连接权值更新、归一化
在已有更新的输入值
x
i
j
(
k
)
x_{ij}^{(k)}
xij(k)和已有的输出值
o
j
(
k
−
1
)
o_j^{(k-1)}
oj(k−1)后，即可更新本轮次神经元运算需用到的连接权值
ω
i
j
(
k
\omega_{ij}^{(k}
ωij(k；设选用了有监督的Hebb学习规则，即同时调用了本轮更新的输出误差
e
(
k
)
e^{(k)}
e(k)，则有：
ω
1
j
(
k
)
=
ω
1
j
(
k
−
1
)
+
η
p
⋅
[
e
(
k
)
⋅
x
1
(
k
)
⋅
o
j
(
k
−
1
)
]
ω
2
j
(
k
)
=
ω
2
j
(
k
−
1
)
+
η
i
⋅
[
e
(
k
)
⋅
x
2
(
k
)
⋅
o
j
(
k
−
1
)
]
ω
3
j
(
k
)
=
ω
3
j
(
k
−
1
)
+
η
d
⋅
[
e
(
k
)
⋅
x
3
(
k
)
⋅
o
j
(
k
−
1
)
]
(11)
\begin{aligned} &\omega_{1j}^{(k)}=\omega_{1j}^{(k-1)}+\eta_p\cdot[e^{(k)}\cdot x_1^{(k)} \cdot o_j^{(k-1)}]\tag{11} \\ &\omega_{2j}^{(k)}=\omega_{2j}^{(k-1)}+\eta_i\cdot[e^{(k)}\cdot x_2^{(k)} \cdot o_j^{(k-1)}] \\ &\omega_{3j}^{(k)}=\omega_{3j}^{(k-1)}+\eta_d\cdot[e^{(k)}\cdot x_3^{(k)} \cdot o_j^{(k-1)}] \end{aligned}
ω1j(k)=ω1j(k−1)+ηp⋅[e(k)⋅x1(k)⋅oj(k−1)]ω2j(k)=ω2j(k−1)+ηi⋅[e(k)⋅x2(k)⋅oj(k−1)]ω3j(k)=ω3j(k−1)+ηd⋅[e(k)⋅x3(k)⋅oj(k−1)](11)
式中，
η
p
\eta_p
ηp、
η
i
\eta_i
ηi、
η
d
\eta_d
ηd分别为神经元PID的比例项、积分项、微分项的学习速率。
在得到上述更新的连接权值
ω
i
j
(
k
)
\omega_{ij}^{(k)}
ωij(k)后，还需要做类似于单位化的归一化操作，即有：
ω
i
j
(
k
)
=
ω
i
j
(
k
)
/
∑
i
=
1
n
∣
ω
i
j
(
k
)
∣
,
i
=
1
,
2
,
3
(10)
\omega_{ij}^{(k)}=\omega_{ij}^{(k)}/ \sum_{i=1}^n \lvert\omega_{ij}^{(k)} \rvert ,i=1,2,3\tag{10}
ωij(k)=ωij(k)/i=1∑n∣ωij(k)∣,i=1,2,3(10)
不难理解可知，一直在更新并用于与式(7)所示的
x
1
j
x_{1j}
x1j、
x
2
j
x_{2j}
x2j、
x
3
j
x_{3j}
x3j相乘再累加的连接权值
ω
1
j
\omega_{1j}
ω1j、
ω
2
j
\omega_{2j}
ω2j、
ω
3
j
\omega_{3j}
ω3j，乘上神经元比例系数
ϵ
\epsilon
ϵ，即是我们神经元PID的自适应参数
K
p
K_p
Kp、
K
i
K_i
Ki、
K
d
K_d
Kd。
输出更新
单神经元的输出如同普通PID一样，为输入到被控对象的供给量
u
u
u（控制器输出，即控制律），即经过神经元，输出得到控制律
u
(
k
)
u^{(k)}
u(k)变化量。另外，当前轮次k用到的是当前轮次k的输入、连接权，即有：
n
e
t
j
(
k
)
=
∑
i
=
1
n
ω
i
j
(
k
)
⋅
x
i
j
(
k
)
(8)
net_j^{(k)}=\sum_{i=1}^n\omega_{ij}^{(k)}\cdot x_{ij}^{(k)}\tag{8}
netj(k)=i=1∑nωij(k)⋅xij(k)(8)
整合函数无非线性要求，直接成比例输出，则控制律更新有：
u
(
k
)
=
u
(
k
−
1
)
+
ϵ
⋅
n
e
t
j
(
k
)
(9)
u^{(k)}=u^{(k-1)}+\epsilon\cdot net_j^{(k)}\tag{9}
u(k)=u(k−1)+ϵ⋅netj(k)(9)
式中，
ϵ
\epsilon
ϵ为神经元的比例系数。当然，神经元输出符号代换有：
o
j
(
k
)
=
u
(
k
)
(10)
o_j^{(k)}=u^{(k)}\tag{10}
oj(k)=u(k)(10)
上述各part表达为控制流图，即如下所示：
![]
代码实现和展示
主程序
编写成Matlab代码，程序框架（主程序）如下所示：
close all;clear
% 迭代次数：
Num=2000;
% 迭代周期：
T=0.001; % T=0.01s
% 连接权值初始化：
omega=[0.1,0.1,0.1];
% 输入变量初始化：
x=[0,0,0]';
% 输出变量初始化：
u(1)=0; % u(k)
u_1=0; % u(k-1)
u_2=0; % u(k-2)
u_3=0; % u(k-3)
net=0; % net=omega'*x; u(k)=u(k-1)+eps*net
y(1)=0; % 被控对象实际输出
y_1=0; % y(k-1)
y_2=0; % y(k-2)
% 误差变量初始化：
err_0(1)=0; % e(k)
err_1=0; % e(k-1)
err_2=0; % e(k-2)
% 控制律输出限幅:
u_max=1.2;
u_min=-1.2;
% 神经元参数设置：
eps=0.12; % 神经元比例系数
eta_p=0.4; % 比例项学习速率
eta_i=0.35; % 积分项学习速率
eta_d=0.4; % 微分项学习速率
w1(1)=0;
w2(1)=0;
w3(1)=0;
%%% 进入控制-训练轮次：
for k=1:Num
% 目标输出：
yd(k)=Target_Oput(k,T);
% 输入到被控对象，实际输出：
y(k)=Controlled_Obj(y_2,y_1,u_2,u_1);
% 计算输出误差：
err_0(k)=yd(k)-y(k);
% （神经元）输入更新：
x(1)=err_0(k)-err_1;
x(2)=err_0(k);
x(3)=err_0(k)-2*err_1+err_2;
% （神经元）连接权值更新
omega=Hebb_Learning(omega,eta_p,eta_i,eta_d,...
err_0(k),x,u_1);
omega=Omega_Norm(omega);
% （神经元）输出更新：
u(k)=u_1+eps*omega*x; % 输出控制律
if(u(k)>u_max) u(k)=u_max;
elseif(u(k)<u_min) u(k)=u_min;end
% 误差序列更新：
err_2=err_1;
err_1=err_0(k);
% 控制序列更新：
u_3=u_2;
u_2=u_1;
u_1=u(k);
% 输出序列更新：
y_2=y_1;
y_1=y(k);
% 用于显示Kp,Ki,Kd：
w1(k)=eps*omega(1);
w2(k)=eps*omega(2);
w3(k)=eps*omega(3);
end
%%% 画图展示:
time=T:T:Num*T;
figure % 输出响应
plot(time,yd,'r');hold on;
plot(time,y,'b');title("输出响应");
ylabel('yt');xlabel('time');legend('目标输出-yd','实际输出-y');
figure % 误差响应+控制律变化
subplot(2,1,1);plot(time,err_0,'-r');title("误差响应");
ylabel('error');xlabel('time');
subplot(2,1,2);plot(time,u,'-g');title("控制律变化");
ylabel('ut');xlabel('time');
figure % PID参数变化
subplot(3,1,1);plot(time,w1,'r');ylabel('Kp');title("PID参数");
subplot(3,1,2);plot(time,w2,'b');ylabel('Ki');
subplot(3,1,3);plot(time,w3,'k');ylabel('Kd');xlabel('time');
子函数——连接权值更新（使用有监督Hebb学习规则）
在每轮神经元运算之前，更新连接权值 ω i j \omega_{ij} ωij，这里示例用的是有监督Hebb学习规则，对应公式(11)，如下所示：
function [omega_new]=Hebb_Learning(omega,eta_p,eta_i,eta_d,...
err,x,u)
w1=omega(1);
w2=omega(2);
w3=omega(3);
x1=x(1);
x2=x(2);
x3=x(3);
if err>1;err=-err;end % 随便加的，合法有效但有病
w1=w1+eta_p*(err*x1*u);
w2=w2+eta_i*(err*x2*u);
w3=w3+eta_d*(err*x3*u);
omega_new=[w1,w2,w3];
end
子函数——连接权值归一化
对应公式(10)，完成连接权值 ω i j \omega_{ij} ωij更新后的归一化（单位化）步骤，如下所示：
function [omega_new]=Omega_Norm(omega)
w1=omega(1);
w2=omega(2);
w3=omega(3);
wsum=abs(w1)+abs(w2)+abs(w3);
w1=w1/wsum;
w2=w2/wsum;
w3=w3/wsum;
omega_new=[w1,w2,w3];
end
子函数——目标输出设置
设计跟踪目标输出为上下幅值为±1的正负阶跃信号（方波信号），如下示例有：
function [yd_k]=Target_Oput(k,T)
yd_k=sign(sin(2*pi*k*T));
% yd_k=sin(2*pi*k*T);
end
注释中的是将目标输出切换为正弦函数 y d = s i n ( 2 π t ) y_d =sin(2\pi t) yd=sin(2πt)，你也可以试着复现下看看效果~
子函数——控制对象设置
相当于我们在控制系统中所见到的传递函数G(s)的部分，只不过这里的对象是离散系统，并且将该数学描述换用了状态空间表达式的形式，具体怎么推导的可以看看我这段子程序开头的注释，如下有：文章来源：https://www.toymoban.com/news/detail-597835.html
% 被控对象的状态空间表达式：
% dx=A*x+B*u；
% 令x1=y(k-2),x2=y(k-1)，则:dx1=y(k-1)=x2，dx2=y(k);
% y(k-1)=[0 1]*[y(k-2) y(k-1)]'+0*u，不用写;
% y(k)=[a21 a22]*[y(k-2) y(k-1)]'+[b21 b22]*[u2 u1]';
% u1=u(k-1),u2=u(k-2);
function [y_k]=Controlled_Obj(y_2,y_1,u_2,u_1)
y_k=0.26*y_2+0.368*y_1+0.632*u_2+0.1*u_1;
end
运行结果展示
运行结果展示
运行主程序代码（程序要“添加到路径”），输出该单神经元PID控制仿真结果（使用的是有监督Hebb学习规则），跟踪三个上下摆动周期，如下所示：
目标输出–实际输出跟踪曲线：
输出误差曲线+控制律输入曲线
P-I-D系数迭代变化曲线
文章来源地址https://www.toymoban.com/news/detail-597835.html
未完待续 ~ ~
到了这里，关于自适应PID算法学习（01）——单神经元PID控制的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
