tunefis

Tune fuzzy inference system or tree of fuzzy inference systems

Description

example

fisout = tunefis(fisin,paramset,in,out) tunes the fuzzy inference system fisin using the tunable parameter settings specified in paramset and the training data specified by in and out.

fisout = tunefis(fisin,paramset,custcostfcn) tunes the fuzzy inference system using a function handle to a custom cost function, custcostfcn.

example

fisout = tunefis(___,options) tunes the fuzzy inference system with additional options from the object options created using tunefisOptions.

[fisout,summary] = tunefis(___) tunes the fuzzy inference system and returns additional information about the tuning algorithm in summary.

Examples

collapse all

Create the initial fuzzy inference system using genfis.

x = (0:0.1:10)';
y = sin(2*x)./exp(x/5);
options = genfisOptions('GridPartition');
options.NumMembershipFunctions = 5;
fisin = genfis(x,y,options);

Obtain the tunable settings of inputs, outputs, and rules of the fuzzy inference system.

[in,out,rule] = getTunableSettings(fisin);

Tune the membership function parameters with "anfis".

fisout = tunefis(fisin,[in;out],x,y,tunefisOptions("Method","anfis"));
ANFIS info: 
	Number of nodes: 24
	Number of linear parameters: 10
	Number of nonlinear parameters: 15
	Total number of parameters: 25
	Number of training data pairs: 101
	Number of checking data pairs: 0
	Number of fuzzy rules: 5


Start training ANFIS ...

   1 	 0.0694086
   2 	 0.0680259
   3 	 0.066663
   4 	 0.0653198
   5 	 0.0639961
Step size increases to 0.011000 after epoch 5.
   6 	 0.0626917
   7 	 0.0612787
   8 	 0.0598881
   9 	 0.0585193
Step size increases to 0.012100 after epoch 9.
  10 	 0.0571712

Designated epoch number reached --> ANFIS training completed at epoch 10.

Minimal training RMSE = 0.057171

Create the initial fuzzy inference system using genfis.

x = (0:0.1:10)';
y = sin(2*x)./exp(x/5);
options = genfisOptions('GridPartition');
options.NumMembershipFunctions = 5;
fisin = genfis(x,y,options);            

Obtain the tunable settings of inputs, outputs, and rules of the fuzzy inference system.

[in,out,rule] = getTunableSettings(fisin);

Tune the rule parameter only. In this example, the pattern search method is used.

fisout = tunefis(fisin,rule,x,y,tunefisOptions("Method","patternsearch"));
Iter     Func-count       f(x)      MeshSize     Method
    0           1       0.346649             1      
    1          19       0.346649           0.5     Refine Mesh
    2          37       0.346649          0.25     Refine Mesh
    3          55       0.346649         0.125     Refine Mesh
    4          73       0.346649        0.0625     Refine Mesh
    5          91       0.346649       0.03125     Refine Mesh
    6         109       0.346649       0.01562     Refine Mesh
    7         127       0.346649      0.007812     Refine Mesh
    8         145       0.346649      0.003906     Refine Mesh
    9         163       0.346649      0.001953     Refine Mesh
   10         181       0.346649     0.0009766     Refine Mesh
   11         199       0.346649     0.0004883     Refine Mesh
   12         217       0.346649     0.0002441     Refine Mesh
   13         235       0.346649     0.0001221     Refine Mesh
   14         253       0.346649     6.104e-05     Refine Mesh
   15         271       0.346649     3.052e-05     Refine Mesh
   16         289       0.346649     1.526e-05     Refine Mesh
   17         307       0.346649     7.629e-06     Refine Mesh
   18         325       0.346649     3.815e-06     Refine Mesh
   19         343       0.346649     1.907e-06     Refine Mesh
   20         361       0.346649     9.537e-07     Refine Mesh
Optimization terminated: mesh size less than options.MeshTolerance.

Create the initial fuzzy inference system using genfis.

x = (0:0.1:10)';
y = sin(2*x)./exp(x/5);
options = genfisOptions('GridPartition');
options.NumMembershipFunctions = 5;
fisin = genfis(x,y,options);

