gpflow.kernels

gpflow.kernels.AnisotropicStationary

class gpflow.kernels.AnisotropicStationary(*args: Any, **kwargs: Any)[source]

Bases: gpflow.kernels.stationaries.Stationary

Base class for anisotropic stationary kernels, i.e. kernels that only depend on

d = x - x’

Derived classes should implement K_d(self, d): Returns the kernel evaluated on d, which is the pairwise difference matrix, scaled by the lengthscale parameter ℓ (i.e. [(X - X2ᵀ) / ℓ]). The last axis corresponds to the input dimension.

Attributes
active_dims
ard

Whether ARD behaviour is active.

parameters
trainable_parameters

Methods

__call__(X[, X2, full_cov, presliced])

Call self as a function.

on_separate_dims(other)

Checks if the dimensions, over which the kernels are specified, overlap.

scaled_difference_matrix(X[, X2])

Returns [(X - X2ᵀ) / ℓ].

slice(X[, X2])

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims.

slice_cov(cov)

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims for covariance matrices.

K

K_d

K_diag

scale

scaled_difference_matrix(X, X2=None)[source]

Returns [(X - X2ᵀ) / ℓ]. If X has shape […, N, D] and X2 has shape […, M, D], the output will have shape […, N, M, D].

gpflow.kernels.ArcCosine

class gpflow.kernels.ArcCosine(order=0, variance=1.0, weight_variances=1.0, bias_variance=1.0, *, active_dims=None, name=None)[source]

Bases: gpflow.kernels.base.Kernel

The Arc-cosine family of kernels which mimics the computation in neural networks. The order parameter specifies the assumed activation function. The Multi Layer Perceptron (MLP) kernel is closely related to the ArcCosine kernel of order 0. The key reference is

