idGaussianProcess
Gaussian process regression mapping function for nonlinear ARX and Hammerstein-Wiener models (requires Statistics and Machine Learning Toolbox)
Since R2021b
Description
An idGaussianProcess object implements a Gaussian process (GP)
regression model, and is a nonlinear mapping function for estimating nonlinear ARX and
Hammerstein-Wiener models. This mapping object, which is also referred to as a
nonlinearity, incorporates RegressionGP (Statistics and Machine Learning Toolbox) objects that the mapping function creates using Statistics and Machine Learning Toolbox™. The mapping object contains three components: an offset, a nonlinear component,
which, in this case, is the GP kernel, and a linear component that uses a combination of
linear weights.
The input to the mapping object can be an internal signal of a nonlinear black-box model, such as one of the following signals:
Vector of the regressors of a nonlinear ARX model
Output of the linear block of a Hammerstein-Wiener model
Mathematically, idGaussianProcess is a function that maps
m inputs X(t) =
[x(t1),x2(t),…,xm(t)]T
to a scalar output y(t) using the following relationship:
Here,
X(t) is an m-by-1 vector of inputs, or regressors.
y0 is the output offset, a scalar.
P is an m-by-p projection matrix, where m is the number of regressors and p is the number of linear weights. m must be greater than or equal to p.
L is a p-by-1 vector of weights.
G(X,θ) is the regressive Gaussian process that constitutes the kernel of the
idGaussianProcessobject. G has a mean of zero and a covariance that the user specifies by choosing a kernel, and can be expressed generally as
A zero-mean Gaussian process G predicts the output Ytest for a given input Xtest using the following relationship:
Here:
K(Xtest,Xtrain) is the covariance kernel function.
Xtrain is a matrix representing the set of training inputs.
Xtest is a matrix representing the set of test inputs.
Ytrain is the vector of outputs from the training set.
σn is the standard deviation of the additive measurement noise.
Gaussian process modeling is especially useful when you have only limited measurement
data. For more information about creating GP regression models, see fitrgp (Statistics and Machine Learning Toolbox).
Use idGaussianProcess as the value of the OutputFcn
property of an idnlarx model or the
OutputNonlinearity property (but not the
InputNonlinearity property) of an idnlhw object. For example, specify idGaussianProcess when you
estimate an idnlarx model with the following
command.
sys = nlarx(data,regressors,idGaussianProcess)
nlarx estimates the model sys, it essentially estimates the
parameters of the idGaussianProcess function. You can use a similar approach when you specify input or output linearities using the
nlhw command. For example, specify idGaussianProcess as an
output nonlinearity with the following command.
sys = nlhw(data,orders,idSaturation,idGaussianProcess)
You can configure the idGaussianProcess function to disable components
and fix parameters. To omit the linear component, set LinearFcn.Use to
false. To omit the offset, set Offset.Use to
false. To specify known values for the linear function and the offset,
set their Value attributes directly and set the corresponding
Free attributes to False. To modify the estimation
options, set the option property in EstimationOptions. For example, to
change the fit method to 'exact', use
G.EstimationOptions.FitMethod = 'exact'. Use evaluate to compute the output of the function for a given vector of
inputs.
Creation
Syntax
Description
G = idGaussianProcessidGaussianProcess object G with the kernel
function 'SquaredExponential' and default kernel parameters. The number
of inputs is determined during model estimation and the number of outputs is 1.
G = idGaussianProcess(kernelFunction)
G = idGaussianProcess(kernelFunction,kernelParameters)kernelParameters.
G = idGaussianProcess(kernelFunction,kernelParameters,UseLinearFcn)
G = idGaussianProcess(kernelFunction,kernelParameters,UseLinearFcn,UseOffset)
Input Arguments
Properties
Examples
Load the input/output data from twotankdata and construct an iddata object z.
load twotankdata u y z = iddata(y,u,0.8,'timeunit','hours');
Create an idGaussianProduct mapping object g that uses a Matern kernel with the parameter 3/2.
g = idGaussianProcess('Matern32');Estimate a nonlinear ARX model that uses g as the output function.
sys = nlarx(z,[4 4 1],g)
sys = Nonlinear ARX model with 1 output and 1 input Inputs: u1 Outputs: y1 Regressors: Linear regressors in variables y1, u1 List of all regressors Output function: Gaussian process function using a Matern32 kernel Sample time: 0.8 hours Status: Estimated using NLARX on time domain data "z". Fit to estimation data: 97.14% (prediction focus) FPE: 2.82e-05, MSE: 2.795e-05 Model Properties
Display the postestimation properties of g.
disp(sys.OutputFcn.Input)
Function inputs
Name: {'y1(t-1)' 'y1(t-2)' 'y1(t-3)' 'y1(t-4)' 'u1(t-1)' 'u1(t-2)' 'u1(t-3)' 'u1(t-4)'}
Mean: [-4.7062e-17 -5.3807e-17 -5.2324e-17 -8.3748e-18 1.0174e-15 1.0364e-15 1.0744e-15 1.1123e-15]
Range: [2×8 double]
disp(sys.outputFcn.Offset)
Output Offset: initialized to -8.11e-17
Use: 1
Value: -8.1058e-17
Free: 1
disp(sys.outputFcn.NonlinearFcn)
GP kernel and its parameters
KernelFunction: 'Matern32'
Parameters: 'Kernel parameters'
Free: 1
Inputs: {'y1(t-1)' 'y1(t-2)' 'y1(t-3)' 'y1(t-4)' 'u1(t-1)' 'u1(t-2)' 'u1(t-3)' 'u1(t-4)'}
Outputs: {'y1(t):Nonlinear'}
Compare the output of sys with the measured output z.
compare(z,sys)
The nonlinear model shows a good fit to the estimation data.
Load the data z3.
load iddata3 z3
Create an idGaussianProcess object G that sets the UseLinearFcn argument to 0. Since this argument is third in the syntax, you must also specify kernelFunction and kernelParameters. Set kernelFunction to its default value of 'SquaredExponential'. Set the kernelParameters argument to [], which specifies no initialization for the parameters.
kernelFunction = 'SquaredExponential';
kernelParameters = [];
UseLinearFcn = 0;
G = idGaussianProcess(kernelFunction,kernelParameters,UseLinearFcn)G =
Gaussian Process Function
Nonlinear Function: Gaussian process function using a SquaredExponential kernel
Linear Function: not in use
Output Offset: uninitialized
Kernel: 'GP kernel and its parameters'
LinearFcn: 'Linear function parameters'
Offset: 'Offset parameters'
EstimationOptions: 'Estimation option set'
The properties of G are consistent with your inputs.
Load the data z3.
load iddata3 z3
Create an idGaussianProcess object that has no offset block by first creating a default object, and then, using dot notation to set the G.Offset.Use property directly.
G = idGaussianProcess; G.Offset.Use = 0
G =
Gaussian Process Function
Nonlinear Function: Gaussian process function using a SquaredExponential kernel
Linear Function: uninitialized
Output Offset: not in use
Kernel: 'GP kernel and its parameters'
LinearFcn: 'Linear function parameters'
Offset: 'Offset parameters'
EstimationOptions: 'Estimation option set'
The function description identifies the output offset as not in use.
