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)