nefopt.m

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

                end  
            end   
        end  
  
    end  
  
  
elseif nef_opt == 2,       % nefcon II (move MFs) 
  
    if NEFCON_RSTATE == [] 
        NEFCON_RSTATE = 0; 
    end 
 
    if NEFCON_RSTATE == 0 
        NEFCON_E = fuzzy_error; 
        NEFCON_RSTATE = 1; 
    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)  
                %defuzzify membership function for rule r  
                ac = nefdfz(linspace(out_bound(1), out_bound(2), point_n), ...  
        	    		qualified_out_mf(:,r)', ...  
    	        		DEFUZZ_METHOD); 
                rc = (output_stack - ac) / (out_bound(1,2) - out_bound(1,1)); 
 
                %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 
 
                delta = T * sign(NEFCON_E) * abs(fuzzy_error) * o * abs(output_stack - ac) * NEFCON_RATE; 
                % shift vj  ( step v) 
                outMF = RULE_LIST(r,IN_N+OUT_N);  
                if strcmp(deblank(OUT_MF_TYPE(outMF,:)), 'trimf')  
                    %check out_bound (peak must stay in bounds)  
                    if (delta  > 0)  
                        delta = min(out_bound(2) - OUT_PARAM(outMF,2), delta);  
                    else  
                        delta = max(out_bound(1) - OUT_PARAM(outMF,2), delta);  
                    end  
                    OUT_PARAM(outMF,1) = OUT_PARAM(outMF,1) + delta;  
                    OUT_PARAM(outMF,2) = OUT_PARAM(outMF,2) + delta;  
                    OUT_PARAM(outMF,3) = OUT_PARAM(outMF,3) + delta;  
                    %fprintf('OutMF: Rule outMF= %i, delta= %f, peak=  %f, o= %f\n', outMF,delta,OUT_PARAM(outMF,2),o);  
                elseif strcmp(deblank(OUT_MF_TYPE(outMF,:)), 'trapmf')  
                    %check out_bound (peak must stay in bounds)  
                    if (delta  > 0)  
                        delta = min(out_bound(2) - OUT_PARAM(outMF,2), delta);  
                    else  
                        delta = max(out_bound(1) - OUT_PARAM(outMF,3), delta);  
                    end  
                    OUT_PARAM(outMF,1) = OUT_PARAM(outMF,1) + delta;  
                    OUT_PARAM(outMF,2) = OUT_PARAM(outMF,2) + delta;  
                    OUT_PARAM(outMF,3) = OUT_PARAM(outMF,3) + delta;  
                    OUT_PARAM(outMF,4) = OUT_PARAM(outMF,4) + delta;  
                elseif strcmp(deblank(OUT_MF_TYPE(outMF,:)), 'gaussmf')  
                    %check out_bound (peak must stay in bounds)  
                    if (delta  > 0)  
                        delta = min(out_bound(2) - OUT_PARAM(outMF,2), delta);  
                    else  
                        delta = max(out_bound(1) - OUT_PARAM(outMF,2), delta);  
                    end  
                    % move center 
                    OUT_PARAM(outMF,2) = OUT_PARAM(outMF,2) + delta;  
                else  
                    disp('Unsupported OutMFType - not modified');  
                end  
 
                % move antecedent fuzzy sets (step vi) 
                for i = 1:IN_N  
                    % find actual MF  
                    inMF = RULE_LIST(r,i);  
                    %fprintf('Rule r= %i, i= %i , inMF= %i \n', r,i,inMF);  
                    % check if any MF is active  
                    if (inMF ~= 0)  
                        %skip MF's of Inputs 1..i-1  
                        firstMF = 0;            % ersetzen durch sum(...)  
                        for j = 1:(i-1)  
                            firstMF = firstMF + IN_MF_N(1,j);  
                        end  
                        inMF = inMF + firstMF;  
                        %fprintf('Rule r= %i, i= %i , inMF= %i \n', r,i,inMF);  
                        if strcmp(deblank(IN_MF_TYPE(inMF,:)), 'trimf')  
                            %check bounds  
                            %IN_PARAM  
                            lb = IN_PARAM(inMF,1); 
                            rb = IN_PARAM(inMF,3); 
 
                            delta = T * sign(NEFCON_E) * (input_stack(i) - IN_PARAM(inMF,2)) * abs(fuzzy_error) * rc * NEFCON_RATE; 
 
                            lb = lb + delta;  
                            rb = rb + delta;  
                            if 1 
                                IN_PARAM(inMF,1) = lb;  
                                IN_PARAM(inMF,2) = IN_PARAM(inMF,2) + delta;  
                                IN_PARAM(inMF,3) = rb;  
                            else 
                                %躡erdeckungspr黦ungen ev. ebenfalls abschalten k鰊nen  
                                % r鋘dern d黵fen 黚erschritten werden, aber max. 黚erschreitung beschr鋘ken  
                                % (sonst senkrechte kante f黵 a=b oder b=c)  
                                de = (in_bound(i, 2) - in_bound(i, 1)) * point_n1;  
                                if (lb <= in_bound(i, 1))  
                                    IN_PARAM(inMF,1) = max(in_bound(i, 1) - de, lb);  
                                else  
                                    % 黚erdeckungpr黤ung  
                                    stat = 0;  
                                    for j = (firstMF + 1) : (firstMF + IN_MF_N(1,i))  
                                        if (inMF ~= j) & (IN_PARAM(j,1) < lb-de) & (lb+de < IN_PARAM(j,3))  
                                            stat = 1;  
                                        end  
                                    end  
                                    if stat == 1  
                                        IN_PARAM(inMF,1) = lb;  
                                    end  
                                end  
                                if (rb >= in_bound(i, 2))  
                                    IN_PARAM(inMF,3) = min(in_bound(i, 2) + de, rb);  
                                else  
                                    % 黚erdeckungpr黤ung  
                                    stat = 0;  
                                    for j = (firstMF + 1) : (firstMF + IN_MF_N(1,i))  
                                        if (inMF ~= j) & (IN_PARAM(j,1) < rb) & (rb < IN_PARAM(j,3))  
                                            stat = 1;  
                                        end  
                                    end  
                                    if stat == 1  
                                        IN_PARAM(inMF,3) = rb;  
                                    end  
                                end  
                            end 
                        elseif strcmp(deblank(IN_MF_TYPE(inMF,:)), 'trapmf')  
                            lb = IN_PARAM(inMF,2);  
                            rb = IN_PARAM(inMF,3); 
                            mid = (rb + lb) * 0.5; 
                            delta = T * sign(NEFCON_E) * (input_stack(i) - mid)* abs(fuzzy_error) * rc * NEFCON_RATE;  
                            lb = lb + delta;  
                            rb = rb + delta;  
                            IN_PARAM(inMF,1) = IN_PARAM(inMF,1) + delta;  
                            IN_PARAM(inMF,2) = lb;  
                            IN_PARAM(inMF,3) = rb;  
                            IN_PARAM(inMF,4) = IN_PARAM(inMF,4) + delta; 
                        elseif strcmp(deblank(IN_MF_TYPE(inMF,:)), 'gaussmf')  
                            delta = T * sign(NEFCON_E) * (input_stack(i) - IN_PARAM(inMF,2))* abs(fuzzy_error) * rc * NEFCON_RATE;  
                            IN_PARAM(inMF,2) = IN_PARAM(inMF,2) + delta;  
                        else  
                            disp('Unsupported InMFType - not modified');  
                        end  
                    end  
                end 
 
            end 
        end 
 
        NEFCON_E = fuzzy_error; 
    end 
 
  
else                        % illegal learning or disabled  
  
    disp(['nefopt: Optimizing disabled or illegal modus (' nef_rule ').']);  
  
end  
 
% set modified parameters of optimizing  
NEFCON_FIS = setfis(NEFCON_FIS, 'OutMFParams', OUT_PARAM);  
NEFCON_FIS = setfis(NEFCON_FIS, 'InMFParams', IN_PARAM);