def visualize_lcb(initial_design, init=None):
"""
Visualize one-step of LCB.
:param initial_design: Method for initializing the GP, choice between 'uniform', 'random', and 'presentation'
:param init: Number of datapoints to initialize GP with.
:return: None
"""
# 1. Plot 3 different confidence envelopes
# 2. Plot only LCB for one confidence envelope
# 3. Mark next sample
boplot.set_rcparams(**{'legend.loc': 'lower right'})
logging.debug("Visualizing PI with initial design {} and init {}".format(initial_design, init))
# Initialize dummy dataset
x, y = initialize_dataset(initial_design=initial_design, init=init)
logging.debug("Initialized dataset with:\nsamples {0}\nObservations {1}".format(x, y))
# Fit GP to the currently available dataset
gp = GPR(kernel=Matern())
logging.debug("Fitting GP to\nx: {}\ny:{}".format(x, y))
gp.fit(x, y) # fit the model
# noinspection PyStringFormat
logging.debug("Model fit to dataset.\nOriginal Inputs: {0}\nOriginal Observations: {1}\n"
"Predicted Means: {2}\nPredicted STDs: {3}".format(x, y, *(gp.predict(x, return_std=True))))
# 1. Plot 3 different confidence envelopes
# -------------Plotting code -----------------
fig, ax = plt.subplots(1, 1, squeeze=True)
ax.set_xlim(bounds["x"])
ax.set_ylim(bounds["gp_y"])
ax.grid()
boplot.plot_gp(model=gp, confidence_intervals=[1.0, 2.0, 3.0], type='both', custom_x=x, ax=ax)
boplot.plot_objective_function(ax=ax)
boplot.mark_observations(X_=x, Y_=y, mark_incumbent=False, highlight_datapoint=None, highlight_label=None, ax=ax)
ax.legend().set_zorder(zorders['legend'])
ax.set_xlabel(labels['xlabel'])
plt.tight_layout()
if TOGGLE_PRINT:
plt.savefig(f"{OUTPUT_DIR}/lcb_1.pdf")
else:
plt.show()
# -------------------------------------------
# 2. Plot only LCB for one confidence envelope
# -------------Plotting code -----------------
boplot.set_rcparams(**{'legend.loc': 'upper left'})
kappa = 3.0
fig, ax = plt.subplots(1, 1, squeeze=True)
ax.set_xlim(bounds["x"])
ax.set_ylim(bounds["gp_y"])
ax.grid()
boplot.plot_gp(model=gp, confidence_intervals=[kappa], type='lower', custom_x=x, ax=ax)
boplot.plot_objective_function(ax=ax)
boplot.mark_observations(X_=x, Y_=y, mark_incumbent=True, highlight_datapoint=None, highlight_label=None, ax=ax)
ax.legend().set_zorder(zorders['legend'])
ax.set_xlabel(labels['xlabel'])
plt.tight_layout()
if TOGGLE_PRINT:
plt.savefig(f"{OUTPUT_DIR}/lcb_2.pdf")
else:
plt.show()
def visualize_es(initial_design, init=None):
"""
Visualize one-step of ES.
:param initial_design: Method for initializing the GP, choice between 'uniform', 'random', and 'presentation'
:param init: Number of datapoints to initialize GP with.
:return: None
"""
# 1. Show GP fit on initial dataset, 0 samples, histogram
# 2. Show GP fit on initial dataset, 1 sample, histogram
# 3. Show GP fit on initial dataset, 3 samples, histogram
# 4. Show GP fit on initial dataset, 50 samples, histogram
# 5. Show PDF derived from the histogram at 50 samples
# 6. Mark maximum of the PDF as next configuration to be evaluated
# a. Plot GP
# b. Sample GP, mark minima, update histogram of lambda*
# c. Repeat 2 for each sample.
# d. Show results after multiple iterations
boplot.set_rcparams(**{'figure.figsize': (22, 11)})
# Initial setup
# -------------------------------------------
logging.debug("Visualizing ES with initial design {} and init {}".format(
initial_design, init))
# Initialize dummy dataset
x, y = initialize_dataset(initial_design=initial_design, init=init)
logging.debug(
"Initialized dataset with:\nsamples {0}\nObservations {1}".format(
x, y))
# Fit GP to the currently available dataset
gp = GPR(kernel=Matern())
logging.debug("Fitting GP to\nx: {}\ny:{}".format(x, y))
gp.fit(x, y) # fit the model
histogram_precision = 20
X_ = boplot.get_plot_domain(precision=histogram_precision)
nbins = X_.shape[0]
logging.info("Creating histograms with {} bins".format(nbins))
bin_range = (bounds['x'][0], bounds['x'][1] + 1 / histogram_precision)
# -------------------------------------------
def draw_samples(nsamples, ax1, ax2, show_min=False, return_pdf=False):
if not nsamples:
return
seed2 = 1256
seed3 = 65
mu = gp.sample_y(X=X_, n_samples=nsamples, random_state=seed3)
boplot.plot_gp_samples(mu=mu,
nsamples=nsamples,
precision=histogram_precision,
custom_x=X_,
show_min=show_min,
ax=ax1,
seed=seed2)
data_h = X_[np.argmin(mu, axis=0), 0]
logging.info("Shape of data_h is {}".format(data_h.shape))
logging.debug("data_h is: {}".format(data_h))
bins = ax2.hist(data_h,
bins=nbins,
range=bin_range,
density=return_pdf,
color='lightgreen',
edgecolor='black',
alpha=0.0 if return_pdf else 1.0)
return bins
# 1. Show GP fit on initial dataset, 0 samples, histogram
# -------------------------------------------
ax2_title = r'$p_{min}=P(\lambda=\lambda^*)$'
bounds['acq_y'] = (0.0, 1.0)
fig, (ax1, ax2) = plt.subplots(2, 1, squeeze=True)
ax1.set_xlim(bounds['x'])
ax1.set_ylim(bounds['gp_y'])
ax2.set_xlim(bounds['x'])
ax2.set_ylim(bounds['acq_y'])
ax1.grid()
ax2.grid()
boplot.plot_objective_function(ax=ax1)
boplot.plot_gp(model=gp, confidence_intervals=[3.0], ax=ax1, custom_x=x)
boplot.mark_observations(X_=x, Y_=y, mark_incumbent=False, ax=ax1)
nsamples = 0
draw_samples(nsamples=nsamples, ax1=ax1, ax2=ax2, show_min=True)
# Plot uniform prior for p_min
xplot = boplot.get_plot_domain()
ylims = ax2.get_ylim()
xlims = ax2.get_xlim()
yupper = [(ylims[1] - ylims[0]) / (xlims[1] - xlims[0])] * xplot.shape[0]
ax2.plot(xplot[:, 0], yupper, color='green', linewidth=2.0)
ax2.fill_between(xplot[:, 0], ylims[0], yupper, color='lightgreen')
ax1.legend().set_zorder(20)
ax1.set_xlabel(labels['xlabel'])
ax1.set_ylabel(labels['gp_ylabel'])
ax1.set_title(r"Visualization of $\mathcal{G}^t$", loc='left')
ax2.set_xlabel(labels['xlabel'])
ax2.set_ylabel(r'$p_{min}$')
ax2.set_title(ax2_title, loc='left')
plt.tight_layout()
if TOGGLE_PRINT:
plt.savefig('es_1')
else:
plt.show()
# -------------------------------------------
# 2. Show GP fit on initial dataset, 1 sample, histogram
# -------------------------------------------
bounds['acq_y'] = (0.0, 5.0)
ax2_title = r'Frequency of $\lambda=\hat{\lambda}^*$'
fig, (ax1, ax2) = plt.subplots(2, 1, squeeze=True)
ax1.set_xlim(bounds['x'])
ax1.set_ylim(bounds['gp_y'])
ax2.set_xlim(bounds['x'])
ax2.set_ylim(bounds['acq_y'])
ax1.grid()
ax2.grid()
boplot.plot_objective_function(ax=ax1)
boplot.mark_observations(X_=x, Y_=y, mark_incumbent=False, ax=ax1)
nsamples = 1
draw_samples(nsamples=nsamples, ax1=ax1, ax2=ax2, show_min=True)
ax1.legend().set_zorder(20)
ax1.set_xlabel(labels['xlabel'])
ax1.set_ylabel(labels['gp_ylabel'])
ax1.set_title(r"One sample from $\mathcal{G}^t$", loc='left')
ax2.set_xlabel(labels['xlabel'])
# ax2.set_ylabel(r'$p_{min}$')
ax2.set_ylabel(r'Frequency')
ax2.set_title(ax2_title, loc='left')
plt.tight_layout()
if TOGGLE_PRINT:
plt.savefig('es_2')
else:
plt.show()
# 3. Show GP fit on initial dataset, 10 samples, histogram
# -------------------------------------------
bounds['acq_y'] = (0.0, 10.0)
ax2_title = r'Frequency of $\lambda=\hat{\lambda}^*$'
fig, (ax1, ax2) = plt.subplots(2, 1, squeeze=True)
ax1.set_xlim(bounds['x'])
ax1.set_ylim(bounds['gp_y'])
ax2.set_xlim(bounds['x'])
ax2.set_ylim(bounds['acq_y'])
ax1.grid()
ax2.grid()
boplot.plot_objective_function(ax=ax1)
boplot.mark_observations(X_=x, Y_=y, mark_incumbent=False, ax=ax1)
nsamples = 10
draw_samples(nsamples=nsamples, ax1=ax1, ax2=ax2)
ax1.set_xlabel(labels['xlabel'])
ax1.set_ylabel(labels['gp_ylabel'])
ax1.set_title(r"Ten samples from $\mathcal{G}^t$", loc='left')
ax2.set_xlabel(labels['xlabel'])
# ax2.set_ylabel(r'$p_{min}$')
ax2.set_ylabel(r'Frequency')
ax2.set_title(ax2_title, loc='left')
plt.tight_layout()
if TOGGLE_PRINT:
plt.savefig('es_3')
else:
plt.show()
# -------------------------------------------
# 4. Show GP fit on initial dataset, 200 samples, histogram
# -------------------------------------------
bounds["acq_y"] = (0.0, 20.0)
ax2_title = r'Frequency of $\lambda=\hat{\lambda}^*$'
fig, (ax1, ax2) = plt.subplots(2, 1, squeeze=True)
ax1.set_xlim(bounds['x'])
ax1.set_ylim(bounds['gp_y'])
ax2.set_xlim(bounds['x'])
ax2.set_ylim(bounds['acq_y'])
ax1.grid()
ax2.grid()
boplot.plot_objective_function(ax=ax1)
boplot.mark_observations(X_=x, Y_=y, mark_incumbent=False, ax=ax1)
nsamples = 200
draw_samples(nsamples=nsamples, ax1=ax1, ax2=ax2)
ax1.set_xlabel(labels['xlabel'])
ax1.set_ylabel(labels['gp_ylabel'])
ax1.set_title(r"200 samples from $\mathcal{G}^t$", loc='left')
ax2.set_xlabel(labels['xlabel'])
# ax2.set_ylabel(r'$p_{min}$')
ax2.set_ylabel(r'Frequency')
ax2.set_title(ax2_title, loc='left')
plt.tight_layout()
if TOGGLE_PRINT:
plt.savefig('es_4')
else:
plt.show()
# -------------------------------------------
# 5. Show PDF derived from the histogram at 200 samples
# -------------------------------------------
ax2_title = "$\hat{P}(\lambda=\lambda^*)$"
bounds["acq_y"] = (0.0, 1.0)
fig, (ax1, ax2) = plt.subplots(2, 1, squeeze=True)
ax1.set_xlim(bounds['x'])
ax1.set_ylim(bounds['gp_y'])
ax2.set_xlim(bounds['x'])
ax2.set_ylim(bounds["acq_y"])
ax1.grid()
ax2.grid()
boplot.plot_objective_function(ax=ax1)
boplot.plot_gp(model=gp, confidence_intervals=[3.0], ax=ax1, custom_x=x)
boplot.mark_observations(X_=x, Y_=y, mark_incumbent=False, ax=ax1)
nsamples = 200
seed3 = 65
mu = gp.sample_y(X=X_, n_samples=nsamples, random_state=seed3)
data_h = X_[np.argmin(mu, axis=0), 0]
kde = kd(kernel='gaussian', bandwidth=0.75).fit(data_h.reshape(-1, 1))
xplot = boplot.get_plot_domain()
ys = np.exp(kde.score_samples(xplot))
ax2.plot(xplot, ys, color='green', lw=2.)
ax2.fill_between(xplot[:, 0], ax2.get_ylim()[0], ys, color='lightgreen')
ax1.set_xlabel(labels['xlabel'])
ax1.set_ylabel(labels['gp_ylabel'])
ax1.set_title(r"Visualization of $\mathcal{G}^t$", loc='left')
ax2.set_xlabel(labels['xlabel'])
ax2.set_ylabel(r'$p_{min}$')
ax2.set_title(ax2_title, loc='left')
plt.tight_layout()
if TOGGLE_PRINT:
plt.savefig('es_5')
else:
plt.show()
# -------------------------------------------
# 6. Mark maximum of the PDF as next configuration to be evaluated
# -------------------------------------------
ax2_title = "$\hat{P}(\lambda=\lambda^*)$"
bounds["acq_y"] = (0.0, 1.0)
fig, (ax1, ax2) = plt.subplots(2, 1, squeeze=True)
ax1.set_xlim(bounds['x'])
ax1.set_ylim(bounds['gp_y'])
ax2.set_xlim(bounds['x'])
ax2.set_ylim(bounds["acq_y"])
ax1.grid()
ax2.grid()
boplot.plot_objective_function(ax=ax1)
boplot.plot_gp(model=gp, confidence_intervals=[3.0], ax=ax1, custom_x=x)
boplot.mark_observations(X_=x, Y_=y, mark_incumbent=False, ax=ax1)
nsamples = 200
seed3 = 65
mu = gp.sample_y(X=X_, n_samples=nsamples, random_state=seed3)
data_h = X_[np.argmin(mu, axis=0), 0]
kde = kd(kernel='gaussian', bandwidth=0.75).fit(data_h.reshape(-1, 1))
xplot = boplot.get_plot_domain()
ys = np.exp(kde.score_samples(xplot))
idx_umax = np.argmax(ys)
boplot.highlight_configuration(x=xplot[idx_umax],
label='',
ax=ax1,
disable_ticks=True)
boplot.annotate_x_edge(label=r'$\lambda^{(t)}$',
xy=(xplot[idx_umax], ax1.get_ylim()[0]),
ax=ax1,
align='top',
offset_param=1.5)
boplot.highlight_configuration(x=xplot[idx_umax],
label='',
ax=ax2,
disable_ticks=True)
boplot.annotate_x_edge(label=r'$\lambda^{(t)}$',
xy=(xplot[idx_umax], ys[idx_umax]),
ax=ax2,
align='top',
offset_param=1.0)
ax2.plot(xplot, ys, color='green', lw=2.)
ax2.fill_between(xplot[:, 0], ax2.get_ylim()[0], ys, color='lightgreen')
ax1.set_xlabel(labels['xlabel'])
ax1.set_ylabel(labels['gp_ylabel'])
ax1.set_title(r"Visualization of $\mathcal{G}^t$", loc='left')
ax2.set_xlabel(labels['xlabel'])
ax2.set_ylabel(r'$p_{min}$')
ax2.set_title(ax2_title, loc='left')
plt.tight_layout()
if TOGGLE_PRINT:
plt.savefig('es_6')
else:
plt.show()
def visualize_lcb(initial_design, init=None):
"""
Visualize one-step of LCB.
:param initial_design: Method for initializing the GP, choice between 'uniform', 'random', and 'presentation'
:param init: Number of datapoints to initialize GP with.
:return: None
"""
# 1. Plot 3 different confidence envelopes
# 2. Plot only LCB for one confidence envelope
# 3. Mark next sample
boplot.set_rcparams(**{'legend.loc': 'lower right'})
logging.debug("Visualizing PI with initial design {} and init {}".format(
initial_design, init))
# Initialize dummy dataset
x, y = initialize_dataset(initial_design=initial_design, init=init)
logging.debug(
"Initialized dataset with:\nsamples {0}\nObservations {1}".format(
x, y))
# Fit GP to the currently available dataset
gp = GPR(kernel=Matern())
logging.debug("Fitting GP to\nx: {}\ny:{}".format(x, y))
gp.fit(x, y) # fit the model
# noinspection PyStringFormat
logging.debug(
"Model fit to dataset.\nOriginal Inputs: {0}\nOriginal Observations: {1}\n"
"Predicted Means: {2}\nPredicted STDs: {3}".format(
x, y, *(gp.predict(x, return_std=True))))
# 1. Plot 3 different confidence envelopes
# -------------Plotting code -----------------
fig, ax = plt.subplots(1, 1, squeeze=True)
ax.set_xlim(bounds["x"])
ax.set_ylim(bounds["gp_y"])
ax.grid()
boplot.plot_gp(model=gp,
confidence_intervals=[1.0, 2.0, 3.0],
type='both',
custom_x=x,
ax=ax)
boplot.plot_objective_function(ax=ax)
boplot.mark_observations(X_=x,
Y_=y,
mark_incumbent=False,
highlight_datapoint=None,
highlight_label=None,
ax=ax)
ax.legend().set_zorder(20)
ax.set_xlabel(labels['xlabel'])
ax.set_ylabel(labels['gp_ylabel'])
ax.set_title(r"Visualization of $\mathcal{G}^{(t)}$", loc='left')
plt.tight_layout()
if TOGGLE_PRINT:
plt.savefig("lcb_1.pdf")
else:
plt.show()
# -------------------------------------------
# 2. Plot only LCB for one confidence envelope
# -------------Plotting code -----------------
boplot.set_rcparams(**{'legend.loc': 'upper left'})
kappa = 3.0
fig, ax = plt.subplots(1, 1, squeeze=True)
ax.set_xlim(bounds["x"])
ax.set_ylim(bounds["gp_y"])
ax.grid()
boplot.plot_gp(model=gp,
confidence_intervals=[kappa],
type='lower',
custom_x=x,
ax=ax)
boplot.plot_objective_function(ax=ax)
boplot.mark_observations(X_=x,
Y_=y,
mark_incumbent=True,
highlight_datapoint=None,
highlight_label=None,
ax=ax)
ax.legend().set_zorder(20)
ax.set_xlabel(labels['xlabel'])
ax.set_ylabel(labels['gp_ylabel'])
ax.set_title(r"Visualization of $\mathcal{G}^{(t)}$", loc='left')
plt.tight_layout()
if TOGGLE_PRINT:
plt.savefig("lcb_2.pdf")
else:
plt.show()
# -------------------------------------------
# 3. Show LCB in parallel
# -------------Plotting code -----------------
if TOGGLE_PRINT:
fig, (ax1, ax2) = plt.subplots(2, 1, squeeze=True, figsize=(18, 9))
else:
fig, (ax1, ax2) = plt.subplots(2, 1, squeeze=True)
ax1.set_xlim(bounds["x"])
ax1.set_ylim(bounds["gp_y"])
ax1.grid()
boplot.plot_gp(model=gp,
confidence_intervals=[kappa],
type='lower',
custom_x=x,
ax=ax1)
boplot.plot_objective_function(ax=ax1)
boplot.mark_observations(X_=x,
Y_=y,
mark_incumbent=True,
highlight_datapoint=None,
highlight_label=None,
ax=ax1)
lcb_max = get_lcb_maximum(gp, kappa)
logging.info("LCB Maximum at:{}".format(lcb_max))
boplot.highlight_configuration(x=lcb_max[0],
label=None,
lloc='bottom',
ax=ax1)
ax1.set_xlabel(labels['xlabel'])
ax1.set_ylabel(labels['gp_ylabel'])
ax1.set_title(r"Visualization of $\mathcal{G}^{(t)}$", loc='left')
ax2.set_xlim(bounds["x"])
ax2.set_ylim(bounds["acq_y"])
ax2.grid()
ax2.set_xlabel(labels['xlabel'])
ax2.set_ylabel(labels['acq_ylabel'])
ax2.set_title(r"Visualization of $LCB$", loc='left')
boplot.highlight_configuration(x=lcb_max[0],
label=None,
lloc='bottom',
ax=ax2)
boplot.plot_acquisition_function(acquisition_functions['LCB'],
0.0,
gp,
kappa,
ax=ax2)
plt.tight_layout()
if TOGGLE_PRINT:
plt.savefig("lcb_3.pdf")
else:
plt.show()
# -------------------------------------------
# 4. Mark next sample
# -------------Plotting code -----------------
fig, ax = plt.subplots(1, 1, squeeze=True)
ax.set_xlim(bounds["x"])
ax.set_ylim(bounds["gp_y"])
ax.grid()
boplot.plot_gp(model=gp,
confidence_intervals=[3.0],
type='lower',
custom_x=x,
ax=ax)
boplot.plot_objective_function(ax=ax)
boplot.mark_observations(X_=x,
Y_=y,
mark_incumbent=True,
highlight_datapoint=None,
highlight_label=None,
ax=ax)
lcb_max = get_lcb_maximum(gp, 3.0)
logging.info("LCB Maximum at:{}".format(lcb_max))
boplot.highlight_configuration(x=lcb_max[0],
label=None,
lloc='bottom',
ax=ax)
boplot.highlight_output(y=lcb_max[1], label='', lloc='left', ax=ax)
boplot.annotate_y_edge(label=r'${\hat{c}}^{(t)}(%.2f)$' % lcb_max[0],
xy=lcb_max,
align='left',
ax=ax)
ax.legend().set_zorder(20)
ax.set_xlabel(labels['xlabel'])
ax.set_ylabel(labels['gp_ylabel'])
ax.set_title(r"Visualization of $\mathcal{G}^{(t)}$", loc='left')
ax.legend().remove()
plt.tight_layout()
if TOGGLE_PRINT:
plt.savefig("lcb_4.pdf")
else:
plt.show()
def visualize_ts(initial_design, init=None):
"""
Visualize one-step of TS.
:param initial_design: Method for initializing the GP, choice between 'uniform', 'random', and 'presentation'
:param init: Number of datapoints to initialize GP with.
:return: None
"""
# 1. Plot GP fit on initial dataset
# 2. Plot one sample
# 3. Mark minimum of sample
boplot.set_rcparams(**{'legend.loc': 'upper left'})
logging.debug("Visualizing EI with initial design {} and init {}".format(
initial_design, init))
# Initialize dummy dataset
x, y = initialize_dataset(initial_design=initial_design, init=init)
ymin_arg = np.argmin(y)
ymin = y[ymin_arg]
logging.debug(
"Initialized dataset with:\nsamples {0}\nObservations {1}".format(
x, y))
# Fit GP to the currently available dataset
gp = GPR(kernel=Matern())
logging.debug("Fitting GP to\nx: {}\ny:{}".format(x, y))
gp.fit(x, y) # fit the model
# noinspection PyStringFormat
logging.debug(
"Model fit to dataset.\nOriginal Inputs: {0}\nOriginal Observations: {1}\n"
"Predicted Means: {2}\nPredicted STDs: {3}".format(
x, y, *(gp.predict(x, return_std=True))))
# 1. Plot GP fit on initial dataset
# -------------Plotting code -----------------
fig, ax = plt.subplots(1, 1, squeeze=True)
ax.set_xlim(bounds["x"])
ax.set_ylim(bounds["gp_y"])
ax.grid()
boplot.plot_gp(model=gp,
confidence_intervals=[1.0, 2.0, 3.0],
custom_x=x,
ax=ax)
boplot.plot_objective_function(ax=ax)
boplot.mark_observations(X_=x,
Y_=y,
mark_incumbent=False,
highlight_datapoint=None,
highlight_label=None,
ax=ax)
ax.legend().set_zorder(zorders['legend'])
ax.set_xlabel(labels['xlabel'])
plt.tight_layout()
if TOGGLE_PRINT:
plt.savefig(f"{OUTPUT_DIR}/ts_1.pdf")
else:
plt.show()
# -------------------------------------------
# 2. Plot one sample
# -------------Plotting code -----------------
fig, ax = plt.subplots(1, 1, squeeze=True)
ax.set_xlim(bounds["x"])
ax.set_ylim(bounds["gp_y"])
ax.grid()
boplot.plot_gp(model=gp,
confidence_intervals=[1.0, 2.0, 3.0],
custom_x=x,
ax=ax)
boplot.plot_objective_function(ax=ax)
boplot.mark_observations(X_=x,
Y_=y,
mark_incumbent=False,
highlight_datapoint=None,
highlight_label=None,
ax=ax)
# Sample from the GP
nsamples = 1
seed2 = 2
seed3 = 1375
X_ = boplot.get_plot_domain(precision=None)
mu = gp.sample_y(X=X_, n_samples=nsamples, random_state=seed3)
boplot.plot_gp_samples(mu=mu,
nsamples=nsamples,
precision=None,
custom_x=X_,
show_min=False,
ax=ax,
seed=seed2)
ax.legend().set_zorder(zorders['legend'])
ax.set_xlabel(labels['xlabel'])
plt.tight_layout()
if TOGGLE_PRINT:
plt.savefig(f"{OUTPUT_DIR}/ts_2.pdf")
else:
plt.show()
# -------------------------------------------
# 3. Mark minimum of sample
# -------------Plotting code -----------------
fig, ax = plt.subplots(1, 1, squeeze=True)
ax.set_xlim(bounds["x"])
ax.set_ylim(bounds["gp_y"])
ax.grid()
# boplot.plot_gp(model=gp, confidence_intervals=[2.0], custom_x=x, ax=ax)
boplot.plot_objective_function(ax=ax)
boplot.mark_observations(X_=x,
Y_=y,
mark_incumbent=False,
highlight_datapoint=None,
highlight_label=None,
ax=ax)
# Sample from the GP
nsamples = 1
X_ = boplot.get_plot_domain(precision=None)
mu = gp.sample_y(X=X_, n_samples=nsamples, random_state=seed3)
colors['highlighted_observations'] = 'red' # Special for Thompson Sampling
boplot.plot_gp_samples(mu=mu,
nsamples=nsamples,
precision=None,
custom_x=X_,
show_min=True,
ax=ax,
seed=seed2)
min_idx = np.argmin(mu, axis=0)
candidate = X_[min_idx]
cost = mu[min_idx]
boplot.highlight_configuration(x=np.array([candidate]),
label='',
lloc='bottom',
disable_ticks=True,
ax=ax)
boplot.annotate_x_edge(label=r'$\lambda^{(t)}$',
xy=(candidate, cost),
align='top',
ax=ax)
boplot.highlight_output(y=np.array([cost]),
label='',
lloc='left',
disable_ticks=True,
ax=ax)
boplot.annotate_y_edge(label=r'$g(\lambda^{(t)})$',
xy=(candidate, cost),
align='left',
ax=ax)
ax.legend().set_zorder(zorders['legend'])
ax.set_xlabel(labels['xlabel'])
plt.tight_layout()
if TOGGLE_PRINT:
plt.savefig(f"{OUTPUT_DIR}/ts_3.pdf")
else:
plt.show()