def log_linear_mfdgp(X_train, Y_train): kernels = [GPy.kern.RBF(5), GPy.kern.RBF(5)] lin_mf_kernel = emukit.multi_fidelity.kernels.LinearMultiFidelityKernel( kernels) gpy_lin_mf_model = GPyLinearMultiFidelityModel(X_train, Y_train, lin_mf_kernel, n_fidelities=2) gpy_lin_mf_model.mixed_noise.Gaussian_noise.fix(0) gpy_lin_mf_model.mixed_noise.Gaussian_noise.fix(0) gpy_lin_mf_model.optimize_restarts(num_restarts=5) return gpy_lin_mf_model
def test_array_training_input(self, kernel): """ Test failure if lists rather than arrays are passed to model """ with pytest.raises(ValueError): GPyLinearMultiFidelityModel([np.random.rand(5, 1)], [np.random.rand(5, 1)], kernel, 1)
def linear_model(X_train, Y_train, save=False): """ Returns GPy model of linear multi fidelity GP.""" kernels = [GPy.kern.RBF(1), GPy.kern.RBF(1)] lin_mf_kernel = emukit.multi_fidelity.kernels.LinearMultiFidelityKernel( kernels) gpy_lin_mf_model = GPyLinearMultiFidelityModel(X_train, Y_train, lin_mf_kernel, n_fidelities=2) # Fix noise to kernel gpy_lin_mf_model.mixed_noise.Gaussian_noise.fix(0) gpy_lin_mf_model.mixed_noise.Gaussian_noise_1.fix(0) # Optimise lin_mf_model = GPyMultiOutputWrapper(gpy_lin_mf_model, 2, n_optimization_restarts=5) lin_mf_model.optimize() if save is not False: lin_mf_model.save_model(save) return lin_mf_model
def test_1d_training_inputs(self, kernel): """ Test failure if 1d training data is given """ x = np.random.rand(5, 2) y = np.random.rand(5) with pytest.raises(ValueError): GPyLinearMultiFidelityModel(x, y, kernel, 2)
def test_inconsistent_fidelity_indices(self, kernel): """ Test failure if more fidelity indices than fidelities """ x = np.random.rand(5, 2) x[:, -1] = 3 y = np.random.rand(5, 1) with pytest.raises(ValueError): GPyLinearMultiFidelityModel(x, y, kernel, 2)
def model(self, x_init, y_init, functions): n_fidelities = len(functions) base_kernels = [GPy.kern.RBF(1) for _ in range(len(functions))] k = emukit.multi_fidelity.kernels.LinearMultiFidelityKernel(base_kernels) # Train model np.random.seed(123) gpy_model = GPyLinearMultiFidelityModel(x_init, y_init, k, n_fidelities) model = GPyMultiOutputWrapper(gpy_model, n_fidelities, n_optimization_restarts=5) model.optimize() return model
def log_linear_mfdgp(X_train, Y_train): kernels = [GPy.kern.RBF(5), GPy.kern.RBF(5)] lin_mf_kernel = emukit.multi_fidelity.kernels.LinearMultiFidelityKernel( kernels) gpy_lin_mf_model = GPyLinearMultiFidelityModel( X_train, Y_train, lin_mf_kernel, n_fidelities=2) gpy_lin_mf_model.mixed_noise.Gaussian_noise.fix(0) gpy_lin_mf_model.mixed_noise.Gaussian_noise.fix(0) lin_mf_model = GPyMultiOutputWrapper( gpy_lin_mf_model, 2, n_optimization_restarts=5) lin_mf_model.optimize() return lin_mf_model
def train(self, x_l, y_l, x_h, y_h): # Construct a linear multi-fidelity model X_train, Y_train = convert_xy_lists_to_arrays([x_l, x_h], [y_l, y_h]) kernels = [GPy.kern.RBF(x_l.shape[1]), GPy.kern.RBF(x_h.shape[1])] kernel = emukit.multi_fidelity.kernels.LinearMultiFidelityKernel( kernels) gpy_model = GPyLinearMultiFidelityModel(X_train, Y_train, kernel, n_fidelities=2) if self.noise is not None: gpy_model.mixed_noise.Gaussian_noise.fix(self.noise) gpy_model.mixed_noise.Gaussian_noise_1.fix(self.noise) # Wrap the model using the given 'GPyMultiOutputWrapper' self.model = GPyMultiOutputWrapper( gpy_model, 2, n_optimization_restarts=self.n_optimization_restarts) # Fit the model self.model.optimize()
plt.figure(figsize=(12, 8)) plt.ylabel('HF(x)') plt.xlabel('LF(x)') plt.plot(y_plot_l, y_plot_h, color=colors['purple']) plt.title('Mapping from low fidelity to high fidelity') plt.legend(['HF-LF Correlation'], loc='lower center') #### ## Construct a linear multi-fidelity model kernels = [GPy.kern.RBF(1), GPy.kern.RBF(1)] lin_mf_kernel = emukit.multi_fidelity.kernels.LinearMultiFidelityKernel( kernels) gpy_lin_mf_model = GPyLinearMultiFidelityModel(X_train, Y_train, lin_mf_kernel, n_fidelities=2) # print(gpy_lin_mf_model) gpy_lin_mf_model.mixed_noise.Gaussian_noise.fix(0) gpy_lin_mf_model.mixed_noise.Gaussian_noise_1.fix(0) lin_mf_model = model = GPyMultiOutputWrapper(gpy_lin_mf_model, 2, n_optimization_restarts=5, verbose_optimization=False) ## Fit the model lin_mf_model.optimize() ####
def denvsrecmain(n_fid, x_dim, n): ################# ### Functions ### ################# f_exact = test_funs.ackley def f_name(): return f_exact(0)[1] def f_m(x): return f_exact(x)[0] a = 4 * (np.random.rand(n_fid - 1) - .5) b = 4 * (np.random.rand(n_fid - 1) - .5) c = 4 * (np.random.rand(n_fid - 1) - .5) d = np.random.randint(-4, 5, size=(n_fid - 1, x_dim + 1)) def f(x, fid): if fid == n_fid - 1: return f_m(x) else: x1_ptb = np.array([x_i[0] - d[fid][0] for x_i in x])[:, None] return a[fid] * f(x, fid + 1) + b[fid] * x1_ptb + c[fid] ############### ### x_dim-D ### ############### ### Plotting data ### x_min = [-5] * x_dim x_max = [5] * x_dim x_plot_grid = [ np.linspace(x_min[j], x_max[j], 50)[:, None] for j in range(x_dim) ] x_plot_mesh = np.meshgrid(*x_plot_grid) x_plot_list = np.hstack([layer.reshape(-1, 1) for layer in x_plot_mesh]) X_plot_mf = convert_x_list_to_array([x_plot_list] * n_fid) X_plot_mf_list = X_plot_mf.reshape((n_fid, len(x_plot_list), x_dim + 1)) ### Training data ### x_train = [x_plot_list[::len(x_plot_list) // n_i] for n_i in n ] # Include possibility to insert training data of choice. y_train = [f(x_train[j], j) for j in range(n_fid)] X_train_mf, Y_train_mf = convert_xy_lists_to_arrays(x_train, y_train) ############################ ### DENSE GP CALCULATION ### ############################ n_opt_restarts = 3 kernels_mf = [] for k in range(n_fid): kernels_mf.append(GPy.kern.RBF(input_dim=x_dim)) lin_mf_kernel = emukit.multi_fidelity.kernels.LinearMultiFidelityKernel( kernels_mf) # print(lin_mf_kernel) # print(lin_mf_kernel.kernels[0]) start_den = time.time() # print(X_train_mf) gpy_m_den_mf = GPyLinearMultiFidelityModel(X_train_mf, Y_train_mf, lin_mf_kernel, n_fidelities=n_fid) # print(gpy_m_den_mf) ### Fixing kernel parameters ### for k in range(n_fid): gpy_m_den_mf.mixed_noise.likelihoods_list[k].fix(0) # print(gpy_m_den_mf) m_den_mf = GPyMultiOutputWrapper(gpy_m_den_mf, n_fid, n_optimization_restarts=n_opt_restarts, verbose_optimization=False) end_den_1 = time.time() # print('Dense MFGPR construction', end_den_1 - start_den) ### Dense HPO ### m_den_mf_pre_HPO = m_den_mf m_den_mf.optimize() print(gpy_m_den_mf) # print(gpy_m_den_mf.kern) # print(lin_mf_kernel) # print(lin_mf_kernel.kernels[0]) # print(X_train_mf) # test = lin_mf_kernel.K(X=X_train_mf) # print(test) # print(lin_mf_kernel) end_den_2 = time.time() # print('Dense MFGPR construction + HPO', end_den_2 - start_den) # print(gpy_m_den_mf) ### Prediction ### # for j in range(n_fid): # a = time.time() # test = m_den_mf.predict(X_plot_mf_list[j]) # b = time.time() # print(b - a) mu_den_mf = [m_den_mf.predict(X_plot_mf_list[j])[0] for j in range(n_fid)] # print(X_plot_mf_list) # print(mu_den_mf) # sigma_den_mf = [m_den_mf.predict(X_plot_mf_list[j])[1] for j in range(n_fid)] # # end_den_3 = time.time() # print('Dense MFGPR construction + HPO + prediction', end_den_3 - start_den) ################################ ### RECURSIVE GP CALCULATION ### ################################ start_rec = time.time() # m_rec_mf = GPy.models.multiGPRegression(x_train, y_train, kernel=[GPy.kern.RBF(x_dim) for i in # range(n_fid)]) # Improve kernel selection...? end_rec_1 = time.time() # print('Recursive MFGPR construction', end_rec_1 - start_rec) # for k in range(n_fid): m_rec_mf.models[k]['Gaussian_noise.variance'].fix(0) ### Recursive HPO ### # m_rec_mf_pre_HPO = m_rec_mf # m_rec_mf.optimize_restarts(restarts=n_opt_restarts, verbose=False) # for j in range(n_fid): print(m_rec_mf.models[j]) end_rec_2 = time.time() # print('Recursive MFGPR construction + HPO', end_rec_2 - start_rec) # for k in range(m): print(m_rec_mf.models[k]) ### Prediction ### # mu_rec_mf, sigma_rec_mf = m_rec_mf.predict(x_plot_list) # print(mu_rec_mf) # # end_rec_3 = time.time() # print('Recursive MFGPR construction + HPO + prediction', end_rec_3 - start_rec) # times = [np.array([end_den_1, end_den_2, end_den_3]) - start_den, np.array([end_rec_1, end_rec_2, end_rec_3]) - start_rec] times = [end_den_2 - start_den, end_rec_2 - start_rec] return times, n_fid, x_dim
# X_train, Y_train = convert_xy_lists_to_arrays([x_train_0, x_train_1, x_train_2], [y_train_0, y_train_1, y_train_2]) ## DENSE GP CALCULATION WITH EMUKIT kernels_mf = [] for k in range(m): kernels_mf.append(GPy.kern.RBF(1)) kernels = [GPy.kern.RBF(1), GPy.kern.RBF(1), GPy.kern.RBF(1)] # print(kernels_mf) lin_mf_kernel = emukit.multi_fidelity.kernels.LinearMultiFidelityKernel(kernels_mf) # lin_mf_kernel = emukit.multi_fidelity.kernels.LinearMultiFidelityKernel(kernels) start = time.time() gpy_m_den_mf = GPyLinearMultiFidelityModel(X_train_mf, Y_train_mf, lin_mf_kernel, n_fidelities=m) # gpy_m_den = GPyLinearMultiFidelityModel(X_train, Y_train, lin_mf_kernel, n_fidelities=3) end1 = time.time() print('dense', end1 - start) for k in range(m): gpy_m_den_mf.mixed_noise.likelihoods_list[k].fix(0) # print(gpy_m_den_mf) # for a in gpy_m_den_mf.mixed_noise: print(a) # gpy_m_den.mixed_noise.Gaussian_noise.fix(0) # gpy_m_den.mixed_noise.Gaussian_noise_1.fix(0) # gpy_m_den.mixed_noise.Gaussian_noise_2.fix(0) m_den_mf = GPyMultiOutputWrapper(gpy_m_den_mf, m, n_optimization_restarts=4, verbose_optimization=True)
import numpy as np from emukit.test_functions.forrester import forrester, forrester_low from emukit.multi_fidelity.convert_lists_to_array import convert_x_list_to_array, convert_xy_lists_to_arrays import GPy from emukit.multi_fidelity.kernels import LinearMultiFidelityKernel from emukit.multi_fidelity.models import GPyLinearMultiFidelityModel x_train_l = np.atleast_2d(np.random.rand(12)).T x_train_h = np.atleast_2d(np.random.permutation(x_train_l)[:6]) y_train_l = forrester_low(x_train_l) y_train_h = forrester(x_train_h) X_train, Y_train = convert_xy_lists_to_arrays([x_train_l, x_train_h], [y_train_l, y_train_h]) num_fidelities = 2 kernels = [GPy.kern.RBF(1), GPy.kern.RBF(1)] linear_mf_kernel = LinearMultiFidelityKernel(kernels) gpy_linear_mf_model = GPyLinearMultiFidelityModel(X_train, Y_train, linear_mf_kernel, n_fidelities=2) gpy_linear_mf_model.mixed_noise.Gaussian_noise.fix(0) gpy_linear_mf_model.mixed_noise.Gaussian_noise_1.fix(0) gpy_linear_mf_model.optimize()