Obtain the tunable settings of inputs, outputs, and rules of the fuzzy inference system.

[in,out,rule] = getTunableSettings(fisin);

You can tune with custom parameter settings using setTunable or dot notation.

Do not tune input 1.

in(1) = setTunable(in(1),false);

For output 1:

  • do not tune membership functions 1 and 2,

  • do not tune membership function 3,

  • set the minimum parameter range of membership function 4 to -2,

  • and set the maximum parameter range of membership function 5 to 2.

out(1).MembershipFunctions(1:2) = setTunable(out(1).MembershipFunctions(1:2),false);
out(1).MembershipFunctions(3).Parameters.Free = false;
out(1).MembershipFunctions(4).Parameters.Minimum = -2;
out(1).MembershipFunctions(5).Parameters.Maximum = 2;

For the rule settings,

  • do not tune rules 1 and 2,

  • set the antecedent of rule 3 to non-tunable,

  • allow NOT logic in the antecedent of rule 4,

  • and do not ignore any outputs in rule 3.

rule(1:2) = setTunable(rule(1:2),false);
rule(3).Antecedent.Free = false;
rule(4).Antecedent.AllowNot = true;
rule(3).Consequent.AllowEmpty = false;

Set the maximum number of iterations to 20 and tune the fuzzy inference system.

opt = tunefisOptions("Method","particleswarm");
opt.MethodOptions.MaxIterations = 20;
fisout = tunefis(fisin,[in;out;rule],x,y,opt);
                                 Best            Mean     Stall
Iteration     f-count            f(x)            f(x)    Iterations
    0              90          0.3265           1.857        0
    1             180          0.3265           4.172        0
    2             270          0.3265           3.065        1
    3             360          0.3265           3.839        2
    4             450          0.3265           3.386        3
    5             540          0.3265           3.249        4
    6             630          0.3265           3.311        5
    7             720          0.3265           2.901        6
    8             810          0.3265           2.868        7
    9             900          0.3181            2.71        0
   10             990          0.3181           2.068        1
   11            1080          0.3181           2.692        2
   12            1170          0.3165           2.146        0
   13            1260          0.3165           1.869        1
   14            1350          0.3165           2.364        2
   15            1440          0.3165            2.07        0
   16            1530          0.3164           1.678        0
   17            1620          0.2978           1.592        0
   18            1710          0.2977           1.847        0
   19            1800          0.2954           1.666        0
   20            1890          0.2947           1.608        0
Optimization ended: number of iterations exceeded OPTIONS.MaxIterations.

To prevent the overfitting of your tuned FIS to your training data using k-fold cross validation.

Load training data. This training data set has one input and one output.

load fuzex1trnData.dat

Create a fuzzy inference system for the training data.

opt = genfisOptions('GridPartition');
opt.NumMembershipFunctions = 4;
opt.InputMembershipFunctionType = "gaussmf";
inputData = fuzex1trnData(:,1);
outputData = fuzex1trnData(:,2);
fis = genfis(inputData,outputData,opt);

For reproducibility, set the random number generator seed.

rng('default')

Configure the options for tuning the FIS. Use the default tuning method with a maximum of 30 iterations.

tuningOpt = tunefisOptions;
tuningOpt.MethodOptions.MaxGenerations = 30;

Configure the following options for using k-fold cross validation.

  • Use a k-fold value of 3.

  • Compute the moving average of the validation cost using a window of length 2.

  • Stop each training-validation iteration when the average cost is 5% greater than the current minimum cost.

tuningOpt.KFoldValue = 3;
tuningOpt.ValidationWindowSize = 2;
tuningOpt.ValidationTolerance = 0.05;

Obtain the settings for tuning the membership function parameters of the FIS.

 [in,out] = getTunableSettings(fis);

Tune the FIS.

[outputFIS,info] = tunefis(fis,[in;out],inputData,outputData,tuningOpt);
                                  Best           Mean      Stall
