Implementing Kernels
Implementing an own kernel is easy. Just create a class which is derived from
Kernel
. Then implement the Kernel.params
attribute and the
Kernel.full()
method. Here is some example code to get you started:
from goppy import Kernel
class MyKernel(Kernel):
def __init__(self, param1, param2):
self.param1 = param1
self.param2 = param2
@property
def params(self):
return np.array([self.param1, self.param2])
@params.setter
def params(self, values):
self.param1 = values[0]
self.param2 = values[1]
def full(x, y, what=('y',)):
# Evaluate your kernel
pass
By implementing Kernel.params
as a property it is possible to access
the parameters as an array (which is needed for evaluating log likelihood
derivatives of Gaussian processes), but also by more expressive names like
k.param1
.
The Kernel.full()
full method should by default evaluate the kernel
normally and return the result in a dictionary with the key 'y'
. This is
sufficient for the basic functionality when used in conjunction with
OnlineGP
. For more advanced usage involving predicting derivatives
Kernel.full()
has also be able to return the derivatives of the kernel.
See the documentation of Kernel.full()
for more information.
Sometimes only the diagonal of the Gram matrix is needed. The diagonal can
usually be calculated more efficiently than evaluating the full Gram matrix and
just using the diagonal. Thus, it might be a good idea to add
code for this special case by implementing Kernel.diag()
.
Look at the source of the kernel module
to see
some complete implementations of kernels.