RatQuad¶

class probnum.randprocs.kernels.RatQuad(input_shape, lengthscale=1.0, alpha=1.0)¶

Bases: Kernel, IsotropicMixin

Rational quadratic kernel.

Covariance function defined by

\begin{equation} k(x_0, x_1) = \left( 1 + \frac{\lVert x_0 - x_1 \rVert_2^2}{2 \alpha l^2} \right)^{-\alpha}, \end{equation}

where \(\alpha > 0\). For \(\alpha \rightarrow \infty\) the rational quadratic kernel converges to the ExpQuad kernel.

Parameters

input_shape (Union[int, Integral, integer, Iterable[Union[int, Integral, integer]]]) – Shape of the kernel’s input.
lengthscale (Union[int, float, complex, Number, number]) – Lengthscale \(l\) of the kernel. Describes the input scale on which the process varies.
alpha (Union[int, float, complex, Number, number]) – Scale mixture \(\alpha\). Positive constant determining the weighting between different lengthscales.

See also

ExpQuad: Exponentiated Quadratic / RBF kernel.

Examples

>>> import numpy as np
>>> from probnum.randprocs.kernels import RatQuad
>>> K = RatQuad(input_shape=1, lengthscale=0.1, alpha=3)
>>> xs = np.linspace(0, 1, 3)[:, None]
>>> K(xs[:, None, :], xs[None, :, :])
array([[1.00000000e+00, 7.25051190e-03, 1.81357765e-04],
       [7.25051190e-03, 1.00000000e+00, 7.25051190e-03],
       [1.81357765e-04, 7.25051190e-03, 1.00000000e+00]])

Attributes Summary

`input_ndim`	Syntactic sugar for `len(input_shape)`.
`input_shape`	Shape of single, i.e. non-batched, arguments of the covariance function.
`output_ndim`	Syntactic sugar for `len(output_shape)`.
`output_shape`	Shape of single, i.e. non-batched, return values of the covariance function.

Methods Summary

`__call__`(x0, x1)	Evaluate the (cross-)covariance function(s).
`matrix`(x0[, x1])	A convenience function for computing a kernel matrix for two sets of inputs.

Attributes Documentation

input_ndim¶: Syntactic sugar for len(input_shape).

input_shape¶: Shape of single, i.e. non-batched, arguments of the covariance function.

output_ndim¶: Syntactic sugar for len(output_shape).

output_shape¶

Shape of single, i.e. non-batched, return values of the covariance function.

If output_shape is (), the Kernel instance represents a single (cross-)covariance function. Otherwise, i.e. if output_shape is non-empty, the Kernel instance represents a tensor of (cross-)covariance functions whose shape is given by output_shape.

Methods Documentation

__call__(x0, x1)¶

Evaluate the (cross-)covariance function(s).

The evaluation of the (cross-covariance) function(s) is vectorized over the batch shapes of the arguments, applying standard NumPy broadcasting.

Parameters

x0 (ArrayLike) – shape= batch_shape_0 + input_shape – (Batch of) input(s) for the first argument of the Kernel.
x1 (Optional[ArrayLike]) – shape= batch_shape_1 + input_shape – (Batch of) input(s) for the second argument of the Kernel. Can also be set to None, in which case the function will behave as if x1 = x0 (but it is implemented more efficiently).

Returns

shape= bcast_batch_shape + output_shape – The (cross-)covariance function(s) evaluated at (x0, x1). Since the function is vectorized over the batch shapes of the inputs, the output array contains the following entries:

k_x0_x1[batch_idx + output_idx] = k[output_idx](
    x0[batch_idx, ...],
    x1[batch_idx, ...],
)

where we assume that x0 and x1 have been broadcast to a common shape bcast_batch_shape + input_shape, and where output_idx and batch_idx are indices compatible with output_shape and bcast_batch_shape, respectively. By k[output_idx] we refer to the covariance function at index output_idx in the tensor of covariance functions represented by the Kernel instance.

Return type

k_x0_x1

Raises

ValueError – If one of the input shapes is not of the form batch_shape_{0,1} + input_shape.
ValueError – If the inputs can not be broadcast to a common shape.