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'