Generation      Func-count        f(x)           f(x)    Generations
    1              400          0.2421          0.5109        0
    2              590          0.2292          0.4688        0
    3              780          0.2292          0.4443        1
    4              970          0.2256          0.4145        0
    5             1160          0.2165          0.3957        0
    6             1350          0.2165          0.3835        1
    7             1540          0.2077          0.3548        0
    8             1730          0.2077          0.3435        1
    9             1920          0.2012          0.3414        0
   10             2110          0.1857           0.316        0
Optimization terminated: validation tolerance exceeded.

Cross validation iteration 1: Minimum validation cost 0.294718 found at training cost 0.207704

                                  Best           Mean      Stall
Generation      Func-count        f(x)           f(x)    Generations
    1              400          0.2089          0.3924        0
    2              590          0.2059          0.3655        0
Optimization terminated: validation tolerance exceeded.

Cross validation iteration 2: Minimum validation cost 0.306682 found at training cost 0.220498

                                  Best           Mean      Stall
Generation      Func-count        f(x)           f(x)    Generations
    1              400          0.2489          0.3936        0
    2              590          0.2438          0.3837        0
    3              780          0.2438          0.3779        1
    4              970          0.2067          0.3476        0
Optimization terminated: validation tolerance exceeded.

Cross validation iteration 3: Minimum validation cost 0.220104 found at training cost 0.255407

Evaluate the FIS for each of the training input values.

outputTuned = evalfis(outputFIS,inputData);

Plot the output of the tuned FIS along with the expected training output.

plot([outputData,outputTuned])
legend("Expected Output","Tuned Output","Location","southeast")
xlabel("Data Index")
ylabel("Output value")

Input Arguments

collapse all

Fuzzy inference system, specified as one of the following:

  • mamfis object — Mamdani fuzzy inference system

  • sugfis object — Sugeno fuzzy inference system

  • mamfistype2 object — Type-2 Mamdani fuzzy inference system

  • sugfistype2 object — Type-2 Sugeno fuzzy inference system

  • fistree object — Tree of interconnected fuzzy inference systems

Tunable parameter settings, specified as an array of input, output, and rule parameter settings in the input FIS. To obtain these parameter settings, use the getTunableSettings function with the input fisin.

paramset can be the input, output, or rule parameter settings, or any combination of these settings.

Input training data, specified as an m-by-n matrix, where m is the total number of input datasets and n is the number of inputs. The number of input and output datasets must be the same.

Output training data, specified as an m-by-q matrix, where m is the total number of output datasets and q is the number of outputs. The number of input and output datasets must be the same.

FIS tuning options, specified as a tunefisOptions object. You can specify the tuning algorithm method and other options for the tuning process.

Custom cost function, specified as a function handle. The custom cost function evaluates fisout to calculate its cost with respect to an evaluation criterion, such as input/output data. custcostfcn must accept at least one input argument for fisout and returns a cost value. You can provide an anonymous function handle to attach additional data for cost calculation, as described in this example:

function fitness = custcost(cost,trainingData)
  ...
end
custcostfcn = @(fis)custcost(fis,trainingData);

Output Arguments

collapse all

Fuzzy inference system, specified as one of the following:

  • mamfis object — Mamdani fuzzy inference system

  • sugfis object — Sugeno fuzzy inference system

  • mamfistype2 object — Type-2 Mamdani fuzzy inference system

  • sugfistype2 object — Type-2 Sugeno fuzzy inference system

  • fistree object — Tree of interconnected fuzzy inference systems

fisout is the same type of FIS as fisin.

Tuning algorithm summary, specified as a structure containing the following fields:

  • tuningOutputs — Algorithm-specific tuning information

  • totalFunctionCount — Total number of evaluations of the optimization cost function

  • totalRuntime — Total execution time of the tuning process in seconds

  • errorMessage — Any error message generated when updating fisin with new parameter values

tuningOutputs is a structure that contains tuning information for the algorithm specified in options. The fields in tuningOutputs depend on the specified tuning algorithm. When using k-fold cross validation, tuningOutputs is an array of k structures, each containing the tuning information for one training-validation iteration.

When using k-fold validation, totalFunctionCount and totalRuntime the total function cost function evaluations and total run time across all k training-validation iterations.

Introduced in R2019a