def main(): """ Main function. """ domain_vars = [{ 'name': 'hubble_constant', 'type': 'float', 'min': 60, 'max': 80 }, { 'name': 'omega_m', 'type': 'float', 'min': 0, 'max': 1 }, { 'name': 'omega_l', 'type': 'float', 'min': 0, 'max': 1 }] config_params = {'domain': domain_vars} config = load_config(config_params) max_capital = 2 * 60 * 60 # Optimisation budget in seconds # Optimise opt_pt, opt_val, history = maximise_function(snls_objective, config.domain, max_capital, capital_type='realtime', config=config)
def main(): """ Main function. """ domain_bounds = [[-5, 10], [0, 15]] max_capital = 100 opt_val, opt_pt, _ = maximise_function(branin, domain_bounds, max_capital) print('Optimum Value in %d evals: %0.4f'%(max_capital, opt_val)) print('Optimum Point: %s'%(opt_pt))
def main(): """ Main function. """ disc_euc_items = list(np.random.random((1000, 3))) domain_vars = [ { 'type': 'discrete_euclidean', 'items': disc_euc_items }, { 'type': 'float', 'min': 0, 'max': 11, 'dim': 2 }, { 'type': 'int', 'min': 0, 'max': 114 }, ] config_params = {'domain': domain_vars} config = load_config(config_params) max_num_evals = 100 opt_val, opt_pt, history = maximise_function(hartmann6_3, config.domain, max_num_evals, config=config) print(opt_pt, opt_val)
def main(): """ Main function. """ domain_bounds = [[-5, 10], [0, 15]] max_capital = 100 opt_val, opt_pt = maximise_function(branin, max_capital, domain_bounds=domain_bounds, hp_tune_criterion='post_sampling', hp_tune_method='slice') print('Optimum Value in %d evals: %0.4f' % (max_capital, opt_val)) print('Optimum Point: %s' % (opt_pt))
def single_fidelity(): """Main function""" domain_bounds = [[-20, 20], [-20, 20]] max_capital = 200 time_start = time.time() opt_val, opt_pt, history = maximise_function( straw_hat, domain_bounds, max_capital) #,opt_method='rand') time_end = time.time() print('totally cost', time_end - time_start) curr_opt_points = history.curr_opt_points curr_opt_vals = history.curr_opt_vals # plot sample points fig = plt.figure() ax = fig.gca(projection='3d') # Make function surface. X1 = np.arange(-20, 20, 0.25) X2 = np.arange(-20, 20, 0.25) X1, X2 = np.meshgrid(X1, X2) x = [X1, X2] z = straw_hat(x) # Make sample points n = len(curr_opt_vals) smaple_z = curr_opt_vals sample_x = np.zeros(n) sample_y = np.zeros(n) for idx in range(n): sample_x[idx] = curr_opt_points[idx][0] sample_y[idx] = curr_opt_points[idx][1] # Plot the surface. #surf = ax.plot_surface(X1, X2, z, cmap=cm.coolwarm,linewidth=0, antialiased=False) # Plot a basic wireframe. ax.plot_wireframe(X1, X2, z, rstride=10, cstride=10) # Customize the z axis. ax.set_zlim(-1.01, 1.01) ax.zaxis.set_major_locator(LinearLocator(10)) ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f')) # Add a color bar which maps values to colors. # fig.colorbar(surf, shrink=0.5, aspect=5) ax.plot(sample_x, sample_y, smaple_z, label='parametric curve', c='red') ax.legend() plt.show()
def main(): """ Main function. """ # First Specify all parameters disc_num_items_x1 = [4, 10, 23, 45, 78, 87.1, 91.8, 99, 75.7, 28.1, 3.141593] domain_vars = [ {'name': 'x0', 'type': 'discrete_numeric', 'items': '0:0.05:1', 'dim': 2}, {'name': 'x1', 'type': 'discrete_numeric', 'items': disc_num_items_x1}, {'name': 'x2', 'type': 'float', 'min': 10, 'max': 16}, ] domain_constraints = [ {'name': 'dc1', 'constraint': 'sum(x0) + (x2 - 10)/6.0 <= 2.1'}, {'name': 'dc2', 'constraint': dc2_constraint} ] disc_items_z2 = ['a', 'ab', 'abc', 'abcd', 'abcde', 'abcdef', 'abcdefg', 'abcdefg', 'abcdefgh', 'abcdefghi'] fidel_vars = [{'name': 'z1', 'type': 'discrete', 'items': disc_items_z2, 'dim': 2}, {'name': 'z2', 'type': 'float', 'min': 21.3, 'max': 243.9}, ] fidel_to_opt = [["abcdefghi", "abcdefghi"], 200.1] # Budget of evaluations max_num_evals = 100 # Optimisation budget (max number of evaluations) max_mf_capital = max_num_evals * mf_cost(fidel_to_opt) # Multi-fideltiy capital # First do the MF version config_params = {'domain': domain_vars, 'fidel_space': fidel_vars, 'domain_constraints': domain_constraints, 'fidel_to_opt': fidel_to_opt} config = load_config(config_params) # Optimise mf_opt_val, mf_opt_pt, history = maximise_multifidelity_function(mf_objective, config.fidel_space, config.domain, config.fidel_to_opt, mf_cost, max_mf_capital, config=config) print(mf_opt_pt, mf_opt_val) # Non-MF version config_params = {'domain': domain_vars, 'domain_constraints': domain_constraints} config = load_config(config_params) max_capital = 100 # Optimisation budget (max number of evaluations) # Optimise opt_val, opt_pt, history = maximise_function(objective, config.domain, max_num_evals, config=config) print(opt_pt, opt_val)
def main(): """ Main function. """ size = 1000 dim = 3 disc_euc_items = list(np.random.random((size, dim))) domain_vars = [ { 'type': 'discrete_euclidean', 'items': disc_euc_items }, ] config_params = {'domain': domain_vars} config = load_config(config_params) max_num_evals = 100 opt_pt, opt_val, history = maximise_function(objective, config.domain, max_num_evals, config=config) print(opt_pt, opt_val)
def main(): """ Main function. """ size = 1000 dim = 3 disc_euc_items = list(np.random.random((size, dim))) domain_vars = [ {'type': 'discrete_euclidean', 'items': disc_euc_items}, ] config_params = {'domain': domain_vars} config = load_config(config_params) max_num_evals = 100 # specify optimisation method # opt_method = 'bo' # Bayesian optimisation opt_method = 'ea' # evolutionary algorithm # opt_method = 'rand' # random search opt_val, opt_pt, history = maximise_function(objective, config.domain, max_num_evals, config=config, opt_method=opt_method) print(opt_pt, opt_val)
def main(): """ Main function. """ # First Specify all parameters domain_vars = [{'name': 'x', 'type': 'float', 'min': 0, 'max': 1, 'dim': 3}] domain_constraints = [ {'name': 'quadrant', 'constraint': 'np.linalg.norm(x[0:2]) <= 0.5'}, ] fidel_vars = [{'name': 'z', 'type': 'float', 'min': 0, 'max': 10}] fidel_space_constraints = [{'name': 'fsc1', 'constraint': fsc1_constraint}] fidel_to_opt = [9.1] print('fsc1_constraint(fidel_to_opt)', fsc1_constraint(fidel_to_opt)) # Budget of evaluations max_num_evals = 100 # Optimisation budget (max number of evaluations) max_mf_capital = max_num_evals * mf_cost(fidel_to_opt) # Multi-fideltiy capital # Non-MF version config_params = {'domain': domain_vars, 'domain_constraints': domain_constraints} config = load_config(config_params) max_capital = 100 # Optimisation budget (max number of evaluations) # Optimise opt_val, opt_pt, history = maximise_function(objective, config.domain, max_num_evals, config=config) print(opt_pt, opt_val) # MF version config_params = {'domain': domain_vars, 'fidel_space': fidel_vars, 'domain_constraints': domain_constraints, 'fidel_space_constraints': fidel_space_constraints, 'fidel_to_opt': fidel_to_opt} config = load_config(config_params) # Optimise mf_opt_val, mf_opt_pt, history = maximise_multifidelity_function(mf_objective, config.fidel_space, config.domain, config.fidel_to_opt, mf_cost, max_mf_capital, config=config) print(mf_opt_pt, mf_opt_val)
def main(): """ Main function. """ # Load configuration file objective, config_file, mf_cost = _CHOOSER_DICT[PROBLEM] config = load_config_file(config_file) # Specify optimisation method ----------------------------------------------------- opt_method = 'bo' # opt_method = 'ga' # opt_method = 'rand' # Optimise max_capital = 60 domain, domain_orderings = config.domain, config.domain_orderings if PROBLEM in ['3d', '5d']: # Create function caller. # Note there is no function passed in to the Function Caller object. func_caller = CPFunctionCaller(None, domain, domain_orderings=domain_orderings) if opt_method == 'bo': opt = gp_bandit.CPGPBandit(func_caller, ask_tell_mode=True) elif opt_method == 'ga': opt = cp_ga_optimiser.CPGAOptimiser(func_caller, ask_tell_mode=True) elif opt_method == 'rand': opt = random_optimiser.CPRandomOptimiser(func_caller, ask_tell_mode=True) opt.initialise() # Optimize using the ask-tell interface # User continually asks for the next point to evaluate, then tells the optimizer the # new result to perform Bayesian optimisation. best_x, best_y = None, float('-inf') for _ in range(max_capital): x = opt.ask() y = objective(x) opt.tell([(x, y)]) print('x: %s, y: %s' % (x, y)) if y > best_y: best_x, best_y = x, y print("Optimal Value: %s, Optimal Point: %s" % (best_y, best_x)) # Compare results with the maximise_function API print("-------------") print("Compare with maximise_function API:") opt_val, opt_pt, history = maximise_function(objective, config.domain, max_capital, opt_method=opt_method, config=config) elif PROBLEM == '3d_euc': # Create function caller. # Note there is no function passed in to the Function Caller object. domain = domain.list_of_domains[0] func_caller = EuclideanFunctionCaller(None, domain) if opt_method == 'bo': opt = gp_bandit.EuclideanGPBandit(func_caller, ask_tell_mode=True) elif opt_method == 'ga': raise ValueError("Invalid opt_method %s" % (opt_method)) opt.initialise() # Optimize using the ask-tell interface # User continually asks for the next point to evaluate, then tells the optimizer the # new result to perform Bayesian optimisation. best_x, best_y = None, float('-inf') for _ in range(max_capital): # Optionally, you can add an integer argument `n_points` to ask to have it return # `n_points` number of points. These points will be returned as a list. # No argument for `n_points` returns a single point from ask. x = opt.ask() y = objective(x) opt.tell([(x, y)]) print('x: %s, y: %s' % (x, y)) if y > best_y: best_x, best_y = x, y print("Optimal Value: %s, Optimal Point: %s" % (best_y, best_x)) # Compare results with the maximise_function API print("-------------") print("Compare with maximise_function API:") opt_val, opt_pt, history = maximise_function(objective, config.domain, max_capital, opt_method=opt_method, config=config) else: # Create function caller. # Note there is no function passed in to the Function Caller object. (ask_tell_fidel_space, ask_tell_domain, _, ask_tell_mf_cost, ask_tell_fidel_to_opt, ask_tell_config, _) = \ preprocess_multifidelity_arguments(config.fidel_space, domain, [objective], mf_cost, config.fidel_to_opt, config) func_caller = CPFunctionCaller( None, ask_tell_domain, domain_orderings=domain_orderings, fidel_space=ask_tell_fidel_space, fidel_cost_func=ask_tell_mf_cost, fidel_to_opt=ask_tell_fidel_to_opt, fidel_space_orderings=config.fidel_space_orderings, config=ask_tell_config) if opt_method == 'bo': opt = gp_bandit.CPGPBandit(func_caller, is_mf=True, ask_tell_mode=True) else: raise ValueError("Invalid opt_method %s" % (opt_method)) opt.initialise() # Optimize using the ask-tell interface # User continually asks for the next point to evaluate, then tells the optimizer the # new result to perform Bayesian optimisation. best_z, best_x, best_y = None, None, float('-inf') for _ in range(max_capital): point = opt.ask() z, x = point[0], point[1] y = objective(z, x) opt.tell([(z, x, y)]) print('z: %s, x: %s, y: %s' % (z, x, y)) if y > best_y: best_z, best_x, best_y = z, x, y print("Optimal Value: %s, Optimal Point: %s" % (best_y, best_x)) # Compare results with the maximise_multifidelity_function API print("-------------") print("Compare with maximise_multifidelity_function API:") opt_val, opt_pt, history = maximise_multifidelity_function( objective, config.fidel_space, config.domain, config.fidel_to_opt, mf_cost, max_capital, opt_method=opt_method, config=config) print('opt_pt: %s' % (str(opt_pt))) print('opt_val: %s' % (str(opt_val)))
def main(): """ Main function. """ # First Specify all parameters domain_vars = [ { 'type': 'int', 'min': 224, 'max': 324, 'dim': 1 }, { 'type': 'float', 'min': 0, 'max': 10, 'dim': 2 }, { 'type': 'float', 'min': 0, 'max': 1, 'dim': 1 }, { 'type': 'int', 'min': 0, 'max': 92, 'dim': 2 }, ] fidel_vars = [ { 'type': 'float', 'min': 1234.9, 'max': 9467.18, 'dim': 2 }, { 'type': 'discrete', 'items': ['a', 'bc', 'def', 'ghij'] }, { 'type': 'int', 'min': 123, 'max': 234, 'dim': 1 }, ] fidel_to_opt = [[9467.18, 9452.8], "def", [234]] # Budget of evaluations max_num_evals = 100 # Optimisation budget (max number of evaluations) max_mf_capital = max_num_evals * mf_cost( fidel_to_opt) # Multi-fideltiy capital # First do the MF version config_params = { 'domain': domain_vars, 'fidel_space': fidel_vars, 'fidel_to_opt': fidel_to_opt } config = load_config(config_params) # Optimise mf_opt_val, mf_opt_pt, history = maximise_multifidelity_function( mf_objective, config.fidel_space, config.domain, config.fidel_to_opt, mf_cost, max_mf_capital, config=config) print(mf_opt_pt, mf_opt_val) # Non-MF version config_params = {'domain': domain_vars} config = load_config(config_params) max_capital = 100 # Optimisation budget (max number of evaluations) # Optimise opt_val, opt_pt, history = maximise_function(objective, config.domain, max_num_evals, config=config) print(opt_pt, opt_val)
def main(): """ Main function. """ domain_vars = [{ 'name': 'hubble_constant', 'type': 'float', 'min': 60, 'max': 80 }, { 'name': 'omega_m', 'type': 'float', 'min': 0, 'max': 1 }, { 'name': 'omega_l', 'type': 'float', 'min': 0, 'max': 1 }] fidel_vars = [{ 'name': 'log10_resolution', 'type': 'float', 'min': 2, 'max': 5 }, { 'name': 'num_obs_to_use', 'type': 'int', 'min': 50, 'max': 192 }] fidel_to_opt = [5, 192] max_capital = 2 * 60 * 60 # Optimisation budget in seconds # A parallel set up where we will evaluate the function in three different threads. num_workers = 3 # Optimise without multi-fidelity config_params = {'domain': domain_vars} config = load_config(config_params) opt_val, opt_pt, history = maximise_function(snls_objective, config.domain, max_capital, num_workers=num_workers, capital_type='realtime', config=config) print(opt_pt, opt_val) # Optimise with multi-fidelity config_params = { 'domain': domain_vars, 'fidel_space': fidel_vars, 'fidel_to_opt': fidel_to_opt } config = load_config(config_params) # Optimise mf_opt_val, mf_opt_pt, history = maximise_multifidelity_function( snls_mf_objective, config.fidel_space, config.domain, config.fidel_to_opt, snls_mf_cost, max_capital, config=config) print(mf_opt_pt, mf_opt_val)
def main(): """ Main function. """ # Load configuration file objective, config_file, mf_cost = _CHOOSER_DICT[PROBLEM] config = load_config_file(config_file) # Specify optimisation method ----------------------------------------------------- # opt_method = 'bo' opt_method = 'ga' # opt_method = 'rand' # Specify options options = Namespace( build_new_model_every=5, # update the model every 5 iterations report_results_every=4, # report progress every 4 iterations report_model_on_each_build=True, # report model when you build it. ) # Specifying GP priors ------------------------------------------------------------- # Dragonfly allows specifying a mean for the GP prior - if there is prior knowledge # on the rough behaviour of the function to be optimised, this is one way that # information can be incorporated into the model. if USE_CONDUCTIVITY_PRIOR_MEAN: if PROBLEM in ['3d', '3d_euc']: options.gp_prior_mean = conductivity_prior_mean_3d elif PROBLEM == '3d_mf': options.gp_prior_mean = conductivity_prior_mean_3d_mf elif PROBLEM == '5d': options.gp_prior_mean = conductivity_prior_mean_5d # The _unproc indicates that the mean function is "unprocessed". Dragonfly converts # the domain specified given in the configuration to an internal order which may # have reordered the variables. The _unproc tells that the function # should be called in the original format. # Saving and loading data ---------------------------------------------------------- # You can save and load progress in Dragonfly. This allows you to resume an # optimisation routine if it crashes from where we left off. # Other related options include: # - progress_load_from: loads progress from this file but does not save it. # - progress_save_to: loads progress from this file but does not save it. # - progress_report_on_each_save: reports that the progress was saved (default True) if SAVE_AND_LOAD_PROGRESS: options.progress_load_from_and_save_to = 'progress.p' options.progress_save_every = 5 # progress_load_from and progress_load_from_and_save_to can be a list of file names # in which case we will load from all the files. # e.g options.progress_load_from_and_save_to = ['progress1.p', 'progress2.p'] # Optimise max_capital = 60 if PROBLEM in ['3d', '3d_euc', '5d']: opt_val, opt_pt, history = maximise_function(objective, config.domain, max_capital, opt_method=opt_method, config=config, options=options) else: opt_val, opt_pt, history = maximise_multifidelity_function( objective, config.fidel_space, config.domain, config.fidel_to_opt, mf_cost, max_capital, opt_method=opt_method, config=config, options=options) print('opt_pt: %s' % (str(opt_pt))) print('opt_val: %s' % (str(opt_val)))
def main(): """ Main function. """ # First Specify all parameters domain_vars = [ { 'name': 'rw', 'type': 'float', 'min': 0.05, 'max': 0.15, 'dim': 1 }, { 'name': 'L_Kw', 'type': 'float', 'min': 0, 'max': 1, 'dim': 2 }, { 'name': 'Tu', 'type': 'int', 'min': 63070, 'max': 115600, 'dim': '' }, { 'name': 'Tl', 'type': 'float', 'min': 63.1, 'max': 116 }, { 'name': 'Hu_Hl', 'type': 'int', 'min': 0, 'max': 240, 'dim': 2 }, { 'name': 'r', 'type': 'float', 'min': 100, 'max': 50000 }, ] domain_constraints = [{ 'constraint': 'np.sqrt(rw[0]) + L_Kw[1] <= 0.9' }, { 'constraint': 'r/100.0 + Hu_Hl[1] < 200' }] fidel_vars = [ { 'name': 'fidel_0', 'type': 'float', 'min': 0.05, 'max': 0.25 }, { 'name': 'fidel_1', 'type': 'discrete_numeric', 'items': "0.1:0.05:1.01" }, ] fidel_space_constraints = [{ 'name': 'fsc1', 'constraint': 'fidel_0 + fidel_1 <= 0.9' }] fidel_to_opt = [0.1, 0.75] # Budget of evaluations max_num_evals = 100 # Optimisation budget (max number of evaluations) max_mf_capital = max_num_evals * mf_cost( fidel_to_opt) # Multi-fideltiy capital # First do the MF version config_params = { 'domain': domain_vars, 'fidel_space': fidel_vars, 'domain_constraints': domain_constraints, 'fidel_space_constraints': fidel_space_constraints, 'fidel_to_opt': fidel_to_opt } config = load_config(config_params) # Optimise mf_opt_pt, mf_opt_val, history = maximise_multifidelity_function( mf_objective, config.fidel_space, config.domain, config.fidel_to_opt, mf_cost, max_mf_capital, config=config) print(mf_opt_pt, mf_opt_val) # Non-MF version config_params = { 'domain': domain_vars, 'domain_constraints': domain_constraints } config = load_config(config_params) max_capital = 100 # Optimisation budget (max number of evaluations) # Optimise opt_pt, opt_val, history = maximise_function(objective, config.domain, max_num_evals, config=config) print(opt_pt, opt_val)