def plot_gp(optimizer, x, y):
fig = plt.figure(figsize=(16, 10))
steps = len(optimizer.space)
fig.suptitle(
'Gaussian Process and Utility Function After {} Steps'.format(steps),
fontdict={'size': 30})
gs = gridspec.GridSpec(2, 1, height_ratios=[3, 1])
axis = plt.subplot(gs[0])
acq = plt.subplot(gs[1])
x_obs = np.array([[res["params"]["c"]] for res in optimizer.res])
y_obs = np.array([res["target"] for res in optimizer.res])
mu, sigma = posterior(optimizer, x_obs, y_obs, x)
axis.plot(x, y, linewidth=3, label='Target')
axis.plot(x_obs.flatten(),
y_obs,
'D',
markersize=8,
label=u'Observations',
color='r')
axis.plot(x, mu, '--', color='k', label='Prediction')
axis.fill(np.concatenate([x, x[::-1]]),
np.concatenate(
[mu - 1.9600 * sigma, (mu + 1.9600 * sigma)[::-1]]),
alpha=.6,
fc='c',
ec='None',
label='95% confidence interval')
axis.set_xlim((2, 4))
axis.set_ylim((None, None))
axis.set_ylabel('Lap Shear Strength (N)', fontdict={'size': 20})
axis.set_xlabel('x', fontdict={'size': 20})
utility_function = UtilityFunction(kind="ei", kappa=5, xi=0.001)
utility = utility_function.utility(x, optimizer._gp, 0)
acq.plot(x, utility, label='Utility Function', color='purple')
acq.plot(x[np.argmax(utility)],
np.max(utility),
'*',
markersize=15,
label=u'Next Best Guess',
markerfacecolor='gold',
markeredgecolor='k',
markeredgewidth=1)
acq.set_xlim((2, 4))
acq.set_ylim((0, np.max(utility) + 300))
acq.set_ylabel('Utility', fontdict={'size': 20})
acq.set_xlabel('x', fontdict={'size': 20})
plt.show()
axis.legend(loc=2, bbox_to_anchor=(1.01, 1), borderaxespad=0.)
acq.legend(loc=2, bbox_to_anchor=(1.01, 1), borderaxespad=0.)
def plot_gp(optimizer, x,
y): #This is a function that plots the optimizer function
fig = plt.figure(figsize=(16, 16))
steps = len(optimizer.space)
#fig.suptitle(
#'Bayesian optimization of a Gaussian process',
#fontdict={'size':30}
#)
plt.rcParams['font.sans-serif'] = "DejaVu Sans"
plt.rcParams['font.family'] = "sans-serif"
gs = gridspec.GridSpec(2, 1, height_ratios=[3, 1])
axis = plt.subplot(gs[0])
acq = plt.subplot(gs[1])
x_obs = np.array([[res["params"]["x"]] for res in optimizer.res])
y_obs = np.array([res["target"] for res in optimizer.res])
mu, sigma = posterior(optimizer, x_obs, y_obs, x)
axis.plot(x, y, linewidth=3, label='Activity')
axis.plot(x_obs.flatten(),
y_obs,
'D',
markersize=3,
label=u'Observations',
color='r')
axis.plot(x, mu, '--', color='k', label='Prediction')
axis.fill(np.concatenate([x, x[::-1]]),
np.concatenate(
[mu - 1.9600 * sigma, (mu + 1.9600 * sigma)[::-1]]),
alpha=.9,
fc='c',
ec='None',
label='95% confidence interval')
axis.set_xlim((firstsample, secondsample))
axis.set_ylim((ylimit1, ylimit2))
axis.set_ylabel('y', fontdict={'size': 15})
axis.set_xlabel('x', fontdict={'size': 15})
utility_function = UtilityFunction(kind="ucb", kappa=1, xi=5)
utility = utility_function.utility(x, optimizer._gp, 0)
acq.plot(x, utility, label='Utility Function', color='green')
# acq.plot(x[np.argmax(utility)], np.max(utility), '*', markersize=15,
# label=u'Next Best Guess', markerfacecolor='gold', markeredgecolor='k', markeredgewidth=1)
acq.set_xlim((firstsample, secondsample))
acq.set_ylim((min(utility), (max(utility)) + min(utility)))
acq.set_ylabel('Utility Function', fontdict={'size': 8})
acq.set_xlabel('Clamping Pressure(bar)', fontdict={'size': 6})
axis.legend(loc=1, borderaxespad=0.5)
acq.legend(loc=1, borderaxespad=0.5)
plt.savefig('./' + str(steps) + '.png', dpi=300)
plt.show()
def plot_gp_1d(gp,
df,
axis,
vector=None,
utility_function=None,
path=None,
dpi=300,
threshold=0.6):
"""
Parameters
----------
gp: gaussian process
df: dataframe of X data with labels, and y data labeled Target
axis: axis of reference by string or index
vector: If given, must correspond to indexing of dataframe
utility_function: instance of UtilityFunction, default to ucb ('greedy') 2.5.
path: path for plot saving if desired
dpi: dots per inch for output figure
threshold: threshold for kernel simialrity measure
Returns
-------
fig
Outputs
-------
Figure as png if given path
"""
# Proccess dataframe
X = df.drop(columns=['Target'])
features = list(X.columns)
y = df.Target
if type(axis) == str:
axis = features.index(axis)
else:
axis = int(axis)
x_max = np.max(X.iloc[:, axis])
x_min = np.min(X.iloc[:, axis])
y_min = np.min(y)
y_max = np.max(y)
if not vector:
vector = np.zeros(X.shape[1])
else:
vector = np.array(vector)
if not utility_function:
utility_function = UtilityFunction(kind="ucb", kappa=2.5, xi=0)
# Prep data for plotting
mask = np.zeros(len(X), dtype=bool)
for i in range(len(X)):
vector[axis] = X.iloc[i, axis]
mask[i] = check_dist(gp, np.array(X.iloc[i]), np.array(vector),
threshold)
x_near = X[mask]
y_near = y[mask]
x_far = X[(mask != True)]
y_far = y[(mask != True)]
x_grid = np.repeat(vector.reshape(1, -1), 10000, axis=0)
x_linspace = np.linspace(x_min, x_max, 10000)
x_grid[:, axis] = x_linspace
x_linspace.reshape(-1, 1)
mu, sigma = posterior(gp, x_grid)
# Prep Figure
fig = plt.figure(figsize=(16, 10))
plt.rcParams['font.sans-serif'] = "DejaVu Sans"
plt.rcParams['font.family'] = "sans-serif"
fp = FontProperties(family="sans-serif", size=24, weight="bold")
vector[axis] = -1
fig.suptitle('Plot along {}'.format(vector)).set_fontproperties(fp)
gs = gridspec.GridSpec(2, 1, height_ratios=[3, 1])
ax = plt.subplot(gs[0])
acq = plt.subplot(gs[1])
# Plot prediction
ax.plot(x_linspace, mu, '--', linewidth=3, color='k', label='Prediction')
ax.fill(np.concatenate([x_linspace, x_linspace[::-1]]),
np.concatenate([mu - 1.9600 * sigma, (mu + 1.9600 * sigma)[::-1]]),
alpha=.6,
fc='c',
ec='None',
label='95% confidence interval')
# Plot observations
ax.plot(x_near.iloc[:, axis],
y_near,
'D',
markersize=8,
label='Local Observations',
color='r')
ax.plot(x_far.iloc[:, axis],
y_far,
'o',
markersize=1,
label='Distant Observations',
color='b')
# Plot settings
vector[axis] = -1
ax.set_xlim((x_min, x_max))
ax.set_ylim((y_min, y_max * 1.1))
ax.set_ylabel('Hydrogen generation', fontdict={'size': 20})
ax.set_xlabel('{}'.format(features[axis]), fontdict={'size': 16})
# Plot Utility
utility = utility_function.utility(x_grid, gp, 0)
acq.plot(x_linspace, utility, label='Utility Function', color='green')
acq.plot(x_linspace[np.argmax(utility)],
np.max(utility),
'*',
markersize=15,
label=u'Next Best Guess',
markerfacecolor='gold',
markeredgecolor='k',
markeredgewidth=1)
acq.set_xlim((x_min, x_max))
acq.set_ylim((np.min(utility) * 0.9, np.max(utility) * 1.1))
acq.set_ylabel('Utility', fontdict={'size': 20})
acq.set_xlabel('{}'.format(features[axis]), fontdict={'size': 16})
ax.legend(loc=1, borderaxespad=0.5)
acq.legend(loc=1, borderaxespad=0.5)
if path: plt.savefig(path, dpi=dpi)
return fig
def plot_gp_2d(gp,
df,
a1,
a2,
vector=None,
utility_function=None,
path=None,
dpi=300,
threshold=0.6,
n_points=200,
scatter=False):
"""
Plots gp along a specific from complete dataset along a specified
vector in space for a given axis. If no vector is given, a zero vector
is assumed.
Points near the vector with respect to the kernel similarity are given
ploted in scatter.
Parameters
==========
gp: gaussian process
df: dataframe of X data with labels, and y data labeled Target
ax1: axis of reference by string or index
ax2: second axis of reference by string or index
vector: If given, must correspond to indexing of dataframe
utility_function: instance of UtilityFunction, default to ucb ('greedy') 2.5.
path: path for plot saving if desired
dpi: dots per inch for figure output
threshold: threshold for kernel simialrity measure
n_points: integer number of points per axis in generating mesh
scatter: logical to include scatter plot of df data
Returns
-------
fig
Outputs
-------
Figure as png if given path
"""
# Proccess dataframe
X = df.drop(columns=['Target'])
features = list(X.columns)
y = df.Target
if type(a1) == str:
a1 = features.index(a1)
else:
a1 = int(a1)
if type(a2) == str:
a2 = features.index(a2)
else:
a2 = int(a2)
x1_max = np.max(X.iloc[:, a1])
x2_max = np.max(X.iloc[:, a2])
x1_min = np.min(X.iloc[:, a1])
x2_min = np.min(X.iloc[:, a2])
y_min = np.min(y)
y_max = np.max(y)
if not vector:
vector = np.zeros(X.shape[1])
else:
vector = np.array(vector)
if not utility_function:
utility_function = UtilityFunction(kind="ucb", kappa=2.5, xi=0)
# Prep data for plotting
mask = np.zeros(len(X), dtype=bool)
for i in range(len(X)):
vector[a1] = X.iloc[i, a1]
vector[a2] = X.iloc[i, a2]
mask[i] = check_dist(gp, np.array(X.iloc[i]), np.array(vector),
threshold)
x_near = X[mask]
y_near = y[mask]
x_far = X[(mask != True)]
y_far = y[(mask != True)]
# Creating complex mesh, unrolling, then predicting
x1_mesh, x2_mesh = np.meshgrid(np.linspace(x1_min, x1_max, n_points),
np.linspace(x2_min, x2_max, n_points))
xx_roll = np.stack([np.ravel(x1_mesh), np.ravel(x2_mesh)], axis=1)
x_grid = np.repeat(vector.reshape(1, -1), xx_roll.shape[0], axis=0)
x_grid[:, a1] = xx_roll[:, 0]
x_grid[:, a2] = xx_roll[:, 1]
mu, sigma = posterior(gp, x_grid)
mu_mesh = mu.reshape(x1_mesh.shape)
sigma_mesh = sigma.reshape(x1_mesh.shape)
utility = utility_function.utility(x_grid, gp, 0)
u_mesh = utility.reshape(x1_mesh.shape)
# Prep Figure
fig = plt.figure(figsize=(20, 20))
plt.rcParams['font.sans-serif'] = "DejaVu Sans"
plt.rcParams['font.family'] = "sans-serif"
ax = plt.subplot(projection='3d')
# Color org
sig_col = cm.Spectral
sm_sig = cm.ScalarMappable(cmap=sig_col)
sm_sig.set_array(sigma_mesh)
u_col = cm.coolwarm
sm_u = cm.ScalarMappable(cmap=u_col)
sm_u.set_array(u_mesh)
mu_col = cm.PuRd
sm_mu = cm.ScalarMappable(cmap=mu_col)
sm_mu.set_array(mu_mesh)
# Plot prediction
surf = ax.plot_surface(x1_mesh,
x2_mesh,
mu_mesh,
cmap=mu_col,
linewidth=0,
antialiased=True,
rstride=1,
cstride=1,
alpha=0.75)
# Bottom utility
contb = ax.contourf(x1_mesh,
x2_mesh,
u_mesh,
zdir='z',
offset=0,
levels=list(
np.arange(np.min(utility), np.max(utility),
0.005)),
cmap=u_col)
# Top (bar on left) uncertainty
contt = ax.contour(x1_mesh,
x2_mesh,
sigma_mesh,
zdir='z',
offset=y_max * 1.1,
levels=list(
np.arange(np.min(sigma), np.max(sigma), 0.05)),
cmap=sig_col)
if scatter:
ax.scatter(x_near.iloc[:, a1], x_near.iloc[:, a2], marker='.', c='k')
# Colorbars
cbaxesr = fig.add_axes([0.88, 0.25, 0.03, 0.5])
cbr = fig.colorbar(sm_mu, ax=ax, cax=cbaxesr)
cbr.set_label('Predicted Mean',
rotation=270,
labelpad=22,
fontdict={'size': 24})
cbaxesb = fig.add_axes([0.25, 0.1, 0.5,
0.03]) # This is the position for the colorbar
cbb = fig.colorbar(sm_u, ax=ax, cax=cbaxesb, orientation='horizontal')
cbb.set_label('Utility Function', fontdict={'size': 24})
cbaxesl = fig.add_axes([0.12, 0.25, 0.03, 0.5])
cbl = fig.colorbar(sm_sig, ax=ax, cax=cbaxesl, orientation='vertical')
cbl.set_label('Uncertainty', rotation=90, fontdict={'size': 24})
cbaxesl.yaxis.set_ticks_position('left')
cbaxesl.yaxis.set_label_position('left')
# Plot observations
# Plot settings
vector[a1] = -1
vector[a2] = -1
ax.set_xlim((x1_min, x1_max))
ax.set_ylim((x2_min, x2_max))
ax.set_zlim((0, y_max * 1.1))
#ax.set_title('Plot along {}'.format(vector), fontdict={'size': 24}, pad=20)
ax.set_zlabel('Hydrogen generation', fontdict={'size': 24}, labelpad=20)
ax.set_xlabel('{}'.format(features[a1], vector),
fontdict={'size': 24},
labelpad=20)
ax.set_ylabel('{}'.format(features[a2], vector),
fontdict={'size': 24},
labelpad=20)
if path: plt.savefig(path, dpi=dpi)
return fig
kwargs = {
'multiprocessing': 1,
'n_warmup': 10
} #n_warmup is the number of times to randomly sample the acquisition function multiprocessing is number of cores for multiprocessing of scipy.minimize
batch_size = 3 #This is the number of observation points in each step
KMBBO_steps = 4
greedy_steps = 2
# Initialize optimizer and utility function
dbo = DiscreteBayesianOptimization(f=None,
prange=prange,
random_state=random_state)
#if UCB is to be used a constant value of kappa is required. UCB returns mean + kappa * std
#if ei is used z = (mean - y_max - xi) / std and it returns (mean - y_max - xi) * norm.cdf(z) + std * norm.pdf(z)
#if POI is used z = (mean - y_max - xi) / std and it returns norm.cdf(z)
utility = UtilityFunction(kind='ucb', kappa=1, xi=5)
########################################################################
def posterior(optimizer, x_obs, y_obs, grid):
optimizer._gp.fit(x_obs, y_obs)
mu, sigma = optimizer._gp.predict(grid, return_std=True)
return mu, sigma
ylimit1 = float(input("Enter the first y-axis limit: "))
ylimit2 = float(input("Enter the second y-axis limit: "))
################################################################################################################################
#Potential Plotting funciton def plot_gp_1d(gp, df, axis, vector=None, utility_function=None, path=None, dpi=300, threshold=0.6):
#gp = gaussian process
acq.set_xlim((2, 4))
acq.set_ylim((0, np.max(utility) + 300))
acq.set_ylabel('Utility', fontdict={'size': 20})
acq.set_xlabel('x', fontdict={'size': 20})
plt.show()
axis.legend(loc=2, bbox_to_anchor=(1.01, 1), borderaxespad=0.)
acq.legend(loc=2, bbox_to_anchor=(1.01, 1), borderaxespad=0.)
optimizer.maximize(init_points=2, n_iter=6)
plot_gp(optimizer, c, y)
#plot_gp(optimizer, c, y)
utility_function = UtilityFunction(kind='ei', kappa=5, xi=0.001)
plt.plot(c, utility_function.utility(c, optimizer._gp, 0), label='1')
print('The max is: ' + str(max(utility_function.utility(c, optimizer._gp, 0))))
g = np.array([2.75]).reshape(-1, 1)
print('Returning a single point: ' +
str(float(utility_function.utility(g, optimizer._gp, 0))))
optimizer.maximize(init_points=0, n_iter=1)
print('The max is: ' + str(max(utility_function.utility(c, optimizer._gp, 0))))
plt.plot(c, utility_function.utility(c, optimizer._gp, 0), label='2')
#plot_gp(optimizer, c, y)
optimizer.maximize(init_points=0, n_iter=1)
print('The max is: ' + str(max(utility_function.utility(c, optimizer._gp, 0))))
plt.plot(c, utility_function.utility(c, optimizer._gp, 0), label='3')
#plot_gp(optimizer, c, y)
from bayesian_optimization import UtilityFunction, BayesianOptimization
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from ThreeDEnv import environment_array
utility_function = UtilityFunction(kind="ei",xi=0,kappa=0)
def target(x,y,z):
return environment_array(x,y,z)
optimizer = BayesianOptimization(target, {'z': (2, 4),'y':(40,65),'x':(1000,4000)}, random_state=250)
#optimizer.maximize(init_points=int(input('Enter the number of random steps: ')),n_iter=0)
'''probe_point(np.min(x),np.max(y))
probe_point(np.max(x),np.max(y))
probe_point(np.max(x),np.min(y))'''
def probe_point(x,y,z):
return optimizer.probe(params={"x": x, "y": y, "z": z},lazy=True,)
probe_point(1000,40,2)
probe_point(1000,40,4)
probe_point(4000,40,4)
probe_point(4000,65,4)
probe_point(4000,65,2)
probe_point(1000,65,2)
probe_point(1000,65,4)