Predict Chaotic Time Series Using Type-2 FIS

This example shows chaotic time series prediction using a tuned type-2 fuzzy inference system (FIS). This example tunes the FIS using particle swarm optimization, which requires Global Optimization Toolbox™ software.

Time Series Data

This example simulates time-series data using the following form of the Mackey-Glass (MG) nonlinear delay differential equation.

$\stackrel{˙}{\mathit{x}}\left(\mathit{t}\right)=\frac{0.2\mathit{x}\left(\mathit{t}-\tau \right)}{1+{\mathit{x}}^{10}\left(\mathit{t}-\tau \right)}-0.1\mathit{x}\left(\mathit{t}\right)$

Simulate the time series for 1200 samples using the following configuration.

• Sample time ${\mathit{t}}_{\mathit{s}}=1$ sec

• Initial condition $\mathit{x}\left(0\right)=1.2$

• $\tau =20$

• $\mathit{x}\left(\mathit{t}-\tau \right)=0$ for $\mathit{t}<\tau$.

ts = 1;
numSamples = 1200;
tau = 20;
x = zeros(1,numSamples+tau+1);
x(tau+1) = 1.2;
for t = 1+tau:numSamples+tau
x_dot = 0.2*x(t-tau)/(1+(x(t-tau))^10)-0.1*x(t);
x(t+1) = x(t) + ts*x_dot;
end

Plot the simulated MG time-series data.

figure(1)
plot(x(tau+2:end))
title('Mackey-Glass Chaotic Time Series')
xlabel('Time (sec)')
ylabel('x(t)') Generate Training and Validation Data

Time-series prediction uses known time-series values up to time t to predict a future value at time $t+P$. The standard method for this type of prediction is to create a mapping from D sample data points, sampled every Δ units in time ($x\left(t-\left(D-1\right)\Delta \right),\dots ,x\left(t-\Delta \right),x\left(t\right)$) to a predicted future value $x=\left(t+P\right)$. For this example, set $\mathit{D}=4$ and $\Delta =\mathit{P}=1$. Hence, for each t, the input and output training data sets are $\left[\mathit{x}\left(\mathit{t}-3\right),\mathit{x}\left(t-2\right),x\left(t-1\right),x\left(t\right)\right]$ and $\mathit{x}\left(\mathit{t}+1\right)$, respectively. In other words, use four successive known time-series values to predict the next value.

Create 1000 input/output data sets from samples $\mathit{x}\left(100+D-1\right)$ to $\mathit{x}\left(1100+D-2\right).$

D = 4;
inputData = zeros(1000,D);
outputData = zeros(1000,1);
for t = 100+D-1:1100+D-2
for i = 1:D
inputData(t-100-D+2,i) = x(t-D+i);
end
outputData(t-100-D+2,:) = x(t+1);
end

Use the first 500 data sets as training data (trnX and trnY) and the second 500 sets as validation data (vldX and vldY).

trnX = inputData(1:500,:);
trnY = outputData(1:500,:);
vldX = inputData(501:end,:);
vldY = outputData(501:end,:);

Construct FIS

This example uses a type-2 Sugeno FIS. Since a Sugeno FIS has fewer tunable parameters than a Mamdani FIS, a Sugeno system generally converges faster during optimization.

fisin = sugfistype2;

Add three inputs, each with three default triangular membership functions (MFs). Initially, eliminate the footprint of uncertainty (FOU) for each input MF by setting each lower MF equal to its corresponding upper MF. To do so, set the scale and lag values of each lower MF to 1 and 0, respectively. By eliminating the FOU for all input membership functions, you configure the type-2 FIS to behave like a type-1 FIS.

numInputs = D;
numInputMFs = 3;
range = [min(x) max(x)];
for i = 1:numInputs
for j = 1:numInputMFs
fisin.Inputs(i).MembershipFunctions(j).LowerScale = 1;
fisin.Inputs(i).MembershipFunctions(j).LowerLag = 0;
end
end

For prediction, add an output to the FIS. The output contains default constant membership functions. To provide maximum resolution for the input-output mapping, set the number of output MFs equal to the number of input MF combinations.

numOutputMFs = numInputMFs^numInputs;

View the FIS structure. Initially, the FIS has zero rules. The rules of the system are found during the tuning process.

plotfis(fisin) Tune FIS with Training Data

To tune the FIS, you use the following three steps.

1. Learn the rule base while keeping the input and output MF parameters constant.

2. Tune the output MF parameters and the upper MF parameters of the inputs while keeping the rule and lower MF parameters constant.

3. Tune the lower MF parameters of the inputs while keeping the rule, output MF, and upper MF parameters constant.

The first step is less computationally expensive due to the small number of rule parameters, and it quickly converges to a fuzzy rule base during training. After the second step, the system is a trained type-1 FIS. The third step produces a tuned type-2 FIS.

Learn Rules

To learn a rule base, first specify tuning options using a tunefisOptions object.

options = tunefisOptions;

Since the FIS does not contain any pretuned fuzzy rules, use a global optimization method (genetic algorithm or particle swarm) to learn the rules. Global optimization methods perform better in large parameter tuning ranges as compared to local optimization methods (pattern search and simulated annealing). For this example, tune the FIS using particle swarm optimization ('particleswarm').

options.Method = 'particleswarm';

To learn new rules, set the OptimizationType to 'learning'.

options.OptimizationType = 'learning';

Restrict the maximum number of rules to the number of input MF combinations. The number of tuned rules can be less than this limit, since the tuning process removes duplicate rules.

