Press "Enter" to skip to content

【模糊神经网络】基于simulink的模糊神经网络控制器设计

本站内容均来自兴趣收集,如不慎侵害的您的相关权益,请留言告知,我们将尽快删除.谢谢.

1.软件版本

 

MATLAB2010b

 

2.模糊神经网络理论概述

 

由于模糊控制是建立在专家经验的基础之上的,但这有很大的局限性,而人工神经网络可以充分逼近任意复杂的时变非线性系统,采用并行分布处理方法,可学习和自适应不确定系统。利用神经网络可以帮助模糊控制器进行学习,模糊逻辑可以帮助神经网络初始化及加快学习过程。通常神经网络的基本构架如下所示:

 

 

整个神经网络结构为五层,其中第一层为“输入层“,第二层为“模糊化层”,第三层为“模糊推理层”,第四层为“归一化层”,第五层为“解模糊输出层”。

 

第一层 为输入层,其主要包括两个节点,所以第一层神经网络的输入输出可以用如下的式子表示:

 

 

 

第二层 为输入变量的语言变量值,通常是模糊集中的 n 个变量, 它的作用是计算各输入分量属于各语言变量值模糊集合的隶属度。用来确定输入在不同的模糊语言值对应的隶属度,以便进行模糊推理,如果隶属函数为高斯函数,那幺其表达式为:

 

 

其中变量的具体含义和第一层节点的变量含义相同。

 

第三层 是比较关键的一层,即模糊推理层,这一层的每个节点代表一条模糊规则,其每个节点的输出值表示每条模糊规则的激励强度。该节点的表达式可用如下的式子表示:

 

 

第四层 为归一化层,其输出是采用了 Madmdani 模糊规则,该层的表达式为:

 

 

第五层 是模糊神经网络的解模糊层,即模糊神经网络的清晰化 .

 

3.算法的simulink建模

 

为了对比加入FNN控制器后的性能变化,我们同时要对有FNN控制器的模型以及没有FNN控制器的模型进行仿真,仿真结果如下所示:

 

非FNN控制器的结构:

 

 

其仿真结果如下所示:

 

 

FNN控制器的结构:

 

 

其仿真结果如下所示:

 

 

前面的是训练阶段,后面的为实际的输出,为了能够体现最后的性能,我们将两个模型的最后输出进行对比,得到的对比结果所示:

 

 

从上面的仿真结果可知,PID的输出值范围降低了很多,性能得到了进一步提升。

 

调速TS模型,该模型最后的仿真结果如下所示:

 

 

从上面的仿真结果可知,采用FNN控制器后,其PID的输出在一个非常小的范围之内进行晃动,整个系统的性能提高了80%。这说明采用模糊神经网络后的系统具有更高的性能和稳定性。

 

4.部分程序

 

Mamdani模糊控制器的S函数

 

function [out,Xt,str,ts] = Sfunc_fnn_Mamdani(t,Xt,u,flag,Learn_rate,coff,lamda,Number_signal_in,Number_Fuzzy_rules,x0,T_samples)
%输入定义
% t,Xt,u,flag        :S函数固定的几个输入脚
% Learn_rate         :学习度
% coff               :用于神经网络第一层的参数调整
% lamda              :神经网络的学习遗忘因子
% Number_signal_in   :输入的信号的个数 
% Number_Fuzzy_rules :模糊控制规则数
% T_samples          :模块采样率
%输入信号的个数 
Number_inport = Number_signal_in;
%整个系统的输入x,误差输入e,以及训练指令的数组的长度
ninps         = Number_inport+1+1;   
NumRules      = Number_Fuzzy_rules;
Num_out1      = 3*Number_signal_in*Number_Fuzzy_rules  + ((Number_signal_in+1)*NumRules)^2 + (Number_signal_in+1)*NumRules;
Num_out2      = 3*Number_signal_in*Number_Fuzzy_rules + (Number_signal_in+1)*NumRules;
%S函数第一步,参数的初始化
if flag == 0
out = [0,Num_out1+Num_out2,1+Num_out1+Num_out2,ninps,0,1,1];  
str = [];                                                         
ts  = T_samples;                                                         
Xt  = x0;
%S函数的第二步,状态的计算
elseif flag == 2
%外部模块的输出三个参数变量输入x,误差输入e,以及训练指令的数组的长度
x        = u(1:Number_inport);%输入x
e        = u(Number_inport+1:Number_inport+1);%误差输入e
learning = u(Number_inport+1+1);%训练指令的数组的长度
%1的时候为正常工作状态
if learning == 1 
Feedfor_phase2;  
%下面定义在正常的工作状态中,各个网络层的工作
%层1:
In1     = x*ones(1,Number_Fuzzy_rules);
Out1    = 1./(1 + (abs((In1-mean1)./sigma1)).^(2*b1));
%层2:
precond = Out1'; 
Out2    = prod(Out1)';
S_2     = sum(Out2);
%层3:
if S_2~=0
   Out3 = Out2'./S_2;
