def plot_optimizer(opt, x, acq_name='EI'): model = opt.models[-1] x_model = opt.space.transform(x.tolist()) # Plot Model(x) + contours y_pred, sigma = model.predict(x_model, return_std=True) plt.plot(x, y_pred, "g--", label=r"$\mu(x)$") plt.fill(np.concatenate([x, x[::-1]]), #np.concatenate([y_pred - 1.9600 * sigma, # (y_pred + 1.9600 * sigma)[::-1]]), np.concatenate([y_pred - sigma, (y_pred + sigma)[::-1]]), alpha=.2, fc="g", ec="None") # Plot sampled points plt.plot(opt.Xi, opt.yi, "ro", label="Observations") if acq_name == 'EI': acq = gaussian_ei(x_model, model, y_opt=np.min(opt.yi), **opt.acq_func_kwargs) acq /= acq.max() elif acq_name == 'LCB': acq = gaussian_lcb(x_model, model, **opt.acq_func_kwargs) acq /= acq.min() # shift down to make a better plot acq = acq - 2 plt.plot(x, acq, "b", label="%s(x)" % acq_name) plt.fill_between(x.ravel(), -2.0, acq.ravel(), alpha=0.3, color='blue') # Adjust plot layout plt.grid() plt.legend(loc='best')
def plot_optimizer(opt, x, fx): model = opt.models[-1] x_model = opt.space.transform(x.tolist()) # Plot true function. plt.plot(x, fx, "r--", label="True (unknown)") plt.fill(np.concatenate([x, x[::-1]]), np.concatenate( [fx - 1.9600 * noise_level, fx[::-1] + 1.9600 * noise_level]), alpha=.2, fc="r", ec="None") # Plot Model(x) + contours y_pred, sigma = model.predict(x_model, return_std=True) plt.plot(x, y_pred, "g--", label=r"$\mu(x)$") plt.fill(np.concatenate([x, x[::-1]]), np.concatenate( [y_pred - 1.9600 * sigma, (y_pred + 1.9600 * sigma)[::-1]]), alpha=.2, fc="g", ec="None") # Plot sampled points plt.plot(opt.Xi, opt.yi, "r.", markersize=8, label="Observations") acq = gaussian_ei(x_model, model, y_opt=np.min(opt.yi)) # shift down to make a better plot acq = 4 * acq - 2 plt.plot(x, acq, "b", label="EI(x)") plt.fill_between(x.ravel(), -2.0, acq.ravel(), alpha=0.3, color='blue') # Adjust plot layout plt.grid() plt.legend(loc='best')
def neg_ei(x): if len(known_values) > 0: a, grad = gaussian_ei(x.reshape(1, -1), model=model, y_opt=y_opt, return_grad=True) return -a, -grad else: return -1.0, np.zeros(x.shape[0])
def acq_f(x): if len(known_values) > 0: acq = gaussian_ei(x, model=model, y_opt=y_opt) else: acq = np.zeros(x.shape[0]) prev_mean, prev_std = prev_model.predict(x, return_std=True) phi = ndtr((threshold - prev_mean) / prev_std) return -acq * phi
def acq_f(x): if len(known_values) > 0: acq, acq_grad = gaussian_ei(x.reshape(1, -1), model=model, y_opt=y_opt, return_grad=True) else: acq, acq_grad = 1.0, np.zeros(x.shape[0]) prev_mean, prev_std, prev_mean_grad, prev_std_grad = \ prev_model.predict(x.reshape(1, -1), return_std=True, return_mean_grad=True, return_std_grad=True) phi = ndtr((threshold - prev_mean) / prev_std) dphi_dz = 1.0 / prev_std / np.sqrt(2 * np.pi) * np.exp( -(prev_mean - threshold)**2 / 2.0 / prev_std**2) dz_dx = -prev_mean_grad / prev_std + prev_mean / ( prev_std**2) * prev_std_grad dphi_dx = dphi_dz * dz_dx full_grad = acq_grad * phi + acq * dphi_dx return -acq * phi, -full_grad
def get_action_using_bo(_env): all_acq = gaussian_ei(_env.possible_locations, _env.gp, np.min(_env.train_targets), xi=1.0) best_loc = _env.possible_locations[np.where(all_acq == np.max(all_acq))][0] vect_dist = np.subtract(best_loc, _env.position) ang = (np.arctan2(vect_dist[0], -vect_dist[1]) + np.pi) / (2 * np.pi) # determina la distancia y luego encuentra el ratio con respecto al max dist (normaliza) dist_ = np.exp(_env.gp.kernel_.theta[0]) * 0.375 / _env.max_step_distance() if dist_ > 1.0: dist_ = 1.0 acq_state = np.zeros(_env.map_size) acq_state[_env.possible_locations[:, 0], _env.possible_locations[:, 1]] = all_acq # plt.figure() # plt.imshow(acq_state) # plt.plot(_env.train_inputs[:, 1], _env.train_inputs[:, 0], 'xr') # plt.plot(best_loc[1], best_loc[0], '^y') # plt.plot(_env.position[1], _env.position[0], 'xb') # action = _env.action2vector([dist_, ang]) + _env.position # print("best: ", best_loc, "pos : ", _env.position, "dist: ", vect_dist, "next: ", action) # plt.plot(action[1], action[0], '^b') return [dist_, ang]
# Adjust plot layout plt.grid() if n_iter == 0: plt.legend(loc="best", prop={'size': 6}, numpoints=1) if n_iter != 4: plt.tick_params(axis='x', which='both', bottom='off', top='off', labelbottom='off') # Plot EI(x) plt.subplot(5, 2, 2 * n_iter + 2) acq = gaussian_ei(x_gp, gp, y_opt=np.min(curr_func_vals)) plt.plot(x, acq, "b", label="EI(x)") plt.fill_between(x.ravel(), -2.0, acq.ravel(), alpha=0.3, color='blue') next_x = res.x_iters[5 + n_iter] next_acq = gaussian_ei(res.space.transform([next_x]), gp, y_opt=np.min(curr_func_vals)) plt.plot(next_x, next_acq, "bo", markersize=6, label="Next query point") # Adjust plot layout plt.ylim(0, 0.1) plt.grid() if n_iter == 0: plt.legend(loc="best", prop={'size': 6}, numpoints=1)
model.fit(x_data, y_data) # use bayesian optimization for i in range(initial_points, iterations): minimum = min(y_data) # minimum = 99999 max_expected_improvement = 0 max_points = [] max_points_unnormalized = [] for pool_size in range(thread_pool_min, thread_pool_max + 1): x = [pool_size] x_normalized = [_normalize(x[0], thread_pool_min, thread_pool_max)] ei = gaussian_ei(np.array(x_normalized).reshape(1, -1), model, minimum) if ei > max_expected_improvement: max_expected_improvement = ei max_points = [x_normalized] max_points_unnormalized = [x] elif ei == max_expected_improvement: max_points.append(x_normalized) max_points_unnormalized.append(x) if max_expected_improvement == 0: print("WARN: Maximum expected improvement was 0. Most likely to pick a random point next") # select the point with maximum expected improvement # if there're multiple points with same ei, chose randomly
def test_acquisition_ei_correctness(): # check that it works with a vector as well X = 10 * np.ones((4, 2)) ei = gaussian_ei(X, ConstSurrogate(), -0.5, xi=0.) assert_array_almost_equal(ei, [0.1977966] * 4)
dimensions = [(-5.0, 10.0), (0.0, 15.0)] x1_values = np.linspace(-5, 10, 100) x2_values = np.linspace(0, 15, 100) x_ax, y_ax = np.meshgrid(x1_values, x2_values) vals = np.c_[x_ax.ravel(), y_ax.ravel()] res = gbrt_minimize( branin, dimensions, maxiter=200, random_state=1) model = res.models[-1] opt_points = res.x_iters y_opt = res.fun x_opt = res.x acquis_values = gaussian_ei(vals, model, y_opt) acquis_values = acquis_values.reshape(100, 100) branin_vals = np.reshape([branin(val) for val in vals], (100, 100)) plt.subplot(211) plt.pcolormesh(x_ax, y_ax, acquis_values) plt.plot(opt_points[:, 0], opt_points[:, 1], 'ro', markersize=4, lw=0, label='samples') plt.plot(x_opt[0], x_opt[1], 'ws', markersize=8, label='best') plt.colorbar() plt.legend(loc='best', numpoints=1) plt.xlabel('X1') plt.xlim([-5, 10]) plt.ylabel('X2') plt.ylim([0, 15])
def plot_optimizer(res, next_x, x, fx, n_iter, max_iters=5): x_gp = res.space.transform(x.tolist()) gp = res.models[-1] curr_x_iters = res.x_iters curr_func_vals = res.func_vals # Plot true function. ax = plt.subplot(max_iters, 2, 2 * n_iter + 1) plt.plot(x, fx, "r--", label="True (unknown)") plt.fill(np.concatenate([x, x[::-1]]), np.concatenate( [fx - 1.9600 * noise_level, fx[::-1] + 1.9600 * noise_level]), alpha=.2, fc="r", ec="None") if n_iter < max_iters - 1: ax.get_xaxis().set_ticklabels([]) # Plot GP(x) + contours y_pred, sigma = gp.predict(x_gp, return_std=True) plt.plot(x, y_pred, "g--", label=r"$\mu_{GP}(x)$") plt.fill(np.concatenate([x, x[::-1]]), np.concatenate( [y_pred - 1.9600 * sigma, (y_pred + 1.9600 * sigma)[::-1]]), alpha=.2, fc="g", ec="None") # Plot sampled points plt.plot(curr_x_iters, curr_func_vals, "r.", markersize=8, label="Observations") plt.title(r"x* = %.4f, f(x*) = %.4f" % (res.x[0], res.fun)) # Adjust plot layout plt.grid() if n_iter == 0: plt.legend(loc="best", prop={'size': 6}, numpoints=1) if n_iter != 4: plt.tick_params(axis='x', which='both', bottom='off', top='off', labelbottom='off') # Plot EI(x) ax = plt.subplot(max_iters, 2, 2 * n_iter + 2) acq = gaussian_ei(x_gp, gp, y_opt=np.min(curr_func_vals)) plt.plot(x, acq, "b", label="EI(x)") plt.fill_between(x.ravel(), -2.0, acq.ravel(), alpha=0.3, color='blue') if n_iter < max_iters - 1: ax.get_xaxis().set_ticklabels([]) next_acq = gaussian_ei(res.space.transform([next_x]), gp, y_opt=np.min(curr_func_vals)) plt.plot(next_x, next_acq, "bo", markersize=6, label="Next query point") # Adjust plot layout plt.ylim(0, 0.07) plt.grid() if n_iter == 0: plt.legend(loc="best", prop={'size': 6}, numpoints=1) if n_iter != 4: plt.tick_params(axis='x', which='both', bottom='off', top='off', labelbottom='off')
# Plot samples from optimsation points fig.add_trace( go.Scatter(x=curr_x_iters, y=-curr_func_vals, name="Samples from optimisation", visible=False, mode='markers', marker=dict(color='red', size=10)), row=1, col=1, ) # # Plot acquisition function if n_iter > 0: acq = gaussian_ei(x_gp, gp, y_opt=np.min(curr_func_vals)) # fig.add_trace(go.Scatter(name = 'Acquisition function', # x = x_data, # y = acq, # visible=False, # line = {'shape': 'spline', 'color': 'pink'}, # ), # row=2, # col=1 # ) fig.add_trace(go.Scatter(name='Acquisition function', x=x_data, y=acq, visible=False, line={
plt.plot(curr_x_iters, curr_func_vals, "r.", markersize=8, label="Observations") # Adjust plot layout plt.grid() if n_iter == 0: plt.legend(loc="best", prop={'size': 6}, numpoints=1) if n_iter != 4: plt.tick_params(axis='x', which='both', bottom='off', top='off', labelbottom='off') # Plot EI(x) plt.subplot(5, 2, 2*n_iter+2) acq = gaussian_ei(x_gp, gp, y_opt=np.min(curr_func_vals)) plt.plot(x, acq, "b", label="EI(x)") plt.fill_between(x.ravel(), -2.0, acq.ravel(), alpha=0.3, color='blue') next_x = res.x_iters[5+n_iter] next_acq = gaussian_ei(res.space.transform([next_x]), gp, y_opt=np.min(curr_func_vals)) plt.plot(next_x, next_acq, "bo", markersize=6, label="Next query point") # Adjust plot layout plt.ylim(0, 0.1) plt.grid() if n_iter == 0: plt.legend(loc="best", prop={'size': 6}, numpoints=1) if n_iter != 4:
def neg_ei(x): if len(known_values) > 0: a = gaussian_ei(x, model=model, y_opt=y_opt) return -a else: return -1.0
all_x = np.reshape(np.linspace(0, 6, 100), (-1, 1)) all_f = [black_box(xi) for xi in all_x] # Plot all points. plt.plot(all_x, all_f, "green", label="Ground truth") # Train only one third of the training data. X = np.reshape(np.linspace(4, 6, 10), (-1, 1)) y = [black_box(xi) for xi in X] # Use RBF kernel. rbf = RBF(length_scale=1.0) gpr = GaussianProcessRegressor(kernel=rbf, alpha=1e-12) gpr.fit(X, y) y_pred, y_std = gpr.predict(all_x, return_std=True) ei_vals = -gaussian_ei(all_x, gpr, y_opt=np.min(y)) lcb_vals = gaussian_lcb(all_x, gpr) all_x_plot = np.ravel(all_x) upper_bound = y_pred + 1.96 * y_std lower_bound = y_pred - 1.96 * y_std plt.title("Acquisition values.") plt.plot(np.ravel(X), y, "ro") plt.plot(all_x_plot, y_pred, "r", label="Predictions") plt.plot(all_x_plot, ei_vals, "b", label="-EI") plt.plot(all_x_plot, lcb_vals, "black", label="LCB") plt.legend() plt.show()
def plot_bo(f, n, res, noise_level): plt.rcParams["figure.figsize"] = (8, 14) x = np.linspace(0.5, 1.5, 400).reshape(-1, 1) x_gp = res.space.transform(x.tolist()) fx = np.array([f(x_i) for x_i in x]) # Plot the first n iterations print("n = ", n) for n_iter in range(n): print("n_iter = ", n_iter) gp = res.models[n_iter] curr_x_iters = res.x_iters[:n_iter + 1] curr_func_vals = res.func_vals[:n_iter + 1] print("res.func_vals = ", res.func_vals) print("curr_func_vals = ", curr_func_vals) # Plot true function. plt.subplot(n, 2, 2 * n_iter + 1) plt.plot(x, fx, "r--", label="True (unknown)") plt.fill(np.concatenate([x, x[::-1]]), np.concatenate([ fx - 1.9600 * noise_level, fx[::-1] + 1.9600 * noise_level ]), alpha=.2, fc="r", ec="None") # Plot GP(x) + contours y_pred, sigma = gp.predict(x_gp, return_std=True) plt.plot(x, y_pred, "g--", label=r"$\mu_{GP}(x)$") plt.fill(np.concatenate([x, x[::-1]]), np.concatenate([ y_pred - 1.9600 * sigma, (y_pred + 1.9600 * sigma)[::-1] ]), alpha=.2, fc="g", ec="None") # Plot sampled points plt.plot(curr_x_iters, curr_func_vals, "r.", markersize=8, label="Observations") # Adjust plot layout plt.grid() if n_iter == 0: plt.legend(loc="best", prop={'size': 6}, numpoints=1) if n_iter != n: plt.tick_params(axis='x', which='both', bottom='off', top='off', labelbottom='off') # Plot EI(x) plt.subplot(n, 2, 2 * n_iter + 2) # print("x_gp = ", x_gp) # print("curr_func_vals = ", curr_func_vals) # print("min = ", np.min(curr_func_vals)) acq = gaussian_ei(x_gp, gp, y_opt=np.min(curr_func_vals)) plt.plot(x, acq, "b", label="EI(x)") plt.fill_between(x.ravel(), -2.0, acq.ravel(), alpha=0.3, color='blue') next_x = res.x_iters[n_iter] next_acq = gaussian_ei(res.space.transform([next_x]), gp, y_opt=np.min(curr_func_vals)) plt.plot(next_x, next_acq, "bo", markersize=6, label="Next query point") # Adjust plot layout plt.ylim(0, 0.1) plt.grid() if n_iter == 0: plt.legend(loc="best", prop={'size': 6}, numpoints=1) if n_iter != n: plt.tick_params(axis='x', which='both', bottom='off', top='off', labelbottom='off') plt.show()
def main(): # import some data to play with X = [] y = [] with codecs.open("../data/machine.data", 'r', 'utf-8') as infile: for line in infile: tokens = line.split(',') X.append([float(x) for x in tokens[:5]]) y.append(float(tokens[6])) slice = int(round(len(X)*0.8)) X_train = X[:slice] X_test = X[slice:] y_train = y[:slice] y_test = y[slice:] regr = linear_model.Lasso() regr.fit(X_train, y_train) y_predict = [i for i in regr.predict(X_test)] print("loss of the model:{}".format(mean_squared_error(y_test, y_predict))) # apply gridsearch worst_case = float("inf") mse_gs_scores = [] t0 = time.time() for g in [(i+1)*0.001 for i in range(8000)]: regr = linear_model.Lasso(alpha=g) regr.fit(X_train, y_train) y_pred = [i for i in regr.predict(X_test)] mse = mean_squared_error(y_test, y_pred) mse_gs_scores.append([g,mse]) # save if best if mse < worst_case: worst_case = mse best_grid = g t1 = time.time() print("time taken by gridserach: {}".format(t1 - t0)) print((worst_case,best_grid)) # applying random search worst_case = float("inf") mse_rs_scores = [] t0 = time.time() for _ in range(1000): g = uniform(0, 8) regr = linear_model.Lasso(alpha=g) regr.fit(X_train, y_train) y_pred = [i for i in regr.predict(X_test)] mse = mean_squared_error(y_test, y_pred) mse_rs_scores.append([g, mse]) # save if best if mse < worst_case: worst_case = mse best_random = g t1 = time.time() print("time taken by randomserach: {}".format(t1 - t0)) print((worst_case,best_random)) # apply bayesian optimization noise_level = 0.1 def f(alphavalue): regr = linear_model.Lasso(alpha=alphavalue) regr.fit(X_train, y_train) y_pred = [i for i in regr.predict(X_test)] return mean_squared_error(y_test, y_pred) x = np.array([(i+1)*0.001 for i in range(8000)]) fx = [f(x_i) for x_i in x] plt.plot(x, fx, "r--", label="True (unknown)") plt.fill(np.concatenate([x, x[::-1]]), np.concatenate(([fx_i - 1.9600 * noise_level for fx_i in fx], [fx_i + 1.9600 * noise_level for fx_i in fx[::-1]])), alpha=.2, fc="r", ec="None") t4 = time.time() res = gp_minimize(f, # the function to minimize [(0.001, 8.0)], # the bounds on each dimension of x acq_func="EI", # the acquisition function n_calls=15, # the number of evaluations of f n_random_starts=5, # the number of random initialization points random_state=123) t5 = time.time() print("time taken by BO_search: {}".format(t5 - t4)) print(res['fun']) print(res['x']) plt.plot(res.x_iters, res.func_vals, "b--", label="BO") plt.plot([i[0] for i in mse_rs_scores][:10], [i[1] for i in mse_rs_scores][:10], "g--", label="Random Search") plt.legend() plt.grid() plt.show() plt.rcParams["figure.figsize"] = (8, 14) x = np.linspace(0.001, 8.0, 8000).reshape(-1, 1) x_gp = res.space.transform(x.tolist()) fx = np.array([f(x_i) for x_i in x]) # Plot the 5 iterations following the 5 random points for n_iter in range(5): gp = res.models[n_iter] curr_x_iters = res.x_iters[:5 + n_iter] curr_func_vals = res.func_vals[:5 + n_iter] # Plot true function. plt.subplot(5, 2, 2 * n_iter + 1) plt.plot(x, fx, "r--", label="True (unknown)") plt.fill(np.concatenate([x, x[::-1]]), np.concatenate([fx - 1.9600 * noise_level, fx[::-1] + 1.9600 * noise_level]), alpha=.2, fc="r", ec="None") # Plot GP(x) + contours y_pred, sigma = gp.predict(x_gp, return_std=True) plt.plot(x, y_pred, "g--", label=r"$\mu_{GP}(x)$") plt.fill(np.concatenate([x, x[::-1]]), np.concatenate([y_pred - 1.9600 * sigma, (y_pred + 1.9600 * sigma)[::-1]]), alpha=.2, fc="g", ec="None") # Plot sampled points plt.plot(curr_x_iters, curr_func_vals, "r.", markersize=8, label="Observations") # Adjust plot layout plt.grid() if n_iter == 0: plt.legend(loc="best", prop={'size': 6}, numpoints=1) if n_iter != 4: plt.tick_params(axis='x', which='both', bottom='off', top='off', labelbottom='off') # Plot EI(x) plt.subplot(5, 2, 2 * n_iter + 2) acq = gaussian_ei(x_gp, gp, y_opt=np.min(curr_func_vals)) plt.plot(x, acq, "b", label="EI(x)") plt.fill_between(x.ravel(), -2.0, acq.ravel(), alpha=0.3, color='blue') next_x = res.x_iters[5 + n_iter] next_acq = gaussian_ei(res.space.transform([next_x]), gp, y_opt=np.min(curr_func_vals)) plt.plot(next_x, next_acq, "bo", markersize=6, label="Next query point") # Adjust plot layout plt.ylim(0, 0.1) plt.grid() if n_iter == 0: plt.legend(loc="best", prop={'size': 6}, numpoints=1) if n_iter != 4: plt.tick_params(axis='x', which='both', bottom='off', top='off', labelbottom='off') plt.show()
row_no = 6 res = gbrt_minimize( bench3, dimensions, maxiter=6, n_start=1, random_state=1) best_xs = res.x_iters.ravel() best_ys = res.func_vals.ravel() models = res.models for n_iter in range(5): model = models[n_iter] best_x = best_xs[:n_iter+1] best_y = best_ys[:n_iter+1] low, mu, high = model.predict(vals).T std = (high - low) / 2 acquis_values = -gaussian_ei(vals, model, best_y[-1]) acquis_values = acquis_values.ravel() posterior_mean = mu.ravel() posterior_std = std.ravel() upper_bound = posterior_mean + posterior_std lower_bound = posterior_mean - posterior_std plt.subplot(2, 5, col_no) plt.plot(x, func_values, color='red', linestyle="--", label="true func") plt.plot(x, posterior_mean, color='blue', label="GBRT mean") plt.fill_between( x, lower_bound, upper_bound, alpha=0.3, color='blue', label="GBRT std") sampled_y = [bench3(x) for x in best_x] plt.plot(best_x, sampled_y, 'ro', label="observations", markersize=5) plt.title("n_iter = %d" % (n_iter + 1))
def plot_bayes_social(f, res, num_plots, lower_bound, upper_bound): print("Plot Bayes") plot_convergence(res) plt.show() initial_num_true_func_samples = 4000 x = np.linspace(lower_bound, upper_bound, initial_num_true_func_samples).reshape(-1, 1) x_gp = res.space.transform(x.tolist()) for n_iter in range(num_plots): # Print some dubg info. gp = res.models[n_iter] curr_x_iters = res.x_iters[:num_plots + n_iter] curr_func_vals = res.func_vals[:num_plots + n_iter] #print('Iteration', n_iter, ', curr_x_iters = ', curr_x_iters, ', curr_func_vals = ', curr_func_vals) # Plot true function. plt.subplot(num_plots, 2, 2 * n_iter + 1) # fx = np.array([f(x_i) for x_i in range(int(lower_bound), int(upper_bound) + 1)]) true_x = np.linspace(lower_bound, upper_bound, num=100) plt.step(true_x, [f((i, )) for i in true_x], "r--", label="True (unknown)", where='post') # Plot GP(x) + contours y_pred, sigma = gp.predict(x_gp, return_std=True) plt.plot(x, y_pred, "g--", label=r"$\mu_{GP}(x)$") plt.fill(np.concatenate([x, x[::-1]]), np.concatenate([ y_pred - 1.9600 * sigma, (y_pred + 1.9600 * sigma)[::-1] ]), alpha=.2, fc="g", ec="None") # Plot sampled points plt.plot(curr_x_iters, curr_func_vals, "r.", markersize=8, label="Observations") # Adjust plot layout plt.grid() if n_iter == 0: plt.legend(loc="best", prop={'size': 6}, numpoints=1) if n_iter != num_plots - 1: plt.tick_params(axis='x', which='both', bottom='off', top='off', labelbottom='off') # Plot EI(x) plt.subplot(num_plots, 2, 2 * n_iter + 2) acq = gaussian_ei(x_gp, gp, y_opt=np.min(curr_func_vals)) plt.plot(x, acq, "b", label="EI(x)") plt.fill_between(x.ravel(), -2.0, acq.ravel(), alpha=0.3, color='blue') next_x = res.x_iters[num_plots + n_iter] next_acq = gaussian_ei(res.space.transform([next_x]), gp, y_opt=np.min(curr_func_vals)) plt.plot(next_x, next_acq, "bo", markersize=6, label="Next query point") # Adjust plot layout plt.ylim(lower_bound, upper_bound) plt.grid() if n_iter == 0: plt.legend(loc="best", prop={'size': 6}, numpoints=1) if n_iter != num_plots - 1: plt.tick_params(axis='x', which='both', bottom='off', top='off', labelbottom='off') plt.show()