emukit.model_wrappers package¶
Submodules¶
- class emukit.model_wrappers.gpy_model_wrappers.GPyModelWrapper(gpy_model, n_restarts=1)¶
Bases:
IModel
,IDifferentiable
,IJointlyDifferentiable
,ICalculateVarianceReduction
,IEntropySearchModel
,IPriorHyperparameters
,IModelWithNoise
This is a thin wrapper around GPy models to allow users to plug GPy models into Emukit
- predict(X)¶
- Parameters
X (
ndarray
) – (n_points x n_dimensions) array containing locations at which to get predictions- Return type
Tuple
[ndarray
,ndarray
]- Returns
(mean, variance) Arrays of size n_points x 1 of the predictive distribution at each input location
- predict_noiseless(X)¶
- Parameters
X (
ndarray
) – (n_points x n_dimensions) array containing locations at which to get predictions- Return type
Tuple
[ndarray
,ndarray
]- Returns
(mean, variance) Arrays of size n_points x 1 of the predictive distribution at each input location
- predict_with_full_covariance(X)¶
- Parameters
X (
ndarray
) – (n_points x n_dimensions) array containing locations at which to get predictions- Return type
Tuple
[ndarray
,ndarray
]- Returns
(mean, variance) Arrays of size n_points x 1 and n_points x n_points of the predictive mean and variance at each input location
- get_prediction_gradients(X)¶
- Parameters
X (
ndarray
) – (n_points x n_dimensions) array containing locations at which to get gradient of the predictions- Return type
Tuple
[ndarray
,ndarray
]- Returns
(mean gradient, variance gradient) n_points x n_dimensions arrays of the gradients of the predictive distribution at each input location
- get_joint_prediction_gradients(X)¶
Computes and returns model gradients of mean and full covariance matrix at given points
- Parameters
X (
ndarray
) – points to compute gradients at, nd array of shape (q, d)- Return type
Tuple
[ndarray
,ndarray
]- Returns
Tuple with first item being gradient of the mean of shape (q) at X with respect to X (return shape is (q, q, d)). The second item is the gradient of the full covariance matrix of shape (q, q) at X with respect to X (return shape is (q, q, q, d)).
- set_data(X, Y)¶
Sets training data in model
- Parameters
X (
ndarray
) – New training featuresY (
ndarray
) – New training outputs
- Return type
- optimize(verbose=False)¶
Optimizes model hyper-parameters
- calculate_variance_reduction(x_train_new, x_test)¶
Computes the variance reduction at x_test, if a new point at x_train_new is acquired
- Return type
ndarray
- predict_covariance(X, with_noise=True)¶
Calculates posterior covariance between points in X :type X:
ndarray
:param X: Array of size n_points x n_dimensions containing input locations to compute posterior covariance at :type with_noise:bool
:param with_noise: Whether to include likelihood noise in the covariance matrix :rtype:ndarray
:return: Posterior covariance matrix of size n_points x n_points
- get_covariance_between_points(X1, X2)¶
Calculate posterior covariance between two sets of points. :type X1:
ndarray
:param X1: An array of shape n_points1 x n_dimensions. This is the first argument of theposterior covariance function.
- Parameters
X2 (
ndarray
) – An array of shape n_points2 x n_dimensions. This is the second argument of the posterior covariance function.- Return type
ndarray
- Returns
An array of shape n_points1 x n_points2 of posterior covariances between X1 and X2. Namely, [i, j]-th entry of the returned array will represent the posterior covariance between i-th point in X1 and j-th point in X2.
- property X: ndarray¶
An array of shape n_points x n_dimensions containing training inputs
- Type
return
- Return type
ndarray
- property Y: ndarray¶
An array of shape n_points x 1 containing training outputs
- Type
return
- Return type
ndarray
- generate_hyperparameters_samples(n_samples=20, n_burnin=100, subsample_interval=10, step_size=0.1, leapfrog_steps=20)¶
Generates the samples from the hyper-parameters and returns them. :param n_samples: Number of generated samples. :param n_burnin: Number of initial samples not used. :param subsample_interval: Interval of subsampling from HMC samples. :param step_size: Size of the gradient steps in the HMC sampler. :param leapfrog_steps: Number of gradient steps before each Metropolis Hasting step. :rtype:
ndarray
:return: A numpy array whose rows are samples of the hyper-parameters.
- emukit.model_wrappers.gpy_model_wrappers.dSigma(x_predict, x_train, kern, w_inv)¶
Compute the derivative of the posterior covariance with respect to the prediction input
- Parameters
x_predict (
ndarray
) – Prediction inputs of shape (q, d)x_train (
ndarray
) – Training inputs of shape (n, d)kern (<module 'GPy.kern' from '/home/docs/checkouts/readthedocs.org/user_builds/emukit/envs/latest/lib/python3.6/site-packages/GPy/kern/__init__.py'>) – Covariance of the GP model
w_inv (
ndarray
) – Woodbury inverse of the posterior fit of the GP
- Return type
ndarray
- Returns
Gradient of the posterior covariance of shape (q, q, q, d)
- emukit.model_wrappers.gpy_model_wrappers.dmean(x_predict, x_train, kern, w_vec)¶
Compute the derivative of the posterior mean with respect to prediction input
- Parameters
x_predict (
ndarray
) – Prediction inputs of shape (q, d)x_train (
ndarray
) – Training inputs of shape (n, d)kern (<module 'GPy.kern' from '/home/docs/checkouts/readthedocs.org/user_builds/emukit/envs/latest/lib/python3.6/site-packages/GPy/kern/__init__.py'>) – Covariance of the GP model
w_vec (
ndarray
) – Woodbury vector of the posterior fit of the GP
- Return type
ndarray
- Returns
Gradient of the posterior mean of shape (q, q, d)
- class emukit.model_wrappers.gpy_model_wrappers.GPyMultiOutputWrapper(gpy_model, n_outputs, n_optimization_restarts, verbose_optimization=True)¶
Bases:
IModel
,IDifferentiable
,ICalculateVarianceReduction
,IEntropySearchModel
A wrapper around GPy multi-output models. X inputs should have the corresponding output index as the last column in the array
- calculate_variance_reduction(x_train_new, x_test)¶
Calculates reduction in variance at x_test due to observing training point x_train_new
- Parameters
x_train_new (
ndarray
) – New training pointx_test (
ndarray
) – Test points to calculate variance reduction at
- Return type
ndarray
- Returns
Array of variance reduction at each test point
- get_prediction_gradients(X)¶
Calculates gradients of predictions with respect to X, excluding with respect to the output index :type X:
ndarray
:param X: Point at which to predict gradients :rtype:Tuple
[ndarray
,ndarray
] :return: (mean gradient, variance gradient)
- predict(X)¶
Predicts mean and variance for output specified by last column of X :type X:
ndarray
:param X: point(s) at which to predict :rtype:ndarray
:return: predicted (mean, variance) at X
- set_data(X, Y)¶
Updates model with new training data :type X:
ndarray
:param X: New training features with output index as last column :type Y:ndarray
:param Y: New training targets with output index as last column- Return type
- optimize()¶
Optimizes hyper-parameters of model. Starts the optimization at random locations equal to the values of the “n_optimization_restarts” attribute.
- Return type
- property X: ndarray¶
- Return type
ndarray
- property Y: ndarray¶
- Return type
ndarray
- predict_covariance(X, with_noise=True)¶
Calculates posterior covariance between points in X
- Parameters
X (
ndarray
) – Array of size n_points x n_dimensions containing input locations to compute posterior covariance atwith_noise (
bool
) – Whether to include likelihood noise in the covariance matrix
- Return type
ndarray
- Returns
Posterior covariance matrix of size n_points x n_points
- get_covariance_between_points(X1, X2)¶
Calculate posterior covariance between two points :type X1:
ndarray
:param X1: An array of shape 1 x n_dimensions that contains a data single point. It is the first argument of theposterior covariance function
- Parameters
X2 (
ndarray
) – An array of shape n_points x n_dimensions that may contain multiple data points. This is the second argument to the posterior covariance function.- Return type
ndarray
- Returns
An array of shape n_points x 1 of posterior covariances between X1 and X2
- generate_hyperparameters_samples(n_samples=10, n_burnin=5, subsample_interval=1, step_size=0.1, leapfrog_steps=1)¶
Generates the samples from the hyper-parameters, and returns them (a numpy array whose rows are samples of the hyper-parameters). :param n_samples: Number of generated samples. :param n_burnin: Number of initial samples not used. :param subsample_interval: Interval of subsampling from HMC samples. :param step_size: Size of the gradient steps in the HMC sampler. :param leapfrog_steps: Number of gradient steps before each Metropolis Hasting step.
- Return type
ndarray
GPy wrappers for the quadrature package.
- class emukit.model_wrappers.gpy_quadrature_wrappers.BaseGaussianProcessGPy(kern, gpy_model, noise_free=True)¶
Bases:
IBaseGaussianProcess
Wrapper for GPy’s
GPRegression
as required for some EmuKit quadrature methods.An instance of this class can be passed as
base_gp
to aWarpedBayesianQuadratureModel
object.Note
GPy’s
GPRegression
cannot takeNone
as initial values for X and Y. Thus, we initialize them with some arbitrary values. These will be re-set in theWarpedBayesianQuadratureModel
.- Parameters
kern (
QuadratureKernel
) – An EmuKit quadrature kernel.gpy_model (
GPRegression
) – A GPy GP regression model.noise_free (
bool
) – IfFalse
, the observation noise variance will be treated as a model parameter, ifTrue
the noise is set to 1e-10, defaults toTrue
.
- property X: ndarray¶
The data nodes.
- Return type
ndarray
- property Y: ndarray¶
The data evaluations at the nodes.
- Return type
ndarray
- property observation_noise_variance: float¶
The variance of the Gaussian observation noise.
- Return type
- set_data(X, Y)¶
Sets training data in model.
- Parameters
X (
ndarray
) – New training features, shape (num_points, input_dim).Y (
ndarray
) – New training outputs, shape (num_points, 1).
- Return type
- predict(X_pred)¶
Predictive mean and covariance at the locations X_pred.
- Parameters
X_pred (
ndarray
) – Points at which to predict, with shape (number of points, input_dim).- Return type
Tuple
[ndarray
,ndarray
]- Returns
Predictive mean, predictive variances shapes (num_points, 1) and (num_points, 1).
- predict_with_full_covariance(X_pred)¶
Predictive mean and covariance at the locations X_pred.
- Parameters
X_pred (
ndarray
) – Points at which to predict, with shape (num_points, input_dim).- Return type
Tuple
[ndarray
,ndarray
]- Returns
Predictive mean, predictive full covariance shapes (num_points, 1) and (num_points, num_points).
- solve_linear(z)¶
Solve the linear system \(Gx=z\) for \(x\).
\(G\) is the Gram matrix \(G := K(X, X) + \sigma^2 I\), of shape (num_dat, num_dat) and \(z\) is a matrix of shape (num_dat, num_obs).
- Parameters
z (
ndarray
) – A matrix of shape (num_dat, num_obs).- Return type
ndarray
- Returns
The solution \(x\) of the linear, shape (num_dat, num_obs).
- graminv_residual()¶
The solution \(z\) of the linear system
\[(K_{XX} + \zeta^2 I) z = (Y - m(X))\]where \(X\) and \(Y\) are the available nodes and function evaluation, \(m(X)\) is the predictive mean at \(X\), and \(\zeta^2\) the observation noise variance.
- Return type
ndarray
- Returns
The solution \(z\) of the linear system, shape (num_dat, 1).
- class emukit.model_wrappers.gpy_quadrature_wrappers.RBFGPy(gpy_rbf)¶
Bases:
IRBF
Wrapper of the GPy RBF kernel as required for some EmuKit quadrature methods.
\[k(x, x') = \sigma^2 e^{-\frac{1}{2}\sum_{i=1}^{d}r_i^2},\]where \(d\) is the input dimensionality, \(r_i = \frac{x_i-x_i'}{\lambda_i}\) is the scaled vector difference of dimension \(i\), \(\lambda_i\) is the \(i\) th element of the
lengthscales
property and \(\sigma^2\) is thevariance
property.- Parameters
gpy_rbf (
RBF
) – An RBF kernel from GPy.
- property lengthscales: ndarray¶
The lengthscales \(\lambda\) of the kernel.
- Return type
ndarray
- K(x1, x2)¶
The kernel k(x1, x2) evaluated at x1 and x2.
- Parameters
x1 (
ndarray
) – First argument of the kernel, shape (n_points N, input_dim)x2 (
ndarray
) – Second argument of the kernel, shape (n_points M, input_dim)
- Return type
ndarray
- Returns
Kernel evaluated at x1, x2, shape (N, M).
- class emukit.model_wrappers.gpy_quadrature_wrappers.ProductMatern12GPy(gpy_matern=None, lengthscales=None, variance=None)¶
Bases:
IProductMatern12
Wrapper of the GPy Exponential (a.k.a Matern12) product kernel as required for some EmuKit quadrature methods.
The product kernel is of the form \(k(x, x') = \sigma^2 \prod_{i=1}^d k_i(x, x')\) where
\[k_i(x, x') = e^{-r_i}.\]\(d\) is the input dimensionality, \(r_i:=\frac{|x_i - x'_i|}{\lambda_i}\), \(\sigma^2\) is the
variance
property and \(\lambda_i\) is the \(i\) th element of thelengthscales
property.- Parameters
gpy_matern (
Union
[Exponential
,Prod
,None
]) – An Exponential (a.k.a. Matern12) product kernel from GPy. For \(d=1\) this is equivalent to an Exponential kernel. For \(d>1\), this is not a \(d\)-dimensional Exponential kernel but a product of \(d\) 1-dimensional Exponential kernels with differing active dimensions constructed as k1 * k2 * … . Make sure to unlink all variances except the variance of the first kernel k1 in the product as the variance of k1 will be used to represent \(\sigma^2\). If you are unsure what to do, use thelengthscales
andvariance
parameter instead. Ifgpy_matern
is not given, thelengthscales
argument is used.lengthscales (
Optional
[ndarray
]) – Ifgpy_matern
is not given, a product Matern12 kernel will be constructed with the given lengthscales. The number of elements need to be equal to the dimensionality \(d\). Ifgpy_matern
is given, this input is disregarded.variance (
Optional
[float
]) – The variance of the product kernel. Only used ifgpy_matern
is not given. Defaults to 1.
- property lengthscales: ndarray¶
The lengthscales \(\lambda\) of the kernel.
- Return type
ndarray
- K(x1, x2)¶
The kernel k(x1, x2) evaluated at x1 and x2.
- Parameters
x1 (
ndarray
) – First argument of the kernel, shape (n_points N, input_dim)x2 (
ndarray
) – Second argument of the kernel, shape (n_points M, input_dim)
- Return type
ndarray
- Returns
Kernel evaluated at x1, x2, shape (N, M).
- dK_dx1(x1, x2)¶
Gradient of the kernel wrt x1 evaluated at pair x1, x2.
- Parameters
x1 (
ndarray
) – First argument of the kernel, shape (n_points N, input_dim)x2 (
ndarray
) – Second argument of the kernel, shape (n_points M, input_dim)
- Return type
ndarray
- Returns
The gradient of the kernel wrt x1 evaluated at (x1, x2), shape (input_dim, N, M)
- class emukit.model_wrappers.gpy_quadrature_wrappers.ProductMatern32GPy(gpy_matern=None, lengthscales=None, variance=None)¶
Bases:
IProductMatern32
Wrapper of the GPy Matern32 product kernel as required for some EmuKit quadrature methods.
The product kernel is of the form \(k(x, x') = \sigma^2 \prod_{i=1}^d k_i(x, x')\) where
\[k_i(x, x') = (1 + \sqrt{3}r_i ) e^{-\sqrt{3} r_i}.\]\(d\) is the input dimensionality, \(r_i:=\frac{|x_i - x'_i|}{\lambda_i}\), \(\sigma^2\) is the
variance
property and \(\lambda_i\) is the \(i\) th element of thelengthscales
property.- Parameters
gpy_matern (
Union
[Matern32
,Prod
,None
]) – A Matern32 product kernel from GPy. For \(d=1\) this is equivalent to a Matern32 kernel. For \(d>1\), this is not a \(d\)-dimensional Matern32 kernel but a product of \(d\) 1-dimensional Matern32 kernels with differing active dimensions constructed as k1 * k2 * … . Make sure to unlink all variances except the variance of the first kernel k1 in the product as the variance of k1 will be used to represent \(\sigma^2\). If you are unsure what to do, use thelengthscales
andvariance
parameter instead. Ifgpy_matern
is not given, thelengthscales
argument is used.lengthscales (
Optional
[ndarray
]) – Ifgpy_matern
is not given, a product Matern32 kernel will be constructed with the given lengthscales. The number of elements need to be equal to the dimensionality \(d\). Ifgpy_matern
is given, this input is disregarded.variance (
Optional
[float
]) – The variance of the product kernel. Only used ifgpy_matern
is not given. Defaults to 1.
- property lengthscales: ndarray¶
The lengthscales \(\lambda\) of the kernel.
- Return type
ndarray
- K(x1, x2)¶
The kernel k(x1, x2) evaluated at x1 and x2.
- Parameters
x1 (
ndarray
) – First argument of the kernel, shape (n_points N, input_dim)x2 (
ndarray
) – Second argument of the kernel, shape (n_points M, input_dim)
- Return type
ndarray
- Returns
Kernel evaluated at x1, x2, shape (N, M).
- dK_dx1(x1, x2)¶
Gradient of the kernel wrt x1 evaluated at pair x1, x2.
- Parameters
x1 (
ndarray
) – First argument of the kernel, shape (n_points N, input_dim)x2 (
ndarray
) – Second argument of the kernel, shape (n_points M, input_dim)
- Return type
ndarray
- Returns
The gradient of the kernel wrt x1 evaluated at (x1, x2), shape (input_dim, N, M)
- class emukit.model_wrappers.gpy_quadrature_wrappers.ProductMatern52GPy(gpy_matern=None, lengthscales=None, variance=None)¶
Bases:
IProductMatern52
Wrapper of the GPy Matern52 product kernel as required for some EmuKit quadrature methods.
The product kernel is of the form \(k(x, x') = \sigma^2 \prod_{i=1}^d k_i(x, x')\) where
\[k_i(x, x') = (1 + \sqrt{5} r_i + \frac{5}{3} r_i^2) \exp(- \sqrt{5} r_i).\]\(d\) is the input dimensionality, \(r_i:=\frac{|x_i - x'_i|}{\lambda_i}\), \(\sigma^2\) is the
variance
property and \(\lambda_i\) is the \(i\) th element of thelengthscales
property.- Parameters
gpy_matern (
Union
[Matern52
,Prod
,None
]) – A Matern52 product kernel from GPy. For \(d=1\) this is equivalent to a Matern52 kernel. For \(d>1\), this is not a \(d\)-dimensional Matern52 kernel but a product of \(d\) 1-dimensional Matern52 kernels with differing active dimensions constructed as k1 * k2 * … . Make sure to unlink all variances except the variance of the first kernel k1 in the product as the variance of k1 will be used to represent \(\sigma^2\). If you are unsure what to do, use thelengthscales
andvariance
parameter instead. Ifgpy_matern
is not given, thelengthscales
argument is used.lengthscales (
Optional
[ndarray
]) – Ifgpy_matern
is not given, a product Matern52 kernel will be constructed with the given lengthscales. The number of elements need to be equal to the dimensionality \(d\). Ifgpy_matern
is given, this input is disregarded.variance (
Optional
[float
]) – The variance of the product kernel. Only used ifgpy_matern
is not given. Defaults to 1.
- property lengthscales: ndarray¶
The lengthscales \(\lambda\) of the kernel.
- Return type
ndarray
- K(x1, x2)¶
The kernel k(x1, x2) evaluated at x1 and x2.
- Parameters
x1 (
ndarray
) – First argument of the kernel, shape (n_points N, input_dim)x2 (
ndarray
) – Second argument of the kernel, shape (n_points M, input_dim)
- Return type
ndarray
- Returns
Kernel evaluated at x1, x2, shape (N, M).
- dK_dx1(x1, x2)¶
Gradient of the kernel wrt x1 evaluated at pair x1, x2.
- Parameters
x1 (
ndarray
) – First argument of the kernel, shape (n_points N, input_dim)x2 (
ndarray
) – Second argument of the kernel, shape (n_points M, input_dim)
- Return type
ndarray
- Returns
The gradient of the kernel wrt x1 evaluated at (x1, x2), shape (input_dim, N, M)
- class emukit.model_wrappers.gpy_quadrature_wrappers.BrownianGPy(gpy_brownian)¶
Bases:
IBrownian
Wrapper of the GPy Brownian motion kernel as required for some EmuKit quadrature methods.
\[k(x, x') = \sigma^2 \operatorname{min}(x, x')\quad\text{with}\quad x, x' \geq 0,\]where \(\sigma^2\) is the
variance
property.- Parameters
gpy_brownian (
Brownian
) – A Brownian motion kernel from GPy.
- K(x1, x2)¶
The kernel k(x1, x2) evaluated at x1 and x2.
- Parameters
x1 (
ndarray
) – First argument of the kernel, shape (n_points N, input_dim)x2 (
ndarray
) – Second argument of the kernel, shape (n_points M, input_dim)
- Return type
ndarray
- Returns
Kernel evaluated at x1, x2, shape (N, M).
- class emukit.model_wrappers.gpy_quadrature_wrappers.ProductBrownianGPy(gpy_brownian=None, offset=0.0, variance=None, input_dim=None)¶
Bases:
IProductBrownian
Wrapper of the GPy Brownian product kernel as required for some EmuKit quadrature methods.
The product kernel is of the form \(k(x, x') = \sigma^2 \prod_{i=1}^d k_i(x, x')\) where
\[k_i(x, x') = \operatorname{min}(x_i-c, x_i'-c)\quad\text{with}\quad x_i, x_i' \geq c,\]\(d\) is the input dimensionality, \(\sigma^2\) is the
variance
property and \(c\) is theoffset
property.- Parameters
gpy_brownian (
Union
[Brownian
,Prod
,None
]) – A Brownian product kernel from GPy. For \(d=1\) this is equivalent to a Brownian kernel. For \(d>1\), this is a product of \(d\) 1-dimensional Brownian kernels with differing active dimensions constructed as k1 * k2 * … . Make sure to unlink all variances except the variance of the first kernel k1 in the product as the variance of k1 will be used to represent \(\sigma^2\). If you are unsure what to do, use theinput_dim
andvariance
parameter instead. Ifgpy_brownian
is not given, thevariance
andinput_dim
argument is used.offset (
float
) – The offset \(c\) of the kernel. Defaults to 0.variance (
Optional
[float
]) – The variance of the product kernel. Only used ifgpy_brownian
is not given. Defaults to 1.input_dim (
Optional
[int
]) – The input dimension. Only used ifgpy_brownian
is not given.
- K(x1, x2)¶
The kernel k(x1, x2) evaluated at x1 and x2.
- Parameters
x1 (
ndarray
) – First argument of the kernel, shape (n_points N, input_dim)x2 (
ndarray
) – Second argument of the kernel, shape (n_points M, input_dim)
- Return type
ndarray
- Returns
Kernel evaluated at x1, x2, shape (N, M).
- dK_dx1(x1, x2)¶
Gradient of the kernel wrt x1 evaluated at pair x1, x2.
- Parameters
x1 (
ndarray
) – First argument of the kernel, shape (n_points N, input_dim)x2 (
ndarray
) – Second argument of the kernel, shape (n_points M, input_dim)
- Return type
ndarray
- Returns
The gradient of the kernel wrt x1 evaluated at (x1, x2), shape (input_dim, N, M)
- dKdiag_dx(x)¶
The gradient of the diagonal of the kernel (the variance) v(x):=k(x, x) evaluated at x.
- Parameters
x (
ndarray
) – The locations where the gradient is evaluated, shape (n_points, input_dim).- Return type
ndarray
- Returns
The gradient of the diagonal of the kernel evaluated at x, shape (input_dim, n_points).
- emukit.model_wrappers.gpy_quadrature_wrappers.create_emukit_model_from_gpy_model(gpy_model, integral_bounds=None, measure=None, integral_name='')¶
Wraps a GPy model and returns an EmuKit quadrature model.
- Parameters
gpy_model (
GPRegression
) – A GPy Gaussian process regression modelGPy.models.GPRegression
.integral_bounds (
Optional
[List
[Tuple
[float
,float
]]]) – List of d tuples, where d is the dimensionality of the integral and the tuples contain the lower and upper bounds of the integral i.e., [(lb_1, ub_1), (lb_2, ub_2), …, (lb_d, ub_d)]. Only used ifmeasure
is not given in which case the unnormalized Lebesgue measure is used.measure (
Optional
[IntegrationMeasure
]) – An integration measure. Eithermeasure
orintegral_bounds
must be given. If bothintegral_bounds
andmeasure
are given,integral_bounds
is disregarded.integral_name (
str
) – The (variable) name(s) of the integral.
- Return type
- Returns
An EmuKit GP model for quadrature with GPy backend.
- class emukit.model_wrappers.simple_gp_model.SimpleGaussianProcessModel(x, y)¶
Bases:
IModel
This model is a Gaussian process with an RBF kernel, with no ARD. It is used to demonstrate uses of emukit, it does not aim to be flexible, robust or fast.
- optimize()¶
Optimize the three hyperparameters of the model, namely the kernel variance, kernel lengthscale and likelihood variance
- Return type
- predict(x_new)¶
Predict from model
- Parameters
x_new (
ndarray
) – (n_points, n_dims) array containing points at which the predictive distributions will be computed- Return type
Tuple
[ndarray
,ndarray
]- Returns
Tuple containing two (n_points, 1) arrays representing the mean and variance of the predictive distribution at the specified input locations
- set_data(X, Y)¶
Set training data to new values
- Parameters
X (
ndarray
) – (n_points, n_dims) array containing training featuresY (
ndarray
) – (n_points, 1) array containing training targets
- Return type
- property X: ndarray¶
- Return type
ndarray
- property Y: ndarray¶
- Return type
ndarray