@incollection{NIPS2009_3628,
    title = {Kernel Methods for Deep Learning},
    author = {Youngmin Cho and Lawrence K. Saul},
    booktitle = {Advances in Neural Information Processing Systems 22},
    year = {2009},
    url = {http://papers.nips.cc/paper/3628-kernel-methods-for-deep-learning.pdf}
}
Attributes
active_dims
ard

Whether ARD behaviour is active.

parameters
trainable_parameters

Methods

__call__(X[, X2, full_cov, presliced])

Call self as a function.

on_separate_dims(other)

Checks if the dimensions, over which the kernels are specified, overlap.

slice(X[, X2])

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims.

slice_cov(cov)

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims for covariance matrices.

K

K_diag

Parameters
  • order (int) –

  • active_dims (Union[slice, list, None]) –

  • name (Optional[str]) –

_J(theta)[source]

Implements the order dependent family of functions defined in equations 4 to 7 in the reference paper.

__init__(order=0, variance=1.0, weight_variances=1.0, bias_variance=1.0, *, active_dims=None, name=None)[source]
Parameters
  • order (int) – specifies the activation function of the neural network the function is a rectified monomial of the chosen order

  • variance – the (initial) value for the variance parameter

  • weight_variances – the (initial) value for the weight_variances parameter, to induce ARD behaviour this must be initialised as an array the same length as the the number of active dimensions e.g. [1., 1., 1.]

  • bias_variance – the (initial) value for the bias_variance parameter defaults to 1.0

  • active_dims (Union[slice, list, None]) – a slice or list specifying which columns of X are used

Parameters

name (Optional[str]) –

property ard

Whether ARD behaviour is active.

Return type

bool

gpflow.kernels.Constant

class gpflow.kernels.Constant(*args: Any, **kwargs: Any)[source]

Bases: gpflow.kernels.statics.Static

The Constant (aka Bias) kernel. Functions drawn from a GP with this kernel are constant, i.e. f(x) = c, with c ~ N(0, σ^2). The kernel equation is

k(x, y) = σ²

where: σ² is the variance parameter.

Attributes
active_dims
parameters
trainable_parameters

Methods

__call__(X[, X2, full_cov, presliced])

Call self as a function.

on_separate_dims(other)

Checks if the dimensions, over which the kernels are specified, overlap.

slice(X[, X2])

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims.

slice_cov(cov)

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims for covariance matrices.

K

K_diag

gpflow.kernels.ChangePoints

class gpflow.kernels.ChangePoints(kernels, locations, steepness=1.0, name=None)[source]

Bases: gpflow.kernels.base.Combination

The ChangePoints kernel defines a fixed number of change-points along a 1d input space where different kernels govern different parts of the space.

The kernel is by multiplication and addition of the base kernels with sigmoid functions (σ). A single change-point kernel is defined as:

K₁(x, x’) * (1 - σ(x)) * (1 - σ(x’)) + K₂(x, x’) * σ(x) * σ(x’)

where K₁ is deactivated around the change-point and K₂ is activated. The single change-point version can be found in citet{lloyd2014}. Each sigmoid is a logistic function defined as:

σ(x) = 1 / (1 + exp{-s(x - x₀)})

parameterized by location “x₀” and steepness “s”.

@incollection{lloyd2014,

author = {Lloyd, James Robert et al}, title = {Automatic Construction and Natural-language Description of Nonparametric Regression Models}, booktitle = {Proceedings of the Twenty-Eighth AAAI Conference on Artificial Intelligence}, year = {2014}, url = {http://dl.acm.org/citation.cfm?id=2893873.2894066},

}

Attributes
active_dims
on_separate_dimensions

Checks whether the kernels in the combination act on disjoint subsets of dimensions.

parameters
trainable_parameters

Methods

__call__(X[, X2, full_cov, presliced])

Call self as a function.

on_separate_dims(other)

Checks if the dimensions, over which the kernels are specified, overlap.

slice(X[, X2])

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims.

slice_cov(cov)

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims for covariance matrices.

K

K_diag

Parameters
  • kernels (List[Kernel]) –

  • locations (List[float]) –

  • steepness (Union[float, List[float]]) –

  • name (Optional[str]) –

__init__(kernels, locations, steepness=1.0, name=None)[source]
Parameters
  • kernels (List[Kernel]) – list of kernels defining the different regimes

  • locations (List[float]) – list of change-point locations in the 1d input space

  • steepness (Union[float, List[float]]) – the steepness parameter(s) of the sigmoids, this can be common between them or decoupled

Parameters

name (Optional[str]) –

gpflow.kernels.Combination

class gpflow.kernels.Combination(kernels, name=None)[source]

Bases: gpflow.kernels.base.Kernel

Combine a list of kernels, e.g. by adding or multiplying (see inheriting classes).

The names of the kernels to be combined are generated from their class names.

Attributes
active_dims
on_separate_dimensions

Checks whether the kernels in the combination act on disjoint subsets of dimensions.

parameters
trainable_parameters

Methods

__call__(X[, X2, full_cov, presliced])

Call self as a function.

on_separate_dims(other)

Checks if the dimensions, over which the kernels are specified, overlap.

slice(X[, X2])

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims.

slice_cov(cov)

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims for covariance matrices.

K

K_diag

Parameters
  • kernels (List[Kernel]) –

  • name (Optional[str]) –

property on_separate_dimensions

Checks whether the kernels in the combination act on disjoint subsets of dimensions. Currently, it is hard to asses whether two slice objects will overlap, so this will always return False.

Returns

Boolean indicator.

gpflow.kernels.Convolutional

class gpflow.kernels.Convolutional(*args: Any, **kwargs: Any)[source]

Bases: gpflow.kernels.base.Kernel

Plain convolutional kernel as described in citet{vdw2017convgp}. Defines a GP f( ) that is constructed from a sum of responses of individual patches in an image:

f(x) = sum_p x^{[p]}

where x^{[p]} is the pth patch in the image.

@incollection{vdw2017convgp,

title = {Convolutional Gaussian Processes}, author = {van der Wilk, Mark and Rasmussen, Carl Edward and Hensman, James}, booktitle = {Advances in Neural Information Processing Systems 30}, year = {2017}, url = {http://papers.nips.cc/paper/6877-convolutional-gaussian-processes.pdf}

}

Attributes
active_dims
num_patches
parameters
patch_len
trainable_parameters

Methods

__call__(X[, X2, full_cov, presliced])

Call self as a function.

get_patches(X)

Extracts patches from the images X.

on_separate_dims(other)

Checks if the dimensions, over which the kernels are specified, overlap.

slice(X[, X2])

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims.

slice_cov(cov)

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims for covariance matrices.

K

K_diag

get_patches(X)[source]

Extracts patches from the images X. Patches are extracted separately for each of the colour channels. :param X: (N x input_dim) :return: Patches (N, num_patches, patch_shape)

gpflow.kernels.Coregion

class gpflow.kernels.Coregion(output_dim, rank, *, active_dims=None, name=None)[source]

Bases: gpflow.kernels.base.Kernel

A Coregionalization kernel. The inputs to this kernel are _integers_ (we cast them from floats as needed) which usually specify the outputs of a Coregionalization model.

The kernel function is an indexing of a positive-definite matrix:

K(x, y) = B[x, y] .

To ensure that B is positive-definite, it is specified by the two parameters of this kernel, W and kappa:

B = W Wᵀ + diag(kappa) .

We refer to the size of B as “output_dim x output_dim”, since this is the number of outputs in a coregionalization model. We refer to the number of columns on W as ‘rank’: it is the number of degrees of correlation between the outputs.

NB. There is a symmetry between the elements of W, which creates a local minimum at W=0. To avoid this, it is recommended to initialize the optimization (or MCMC chain) using a random W.

Attributes
active_dims
parameters
trainable_parameters

Methods

__call__(X[, X2, full_cov, presliced])

Call self as a function.

on_separate_dims(other)

Checks if the dimensions, over which the kernels are specified, overlap.

slice(X[, X2])

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims.

slice_cov(cov)

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims for covariance matrices.

K

K_diag

output_covariance

output_variance

Parameters
  • output_dim (int) –

  • rank (int) –

  • active_dims (Union[slice, list, None]) –

  • name (Optional[str]) –

__init__(output_dim, rank, *, active_dims=None, name=None)[source]
Parameters
  • output_dim (int) – number of outputs expected (0 <= X < output_dim)

  • rank (int) – number of degrees of correlation between outputs

Parameters
  • active_dims (Union[slice, list, None]) –

  • name (Optional[str]) –

gpflow.kernels.Cosine

class gpflow.kernels.Cosine(*args: Any, **kwargs: Any)[source]

Bases: gpflow.kernels.stationaries.AnisotropicStationary

The Cosine kernel. Functions drawn from a GP with this kernel are sinusoids (with a random phase). The kernel equation is

k(r) = σ² cos{2πd}

where: d is the sum of the per-dimension differences between the input points, scaled by the lengthscale parameter ℓ (i.e. Σᵢ [(X - X2ᵀ) / ℓ]ᵢ), σ² is the variance parameter.

Attributes
active_dims
ard

Whether ARD behaviour is active.

parameters
trainable_parameters

Methods

__call__(X[, X2, full_cov, presliced])

Call self as a function.

on_separate_dims(other)

Checks if the dimensions, over which the kernels are specified, overlap.

scaled_difference_matrix(X[, X2])

Returns [(X - X2ᵀ) / ℓ].

slice(X[, X2])

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims.

slice_cov(cov)

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims for covariance matrices.

K

K_d

K_diag

scale

gpflow.kernels.Exponential

class gpflow.kernels.Exponential(*args: Any, **kwargs: Any)[source]

Bases: gpflow.kernels.stationaries.IsotropicStationary

The Exponential kernel. It is equivalent to a Matern12 kernel with doubled lengthscales.

Attributes
active_dims
ard

Whether ARD behaviour is active.

parameters
trainable_parameters

Methods

__call__(X[, X2, full_cov, presliced])

Call self as a function.

on_separate_dims(other)

Checks if the dimensions, over which the kernels are specified, overlap.

scaled_squared_euclid_dist(X[, X2])

Returns ‖(X - X2ᵀ) / ℓ‖², i.e. the squared L₂-norm.

slice(X[, X2])

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims.

slice_cov(cov)

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims for covariance matrices.

K

K_diag

K_r

K_r2

scale

gpflow.kernels.IndependentLatent

class gpflow.kernels.IndependentLatent(active_dims=None, name=None)[source]

Bases: gpflow.kernels.multioutput.kernels.MultioutputKernel

Base class for multioutput kernels that are constructed from independent latent Gaussian processes.

It should always be possible to specify inducing variables for such kernels that give a block-diagonal Kuu, which can be represented as a [L, M, M] tensor. A reasonable (but not optimal) inference procedure can be specified by placing the inducing points in the latent processes and simply computing Kuu [L, M, M] and Kuf [N, P, M, L] and using fallback_independent_latent_ conditional(). This can be specified by using Fallback{Separate|Shared} IndependentInducingVariables.

Attributes
active_dims
latent_kernels

The underlying kernels in the multioutput kernel

num_latent_gps

The number of latent GPs in the multioutput kernel

parameters
trainable_parameters

Methods

K(X[, X2, full_output_cov])

Returns the correlation of f(X) and f(X2), where f(.) can be multi-dimensional.

K_diag(X[, full_output_cov])

Returns the correlation of f(X) and f(X), where f(.) can be multi-dimensional.

__call__(X[, X2, full_cov, full_output_cov, …])

Call self as a function.

on_separate_dims(other)

Checks if the dimensions, over which the kernels are specified, overlap.

slice(X[, X2])

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims.

slice_cov(cov)

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims for covariance matrices.

Kgg

Parameters
  • active_dims (Union[slice, list, None]) –

  • name (Optional[str]) –

gpflow.kernels.IsotropicStationary

class gpflow.kernels.IsotropicStationary(*args: Any, **kwargs: Any)[source]

Bases: gpflow.kernels.stationaries.Stationary

Base class for isotropic stationary kernels, i.e. kernels that only depend on

r = ‖x - x’‖

Derived classes should implement one of:

K_r2(self, r2): Returns the kernel evaluated on r² (r2), which is the squared scaled Euclidean distance Should operate element-wise on r2.

K_r(self, r): Returns the kernel evaluated on r, which is the scaled Euclidean distance. Should operate element-wise on r.

Attributes
active_dims
ard

Whether ARD behaviour is active.

parameters
trainable_parameters

Methods

__call__(X[, X2, full_cov, presliced])

Call self as a function.

on_separate_dims(other)

Checks if the dimensions, over which the kernels are specified, overlap.

scaled_squared_euclid_dist(X[, X2])

Returns ‖(X - X2ᵀ) / ℓ‖², i.e. the squared L₂-norm.

slice(X[, X2])

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims.

slice_cov(cov)

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims for covariance matrices.

K

K_diag

K_r2

scale

scaled_squared_euclid_dist(X, X2=None)[source]

Returns ‖(X - X2ᵀ) / ℓ‖², i.e. the squared L₂-norm.

gpflow.kernels.Kernel

class gpflow.kernels.Kernel(active_dims=None, name=None)[source]

Bases: gpflow.base.Module

The basic kernel class. Handles active dims.

Attributes
active_dims
parameters
trainable_parameters

Methods

__call__(X[, X2, full_cov, presliced])

Call self as a function.

on_separate_dims(other)

Checks if the dimensions, over which the kernels are specified, overlap.

slice(X[, X2])

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims.

slice_cov(cov)

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims for covariance matrices.

K

K_diag

Parameters
  • active_dims (Union[slice, list, None]) –

  • name (Optional[str]) –

__init__(active_dims=None, name=None)[source]
Parameters
  • active_dims (Union[slice, list, None]) – active dimensions, either a slice or list of indices into the columns of X.

  • name (Optional[str]) – optional kernel name.

_validate_ard_active_dims(ard_parameter)[source]

Validate that ARD parameter matches the number of active_dims (provided active_dims has been specified as an array).

on_separate_dims(other)[source]

Checks if the dimensions, over which the kernels are specified, overlap. Returns True if they are defined on different/separate dimensions and False otherwise.

slice(X, X2=None)[source]

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims.

Parameters
  • X (Tensor) – Input 1 [N, D].

  • X2 (Optional[Tensor]) – Input 2 [M, D], can be None.

Returns

Sliced X, X2, [N, I], I - input dimension.

slice_cov(cov)[source]

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims for covariance matrices. This requires slicing the rows and columns. This will also turn flattened diagonal matrices into a tensor of full diagonal matrices.

Parameters

cov (Tensor) – Tensor of covariance matrices, [N, D, D] or [N, D].

Return type

Tensor

Returns

[N, I, I].

gpflow.kernels.Linear

class gpflow.kernels.Linear(*args: Any, **kwargs: Any)[source]

Bases: gpflow.kernels.base.Kernel

The linear kernel. Functions drawn from a GP with this kernel are linear, i.e. f(x) = cx. The kernel equation is

k(x, y) = σ²xy

where σ² is the variance parameter.

Attributes
active_dims
ard

Whether ARD behaviour is active.

parameters
trainable_parameters

Methods

__call__(X[, X2, full_cov, presliced])

Call self as a function.

on_separate_dims(other)

Checks if the dimensions, over which the kernels are specified, overlap.

slice(X[, X2])

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims.

slice_cov(cov)

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims for covariance matrices.

K

K_diag

__init__(variance=1.0, active_dims=None)[source]
Parameters
  • variance – the (initial) value for the variance parameter(s), to induce ARD behaviour this must be initialised as an array the same length as the the number of active dimensions e.g. [1., 1., 1.]

  • active_dims – a slice or list specifying which columns of X are used

property ard

Whether ARD behaviour is active.

Return type

bool

gpflow.kernels.LinearCoregionalization

class gpflow.kernels.LinearCoregionalization(*args: Any, **kwargs: Any)[source]

Bases: gpflow.kernels.multioutput.kernels.IndependentLatent, gpflow.kernels.base.Combination

Linear mixing of the latent GPs to form the output.

Attributes
active_dims
latent_kernels

The underlying kernels in the multioutput kernel

num_latent_gps

The number of latent GPs in the multioutput kernel

on_separate_dimensions

Checks whether the kernels in the combination act on disjoint subsets of dimensions.

parameters
trainable_parameters

Methods

K(X[, X2, full_output_cov])

Returns the correlation of f(X) and f(X2), where f(.) can be multi-dimensional.

K_diag(X[, full_output_cov])

Returns the correlation of f(X) and f(X), where f(.) can be multi-dimensional.

__call__(X[, X2, full_cov, full_output_cov, …])

Call self as a function.

on_separate_dims(other)

Checks if the dimensions, over which the kernels are specified, overlap.

slice(X[, X2])

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims.

slice_cov(cov)

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims for covariance matrices.

Kgg

K(X, X2=None, full_output_cov=True)[source]

Returns the correlation of f(X) and f(X2), where f(.) can be multi-dimensional. :param X: data matrix, [N1, D] :param X2: data matrix, [N2, D] :param full_output_cov: calculate correlation between outputs. :return: cov[f(X), f(X2)] with shape - [N1, P, N2, P] if full_output_cov = True - [P, N1, N2] if full_output_cov = False

K_diag(X, full_output_cov=True)[source]

Returns the correlation of f(X) and f(X), where f(.) can be multi-dimensional. :param X: data matrix, [N, D] :param full_output_cov: calculate correlation between outputs. :return: var[f(X)] with shape - [N, P, N, P] if full_output_cov = True - [N, P] if full_output_cov = False

property latent_kernels

The underlying kernels in the multioutput kernel

property num_latent_gps

The number of latent GPs in the multioutput kernel

gpflow.kernels.Matern12

class gpflow.kernels.Matern12(*args: Any, **kwargs: Any)[source]

Bases: gpflow.kernels.stationaries.IsotropicStationary

The Matern 1/2 kernel. Functions drawn from a GP with this kernel are not differentiable anywhere. The kernel equation is

k(r) = σ² exp{-r}

where: r is the Euclidean distance between the input points, scaled by the lengthscales parameter ℓ. σ² is the variance parameter

Attributes
active_dims
ard

Whether ARD behaviour is active.

parameters
trainable_parameters

Methods

__call__(X[, X2, full_cov, presliced])

Call self as a function.

on_separate_dims(other)

Checks if the dimensions, over which the kernels are specified, overlap.

scaled_squared_euclid_dist(X[, X2])

Returns ‖(X - X2ᵀ) / ℓ‖², i.e. the squared L₂-norm.

slice(X[, X2])

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims.

slice_cov(cov)

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims for covariance matrices.

K

K_diag

K_r

K_r2

scale

gpflow.kernels.Matern32

class gpflow.kernels.Matern32(*args: Any, **kwargs: Any)[source]

Bases: gpflow.kernels.stationaries.IsotropicStationary

The Matern 3/2 kernel. Functions drawn from a GP with this kernel are once differentiable. The kernel equation is

k(r) = σ² (1 + √3r) exp{-√3 r}

where: r is the Euclidean distance between the input points, scaled by the lengthscales parameter ℓ, σ² is the variance parameter.

Attributes
active_dims
ard

Whether ARD behaviour is active.

parameters
trainable_parameters

Methods

__call__(X[, X2, full_cov, presliced])

Call self as a function.

on_separate_dims(other)

Checks if the dimensions, over which the kernels are specified, overlap.

scaled_squared_euclid_dist(X[, X2])

Returns ‖(X - X2ᵀ) / ℓ‖², i.e. the squared L₂-norm.

slice(X[, X2])

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims.

slice_cov(cov)

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims for covariance matrices.

K

K_diag

K_r

K_r2

scale

gpflow.kernels.Matern52

class gpflow.kernels.Matern52(*args: Any, **kwargs: Any)[source]

Bases: gpflow.kernels.stationaries.IsotropicStationary

The Matern 5/2 kernel. Functions drawn from a GP with this kernel are twice differentiable. The kernel equation is

k(r) = σ² (1 + √5r + 5/3r²) exp{-√5 r}

where: r is the Euclidean distance between the input points, scaled by the lengthscales parameter ℓ, σ² is the variance parameter.

Attributes
active_dims
ard

Whether ARD behaviour is active.

parameters
trainable_parameters

Methods

__call__(X[, X2, full_cov, presliced])

Call self as a function.

on_separate_dims(other)

Checks if the dimensions, over which the kernels are specified, overlap.

scaled_squared_euclid_dist(X[, X2])

Returns ‖(X - X2ᵀ) / ℓ‖², i.e. the squared L₂-norm.

slice(X[, X2])

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims.

slice_cov(cov)

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims for covariance matrices.

K

K_diag

K_r

K_r2

scale

gpflow.kernels.MultioutputKernel

class gpflow.kernels.MultioutputKernel(active_dims=None, name=None)[source]

Bases: gpflow.kernels.base.Kernel

Multi Output Kernel class. This kernel can represent correlation between outputs of different datapoints. Therefore, subclasses of Mok should implement K which returns: - [N, P, N, P] if full_output_cov = True - [P, N, N] if full_output_cov = False and K_diag returns: - [N, P, P] if full_output_cov = True - [N, P] if full_output_cov = False The full_output_cov argument holds whether the kernel should calculate the covariance between the outputs. In case there is no correlation but full_output_cov is set to True the covariance matrix will be filled with zeros until the appropriate size is reached.

Attributes
active_dims
latent_kernels

The underlying kernels in the multioutput kernel

num_latent_gps

The number of latent GPs in the multioutput kernel

parameters
trainable_parameters

Methods

K(X[, X2, full_output_cov])

Returns the correlation of f(X) and f(X2), where f(.) can be multi-dimensional.

K_diag(X[, full_output_cov])

Returns the correlation of f(X) and f(X), where f(.) can be multi-dimensional.

__call__(X[, X2, full_cov, full_output_cov, …])

Call self as a function.

on_separate_dims(other)

Checks if the dimensions, over which the kernels are specified, overlap.

slice(X[, X2])

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims.

slice_cov(cov)

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims for covariance matrices.

Parameters
  • active_dims (Union[slice, list, None]) –

  • name (Optional[str]) –

abstract K(X, X2=None, full_output_cov=True)[source]

Returns the correlation of f(X) and f(X2), where f(.) can be multi-dimensional. :param X: data matrix, [N1, D] :param X2: data matrix, [N2, D] :param full_output_cov: calculate correlation between outputs. :return: cov[f(X), f(X2)] with shape - [N1, P, N2, P] if full_output_cov = True - [P, N1, N2] if full_output_cov = False

abstract K_diag(X, full_output_cov=True)[source]

Returns the correlation of f(X) and f(X), where f(.) can be multi-dimensional. :param X: data matrix, [N, D] :param full_output_cov: calculate correlation between outputs. :return: var[f(X)] with shape - [N, P, N, P] if full_output_cov = True - [N, P] if full_output_cov = False

abstract property latent_kernels

The underlying kernels in the multioutput kernel

abstract property num_latent_gps

The number of latent GPs in the multioutput kernel

gpflow.kernels.Periodic

class gpflow.kernels.Periodic(base_kernel, period=1.0)[source]

Bases: gpflow.kernels.base.Kernel

The periodic family of kernels. Can be used to wrap any Stationary kernel to transform it into a periodic version. The canonical form (based on the SquaredExponential kernel) can be found in Equation (47) of

D.J.C.MacKay. Introduction to Gaussian processes. In C.M.Bishop, editor, Neural Networks and Machine Learning, pages 133–165. Springer, 1998.

The derivation can be achieved by mapping the original inputs through the transformation u = (cos(x), sin(x)).

For the SquaredExponential base kernel, the result can be expressed as:

k(r) = σ² exp{ -0.5 sin²(π r / γ) / ℓ²}

where: r is the Euclidean distance between the input points ℓ is the lengthscales parameter, σ² is the variance parameter, γ is the period parameter.

NOTE: usually we have a factor of 4 instead of 0.5 in front but this

is absorbed into the lengthscales hyperparameter.

NOTE: periodic kernel uses active_dims of a base kernel, therefore

the constructor doesn’t have it as an argument.

Attributes
active_dims
parameters
trainable_parameters

Methods

__call__(X[, X2, full_cov, presliced])

Call self as a function.

on_separate_dims(other)

Checks if the dimensions, over which the kernels are specified, overlap.

slice(X[, X2])

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims.

slice_cov(cov)

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims for covariance matrices.

K

K_diag

Parameters
  • base_kernel (IsotropicStationary) –

  • period (Union[float, List[float]]) –

__init__(base_kernel, period=1.0)[source]
Parameters
  • base_kernel (IsotropicStationary) – the base kernel to make periodic; must inherit from Stationary Note that active_dims should be specified in the base kernel.

  • period (Union[float, List[float]]) – the period; to induce a different period per active dimension this must be initialized with an array the same length as the number of active dimensions e.g. [1., 1., 1.]

gpflow.kernels.Polynomial

class gpflow.kernels.Polynomial(*args: Any, **kwargs: Any)[source]

Bases: gpflow.kernels.linears.Linear

The Polynomial kernel. Functions drawn from a GP with this kernel are polynomials of degree d. The kernel equation is

k(x, y) = (σ²xy + γ)ᵈ

where: σ² is the variance parameter, γ is the offset parameter, d is the degree parameter.

Attributes
active_dims
ard

Whether ARD behaviour is active.

parameters
trainable_parameters

Methods

__call__(X[, X2, full_cov, presliced])

Call self as a function.

on_separate_dims(other)

Checks if the dimensions, over which the kernels are specified, overlap.

slice(X[, X2])

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims.

slice_cov(cov)

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims for covariance matrices.

K

K_diag

__init__(degree=3.0, variance=1.0, offset=1.0, active_dims=None)[source]
Parameters
  • degree – the degree of the polynomial

  • variance – the (initial) value for the variance parameter(s), to induce ARD behaviour this must be initialised as an array the same length as the the number of active dimensions e.g. [1., 1., 1.]

  • offset – the offset of the polynomial

  • active_dims – a slice or list specifying which columns of X are used

gpflow.kernels.Product

class gpflow.kernels.Product(kernels, name=None)[source]

Bases: gpflow.kernels.base.ReducingCombination

Attributes
active_dims
on_separate_dimensions

Checks whether the kernels in the combination act on disjoint subsets of dimensions.

parameters
trainable_parameters

Methods

__call__(X[, X2, full_cov, presliced])

Call self as a function.

on_separate_dims(other)

Checks if the dimensions, over which the kernels are specified, overlap.

slice(X[, X2])

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims.

slice_cov(cov)

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims for covariance matrices.

K

K_diag

Parameters
  • kernels (List[Kernel]) –

  • name (Optional[str]) –

gpflow.kernels.SquaredExponential

class gpflow.kernels.SquaredExponential(*args: Any, **kwargs: Any)[source]

Bases: gpflow.kernels.stationaries.IsotropicStationary

The radial basis function (RBF) or squared exponential kernel. The kernel equation is

k(r) = σ² exp{-½ r²}

where: r is the Euclidean distance between the input points, scaled by the lengthscales parameter ℓ. σ² is the variance parameter

Functions drawn from a GP with this kernel are infinitely differentiable!

Attributes
active_dims
ard

Whether ARD behaviour is active.

parameters
trainable_parameters

Methods

__call__(X[, X2, full_cov, presliced])

Call self as a function.

on_separate_dims(other)

Checks if the dimensions, over which the kernels are specified, overlap.

scaled_squared_euclid_dist(X[, X2])

Returns ‖(X - X2ᵀ) / ℓ‖², i.e. the squared L₂-norm.

slice(X[, X2])

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims.

slice_cov(cov)

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims for covariance matrices.

K

K_diag

K_r2

scale

gpflow.kernels.RationalQuadratic

class gpflow.kernels.RationalQuadratic(*args: Any, **kwargs: Any)[source]

Bases: gpflow.kernels.stationaries.IsotropicStationary

Rational Quadratic kernel,

k(r) = σ² (1 + r² / 2αℓ²)^(-α)

σ² : variance ℓ : lengthscales α : alpha, determines relative weighting of small-scale and large-scale fluctuations

For α → ∞, the RQ kernel becomes equivalent to the squared exponential.

Attributes
active_dims
ard

Whether ARD behaviour is active.

parameters
trainable_parameters

Methods

__call__(X[, X2, full_cov, presliced])

Call self as a function.

on_separate_dims(other)

Checks if the dimensions, over which the kernels are specified, overlap.

scaled_squared_euclid_dist(X[, X2])

Returns ‖(X - X2ᵀ) / ℓ‖², i.e. the squared L₂-norm.

slice(X[, X2])

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims.

slice_cov(cov)

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims for covariance matrices.

K

K_diag

K_r2

scale

gpflow.kernels.SeparateIndependent

class gpflow.kernels.SeparateIndependent(*args: Any, **kwargs: Any)[source]

Bases: gpflow.kernels.multioutput.kernels.MultioutputKernel, gpflow.kernels.base.Combination

  • Separate: we use different kernel for each output latent

  • Independent: Latents are uncorrelated a priori.

Attributes
active_dims
latent_kernels

The underlying kernels in the multioutput kernel

num_latent_gps

The number of latent GPs in the multioutput kernel

on_separate_dimensions

Checks whether the kernels in the combination act on disjoint subsets of dimensions.

parameters
trainable_parameters

Methods

K(X[, X2, full_output_cov])

Returns the correlation of f(X) and f(X2), where f(.) can be multi-dimensional.

K_diag(X[, full_output_cov])

Returns the correlation of f(X) and f(X), where f(.) can be multi-dimensional.

__call__(X[, X2, full_cov, full_output_cov, …])

Call self as a function.

on_separate_dims(other)

Checks if the dimensions, over which the kernels are specified, overlap.

slice(X[, X2])

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims.

slice_cov(cov)

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims for covariance matrices.

K(X, X2=None, full_output_cov=True)[source]

Returns the correlation of f(X) and f(X2), where f(.) can be multi-dimensional. :param X: data matrix, [N1, D] :param X2: data matrix, [N2, D] :param full_output_cov: calculate correlation between outputs. :return: cov[f(X), f(X2)] with shape - [N1, P, N2, P] if full_output_cov = True - [P, N1, N2] if full_output_cov = False

K_diag(X, full_output_cov=False)[source]

Returns the correlation of f(X) and f(X), where f(.) can be multi-dimensional. :param X: data matrix, [N, D] :param full_output_cov: calculate correlation between outputs. :return: var[f(X)] with shape - [N, P, N, P] if full_output_cov = True - [N, P] if full_output_cov = False

property latent_kernels

The underlying kernels in the multioutput kernel

property num_latent_gps

The number of latent GPs in the multioutput kernel

gpflow.kernels.SharedIndependent

class gpflow.kernels.SharedIndependent(kernel, output_dim)[source]

Bases: gpflow.kernels.multioutput.kernels.MultioutputKernel

  • Shared: we use the same kernel for each latent GP

  • Independent: Latents are uncorrelated a priori.

Note: this class is created only for testing and comparison purposes. Use gpflow.kernels instead for more efficient code.

Attributes
active_dims
latent_kernels

The underlying kernels in the multioutput kernel

num_latent_gps

The number of latent GPs in the multioutput kernel

parameters
trainable_parameters

Methods

K(X[, X2, full_output_cov])

Returns the correlation of f(X) and f(X2), where f(.) can be multi-dimensional.

K_diag(X[, full_output_cov])

Returns the correlation of f(X) and f(X), where f(.) can be multi-dimensional.

__call__(X[, X2, full_cov, full_output_cov, …])

Call self as a function.

on_separate_dims(other)

Checks if the dimensions, over which the kernels are specified, overlap.

slice(X[, X2])

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims.

slice_cov(cov)

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims for covariance matrices.

Parameters
  • kernel (Kernel) –

  • output_dim (int) –

K(X, X2=None, full_output_cov=True)[source]

Returns the correlation of f(X) and f(X2), where f(.) can be multi-dimensional. :param X: data matrix, [N1, D] :param X2: data matrix, [N2, D] :param full_output_cov: calculate correlation between outputs. :return: cov[f(X), f(X2)] with shape - [N1, P, N2, P] if full_output_cov = True - [P, N1, N2] if full_output_cov = False

K_diag(X, full_output_cov=True)[source]

Returns the correlation of f(X) and f(X), where f(.) can be multi-dimensional. :param X: data matrix, [N, D] :param full_output_cov: calculate correlation between outputs. :return: var[f(X)] with shape - [N, P, N, P] if full_output_cov = True - [N, P] if full_output_cov = False

property latent_kernels

The underlying kernels in the multioutput kernel

property num_latent_gps

The number of latent GPs in the multioutput kernel

gpflow.kernels.Static

class gpflow.kernels.Static(*args: Any, **kwargs: Any)[source]

Bases: gpflow.kernels.base.Kernel

Kernels who don’t depend on the value of the inputs are ‘Static’. The only parameter is a variance, σ².

Attributes
active_dims
parameters
trainable_parameters

Methods

__call__(X[, X2, full_cov, presliced])

Call self as a function.

on_separate_dims(other)

Checks if the dimensions, over which the kernels are specified, overlap.

slice(X[, X2])

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims.

slice_cov(cov)

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims for covariance matrices.

K

K_diag

gpflow.kernels.Stationary

class gpflow.kernels.Stationary(*args: Any, **kwargs: Any)[source]

Bases: gpflow.kernels.base.Kernel

Base class for kernels that are stationary, that is, they only depend on

d = x - x’

This class handles ‘ard’ behaviour, which stands for ‘Automatic Relevance Determination’. This means that the kernel has one lengthscale per dimension, otherwise the kernel is isotropic (has a single lengthscale).

Attributes
active_dims
ard

Whether ARD behaviour is active.

parameters
trainable_parameters

Methods

__call__(X[, X2, full_cov, presliced])

Call self as a function.

on_separate_dims(other)

Checks if the dimensions, over which the kernels are specified, overlap.

slice(X[, X2])

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims.

slice_cov(cov)

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims for covariance matrices.

K

K_diag

scale

__init__(variance=1.0, lengthscales=1.0, **kwargs)[source]
Parameters
  • variance – the (initial) value for the variance parameter.

  • lengthscales – the (initial) value for the lengthscale parameter(s), to induce ARD behaviour this must be initialised as an array the same length as the the number of active dimensions e.g. [1., 1., 1.]. If only a single value is passed, this value is used as the lengthscale of each dimension.

  • kwargs – accepts name and active_dims, which is a list or slice of indices which controls which columns of X are used (by default, all columns are used).

property ard

Whether ARD behaviour is active.

Return type

bool

gpflow.kernels.Sum

class gpflow.kernels.Sum(kernels, name=None)[source]

Bases: gpflow.kernels.base.ReducingCombination

Attributes
active_dims
on_separate_dimensions

Checks whether the kernels in the combination act on disjoint subsets of dimensions.

parameters
trainable_parameters

Methods

__call__(X[, X2, full_cov, presliced])

Call self as a function.

on_separate_dims(other)

Checks if the dimensions, over which the kernels are specified, overlap.

slice(X[, X2])

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims.

slice_cov(cov)

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims for covariance matrices.

K

K_diag

Parameters
  • kernels (List[Kernel]) –

  • name (Optional[str]) –

gpflow.kernels.White

class gpflow.kernels.White(*args: Any, **kwargs: Any)[source]

Bases: gpflow.kernels.statics.Static

The White kernel: this kernel produces ‘white noise’. The kernel equation is

k(x_n, x_m) = δ(n, m) σ²

where: δ(.,.) is the Kronecker delta, σ² is the variance parameter.

Attributes
active_dims
parameters
trainable_parameters

Methods

__call__(X[, X2, full_cov, presliced])

Call self as a function.

on_separate_dims(other)

Checks if the dimensions, over which the kernels are specified, overlap.

slice(X[, X2])

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims.

slice_cov(cov)

Slice the correct dimensions for use in the kernel, as indicated by self.active_dims for covariance matrices.

K

K_diag

gpflow.kernels.base

Kernels form a core component of GPflow models and allow prior information to be encoded about a latent function of interest. The effect of choosing different kernels, and how it is possible to combine multiple kernels is shown in the “Using kernels in GPflow” notebook.

Broadcasting over leading dimensions: kernel.K(X1, X2) returns the kernel evaluated on every pair in X1 and X2. E.g. if X1 has shape [S1, N1, D] and X2 has shape [S2, N2, D], kernel.K(X1, X2) will return a tensor of shape [S1, N1, S2, N2]. Similarly, kernel.K(X1, X1) returns a tensor of shape [S1, N1, S1, N1]. In contrast, the return shape of kernel.K(X1) is [S1, N1, N1]. (Without leading dimensions, the behaviour of kernel.K(X, None) is identical to kernel.K(X, X).)

gpflow.kernels.multioutput