def sample_pareto_fronts(self, num_of_design_samples=5, num_of_gp=5, num_of_design_points=1000, verbose=False): """ Samples a plaussible pareto front. NOTE: Only works if design is the unit hyper-cube. """ import design Y_p = [] for _ in xrange(num_of_design_samples): X_design = design.latin_center(num_of_design_points, self.X.shape[1]) Y = [] for m in self.surrogates: _m = copy.copy(m) _m.Gaussian_noise.variance.unconstrain() _m.Gaussian_noise.variance.fix(1e-8) y = _m.posterior_samples(X_design, size=num_of_gp, full_cov=True) Y.append(y) Y = np.array(Y) for i in xrange(Y.shape[2]): if verbose: print 'sampling pareto', _, i idx = get_idx_of_observed_pareto_front(Y[:, :, i].T) y_p = Y[:, idx, i].T Y_p.append(y_p) return Y_p
def new_optimization(): global inputs, outputs, l_bounds, u_bounds, max_it, x_datalist, y_datalist, csv_valid, pareto_data, designs, bounds, initial_x_designs, mk_plots response = None my_log.write('New optimization...\n') if check_observations(): Rappture.Utils.progress(10, "New model being created...") out_dir = 'surf_test_results_noisy_moo' if os.path.isdir(out_dir): shutil.rmtree(out_dir) os.makedirs(out_dir) X_init = np.array(x_datalist) Y_init = np.array(y_datalist) if bounds: my_log.write('Bounds given...\n') a = literal_eval(l_bounds) b = literal_eval(u_bounds) a = np.array(a) b = np.array(b) X_design = (b-a)*design.latin_center(1000, len(X_init[0]), seed=314519) + a else: my_log.write('Initial designs given:\n' + str(initial_x_designs) + '\n') X_design = initial_x_designs my_log.write('Dimensionality of X: ' + str(len(X_init[0])) + '\n') my_log.write('Dimensionality of Y: ' + str(len(Y_init[0])) + '\n') if len(Y_init[0]) <= 2: mk_plots = True else: mk_plots = False my_log.write('Creating Pareto model...\n') pareto_model = ParetoFront(X_init, Y_init, X_design=X_design, gp_opt_num_restarts=50, verbose=False, max_it=max_it, make_plots=mk_plots, add_at_least=30, get_fig=get_full_fig, fig_prefix=os.path.join(out_dir,'ex1'), Y_true_pareto=None, gp_fixed_noise=None, samp=100, denoised=True) my_log.write('Pareto model created...\n') Rappture.Utils.progress(20, "Performing optimization algorithm...") my_log.write('Starting optimization algorithm...\n') pareto_model.optimize_paused() response = pareto_model.response pareto_data = pareto_model.get_pareto_data() designs = pareto_model.get_X_design() my_log.write('Optimization finished, saving the model...\n') Rappture.Utils.progress(60, "Saving the model...") model_file = open('model.obj','wb') pkl.dump(pareto_model, model_file, pkl.HIGHEST_PROTOCOL) model_file.close() my_log.write('Process completed...\n') Rappture.Utils.progress(100, "Done...") else: my_log.write('Incorrect input values, finishing execution...\n') response = 'Incorrect tuples for new model' return response
def new_optimization(): global inputs, outputs, l_bounds, u_bounds, max_it, x_datalist, y_datalist, csv_valid response = None my_log.write('New optimization...\n') if check_observations(): Rappture.Utils.progress(10, "New model being created...") out_dir = 'surf_test_results_noisy_moo' if os.path.isdir(out_dir): shutil.rmtree(out_dir) os.makedirs(out_dir) if csv_valid: X_init = x_datalist Y_init = y_datalist else: X_init = literal_eval(inputs) Y_init = literal_eval(outputs) X_init = np.array(X_init) Y_init = np.array(Y_init) a = literal_eval(l_bounds) b = literal_eval(u_bounds) a = np.array(a) b = np.array(b) X_design = (b - a) * design.latin_center(1000, 2, seed=314519) + a pareto_model = ParetoFront(X_init, Y_init, X_design=X_design, gp_opt_num_restarts=50, verbose=False, max_it=max_it, make_plots=True, add_at_least=30, get_fig=get_full_fig, fig_prefix=os.path.join(out_dir, 'ex1'), Y_true_pareto=None, gp_fixed_noise=None, samp=100, denoised=True) Rappture.Utils.progress(20, "Performing optimization algorithm...") pareto_model.optimize_paused() response = pareto_model.response Rappture.Utils.progress(60, "Saving the model...") model_file = open('model.obj', 'wb') pkl.dump(pareto_model, model_file, pkl.HIGHEST_PROTOCOL) model_file.close() Rappture.Utils.progress(100, "Done...") else: response = 'Incorrect tuples for new model' return response
def propose_experiment_paused(self, it): """ Optimize the objectives and propose just 1 experiment, then saves the state of the program """ if self.verbose: print 'step {0:s}'.format(str(it).zfill(len(str(self.max_it)))) #print '\t> training surrogates' #self.train_surrogates() # Are we drawing new design points or not? if isinstance(self.X_design, int): num_design = self.X_design X_design = design.latin_center(num_design, self.num_dim) else: X_design = self.X_design if self.verbose: print '\t> done' print '\t> computing expected improvement' ei = self.compute_expected_improvement(X_design) if self.verbose: print '\t> done' i = np.argmax(ei) ei_max = ei[i] self.ei_values.append(ei_max) rel_ei_max = ei_max / self.ei_values[0] if self.verbose: print '\t> rel_ei_max = {0:1.3f}'.format(rel_ei_max) if it >= self.add_at_least and rel_ei_max < self.rtol: if self.verbose: print '*** Converged (rel_ei_max = {0:1.7f} < rtol = {1:1.2e})'.format( rel_ei_max, self.rtol) print '\t> writing final status' self.plot_status(it, final=True) return if self.verbose: print '\t> adding design point', i print '\t> X_d[i, :]', X_design[i, :] print '\t> starting simulation' #print self.Y_pareto k = self.active_cells #for k in k: #print k lplus = self.active_cells_lplus #for lplus in lplus: #print lplus #y = self.obj_funcs(X_design[i,:]) #print "Run the experiment/code at the following design"+str(X_design[i,:]) self.response = "Run the experiment/code at the following design" + str( X_design[i, :]) self.X_design_paused = X_design self.i_paused = i
def normal_execution(): #The following three lines are useful only if the code is being used to #solve a known problem, like the above. #assert len(sys.argv)==3 #noise = float(sys.argv[1]) #n = int(sys.argv[2]) #ObjFunc_noise = ObjFunc(noise,1) #ObjFunc_true = ObjFunc(noise,100) # The noisy objective function `dtlz1a`. # def obj_funcs_noise(x1): # return ObjFunc_noise.__call__(x1) # # The sample averaged objective function `dtlz1a`. # def obj_funcs_true(x1): # return ObjFunc_true.__call__(x1) out_dir = 'surf_test_results_noisy_moo' if os.path.isdir(out_dir): shutil.rmtree(out_dir) os.makedirs(out_dir) X_init = input('Enter the observed inputs') Y_init = input ('Enter the observed outputs') X_init = np.array(X_init) Y_init = np.array(Y_init) a = input('Enter the lower bounds of the inputs') b = input('Enter the upper bounds of the inputs') a = np.array(a) b = np.array(b) X_design = (b-a)*design.latin_center(1000, 2, seed=314519) + a pareto = ParetoFront(X_init, Y_init, X_design=X_design, gp_opt_num_restarts=50, verbose=True, max_it=10, make_plots=True, add_at_least=30, get_fig=get_full_fig, fig_prefix=os.path.join(out_dir,'ex1'), Y_true_pareto=None, gp_fixed_noise=None, samp=100, denoised=True ) #pareto.optimize() pareto.my_optimize()
def normal_execution(): #The following three lines are useful only if the code is being used to #solve a known problem, like the above. #assert len(sys.argv)==3 #noise = float(sys.argv[1]) #n = int(sys.argv[2]) #ObjFunc_noise = ObjFunc(noise,1) #ObjFunc_true = ObjFunc(noise,100) # The noisy objective function `dtlz1a`. # def obj_funcs_noise(x1): # return ObjFunc_noise.__call__(x1) # # The sample averaged objective function `dtlz1a`. # def obj_funcs_true(x1): # return ObjFunc_true.__call__(x1) out_dir = 'surf_test_results_noisy_moo' if os.path.isdir(out_dir): shutil.rmtree(out_dir) os.makedirs(out_dir) X_init = input('Enter the observed inputs') Y_init = input('Enter the observed outputs') X_init = np.array(X_init) Y_init = np.array(Y_init) a = input('Enter the lower bounds of the inputs') b = input('Enter the upper bounds of the inputs') a = np.array(a) b = np.array(b) X_design = (b - a) * design.latin_center(1000, 2, seed=314519) + a pareto = ParetoFront(X_init, Y_init, X_design=X_design, gp_opt_num_restarts=50, verbose=True, max_it=10, make_plots=True, add_at_least=30, get_fig=get_full_fig, fig_prefix=os.path.join(out_dir, 'ex1'), Y_true_pareto=None, gp_fixed_noise=None, samp=100, denoised=True) #pareto.optimize() pareto.my_optimize()
def propose_experiment_paused(self, it): """ Optimize the objectives and propose just 1 experiment, then saves the state of the program """ if self.verbose: print 'step {0:s}'.format(str(it).zfill(len(str(self.max_it)))) #print '\t> training surrogates' #self.train_surrogates() # Are we drawing new design points or not? if isinstance(self.X_design, int): num_design = self.X_design X_design = design.latin_center(num_design, self.num_dim) else: X_design = self.X_design if self.verbose: print '\t> done' print '\t> computing expected improvement' ei = self.compute_expected_improvement(X_design) if self.verbose: print '\t> done' i = np.argmax(ei) ei_max = ei[i] self.ei_values.append(ei_max) rel_ei_max = ei_max / self.ei_values[0] if self.verbose: print '\t> rel_ei_max = {0:1.3f}'.format(rel_ei_max) if it >= self.add_at_least and rel_ei_max < self.rtol: if self.verbose: print '*** Converged (rel_ei_max = {0:1.7f} < rtol = {1:1.2e})'.format(rel_ei_max, self.rtol) print '\t> writing final status' self.plot_status(it,final=True) return if self.verbose: print '\t> adding design point', i print '\t> X_d[i, :]', X_design[i, :] print '\t> starting simulation' #print self.Y_pareto k = self.active_cells #for k in k: #print k lplus = self.active_cells_lplus #for lplus in lplus: #print lplus #y = self.obj_funcs(X_design[i,:]) #print "Run the experiment/code at the following design"+str(X_design[i,:]) self.response = "Run the experiment/code at the following design"+str(X_design[i,:]) self.X_design_paused = X_design self.i_paused = i
def new_optimization(): global inputs, outputs, l_bounds, u_bounds, max_it, x_datalist, y_datalist, csv_valid response = None my_log.write('New optimization...\n') if check_observations(): Rappture.Utils.progress(10, "New model being created...") out_dir = 'surf_test_results_noisy_moo' if os.path.isdir(out_dir): shutil.rmtree(out_dir) os.makedirs(out_dir) if csv_valid: X_init = x_datalist Y_init = y_datalist else: X_init = literal_eval(inputs) Y_init = literal_eval(outputs) X_init = np.array(X_init) Y_init = np.array(Y_init) a = literal_eval(l_bounds) b = literal_eval(u_bounds) a = np.array(a) b = np.array(b) X_design = (b-a)*design.latin_center(1000, 2, seed=314519) + a pareto_model = ParetoFront(X_init, Y_init, X_design=X_design, gp_opt_num_restarts=50, verbose=False, max_it=max_it, make_plots=True, add_at_least=30, get_fig=get_full_fig, fig_prefix=os.path.join(out_dir,'ex1'), Y_true_pareto=None, gp_fixed_noise=None, samp=100, denoised=True) Rappture.Utils.progress(20, "Performing optimization algorithm...") pareto_model.optimize_paused() response = pareto_model.response Rappture.Utils.progress(60, "Saving the model...") model_file = open('model.obj','wb') pkl.dump(pareto_model, model_file, pkl.HIGHEST_PROTOCOL) model_file.close() Rappture.Utils.progress(100, "Done...") else: response = 'Incorrect tuples for new model' return response
def optimize_step(self, it): """ Perform a single optimization step. """ # Train current model self._ei = None self._denoised_posterior_samples = None self._best_idx = None if self.mcmc_start_from_scratch: self._model = None else: self.model.set_XY(self.X, self.Y[:, None]) if self.renew_design: self.X_design = design.latin_center(*self.X_design.shape) self.model._X_predict = self.X_design if ((it == 0 and self.optimize_model_before_init_mcmc) or self.optimize_model_before_mcmc): self.model.optimize() print str(self.model) print self.model.kern.lengthscale if self.verbose: print '\t> starting mcmc sampling' self.model.pymc_mcmc.sample(self.num_mcmc_samples, burn=self.num_mcmc_burn, thin=self.num_mcmc_thin, tune_throughout=self.mcmc_tune_throughout, progress_bar=self.mcmc_progress_bar) # Find best expected improvement ei = self.ei i = np.argmax(ei) # Do the simulation and add it self.idx_X_obs.append(i) self.Y_obs.append(self.func(self.X_design[i], *self.args)) if self.verbose: print '\t> design point id to be added : {0:d}'.format(i) print '\t> maximum expected improvement: {0:1.3f}'.format(ei[i]) return i, ei[i]
def paused_execution(): print 'Trying to load previous model...' try: f = open('model.obj','rb') pareto = pkl.load(f) f.close() pareto.my_optimize_paused() print 'Saving model...' f = open('model.obj','wb') pkl.dump(pareto, f, pkl.HIGHEST_PROTOCOL) f.close() except IOError: print 'New model being created...' #The following three lines are useful only if the code is being used to #solve a known problem, like the above. #assert len(sys.argv)==3 #noise = float(sys.argv[1]) #n = int(sys.argv[2]) #ObjFunc_noise = ObjFunc(noise,1) #ObjFunc_true = ObjFunc(noise,100) # The noisy objective function `dtlz1a`. # def obj_funcs_noise(x1): # return ObjFunc_noise.__call__(x1) # # The sample averaged objective function `dtlz1a`. # def obj_funcs_true(x1): # return ObjFunc_true.__call__(x1) out_dir = 'surf_test_results_noisy_moo' if os.path.isdir(out_dir): shutil.rmtree(out_dir) os.makedirs(out_dir) X_init = input('Enter the observed inputs') Y_init = input ('Enter the observed outputs') X_init = np.array(X_init) Y_init = np.array(Y_init) a = input('Enter the lower bounds of the inputs') b = input('Enter the upper bounds of the inputs') a = np.array(a) b = np.array(b) X_design = (b-a)*design.latin_center(1000, 2, seed=314519) + a pareto = ParetoFront(X_init, Y_init, X_design=X_design, gp_opt_num_restarts=50, verbose=True, max_it=10, make_plots=True, add_at_least=30, get_fig=get_full_fig, fig_prefix=os.path.join(out_dir,'ex1'), Y_true_pareto=None, gp_fixed_noise=None, samp=100, denoised=True ) pareto.my_optimize_paused() print 'Saving model...' f = open('model.obj','wb') pkl.dump(pareto, f, pkl.HIGHEST_PROTOCOL) f.close()
n = int(sys.argv[2]) ObjFunc_noise = ObjFunc(noise,noise,1) ObjFunc_true = ObjFunc(noise,noise,100) # The objective function `dtlz1a`. def obj_funcs_noise(x1): return ObjFunc_noise.__call__(x1) def obj_funcs_true(x1): return ObjFunc_true.__call__(x1) out_dir = 'ex1_results_n={0:d}_sigma={1:s}'.format(n,sys.argv[1]) if os.path.isdir(out_dir): shutil.rmtree(out_dir) os.makedirs(out_dir) X_init = design.latin_center(n, 6, seed=1234) Y_init = np.array([obj_funcs_noise(x) for x in X_init]) X_d_for_true = design.latin_center(10000, 6, seed=23415) X_design = design.latin_center(100, 6, seed=314519) Y_true = np.array([obj_funcs_true(x) for x in X_d_for_true]) #Y_true = np.load('true_data.npy') pareto = ParetoFront(X_init, Y_init, obj_funcs_noise, obj_funcs_true, X_design=1000, gp_opt_num_restarts=20, verbose=True, max_it = 100, make_plots=True, add_at_least=30, get_fig=get_full_fig, fig_prefix=os.path.join(out_dir,'ex1'), Y_true_pareto=Y_true,
""" Construct a centered Latin Square design. Author: Ilias Bilionis Date: 3/19/2014 """ import design import matplotlib.pyplot as plt # The number of input dimensions num_dim = 2 # The number of points you want num_points = 10 # Create the design X = design.latin_center(num_points, num_dim) # Look at it print X # And plot it plt.plot(X[:, 0], X[:, 1], '.', markersize=10) plt.xlabel('$x_1$', fontsize=16) plt.ylabel('$x_2$', fontsize=16) plt.title('Centered Latin Square Design', fontsize=16) plt.show()
def optimize(self): """ Optimize the objectives, i.e., discover the Pareto front. """ self.ei_values = [] for it in xrange(self.max_it): if self.verbose: print 'step {0:s}'.format(str(it).zfill(len(str(self.max_it)))) #print '\t> training surrogates' #self.train_surrogates() # Are we drawing new design points or not? if isinstance(self.X_design, int): num_design = self.X_design X_design = design.latin_center(num_design, self.num_dim) else: X_design = self.X_design if self.verbose: print '\t> done' print '\t> computing expected improvement' ei = self.compute_expected_improvement(X_design) if self.verbose: print '\t> done' i = np.argmax(ei) ei_max = ei[i] self.ei_values.append(ei_max) rel_ei_max = ei_max / self.ei_values[0] if self.verbose: print '\t> rel_ei_max = {0:1.3f}'.format(rel_ei_max) if it >= self.add_at_least and rel_ei_max < self.rtol: if self.verbose: print '*** Converged (rel_ei_max = {0:1.7f} < rtol = {1:1.2e})'.format(rel_ei_max, self.rtol) print '\t> writing final status' self.plot_status(it,final=True) break if self.verbose: print '\t> adding design point', i print '\t> X_d[i, :]', X_design[i, :] print '\t> starting simulation' #print self.Y_pareto k = self.active_cells #for k in k: #print k lplus = self.active_cells_lplus #for lplus in lplus: #print lplus #y = self.obj_funcs(X_design[i,:]) print "Run the experiment/code at the following design"+str(X_design[i,:]) y = input('Enter the observed value at the new design') self.add_new_observations(X_design[i, :], y) if self.verbose: print '\t> training surrogates now' self.train_surrogates() self.Y_p = self.get_projected_observations() self.idx = get_idx_of_observed_pareto_front(self.Y_p) self.b = compute_sorted_list_of_pareto_points(self.Y_pareto, self.y_ref) #self.Y_true_noiseless = np.array([self.obj_funcs_true(x) for x in self.X]) if self.verbose: print '\t> done' if not isinstance(self.X_design, int): self.X_design = np.delete(self.X_design, i, 0) if self.make_plots: if it==(self.max_it-1): self.plot_status(it,final=True) else: self.plot_status(it)
self.sigma = sigma def __call__(self, x): return self.f1(x), self.f2(x) if __name__ == '__main__': noise = float(sys.argv[1]) ObjFunc_noise = ObjFunc(noise, 1) # The objective function from `Binois et al`. def obj_funcs_noise(x): return ObjFunc_noise.__call__(x) if sys.argv[2].isdigit(): x = design.latin_center(sys.argv[2], 2) x_string_array = str(x).split('\n') inp = open('x_2.csv', 'wb') for i, string in enumerate(x_string_array): n_string = string.replace('[', '') n_string = n_string.replace(']', '') n_string = n_string.replace(' ', '') if i < len(x_string_array) - 1: inp.write(n_string[:4] + ',' + n_string[4:len(n_string)] + '\n') else: inp.write(n_string[:4] + ',' + n_string[4:len(n_string)]) inp.close() print 'the inputs are' + str(x) y = np.array([obj_funcs_noise(x) for x in x])
print '+ making', out_dir os.makedirs(out_dir) # We are looking for the minimum over these points # Use something like the following for a generic problem #X_design = domain[:, 0] + (domain[:, 1] - domain[:, 0]) * design.latin_center(num_design, 2) # For this one we use a regular grid only because we want to do some contour # plots x1 = np.linspace(domain[0, 0], domain[0, 1], num_design) x2 = np.linspace(domain[1, 0], domain[1, 1], num_design) X1, X2= np.meshgrid(x1, x2) X_design = np.hstack([X1.flatten()[:, None], X2.flatten()[:, None]]) # The initial points to start from X_init = np.random.rand(num_init)[:, None] * 6. X_init = domain[:, 0] + (domain[:, 1] - domain[:, 0]) * design.latin_center(num_init, 2) # Globally minimize f x, y, ei, _ = pybgo.minimize(f, X_init, X_design, tol=1e-5, callback=pybgo.plot_summary_2d, # This plots the results # at each iteration of # the algorithm prefix=os.path.join(out_dir, 'out'), save_model=True) # The best value at each iteration bv = np.array([y[:i, 0].min() for i in xrange(1, y.shape[0])]) fig, ax = plt.subplots() it = np.arange(1, bv.shape[0] + 1) ax.plot(it, bv, linewidth=2)
self.n_samp = n_samp self.sigma = sigma def __call__(self,x): return self.f1(x), self.f2(x) if __name__ == '__main__': noise = float(sys.argv[1]) ObjFunc_noise = ObjFunc(noise,1) # The objective function from `Binois et al`. def obj_funcs_noise(x): return ObjFunc_noise.__call__(x) if sys.argv[2].isdigit(): x = design.latin_center(sys.argv[2],2) x_string_array = str(x).split('\n') inp = open('x_2.csv','wb') for i, string in enumerate(x_string_array): n_string = string.replace('[','') n_string = n_string.replace(']','') n_string = n_string.replace(' ','') if i < len(x_string_array)-1: inp.write(n_string[:4] + ',' + n_string[4:len(n_string)] + '\n') else: inp.write(n_string[:4] + ',' + n_string[4:len(n_string)]) inp.close() print 'the inputs are'+ str(x) y = np.array([obj_funcs_noise(x) for x in x])
import math import GPy import matplotlib.pyplot as plt import seaborn as sns from design import latin_center def f(x, sigma=0.): """ A 1D function to look at. """ return 4. * (1. - np.exp(-0.1 * x) * np.sin((x + 8. * np.exp(x - 7.)))) + \ sigma * np.random.randn(*x.shape) np.random.seed(3145252) # The objective objective = lambda (x): f(x, sigma=1.5) # Just for plotting X_design = np.linspace(0, 6., 100)[:, None] # The initial points to start from X_init = latin_center(5, 1) * 6. Y_init = f(X_init) optimizer = pybgo.GlobalOptimizer(X_init, X_design, objective, true_func=f) optimizer.optimize()
def new_optimization(): global inputs, outputs, l_bounds, u_bounds, max_it, x_datalist, y_datalist, csv_valid, pareto_data, designs, bounds, initial_x_designs, mk_plots response = None my_log.write('New optimization...\n') if check_observations(): Rappture.Utils.progress(10, "New model being created...") out_dir = 'surf_test_results_noisy_moo' if os.path.isdir(out_dir): shutil.rmtree(out_dir) os.makedirs(out_dir) X_init = np.array(x_datalist) Y_init = np.array(y_datalist) if bounds: my_log.write('Bounds given...\n') a = literal_eval(l_bounds) b = literal_eval(u_bounds) a = np.array(a) b = np.array(b) X_design = (b - a) * design.latin_center( 1000, len(X_init[0]), seed=314519) + a else: my_log.write('Initial designs given:\n' + str(initial_x_designs) + '\n') X_design = initial_x_designs my_log.write('Dimensionality of X: ' + str(len(X_init[0])) + '\n') my_log.write('Dimensionality of Y: ' + str(len(Y_init[0])) + '\n') if len(Y_init[0]) <= 2: mk_plots = True else: mk_plots = False my_log.write('Creating Pareto model...\n') pareto_model = ParetoFront(X_init, Y_init, X_design=X_design, gp_opt_num_restarts=50, verbose=False, max_it=max_it, make_plots=mk_plots, add_at_least=30, get_fig=get_full_fig, fig_prefix=os.path.join(out_dir, 'ex1'), Y_true_pareto=None, gp_fixed_noise=None, samp=100, denoised=True) my_log.write('Pareto model created...\n') Rappture.Utils.progress(20, "Performing optimization algorithm...") my_log.write('Starting optimization algorithm...\n') pareto_model.optimize_paused() response = pareto_model.response pareto_data = pareto_model.get_pareto_data() designs = pareto_model.get_X_design() my_log.write('Optimization finished, saving the model...\n') Rappture.Utils.progress(60, "Saving the model...") model_file = open('model.obj', 'wb') pkl.dump(pareto_model, model_file, pkl.HIGHEST_PROTOCOL) model_file.close() my_log.write('Process completed...\n') Rappture.Utils.progress(100, "Done...") else: my_log.write('Incorrect input values, finishing execution...\n') response = 'Incorrect tuples for new model' return response
def paused_execution(): print 'Trying to load previous model...' try: f = open('model.obj', 'rb') pareto = pkl.load(f) f.close() pareto.my_optimize_paused() print 'Saving model...' f = open('model.obj', 'wb') pkl.dump(pareto, f, pkl.HIGHEST_PROTOCOL) f.close() except IOError: print 'New model being created...' #The following three lines are useful only if the code is being used to #solve a known problem, like the above. #assert len(sys.argv)==3 #noise = float(sys.argv[1]) #n = int(sys.argv[2]) #ObjFunc_noise = ObjFunc(noise,1) #ObjFunc_true = ObjFunc(noise,100) # The noisy objective function `dtlz1a`. # def obj_funcs_noise(x1): # return ObjFunc_noise.__call__(x1) # # The sample averaged objective function `dtlz1a`. # def obj_funcs_true(x1): # return ObjFunc_true.__call__(x1) out_dir = 'surf_test_results_noisy_moo' if os.path.isdir(out_dir): shutil.rmtree(out_dir) os.makedirs(out_dir) X_init = input('Enter the observed inputs') Y_init = input('Enter the observed outputs') X_init = np.array(X_init) Y_init = np.array(Y_init) a = input('Enter the lower bounds of the inputs') b = input('Enter the upper bounds of the inputs') a = np.array(a) b = np.array(b) X_design = (b - a) * design.latin_center(1000, 2, seed=314519) + a pareto = ParetoFront(X_init, Y_init, X_design=X_design, gp_opt_num_restarts=50, verbose=True, max_it=10, make_plots=True, add_at_least=30, get_fig=get_full_fig, fig_prefix=os.path.join(out_dir, 'ex1'), Y_true_pareto=None, gp_fixed_noise=None, samp=100, denoised=True) pareto.my_optimize_paused() print 'Saving model...' f = open('model.obj', 'wb') pkl.dump(pareto, f, pkl.HIGHEST_PROTOCOL) f.close()
def optimize(self): """ Optimize the objectives, i.e., discover the Pareto front. """ self.ei_values = [] for it in xrange(self.max_it): if self.verbose: print 'step {0:s}'.format(str(it).zfill(len(str(self.max_it)))) #print '\t> training surrogates' #self.train_surrogates() # Are we drawing new design points or not? if isinstance(self.X_design, int): num_design = self.X_design X_design = design.latin_center(num_design, self.num_dim) else: X_design = self.X_design if self.verbose: print '\t> done' print '\t> computing expected improvement' ei = self.compute_expected_improvement(X_design) if self.verbose: print '\t> done' i = np.argmax(ei) ei_max = ei[i] self.ei_values.append(ei_max) rel_ei_max = ei_max / self.ei_values[0] if self.verbose: print '\t> rel_ei_max = {0:1.3f}'.format(rel_ei_max) if it >= self.add_at_least and rel_ei_max < self.rtol: if self.verbose: print '*** Converged (rel_ei_max = {0:1.7f} < rtol = {1:1.2e})'.format( rel_ei_max, self.rtol) print '\t> writing final status' self.plot_status(it, final=True) break if self.verbose: print '\t> adding design point', i print '\t> X_d[i, :]', X_design[i, :] print '\t> starting simulation' #print self.Y_pareto k = self.active_cells #for k in k: #print k lplus = self.active_cells_lplus #for lplus in lplus: #print lplus #y = self.obj_funcs(X_design[i,:]) print "Run the experiment/code at the following design" + str( X_design[i, :]) y = input('Enter the observed value at the new design') self.add_new_observations(X_design[i, :], y) if self.verbose: print '\t> training surrogates now' self.train_surrogates() self.Y_p = self.get_projected_observations() self.idx = get_idx_of_observed_pareto_front(self.Y_p) self.b = compute_sorted_list_of_pareto_points( self.Y_pareto, self.y_ref) #self.Y_true_noiseless = np.array([self.obj_funcs_true(x) for x in self.X]) if self.verbose: print '\t> done' if not isinstance(self.X_design, int): self.X_design = np.delete(self.X_design, i, 0) if self.make_plots: if it == (self.max_it - 1): self.plot_status(it, final=True) else: self.plot_status(it)
out_dir = 'surf_test_results_noisy_moo' if os.path.isdir(out_dir): shutil.rmtree(out_dir) os.makedirs(out_dir) X_init = input('Enter the observed inputs') Y_init = input ('Enter the observed outputs') X_init = np.array(X_init) Y_init = np.array(Y_init) a = input('Enter the lower bounds of the inputs') b = input('Enter the upper bounds of the inputs') a = np.array(a) b = np.array(b) X_design = (b-a)*design.latin_center(1000, 2, seed=314519) + a pareto = ParetoFront(X_init, Y_init, X_design=X_design, gp_opt_num_restarts=50, verbose=True, max_it=10, make_plots=True, add_at_least=30, get_fig=get_full_fig, fig_prefix=os.path.join(out_dir,'ex1'), Y_true_pareto=None, gp_fixed_noise=None, samp=1000, denoised=True ) pareto.optimize()
ObjFunc_noise = ObjFunc(noise, noise, 1) ObjFunc_true = ObjFunc(noise, noise, 100) # The objective function `dtlz1a`. def obj_funcs_noise(x1): return ObjFunc_noise.__call__(x1) def obj_funcs_true(x1): return ObjFunc_true.__call__(x1) out_dir = 'ex1_results_n={0:d}_sigma={1:s}'.format(n, sys.argv[1]) if os.path.isdir(out_dir): shutil.rmtree(out_dir) os.makedirs(out_dir) X_init = design.latin_center(n, 6, seed=1234) Y_init = np.array([obj_funcs_noise(x) for x in X_init]) X_d_for_true = design.latin_center(10000, 6, seed=23415) X_design = design.latin_center(100, 6, seed=314519) Y_true = np.array([obj_funcs_true(x) for x in X_d_for_true]) #Y_true = np.load('true_data.npy') pareto = ParetoFront(X_init, Y_init, obj_funcs_noise, obj_funcs_true, X_design=1000, gp_opt_num_restarts=20, verbose=True, max_it=100, make_plots=True, add_at_least=30,
print '+ making', out_dir os.makedirs(out_dir) # We are looking for the minimum over these points # Use something like the following for a generic problem #X_design = domain[:, 0] + (domain[:, 1] - domain[:, 0]) * design.latin_center(num_design, 2) # For this one we use a regular grid only because we want to do some contour # plots x1 = np.linspace(domain[0, 0], domain[0, 1], num_design) x2 = np.linspace(domain[1, 0], domain[1, 1], num_design) X1, X2 = np.meshgrid(x1, x2) X_design = np.hstack([X1.flatten()[:, None], X2.flatten()[:, None]]) # The initial points to start from X_init = np.random.rand(num_init)[:, None] * 6. X_init = domain[:, 0] + (domain[:, 1] - domain[:, 0]) * design.latin_center( num_init, 2) # Globally minimize f x, y, ei, _ = pybgo.minimize( f, X_init, X_design, tol=1e-5, callback=pybgo.plot_summary_2d, # This plots the results # at each iteration of # the algorithm prefix=os.path.join(out_dir, 'out'), save_model=True) # The best value at each iteration bv = np.array([y[:i, 0].min() for i in xrange(1, y.shape[0])])
import math import GPy import matplotlib.pyplot as plt import seaborn as sns from design import latin_center def f(x, sigma=0.): """ A 1D function to look at. """ return 4. * (1. - np.exp(-0.1 * x) * np.sin((x + 8. * np.exp(x - 7.)))) + \ sigma * np.random.randn(*x.shape) np.random.seed(3145252) # The objective objective = lambda(x): f(x, sigma=1.5) # Just for plotting X_design = np.linspace(0, 6., 100)[:, None] # The initial points to start from X_init = latin_center(5, 1) * 6. Y_init = f(X_init) optimizer = pybgo.GlobalOptimizer(X_init, X_design, objective, true_func=f) optimizer.optimize()
out_dir = 'surf_test_results_noisy_moo' if os.path.isdir(out_dir): shutil.rmtree(out_dir) os.makedirs(out_dir) X_init = input('Enter the observed inputs') Y_init = input('Enter the observed outputs') X_init = np.array(X_init) Y_init = np.array(Y_init) a = input('Enter the lower bounds of the inputs') b = input('Enter the upper bounds of the inputs') a = np.array(a) b = np.array(b) X_design = (b - a) * design.latin_center(1000, 2, seed=314519) + a pareto = ParetoFront(X_init, Y_init, X_design=X_design, gp_opt_num_restarts=50, verbose=True, max_it=10, make_plots=True, add_at_least=30, get_fig=get_full_fig, fig_prefix=os.path.join(out_dir, 'ex1'), Y_true_pareto=None, gp_fixed_noise=None, samp=1000, denoised=True) pareto.optimize()