else
   Out3 = zeros(1,NumRules);
end 
%层4:
Aux1 = [x; 1]*Out3;
%训练数据
a = reshape(Aux1,(Number_signal_in+1)*NumRules,1);  
 
%参数学习
P           = (1./lamda).*(P - P*a*a'*P./(lamda+a'*P*a));
ThetaL4     = ThetaL4 + P*a.*e;
ThetaL4_mat = reshape(ThetaL4,Number_signal_in+1,NumRules);
%错误反馈
e3          = [x' 1]*ThetaL4_mat.*e;
denom       = S_2*S_2;
%下面自适应产生10个规则的模糊控制器
Theta32     = zeros(NumRules,NumRules);
if denom~=0
   for k1=1:NumRules
        for k2=1:NumRules
             if k1==k2 
                Theta32(k1,k2) = ((S_2-Out2(k2))./denom).*e3(k2);
             else
                Theta32(k1,k2) = -(Out2(k2)./denom).*e3(k2);
             end
        end
   end
end
e2 = sum(Theta32,2);
%层一
Q = zeros(Number_signal_in,Number_Fuzzy_rules,NumRules);  
for i=1:Number_signal_in
   for j=1:Number_Fuzzy_rules
     for k=1:NumRules  
      if Out1(i,j)== precond(k,i) && Out1(i,j)~=0
      Q(i,j,k) = (Out2(k)./Out1(i,j)).*e2(k);
            else
        Q(i,j,k) = 0;
        end
     end 
   end 
 end
Theta21 = sum(Q,3);
 
%自适应参数调整 
if isempty(find(In1==mean1))
    
deltamean1   =  Theta21.*(2*b1./(In1-mean1)).*Out1.*(1-Out1);
deltab1      =  Theta21.*(-2).*log(abs((In1-mean1)./sigma1)).*Out1.*(1-Out1);
deltasigma1  =  Theta21.*(2*b1./sigma1).*Out1.*(1-Out1);                
dmean1       = Learn_rate*deltamean1 + coff*dmean1;
mean1        = mean1 + dmean1;
dsigma1      = Learn_rate*deltasigma1 + coff*dsigma1;
sigma1       = sigma1 + dsigma1;
db1          = Learn_rate*deltab1 + coff*db1;
b1           = b1 + db1;
               
for i=1:Number_Fuzzy_rules-1
    if ~isempty(find(mean1(:,i)>mean1(:,i+1)))
        for i=1:Number_signal_in
            [mean1(i,:) index1] = sort(mean1(i,:));
            sigma1(i,:)         = sigma1(i,index1);
            b1(i,:)             = b1(i,index1);
        end
    end
end
end
%完成参数学习过程
%并保存参数学习结果
Xt = [reshape(mean1,Number_signal_in*Number_Fuzzy_rules,1);reshape(sigma1,Number_signal_in*Number_Fuzzy_rules,1);reshape(b1,Number_signal_in*Number_Fuzzy_rules,1);reshape(P,((Number_signal_in+1)*NumRules)^2,1);ThetaL4;reshape(dmean1,Number_signal_in*Number_Fuzzy_rules,1);reshape(dsigma1,Number_signal_in*Number_Fuzzy_rules,1);reshape(db1,Number_signal_in*Number_Fuzzy_rules,1);dThetaL4;];
end
out=Xt;
%S函数的第三步,定义各个网络层的数据转换
elseif flag == 3
Feedfor_phase;
%定义整个模糊神经网络的各个层的数据状态
%第一层
x       = u(1:Number_inport);
In1     = x*ones(1,Number_Fuzzy_rules);%第一层的输入
Out1    = 1./(1 + (abs((In1-mean1)./sigma1)).^(2*b1));%第一层的输出,这里,这个神经网络的输入输出函数可以修改
%第一层
precond = Out1'; 
Out2    = prod(Out1)';
S_2     = sum(Out2);%计算和
%第三层
if S_2~=0
   Out3 = Out2'./S_2;
else
   Out3 = zeros(1,NumRules);%为了在模糊控制的时候方便系统的运算,需要对系统进行归一化处理
end
%第四层
Aux1    = [x; 1]*Out3;
a       = reshape(Aux1,(Number_signal_in+1)*NumRules,1);%控制输出
%第五层,最后结果输出
outact  = a'*ThetaL4;
%最后的出处结果
out     = [outact;Xt];             
else
out     = [];
end

 

TS模糊控制器的S函数

 

function [out,Xt,str,ts] = Sfunc_fnn_TS(t,Xt,u,flag,Learn_rate,coffa,lamda,r,vigilance,coffb,arate,Number_signal_in,Number_Fuzzy_rules,x0,Xmins,Data_range,T_samples)
%输入定义
% t,Xt,u,flag        :S函数固定的几个输入脚
% Learn_rate         :学习度
% coffb               :用于神经网络第一层的参数调整
% lamda              :神经网络的学习遗忘因子
% Number_signal_in   :输入的信号的个数 
% Number_Fuzzy_rules :模糊控制规则数
% T_samples          :模块采样率 
    
Data_in_numbers       = Number_signal_in;
Data_out_numbers      = 1;
%整个系统的输入x,误差输入e,以及训练指令的数组的长度
ninps                 = Data_in_numbers+Data_out_numbers+1;   
Number_Fuzzy_rules2   = Number_Fuzzy_rules;
Num_out1              = 2*Number_signal_in*Number_Fuzzy_rules + ((Number_signal_in+1)*Number_Fuzzy_rules2)^2 + (Number_signal_in+1)*Number_Fuzzy_rules2 + 1;
Num_out2              = 2*Number_signal_in*Number_Fuzzy_rules +  (Number_signal_in+1)*Number_Fuzzy_rules2;
%S函数第一步,参数的初始化
if flag == 0
out = [0,Num_out1+Num_out2,1+Num_out1+Num_out2,ninps,0,1,1];  
str = [];                                                        
ts  = T_samples;                                                 
Xt  = x0;
%S函数的第二步,状态的计算
elseif flag == 2
x1       = (u(1:Data_in_numbers) - Xmins)./Data_range;
x        = [ x1; ones(Data_in_numbers,1) -  x1]; 
e        = u(Data_in_numbers+1:Data_in_numbers+Data_out_numbers);
learning = u(Data_in_numbers+Data_out_numbers+1);
%1的时候为正常工作状态
if learning == 1 
   
NumRules   = Xt(1);
NumInTerms = NumRules;
Feedfor_phase;  
%最佳参数搜索
New_nodess = 0;
reass      = 0;
Rst_nodes  = [];                   
rdy_nodes  = [];
while reass == 0 && NumInTerms<Number_Fuzzy_rules 
      %搜索最佳点
      N          = size(w_a,2);
      node_tmp   = x * ones(1,N);                                                                   
      A_AND_w    = min(node_tmp,w_a);  
      Sa         = sum(abs(A_AND_w)); 
      Ta         = Sa ./ (coffb + sum(abs(w_a)));  
      %节点归零
      Ta(Rst_nodes) = zeros(1,length(Rst_nodes));
      Ta(rdy_nodes) = zeros(1,length(rdy_nodes));    
      [Tamax,J]     = max(Ta);  
      w_J           = w_a(:,J);              
      xa            = min(x,w_J);
      %最佳节点测试
      if sum(abs(xa))./Number_signal_in >= vigilance,
         reass    = 1;   
         w_a(:,J) = arate*xa + (1-arate)*w_a(:,J);
      elseif sum(abs(xa))/Number_signal_in < vigilance,
             reass = 0;     
             Rst_nodes = [Rst_nodes  J ];
      end  
      if  length(Rst_nodes)== N || length(rdy_nodes)== N
          w_a        = [w_a x];
          New_nodess = 1;    
          reass      = 0;   
      end
end;      
                          
%节点更新
u2          = w_a(1:Number_signal_in,:);
v2          = 1 - w_a(Number_signal_in+1:2*Number_signal_in,:);
NumInTerms  = size(u2,2);
NumRules    = NumInTerms;
if New_nodess == 1
    ThetaL5  = [ThetaL5; zeros(Number_signal_in+1,1)];
    dThetaL5 = [dThetaL5; zeros(Number_signal_in+1,1)];
    P        =  [  P                                                           zeros((Number_signal_in+1)*(NumRules-1),Number_signal_in+1);
                  zeros(Number_signal_in+1,(Number_signal_in+1)*(NumRules-1))  1e6*eye(Number_signal_in+1); ];
    du2      = [du2  zeros(Number_signal_in,1);];      
    dv2     = [dv2  zeros(Number_signal_in,1);];
end
 
%层2:
x1_tmp  = x1;
x1_tmp2 = x1_tmp*ones(1,NumInTerms);
Out2    = 1 - check(x1_tmp2-v2,r) - check(u2-x1_tmp2,r);
%层3: 
Out3    = prod(Out2);  
S_3     = sum(Out3);
%层4:
if S_3~=0
   Out4 = Out3/S_3;
else 
   Out4 = zeros(1,NumRules); 
end
Aux1    = [x1_tmp; 1]*Out4;
a       = reshape(Aux1,(Number_signal_in+1)*NumRules,1);
%层五
P           = (1./lamda).*(P - P*a*a'*P./(lamda+a'*P*a));
ThetaL5     = ThetaL5 + P*a.*e;
ThetaL5_tmp = reshape(ThetaL5,Number_signal_in+1,NumRules);
%错误反馈
%层4:
e4          = [x1_tmp' 1]*ThetaL5_tmp.*e;
denom       = S_3*S_3;
%层3:
Theta43 = zeros(NumRules,NumRules);
if denom~=0
    for k1=1:NumRules
        for k2=1:NumRules
            if k1==k2
                Theta43(k1,k2) = ((S_3-Out3(k2))./denom).*e4(k2);
            else
                Theta43(k1,k2) = -(Out3(k2)./denom).*e4(k2);
            end
        end
    end
end
e3 = sum(Theta43,2);
%层2
Q = zeros(Number_signal_in,NumInTerms,NumRules);  
for i=1:Number_signal_in
    for j=1:NumInTerms
        for k=1:NumRules  
            if j==k && Out2(i,j)~=0
           Q(i,j,k) = (Out3(k)./Out2(i,j)).*e3(k);
            else
         Q(i,j,k) = 0;
            end
         end 
    end 
 end
Thetass  = sum(Q,3);
Thetavv  = zeros(Number_signal_in,NumInTerms);
Thetauu  = zeros(Number_signal_in,NumInTerms);
for i=1:Number_signal_in
    for j=1:NumInTerms
       if ((Out2(i)-v2(i,j))*r>=0) && ((Out2(i)-v2(i,j))*r<=1)
          Thetavv(i,j) = r;
       end
       if ((u2(i,j)-Out2(i))*r>=0) && ((u2(i,j)-Out2(i))*r<=1)
          Thetauu(i,j) = -r;
       end
   end
end
%根据学习结果辨识参数计算
e3_tmp = (e3*ones(1,Number_signal_in))';
du2    = Learn_rate*Thetavv.*e3_tmp.*Thetass + coffa*du2;
dv2    = Learn_rate*Thetauu.*e3_tmp.*Thetass + coffa*dv2;
v2     = v2 + du2;
u2     = u2 + dv2;
 
if ~isempty(find(u2>v2))
   for i=1:Number_signal_in
     for j=1:NumInTerms
        if u2(i,j) > v2(i,j)
            temp = v2(i,j);
            v2(i,j) = u2(i,j);
            u2(i,j) = temp;
        end
     end
   end
end
if ~isempty(find(u2<0)) || ~isempty(find(v2>1))
   for i=1:Number_signal_in
      for j=1:NumInTerms
        if u2(i,j) < 0
           u2(i,j) = 0;
        end
        if v2(i,j) > 1
           v2(i,j) = 1;
        end
      end
   end
end
%WA由学习结果更新
w_a = [u2; 1-v2];
%上面的结果完成学习过程
Xt1 = [NumRules;reshape(w_a,2*Number_signal_in*NumInTerms,1);reshape(P,((Number_signal_in+1)*NumRules)^2,1); ThetaL5;reshape(du2,Number_signal_in*NumInTerms,1);reshape(dv2,Number_signal_in*NumInTerms,1);dThetaL5;];
ns1 = size(Xt1,1);
Xt  = [Xt1; zeros(Num_out1+Num_out2-ns1,1);];       
end 
out=Xt;

%S函数的第三步,定义各个网络层的数据转换
elseif flag == 3
NumRules   = Xt(1);
NumInTerms = NumRules;
Feedfor_phase;  
u2         = w_a(1:Number_signal_in,:);
v2         = 1 - w_a(Number_signal_in+1:2*Number_signal_in,:);
%层1输出
x1      = (u(1:Data_in_numbers) - Xmins)./Data_range; 
%层2输出
x1_tmp  = x1; 
x1_tmp2 = x1_tmp*ones(1,NumInTerms); 
Out2    = 1 - check(x1_tmp2-v2,r) - check(u2-x1_tmp2,r);
%层3输出
Out3    = prod(Out2); 
S_3     = sum(Out3);
%层4输出.
if S_3~=0
   Out4 = Out3/S_3;
else 
   Out4 = zeros(1,NumRules); 
end
%层5输出
Aux1   = [x1_tmp; 1]*Out4;
a      = reshape(Aux1,(Number_signal_in+1)*NumRules,1);
outact = a'*ThetaL5;
out    = [outact;Xt];              
else
out    = [];
end
function y = check(s,r);
rows = size(s,1);
columns = size(s,2);
y = zeros(rows,columns);
for i=1:rows
   for j=1:columns
        if s(i,j).*r>1
            y(i,j) = 1;
        elseif 0 <= s(i,j).*r && s(i,j).*r <= 1
            y(i,j) = s(i,j).*r;
        elseif s(i,j).*r<0
            y(i,j) = 0;
        end
    end
end
return

 

A05-04

Be First to Comment

发表评论

您的电子邮箱地址不会被公开。