def setUp(self): self.se0 = Covariance(RBF(1, active_dims=[0])) self.se1 = Covariance(RBF(1, active_dims=[1])) self.se2 = Covariance(RBF(1, active_dims=[2])) self.rq0 = Covariance(RationalQuadratic(1, active_dims=[0])) self.rq1 = Covariance(RationalQuadratic(1, active_dims=[1])) self.rq2 = Covariance(RationalQuadratic(1, active_dims=[2])) self.lin0 = Covariance(LinScaleShift(1, active_dims=[0]))
def test_encode_gp_models(self): gp_models = [GPModel(Covariance(RBF(1))), GPModel(Covariance(RationalQuadratic(1)))] result = encode_gp_models(gp_models) self.assertIsInstance(result, np.ndarray) self.assertEqual(result.shape, (len(gp_models), 1)) self.assertListEqual(result[0][0], [encode_kernel(gp_models[0].covariance.raw_kernel), [None]]) self.assertListEqual(result[1][0], [encode_kernel(gp_models[1].covariance.raw_kernel), [None]]) gp_models = [GPModel(Covariance(RBF(1) * RBF(1))), GPModel(Covariance(RationalQuadratic(1)))] result = encode_gp_models(gp_models) self.assertIsInstance(result, np.ndarray) self.assertEqual(result.shape, (len(gp_models), 1)) self.assertListEqual(result[0][0], [encode_kernel(gp_models[0].covariance.raw_kernel), [None]]) self.assertListEqual(result[1][0], [encode_kernel(gp_models[1].covariance.raw_kernel), [None]])
def setUp(self) -> None: self.x = np.array([[1, 2], [4, 5], [6, 7], [8, 9], [10, 11]]) self.noise_prior = Gaussian(mu=np.log(0.01), sigma=1) cov_1 = Covariance(RBF(1)) p1 = LogGaussian(20, 1) p2 = LogGaussian(0, 1.1) cov_1.raw_kernel.variance.set_prior(p1, warning=False) cov_1.raw_kernel.lengthscale.set_prior(p2, warning=False) cov_2 = Covariance(RBF(1)) p3 = LogGaussian(11, 1) p4 = LogGaussian(1, 1.21) cov_2.raw_kernel.variance.set_prior(p3, warning=False) cov_2.raw_kernel.lengthscale.set_prior(p4, warning=False) cov_3 = Covariance(RationalQuadratic(1)) p5 = LogGaussian(4, 1) p6 = LogGaussian(1.2, 1.21) p7 = LogGaussian(13, 1.21) cov_3.raw_kernel.variance.set_prior(p5, warning=False) cov_3.raw_kernel.lengthscale.set_prior(p6, warning=False) cov_3.raw_kernel.power.set_prior(p7, warning=False) models = [GPModel(cov_1), GPModel(cov_2), GPModel(cov_3)] self.active_models = ActiveSet(max_n_models=3) self.active_models.models = models self.ind_init = [0, 2]
def test_tokens_to_kernel_symbols(self): k1 = RBF(1) k2 = RationalQuadratic(1) kernel_tokens = [k1, '+', k2] actual = tokens_to_kernel_symbols(kernel_tokens) expected = [KernelSymbol('SE_1', k1), '+', KernelSymbol('RQ_1', k2)] self.assertListEqual(expected, actual)
def test_hellinger_distance(self): cov_i = Covariance(RBF(1)) p1 = LogGaussian(20, 1) p2 = LogGaussian(0, 1.1) cov_i.raw_kernel.variance.set_prior(p1, warning=False) cov_i.raw_kernel.lengthscale.set_prior(p2, warning=False) cov_j = Covariance(RationalQuadratic(1)) p3 = LogGaussian(11, 2) p4 = LogGaussian(2, 1.12) cov_j.raw_kernel.variance.set_prior(p3, warning=False) cov_j.raw_kernel.lengthscale.set_prior(p4, warning=False) cov_j.raw_kernel.power.set_prior(p2, warning=False) x = np.array([[1, 2], [4, 5], [6, 7], [8, 9], [10, 11]]) noise_prior = Gaussian(mu=np.log(0.01), sigma=1) builder = HellingerDistanceBuilder(noise_prior, num_samples=20, max_num_hyperparameters=40, max_num_kernels=10, active_models=MagicMock(), initial_model_indices=MagicMock(), data_X=x) log_det_i, mini_gram_matrices_i = builder.create_precomputed_info( cov_i, x) log_det_j, mini_gram_matrices_j = builder.create_precomputed_info( cov_j, x) result = HellingerDistanceBuilder.hellinger_distance( log_det_i, mini_gram_matrices_i, log_det_j, mini_gram_matrices_j) self.assertIsInstance(result, float)
def test_propose_new_models(self, mock_get_candidates): expected = [ Covariance(RBF(1)), Covariance(RationalQuadratic(1)), Covariance(RBF(1) + RationalQuadratic(1)), Covariance(RBF(1) * RationalQuadratic(1)) ] mock_get_candidates.return_value = expected pop = ActiveModelPopulation() pop.update(self.gp_models) actual = self.model_selector._propose_new_models(pop, callbacks=MagicMock()) self.assertIsInstance(actual, list) self.assertEqual(len(expected), len(actual)) for expected_cov, actual_cov in zip(expected, actual): self.assertEqual(expected_cov.infix, actual_cov.covariance.infix)
def test_save(self): kernel = Covariance(RBF(1) * RBF(1) + RationalQuadratic(1)) gp_model = GPModel(kernel) file_name = "test_save" out_fname = gp_model.save(file_name) self.addCleanup(os.remove, out_fname)
def test_shd_metric(self): gp_models = [ GPModel(Covariance(RBF(1) + RationalQuadratic(1))), GPModel(Covariance(RBF(1))) ] data = encode_gp_models(gp_models) u, v = data[0], data[1] result = shd_metric(u, v) self.assertEqual(result, 1)
def test_get_index_to_insert_full_no_priority(self): # add five models self.active_set.add_model(GPModel(Covariance(RBF(1)))) self.active_set.add_model(GPModel(Covariance(RationalQuadratic(1)))) self.active_set.add_model(GPModel(Covariance(StandardPeriodic(1)))) self.active_set.add_model(GPModel(Covariance(LinScaleShift(1)))) self.active_set.add_model(GPModel(Covariance(RBF(1) + RBF(1)))) self.assertRaises(ValueError, self.active_set.get_index_to_insert)
def test_get_new_candidate_with_default(self): candidates = [GPModel(Covariance(RBF(1)))] self.active_set.update(candidates) new_model = GPModel(Covariance(RationalQuadratic(1))) default = 2 actual = self.active_set.get(new_model, default) self.assertIsInstance(actual, int) expected_ind = default self.assertEqual(expected_ind, actual)
def test_update_exceed_max_no_remove(self): candidates = [ GPModel(Covariance(RBF(1))), GPModel(Covariance(RationalQuadratic(1))), GPModel(Covariance(LinScaleShift(1))), GPModel(Covariance(StandardPeriodic(1))), GPModel(Covariance(RBF(1) + RBF(1))), GPModel(Covariance(RBF(1) * RBF(1))) ] self.assertRaises(ValueError, self.active_set.update, candidates)
def test_from_dict(self): test_cases = (GPModel, Serializable) for cls in test_cases: with self.subTest(name=cls.__name__): kernel = Covariance(RBF(1) * RBF(1) + RationalQuadratic(1)) gp_model = GPModel(kernel) actual = cls.from_dict(gp_model.to_dict()) self.assertIsInstance(actual, GPModel) self.assertEqual(gp_model.likelihood, actual.likelihood) self.assertEqual(gp_model.covariance.infix, actual.covariance.infix)
def test_load(self): kernel = Covariance(RBF(1) * RBF(1) + RationalQuadratic(1)) gp_model = GPModel(kernel) file_name = "test_save" out_file_name = gp_model.save(file_name) self.addCleanup(os.remove, out_file_name) new_gp_model = GPModel.load(out_file_name) self.assertIsInstance(new_gp_model, GPModel) self.assertEqual(gp_model.covariance.infix, new_gp_model.covariance.infix)
def test_euclidean_metric(self): x_train = np.array([[1, 2], [3, 4]]) gp_models = [ GPModel(Covariance(RBF(1) + RationalQuadratic(1))), GPModel(Covariance(RBF(1))) ] data = encode_gp_models(gp_models) u, v = data[0], data[1] result = euclidean_metric(u, v, get_x_train=lambda: x_train) self.assertIsInstance(result, float) self.assertAlmostEqual( result, np.linalg.norm( gp_models[0].covariance.raw_kernel.K(x_train, x_train) - gp_models[1].covariance.raw_kernel.K(x_train, x_train)))
def test_update_empty(self): candidates = [ GPModel(Covariance(RBF(1))), GPModel(Covariance(RationalQuadratic(1))) ] expected_candidates_ind = [0, 1] new_candidates_ind = self.active_set.update(candidates) self.assertEqual(expected_candidates_ind, new_candidates_ind) expected_models = [candidates[0], candidates[1], None, None, None] self.assertListEqual(expected_models, self.active_set.models) expected_next_ind = 2 self.assertEqual(expected_next_ind, self.active_set.get_index_to_insert())
def setUp(self): self.gp_models = [ GPModel(Covariance(RationalQuadratic(1))), GPModel(Covariance(RBF(1) + RBF(1))), GPModel(Covariance(RBF(1))) ] grammar = GeometricRandomGrammar() grammar.build(n_dims=1) fitness_fn = 'nbic' self.x_train = np.array([[1, 2, 3], [4, 5, 6]]) self.y_train = np.array([[5], [10]]) self.x_test = np.array([[10, 20, 30], [40, 50, 60]]) self.y_test = np.array([[2], [1]]) self.model_selector = ModelSelector(grammar, fitness_fn)
def setUp(self): self.gp_models = [ GPModel(Covariance(RationalQuadratic(1))), GPModel(Covariance(RBF(1) + RBF(1))), GPModel(Covariance(RBF(1))) ] grammar = MagicMock() kernel_selector = MagicMock() objective = MagicMock() self.x_train = np.array([[1, 2, 3], [4, 5, 6]]) self.y_train = np.array([[5], [10]]) self.x_test = np.array([[10, 20, 30], [40, 50, 60]]) self.y_test = np.array([[2], [1]]) self.model_selector = BomsModelSelector(grammar, kernel_selector, objective)
def test_get_priors(self): # Test assertRaises ValueError if not all parameters have priors set c = RBF(1) self.assertRaises(ValueError, get_priors, c) c = RBF(1) * RationalQuadratic(1) p1 = LogGaussian(2, 2.21) p2 = LogGaussian(1, 2.1) p3 = LogGaussian(1, 2) c.parameters[0].variance.set_prior(p1, warning=False) c.parameters[1].lengthscale.set_prior(p2, warning=False) c.parameters[0].lengthscale.set_prior(p3, warning=False) c.parameters[1].power.set_prior(p2, warning=False) c.parameters[1].variance.set_prior(p1, warning=False) result = get_priors(c) self.assertIsInstance(result, np.ndarray) self.assertEqual(result.shape, (5, )) np.testing.assert_array_equal(result, [p1, p3, p1, p2, p2])
def test_additive_part_to_vec(self): base_kernels = ['SE', 'RQ'] n_dims = 2 k = RBF(1) + RBF(1) self.assertRaises(TypeError, additive_part_to_vec, k, base_kernels, n_dims) k = RBF(1) result = additive_part_to_vec(k, base_kernels=base_kernels, n_dims=2) np.testing.assert_array_equal(result, np.array([1, 0, 0, 0])) k = RBF(1) * RBF(1) * RBF(1, active_dims=[1]) * RationalQuadratic( 1, active_dims=[1]) result = additive_part_to_vec(k, base_kernels=base_kernels, n_dims=2) np.testing.assert_array_equal(result, np.array([2, 1, 0, 1])) k = RBF(1) * (RBF(1) + RBF(1)) self.assertRaises(TypeError, additive_part_to_vec, k, base_kernels, n_dims)
def test_get_index_to_insert_full_with_priority(self): # add five models self.active_set.add_model(GPModel(Covariance(RBF(1)))) self.active_set.add_model(GPModel(Covariance(RationalQuadratic(1)))) self.active_set.add_model(GPModel(Covariance(StandardPeriodic(1)))) self.active_set.add_model(GPModel(Covariance(LinScaleShift(1)))) self.active_set.add_model(GPModel(Covariance(RBF(1) + RBF(1)))) remove_priority = [2] self.active_set.remove_priority = remove_priority actual = self.active_set.get_index_to_insert() expected = 2 self.assertEqual(expected, actual) self.assertEqual(self.active_set.remove_priority, []) remove_priority = [0, 2, 3] self.active_set.remove_priority = remove_priority actual = self.active_set.get_index_to_insert() expected = 0 self.assertEqual(expected, actual) self.assertEqual(self.active_set.remove_priority, [2, 3])
def test_to_dict(self): test_cases = ( (None, 'None score'), (10., 'Positive score') ) for score, description in test_cases: with self.subTest(description=description): kernel = Covariance(RBF(1) * RBF(1) + RationalQuadratic(1)) gp_model = GPModel(kernel) gp_model.score = score actual = gp_model.to_dict() self.assertIsInstance(actual, dict) self.assertIn('likelihood', actual) self.assertIn('covariance', actual) self.assertIn('score', actual) self.assertEqual(None, actual['likelihood']) self.assertEqual(gp_model.covariance.to_dict(), actual['covariance']) self.assertEqual(gp_model.score, actual['score'])
def test_hd_kern_nodes(self): node_1 = KernelNode(RBF(1, active_dims=[0]).to_dict()) node_2 = KernelNode(RBF(1, active_dims=[0]).to_dict()) result = hd_kern_nodes(node_1, node_2) self.assertEqual(result, 0) node_1 = KernelNode(RBF(1, active_dims=[0]).to_dict()) node_2 = KernelNode(RationalQuadratic(1, active_dims=[0]).to_dict()) result = hd_kern_nodes(node_1, node_2) self.assertEqual(result, 1) node_1 = KernelNode(RBF(1, active_dims=[0]).to_dict()) node_2 = KernelNode(RBF(1, active_dims=[1]).to_dict()) result = hd_kern_nodes(node_1, node_2) self.assertEqual(result, 1) node_1 = KernelNode(RBF(1, active_dims=[0]).to_dict()) node_1.add_left('U') node_1.add_right('V') node_2 = KernelNode(RBF(1, active_dims=[0]).to_dict()) result = hd_kern_nodes(node_1, node_2) self.assertEqual(result, 1)
def test_update_exceed_max_remove_set(self): candidates = [ GPModel(Covariance(RBF(1))), GPModel(Covariance(RationalQuadratic(1))), GPModel(Covariance(LinScaleShift(1))), GPModel(Covariance(StandardPeriodic(1))), GPModel(Covariance(RBF(1) + RBF(1))), GPModel(Covariance(RBF(1) * RBF(1))) ] self.active_set.remove_priority = [0, 1, 2, 3, 4] actual_new_candidates_ind = self.active_set.update(candidates) expected_new_candidates_ind = [1, 2, 3, 4, 0] self.assertListEqual(expected_new_candidates_ind, actual_new_candidates_ind) expected_models = [ candidates[5], candidates[1], candidates[2], candidates[3], candidates[4] ] self.assertListEqual(expected_models, self.active_set.models) expected_next_ind = 1 self.assertEqual(expected_next_ind, self.active_set.get_index_to_insert())
def test_remove_duplicate_gp_models(self): k1 = GPModel(Covariance(RBF(1))) k1.score = 10 k2 = GPModel(Covariance(RBF(1))) k2.score = 9 k3 = GPModel(Covariance(RBF(1))) k4 = GPModel(Covariance(RBF(1))) k5 = GPModel(Covariance(RBF(1))) k6 = GPModel(Covariance(RBF(1, lengthscale=0.5))) k7 = GPModel(Covariance(RationalQuadratic(1))) # Always keep k1 then k2 then k3 etc. result = remove_duplicate_gp_models([k1, k2, k3, k4, k5, k6, k7]) self.assertListEqual(result, [k1, k7]) result = remove_duplicate_gp_models([k1, k2, k3, k4, k5, k7]) self.assertListEqual(result, [k1, k7]) result = remove_duplicate_gp_models([k1, k2, k3, k4, k7]) self.assertListEqual(result, [k1, k7]) result = remove_duplicate_gp_models([k1, k2, k3, k7]) self.assertListEqual(result, [k1, k7]) result = remove_duplicate_gp_models([k1, k2, k7]) self.assertListEqual(result, [k1, k7]) result = remove_duplicate_gp_models([k1, k7]) self.assertListEqual(result, [k1, k7]) result = remove_duplicate_gp_models([k2, k3, k4, k5, k6, k7]) self.assertListEqual(result, [k2, k7]) result = remove_duplicate_gp_models([k2, k3, k4, k5, k7]) self.assertListEqual(result, [k2, k7]) result = remove_duplicate_gp_models([k2, k3, k4, k7]) self.assertListEqual(result, [k2, k7]) result = remove_duplicate_gp_models([k2, k3, k7]) self.assertListEqual(result, [k2, k7]) result = remove_duplicate_gp_models([k2, k7]) self.assertListEqual(result, [k2, k7]) result = remove_duplicate_gp_models([k3, k4, k5, k6, k7]) self.assertTrue(result == [k3, k7] or result == [k4, k7]) result = remove_duplicate_gp_models([k3, k4, k5, k7]) self.assertTrue(result == [k3, k7] or result == [k4, k7]) result = remove_duplicate_gp_models([k4, k3, k5, k6, k7]) self.assertTrue(result == [k3, k7] or result == [k4, k7]) result = remove_duplicate_gp_models([k4, k3, k5, k7]) self.assertTrue(result == [k3, k7] or result == [k4, k7]) result = remove_duplicate_gp_models([k3, k4, k5, k7]) self.assertTrue(result == [k3, k7] or result == [k4, k7]) result = remove_duplicate_gp_models([k3, k4, k7]) self.assertTrue(result == [k3, k7] or result == [k4, k7]) result = remove_duplicate_gp_models([k4, k3, k7]) self.assertTrue(result == [k3, k7] or result == [k4, k7]) result = remove_duplicate_gp_models([k3, k7]) self.assertListEqual(result, [k3, k7]) result = remove_duplicate_gp_models([k4, k7]) self.assertListEqual(result, [k4, k7]) result = remove_duplicate_gp_models([k5, k6, k7]) self.assertTrue(result == [k5, k7] or result == [k6, k7]) result = remove_duplicate_gp_models([k6, k5, k7]) self.assertTrue(result == [k5, k7] or result == [k6, k7])
def test_index_new_model(self): candidates = [GPModel(Covariance(RBF(1)))] self.active_set.update(candidates) new_model = GPModel(Covariance(RationalQuadratic(1))) self.assertRaises(KeyError, self.active_set.index, new_model)
def setUp(self): self.se0 = Covariance(RBF(1, active_dims=[0])) self.se1 = Covariance(RBF(1, active_dims=[1])) self.rq0 = Covariance(RationalQuadratic(1, active_dims=[0])) self.rq1 = Covariance(RationalQuadratic(1, active_dims=[1]))
def test_to_binary_tree(self): kernel = Covariance(RBF(1) * RBF(1) + RationalQuadratic(1)) gp_model = GPModel(kernel) result = gp_model.covariance.to_binary_tree() self.assertIsInstance(result, KernelTree) self.assertCountEqual(result.postfix_tokens(), ['SE_1', 'SE_1', '*', 'RQ_1', '+'])
def setUp(self): self.se0 = RBF(1, active_dims=[0]) self.se1 = RBF(1, active_dims=[1]) self.rq0 = RationalQuadratic(1, active_dims=[0]) self.rq1 = RationalQuadratic(1, active_dims=[1])