def compare_kernels(kernel1, kernel2):
"""
Compare the values of kernel1 and kernel2. Returns True if they're equal, otherwise it
return False.
:param kernel1: Matern52 instance object
:param kernel2: Matern52 instance object
:return: boolean
"""
if kernel1.name != kernel2.name:
return False
if kernel1.dimension != kernel2.dimension:
return False
if kernel1.dimension_parameters != kernel2.dimension_parameters:
return False
if kernel1.sigma2.value != kernel2.sigma2.value:
return False
kernel_ = kernel1.kernel
kernel_2 = kernel2.kernel
ct = find_kernel_constructor(kernel_.name)
return ct.compare_kernels(kernel_, kernel_2)
def define_default_kernel(cls,
dimension,
bounds=None,
default_values=None,
parameters_priors=None,
*args,
**kernel_parameters):
"""
:param dimension: [(int)] dimension of the domain of the kernels. It's the number of tasks
for the tasks kernel.
:param default_values: [np.array(n)] List with the default value for the parameters of each
of the kernels of the product.
:param bounds: [[[float], float]] List witht he bounds of the domain of each of the kernels
of the product.
:param parameters_priors: {
SIGMA2_NAME: float
LENGTH_SCALE_NAME: [float]
LOWER_TRIANG_NAME: [float]
}
:param args: [str] List with the names of the kernels.
:param kernel_parameters: additional kernel parameters,
- SAME_CORRELATION: (boolean) True or False. Parameter used only for task kernel.
:return: ProductKernels
"""
kernels = []
if default_values is None:
iterate = zip(args[0], dimension)
else:
iterate = zip(args[0], dimension, default_values)
if bounds is None:
bounds = len(dimension) * [None]
index = 0
for value in iterate:
name = value[0]
dim = value[1]
bound = bounds[index]
index += 1
constructor = find_kernel_constructor(name)
if default_values is None:
kernels.append(
constructor.define_default_kernel(dim, bound, None,
parameters_priors,
**kernel_parameters))
else:
kernels.append(
constructor.define_default_kernel(dim, bound, value[2],
parameters_priors,
**kernel_parameters))
return cls(*kernels)
def define_kernel_from_array(cls, dimension, params, *args):
"""
:param dimension: (int) dimension of the kernel instance used in this kernel
:param params: (np.array(k)) The first part are the parameters for the kernel, the
second part is the parameter for sigma2.
:param args: [str] name of the kernel instance
:return: scaled kernel
"""
for name in args[0]:
kernel_ct = find_kernel_constructor(name)
kernel = kernel_ct.define_kernel_from_array(dimension, params[0: -1])
sigma2 = ParameterEntity(SIGMA2_NAME, params[-1:], None)
return cls(dimension, kernel, sigma2)
def parameters_from_list_to_dict(params, **kwargs):
"""
Converts a list of parameters to dictionary using the order of the kernel.
:param params: [float]
:param kwargs:{
'dimensions': [float],
'kernel': str,
}
:return: {
KERNEL_PARAMETERS: [float],
SIGMA2_NAME: float,
}
"""
ct = find_kernel_constructor(kwargs['kernels'])
parameters = ct.parameters_from_list_to_dict(params[0: -1])
parameters[SIGMA2_NAME] = params[-1]
return parameters
def define_default_kernel(cls, dimension, bounds=None, default_values=None,
parameters_priors=None, *args):
"""
:param dimension: (int) dimension of the domain of the kernel instance
:param bounds: [[float, float]], lower bound and upper bound for each entry of the domain.
This parameter is used to compute priors in a smart way.
:param default_values: (np.array(k)) The first part are the parameters for the instance of
the kernel, the second part is the parameter for sigma2.
:param parameters_priors: {
PARAMATER_NAME: [float],
SIGMA2_NAME: float,
}
:param args: [str] List with the names of the default kernel
:return: scaled kernel
"""
if parameters_priors is None:
parameters_priors = {}
default_values_kernel = None
if default_values is not None:
default_values_kernel = default_values[0: -1]
default_value_sigma = default_values[-1:]
else:
default_value_sigma = [parameters_priors.get(SIGMA2_NAME, 1.0)]
for name in args[0]:
kernel_ct = find_kernel_constructor(name)
kernel = kernel_ct.define_default_kernel(dimension, bounds, default_values_kernel,
parameters_priors)
sigma2 = ParameterEntity(SIGMA2_NAME, default_value_sigma,
LogNormalSquare(1, 1.0, np.sqrt(default_value_sigma)),
bounds=[(SMALLEST_POSITIVE_NUMBER, None)])
kernel_scaled = cls(dimension, kernel, sigma2)
return kernel_scaled
def test_find_kernel_constructor(self):
assert find_kernel_constructor(MATERN52_NAME) == Matern52
assert find_kernel_constructor(TASKS_KERNEL_NAME) == TasksKernel
with self.assertRaises(NameError):
find_kernel_constructor('a')