小工具知识网

当前位置: 首页 > 行业知识 > 自适应PID算法学习(01)——单神经元PID控制

行业知识

自适应PID算法学习(01)——单神经元PID控制

2026-11-21 08:57:09 来源:互联网转载

神经元PID

文章目录

  • 神经元PID
    • 单神经元结构
    • 学习规则
        • 无监督Hebb学习
        • 有监督Delta学习
        • 有监督Hebb学习
        • 神经元PID控制过程
            • 输入更新
            • 连接权值更新、归一化
            • 输出更新
            • 代码实现和展示
                • 主程序
                • 子函数——连接权值更新(使用有监督Hebb学习规则)
                • 子函数——连接权值归一化
                • 子函数——目标输出设置
                • 子函数——控制对象设置
                • 运行结果展示
                • 运行结果展示
                • ���完待续 ~ ~

                  单神经元结构

                    单神经元含有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*nety(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)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)的部分,只不过这里的对象是离散系统,并且将该数学描述换用了状态空间表达式的形式,具体怎么推导的可以看看我这段子程序开头的注释,如下有:

                  % 被控对象的状态空间表达式:% 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系数迭代变化曲线

                    

                  未完待续 ~ ~

上一篇:SQL数据交集详解,轻松获取结果的方法

下一篇:xerox主机怎么样