Main Content

CompactRegressionGP

Namespace: classreg.learning.regr

Compact Gaussian process regression model class

expand all in page

Description

CompactRegressionGP is a compact Gaussian process regression (GPR) model. The compact model consumes less memory than a full model, because it does not include the data used for training the GPR model.

Because the compact model does not include the training data, you cannot perform some tasks, such as cross-validation, using the compact model. However, you can use the compact model for making predictions or calculate regression loss for new data (use predict and loss).

Construction

Create a CompactRegressionGP object from a full RegressionGP model object by using compact.

Properties

expand all

Fitting

Method used to estimate the basis function coefficients, β; noise standard deviation, σ; and kernel parameters, θ, of the GPR model, stored as a character vector. It can be one of the following.

Fit MethodDescription
'none'No estimation. fitrgp uses the initial parameter values as the parameter values.
'exact'Exact Gaussian process regression.
'sd'Subset of data points approximation.
'sr'Subset of regressors approximation.
'fic'Fully independent conditional approximation.

Explicit basis function used in the GPR model, stored as a character vector or a function handle. It can be one of the following. If n is the number of observations, the basis function adds the term H*β to the model, where H is the basis matrix and β is a p-by-1 vector of basis coefficients.

Explicit BasisBasis Matrix
'none'Empty matrix.
'constant'

H=1

H is an n-by-1 vector of 1s, where n is the number of observations.

'linear'

H=[1,X]

X is the expanded predictor data after the software creates dummy variables for the categorical variables. For details about creating dummy variables, see CategoricalPredictors.

'pureQuadratic'

H=[1,X,X2],

where

X2=[x112x122⋯x1d2x212x222⋯x2d2⋮⋮⋮⋮xn12xn22⋯xnd2].

For this basis option, CompactRegressionGP does not support X with categorical predictors.

Function handle

Function handle, hfcn, that fitrgp calls as:

H=hfcn(X),

where X is an n-by-d matrix of predictors, d is the number of predictors after the software creates dummy variables for the categorical variables, and H is an n-by-p matrix of basis functions.

Data Types: char | function_handle

Categorical predictor indices, specified as a vector of positive integers. CategoricalPredictors contains index values indicating that the corresponding predictors are categorical. The index values are between 1 and p, where p is the number of predictors used to train the model. If none of the predictors are categorical, then this property is empty ([]).

Data Types: single | double

Estimated coefficients for the explicit basis functions, stored as a vector. You can define the explicit basis function by using the BasisFunction name-value pair argument in fitrgp.

Data Types: double

Estimated noise standard deviation of the GPR model, stored as a scalar value.

Data Types: double

Parameters used for training the GPR model, stored as a GPParams object.

Kernel Function

Form of the covariance function used in the GPR model, stored as a character vector containing the name of the built-in covariance function or a function handle. It can be one of the following.

FunctionDescription
'squaredexponential'Squared exponential kernel.
'matern32'Matern kernel with parameter 3/2.
'matern52'Matern kernel with parameter 5/2.
'ardsquaredexponential'Squared exponential kernel with a separate length scale per predictor.
'ardmatern32'Matern kernel with parameter 3/2 and a separate length scale per predictor.
'ardmatern52'Matern kernel with parameter 5/2 and a separate length scale per predictor.
Function handleA function handle that fitrgp can call like this:
Kmn = kfcn(Xm,Xn,theta)
where Xm is an m-by-d matrix, Xn is an n-by-d matrix, and Kmn is an m-by-n matrix of kernel products such that Kmn(i,j) is the kernel product between Xm(i,:) and Xn(j,:). d is the number of predictor variables after the software creates dummy variables for the categorical variables. For details about creating dummy variables, see CategoricalPredictors.
theta is the r-by-1 unconstrained parameter vector for kfcn.

Data Types: char | function_handle

Information about the parameters of the kernel function used in the GPR model, stored as a structure with the following fields.

Field NameDescription
NameName of the kernel function
KernelParametersVector of the estimated kernel parameters
KernelParameterNamesNames associated with the elements of KernelParameters.

Data Types: struct

Prediction

Method that predict uses to make predictions from the GPR model, stored as a character vector. It can be one of the following.

