def test_evaluate_grad_respect_point(self): result = ScaledKernel.evaluate_grad_respect_point( np.array([5.0, 1.0]), np.array([[1]]), np.array([[4], [5]]), 1, *([MATERN52_NAME], )) kernel = ScaledKernel.define_kernel_from_array(1, np.array([5.0, 1.0]), *([MATERN52_NAME], )) assert np.all(result == kernel.grad_respect_point( np.array([[1]]), np.array([[4], [5]])))
def test_gradient_respect_parameters_finite_differences(self): inputs_1 = np.array([[2.0, 4.0], [3.0, 5.0]]) dh = 0.00000001 finite_diff = FiniteDifferences.forward_difference( lambda params: ScaledKernel.evaluate_cov_defined_by_params( params, inputs_1, 2, *([MATERN52_NAME], )), np.array([2.0, 3.0, 4.0]), np.array([dh])) gradient = ScaledKernel.evaluate_grad_defined_by_params_respect_params( np.array([2.0, 3.0, 4.0]), inputs_1, 2, *([MATERN52_NAME], )) for i in range(3): npt.assert_almost_equal(finite_diff[i], gradient[i])
def setUp(self): np.random.seed(2) n_points = 100 normal_noise = np.random.normal(0, 1.0, n_points) points = np.linspace(0, 10, n_points) points = points.reshape([n_points, 1]) kernel = Matern52.define_kernel_from_array(1, np.array([2.0])) self.sigma2 = ParameterEntity(SIGMA2_NAME, np.array([1.0]), None) kernel = ScaledKernel(1, kernel, self.sigma2) function = SampleFunctions.sample_from_gp(points, kernel) function = function[0, :] evaluations = function + normal_noise + 10.0 self.training_data_gp = { "evaluations": list(evaluations), "points": points, "var_noise": [] } bounds = None self.gp_gaussian = GPFittingGaussian([MATERN52_NAME], self.training_data_gp, [1], bounds, max_steps_out=1000) self.gp_gaussian_2 = GPFittingGaussian([SCALED_KERNEL, MATERN52_NAME], self.training_data_gp, [1], bounds, max_steps_out=1000)
def test_evaluate_grad_cross_cov_respect_point(self): value = self.gp.evaluate_grad_cross_cov_respect_point(np.array([[40.0]]), np.array([[39.0], [38.0]]), np.array([1.0, 1.0])) value_2 = ScaledKernel.evaluate_grad_respect_point(np.array([1.0, 1.0]), np.array([[40.0]]), np.array([[39.0], [38.0]]), 1, *([MATERN52_NAME],)) assert np.all(value == value_2) type_kernel = [MATERN52_NAME] training_data = { "evaluations": [42.2851784656, 72.3121248508, 1.0113231069, 30.9309246906, 15.5288331909], "points": [ [42.2851784656], [72.3121248508], [1.0113231069], [30.9309246906], [15.5288331909]], "var_noise": []} dimensions = [1] gp = GPFittingGaussian(type_kernel, training_data, dimensions) value = gp.evaluate_grad_cross_cov_respect_point(np.array([[40.0]]), np.array([[39.0], [38.0]]), np.array([1.0])) value_2 = Matern52.evaluate_grad_respect_point(np.array([1.0]), np.array([[40.0]]), np.array([[39.0], [38.0]]), 1) assert np.all(value == value_2)
def test_define_default_kernel_2(self): kernel = ScaledKernel.define_default_kernel(1, None, None, None, *([MATERN52_NAME], )) assert kernel.name == MATERN52_NAME assert kernel.dimension == 1 assert kernel.dimension_parameters == 2 assert kernel.sigma2.value == [1.0] assert kernel.kernel.length_scale.value == [1.0]
def setUp(self): self.dimension = 2 self.length_scale = ParameterEntity('scale', np.array([1.0, 2.0]), None) self.sigma2 = ParameterEntity('sigma2', np.array([3]), None) self.matern52 = Matern52(self.dimension, self.length_scale) self.matern52 = ScaledKernel(self.dimension, self.matern52, self.sigma2)
def test_define_prior_parameters(self): training_data = { "evaluations": np.array([1.0, 2.0]), "points": np.array([[1.0], [2.0]]), "var_noise": None } assert ScaledKernel.define_prior_parameters(training_data, 0, None) == { SIGMA2_NAME: 0.25, }
def setUp(self): self.dimension = 2 self.length_scale = ParameterEntity('scale', np.array([1.0, 2.0]), None) self.sigma2 = ParameterEntity('sigma2', np.array([3]), None) self.matern52 = Matern52(self.dimension, self.length_scale) self.matern52 = ScaledKernel(self.dimension, self.matern52, self.sigma2) self.inputs = np.array([[1, 0], [0, 1]]) self.prior = UniformPrior(2, [1, 1], [100, 100]) self.prior_2 = UniformPrior(1, [1], [100]) self.matern52_ = Matern52( 2, ParameterEntity(LENGTH_SCALE_NAME, np.array([2.0, 3.0]), self.prior)) self.matern52_ = ScaledKernel( self.dimension, self.matern52_, ParameterEntity('sigma2', np.array([4.0]), self.prior_2))
def test_evaluate_hessian_respect_point(self): point = np.array([[4.5, 7.5]]) inputs = np.array([[5.0, 6.0], [8.0, 9.0]]) params = np.array([1.0, 5.0, 3.0]) result = ScaledKernel.evaluate_hessian_respect_point( params, point, inputs, 2, *([MATERN52_NAME], )) dh = 0.00001 finite_diff = FiniteDifferences.second_order_central( lambda x: ScaledKernel.evaluate_cross_cov_defined_by_params( params, x.reshape( (1, len(x))), inputs, 2, *([MATERN52_NAME], )), point[0, :], np.array([dh])) for i in xrange(2): for j in xrange(2): npt.assert_almost_equal( finite_diff[i, j], np.array([[result[0, i, j], result[1, i, j]]]), decimal=5)
def test_compare_kernels(self): kernel_t = TasksKernel(self.dimension, np.array([0.0])) assert ScaledKernel.compare_kernels(self.matern52, kernel_t) is False kernel_s = Matern52(3, self.length_scale) assert ScaledKernel.compare_kernels(self.matern52, kernel_s) is False kernel_s = Matern52(2, self.length_scale) assert ScaledKernel.compare_kernels(self.matern52, kernel_s) is False sigma2 = ParameterEntity('sigma2', np.array([1]), None) kernel = ScaledKernel(self.dimension, kernel_s, sigma2) assert ScaledKernel.compare_kernels(self.matern52, kernel) is False kernel_s = Matern52( 2, ParameterEntity('scale', np.array([1.0, 3.0]), None)) kernel = ScaledKernel(self.dimension, kernel_s, self.sigma2) assert ScaledKernel.compare_kernels(self.matern52, kernel) is False
def test_cross_cov(self): r2 = np.array([[0.0, 1.25], [1.25, 0.0]]) r = np.sqrt(r2) left_term = ((1.0 + np.sqrt(5) * r + (5.0 / 3.0) * r2) * np.exp(-np.sqrt(5) * r) * np.array([3]))[0, 1] comparisons = left_term == self.matern52.cross_cov( self.inputs, self.inputs)[0, 1] assert np.all(comparisons) point_1 = np.array([[2.0, 4.0]]) point_2 = np.array([[3.0, 5.0]]) matern52 = Matern52( 2, ParameterEntity('scale', np.array([2.0, 3.0]), None)) matern52 = ScaledKernel( 2, matern52, ParameterEntity('sigma2', np.array([4.0]), None)) assert np.all( matern52.cross_cov(point_1, point_2) == np.array( [[3.0737065834936015]])) inputs_1 = np.array([[2.0, 4.0], [3.0, 5.0]]) inputs_2 = np.array([[1.5, 9.0], [-3.0, 8.0]]) assert np.all( matern52.cross_cov(inputs_1, inputs_2) == np.array([[ 0.87752659905500319, 0.14684671522649542 ], [1.0880320585678382, 0.084041575076539962]])) inputs_1 = np.array([[2.0, 4.0]]) inputs_2 = np.array([[1.5, 9.0], [-3.0, 8.0]]) assert np.all( matern52.cross_cov(inputs_1, inputs_2) == np.array( [[0.87752659905500319, 0.14684671522649542]])) inputs_1 = np.array([[2.0, 4.0], [3.0, 5.0]]) inputs_2 = np.array([[1.5, 9.0]]) npt.assert_almost_equal( matern52.cross_cov(inputs_1, inputs_2), np.array([[0.87752659905500319], [1.0880320585678382]]))
class TestMatern52(unittest.TestCase): def setUp(self): self.dimension = 2 self.length_scale = ParameterEntity('scale', np.array([1.0, 2.0]), None) self.sigma2 = ParameterEntity('sigma2', np.array([3]), None) self.matern52 = Matern52(self.dimension, self.length_scale) self.matern52 = ScaledKernel(self.dimension, self.matern52, self.sigma2) self.inputs = np.array([[1, 0], [0, 1]]) self.prior = UniformPrior(2, [1, 1], [100, 100]) self.prior_2 = UniformPrior(1, [1], [100]) self.matern52_ = Matern52( 2, ParameterEntity(LENGTH_SCALE_NAME, np.array([2.0, 3.0]), self.prior)) self.matern52_ = ScaledKernel( self.dimension, self.matern52_, ParameterEntity('sigma2', np.array([4.0]), self.prior_2)) def test_hypers(self): assert { 'scale': self.length_scale, 'sigma2': self.sigma2 } == self.matern52.hypers def test_set_parameters(self): length = ParameterEntity('scale_', np.array([1, 2]), None) sigma2 = ParameterEntity('sigma2', np.array([3]), None) self.matern52.set_parameters([length], sigma2=sigma2) assert self.matern52.hypers == {'scale_': length, 'sigma2': sigma2} def test_cov(self): expect(self.matern52).cross_cov.once().and_return(0) assert self.matern52.cov(self.inputs) == 0 def test_cross_cov(self): r2 = np.array([[0.0, 1.25], [1.25, 0.0]]) r = np.sqrt(r2) left_term = ((1.0 + np.sqrt(5) * r + (5.0 / 3.0) * r2) * np.exp(-np.sqrt(5) * r) * np.array([3]))[0, 1] comparisons = left_term == self.matern52.cross_cov( self.inputs, self.inputs)[0, 1] assert np.all(comparisons) point_1 = np.array([[2.0, 4.0]]) point_2 = np.array([[3.0, 5.0]]) matern52 = Matern52( 2, ParameterEntity('scale', np.array([2.0, 3.0]), None)) matern52 = ScaledKernel( 2, matern52, ParameterEntity('sigma2', np.array([4.0]), None)) assert np.all( matern52.cross_cov(point_1, point_2) == np.array( [[3.0737065834936015]])) inputs_1 = np.array([[2.0, 4.0], [3.0, 5.0]]) inputs_2 = np.array([[1.5, 9.0], [-3.0, 8.0]]) assert np.all( matern52.cross_cov(inputs_1, inputs_2) == np.array([[ 0.87752659905500319, 0.14684671522649542 ], [1.0880320585678382, 0.084041575076539962]])) inputs_1 = np.array([[2.0, 4.0]]) inputs_2 = np.array([[1.5, 9.0], [-3.0, 8.0]]) assert np.all( matern52.cross_cov(inputs_1, inputs_2) == np.array( [[0.87752659905500319, 0.14684671522649542]])) inputs_1 = np.array([[2.0, 4.0], [3.0, 5.0]]) inputs_2 = np.array([[1.5, 9.0]]) npt.assert_almost_equal( matern52.cross_cov(inputs_1, inputs_2), np.array([[0.87752659905500319], [1.0880320585678382]])) def test_gradient_respect_parameters(self): expect(GradientLSMatern52).gradient_respect_parameters_ls.once( ).and_return({'a': 0}) expect(self.matern52).cov.once().and_return(1.0) assert self.matern52.gradient_respect_parameters(self.inputs) == { 'a': 0, 'sigma2': 1.0 / 3 } def test_gradient_respect_parameters_finite_differences(self): inputs_1 = np.array([[2.0, 4.0], [3.0, 5.0]]) dh = 0.00000001 finite_diff = FiniteDifferences.forward_difference( lambda params: ScaledKernel.evaluate_cov_defined_by_params( params, inputs_1, 2, *([MATERN52_NAME], )), np.array([2.0, 3.0, 4.0]), np.array([dh])) gradient = ScaledKernel.evaluate_grad_defined_by_params_respect_params( np.array([2.0, 3.0, 4.0]), inputs_1, 2, *([MATERN52_NAME], )) for i in range(3): npt.assert_almost_equal(finite_diff[i], gradient[i]) def test_grad_respect_point(self): expect(GradientLSMatern52).grad_respect_point.once().and_return(0) assert 0 == self.matern52.grad_respect_point(self.inputs, self.inputs) def test_grad_respect_point_finite_differences(self): dh = 0.000000000001 inputs_1 = np.array([[2.0, 4.0], [3.0, 5.0]]) point = np.array([[42.0, 35.0]]) finite_diff = FiniteDifferences.forward_difference( lambda point: self.matern52_.cross_cov(point.reshape([1, 2]), inputs_1), np.array([42.0, 35.0]), np.array([dh])) gradient = self.matern52_.grad_respect_point(point, inputs_1) for i in range(2): npt.assert_almost_equal(finite_diff[i], gradient[:, i:i + 1].transpose()) def test_gradient_respect_parameters_ls(self): expect(GradientLSMatern52).gradient_respect_distance.once().and_return( 4) expect(Distances).gradient_distance_length_scale_respect_ls.once( ).and_return({ 0: 3, 1: 2 }) assert GradientLSMatern52.gradient_respect_parameters_ls( self.inputs, self.length_scale) == { 'scale': { 0: 12, 1: 8 } } def test_gradient_respect_distance(self): expect(GradientLSMatern52).gradient_respect_distance_cross.once( ).and_return(0) assert GradientLSMatern52.gradient_respect_distance( self.length_scale, self.inputs) == 0 def test_gradient_respect_distance_cross(self): expect(Distances).dist_square_length_scale.once().and_return( np.array([0.0])) assert GradientLSMatern52.gradient_respect_distance_cross( self.length_scale, self.inputs, self.inputs) == np.array([0.0]) def test_grad_respect_point_2(self): expect(GradientLSMatern52).gradient_respect_distance_cross.once( ).and_return(np.array([[1, 0], [0, 1]])) expect(Distances).gradient_distance_length_scale_respect_point.once( ).and_return(1.0) comparisons = GradientLSMatern52.grad_respect_point(self.length_scale, self.inputs, self.inputs) == \ np.array([[1, 0], [0, 1]]) assert np.all(comparisons) def test_grad_respect_point_matern(self): expect(GradientLSMatern52).grad_respect_point.once().and_return(0.0) assert self.matern52.grad_respect_point(self.inputs, self.inputs) == 0.0 def test_name_parameters_as_list(self): assert self.matern52.name_parameters_as_list == \ [('scale', [(0, None), (1, None)]), ('sigma2', None)] def test_define_kernel_from_array(self): kernel = Matern52.define_kernel_from_array(2, np.array([1, 3])) assert np.all(kernel.length_scale.value == np.array([1, 3])) def test_evaluate_cov_defined_by_params(self): result = Matern52.evaluate_cov_defined_by_params( np.array([1, 3, 5]), np.array([[4, 5]]), 2) kernel = Matern52.define_kernel_from_array(2, np.array([1, 3, 5])) assert result == kernel.cov(np.array([[4, 5]])) def test_evaluate_grad_defined_by_params_respect_params(self): result = Matern52.evaluate_grad_defined_by_params_respect_params( np.array([1, 3]), np.array([[4, 5]]), 2) kernel = Matern52.define_kernel_from_array(2, np.array([1, 3])) grad_kernel = kernel.gradient_respect_parameters(np.array([[4, 5]])) assert result == { 0: grad_kernel['length_scale'][0], 1: grad_kernel['length_scale'][1] } def test_hypers_as_list(self): assert self.matern52_.hypers_as_list == [ self.matern52_.kernel.length_scale, self.matern52_.sigma2 ] def test_hypers_values_as_array(self): assert np.all( self.matern52_.hypers_values_as_array == np.array([2.0, 3.0, 4.0])) def test_sample_parameters(self): parameters = self.matern52_.hypers_as_list samples = [] np.random.seed(1) for parameter in parameters: samples.append(parameter.sample_from_prior(2)) assert np.all( self.matern52_.sample_parameters(2, random_seed=1) == np.array([[ samples[0][0, 0], samples[0][0, 1], samples[1][0] ], [samples[0][1, 0], samples[0][1, 1], samples[1][1]]])) np.random.seed(1) matern52 = Matern52( 2, ParameterEntity(LENGTH_SCALE_NAME, np.array([2.0, 3.0]), self.prior)) samples = [] parameters1 = matern52.hypers_as_list for parameter in parameters1: samples.append(parameter.sample_from_prior(2)) assert np.all( matern52.sample_parameters(2, random_seed=1) == samples[0]) def test_get_bounds_parameters(self): assert self.matern52_.get_bounds_parameters() == 3 * [ (SMALLEST_NUMBER, LARGEST_NUMBER) ] def test_update_value_parameters(self): self.matern52_.update_value_parameters(np.array([1, 5, 10])) assert self.matern52_.sigma2.value == np.array([10]) parameters = self.matern52_.hypers assert np.all(parameters[LENGTH_SCALE_NAME].value == np.array([1, 5])) def test_define_default_kernel(self): kern1 = Matern52.define_default_kernel(1) assert kern1.name == MATERN52_NAME assert kern1.dimension == 1 assert kern1.dimension_parameters == 1 assert kern1.length_scale.value == np.array([1]) assert kern1.length_scale.prior.max == [LARGEST_NUMBER] assert kern1.length_scale.prior.min == [SMALLEST_POSITIVE_NUMBER] kern2 = Matern52.define_default_kernel(1, default_values=np.array([5])) assert kern2.name == MATERN52_NAME assert kern2.dimension == 1 assert kern2.dimension_parameters == 1 assert kern2.length_scale.value == np.array([5]) assert kern2.length_scale.prior.max == [LARGEST_NUMBER] assert kern2.length_scale.prior.min == [SMALLEST_POSITIVE_NUMBER] kern3 = Matern52.define_default_kernel(1, bounds=[[5, 6]]) assert kern3.name == MATERN52_NAME assert kern3.dimension == 1 assert kern3.dimension_parameters == 1 assert kern3.length_scale.value == np.array([1]) assert kern3.length_scale.prior.max == [20.0] assert kern3.length_scale.prior.min == [SMALLEST_POSITIVE_NUMBER] def test_compare_kernels(self): kernel = Matern52.define_kernel_from_array(1, np.ones(1)) kernel_ = copy.deepcopy(kernel) kernel_.name = 'a' assert Matern52.compare_kernels(kernel, kernel_) is False kernel_ = copy.deepcopy(kernel) kernel_.dimension = 2 assert Matern52.compare_kernels(kernel, kernel_) is False kernel_ = copy.deepcopy(kernel) kernel_.dimension_parameters = 5 assert Matern52.compare_kernels(kernel, kernel_) is False kernel_ = copy.deepcopy(kernel) kernel_.length_scale.value = np.array([-1]) assert Matern52.compare_kernels(kernel, kernel_) is False def test_define_prior_parameters(self): data = { 'points': np.array([[1]]), 'evaluations': np.array([1]), 'var_noise': None, } dimension = 1 result = Matern52.define_prior_parameters(data, dimension) assert result == { LENGTH_SCALE_NAME: [0.0], } data2 = { 'points': np.array([[1], [2]]), 'evaluations': np.array([1, 2]), 'var_noise': None, } dimension2 = 1 result2 = Matern52.define_prior_parameters(data2, dimension2) assert result2 == { LENGTH_SCALE_NAME: [1.5432098765432098], } def test_evaluate_grad_respect_point(self): result = Matern52.evaluate_grad_respect_point(np.array([5.0]), np.array([[1]]), np.array([[4], [5]]), 1) kernel = Matern52.define_kernel_from_array(1, np.array([5.0])) assert np.all(result == kernel.grad_respect_point( np.array([[1]]), np.array([[4], [5]]))) def test_evaluate_hessian_respect_point(self): point = np.array([[4.5, 7.5]]) inputs = np.array([[5.0, 6.0], [8.0, 9.0]]) params = np.array([1.0, 5.0]) result = Matern52.evaluate_hessian_respect_point( params, point, inputs, 2) dh = 0.00001 finite_diff = FiniteDifferences.second_order_central( lambda x: Matern52.evaluate_cross_cov_defined_by_params( params, x.reshape((1, len(x))), inputs, 2), point[0, :], np.array([dh])) for i in xrange(2): for j in xrange(2): print i, j npt.assert_almost_equal( finite_diff[i, j], np.array([[result[0, i, j], result[1, i, j]]]), decimal=5) def test_hessian_distance_length_scale_respect_point(self): params = np.array([1.0, 5.0]) point = np.array([[4.5, 7.5]]) inputs = np.array([[5.0, 6.0], [8.0, 9.0]]) result = Distances.gradient_distance_length_scale_respect_point( params, point, inputs, second=True) result = result['second'] dh = 0.00001 finite_diff = FiniteDifferences.second_order_central( lambda x: np.sqrt( Distances.dist_square_length_scale( params, x.reshape((1, len(x))), inputs)), point[0, :], np.array([dh])) for i in xrange(2): for j in xrange(2): print i, j npt.assert_almost_equal( finite_diff[i, j], np.array([[result[0, i, j], result[1, i, j]]]), decimal=5)
def get_kernel_default(kernel_name, dimension, bounds=None, default_values=None, parameters_priors=None, **kernel_parameters): """ Returns a default kernel object associated to the kernel_name :param kernel_name: [str] :param dimension: [int]. It's the number of tasks for the task kernel. :param bounds: [[float, float]], lower bound and upper bound for each entry. This parameter is to compute priors in a smart way. :param default_values: np.array(k), default values for the parameters of the kernel :param parameters_priors: { SIGMA2_NAME: float, LENGTH_SCALE_NAME: [float], LOWER_TRIANG_NAME: [float], } :param kernel_parameters: additional kernel parameters, - SAME_CORRELATION: (boolean) True or False. Parameter used only for task kernel. :return: kernel object """ if kernel_name[0] == SCALED_KERNEL: if kernel_name[1] == MATERN52_NAME: return ScaledKernel.define_default_kernel(dimension[0], bounds, default_values, parameters_priors, *([MATERN52_NAME], )) if kernel_name[0] == MATERN52_NAME: return Matern52.define_default_kernel(dimension[0], bounds, default_values, parameters_priors) if kernel_name[0] == TASKS_KERNEL_NAME: return TasksKernel.define_default_kernel(dimension[0], bounds, default_values, parameters_priors, **kernel_parameters) if kernel_name[0] == PRODUCT_KERNELS_SEPARABLE: values = [] cont = 0 bounds_ = [] cont_b = 0 for name, dim in zip(kernel_name[1:], dimension[1:]): n_params = get_number_parameters_kernel([name], [dim], **kernel_parameters) if default_values is not None: value_kernel = default_values[cont:cont + n_params] else: value_kernel = None if bounds is not None: if name == MATERN52_NAME: bounds_.append(bounds[cont_b:cont_b + dim]) cont_b += dim if name == TASKS_KERNEL_NAME: bounds_.append(bounds[cont_b:cont_b + 1]) cont_b += 1 cont += n_params values.append(value_kernel) if len(bounds_) > 0: bounds = bounds_ return ProductKernels.define_default_kernel(dimension[1:], bounds, values, parameters_priors, kernel_name[1:], **kernel_parameters)
def define_prior_parameters_using_data(data, type_kernel, dimensions, sigma2=None, **kernel_parameters): """ Defines value of the parameters of the prior distributions of the kernel's parameters. :param data: {'points': np.array(nxm), 'evaluations': np.array(n), 'var_noise': np.array(n) or None} :param type_kernel: [str] :param dimensions: [int], It has only the n_tasks for the task_kernels, and for the PRODUCT_KERNELS_SEPARABLE contains the dimensions of every kernel in the product, and the total dimension of the product_kernels_separable too in the first entry. :param: sigma2: float :param kernel_parameters: additional kernel parameters, - SAME_CORRELATION: (boolean) True or False. Parameter used only for task kernel. :return: { SIGMA2_NAME: float, LENGTH_SCALE_NAME: [float], LOWER_TRIANG_NAME: [float], } """ # We assume that there is at most one task kernel, and mattern52 kernel in the product. parameters_priors = { SIGMA2_NAME: None, LENGTH_SCALE_NAME: None, LOWER_TRIANG_NAME: None, } index = 1 if TASKS_KERNEL_NAME in type_kernel: same_correlation = kernel_parameters.get(SAME_CORRELATION, False) index = type_kernel.index(TASKS_KERNEL_NAME) index_tasks = 0 for i in xrange(1, index): index_tasks += dimensions[i] n_tasks = dimensions[index] if n_tasks > 1: tasks_index = data['points'][:, index_tasks] task_data = data.copy() task_data['points'] = tasks_index.reshape((len(tasks_index), 1)) else: task_data = None task_parameters = TasksKernel.define_prior_parameters( task_data, n_tasks, same_correlation=same_correlation, var_evaluations=sigma2) parameters_priors[LOWER_TRIANG_NAME] = task_parameters[ LOWER_TRIANG_NAME] if MATERN52_NAME in type_kernel: m = data['points'].shape[1] indexes = [i for i in range(m) if i != m - index + 1] points_matern = data['points'][:, indexes] matern_data = data.copy() matern_data['points'] = points_matern matern52_parameters = Matern52.define_prior_parameters( matern_data, len(indexes)) parameters_priors[LENGTH_SCALE_NAME] = matern52_parameters[ LENGTH_SCALE_NAME] if SCALED_KERNEL in type_kernel: parameters = \ ScaledKernel.define_prior_parameters(data, len(indexes), var_evaluations=sigma2) parameters_priors[SIGMA2_NAME] = parameters[SIGMA2_NAME] return parameters_priors