options.NumMaxRules = numInputMFs^numInputs;

If you have Parallel Computing Toolbox™ software, you can improve the speed of the tuning process by setting UseParallel to true. If you do not have Parallel Computing Toolbox software, set UseParallel to false.

options.UseParallel = false;

Set the maximum number of iterations to 10. Increasing the number of iterations can reduce training error. However, the larger number of iterations increases the duration of the tuning process and can overtune the rule parameters to the training data.

options.MethodOptions.MaxIterations = 10;

Since particle swarm optimization uses random search, to obtain reproducible results, initialize the random number generator to its default configuration.

rng('default')

Tuning a FIS using the tunefis function takes several minutes. For this example, enable tuning by setting runtunefis to true. To load pretrained results without running tunefis, you can set runtunefis to false.

runtunefis = false;

Tune the FIS using the specified training data and options.

if runtunefis
fisout1 = tunefis(fisin,[],trnX,trnY,options);
else
fisout1 = tunedfis.fisout1;
end

View the structure of the trained FIS, which contains the new learned rules.

plotfis(fisout1) Check the individual input-output relationships tuned by the learned rule base. For example, the following figure shows the relationship between the second input and the output.

gensurf(fisout1,gensurfOptions('InputIndex',2)) Evaluate the tuned FIS using the input validation data. Plot the actual generated output with the expected validation output, and compute the root-mean-square-error (RMSE).

plotActualAndExpectedResultsWithRMSE(fisout1,vldX,vldY) Tune Upper Membership Function Parameters

Tune the upper membership function parameters. A type-2 Sugeno FIS supports only crisp output functions. Therefore, this step tunes input upper MFs and crisp output functions.

Obtain the input and output parameter settings using getTunableSettings. Since the FIS uses triangular input MFs, you can tune the input MFs using asymmetric lag values.

[in,out] = getTunableSettings(fisout1,'AsymmetricLag',true);

Disable the tuning of lower MF parameters.

for i = 1:length(in)
for j = 1:length(in(i).MembershipFunctions)
in(i).MembershipFunctions(j).LowerScale.Free = false;
in(i).MembershipFunctions(j).LowerLag.Free = false;
end
end

To optimize the existing tunable MF parameters while keeping the rule base constant, set OptimizationType to 'tuning'.

options.OptimizationType = 'tuning';

Tune the FIS using the specified tuning data and options. To load pretrained results without running tunefis, you can set runtunefis to false.

rng('default')
if runtunefis
fisout2 = tunefis(fisout1,[in;out],trnX,trnY,options);
else
fisout2 = tunedfis.fisout2;
end

View the structure of the trained FIS, which now contains tuned upper MF parameters.

plotfis(fisout2) Evaluate the tuned FIS using the validation data, compute the RMSE, and plot the actual generated output with the expected validation output.

plotActualAndExpectedResultsWithRMSE(fisout2,vldX,vldY) Tuning the upper MF parameters improves the performance of the FIS. This result is equivalent to tuning a type-1 FIS.

Tune Lower Membership Function Parameters

Tune only the input lower MF parameters. To do so, set the lower scale and lag values tunable, and disable tuning of the upper MF parameters.

for i = 1:length(in)
for j = 1:length(in(i).MembershipFunctions)
in(i).MembershipFunctions(j).UpperParameters.Free = false;
in(i).MembershipFunctions(j).LowerScale.Free = true;
in(i).MembershipFunctions(j).LowerLag.Free = true;
end
end

Tune the FIS using the specified tuning data and options. To load pretrained results without running tunefis, you can set runtunefis to false.

rng('default')
if runtunefis
fisout3 = tunefis(fisout2,in,trnX,trnY,options);
else
fisout3 = tunedfis.fisout3;
end

View structure of the trained FIS, which now contains tuned lower MF parameters.

plotfis(fisout3) Evaluate the tuned FIS using the validation data, compute the RMSE, and plot the actual generated output with the expected validation output.

plotActualAndExpectedResultsWithRMSE(fisout3,vldX,vldY) Tuning both the upper and lower MF values improves the FIS performance. The RMSE improves when the trained FIS includes both tuned upper and lower parameter values.

Conclusion

Type-2 MFs provides additional tunable parameters as compared to type-1 MFs. Therefore, with adequate training data, a tuned type-2 FIS can fit the training data better than a tuned type-1 FIS.

Overall, you can produce different tuning results by modifying any of the following FIS properties or tuning options:

• Number of inputs

• Number of MFs

• Type of MFs

• Optimization method

• Number of tuning iterations

Local Functions

function [rmse,actY] = calculateRMSE(fis,x,y)

% Specify options for FIS evaluation
evalOptions = evalfisOptions("EmptyOutputFuzzySetMessage","none", ...
"NoRuleFiredMessage","none","OutOfRangeInputValueMessage","none");

% Evaluate FIS
actY = evalfis(fis,x,evalOptions);

% Calculate RMSE
del = actY - y;
rmse = sqrt(mean(del.^2));

end

function plotActualAndExpectedResultsWithRMSE(fis,vldX,vldY)
[rmse,actY] = calculateRMSE(fis,vldX,vldY);

figure
plot([actY vldY])
axis([0 length(vldY) min(vldY)-0.01 max(vldY)+0.13])
xlabel('sample index')
ylabel('signal value')
title(['RMSE = ' num2str(rmse)])
legend(["Actual output" "Expected output"],'Location',"northeast")
end