def optimizeOptimization(): """ Run Bayesian Optimization several times with different configurations (f.ex. different acquisition functions). - save the best results from each optimization iteration and use then to initialize the next optimization """ initDict = {'target': [], 'damping': [], 'friction': []} acquisitionFunctions = ['ei', 'ucb', 'ei', 'ucb', 'ei', 'ucb'] for i in range(6): optimization = BO(runAll40ExperimentsAndGetCost, {'damping': (0, 1), 'friction': (0, 1)}) try: optimization.initialize(initDict) optimization.maximize(n_iter=50, acq=acquisitionFunctions[i]) res = optimization.res['max'] if res['max_val'] not in initDict['target']: initDict['target'].append(res['max_val']) maxParams = res['max_params'] initDict['damping'].append(maxParams['damping']) initDict['friction'].append(maxParams['friction']) print(initDict) with open('BO_sledge_params/6xBO_all40_60iters_0-8_0-4.txt', 'w') as file: file.write(json.dumps(initDict)) # use `json.loads` to do the reverse except Exception as ex: print(ex) continue
def BayesianOptimizeArgmax(priorInputs, priorOutputs, ranges, acq='ucb', kappa=6): bo = BayesianOptimization(None, ranges) # BO requires a single dict with the keys being the parameters and 'target' which is the output from the function # Combine Inputs and Outputs into one dict.. { 'target': [...], 'x': [...], 'y': [...]} inputsOutputs = {} for sampleIter in range(len(priorInputs)): for paramIter, key in enumerate(ranges.keys()): if key in inputsOutputs: inputsOutputs[key].append(priorInputs[sampleIter][paramIter]) else: inputsOutputs[key] = [priorInputs[sampleIter][paramIter]] inputsOutputs['target'] = priorOutputs bo.initialize(inputsOutputs) # Maximize the function approximation to find the best parameters (0 iterations since we dont have an explicit function to sample) bo.maximize(init_points=0, n_iter=0, acq=acq, kappa=kappa) # Argmax, return the optimal parameters to try next (based on Explore vs Exploit) knownYmax = bo.Y.max() knownArgmax = bo.X[bo.Y.argmax()] nextArgmax = helpers.acq_max(ac=bo.util.utility, gp=bo.gp, y_max=knownYmax, bounds=bo.bounds) return OrderedDict(zip(ranges.keys(), knownArgmax)), \ knownYmax, \ OrderedDict(zip(ranges.keys(), nextArgmax))
def optimizeSledgeParams(): """ Run Bayesian Optimization with normalized inputs to find best parameters to replicate the free falling trajetories of the sledge """ optimization = BO(runAll40ExperimentsAndGetCost, {'damping': (-1, 1), 'friction': (-1, 1)}) # initialize optimization with so far best found parameters to improve the results optimization.initialize({ 'target': [-1198.0, -1300.0, -1197.0], 'damping': [-0.6826810335539988, -0.8658977050860612, -0.6818051907866487], 'friction': [0.5014436638411311, 0.7335613457613679, 0.49986569844586715] }) optimization.maximize(n_iter=55, acq='ucb') print(optimization.res) # uncomment to save the results for monitoring # with open('BO_sledge_params/BO_all40_45iters_0-8_0-1.txt', 'w') as file: # file.write(json.dumps(optimization.res)) # use `json.loads` to do the reverse results = np.array(optimization.res['all']['values']) results = results[results > (optimization.res['max']['max_val'] * 10)] bestParams = optimization.res['max']['max_params'] unscaledDamping, unscaledFriction = bestParams['damping'], bestParams['friction'] bestDamping, bestFriction = unscaleDampingAndFriction(unscaledDamping, unscaledFriction) print("Best Cost of {} was achieved with damping = {} and friction = {}" .format(max(results), bestDamping, bestFriction)) tools.plot(results, title="Bayesian Optimization convergence", ylabel="Cost []", xlabel="Optimization step []")
def opti(self): bo = BayesianOptimization(self.trainAndCompareHit, {"x": (10, 50), "y": (0.1, 1.0)}) bo.explore({"x": range(10, 50), "y": [0.1, 0.25, 0.5, 0.75, 1.0]}) bo.initialize({-11: {"x": 20, "y": 0.5}}) bo.maximize(init_points=5, n_iter=5, kappa=3.29) print(bo.res["max"])
def opti(self): bo = BayesianOptimization(self.trainAndCompareHit, { 'x': (10, 50), 'y': (0.1, 1.0) }) bo.explore({'x': range(10, 50), 'y': [0.1, 0.25, 0.5, 0.75, 1.]}) bo.initialize({-11: {'x': 20, 'y': 0.5}}) bo.maximize(init_points=5, n_iter=5, kappa=3.29) print(bo.res['max'])
def optimizeSolverParams(): """ Run Bayesian Optimization with normalized inputs to find best parameters to replicate the vertical sledge position trajetories after the touchdown """ optimization = BO( runAll40ExperimentsAndGetCost, { 'solref1': (0, 1), 'solref2': (0, 1), 'solimp1': (0, 1), 'solimp2': (0, 1), 'solimp3': (0, 1) }) # initialize optimization with so far best found parameters to improve the results optimization.initialize({ 'target': [-30668.7, -38917.8], 'solref1': [0.10667760273187854, 0.7917295903960275], 'solref2': [0, 0], 'solimp1': [0.6323304436894982, 0.9999981685561232], 'solimp2': [0.0, 0.0], 'solimp3': [0.9029115238081952, 1.0] }) print("BO settings: n_iter = 250 and acq=UCB") optimization.maximize(n_iter=75, acq='ei') print("Optimization Results:\n" + optimization.res) results = np.array(optimization.res['all']['values']) results = results[results > optimization.res['max']['max_val'] * 100] bestParams = optimization.res['max']['max_params'] solref1, solref2, solimp1, solimp2, solimp3 = bestParams[ 'solref1'], bestParams['solref2'], bestParams['solimp1'], bestParams[ 'solimp2'], bestParams['solimp3'] solref1, solref2, solimp1, solimp2, solimp3 = unscaleGroundContactParams( solref1, solref2, solimp1, solimp2, solimp3) print("Best Cost of {} was achieved with {}, {}, {}, {}, {} params".format( max(results), solref1, solref2, solimp1, solimp2, solimp3)) tools.plot(results, title="Optimization Results from setting: {}".format( settings.replace(" ", "_")))
'x2': [0, 1], 'x3': [0, 1], 'x4': [0, 1], 'x5': [0, 1], 'x6': [0, 1], 'x7': [0, 1], 'x8': (0, 1), 'x9': (0, 1) }) # Additionally, if we have any prior knowledge of the behaviour of # the target function (even if not totally accurate) we can also # tell that to the optimizer. # Here we pass a dictionary with 'target' and parameter names as keys and a # list of corresponding values """ bo.initialize( { 'target': [-1, -1], 'x': [1, 1], 'y': [0, 2] } ) """ # Once we are satisfied with the initialization conditions # we let the algorithm do its magic by calling the maximize() # method. bo.maximize(init_points=5, n_iter=30, kappa=2) # The output values can be accessed with self.res
'x': (-4, 4), 'y': (-3, 3) }) # One of the things we can do with this object is pass points # which we want the algorithm to probe. A dictionary with the # parameters names and a list of values to include in the search # must be given. bo.explore({'x': [-1, 3], 'y': [-2, 2]}) # Additionally, if we have any prior knowledge of the behaviour of # the target function (even if not totally accurate) we can also # tell that to the optimizer. # Here we pass a dictionary with target values as keys of another # dictionary with parameters names and their corresponding value. bo.initialize({-2: {'x': 1, 'y': 0}, -1.251: {'x': 1, 'y': 1.5}}) # Once we are satisfied with the initialization conditions # we let the algorithm do its magic by calling the maximize() # method. bo.maximize(init_points=5, n_iter=15, kappa=3.29) # The output values can be accessed with self.res print(bo.res['max']) # If we are not satisfied with the current results we can pickup from # where we left, maybe pass some more exploration points to the algorithm # change any parameters we may choose, and the let it run again. bo.explore({'x': [0.6], 'y': [-0.23]}) # Making changes to the gaussian process can impact the algorithm
def run_bayesian_optimization(name, eval_file, target, var_ranges, init_points, max_iterations, patience, alpha): global evalcnt evalcnt = 0 print "now optimizing the following variables: " + str(var_ranges) print "alpha = " + str(alpha) # change the kernel to have a length scale more appropriate to this function # alpha ... corresponds to the value added to the diagonal elements of the covariance matrix <-> the approximate noise level in the observations gp_params = {'kernel': ConstantKernel(1.0, (1e-8, 1e2)) * Matern(length_scale = 0.01, length_scale_bounds = (1e-5, 1e5), nu = 1.5), 'alpha': alpha} bo = BayesianOptimization(target, var_ranges) # check if a file with previous evaluations of this utility function already exists, if so, use it for initialization evaluations_path = os.path.join(out_dir, eval_file) if os.path.exists(evaluations_path): confhandler = ConfigFileHandler() confhandler.load_configuration(evaluations_path) init_dict = {} for section_name in confhandler.get_sections(): cur_section = confhandler.get_section(section_name) for key, value in cur_section.iteritems(): # only take those variables that are actually relevant if key in var_ranges or key == "target": if key not in init_dict: init_dict[key] = [] init_dict[key].append(float(value)) evalcnt = int(re.sub('evaluation_', '', confhandler.get_sections()[-1])) + 1 print "resuming " + name + " at evaluation " + str(evalcnt) init_points_loaded = len(init_dict["target"]) print "found " + str(init_points_loaded) + " initialization points: " + str(init_dict) bo.initialize(init_dict) bo.maximize(init_points = max(0, init_points - init_points_loaded), n_iter = 0, acq = 'poi', kappa = 3, xi = xi_scheduler(0.0, max_iterations), **gp_params) print "initialization done" else: bo.maximize(init_points = init_points, n_iter = 0, acq = 'poi', kappa = 3, xi = xi_scheduler(0.0, max_iterations), **gp_params) cur_iteration = 1 patience_cnt = 0 best_cost = -7.0 for it in range(max_iterations): cur_xi = xi_scheduler(cur_iteration, max_iterations) print "cur_iteration = " + str(cur_iteration) + ", using xi = " + str(cur_xi) cur_iteration += 1 bo.maximize(init_points = 0, n_iter = 1, acq = 'poi', kappa = 3, xi = cur_xi, **gp_params) # evaluate the current maximum curval = bo.res['max'] cost = curval['max_val'] curparams = curval['max_params'] confhandler = ConfigFileHandler() confhandler.config.optionxform = str confhandler.new_section(name) confhandler.set_field(name, 'target', str(cost)) for key, val in curparams.iteritems(): confhandler.set_field(name, key, str(val)) confhandler.save_configuration(os.path.join(out_dir, name + '.txt')) # check if it is time to stop this optimization if(cost > best_cost): best_cost = cost patience_cnt = 0 patience_cnt += 1 if(patience_cnt > patience): break return curparams
# together with the parameters names and their bounds. bo = BayesianOptimization(lambda x, y: -x**2 - (y - 1)**2 + 1, {'x': (-4, 4), 'y': (-3, 3)}) # One of the things we can do with this object is pass points # which we want the algorithm to probe. A dictionary with the # parameters names and a list of values to include in the search # must be given. bo.explore({'x': [-1, 3], 'y': [-2, 2]}) # Additionally, if we have any prior knowledge of the behaviour of # the target function (even if not totally accurate) we can also # tell that to the optimizer. # Here we pass a dictionary with target values as keys of another # dictionary with parameters names and their corresponding value. bo.initialize({-2: {'x': 1, 'y': 0}, -1.251: {'x': 1, 'y': 1.5}}) # Once we are satisfied with the initialization conditions # we let the algorithm do its magic by calling the maximize() # method. bo.maximize(init_points=15, n_iter=25) # The output values can be accessed with self.res print(bo.res['max']) # If we are not satisfied with the current results we can pickup from # where we left, maybe pass some more exploration points to the algorithm # change any parameters we may choose, and the let it run again. bo.explore({'x': [0.6], 'y': [-0.23]}) bo.maximize(n_iter=5, acq='pi')
class LearningGUI: def __init__(self, learning_client): self.learning_client = learning_client self.parent = tk.Tk() self.parent.resizable(0, 0) self.parent.minsize(500, 500) self.parent.maxsize(1000, 1000) self.parent.title('Parameters Learning GUI') self.parent.bind('<Control-c>', lambda e: self.parent.destroy()) self.task_ctr_frame = tk.LabelFrame(self.parent, font=title_font, text="Task Settings") self.lrning_frame = tk.LabelFrame( self.parent, font=title_font, text="Bayesian Optimization Settings and Info") self.dyn_config_frame = tk.LabelFrame( self.parent, height=400, font=title_font, text="Dynamic Reconfigure Settings") self.lrning_frame.grid(row=0, column=1, sticky='wens', padx=2, pady=2) self.task_ctr_frame.grid(row=0, column=0, sticky='wns', padx=2, pady=2) self.dyn_config_frame.grid(row=1, column=0, columnspan=2, sticky='ns', padx=2, pady=2) self.parent.rowconfigure(1, minsize=400) self.parent.columnconfigure(1, weight=1) # --------- Task Control Frame --------- # self.task_ctr = dict() self.task_ctr['start'] = tk.Button(self.task_ctr_frame, width=10, font=normal_font, text='Start Task', command=self.start_task_once) self.task_ctr['fail'] = tk.Button( self.task_ctr_frame, width=10, font=normal_font, text='FAILURE', command=self.learning_client.cancel_task, fg='red') task_type_frame = tk.Frame(self.task_ctr_frame) v = tk.IntVar(task_type_frame) v.set(0) self.learning_client.set_action_settings(atype=0) self.task_ctr['circle'] = tk.Radiobutton( task_type_frame, text="Circle", variable=v, value=0, command=lambda: self.learning_client.set_action_settings(atype=0)) self.task_ctr['square'] = tk.Radiobutton( task_type_frame, text="Square", variable=v, value=1, command=lambda: self.learning_client.set_action_settings(atype=1)) self.task_ctr['circle'].pack(side='left', anchor='center') self.task_ctr['square'].pack(side='left', anchor='center') self.task_ctr['depth'] = tk.Scale( self.task_ctr_frame, from_=0.0, to=1.0, resolution=0.01, orient='horizontal', font=small_font, tickinterval=1, length=250, command=lambda x: self.learning_client.set_action_settings( depth=float(x))) self.task_ctr['radius'] = tk.Scale( self.task_ctr_frame, from_=0.1, to=1.5, resolution=0.1, orient='horizontal', font=small_font, tickinterval=1.4, length=250, command=lambda x: self.learning_client.set_action_settings( radius=float(x))) self.task_ctr['speed'] = tk.Scale( self.task_ctr_frame, from_=0.1, to=5.0, resolution=0.1, orient='horizontal', font=small_font, tickinterval=4.9, length=250, command=lambda x: self.learning_client.set_action_settings( speed=float(x))) self.task_ctr['depth'].set(0.05) self.task_ctr['radius'].set(1) self.task_ctr['speed'].set(0.2) self.task_ctr['start'].grid(columnspan=2, sticky='we', padx=2, pady=2) self.task_ctr['fail'].grid(row=0, column=2, columnspan=2, sticky='we', padx=2, pady=2) self.create_labels(self.task_ctr_frame, 1, 0, 0, 'Type', 'Depth', 'Radius', 'Speed') task_type_frame.grid(row=1, column=1, columnspan=3, sticky='we', padx=2, pady=2) self.task_ctr['depth'].grid(row=2, column=1, columnspan=3, sticky='we', padx=2, pady=2) self.task_ctr['radius'].grid(row=3, column=1, columnspan=3, sticky='we', padx=2, pady=2) self.task_ctr['speed'].grid(row=4, column=1, columnspan=3, sticky='we', padx=2, pady=2) # --------- Bayesian Optimization and Info Frame --------- # self.lrning_ctr = dict() self.lrning_ctr['init'] = tk.Button(self.lrning_frame, text='Add Initial Point', font=normal_font, command=self.add_last_init_pt) self.lrning_ctr['raninit'] = tk.Button( self.lrning_frame, text='Add Random Initial Points', font=normal_font, command=self.add_rand_init_pt) self.lrning_ctr['points'] = tk.Scale(self.lrning_frame, from_=1, to=10, orient='horizontal', font=small_font, tickinterval=9, length=150) self.lrning_ctr['start'] = tk.Button(self.lrning_frame, text='Start Learning', font=normal_font, command=self.learn) self.lrning_ctr['iter'] = tk.Scale(self.lrning_frame, from_=1, to=40, orient='horizontal', font=small_font, tickinterval=39, length=150) self.lrning_ctr['cancel'] = tk.Button(self.lrning_frame, text='Cancel Learning', width=12, font=normal_font, command=self.reset_learning, fg='red') self.lrning_ctr['load'] = tk.Button(self.lrning_frame, text='Automatic Load & Learn', font=normal_font, command=self.load_init_pts) self.lrning_ctr['save'] = tk.Button(self.lrning_frame, text='Save Results', font=normal_font, command=self.save_results) self.lrning_ctr['init'].grid(row=0, column=0, columnspan=2, sticky='we', padx=2, pady=2) self.lrning_ctr['raninit'].grid(row=1, column=0, columnspan=2, sticky='we', padx=2, pady=2) tk.Label(self.lrning_frame, font=small_font, anchor='e', width=8, text='Points').grid(row=2, column=0, padx=2, pady=2) self.lrning_ctr['points'].grid(row=2, column=1, sticky='we', padx=2, pady=2) self.lrning_ctr['start'].grid(row=3, column=0, columnspan=2, sticky='we', padx=2, pady=2) tk.Label(self.lrning_frame, font=small_font, anchor='e', width=8, text='Iterations').grid(row=4, column=0, padx=2, pady=2) self.lrning_ctr['iter'].grid(row=4, column=1, sticky='we', padx=2, pady=2) self.lrning_ctr['save'].grid(row=0, column=2, sticky='we', padx=2, pady=2) self.lrning_ctr['load'].grid(row=0, column=3, sticky='we', padx=2, pady=2) self.lrning_ctr['cancel'].grid(row=1, column=2, columnspan=2, sticky='we', padx=2, pady=2) self.params_frame = tk.LabelFrame(self.lrning_frame, font=title_font, text="Learning Params.") self.params_frame.grid(row=2, rowspan=3, column=2, sticky='ns', padx=2, pady=2) self.info_frame = tk.LabelFrame(self.lrning_frame, font=title_font, text="Information") self.info_frame.grid(row=2, rowspan=3, column=3, sticky='wens', padx=2, pady=2) self.lrning_frame.columnconfigure(3, weight=1) self.create_labels(self.params_frame, 0, 0, 0, 'Alpha', 'xi/kappa', 'Acq. Fun.', 'Loc. Opt.', 'd', 'logistic', anchor='e', width=8) self.lrning_param = dict() self.lrning_param['alpha'] = tk.Entry(self.params_frame, font=small_font, width=10) self.lrning_param['alpha'].insert(0, '1e-10') self.lrning_param['const'] = tk.Entry(self.params_frame, font=small_font, width=10) self.lrning_param['const'].insert(0, '0.001') self.lrning_param['var'] = tk.StringVar(self.params_frame) self.lrning_param['var'].set('poi') self.lrning_param['acq'] = tk.OptionMenu(self.params_frame, self.lrning_param['var'], 'poi', 'ei', 'ucb') self.lrning_param['acq'].config(font=small_font) self.lrning_param['locvar'] = tk.IntVar() self.lrning_param['local'] = tk.Checkbutton( self.params_frame, variable=self.lrning_param['locvar']) self.lrning_param['dist'] = tk.Entry(self.params_frame, font=small_font, width=10) self.lrning_param['dist'].insert(0, '0.1') self.lrning_param['logvar'] = tk.IntVar() self.lrning_param['logis'] = tk.Checkbutton( self.params_frame, variable=self.lrning_param['logvar']) self.lrning_param['alpha'].grid(row=0, column=1, padx=2, pady=2) self.lrning_param['const'].grid(row=1, column=1, padx=2, pady=2) self.lrning_param['acq'].grid(row=2, column=1, sticky='we', padx=2, pady=2) self.lrning_param['local'].grid(row=3, column=1, sticky='we', padx=2, pady=2) self.lrning_param['dist'].grid(row=4, column=1, padx=2, pady=2) self.lrning_param['logis'].grid(row=5, column=1, sticky='we', padx=2, pady=2) self.create_labels(self.info_frame, 0, 0, 0, 'Last Reward', 'Max Reward', 'Initial Points', 'Iterations', 'Dimensions', anchor='e', width=11) self.lrning_info = dict() self.lrning_info['last'] = tk.Label(self.info_frame, text='---', font=small_font, anchor='w', width=11, bd=2, relief='groove') self.lrning_info['max'] = tk.Label(self.info_frame, text='---', font=small_font, anchor='w', width=11, bd=2, relief='groove') self.lrning_info['init'] = tk.Label(self.info_frame, text='0', font=small_font, anchor='w', width=11, bd=2, relief='groove') self.lrning_info['itrs'] = tk.Label(self.info_frame, text='0', font=small_font, anchor='w', width=11, bd=2, relief='groove') self.lrning_info['dim'] = tk.Label(self.info_frame, text='0', font=small_font, anchor='w', width=11, bd=2, relief='groove') self.lrning_info['last'].grid(row=0, column=1, padx=2, pady=2) self.lrning_info['max'].grid(row=1, column=1, padx=2, pady=2) self.lrning_info['init'].grid(row=2, column=1, padx=2, pady=2) self.lrning_info['itrs'].grid(row=3, column=1, padx=2, pady=2) self.lrning_info['dim'].grid(row=4, column=1, padx=2, pady=2) # --------- Dynamic Reconfiguration Frame --------- # self.ctr_vars_frame = tk.LabelFrame(self.dyn_config_frame, height=400, font=title_font, text="Controlled Variables") self.fix_vars_frame = tk.LabelFrame(self.dyn_config_frame, height=400, font=title_font, text="Fixed Variables") self.link_vars_frame = tk.LabelFrame(self.dyn_config_frame, height=400, font=title_font, text="Linked Variables") self.dyn_ctr_frame = tk.Frame(self.dyn_config_frame) self.dyn_ctr_frame.pack(side='top', fill='x') self.ctr_vars_frame.pack(side='left', fill='y', padx=2, pady=2) self.fix_vars_frame.pack(side='left', fill='y', padx=2, pady=2) self.link_vars_frame.pack(side='left', fill='y', padx=2, pady=2) # --------- Dynamic Reconfiguration Control Frame --------- # self.dyn_update_button = tk.Button(self.dyn_ctr_frame, text='Send Values', width=12, font=normal_font, command=self.send_dyn_reconfig_vals) self.dyn_show_button = tk.Button( self.dyn_ctr_frame, text='Show Current', width=12, font=normal_font, command=self.show_current_dyn_reconfig) self.dyn_default_button = tk.Button( self.dyn_ctr_frame, text='Restore Default', width=12, font=normal_font, command=self.restore_dyn_reconfig_default) self.dyn_setmax_button = tk.Button(self.dyn_ctr_frame, text='Set on Max', width=12, font=normal_font, command=self.set_dyn_reconfig_max) self.dyn_update_button.pack(side='left', fill='y', padx=2, pady=2) self.dyn_show_button.pack(side='left', fill='y', padx=2, pady=2) self.dyn_default_button.pack(side='left', fill='y', padx=2, pady=2) self.dyn_setmax_button.pack(side='left', fill='y', padx=2, pady=2) # ---- Controlled Variables Frame ---- # self.create_labels(self.ctr_vars_frame, 0, 0, 1, 'Selected Variables', 'min.', 'set', 'max.') self.selected_ctr_vars = [] self.dyn_ctr_bottom = dict() self.dyn_ctr_bottom['var'] = tk.StringVar(self.ctr_vars_frame) self.dyn_ctr_bottom['opt'] = tk.OptionMenu(self.ctr_vars_frame, self.dyn_ctr_bottom['var'], 'a') self.dyn_ctr_bottom['min'] = tk.Entry(self.ctr_vars_frame, font=small_font, width=5) self.dyn_ctr_bottom['val'] = tk.Entry(self.ctr_vars_frame, font=small_font, width=5) self.dyn_ctr_bottom['max'] = tk.Entry(self.ctr_vars_frame, font=small_font, width=5) self.dyn_ctr_bottom['add'] = tk.Button(self.ctr_vars_frame, font=small_font, text='Add', command=self.add_dyn_ctr_var) # ---- Fixed Variables Frame ---- # self.create_labels(self.fix_vars_frame, 0, 0, 1, 'Selected Variables', 'set') self.selected_fix_vars = [] self.dyn_fix_bottom = dict() self.dyn_fix_bottom['var'] = tk.StringVar(self.fix_vars_frame) self.dyn_fix_bottom['opt'] = tk.OptionMenu(self.fix_vars_frame, self.dyn_fix_bottom['var'], 'a') self.dyn_fix_bottom['val'] = tk.Entry(self.fix_vars_frame, font=small_font, width=5) self.dyn_fix_bottom['add'] = tk.Button(self.fix_vars_frame, font=small_font, text='Add', command=self.add_dyn_fix_var) # ---- Linked Variables Frame ---- # self.create_labels(self.link_vars_frame, 0, 0, 1, 'Selected Variables', 'Linked') self.selected_link_vars = [] self.dyn_link_bottom = dict() self.dyn_link_bottom['var1'] = tk.StringVar(self.link_vars_frame) self.dyn_link_bottom['opt1'] = tk.OptionMenu( self.link_vars_frame, self.dyn_link_bottom['var1'], 'a') self.dyn_link_bottom['var2'] = tk.StringVar(self.link_vars_frame) self.dyn_link_bottom['opt2'] = tk.OptionMenu( self.link_vars_frame, self.dyn_link_bottom['var2'], 'a') self.dyn_link_bottom['add'] = tk.Button(self.link_vars_frame, font=small_font, text='Add', command=self.add_dyn_link_var) self.reset_learning() self.update_bottoms() tk.mainloop() def create_labels(self, parent, row, column, h, *labels, **config): for i in range(len(labels)): label = tk.Label(parent, text=labels[i], font=small_font, **config) if h: label.grid(row=row, column=column + i, padx=2, pady=2) else: label.grid(row=row + i, column=column, padx=2, pady=2) def get_float_entry(self, entry): try: return float(entry.get()) except ValueError: return None def reset_learning(self): self.learning_client.cancel_task self.bo = None # Bayesian Optimization class place holder self.learning_started = self.task_running = self.learning_initialized = False self.iters_running = 0 self.init_pts_num = 0 self.last_reward = None self.pos_error = [] self.rot_error = [] self.toggle_task_ctr() self.toggle_lrning_ctr() self.toggle_dyn_reconfig_ctr() self.update_info() def init_bo(self): if not self.bo: self.bo = BO(self.start_task, self.learning_client.controlled_vars) self.learning_started = True self.toggle_task_ctr() self.toggle_dyn_reconfig_ctr() def update_info(self): self.lrning_info['dim'].config(text=str(len(self.selected_ctr_vars))) if self.bo: self.lrning_info['init'].config(text=str(self.init_pts_num)) if self.bo.space.Y is not None: self.lrning_info['max'].config(text=str(max(self.bo.space.Y))) else: self.lrning_info['max'].config(text=str(max(self.bo.y_init))) if self.learning_initialized: self.lrning_info['itrs'].config( text=str(len(self.bo.space.Y) - self.init_pts_num)) else: self.lrning_info['itrs'].config(text='0') if self.last_reward is not None: self.lrning_info['last'].config(text=str(self.last_reward)) def toggle_task_ctr(self): self.task_ctr['start'][ 'state'] = 'disabled' if self.task_running or self.iters_running else 'normal' self.task_ctr['fail'][ 'state'] = 'normal' if self.task_running else 'disabled' for key in ['depth', 'radius', 'speed', 'circle', 'square']: if self.task_running or self.learning_started: self.task_ctr[key]['state'] = 'disabled' else: self.task_ctr[key]['state'] = 'normal' def toggle_lrning_ctr(self): for key in ['init', 'raninit', 'points']: if (not self.task_running) and len( self.selected_ctr_vars) and not self.learning_initialized: self.lrning_ctr[key]['state'] = 'normal' else: self.lrning_ctr[key]['state'] = 'disabled' for key in ['start', 'iter']: if not (self.task_running or self.iters_running) and self.init_pts_num: self.lrning_ctr[key].config(state='normal') else: self.lrning_ctr[key].config(state='disabled') self.lrning_ctr['cancel'][ 'state'] = 'normal' if self.learning_started else 'disabled' self.lrning_ctr['save']['state'] = 'normal' if self.learning_initialized and \ not (self.task_running or self.iters_running) else 'disabled' for key in ['alpha', 'const', 'acq', 'local', 'dist']: if not (self.task_running or self.iters_running) and self.init_pts_num: self.lrning_param[key].config(state='normal') else: self.lrning_param[key].config(state='disabled') self.lrning_param['logis']['state'] = 'normal' if self.learning_started and \ not (self.task_running or self.iters_running or self.learning_initialized) else 'disabled' def toggle_dyn_reconfig_ctr(self): if self.task_running or self.learning_started: self.dyn_ctr_bottom['add']['state'] = 'disabled' self.dyn_fix_bottom['add']['state'] = 'disabled' self.dyn_link_bottom['add']['state'] = 'disabled' for var, items in (self.selected_ctr_vars + self.selected_fix_vars + self.selected_link_vars): items['del']['state'] = 'disabled' for var, items in self.selected_fix_vars: items['val']['state'] = 'disabled' else: self.dyn_ctr_bottom['add']['state'] = 'normal' self.dyn_fix_bottom['add']['state'] = 'normal' self.dyn_link_bottom['add']['state'] = 'normal' for var, items in (self.selected_ctr_vars + self.selected_fix_vars + self.selected_link_vars): items['del']['state'] = 'normal' for var, items in self.selected_fix_vars: items['val']['state'] = 'normal' if self.task_running or self.iters_running: self.dyn_update_button['state'] = 'disabled' self.dyn_show_button['state'] = 'disabled' self.dyn_default_button['state'] = 'disabled' else: self.dyn_update_button['state'] = 'normal' self.dyn_show_button['state'] = 'normal' self.dyn_default_button['state'] = 'normal' if self.learning_initialized and not (self.task_running or self.iters_running): self.dyn_setmax_button['state'] = 'normal' else: self.dyn_setmax_button['state'] = 'disabled' def start_task(self, **ctr_vars): self.task_running = True self.toggle_task_ctr() self.toggle_dyn_reconfig_ctr() self.toggle_lrning_ctr() if ctr_vars: for var in ctr_vars: self.learning_client.set_dyn_reconfig_var(var, ctr_vars[var]) self.parent.after(200, self.check_new_dyn_vals) reward, self.last_pos_error, self.last_rot_error = self.learning_client.start_task( ) self.last_reward = self.convert_reward(reward) self.task_running = False if self.iters_running: self.iters_running -= 1 if not self.iters_running: self.restore_dyn_reconfig_default( ) # restore to default after finishing iterations. if not self.learning_initialized: self.init_pts_num += 1 self.pos_error.append(self.last_pos_error) self.rot_error.append(self.last_rot_error) self.toggle_task_ctr() self.toggle_dyn_reconfig_ctr() self.toggle_lrning_ctr() self.parent.after( 50, self.update_info ) # Needs to be done after a lag so that self.bo is updated after the current start_task return return self.last_reward def convert_reward(self, reward): if self.learning_initialized and self.enable_sig: reward = 1 / (1 + np.exp(-0.5 * (reward - self.sig_mid)) ) # logistic function return reward def check_new_dyn_vals(self): if self.learning_client.task_started: self.parent.after(100, self.show_current_dyn_reconfig) else: self.parent.after(200, self.check_new_dyn_vals) def start_task_once(self): self.task_thread = threading.Thread(target=self.start_task) self.task_thread.daemon = True self.task_thread.start() def add_last_init_pt(self): self.init_bo() if self.last_reward is not None: point = {'target': [self.last_reward]} for var in self.learning_client.controlled_vars: point[var] = [self.learning_client.current_config[var]] try: self.bo.initialize(point) self.init_pts_num += 1 self.pos_error.append(self.last_pos_error) self.rot_error.append(self.last_rot_error) self.toggle_lrning_ctr() self.update_info() except KeyError: print "CANNOT add the same point twice" def load_init_pts(self): def simulate(init, dim, coef, atype, speed, sig, local): with open(str(dim) + 'd' + str(init) + '.pkl', 'rb') as f: data = pickle.load(f) self.learning_client.controlled_vars = data['controlled_vars'] self.learning_client.fixed_vars = data['fixed_vars'] self.learning_client.linked_vars = data['linked_vars'] print data['controlled_vars'] print data['fixed_vars'] print data['linked_vars'] self.reset_learning() self.learning_client.set_action_settings(atype=atype) self.learning_client.set_action_settings(speed=speed) self.enable_sig = sig for i in range(data['init_pts_num']): vars = dict(zip(data['keys'], data['x'][i])) self.start_task(**vars) self.add_last_init_pt() self.initialize_learning() self.iters_running = 40 self.bo.maximize(init_points=0, n_iter=40, acq='poi', kappa=0.01, xi=0.01, local_acq_opt=local, d=0.05, alpha=1e-4) self.save_results(('square' if atype else 'circle') + str(dim) + 'd' + str(coef) + '-' + str(init) * (2 - sig) + 2 * str(init) * (not local) + '-2' + 's' + str(speed)) def sims(): simulate(1, 4, 1.16, 0, 0.5, True, False) self.task_thread = threading.Thread(target=sims) self.task_thread.daemon = True self.task_thread.start() def add_rand_init_pt(self): self.init_bo() itrs = int(self.lrning_ctr['points'].get()) self.iters_running = itrs self.task_thread = threading.Thread(target=lambda: self.bo.init(itrs)) self.task_thread.daemon = True self.task_thread.start() def initialize_learning(self): if self.init_pts_num: if not self.learning_initialized: self.learning_initialized = True if not self.bo.initialized: self.bo.init(0) self.enable_sig = self.lrning_param['logvar'].get() self.sig_mid = max(self.bo.space.Y) for i in range(len(self.bo.space.Y)): self.bo.space.Y[i] = self.convert_reward( self.bo.space.Y[i]) print self.bo.space.Y def learn(self): self.initialize_learning() if self.learning_initialized: itrs = int(self.lrning_ctr['iter'].get()) alpha = self.get_float_entry(self.lrning_param['alpha']) const = self.get_float_entry(self.lrning_param['const']) d = self.get_float_entry(self.lrning_param['dist']) acq = self.lrning_param['var'].get() local = self.lrning_param['locvar'].get() self.iters_running = itrs self.task_thread = threading.Thread( target=lambda: self.bo.maximize(init_points=0, n_iter=itrs, acq=acq, kappa=const, xi=const, local_acq_opt=local, d=d, alpha=alpha)) self.task_thread.daemon = True self.task_thread.start() def save_results(self, filename='learning_results_'): data = dict() data['x'] = self.bo.space.X data['y'] = self.bo.space.Y data['keys'] = self.bo.space.keys data['pos_error'] = np.vstack(self.pos_error) data['rot_error'] = np.vstack(self.rot_error) data['action_settings'] = self.learning_client.action_settings data['init_pts_num'] = self.init_pts_num data['learning_settings'] = { 'acq': self.lrning_param['var'].get(), 'loc': self.lrning_param['locvar'].get(), 'd': self.get_float_entry(self.lrning_param['dist']), 'alpha': self.get_float_entry(self.lrning_param['alpha']), 'const': self.get_float_entry(self.lrning_param['const']) } data['controlled_vars'] = self.learning_client.controlled_vars data['fixed_vars'] = self.learning_client.fixed_vars data['linked_vars'] = self.learning_client.linked_vars data['sig_mid'] = self.sig_mid # Modified to alleviate file overriding problem (Ramy) modFileName = filename + datetime.datetime.now().strftime( '%Y-%m-%d-%H-%M-%S') + '.pkl' with open(modFileName, 'wb') as f: pickle.dump(data, f) del data shutil.move( os.getcwd() + "/" + modFileName, rospkg.RosPack().get_path('spc_uav_comm') + "/scripts/practical/" + modFileName) print "Results Saved !" # ---------------- Dynamic Reconfigure Functions --------------- # def add_dyn_ctr_var(self): var = self.dyn_ctr_bottom['var'].get() try: min_val = float(self.dyn_ctr_bottom['min'].get()) max_val = float(self.dyn_ctr_bottom['max'].get()) if self.learning_client.add_dyn_ctr_var(var, min_val, max_val): self.learning_client.set_dyn_reconfig_var( var, self.get_float_entry(self.dyn_ctr_bottom['val'])) self.add_dyn_ctr_row(var, min_val, max_val) self.update_info() self.toggle_lrning_ctr() except ValueError: return # TODO: Warn the user for invalid input def add_dyn_fix_var(self): var = self.dyn_fix_bottom['var'].get() if self.learning_client.add_dyn_fix_var(var): self.learning_client.set_dyn_reconfig_var( var, self.get_float_entry(self.dyn_fix_bottom['val'])) self.add_dyn_fix_row(var) def add_dyn_link_var(self): var1 = self.dyn_link_bottom['var1'].get() var2 = self.dyn_link_bottom['var2'].get() if self.learning_client.add_dyn_link_var(var1, var2): self.add_dyn_link_row(var1, var2) def add_dyn_ctr_row(self, var, min_val, max_val): items = dict() items['var'] = tk.Label(self.ctr_vars_frame, font=small_font, text=var, anchor='e') items['min'] = tk.Label(self.ctr_vars_frame, font=small_font, text=min_val) items['val'] = tk.Entry(self.ctr_vars_frame, font=small_font, width=5) items['val'].insert(0, str(self.learning_client.current_config[var])) items['max'] = tk.Label(self.ctr_vars_frame, font=small_font, text=max_val) items['del'] = tk.Button(self.ctr_vars_frame, font=small_font, text='x', bd=0, relief='flat', command=lambda: self.delete_dyn_var(var)) self.selected_ctr_vars.append((var, items)) self.arrange_columns(items, 'var', 'min', 'val', 'max', 'del') self.place_dyn_row(items, len(self.selected_ctr_vars)) self.update_bottoms() def add_dyn_fix_row(self, var): items = dict() items['var'] = tk.Label(self.fix_vars_frame, font=small_font, text=var, anchor='e') items['val'] = tk.Entry(self.fix_vars_frame, font=small_font, width=5) items['val'].insert(0, str(self.learning_client.current_config[var])) items['del'] = tk.Button(self.fix_vars_frame, font=small_font, text='x', bd=0, relief='flat', command=lambda: self.delete_dyn_var(var)) self.selected_fix_vars.append((var, items)) self.arrange_columns(items, 'var', 'val', 'del') self.place_dyn_row(items, len(self.selected_fix_vars)) self.update_bottoms() def add_dyn_link_row(self, var1, var2): items = dict() items['var1'] = tk.Label(self.link_vars_frame, font=small_font, text=var1, anchor='e') items['var2'] = tk.Label(self.link_vars_frame, font=small_font, text='= ' + var2, anchor='e') items['del'] = tk.Button(self.link_vars_frame, font=small_font, text='x', bd=0, relief='flat', command=lambda: self.delete_dyn_var(var1)) self.selected_link_vars.append((var1, items)) self.arrange_columns(items, 'var1', 'var2', 'del') self.place_dyn_row(items, len(self.selected_link_vars)) self.update_bottoms() def arrange_columns(self, items, *columns): for i in range(len(columns)): config = items[columns[i]].grid_info() config['column'] = i items[columns[i]].grid(config) def place_dyn_row(self, items, row): for item in items.values(): config = item.grid_info() config['row'] = row item.grid(config) def delete_dyn_var(self, var): self.learning_client.delete_dyn_reconfig_var(var) self.update_vars_rows(self.selected_ctr_vars) self.update_vars_rows(self.selected_fix_vars) self.update_vars_rows(self.selected_link_vars) self.update_bottoms() self.update_info() self.toggle_lrning_ctr() def update_vars_rows(self, selected_vars): i = 0 while i < len(selected_vars): var, items = selected_vars[i] if var in self.learning_client.get_selectable_vars(): for item in items.values(): item.destroy() selected_vars.pop(i) else: i += 1 for i in range(len(selected_vars)): self.place_dyn_row(selected_vars[i][1], i + 1) def update_bottoms(self): self.place_dyn_ctr_bottom() self.place_dyn_fix_bottom() self.place_dyn_link_bottom() def place_dyn_ctr_bottom(self): row = len(self.selected_ctr_vars) + 1 self.dyn_ctr_bottom['opt'] = self.set_optionmenu( self.ctr_vars_frame, self.dyn_ctr_bottom['opt'], self.dyn_ctr_bottom['var'], self.learning_client.get_selectable_vars()) self.dyn_ctr_bottom['opt'].grid(row=1 + row, column=0, sticky="we", padx=2, pady=2) self.dyn_ctr_bottom['min'].grid(row=1 + row, column=1) self.dyn_ctr_bottom['val'].grid(row=1 + row, column=2) self.dyn_ctr_bottom['max'].grid(row=1 + row, column=3) self.dyn_ctr_bottom['add'].grid(row=1 + row, column=4, sticky="we", padx=2, pady=2) def place_dyn_fix_bottom(self): row = len(self.selected_fix_vars) + 1 self.dyn_fix_bottom['opt'] = self.set_optionmenu( self.fix_vars_frame, self.dyn_fix_bottom['opt'], self.dyn_fix_bottom['var'], self.learning_client.get_selectable_vars()) self.dyn_fix_bottom['opt'].grid(row=1 + row, column=0, sticky="we", padx=2, pady=2) self.dyn_fix_bottom['val'].grid(row=1 + row, column=1) self.dyn_fix_bottom['add'].grid(row=1 + row, column=2, sticky="we", padx=2, pady=2) def place_dyn_link_bottom(self): row = len(self.selected_link_vars) + 1 self.dyn_link_bottom['opt1'] = self.set_optionmenu( self.link_vars_frame, self.dyn_link_bottom['opt1'], self.dyn_link_bottom['var1'], self.learning_client.get_selectable_vars()) self.dyn_link_bottom['opt2'] = self.set_optionmenu( self.link_vars_frame, self.dyn_link_bottom['opt2'], self.dyn_link_bottom['var2'], self.learning_client.get_linkable_vars()) self.dyn_link_bottom['opt1'].grid(row=1 + row, column=0, sticky="we", padx=2, pady=2) self.dyn_link_bottom['opt2'].grid(row=1 + row, column=1, sticky="we", padx=2, pady=2) self.dyn_link_bottom['add'].grid(row=1 + row, column=2, sticky="we", padx=2, pady=2) def set_optionmenu(self, frame, optionmenu, var, options): if options: options.sort() var.set('Select Variable') optionmenu.destroy() optionmenu = tk.OptionMenu(frame, var, *options) optionmenu.config(width=11, font=small_font) else: var.set('Not Available') optionmenu.config(width=11, font=small_font, state='disabled') return optionmenu def show_current_dyn_reconfig(self): self.learning_client.refresh_current_config() for var, items in (self.selected_ctr_vars + self.selected_fix_vars): items['val'].delete(0, 'end') items['val'].insert(0, str(self.learning_client.current_config[var])) def restore_dyn_reconfig_default(self): self.learning_client.default_dyn_reconfig() self.parent.after(10, self.show_current_dyn_reconfig) def set_dyn_reconfig_max(self): if self.learning_initialized: point = self.bo.space.max_point()['max_params'] self.learning_client.send_controlled_vars(**point) self.parent.after(10, self.show_current_dyn_reconfig) def send_dyn_reconfig_vals(self): for var, items in (self.selected_ctr_vars + self.selected_fix_vars): self.learning_client.set_dyn_reconfig_var( var, self.get_float_entry(items['val'])) self.parent.after(10, self.show_current_dyn_reconfig)
import scipy.io as sio import numpy as np import matplotlib.pyplot as plt from bayes_opt import BayesianOptimization def lossfunction(lr, w1, w2): loss = np.random.uniform() * 20 return -loss bo = BayesianOptimization(lossfunction, { 'lr': (0.3, 3.0), 'w1': (0.3, 3.0), 'w2': (0.3, 3.0) }) bo.initialize({ 'target': [ -16.626141084222657, -16.656124820118073, -16.62569318934877, -16.62492867148469 ], 'lr': [1.6879, 2.1292, 0.3, 0.3], 'w1': [3.0000, 2.6128, 0.3, 0.3], 'w2': [0.9983, 2.0528, 0.3, 3.0] }) bo.maximize(init_points=0, n_iter=2, acq='ucb', kappa=2)
def main(): global evalcnt if len(sys.argv) != 4: print "Error: exactly 3 arguments are required" ref_dir = sys.argv[1] out_dir = sys.argv[2] lumi = float(sys.argv[3]) print ref_dir print out_dir print lumi def punzi_target(WP_VBF2j, WP_VBF1j, WP_WHh, WP_ZHh): global evalcnt bin_dir = "/home/llr/cms/wind/cmssw/CMSSW_9_4_2/bin/slc6_amd64_gcc630/" cost_function_evaluator = "run_WP_evaluator" output = check_output([ bin_dir + cost_function_evaluator, ref_dir, out_dir, str(lumi), str(WP_VBF2j), str(WP_VBF1j), str(WP_WHh), str(WP_ZHh) ]) costval = 0.0 for line in output.split('\n'): if "cost = " in line: costval = float(line.replace("cost = ", "")) break if math.isnan(costval): costval = -8.75 # save the sampled point such that later they can be used as exploration points (if the need occurs) confhandler = ConfigFileHandler() evaluations_path = out_dir + 'evaluations.txt' if os.path.exists(evaluations_path): confhandler.load_configuration(evaluations_path) print "saving evaluation for iteration " + str(evalcnt) section_name = 'evaluation_' + str(evalcnt) confhandler.new_section(section_name) confhandler.set_field(section_name, 'cost', str(costval)) confhandler.set_field(section_name, 'WP_VBF2j', str(WP_VBF2j)) confhandler.set_field(section_name, 'WP_VBF1j', str(WP_VBF1j)) confhandler.set_field(section_name, 'WP_WHh', str(WP_WHh)) confhandler.set_field(section_name, 'WP_ZHh', str(WP_ZHh)) confhandler.save_configuration(evaluations_path) evalcnt += 1 return costval eps = 1e-3 delta = 0.2 bo = BayesianOptimization( punzi_target, { 'WP_VBF2j': (eps, 1.0 - eps), 'WP_VBF1j': (eps, 1.0 - eps), 'WP_WHh': (eps, 1.0 - eps), 'WP_ZHh': (eps, 1.0 - eps) }) # check if a file with previously evaluated points exists, if so, use them for initialization confhandler = ConfigFileHandler() evaluations_path = out_dir + 'evaluations.txt' if os.path.exists(evaluations_path): confhandler.load_configuration(evaluations_path) targets_init = [] WP_VBF2j_init = [] WP_VBF1j_init = [] WP_WHh_init = [] WP_ZHh_init = [] for section_name in confhandler.get_sections(): cur_section = confhandler.get_section(section_name) targets_init.append(float(cur_section['cost'])) WP_VBF2j_init.append(float(cur_section['WP_VBF2j'])) WP_VBF1j_init.append(float(cur_section['WP_VBF1j'])) WP_WHh_init.append(float(cur_section['WP_WHh'])) WP_ZHh_init.append(float(cur_section['WP_ZHh'])) init_dict = { 'target': targets_init, 'WP_VBF2j': WP_VBF2j_init, 'WP_VBF1j': WP_VBF1j_init, 'WP_WHh': WP_WHh_init, 'WP_ZHh': WP_ZHh_init } evalcnt = int(re.sub('evaluation_', '', confhandler.get_sections()[-1])) + 1 print "resuming at evaluation " + str(evalcnt) bo.initialize(init_dict) initialized = True else: initialized = False # change the kernel to have a length scale more appropriate to this function gp_params = { 'kernel': 1.0 * Matern(length_scale=0.05, length_scale_bounds=(1e-5, 1e5), nu=1.5), 'alpha': 1e-5 } # perform the standard initialization and setup if initialized: bo.maximize(init_points=0, n_iter=0, acq='poi', kappa=3, xi=xi_scheduler(0.0), **gp_params) else: bo.maximize(init_points=6, n_iter=0, acq='poi', kappa=3, xi=xi_scheduler(0.0), **gp_params) cur_iteration = 1 for it in range(1000): cur_xi = xi_scheduler(cur_iteration) cur_iteration += 1 print "using xi = " + str(cur_xi) bo.maximize(init_points=6, n_iter=1, acq='poi', kappa=3, xi=cur_xi, **gp_params) # evaluate the current maximum curval = bo.res['max'] cost = curval['max_val'] WPs = curval['max_params'] confhandler = ConfigFileHandler() confhandler.config.optionxform = str confhandler.new_section('WPs') confhandler.set_field('WPs', 'cost', str(cost)) for key, val in WPs.iteritems(): confhandler.set_field('WPs', key, str(val)) confhandler.save_configuration(out_dir + 'WPs.txt')
'x': (-4, 4), 'y': (-3, 3) }) # One of the things we can do with this object is pass points # which we want the algorithm to probe. A dictionary with the # parameters names and a list of values to include in the search # must be given. bo.explore({'x': [-1, 3], 'y': [-2, 2]}) # Additionally, if we have any prior knowledge of the behaviour of # the target function (even if not totally accurate) we can also # tell that to the optimizer. # Here we pass a dictionary with 'target' and parameter names as keys and a # list of corresponding values bo.initialize({'target': [-1, -1], 'x': [1, 1], 'y': [0, 2]}) # Once we are satisfied with the initialization conditions # we let the algorithm do its magic by calling the maximize() # method. bo.maximize(init_points=5, n_iter=15, kappa=2) # The output values can be accessed with self.res print(bo.res['max']) # If we are not satisfied with the current results we can pickup from # where we left, maybe pass some more exploration points to the algorithm # change any parameters we may choose, and the let it run again. bo.explore({'x': [0.6], 'y': [-0.23]}) # Making changes to the gaussian process can impact the algorithm
idx = round(1000 * (np.log(2) - s), scoredp) featimp = featimp.append(pd.Series(fscores, name=idx)) return idx while True: init_points = args.init n_iter = args.iter scaledrange = {k: (0, 1) for k in p_range.keys()} bo = BayesianOptimization(score, scaledrange) if p: bo.initialize({ k: { pk: (pv - p_range[pk][0]) / (p_range[pk][1] - p_range[pk][0]) for pk, pv in param.iteritems() } for k, param in p.iteritems() }) else: init_points, n_iter = 5, 0 if not args.trunc: bo.maximize(init_points=init_points, n_iter=n_iter, acq=args.acq) featimp_cur = featimp p_new = {} for i in xrange(len(bo.Y)): if bo.Y[i] not in bo.y_init: p_new[bo.Y[i].round(scoredp)] = { bo.keys[j]: p_range[bo.keys[j]][0] * (1 - bo.X[i, j]) + p_range[bo.keys[j]][1] * bo.X[i, j] for j in xrange(len(bo.keys))
# One of the things we can do with this object is pass points # which we want the algorithm to probe. A dictionary with the # parameters names and a list of values to include in the search # must be given. bo.explore({'x': [-1, 3], 'y': [-2, 2]}) # Additionally, if we have any prior knowledge of the behaviour of # the target function (even if not totally accurate) we can also # tell that to the optimizer. # Here we pass a dictionary with 'target' and parameter names as keys and a # list of corresponding values bo.initialize( { 'target': [-1, -1], 'x': [1, 1], 'y': [0, 2] } ) # Once we are satisfied with the initialization conditions # we let the algorithm do its magic by calling the maximize() # method. bo.maximize(init_points=5, n_iter=15, kappa=2) # The output values can be accessed with self.res print(bo.res['max']) # If we are not satisfied with the current results we can pickup from # where we left, maybe pass some more exploration points to the algorithm # change any parameters we may choose, and the let it run again.
def main(): global evalcnt if len(sys.argv) != 4: print "Error: exactly 3 arguments are required" run_dir = sys.argv[1] out_dir = sys.argv[2] engine = sys.argv[3] print run_dir print out_dir print engine # punzi_target_2d = lambda WHlept_prior, ZHlept_prior: punzi_target(ggH_prior_default, WHhadr_prior_default, ZHhadr_prior_default, # WHlept_prior, ZHlept_prior, ZHMET_prior_default, # ttHhadr_prior_default, ttHlept_prior_default) def punzi_target(ggH_prior, WHhadr_prior, ZHhadr_prior, WHlept_prior, ZHlept_prior, ZHMET_prior, ttHhadr_prior, ttHlept_prior): global evalcnt bin_dir = "/home/llr/cms/wind/cmssw/CMSSW_9_4_2/bin/slc6_amd64_gcc630/" cost_function_evaluator = "run_prior_evaluator" output = check_output([ bin_dir + cost_function_evaluator, run_dir, out_dir, engine, str(ggH_prior), str(WHhadr_prior), str(ZHhadr_prior), str(WHlept_prior), str(ZHlept_prior), str(ZHMET_prior), str(ttHhadr_prior), str(ttHlept_prior) ]) costval = 0.0 for line in output.split('\n'): if "cost = " in line: costval = float(line.replace("cost = ", "")) break if math.isnan(costval): costval = -8.75 # add a regularization term that prefers default priors (i.e. close to 1.0) reg_term = 1.0 / 8.0 * ( (ggH_prior - 1.0)**2.0 + (WHhadr_prior - 1.0)**2.0 + (ZHhadr_prior - 1.0)**2.0 + (WHlept_prior - 1.0)**2.0 + (ZHlept_prior - 1.0)**2.0 + (ZHMET_prior - 1.0)**2.0 + (ttHhadr_prior - 1.0)**2.0 + (ttHlept_prior - 1.0)**2.0) costval -= reg_term * lambda_reg # save the sampled point such that later they can be used as exploration points (if the need occurs) confhandler = ConfigFileHandler() evaluations_path = out_dir + 'evaluations.txt' if os.path.exists(evaluations_path): confhandler.load_configuration(evaluations_path) print "saving evaluation for iteration " + str(evalcnt) section_name = 'evaluation_' + str(evalcnt) confhandler.new_section(section_name) confhandler.set_field(section_name, 'cost', str(costval)) confhandler.set_field(section_name, 'ggH_prior', str(ggH_prior)) confhandler.set_field(section_name, 'WHhadr_prior', str(WHhadr_prior)) confhandler.set_field(section_name, 'ZHhadr_prior', str(ZHhadr_prior)) confhandler.set_field(section_name, 'WHlept_prior', str(WHlept_prior)) confhandler.set_field(section_name, 'ZHlept_prior', str(ZHlept_prior)) confhandler.set_field(section_name, 'ZHMET_prior', str(ZHMET_prior)) confhandler.set_field(section_name, 'ttHhadr_prior', str(ttHhadr_prior)) confhandler.set_field(section_name, 'ttHlept_prior', str(ttHlept_prior)) confhandler.save_configuration(evaluations_path) evalcnt += 1 return costval eps = 1e-1 delta = 0.2 bo = BayesianOptimization( punzi_target, { 'ggH_prior': (1.0 - delta, 1.0 + delta), 'WHhadr_prior': (eps, 1.0), 'ZHhadr_prior': (eps, 1.0), 'WHlept_prior': (eps, 1.0), 'ZHlept_prior': (eps, 1.0), 'ZHMET_prior': (eps, 1.0), 'ttHhadr_prior': (eps, 1.0), 'ttHlept_prior': (eps, 1.0) }) # bo = BayesianOptimization(punzi_target_2d, {'WHlept_prior': (eps, WHlept_prior_default + delta), # 'ZHlept_prior': (eps, ZHlept_prior_default + delta)}) # check if a file with previously evaluated points exists, if so, use them for initialization confhandler = ConfigFileHandler() evaluations_path = out_dir + 'evaluations.txt' if os.path.exists(evaluations_path): confhandler.load_configuration(evaluations_path) ggH_priors_init = [] WHhadr_priors_init = [] ZHhadr_priors_init = [] WHlept_priors_init = [] ZHlept_priors_init = [] ZHMET_priors_init = [] ttHhadr_priors_init = [] ttHlept_priors_init = [] targets_init = [] for section_name in confhandler.get_sections(): cur_section = confhandler.get_section(section_name) targets_init.append(float(cur_section['cost'])) ggH_priors_init.append(float(cur_section['ggH_prior'])) WHhadr_priors_init.append(float(cur_section['WHhadr_prior'])) ZHhadr_priors_init.append(float(cur_section['ZHhadr_prior'])) WHlept_priors_init.append(float(cur_section['WHlept_prior'])) ZHlept_priors_init.append(float(cur_section['ZHlept_prior'])) ZHMET_priors_init.append(float(cur_section['ZHMET_prior'])) ttHhadr_priors_init.append(float(cur_section['ttHhadr_prior'])) ttHlept_priors_init.append(float(cur_section['ttHlept_prior'])) init_dict = { 'target': targets_init, 'ggH_prior': ggH_priors_init, 'WHhadr_prior': WHhadr_priors_init, 'ZHhadr_prior': ZHhadr_priors_init, 'WHlept_prior': WHlept_priors_init, 'ZHlept_prior': ZHlept_priors_init, 'ZHMET_prior': ZHMET_priors_init, 'ttHhadr_prior': ttHhadr_priors_init, 'ttHlept_prior': ttHlept_priors_init } evalcnt = int(re.sub('evaluation_', '', confhandler.get_sections()[-1])) + 1 print "resuming at evaluation " + str(evalcnt) bo.initialize(init_dict) initialized = True else: initialized = False # change the kernel to have a length scale more appropriate to this function # alpha ... corresponds to the value added to the diagonal elements of the covariance matrix <-> the approximate noise level in the observations gp_params = { 'kernel': 1.0 * Matern(length_scale=0.05, length_scale_bounds=(1e-5, 1e5), nu=1.5), 'alpha': 1e-1 } # perform the standard initialization and setup if initialized: bo.maximize(init_points=0, n_iter=0, acq='poi', kappa=3, xi=xi_scheduler(0.0), **gp_params) else: bo.maximize(init_points=6, n_iter=0, acq='poi', kappa=3, xi=xi_scheduler(0.0), **gp_params) cur_iteration = 1 for it in range(1000): cur_iteration += 1 cur_xi = xi_scheduler(cur_iteration) print "using xi = " + str(cur_xi) bo.maximize(init_points=6, n_iter=1, acq='poi', kappa=3, xi=cur_xi, **gp_params) # evaluate the current maximum curval = bo.res['max'] cost = curval['max_val'] priors = curval['max_params'] confhandler = ConfigFileHandler() confhandler.config.optionxform = str confhandler.new_section('Priors') confhandler.set_field('Priors', 'cost', str(cost)) confhandler.set_field('Priors', 'VBF_prior', str(1.0)) for key, val in priors.iteritems(): confhandler.set_field('Priors', key, str(val)) confhandler.save_configuration(out_dir + 'priors.txt')
def start_naive_bayes(automated_run, session, path): """Starts naive bayes automated run Args: automated_run (xcessiv.models.AutomatedRun): Automated run object session: Valid SQLAlchemy session path (str, unicode): Path to project folder """ module = functions.import_string_code_as_module(automated_run.source) random_state = 8 if not hasattr(module, 'random_state') else module.random_state assert module.metric_to_optimize in automated_run.base_learner_origin.metric_generators # get non-searchable parameters base_estimator = automated_run.base_learner_origin.return_estimator() base_estimator.set_params(**module.default_params) default_params = functions.make_serializable(base_estimator.get_params()) non_searchable_params = dict((key, val) for key, val in iteritems(default_params) if key not in module.pbounds) # get already calculated base learners in search space existing_base_learners = [] for base_learner in automated_run.base_learner_origin.base_learners: if not base_learner.job_status == 'finished': continue in_search_space = True for key, val in iteritems(non_searchable_params): if base_learner.hyperparameters[key] != val: in_search_space = False break # If no match, move on to the next base learner if in_search_space: existing_base_learners.append(base_learner) # build initialize dictionary target = [] initialization_dict = dict((key, list()) for key in module.pbounds.keys()) for base_learner in existing_base_learners: # check if base learner's searchable hyperparameters are all numerical all_numerical = True for key in module.pbounds.keys(): if not isinstance(base_learner.hyperparameters[key], numbers.Number): all_numerical = False break if not all_numerical: continue # if there is a non-numerical hyperparameter, skip this. for key in module.pbounds.keys(): initialization_dict[key].append(base_learner.hyperparameters[key]) target.append(base_learner.individual_score[module.metric_to_optimize]) initialization_dict['target'] = target if not module.invert_metric \ else list(map(lambda x: -x, target)) print('{} existing in initialization dictionary'.format( len(initialization_dict['target']))) # Create function to be optimized func_to_optimize = return_func_to_optimize( path, session, automated_run.base_learner_origin, module.default_params, module.metric_to_optimize, module.invert_metric, set(module.integers)) # Create Bayes object bo = BayesianOptimization(func_to_optimize, module.pbounds) bo.initialize(initialization_dict) np.random.seed(random_state) bo.maximize(**module.maximize_config) automated_run.job_status = 'finished' session.add(automated_run) session.commit()
def run(self, num_iterations, kappa=10): """ Fetches latest t-SNE model from DB. Collects pickled BO status object, if existent. Intermediate t-SNE models are persisted. :param num_iterations: Number of iterations BO should run. :param kappa: :return: """ # 1. Load all previous t-SNE parameters and results (read_metadata_for_run). Consider which params are # fixed though! Put only dynamic ones in dict. for BO, static ones should be made available via class # attribute. self.run_metadata = self.db_connector.read_metadata_for_run( self.run_name) # Set fixed parameters. self.fixed_parameters = self._update_parameter_dictionary( run_iter_metadata=self.run_metadata[0], is_fixed=True) self.variable_parameters = self._update_parameter_dictionary( run_iter_metadata=self.run_metadata[0], is_fixed=False) # 2. Generate dict object for BO.initialize from t-SNE metadata. initialization_dataframe = pandas.DataFrame.from_dict( self.run_metadata) # Drop non-hyperparameter columns. initialization_dataframe.drop(TSNEModel.ISFIXED_COLUMN_NAMES, inplace=True, axis=1) # Create initialization dictionary. initialization_dict = { column_name[3:-6]: initialization_dataframe[column_name[3:-6]].values.tolist() for column_name in TSNEModel.ISFIXED_COLUMN_NAMES } # Add target values (model quality) to initialization dictionary. initialization_dict["target"] = initialization_dataframe[ "measure_user_quality"].values.tolist() # Replace categorical values (strings) with integer representations. initialization_dict["metric"] = [ TSNEModel.CATEGORICAL_VALUES["metric"].index(metric) for metric in initialization_dict["metric"] ] initialization_dict["init_method"] = [ TSNEModel.CATEGORICAL_VALUES["init_method"].index(metric) for metric in initialization_dict["init_method"] ] # 3. Create BO object. parameter_ranges = copy.deepcopy(TSNEModel.PARAMETER_RANGES) # Update key for min. gradient norm, since for whatever reason BO optimizer wrecks this number. parameter_ranges["min_grad_norm"] = (-10, -7) # Drop all fixed parameters' ranges and entries in initialization dictionary. for key in self.fixed_parameters: if self.fixed_parameters[key] is not None: del parameter_ranges[key] del initialization_dict[key] # Create optimization object. bo = BayesianOptimization(self._calculate_tsne_quality, parameter_ranges) # Pass previous results to BO instance. bo.initialize(initialization_dict) # 4. Execute optimization. num_init_points = max(int(num_iterations / 4), 1) bo.maximize(init_points=num_init_points, n_iter=(num_iterations - num_init_points), kappa=kappa, acq='ucb')
def target(x): return np.exp(-(x - 2)**2) + np.exp(-(x - 6)**2 / 10) + 1 / (x**2 + 1) x = np.linspace(-2, 10, 10000).reshape(-1, 1) y = target(x) bo = BayesianOptimization(target, {'x': (-2, 10)}) # Additionally, if we have any prior knowledge of the behaviour of # the target function (even if not totally accurate) we can also # tell that to the optimizer. # Here we pass a dictionary with 'target' and parameter names as keys and a # list of corresponding values bo.initialize({ 'target': [0.20166, 1.08328, 1.30455, 0.21180], 'x': [-2, 2.6812, 1.6509, 10] }) # utility = Upper Confidence Bound # alternative acq = 'ei' (Expected Improvement) # kappa = exploration vs exploitation. 10 -> much exploration, 1 -> only tight exploitation bo.maximize(init_points=5, n_iter=5, acq='ucb', kappa=5) # The output values can be accessed with self.res print('Best param/output so far:', bo.res['max']) utility = bo.util.utility(x, bo.gp, 0) print('Best param to test next:', x[np.argmax(utility)]) y_max = bo.Y.max() x_max = helpers.acq_max(ac=bo.util.utility, gp=bo.gp, y_max=y_max, bounds=bo.bounds)
fscore = fi['Expected Gain'].to_dict() #Gain, FScore, wFScore, Average wFScore, Average Gain, Expected Gain meanscore = np.average(fscore.values()) for k in fscore.keys(): fscore[k]/=meanscore*len(fscore) featimpmean=featimpmean.fillna(1./featimp.shape[1]) normalization = featimpmean[chosen_feat].sum()/featimpmean.sum()/np.sum(fscore.values())/kftune.get_n_splits() for k,v in fscore.iteritems(): fscores[k]+=normalization*v curscore = -mean_absolute_error(yback(y_pred,params),yback(train_y,params)) featimp = featimp.append(pd.Series(fscores,name=round(curscore,4))) return curscore while True: init_points=args.init n_iter=args.iter bo = BayesianOptimization(score, p_range) if p: bo.initialize(p) else: init_points,n_iter=1,0 if args.trunc: init_points,n_iter=0,0 bo.maximize(init_points=init_points, n_iter=n_iter, acq=args.acq) featimp_cur=featimp p_new = {} for i in xrange(len(bo.Y)): if bo.Y[i] not in bo.y_init: p_new[bo.Y[i].round(4)]={bo.keys[j]:bo.X[i,j].round(4) for j in xrange(len(bo.keys))} if not os.path.isfile(picklefile): break with open(picklefile,'rb') as infile: try: (featimp,p_now,n_rounds_without_improve,n_wait)=pickle.load(infile) p.update(p_now) except: featimp=featimp_cur
def start_automated_run(path, automated_run_id): """Starts automated run. This will automatically create base learners until the run finishes or errors out. Args: path (str): Path to Xcessiv notebook automated_run_id (str): Automated Run ID """ with functions.DBContextManager(path) as session: automated_run = session.query(models.AutomatedRun).filter_by(id=automated_run_id).first() if not automated_run: raise exceptions.UserError('Automated run {} ' 'does not exist'.format(automated_run_id)) automated_run.job_id = get_current_job().id automated_run.job_status = 'started' session.add(automated_run) session.commit() try: module = functions.import_string_code_as_module(automated_run.source) random_state = 8 if not hasattr(module, 'random_state') else module.random_state assert module.metric_to_optimize in automated_run.base_learner_origin.metric_generators # get non-searchable parameters base_estimator = automated_run.base_learner_origin.return_estimator() base_estimator.set_params(**module.default_params) default_params = functions.make_serializable(base_estimator.get_params()) non_searchable_params = dict((key, val) for key, val in iteritems(default_params) if key not in module.pbounds) # get already calculated base learners in search space existing_base_learners = [] for base_learner in automated_run.base_learner_origin.base_learners: if not base_learner.job_status == 'finished': continue in_search_space = True for key, val in iteritems(non_searchable_params): if base_learner.hyperparameters[key] != val: in_search_space = False break # If no match, move on to the next base learner if in_search_space: existing_base_learners.append(base_learner) # build initialize dictionary target = [] initialization_dict = dict((key, list()) for key in module.pbounds.keys()) for base_learner in existing_base_learners: # check if base learner's searchable hyperparameters are all numerical all_numerical = True for key in module.pbounds.keys(): if not isinstance(base_learner.hyperparameters[key], numbers.Number): all_numerical = False break if not all_numerical: continue # if there is a non-numerical hyperparameter, skip this. for key in module.pbounds.keys(): initialization_dict[key].append(base_learner.hyperparameters[key]) target.append(base_learner.individual_score[module.metric_to_optimize]) initialization_dict['target'] = target if not module.invert_metric \ else list(map(lambda x: -x, target)) print('{} existing in initialization dictionary'. format(len(initialization_dict['target']))) # Create function to be optimized func_to_optimize = return_func_to_optimize( path, session, automated_run.base_learner_origin, module.default_params, module.metric_to_optimize, module.invert_metric, set(module.integers) ) # Create Bayes object bo = BayesianOptimization(func_to_optimize, module.pbounds) bo.initialize(initialization_dict) np.random.seed(random_state) bo.maximize(**module.maximize_config) automated_run.job_status = 'finished' session.add(automated_run) session.commit() except: session.rollback() automated_run.job_status = 'errored' automated_run.description['error_type'] = repr(sys.exc_info()[0]) automated_run.description['error_value'] = repr(sys.exc_info()[1]) automated_run.description['error_traceback'] = \ traceback.format_exception(*sys.exc_info()) session.add(automated_run) session.commit() raise
np.savez(path, mu0=X[keys.index('mu0')], gamma0=X[keys.index('gamma0')], beta0=X[keys.index('beta0')], eta0=X[keys.index('eta0')], kappa0=X[keys.index('kappa0')], kappa1=X[keys.index('kappa1')], lambda0=X[keys.index('lambda0')], target=Y) name_result_file = 'resultPG5PC1PC2.txt' label = 'PG5PC1PC2' else: print('Warning: set model name') sys.exit() # training BO = BayesianOptimization(evaluate_BO, pbounds) if args.init_npz: npzfile = np.load(args.init_npz) BO.initialize(dict(npzfile)) BO.maximize(init_points=bo_init_points, n_iter=bo_num_iter) saveBO(BO, 'full') ''' with open(os.path.join(snapshot_path, name_result_file),'a') as f: f.write('##{},full##\n'.format(label)) f.write('keys: {}\n'.format(BO.keys)) f.write('opt X: {}\n'.format(BO.X[BO.Y.argmax()])) f.write('max cor: {}\n'.format(BO.Y.max())) '''