def gen_gp_test_data():
""" This function generates a bunch of test data. """
# pylint: disable=too-many-locals
# Dataset 1
f1 = lambda x: (x**2).sum(axis=1)
N1 = 5
X1_tr = np.array(list(range(N1))).astype(float).reshape(
(N1, 1)) / N1 + 1 / (2 * N1)
Y1_tr = f1(X1_tr)
X1_te = np.random.random((50, 1))
Y1_te = f1(X1_te)
kernel1 = SEKernel(1, 1, 0.5)
# Dataset 2
N2 = 100
D2 = 10
f2 = lambda x: ((x**2) * list(range(1, D2 + 1)) / D2).sum(axis=1)
X2_tr = np.random.random((N2, D2))
Y2_tr = f2(X2_tr)
X2_te = np.random.random((N2, D2))
Y2_te = f2(X2_te)
kernel2 = SEKernel(D2, 10, 0.2 * np.sqrt(D2))
# Dataset 3
N3 = 200
D3 = 6
f3 = lambda x: (
(x**3 + 2 * x**2 - x + 2) * list(range(1, D3 + 1)) / D3).sum(axis=1)
X3_tr = np.random.random((N3, D3))
Y3_tr = f3(X3_tr)
X3_te = np.random.random((N3, D3))
Y3_te = f3(X3_te)
kernel3 = SEKernel(D3, 10, 0.2 * np.sqrt(D3))
# Dataset 4
N4 = 400
D4 = 8
f4 = lambda x: ((np.sin(x**2) + 2 * np.cos(x**2) - x + 2) * list(
range(1, D4 + 1)) / D4).sum(axis=1)
X4_tr = np.random.random((N4, D4))
Y4_tr = f4(X4_tr)
X4_te = np.random.random((N4, D4))
Y4_te = f4(X4_te)
kernel4 = SEKernel(D4, 10, 0.2 * np.sqrt(D4))
# put all datasets into a list.
return [(X1_tr, Y1_tr, kernel1, X1_te, Y1_te),
(X2_tr, Y2_tr, kernel2, X2_te, Y2_te),
(X3_tr, Y3_tr, kernel3, X3_te, Y3_te),
(X4_tr, Y4_tr, kernel4, X4_te, Y4_te)]
def _get_se_kernel(cls, dim, gp_hyperparams, use_same_bandwidth):
""" Builds a squared exponential kernel. """
if use_same_bandwidth:
ke_dim_bandwidths = [np.exp(gp_hyperparams[0])] * dim
gp_hyperparams = gp_hyperparams[1:]
else:
ke_dim_bandwidths = np.exp(gp_hyperparams[0:dim])
gp_hyperparams = gp_hyperparams[dim:]
kernel = SEKernel(dim=dim, scale=1, dim_bandwidths=ke_dim_bandwidths)
return kernel, gp_hyperparams
def test_se_kernel(self):
""" Tests for the SE kernel. """
self.report('Tests for the SE kernel.')
kern = SEKernel(self.data_1.shape[1], self.se_scale, self.dim_bandwidths)
K11 = kern(self.data_1)
K22 = kern(self.data_2)
K12 = kern(self.data_1, self.data_2)
assert np.linalg.norm(self.true_se_vals_11 - K11) < 1e-10
assert np.linalg.norm(self.true_se_vals_22 - K22) < 1e-10
assert np.linalg.norm(self.true_se_vals_12 - K12) < 1e-10
def test_compute_std_slack_se(self):
""" Tests for the effective length in the SE kernel. """
self.report('Tests for std slack in the SE kernel.')
# The data here are in the order [dim, scale, num_data]
prob_params = [[2, 1, 10], [3, 2, 0], [10, 6, 13]]
n = 5
for prob in prob_params:
dim_bws = list(np.random.random(prob[0]) * 0.3 + 0.5)
kern = SEKernel(prob[0], prob[1], dim_bws)
X_1 = np.random.random((n, prob[0]))
X_2 = np.random.random((n, prob[0]))
X_tr = np.random.random((prob[2], prob[0]))
_, std_1 = self._compute_post_covar(kern, X_tr, X_1)
_, std_2 = self._compute_post_covar(kern, X_tr, X_2)
std_diff = np.abs(std_1 - std_2)
std_slack = kern.compute_std_slack(X_1, X_2)
diff_12_scaled = kern.get_effective_norm(X_1 - X_2, order=2, is_single=False)
kern_diff_12_scaled = kern.hyperparams['scale'] * diff_12_scaled
assert np.all(std_diff <= std_slack)
assert np.all(std_slack <= kern_diff_12_scaled)
def _create_init_gp(self):
""" Creates an initial GP. """
reg_X = np.concatenate(
(self.pre_eval_points, self.history.query_points), axis=0)
reg_Y = np.concatenate((self.pre_eval_vals, self.history.query_vals),
axis=0)
range_Y = reg_Y.max() - reg_Y.min()
mean_func = lambda x: np.array([np.median(reg_X)] * len(x))
kernel = SEKernel(self.domain_dim,
range_Y / 4.0,
dim_bandwidths=0.05 * np.sqrt(self.domain_dim))
noise_var = (reg_Y.std()**2) / 10
self.gp = GP(reg_X, reg_Y, kernel, mean_func, noise_var)
def gen_simple_mfgp_as_mfof(fidel_bw=0.8, random_seed=512):
""" Gets a simple mfgp wrapped into an mfof. """
# Create a GP
kernel_scale = 2
fidel_kernel = SEKernel(1, 1, [fidel_bw])
domain_kernel = SEKernel(1, 1, [0.08])
noise_var = 0.1
dummy_ZZ = np.zeros((0, 1))
dummy_XX = np.zeros((0, 1))
dummy_YY = np.zeros((0))
mean_func = lambda x: np.zeros((len(x)))
mfgp = mf_gp.get_mfgp_from_fidel_domain(dummy_ZZ,
dummy_XX,
dummy_YY,
kernel_scale,
fidel_kernel,
domain_kernel,
mean_func,
noise_var,
build_posterior=True)
# Get an mfof object
fidel_cost_func = lambda z: 0.2 + 6 * z**2
return gen_mfgp_sample_as_mfof(mfgp, fidel_cost_func, random_seed)
def test_comb_kernel(self):
""" Tests for the combined kernel. """
self.report('Tests for the Combined kernel.')
kern_se = SEKernel(self.data_1.shape[1], self.se_scale, self.dim_bandwidths)
kern_po = PolyKernel(self.data_1.shape[1], self.poly_order, self.poly_scale,
self.poly_dim_scalings)
kern = CoordinateProductKernel(self.data_1.shape[0], self.com_scale,
[kern_se, kern_po], [[0, 1], [0, 1]])
K11 = kern(self.data_1)
K22 = kern(self.data_2)
K12 = kern(self.data_1, self.data_2)
assert np.linalg.norm(self.true_comb_11 - K11) < 1e-10
assert np.linalg.norm(self.true_comb_22 - K22) < 1e-10
assert np.linalg.norm(self.true_comb_12 - K12) < 1e-10
def test_effective_length_se(self):
""" Tests for the effective length in the SE kernel. """
# pylint: disable=too-many-locals
self.report('Tests for the effective length in the SE kernel.')
data_1 = np.array([1, 2])
data_2 = np.array([[0, 1, 2], [1, 1, 0.5]])
bws_1 = [0.1, 1]
bws_2 = [0.5, 1, 2]
res_l2_1 = np.sqrt(104)
res_l2_2 = np.array([np.sqrt(2), np.sqrt(5.0625)])
res_l1_1 = 12
res_l1_2 = np.array([2, 3.25])
dim_1 = 2
dim_2 = 3
all_data = [(data_1, bws_1, dim_1, res_l2_1, res_l1_1),
(data_2, bws_2, dim_2, res_l2_2, res_l1_2)]
for data in all_data:
kern = SEKernel(data[2], 1, data[1])
eff_l1_norms = kern.get_effective_norm(data[0], order=1,
is_single=len(data[0].shape) == 1)
eff_l2_norms = kern.get_effective_norm(data[0], order=2,
is_single=len(data[0].shape) == 1)
assert np.linalg.norm(eff_l2_norms - data[3]) < 1e-5
assert np.linalg.norm(eff_l1_norms - data[4]) < 1e-5
def get_default_kernel(self, range_Y):
""" Returns the default (SE) kernel. """
return SEKernel(self.dim,
range_Y / 4.0,
dim_bandwidths=0.05 * np.sqrt(self.dim))