nnexport.m

神经网络预测控制程序的源代码

         B2=eval(strvcat(get_param(parent_simulink,'B2')));
         B3=eval(strvcat(get_param(parent_simulink,'B3')));
         B4=eval(strvcat(get_param(parent_simulink,'B4')));
      
         mM=[mint maxt];
         for k=1:Nj-1
            mM=[mM;mint maxt];
         end
         for k=1:Ni-1
            mM=[mM;minp maxp];
         end
         if (nnco | allv) & nnob
            netn_contr = newff(mM,[S1 S2 S1 S2 1],{f1,f2,f1,'netinv',f2},'trainlm');
  
            netn_contr.numInputs=2;
            netn_contr.numInputs=3;
            netn_contr.inputs{2}.size=netn_contr.inputs{1}.size;
            netn_contr.inputs{2}.range=mM;  
            netn_contr.inputs{3}.range=[mint maxt];
            netn_contr.biasConnect(5)=0;
            netn_contr.inputConnect(3,2)=1;
            netn_contr.inputConnect(5,3)=1;
            netn_contr.layerConnect(3,2)=0;
            netn_contr.layerConnect(5,2)=1;
 
            netn_contr.IW{1,1}=IW1_1;
            netn_contr.b{1}=B1;
            netn_contr.IW{3,2}=IW3_2;
            netn_contr.IW{5,3}=1;
            netn_contr.LW{2,1}=-LW2_1;
            netn_contr.b{2}=-B2;       % This creates -f(x)
            netn_contr.LW{4,3}=LW4_3;
            netn_contr.b{3}=B3;
            netn_contr.b{4}=B4;
            netn_contr.LW{5,4}=LW6_5*LW5_4*IW5_3;
            netn_contr.LW{5,2}=LW6_2;
            
            name_netn_contr=get(ud.Handles.nncontroledit,'string');
            if ~isempty(strmatch(name_netn_contr,...
               Wname,'exact')),
               overwrite=1;
            end
         end
         if (nnpl | allv) & nnob
            netn_plant = newff(mM,[S1 S2 S1 S2 1 1],{f1,f2,f1,f2,f2,f2},'trainlm');
  
            netn_plant.numInputs=2;
            netn_plant.numInputs=3;
            netn_plant.inputs{2}.size=netn_plant.inputs{1}.size;
            netn_plant.inputs{2}.range=mM;  
            netn_plant.inputs{3}.range=[minp maxp];
            netn_plant.biasConnect(5:6)=0;
            netn_plant.layers{5}.netInputFcn='netprod';
            netn_plant.inputConnect(3,2)=1;
            netn_plant.inputConnect(5,3)=1;
            netn_plant.layerConnect(6,2)=1;
            netn_plant.layerConnect(3,2)=0;
 
            netn_plant.IW{1,1}=IW1_1;
            netn_plant.IW{3,2}=IW3_2;
            netn_plant.IW{5,3}=IW5_3;
            netn_plant.LW{2,1}=LW2_1;
            netn_plant.LW{4,3}=LW4_3;
            netn_plant.LW{5,4}=LW5_4;
            netn_plant.LW{6,5}=LW6_5;
            netn_plant.LW{6,2}=LW6_2;
            netn_plant.b{1}=B1;
            netn_plant.b{2}=B2;
            netn_plant.b{3}=B3;
            netn_plant.b{4}=B4;
            
            name_netn_plant=get(ud.Handles.nnplantedit,'string');
            if ~isempty(strmatch(name_netn_plant,...
               Wname,'exact')),
               overwrite=1;
            end
         end
      else   % nnpredict or nn_modref
         if (nnco | allv) & nnob & ~strcmp(ud.Handles.type_net,'nnpredict')
            min_r=str2num(get_param(parent_simulink,'min_r'));
            max_r=str2num(get_param(parent_simulink,'max_r'));
            Njc=str2num(get_param(parent_simulink,'Njc')); 
            Nic=str2num(get_param(parent_simulink,'Nic')); 
            Nrc=str2num(get_param(parent_simulink,'Nrc')); 
            mM=[min_r max_r];
            S1c=str2num(get_param(parent_simulink,'S1c'));
            netn_contr = newff(mM,[S1c S2],{f1,f2},'trainlm');
   
            IW_y = eval(strvcat(get_param(parent_simulink,'IW_y')));
            IW_r = eval(strvcat(get_param(parent_simulink,'IW_r')));
            IW_u = eval(strvcat(get_param(parent_simulink,'IW_u')));
            LW_c = eval(strvcat(get_param(parent_simulink,'LW_c')));
            B1_c = eval(strvcat(get_param(parent_simulink,'B1_c')));
            B2_c = eval(strvcat(get_param(parent_simulink,'B2_c')));
      
            netn_contr.layerConnect(1,2)=1;
            netn_contr.layerWeights{1,2}.delays=[1:Nic];
            netn_contr.LW{1,2}=IW_u;
            netn_contr.inputWeights{1,1}.delays=[0:Nrc-1];
            netn_contr.IW{1,1}=IW_r;
            netn_contr.b{1}=B1_c;
            netn_contr.b{2}=B2_c;
            netn_contr.LW{2,1}=LW_c;
            netn_contr.numInputs=2;
            netn_contr.inputConnect=[1 1;0 0];
            netn_contr.inputWeights{1,2}.delays=[0:Njc-1];
            netn_contr.IW{1,2}=IW_y;
            
            name_netn_contr=get(ud.Handles.nncontroledit,'string');
            if ~isempty(strmatch(name_netn_contr,...
               Wname,'exact')),
               overwrite=1;
            end
         end
         if (nnpl | allv) & nnob
            mM=[minp maxp];
            S1=str2num(get_param(parent_simulink,'S1'));
            netn_plant = newff(mM,[S1 S2],{f1,f2},'trainlm');
          
            IW=eval(strvcat(get_param(parent_simulink,'IW')));
            LW2_1=eval(strvcat(get_param(parent_simulink,'LW2_1')));
            LW1_2=eval(strvcat(get_param(parent_simulink,'LW1_2')));
            B1=eval(strvcat(get_param(parent_simulink,'B1')));
            B2=eval(strvcat(get_param(parent_simulink,'B2')));
 
            netn_plant.inputWeights{1,1}.delays=[0:Ni-1];
            netn_plant.IW{1,1}=IW;
            netn_plant.layerConnect(1,2)=1;
            netn_plant.layerWeights{1,2}.delays=[1:Nj];
            netn_plant.LW{1,2}=LW1_2;
            netn_plant.LW{2,1}=LW2_1;
            netn_plant.b{1}=B1;
            netn_plant.b{2}=B2;
            
            name_netn_plant=get(ud.Handles.nnplantedit,'string');
            if ~isempty(strmatch(name_netn_plant,...
               Wname,'exact')),
               overwrite=1;
            end
         end
      end
   end
   
   ExportVal=0;
   if allv
      MaskNames=get_param(parent_simulink,'MaskNames');
      ExportVal=size(MaskNames,1);
   elseif (nnpl | nnco) & ~nnob
      if nnpl
         MaskNames{1}='IW';
         MaskNames{2}='LW1_2';
         MaskNames{3}='LW2_1';
         MaskNames{4}='B1';
         MaskNames{5}='B2';
         ExportVal=5;
      end
      if nnco
         MaskNames{ExportVal+1}='IW_u';
         MaskNames{ExportVal+2}='IW_y';
         MaskNames{ExportVal+3}='IW_r';
         MaskNames{ExportVal+4}='LW_c';
         MaskNames{ExportVal+5}='B1_c';
         MaskNames{ExportVal+6}='B2_c';
         ExportVal=ExportVal+6;
      end
   end
   if strcmp(cmd,'workspace')
      for CheckName = 1:ExportVal,
         if ~isempty(strmatch(MaskNames{CheckName},...
             Wname,'exact')),
             overwrite=1;
             break
         end % if ~isempty...
      end % for CheckName
      
      if overwrite
         switch questdlg(...
              {'At least one of the items you are exporting to'
               'the workspace already exists.'
               ' ';
               'Exporting will overwrite the existing variables.'
               ' '
               'Do you want to continue?'},...
               'Variable Name Conflict','Yes','No','No');
            
        case 'Yes'
           overwriteOK = 1;
        case 'No'
           overwriteOK = 0;
        end % switch questdlg
      else
        overwriteOK = 1;
      end % if/else overwrite
      
      if overwriteOK 
        for k = 1:ExportVal
           temp=get_param(parent_simulink,MaskNames{k});
           if sum(isletter(temp))==0
              temp=eval(strvcat(get_param(parent_simulink,MaskNames{k})));
           end
           assignin('base',MaskNames{k},temp);
        end % for k
        if (nnco | allv) & nnob& ~(strcmp(ud.Handles.type_net,'nnpredict'))
           assignin('base',name_netn_contr,netn_contr);
        end
        if (nnpl | allv) & nnob
           assignin('base',name_netn_plant,netn_plant);
        end
        delete(fig)   
      end
   elseif strcmp(cmd,'disk')
      fname = '*';
      fname=[fname,'.mat']; % Revisit for CODA -- is a .mat extension already provide
      [fname,p]=uiputfile(fname,'Export to Disk');
      if fname,
         fname = fullfile(p,fname);
         if ExportVal
            temp=get_param(parent_simulink,MaskNames{1});
            if sum(isletter(temp))==0
               temp=eval(strvcat(get_param(parent_simulink,MaskNames{1})));
            end
            eval([MaskNames{1},'=temp;']);
            save(fname,MaskNames{1});
            for k = 2:ExportVal,
               temp=get_param(parent_simulink,MaskNames{k});
               if sum(isletter(temp))==0
                  temp=eval(strvcat(get_param(parent_simulink,MaskNames{k})));
               end
               eval([MaskNames{k},'=temp;']);
               save(fname,MaskNames{k},'-append');
            end
            if (nnco | allv) & nnob & ~strcmp(ud.Handles.type_net,'nnpredict')
               eval([name_netn_contr '= netn_contr;']);
               save(fname,name_netn_contr,'-append');
            end
            if (nnpl | allv) & nnob
               eval([name_netn_plant '= netn_plant;']);
               save(fname,name_netn_plant,'-append');
            end
         else
            if (nnco | allv) & nnob & ~strcmp(ud.Handles.type_net,'nnpredict')
               eval([name_netn_contr '= netn_contr;']);
               save(fname,name_netn_contr);
               if (nnpl | allv) & nnob
                  eval([name_netn_plant '= netn_plant;']);
                  save(fname,name_netn_plant,'-append');
               end
            else
               eval([name_netn_plant '= netn_plant;']);
               save(fname,name_netn_plant);
            end
         end
         delete(fig)   
      end
   else    % Simulink
      Ts=get_param(parent_simulink,'Ts');
      if allv | nnpl
         gensim(netn_plant,Ts);
      end
      if (allv | nnco) & ~(strcmp(ud.Handles.type_net,'nnpredict'))
         gensim(netn_contr,Ts);
      end
      delete(fig)   
   end
   
end