Predict Responses Using RegressionGP Predict Block

This example shows how to use the RegressionGP Predict block for response prediction in Simulink®. The block accepts an observation (predictor data) and returns the predicted response for the observation using the trained Gaussian process (GP) regression model. The block can also return the standard deviation and prediction intervals of the response.

Train Regression Model

Train a GP regression model at the MATLAB® command line, and calculate the predicted responses and prediction intervals.

Load the gprdata data set. The data set contains simulated training and test data, with 500 observations in training data and 100 observations in test data. The data has 6 predictor variables.

load gprdata

Train a GP regression model by passing the training data Xtrain and ytrain to the fitrgp function. Specify to standardize the numeric predictors.

gpMdl = fitrgp(Xtrain,ytrain,Standardize=1)

gpMdl = 
  RegressionGP
             ResponseName: 'Y'
    CategoricalPredictors: []
        ResponseTransform: 'none'
          NumObservations: 500
           KernelFunction: 'SquaredExponential'
        KernelInformation: [1x1 struct]
            BasisFunction: 'Constant'
                     Beta: 304.8486
                    Sigma: 0.8235
        PredictorLocation: [6x1 double]
           PredictorScale: [6x1 double]
                    Alpha: [500x1 double]
         ActiveSetVectors: [500x6 double]
            PredictMethod: 'Exact'
            ActiveSetSize: 500
                FitMethod: 'Exact'
          ActiveSetMethod: 'Random'
        IsActiveSetVector: [500x1 logical]
            LogLikelihood: -770.2440
         ActiveSetHistory: []
           BCDInformation: []

gpMdl is a RegressionGP model. You can use dot notation to access the properties of gpMdl. For example, you can specify gpMdl.TrainingHistory to display more information about the training history of the GP model.

Compute the predictions ypred and prediction intervals yint, and calculate the root mean squared error (RMSE).

[ypred,~,yint] = predict(gpMdl,Xtest);
rmse = sqrt(mean((ypred-ytest).^2))

rmse = 
0.9166

Plot the true responses, predicted responses, and prediction intervals.

hold on
plot(ytest)
plot(ypred)
plot(yint(:,1),"k:")
plot(yint(:,2),"k:")
hold off
legend("True Responses","GP Predictions",...
    "Prediction Intervals",Location="best")

Now that you have trained the model gpMdl, you can import it into the RegressionGP Predict block.

Create Simulink Model

Create a new model using the RegressionGP Predict block. To create a new Simulink model, open the Blank Model template and add the RegressionGP Predict block from the Statistics and Machine Learning Toolbox™ library.

Double-click the RegressionGP Predict block to open the Block Parameters dialog box. Import a trained RegressionGP model into the block by specifying the name of a workspace variable that contains the model. The default variable name is gpMdl, which is the model you trained at the command line.

Click the Refresh button to refresh the settings of the trained model in the dialog box. The Trained Machine Learning Model section of the dialog box displays the options used to train the model gpMdl. Select the check box Add output port for prediction intervals to add a second output port (yint) in the block.

Add one Inport and two Outport blocks, and connect them to the input and outputs of the RegressionGP Predict block.

The RegressionGP Predict block expects an observation containing 6 predictor values, because the model was trained using a data set with 6 predictor variables. Double-click the Inport block, and set Port dimensions to 6 on the Signal Attributes tab. If you want the output signals to have the same length as the input signal, set Sample Time to 1.

Create an input signal in the form of a structure array for the Simulink model. The structure array must contain these fields:

• time — The points in time at which the observations enter the model. The orientation must correspond to the observations in the predictor data. In this example, time must be a column vector.

• signals — A 1-by-1 structure array describing the input data and containing the fields values and dimensions, where values is a matrix of predictor data, and dimensions is the number of predictor variables.

Create an appropriate structure array for future predictions. For more information, see Structure with Time (Simulink).

modelInput.time = (0:length(ytest)-1)';
modelInput.signals(1).values = Xtest;
modelInput.signals(1).dimensions = size(Xtest,2);

Import the signal data from the workspace:

• Open the Configuration Parameters dialog box. On the Modeling tab, click Model Settings.

• In the Data Import/Export pane, select the Input check box and enter modelInput in the adjacent text box.

• In the Solver pane, under Simulation time, set Stop time to modelInput.time(end). Under Solver selection, set Type to Fixed-step, and set Solver to discrete (no continuous states).

For more details, see Load Signal Data for Simulation (Simulink).

Double-click the Outport 1 block and set Signal name to ypred on the Main tab. Similarly, double-click the Outport 2 block and set Signal name to yint.

Open Provided Model

Instead of creating a new model, you can open the provided Simulink model slexRegressionGPPredictExample.slx, which includes the RegressionGP Predict block. To access this model, you must open the example as a live script.

Open the Simulink model slexRegressionGPPredictExample.slx.

SimMdlName = "slexRegressionGPPredictExample"; 
open_system(SimMdlName)

If you open the Simulink model, then the software runs the code in the PreLoadFcn callback function before loading the Simulink model. The PreLoadFcn callback function of slexRegressionGPPredictExample includes code to check if your workspace contains the gpMdl variable for the trained model. If the workspace does not contain the variable, PreLoadFcn loads the sample data, trains the GP model, and creates an input signal for the Simulink model. To view the callback function, in the Setup section on the Modeling tab, click Model Settings and select Model Properties. Then, on the Callbacks tab, select the PreLoadFcn callback function in the Model callbacks pane.

Simulate Simulink Model

Simulate the Simulink model, and export the simulation outputs to the workspace. When the Inport block detects an observation, it places the observation into the RegressionGP Predict block. You can use the Simulation Data Inspector (Simulink) to view the logged data of the Outport block.

simOut = sim(SimMdlName)

simOut = 
  Simulink.SimulationOutput:
                   tout: [100x1 double] 
                   yout: [1x1 Simulink.SimulationData.Dataset] 

     SimulationMetadata: [1x1 Simulink.SimulationMetadata] 
           ErrorMessage: [0x0 char] 

Determine the simulated predictions and prediction intervals, and calculate the RMSE for the simulated predictions.

outputs = simOut.yout;
sim_ypred = outputs.get("ypred").Values.Data;
sim_yint = outputs.get("yint").Values.Data;
sim_rmse = sqrt(mean((sim_ypred-ytest).^2))

sim_rmse = 
0.9166

Plot the true responses, simulated predictions, and simulated prediction intervals.

hold on
plot(ytest,"b")
plot(sim_ypred,"r")
plot(sim_yint(:,1),"k:")
plot(sim_yint(:,2),"k:")
hold off
legend("True Responses","Simulated GP Predictions",...
    "Simulated Prediction Intervals",Location="best")

The plot is similar to the plot created with the outputs of the predict function.