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_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_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_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_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_cross_validation_mle_parameters_2(self): type_kernel = [MATERN52_NAME] np.random.seed(5) n_points = 10 normal_noise = np.random.normal(0, 0.01, n_points) points = np.linspace(0, 100, n_points) points = points.reshape([n_points, 1]) kernel = Matern52.define_kernel_from_array(1, np.array([100.0])) function = SampleFunctions.sample_from_gp(points, kernel) function = function[0, :] evaluations = function + normal_noise training_data = { "evaluations": evaluations, "points": points, "var_noise": None} dimensions = [1] problem_name = 'a' result = \ ValidationGPModel.cross_validation_mle_parameters(type_kernel, training_data, dimensions, problem_name, start=np.array([-1])) assert result['success_proportion'] == -1
def test_cross_validation_mle_parameters(self): type_kernel = [MATERN52_NAME] np.random.seed(5) n_points = 10 normal_noise = np.random.normal(0, 0.01, n_points) points = np.linspace(0, 100, n_points) points = points.reshape([n_points, 1]) kernel = Matern52.define_kernel_from_array(1, np.array([100.0])) function = SampleFunctions.sample_from_gp(points, kernel) function = function[0, :] evaluations = function + normal_noise training_data = { "evaluations": evaluations, "points": points, "var_noise": None} dimensions = [1] problem_name = 'a' result = \ ValidationGPModel.cross_validation_mle_parameters(type_kernel, training_data, dimensions, problem_name, start=np.array([0.01**2, 0.0, 100.0])) compare = 'results/diagnostic_kernel/a/validation_kernel_histogram_a_' + MATERN52_NAME + \ '_same_correlation_False_10_None.png' assert result['filename_histogram'] == compare assert np.all(result['y_eval'] == evaluations) assert result['n_data'] == n_points assert result['filename_plot'] == 'results/diagnostic_kernel/a/' \ 'validation_kernel_mean_vs_observations_a_' + \ MATERN52_NAME + '_same_correlation_False_10_None' + '.png' assert result['success_proportion'] >= 0.9 noise = np.random.normal(0, 0.000001, n_points) evaluations_noisy = evaluations + noise training_data_2 = { "evaluations": evaluations_noisy, "points": points, "var_noise": np.array(n_points * [0.000001**2])} result_2 = \ ValidationGPModel.cross_validation_mle_parameters(type_kernel, training_data_2, dimensions, problem_name, start=np.array([0.01**2, 0.0, 100.0])) compare = 'results/diagnostic_kernel/a/validation_kernel_histogram_a_' + MATERN52_NAME + \ '_same_correlation_False_10_None.png' assert result_2['filename_histogram'] == compare assert np.all(result_2['y_eval'] == evaluations_noisy) assert result_2['n_data'] == n_points compare = 'results/diagnostic_kernel/a/validation_kernel_mean_vs_observations_a_' + \ MATERN52_NAME + '_same_correlation_False_10_None.png' assert result_2['filename_plot'] == compare assert result_2['success_proportion'] >= 0.9
def test_sample_new_observations(self): np.random.seed(5) n_points = 10 normal_noise = np.random.normal(0, 0.5, n_points) points = np.linspace(0, 500, n_points) points = points.reshape([n_points, 1]) kernel = Matern52.define_kernel_from_array(1, np.array([100.0, 1.0])) function = SampleFunctions.sample_from_gp(points, kernel) function = function[0, :] evaluations = function + normal_noise training_data_gp = { "evaluations": list(evaluations[1:]), "points": points[1:, :], "var_noise": []} gp = GPFittingGaussian([MATERN52_NAME], training_data_gp, [1], kernel_values=[100.0, 1.0], mean_value=[0.0], var_noise_value=[0.5**2]) n_samples = 100 samples = gp.sample_new_observations(np.array([[30.0]]), n_samples, random_seed=1) new_point = np.array([[30.0]]) z = gp.compute_posterior_parameters(new_point) mean = z['mean'] cov = z['cov'] npt.assert_almost_equal(mean, np.mean(samples), decimal=1) npt.assert_almost_equal(cov, np.var(samples), decimal=1)
def test_compute_posterior_parameters(self): np.random.seed(5) n_points = 10 normal_noise = np.random.normal(0, 0.5, n_points) points = np.linspace(0, 500, n_points) points = points.reshape([n_points, 1]) kernel = Matern52.define_kernel_from_array(1, np.array([100.0, 1.0])) function = SampleFunctions.sample_from_gp(points, kernel) function = function[0, :] evaluations = function + normal_noise training_data_gp = { "evaluations": list(evaluations[1:]), "points": points[1:, :], "var_noise": []} gp = GPFittingGaussian([MATERN52_NAME], training_data_gp, [1], kernel_values=[100.0, 1.0], mean_value=[0.0], var_noise_value=[0.5**2]) new_point = np.array([points[0], points[1]]) z = gp.compute_posterior_parameters(new_point) mean = z['mean'] cov = z['cov'] assert mean[1] - 2.0 * np.sqrt(cov[1, 1]) <= function[1] assert function[1] <= mean[1] + 2.0 * np.sqrt(cov[1, 1]) assert mean[0] - 2.0 * np.sqrt(cov[0, 0]) <= function[0] assert function[0] <= mean[0] + 2.0 * np.sqrt(cov[0, 0]) # Values obtained from GPy npt.assert_almost_equal(mean, np.array([0.30891226, 0.60256237])) npt.assert_almost_equal(cov, np.array([[0.48844879, 0.16799927], [0.16799927, 0.16536313]]))
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_forward_difference(self): result = FiniteDifferences.forward_difference(self.f, self.x, self.h) base_eval = \ Matern52.evaluate_cov_defined_by_params(self.x, np.array([[2.0, 0.0], [0.0, 2.0]]), 2) for i in result: new_x = deepcopy(self.x) new_x[i] += self.h[0] new_eval = \ Matern52.evaluate_cov_defined_by_params( new_x, np.array([[2.0, 0.0], [0.0, 2.0]]), 2) for j in range(2): for h in range(2): assert result[i][j, h] == (new_eval[j, h] - base_eval[j, h]) / self.h[0]
def setUp(self): np.random.seed(5) n_points = 100 points = np.linspace(0, 100, n_points) points = points.reshape([n_points, 1]) tasks = np.random.randint(2, size=(n_points, 1)) add = [-10, 10] kernel = Matern52.define_kernel_from_array(1, np.array([100.0, 1.0])) function = SampleFunctions.sample_from_gp(points, kernel) self.function = function for i in xrange(n_points): function[0, i] += add[tasks[i, 0]] points = np.concatenate((points, tasks), axis=1) self.points = points self.evaluations = function[0, :] function = function[0, :] training_data = { 'evaluations': list(function), 'points': points, "var_noise": [], } gaussian_p = GPFittingGaussian( [PRODUCT_KERNELS_SEPARABLE, MATERN52_NAME, TASKS_KERNEL_NAME], training_data, [2, 1, 2], bounds_domain=[[0, 100], [0, 1]], type_bounds=[0, 1]) gaussian_p = gaussian_p.fit_gp_regression(random_seed=1314938) quadrature = BayesianQuadrature(gaussian_p, [0], UNIFORM_FINITE, parameters_distribution={TASKS: 2}, model_only_x=True) self.mt = MultiTasks(quadrature, quadrature.parameters_distribution.get(TASKS))
def test_train(self): np.random.seed(5) n_points = 10 normal_noise = np.random.normal(0, 0.5, n_points) points = np.linspace(0, 500, n_points) points = points.reshape([n_points, 1]) kernel = Matern52.define_kernel_from_array(1, np.array([100.0, 1.0])) function = SampleFunctions.sample_from_gp(points, kernel) function = function[0, :] evaluations = function + normal_noise training_data_gp = { "evaluations": list(evaluations), "points": points, "var_noise": []} new_gp = GPFittingGaussian.train([MATERN52_NAME], [1], True, training_data_gp, None, random_seed=1314938) gp_gaussian = GPFittingGaussian([MATERN52_NAME], training_data_gp, [1]) gp_2 = gp_gaussian.fit_gp_regression(random_seed=1314938) npt.assert_almost_equal(new_gp.var_noise.value[0], gp_2.var_noise.value[0], decimal=6) npt.assert_almost_equal(new_gp.mean.value[0], gp_2.mean.value[0], decimal=6) npt.assert_almost_equal(new_gp.kernel_values, gp_2.kernel_values) gp_gaussian = GPFittingGaussian([MATERN52_NAME], training_data_gp, [1]) new_gp_2 = GPFittingGaussian.train([MATERN52_NAME], [1], False, training_data_gp, None) npt.assert_almost_equal(new_gp_2.var_noise.value[0], gp_gaussian.var_noise.value[0]) npt.assert_almost_equal(new_gp_2.mean.value[0], gp_gaussian.mean.value[0], decimal=6) npt.assert_almost_equal(new_gp_2.kernel_values, gp_gaussian.kernel_values)
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], 'kernels': [str], SAME_CORRELATION: (boolean), } :return: { PARAM_NAME: [float] or float } """ parameters = {} for dim, kernel in zip(kwargs['dimensions'], kwargs['kernels']): if kernel == MATERN52_NAME: n_params = get_number_parameters_kernel([kernel], [dim]) param_dict = Matern52.parameters_from_list_to_dict( params[0:n_params]) params = params[n_params:] parameters.update(param_dict) elif kernel == TASKS_KERNEL_NAME: n_params = get_number_parameters_kernel([kernel], [dim], **kwargs) param_dict = TasksKernel.parameters_from_list_to_dict( params[0:n_params]) params = params[n_params:] parameters.update(param_dict) return parameters
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_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_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_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 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_get_kernel_default(self): kernel_name = [MATERN52_NAME] dimension = [2] kernel = get_kernel_default(kernel_name, dimension) kernel_ = Matern52.define_kernel_from_array(2, np.ones(3)) assert Matern52.compare_kernels(kernel, kernel_) kernel_name = [TASKS_KERNEL_NAME] dimension = [1] kernel = get_kernel_default(kernel_name, dimension) kernel_ = TasksKernel.define_kernel_from_array(1, np.array([0])) assert TasksKernel.compare_kernels(kernel, kernel_) kernel_name = [PRODUCT_KERNELS_SEPARABLE, MATERN52_NAME, TASKS_KERNEL_NAME] dimension = [2, 1, 1] kernel = get_kernel_default(kernel_name, dimension) kernel_ = ProductKernels.define_kernel_from_array([1, 1], [np.array([1]), np.array([0])], [MATERN52_NAME, TASKS_KERNEL_NAME]) assert ProductKernels.compare_kernels(kernel, kernel_) kernel = get_kernel_default(kernel_name, dimension, default_values=np.array([1, 0])) assert ProductKernels.compare_kernels(kernel, kernel_) assert kernel.parameters[MATERN52_NAME][LENGTH_SCALE_NAME].prior.max == [LARGEST_NUMBER] compare = kernel.parameters[MATERN52_NAME][LENGTH_SCALE_NAME].prior.min assert compare == SMALLEST_POSITIVE_NUMBER kernel = get_kernel_default(kernel_name, dimension, default_values=np.array([1, 0]), bounds=[[-1, 2]]) assert ProductKernels.compare_kernels(kernel, kernel_) assert kernel.parameters[MATERN52_NAME][LENGTH_SCALE_NAME].prior.max == 60.0 compare = kernel.parameters[MATERN52_NAME][LENGTH_SCALE_NAME].prior.min assert compare == SMALLEST_POSITIVE_NUMBER
def test_optimize_posterior_mean_samples(self): np.random.seed(5) n_points = 100 points = np.linspace(0, 100, n_points) points = points.reshape([n_points, 1]) tasks = np.random.randint(2, size=(n_points, 1)) add = [10, -10] kernel = Matern52.define_kernel_from_array(1, np.array([100.0, 1.0])) function = SampleFunctions.sample_from_gp(points, kernel) max_value = function[0, np.argmax(function)] max_point = points[np.argmax(function), 0] for i in xrange(n_points): function[0, i] += add[tasks[i, 0]] points = np.concatenate((points, tasks), axis=1) function = function[0, :] training_data = { 'evaluations': list(function), 'points': points, "var_noise": [], } gaussian_p = GPFittingGaussian( [PRODUCT_KERNELS_SEPARABLE, MATERN52_NAME, TASKS_KERNEL_NAME], training_data, [2, 1, 2], bounds_domain=[[0, 100]], max_steps_out=1000) gaussian_p = gaussian_p.fit_gp_regression(random_seed=1314938) gp = BayesianQuadrature(gaussian_p, [0], UNIFORM_FINITE, {TASKS: 2}) random_seed = 10 n_samples_parameters = 15 gp.gp.thinning = 10 gp.gp.n_burning = 500 sol_2 = gp.optimize_posterior_mean( random_seed=random_seed, n_best_restarts=2, n_samples_parameters=n_samples_parameters, start_new_chain=True) assert max_point == sol_2['solution'] npt.assert_almost_equal(max_value, sol_2['optimal_value'], decimal=3)
def test_gradient_vector_b(self): np.random.seed(5) n_points = 10 points = np.linspace(0, 100, n_points) points = points.reshape([n_points, 1]) tasks = np.random.randint(2, size=(n_points, 1)) add = [10, -10] kernel = Matern52.define_kernel_from_array(1, np.array([100.0, 1.0])) function = SampleFunctions.sample_from_gp(points, kernel) for i in xrange(n_points): function[0, i] += add[tasks[i, 0]] points = np.concatenate((points, tasks), axis=1) function = function[0, :] training_data = { 'evaluations': list(function), 'points': points, "var_noise": [], } gaussian_p = GPFittingGaussian( [PRODUCT_KERNELS_SEPARABLE, MATERN52_NAME, TASKS_KERNEL_NAME], training_data, [2, 1, 2], bounds_domain=[[0, 100]]) gaussian_p = gaussian_p.fit_gp_regression(random_seed=1314938) gp = BayesianQuadrature(gaussian_p, [0], UNIFORM_FINITE, {TASKS: 2}) # gp = self.gp_complete candidate_point = np.array([[84.0, 1]]) points = np.array([[99.5], [12.1], [70.2]]) value = gp.gradient_vector_b(candidate_point, points, cache=False) dh_ = 0.0000001 dh = [dh_] finite_diff = FiniteDifferences.forward_difference( lambda point: gp.compute_posterior_parameters_kg( points, point.reshape((1, len(point))), cache=False)['b'], candidate_point[0, :], np.array(dh)) npt.assert_almost_equal(finite_diff[0], value[:, 0], decimal=5) assert np.all(finite_diff[1] == value[:, 1]) value_2 = gp.gradient_vector_b(candidate_point, points, cache=True) assert np.all(value_2 == value)
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_mle_parameters(self): # Results compared with the ones given by GPy np.random.seed(1) add = -45.946926660233636 llh = self.gp_gaussian.log_likelihood(1.0, 0.0, np.array([100.0, 1.0])) npt.assert_almost_equal(llh + add, -59.8285565516, decimal=6) opt = self.gp_gaussian.mle_parameters(start=np.array([1.0, 0.0, 14.0, 0.9])) assert opt['optimal_value'] + add >= -67.1494227694 compare = self.gp_gaussian.log_likelihood(9, 10.0, np.array([100.2, 1.1])) assert self.gp_gaussian_central.log_likelihood(9, 0.0, np.array([100.2, 1.1])) == compare np.random.seed(5) n_points = 10 normal_noise = np.random.normal(0, 0.5, n_points) points = np.linspace(0, 500, n_points) points = points.reshape([n_points, 1]) kernel = Matern52.define_kernel_from_array(1, np.array([100.0, 1.0])) function = SampleFunctions.sample_from_gp(points, kernel) function = function[0, :] evaluations = function + normal_noise training_data_gp = { "evaluations": list(evaluations), "points": points, "var_noise": []} gp_gaussian = GPFittingGaussian([MATERN52_NAME], training_data_gp, [1]) opt_3 = gp_gaussian.mle_parameters(random_seed=1314938) np.random.seed(1314938) start = gp_gaussian.sample_parameters_posterior(1)[0, :] opt_4 = gp_gaussian.mle_parameters(start) npt.assert_almost_equal(opt_3['optimal_value'], opt_4['optimal_value']) npt.assert_almost_equal(opt_3['solution'], opt_4['solution'], decimal=4)
def setUp(self): np.random.seed(2) n_points = 50 points = np.linspace(0, 500, n_points) points = points.reshape([n_points, 1]) kernel = Matern52.define_kernel_from_array(1, np.array([100.0, 1.0])) self.cov = kernel.cov(points) self.cov_2 = np.array( [[3.76518160e-02, 8.35508788e-03, 2.26375310e-03, 4.81839112e-02, 1.19018900e-02], [8.35508788e-03, 3.76518160e-02, 4.65867508e-05, 2.23451418e-03, 3.20904593e-04], [2.26375310e-03, 4.65867508e-05, 3.76518160e-02, 8.45452922e-03, 3.79688244e-02], [4.81839112e-02, 2.23451418e-03, 8.45452922e-03, 3.76518160e-02, 3.53194132e-02], [1.19018900e-02, 3.20904593e-04, 3.79688244e-02, 3.53194132e-02, 3.76518160e-02]]) self.cov_ = np.array( [[1.04681851e+00, 9.95986475e-02, 2.71028578e-02, 5.70675240e-01, 1.41705272e-01], [9.95986475e-02, 1.04681851e+00, 5.64490356e-04, 2.67539188e-02, 3.86574119e-03], [2.71028578e-02, 5.64490356e-04, 1.04681851e+00, 1.00779972e-01, 4.50126283e-01], [5.70675240e-01, 2.67539188e-02, 1.00779972e-01, 1.04681851e+00, 4.18836616e-01], [1.41705272e-01, 3.86574119e-03, 4.50126283e-01, 4.18836616e-01, 1.04681851e+00]])
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_sample_from_gp(self): x = np.linspace(0, 10, 50) x = x.reshape([50, 1]) kernel = Matern52.define_kernel_from_array(1, np.array([3.0, 5.0])) function = SampleFunctions.sample_from_gp(x, kernel, n_samples=100000) mean = np.mean(function, axis=0) cov = np.cov(function.transpose()) cov_ = kernel.cov(x) npt.assert_almost_equal(mean, np.zeros(len(mean)), decimal=1) npt.assert_almost_equal(cov, cov_, decimal=1) function_2 = SampleFunctions.sample_from_gp(x, kernel, n_samples=100000, random_seed=10) mean = np.mean(function_2, axis=0) cov = np.cov(function_2.transpose()) cov_ = kernel.cov(x) npt.assert_almost_equal(mean, np.zeros(len(mean)), decimal=1) npt.assert_almost_equal(cov, cov_, decimal=1)
def compare_kernels(kernel1, kernel2): """ Compare the values of kernel1 and kernel2. Returns True if they're equal, otherwise it return False. :param kernel1: ProductKernels instance object :param kernel2: ProductKernels 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.names != kernel2.names: return False for i in xrange(len(kernel1.names)): name1 = kernel1.names[i] kernel_1 = kernel1.kernels[name1] kernel_2 = kernel2.kernels[name1] if name1 == MATERN52_NAME: if Matern52.compare_kernels(kernel_1, kernel_2) is False: return False if name1 == TASKS_KERNEL_NAME: if TasksKernel.compare_kernels(kernel_1, kernel_2) is False: return False return True
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]]))