def __init__(self, dim, unit_sp=None, hypers=None): super(GPQuad, self).__init__(dim, unit_sp, hypers) # GPy RBF kernel with given hypers self.kern = RBF(self.d, variance=self.hypers['sig_var'], lengthscale=self.hypers['lengthscale'], ARD=True)
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 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_decode_kernel(self): kern = RBF(1) kern_dict = kern.to_dict() kern_dict_str = str(kern_dict) result = decode_kernel(kern_dict_str) self.assertIsInstance(result, RBF) self.assertEqual(result.input_dim, 1) self.assertDictEqual(result.to_dict(), kern_dict)
def test_index_same_candidate_expression(self): candidates = [GPModel(Covariance(RBF(1)))] self.active_set.update(candidates) new_model = GPModel(Covariance(RBF(1))) actual = self.active_set.index(new_model) self.assertIsInstance(actual, int) expected_ind = 0 self.assertEqual(expected_ind, actual)
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_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_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 __init__(self, input_dim=1, k1=None, k2=None, kc=None, xc=None, cpDim=None, *args, **kwargs): if k1 is None: k1 = RBF(input_dim, name="k1", *args, **kwargs) else: self.k1 = k1 self.k1.name = 'k1' if k2 is None: k2 = RBF(input_dim, name="k2", *args, **kwargs) else: self.k2 = k2 self.k2.name = 'k2' if kc is None: kc = RBF(input_dim, name="kc", *args, **kwargs) else: kc.name = 'kc' # self.kc = Param('kc', kc, Logexp()) # self.link_parameter(self.kc) if k2 is k1: kerns = [k1, kc] else: kerns = [k1, k2, kc] super(Changepoint, self).__init__(kerns, "changepoint") self.input_dim = input_dim assert k1.input_dim == self.input_dim, "k1 must match input dim" assert k2.input_dim == self.input_dim, "k2 must match input dim" self.xc = xc if self.xc is None: self.xc = np.zeros((1, self.input_dim)) self.xc = np.array(self.xc) self.cpDim = cpDim if self.cpDim is None: self.cpDim = 0 self.otherDims = list(range(self.input_dim)) self.otherDims.remove(self.cpDim) self.otherDims = np.array(self.otherDims) # sort the changepoints if self.xc.shape[0] > 1: for i in self.otherDims[::-1]: self.xc = self.xc[self.xc[:, i].argsort(), :] self.xc = self.xc[self.xc[:, self.cpDim].argsort(), :]
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 __init__(self, input_dim, variance1=1., variance2=1., lengthscale1=1., lengthscale2=1., xc=1, active_dims=None): super(ChangepointRBF, self).__init__(input_dim, active_dims, 'chngpt') assert input_dim == 1, "For this kernel we assume input_dim = 1" self.variance1 = Param('variance1', variance1) self.variance2 = Param('variance2', variance2) self.lengthscale1 = Param('lengthscale1', lengthscale1) self.lengthscale2 = Param('lengthscale2', lengthscale2) self.rbf = RBF(input_dim=input_dim, lengthscale=1., variance=1.) self.xc = Param('xc', xc) self.add_parameters(self.variance1, self.variance2, self.lengthscale1, self.lengthscale2, self.xc)
def buildKernel(ndim, ARD=False): if (ndim > 1) and (ARD == False): kern = buildCompositeKernel(ndim) elif (ndim > 1): kern = RBF(ndim, ARD=True) elif (ndim == 1): kern = RBF(ndim, ARD=False) return kern
def test_update_with_duplicates(self): candidates = [GPModel(Covariance(RBF(1))), GPModel(Covariance(RBF(1)))] expected_candidates_ind = [0] new_candidates_ind = self.active_set.update(candidates) self.assertEqual(expected_candidates_ind, new_candidates_ind) expected_models = [candidates[0], None, None, None, None] 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_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)
class ChangepointRBF(Kern): def __init__(self, input_dim, variance1=1., variance2=1., lengthscale1=1., lengthscale2=1., xc=1, active_dims=None): super(ChangepointRBF, self).__init__(input_dim, active_dims, 'chngpt') assert input_dim == 1, "For this kernel we assume input_dim = 1" self.variance1 = Param('variance1', variance1) self.variance2 = Param('variance2', variance2) self.lengthscale1 = Param('lengthscale1', lengthscale1) self.lengthscale2 = Param('lengthscale2', lengthscale2) self.rbf = RBF(input_dim=input_dim, lengthscale=1., variance=1.) self.xc = Param('xc', xc) self.add_parameters(self.variance1, self.variance2, self.lengthscale1, self.lengthscale2, self.xc) def parameters_changed(self): pass def K(self, X, X2): """Covariance matrix""" u1 = self.u(X) a1 = self.a(X) if X2 is None: u2 = u1 a2 = a1 else: u2 = self.u(X2) a2 = self.a(X2) return a1 * a2 * self.rbf.K(X=u1, X2=u2) def Kdiag(self, X): """Diagonal of covariance matrix""" u = self.u(X) a = self.a(X) return a * self.rbf.Kdiag(u) def u(self, X: np.ndarray): """u operation in the paper""" u = np.empty(X.shape) for i in X.shape[0]: if X[i] < self.xc: u[i] = X[i] / self.variance1 else: u[i] = self.xc/self.variance1 + (X[i] - self.xc)/self.variance2 return u def a(self, X: np.ndarray): """a operation in the paper""" a = np.empty(X.shape) for i in X.shape[0]: if X[i] < self.xc: a[i] = self.lengthscale1 else: a[i] = self.lengthscale2 return a
def test_kernels(self): from GPy.kern import RBF,Linear,MLP,Bias,White Q = self.Z.shape[1] kernels = [RBF(Q,ARD=True), Linear(Q,ARD=True),MLP(Q,ARD=True), RBF(Q,ARD=True)+Linear(Q,ARD=True)+Bias(Q)+White(Q) ,RBF(Q,ARD=True)+Bias(Q)+White(Q), Linear(Q,ARD=True)+Bias(Q)+White(Q)] for k in kernels: k.randomize() self._test_kernel_param(k) self._test_Z(k) self._test_qX(k) self._test_kernel_param(k, psi2n=True) self._test_Z(k, psi2n=True) self._test_qX(k, psi2n=True)
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 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 __init__(self,input_dim=1,k1=None,k2=None,kc=None,xc=None,cpDim=None,*args,**kwargs): if k1 is None: k1 = RBF(input_dim,name="k1",*args,**kwargs) else: self.k1 = k1 self.k1.name = 'k1' if k2 is None: k2 = RBF(input_dim,name="k2",*args,**kwargs) else: self.k2 = k2 self.k2.name = 'k2' if kc is None: kc = RBF(input_dim,name="kc",*args,**kwargs) else: kc.name = 'kc' # self.kc = Param('kc', kc, Logexp()) # self.link_parameter(self.kc) if k2 is k1: kerns = [k1,kc] else: kerns = [k1,k2,kc] super(Changepoint,self).__init__(kerns,"changepoint") self.input_dim = input_dim assert k1.input_dim == self.input_dim, "k1 must match input dim" assert k2.input_dim == self.input_dim, "k2 must match input dim" self.xc = xc if self.xc is None: self.xc = np.zeros((1,self.input_dim)) self.xc = np.array(self.xc) self.cpDim = cpDim if self.cpDim is None: self.cpDim = 0 self.otherDims = range(self.input_dim) self.otherDims.remove(self.cpDim) self.otherDims = np.array(self.otherDims) # sort the changepoints if self.xc.shape[0] > 1: for i in self.otherDims[::-1]: self.xc = self.xc[self.xc[:,i].argsort(),:] self.xc = self.xc[self.xc[:,self.cpDim].argsort(),:]
def test_create_precomputed_info(self): num_samples = 20 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, max_num_hyperparameters=40, max_num_kernels=10, active_models=MagicMock(), initial_model_indices=MagicMock(), data_X=x) cov = Covariance(RBF(1)) p1 = LogGaussian(20, 1) p2 = LogGaussian(0, 1.1) cov.raw_kernel.variance.set_prior(p1, warning=False) cov.raw_kernel.lengthscale.set_prior(p2, warning=False) result = builder.create_precomputed_info(cov, x) self.assertIsInstance(result, tuple) self.assertEqual(len(result), 2) self.assertIsInstance(result[0], np.ndarray) self.assertIsInstance(result[1], np.ndarray) self.assertEqual(result[0].shape, (num_samples, )) self.assertEqual(result[1].shape, (x.shape[0], x.shape[0], num_samples))
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 test_subkernel_expression(self): kernel = RBF(1, variance=3, lengthscale=2) result = subkernel_expression(kernel=kernel, show_params=False, html_like=False) self.assertIsInstance(result, str) self.assertEqual(result, 'SE_1') result = subkernel_expression(kernel=kernel, show_params=True, html_like=False) self.assertIsInstance(result, str) self.assertIn('SE_1', result) self.assertIn('variance', result) self.assertIn('lengthscale', result) self.assertIn('3', result) self.assertIn('2', result) result = subkernel_expression(kernel=kernel, show_params=False, html_like=True) self.assertIsInstance(result, str) self.assertEqual(result, '<SE<SUB><FONT POINT-SIZE="8">1</FONT></SUB>>') result = subkernel_expression(kernel=kernel, show_params=True, html_like=True) self.assertIsInstance(result, str) self.assertIn('<SE<SUB><FONT POINT-SIZE="8">1</FONT></SUB>>', result) self.assertIn('variance', result) self.assertIn('lengthscale', result) self.assertIn('3', result) self.assertIn('2', result)
def test_get_index_to_insert_one_item(self): # add one model self.active_set.add_model(GPModel(Covariance(RBF(1)))) expected_index = 1 actual_index = self.active_set.get_index_to_insert() self.assertEqual(expected_index, actual_index)
def test_get_same_candidate_with_default(self): candidates = [GPModel(Covariance(RBF(1)))] self.active_set.update(candidates) actual = self.active_set.get(candidates[0], -1) self.assertIsInstance(actual, int) expected_ind = 0 self.assertEqual(expected_ind, actual)
def fit_all_models(self): functions = {} num_features = self.Z.shape[1] kernel = RBF(num_features, ARD=False, lengthscale=1., variance=1.) gp_Y = GPRegression(X=self.Z, Y=self.Y, kernel=kernel, noise_var=1.) gp_Y.optimize() num_features = self.X.shape[1] kernel = RBF(num_features, ARD=False, lengthscale=1., variance=1.) gp_Z = GPRegression(X=self.X, Y=self.Z, kernel=kernel) gp_Z.optimize() functions = OrderedDict([('Y', gp_Y), ('Z', gp_Z), ('X', [])]) return functions
def test_init(self): kern = RBF(1) root = KernelNode(kern) result = KernelTree(root) self.assertEqual(result.root, root) self.assertEqual(result.root.label, 'SE_1') self.assertEqual(result.root.value, kern)
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_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 __init__( self, kernel=RBF(2, ARD=True), ): super().__init__() self.kernel = kernel
def set_gp_kernel(self, kernel=DEFAULTS['kernel'], in_dim=DEFAULTS['input_dim'], variance=DEFAULTS['variance'], lengthscale=DEFAULTS['lengthscale'], multi_dim=False): self.kernel_name = kernel # This is used for saving file names """Sets the kernel of this Gaussfit""" if kernel == 'RBF': self.kernel = RBF(input_dim=in_dim, variance=variance, lengthscale=lengthscale, ARD=multi_dim) elif kernel == 'Exponential': self.kernel = Exponential(input_dim=in_dim, variance=variance, lengthscale=lengthscale, ARD=multi_dim) elif kernel == 'Matern32': self.kernel = Matern32(input_dim=in_dim, variance=variance, lengthscale=lengthscale, ARD=multi_dim) elif kernel == 'Matern52': self.kernel = Matern52(input_dim=in_dim, variance=variance, lengthscale=lengthscale, ARD=multi_dim) else: print 'Kernel not recognized or not implemented'