nefrule2.m

模糊神经网络采用matlab编程 o install NEFCON follow these steps: 1. Unpack the tar file NEFCON.TAR into your MA

function nefrule2(fuzzy_error, input_stack, nef_rule);  
%NEFRULES Rule learning function (Phase2)
%       This function learns the rules of the
%       fismatrix by using the fuzzy_error and the current input_stack.
%       The rule learning method is selected by nef_rule.  
%
%       nefrule2(fuzzy_error, input_stack, nef_rule)
%
% See also NEFCON.  
   
% Author: Andreas Nuernberger, TU Braunschweig, August 1996; [e-mail]
%         contact: Ludger Merz, DASA-Airbus GmbH, Hamburg; [e-mail]
  
global IN_N OUT_N  
global IN_MF_N OUT_MF_N FIS_TYPE IN_MF_TYPE OUT_MF_TYPE RULE_N DEFUZZ_METHOD in_bound out_bound  
global IMP_METHOD RULE_WEIGHT AND_OR RULE_LIST  
global IN_PARAM OUT_PARAM  
 
global output_stack in_mf_value qualified_out_mf overall_out_mf  
 
global NEFCON_C NEFCON_Z 
 
% local state: 0 : get E and activation; 1 : get E' and move MFs 
global NEFCON_RSTATE NEFCON_E 
 
global NEFCON_RRATE NEFCON_RPER  
global NEFCON_FIS 
 
% rulebase backup during NEFCON rulelearning (main and current) 
global NEFCON_RULE_M NEFCON_RULE_C NEFCON_RULE_O NEFCON_RULE_S  
 
%propagation counter 
global NEFCON_PROPC 
  
point_n = 101;  
 
NEFCON_PROPC = NEFCON_PROPC + 1; 
 
if nef_rule == 1,           % 'bottom-up' rule learning  
    if NEFCON_RSTATE == [] 
        NEFCON_RSTATE = 0; 
    end 
 
    if NEFCON_RSTATE == 0 
        NEFCON_E = fuzzy_error; 
        NEFCON_RSTATE = 1; 
        NEFCON_PROPC = 1; 
        NEFCON_C = zeros(1,RULE_N); 
    end 
 
    if NEFCON_RSTATE == 1 
        % E' is fuzzy error  
 
        for r=1:RULE_N  
            % calculate delta c(j(r))  (Phase 2; step i) 
            % if rule r is firing 
            if (sum(qualified_out_mf(:, r)) ~= 0)  
 
                NEFCON_C(r) = NEFCON_C(r) + 1; 
 
                %defuzzify membership function for rule r  
                ac = nefdfz(linspace(out_bound(1), out_bound(2), point_n), ...  
        	    		qualified_out_mf(:,r)', ...  
    	        		DEFUZZ_METHOD); 
                %calculate o[r] the firing strength of Rule R  
                o = min(in_mf_value(r,:)); 
                if NEFCON_E*fuzzy_error < 0 
                    T = -1; 
                else 
                    if abs(fuzzy_error) < abs(NEFCON_E)  
                        T = 0; 
                    else 
                        T = 1; 
                    end 
                end 
                dc = T * sign(NEFCON_E) * abs(fuzzy_error) * o * abs(output_stack - ac) * NEFCON_RRATE; 
                t = ac + dc; 
 
                % find new vj  (Phase 2; step ii) 
                i = 1; % nof output 
                pos = 1;  
                nr = RULE_LIST(r,IN_N+1); 
                maxAct = 0;  
                for j = 1 : OUT_MF_N(1,i)        % MF's  
                    m = nefevmf(t, OUT_PARAM(pos,:), OUT_MF_TYPE(pos,:));  
                    if m > maxAct,  
                        maxAct = m; 
                        nr = j; 
                    end  
                    pos = pos + 1;  
                end  
                if nr ~= RULE_LIST(r,IN_N+1)  
                    % change output mf 
                    RULE_LIST(r,IN_N+1) = nr; 
                    NEFCON_FIS = setfis(NEFCON_FIS, 'RuleList', ... 
                                [RULE_LIST RULE_WEIGHT AND_OR]);  
                    disp('rule changed'); 
                end 
            end 
        end 
 
        NEFCON_E = fuzzy_error; 
    end 
 
elseif nef_rule == 12,       % bottom up rule learning (cleanup after phase 2, step ii) 
  
    newrlist = []; 
    for r = 1:RULE_N 
        if NEFCON_C(r)/NEFCON_PROPC > NEFCON_RPER*.01  
            newrlist = [newrlist; RULE_LIST(r,:)]; 
        end  
    end 
 
    RULE_LIST = newrlist; 
    NEFCON_FIS = setfis(NEFCON_FIS, 'RuleList', [RULE_LIST ones(size(RULE_LIST,1),2)]);  
    RULE_N = size(RULE_LIST,1); 
    NEFCON_FIS = setfis(NEFCON_FIS, 'numRules', RULE_N);  
     
    % reset rule base if phase 2 is started later again 
    NEFCON_RSTATE = 0; 
  
