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))