PredictMethodDescription
'exact'Exact Gaussian process regression
'bcd'Block Coordinate Descent
'sd'Subset of Data points approximation
'sr'Subset of Regressors approximation
'fic'Fully Independent Conditional approximation

Weights used to make predictions from the trained GPR model, stored as a numeric vector. predict computes the predictions for a new predictor matrix Xnew by using the product

K(Xnew,A)*α .

K(Xnew,A) is the matrix of kernel products between Xnew and active set vector A and α is a vector of weights.

Data Types: double

Transformation applied to the predicted response, stored as a character vector describing how the response values predicted by the model are transformed. In RegressionGP, ResponseTransform is 'none' by default, and RegressionGP does not use ResponseTransform when making predictions.

Active Set Selection

Subset of training data used to make predictions from the GPR model, stored as a matrix.

predict computes the predictions for a new predictor matrix Xnew by using the product

K(Xnew,A)*α .

K(Xnew,A) is the matrix of kernel products between Xnew and active set vector A and α is a vector of weights.

ActiveSetVectors is equal to the training data X for exact GPR fitting and a subset of the training data X for sparse GPR methods. When there are categorical predictors in the model, ActiveSetVectors contains dummy variables for the corresponding predictors.

Data Types: double

Method used to select the active set for sparse methods ('sd','sr', or 'fic'), stored as a character vector. It can be one of the following.

ActiveSetMethodDescription
'sgma'Sparse greedy matrix approximation
'entropy'Differential entropy-based selection
'likelihood'Subset of regressors log likelihood-based selection
'random'Random selection

The selected active set is used in parameter estimation or prediction, depending on the choice of FitMethod and PredictMethod in fitrgp.

Size of the active set for sparse methods ('sd','sr', or 'fic'), stored as an integer value.

Data Types: double

Object Functions

limeLocal interpretable model-agnostic explanations (LIME)
lossRegression error for Gaussian process regression model
partialDependenceCompute partial dependence
plotPartialDependenceCreate partial dependence plot (PDP) and individual conditional expectation (ICE) plots
predictPredict response of Gaussian process regression model
shapleyShapley values

Examples

collapse all

Open Live Script

Generate example training data. 

rng(1) % For reproducibility
n = 100000;
X = linspace(0,1,n)';
X = [X,X.^2];
y = 1 + X*[1;2] + sin(20*X*[1;-2]) + 0.2*randn(n,1);

Train a GPR model using the subset of regressors ('sr') approximation method and predict using the subset of data ('sd') method. Use 50 points in the active set and sparse greedy matrix approximation ('sgma') method for active set selection. Because the scales of the first and second predictors are different, it is good practice to standardize the data. 

gprMdl = fitrgp(X,y,'KernelFunction','squaredExponential','FitMethod', ...
    'sr','PredictMethod','sd','Basis','none','ActiveSetSize',50, ...
    'ActiveSetMethod','sgma','Standardize',1,'KernelParameters',[1;1]);

fitrgp accepts any combination of fitting, prediction, and active set selection methods. In some cases it might not be possible to compute the standard deviations of the predicted responses, hence the prediction intervals. See Tips. And, in some cases, using the exact method might be expensive because of the size of the training data.

Create a compact GPR object. 

cgprMdl = compact(gprMdl);

Generate the test data. 

n = 4000;
Xnew = linspace(0,1,n)';
Xnew = [Xnew,Xnew.^2];
ynew = 1 + Xnew*[1;2] + sin(20*Xnew*[1;-2]) + 0.2*randn(n,1);

Use the compact object to predict the response in test data and the prediction intervals. 

[ypred,~,yci] = predict(cgprMdl,Xnew);

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

figure
plot(ynew,'r')
hold on
plot(ypred,'b')
plot(yci(:,1),'k--')
plot(yci(:,2),'k--')
legend('True responses','GPR predictions','95% prediction limits','Location','Best')
xlabel('x')
ylabel('y')
hold off

Figure contains an axes object. The axes object with xlabel x, ylabel y contains 4 objects of type line. These objects represent True responses, GPR predictions, 95% prediction limits.

Compute the mean squared error loss on the test data using the trained GPR model. 

L = loss(cgprMdl,Xnew,ynew)
L = 
0.0497

Copy Semantics

Value. To learn how value classes affect copy operations, see Copying Objects.

Extended Capabilities

Version History

Introduced in R2015b

See Also

| |

Topics