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 features
Y (ndarray) – New training outputs

Return type:

None

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 the

posterior 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

property Y: ndarray

An array of shape n_points x 1 containing training outputs

Type:: return

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. :type n_samples: :param n_samples: Number of generated samples. :type n_burnin: :param n_burnin: Number of initial samples not used. :type subsample_interval: :param subsample_interval: Interval of subsampling from HMC samples. :type step_size: :param step_size: Size of the gradient steps in the HMC sampler. :type leapfrog_steps: :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.

fix_model_hyperparameters(sample_hyperparameters)

Fix model hyperparameters

Return type:: None

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.9/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.9/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 point
x_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:: None

optimize()

Optimizes hyper-parameters of model. Starts the optimization at random locations equal to the values of the “n_optimization_restarts” attribute.

Return type:: None

property X: ndarray

property Y: 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 at
with_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 the

posterior 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). :type n_samples: :param n_samples: Number of generated samples. :type n_burnin: :param n_burnin: Number of initial samples not used. :type subsample_interval: :param subsample_interval: Interval of subsampling from HMC samples. :type step_size: :param step_size: Size of the gradient steps in the HMC sampler. :type leapfrog_steps: :param leapfrog_steps: Number of gradient steps before each Metropolis Hasting step.

Return type:: ndarray

fix_model_hyperparameters(sample_hyperparameters)

Fix model hyperparameters

Return type:: None

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 a WarpedBayesianQuadratureModel object.

Note

GPy’s GPRegression cannot take None as initial values for X and Y. Thus, we initialize them with some arbitrary values. These will be re-set in the WarpedBayesianQuadratureModel.

Parameters:

kern (QuadratureKernel) – An EmuKit quadrature kernel.
gpy_model (GPRegression) – A GPy GP regression model.
noise_free (bool) – If False, the observation noise variance will be treated as a model parameter, if True the noise is set to 1e-10, defaults to True.

property X: ndarray: The data nodes.

property Y: ndarray: The data evaluations at the nodes.

property observation_noise_variance: float: The variance of the Gaussian observation noise.

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:

None

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).

optimize()

Optimize the hyperparameters of the GP.

Return type:: None

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 the variance property.

Parameters:: gpy_rbf (RBF) – An RBF kernel from GPy.

property lengthscales: ndarray: The lengthscales \(\lambda\) of the kernel.

property variance: float: The scale \(\sigma^2\) of the kernel.

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 the lengthscales 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 the lengthscales and variance parameter instead. If gpy_matern is not given, the lengthscales argument is used.
lengthscales (Optional[ndarray]) – If gpy_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\). If gpy_matern is given, this input is disregarded.
variance (Optional[float]) – The variance of the product kernel. Only used if gpy_matern is not given. Defaults to 1.

property lengthscales: ndarray: The lengthscales \(\lambda\) of the kernel.

property variance: float: The scale \(\sigma^2\) of the kernel.

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 the lengthscales 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 the lengthscales and variance parameter instead. If gpy_matern is not given, the lengthscales argument is used.
lengthscales (Optional[ndarray]) – If gpy_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\). If gpy_matern is given, this input is disregarded.
variance (Optional[float]) – The variance of the product kernel. Only used if gpy_matern is not given. Defaults to 1.

property lengthscales: ndarray: The lengthscales \(\lambda\) of the kernel.

property variance: float: The scale \(\sigma^2\) of the kernel.

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 the lengthscales 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 the lengthscales and variance parameter instead. If gpy_matern is not given, the lengthscales argument is used.
lengthscales (Optional[ndarray]) – If gpy_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\). If gpy_matern is given, this input is disregarded.
variance (Optional[float]) – The variance of the product kernel. Only used if gpy_matern is not given. Defaults to 1.

property lengthscales: ndarray: The lengthscales \(\lambda\) of the kernel.

property variance: float: The scale \(\sigma^2\) of the kernel.

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.

property variance: float: The scale \(\sigma^2\) of the kernel.

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 the offset 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 the input_dim and variance parameter instead. If gpy_brownian is not given, the variance and input_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 if gpy_brownian is not given. Defaults to 1.
input_dim (Optional[int]) – The input dimension. Only used if gpy_brownian is not given.

property variance: float: The scale \(\sigma^2\) of the kernel.

property offset: float: The offset \(c\) of the kernel.

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 model GPy.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 if measure is not given in which case the unnormalized Lebesgue measure is used.
measure (Optional[IntegrationMeasure]) – An integration measure. Either measure or integral_bounds must be given. If both integral_bounds and measure are given, integral_bounds is disregarded.
integral_name (str) – The (variable) name(s) of the integral.

Return type:

BaseGaussianProcessGPy

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:: None

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 features
Y (ndarray) – (n_points, 1) array containing training targets

Return type:

None

property X: ndarray

property Y: ndarray

emukit.model_wrappers package

Submodules

Module contents