elseif nef_rule == 2,       % nefcon rule learning  
    if NEFCON_RULE_M == [] 
        % build rule description (matrix r lines, row: startrule , nof rows with same antecedent) 
        mainlist = getfis(NEFCON_FIS, 'Rulelist'); 
        actr = mainlist(1,1:IN_N); 
        cnt = 1; firstpos = 1; 
        for r = 2:RULE_N 
            if mainlist(r, 1:IN_N) == actr 
                cnt = cnt + 1; 
            else 
                NEFCON_RULE_M = [NEFCON_RULE_M; firstpos, cnt]; 
                actr = mainlist(r,1:IN_N); 
                firstpos = r; 
                cnt = 1; 
            end             
        end 
        NEFCON_RULE_M = [NEFCON_RULE_M; firstpos, cnt]; 
        NEFCON_RULE_O = mainlist; 
        NEFCON_RSTATE = 0; 
        NEFCON_Z = zeros(1,RULE_N); 
        % ignore first step... 
        NEFCON_C = zeros(1,RULE_N); 
        NEFCON_PROPC = 1; 
    end 
 
    if NEFCON_RSTATE == 1       % evaluate results (step ii.d-g) 
        for r = 1:size(NEFCON_RULE_M,1) 
            % check if rule r is firing 
            if (sum(qualified_out_mf(:, r)) ~= 0)  
                %calculate o[r] the firing strength of Rule R  
                o  = min(in_mf_value(r,:));  
                Er = o * abs(fuzzy_error); 
                ruleno = NEFCON_RULE_S(r); 
                NEFCON_Z(ruleno) = NEFCON_Z(ruleno) + Er; 
                NEFCON_C(ruleno) = NEFCON_C(ruleno) + 1; 
            end 
        end 
    else 
        NEFCON_RSTATE = 1; 
    end 
 
    % create new rulebases (step ii.a) 
    rulebase = []; 
    NEFCON_RULE_S = zeros(1,size(NEFCON_RULE_M,1)); 
    % select one rule for every antecedent 
    for r = 1:size(NEFCON_RULE_M,1) 
        ruleno = NEFCON_RULE_M(r, 1) + floor(NEFCON_RULE_M(r, 2) * rand(1)); 
        rulebase = [rulebase; NEFCON_RULE_O(ruleno,:)]; 
        NEFCON_RULE_S(r) = ruleno; 
    end 
    localfis = setfis(NEFCON_FIS, 'RuleList', rulebase);  
    localfis = setfis(localfis, 'numRules', size(rulebase,1));  
 
    %compute output of fuzzy inference system with modified parameters (step ii.a,b) 
    [output_stack, in_mf_value, qualified_out_mf, overall_out_mf] = evalfis(input_stack, localfis);  
 
 
elseif nef_rule == 22,       % nefcon rule learning (cleanup after phase 2, step ii) 
  
    newrlist = []; 
%    newC=[]; 
    for r = 1:size(NEFCON_RULE_M,1) 
        minZ = max(NEFCON_Z); 
        rsel = 0; 
        for ruleno = NEFCON_RULE_M(r, 1):NEFCON_RULE_M(r, 1)+NEFCON_RULE_M(r, 2)-1 
            if NEFCON_C(ruleno)/NEFCON_PROPC > NEFCON_RPER*.01  
	    if NEFCON_C(ruleno) > 0
                    relerr = NEFCON_Z(ruleno)/NEFCON_C(ruleno); 
                    if relerr < minZ 
                        minZ = relerr; 
                        rsel = ruleno; 
                    end  
                end
            end 
        end 
        if rsel == 0 
%            disp(['NEFCON: Zr = 0 or percent < min for every rule.']); 
%            disp('NEFCON: Zr = 0 for every rule - selecting random rule.'); 
%            rsel = NEFCON_RULE_M(r, 1) + floor(NEFCON_RULE_M(r, 2) * rand(1));  
        end 
        if rsel > 0  
            newrlist = [newrlist; RULE_LIST(rsel,:)]; 
%            newC = [newC NEFCON_C(rsel)]; 
        end  
    end 
 
    RULE_LIST = newrlist; 
%    NEFCON_C = newC; 
    NEFCON_FIS = setfis(NEFCON_FIS, 'RuleList', [RULE_LIST ones(size(RULE_LIST,1),2)]);  
    RULE_N = size(RULE_LIST,1); 
    NEFCON_FIS = setfis(NEFCON_FIS, 'numRules', RULE_N);  
     
    % reset rule base if phase 2 is started later again 
    NEFCON_RULE_M = [];  
    NEFCON_RSTATE = 0; 
 
else                        % illegal rule learning or disabled  
  
    disp(['nefrules: Rule learning disabled or illegal modus (' nef_rule ').']);  
  
end