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