def minimize( self, problem: Problem, x0: np.ndarray, id: str, history_options: HistoryOptions = None, ) -> OptimizerResult: lb = problem.lb ub = problem.ub objective = problem.objective if dlib is None: raise ImportError( "This optimizer requires an installation of dlib.") if not objective.has_fun: raise Exception("For this optimizer, the objective must " "be able to return function values.") # dlib requires variable length arguments def get_fval_vararg(*x): return objective.get_fval(x) dlib.find_min_global( get_fval_vararg, list(lb), list(ub), int(self.options['maxiter']), 0.002, ) optimizer_result = OptimizerResult() return optimizer_result
def main(self, piezo_scan_range=Q_(30,'V'), maxevals=50, initial_current=Q_(220,'mA'), initial_feedforward=Q_(-0.2, 'mA/V'), max_retries =2): #Set the optimization parametters sigma0 = 1 x0 = [ (initial_current.to('mA')/self.CONSTS['current_scaling'].to('mA')).m, initial_feedforward.to('mA / V').m, ] bounds = [[self.CONSTS['current_bounds'][0] / self.CONSTS['current_scaling'].to('mA').m, self.CONSTS['feedfoward_bounds'][0]], [self.CONSTS['current_bounds'][1] / self.CONSTS['current_scaling'].to('mA').m, self.CONSTS['feedfoward_bounds'][1]]] cmaopts = { 'tolfun':self.CONSTS['error_threshold'], 'tolx': 1e-2, 'maxfevals': maxevals, 'bounds': bounds, 'verb_disp':self.CONSTS['verbose'],# No printing of the optimization results on the console } for retry_idx in self.progress(range(max_retries)): #Set to passive mode self.fp.active_mode = False self.dlc.scan_enabled = True self.dlc.piezo_external_input_enabled = True #Run the optimization self.inner_progress = iter(self.progress(range(maxevals))) if self.CONSTS['optimizer'] == 'cma': result = cma.fmin(self.cost_func, x0, sigma0, options=cmaopts) xopt = result[0] elif self.CONSTS['optimizer'] == 'dlib': _f = lambda current, ff: self.cost_func([current, ff]) result = dlib.find_min_global(_f, bounds[0], bounds[1], maxevals) xopt = result[0] #Set the optimal parameters err = self.cost_func(xopt) #Verify the results self.fp.refresh() peak_mags = self.fp.peak_magnitudes() restart = False # If there is too many peak => Restart if len(peak_mags) > self.num_peak_threshold: restart = True if self.CONSTS['verbose']: print('CTROptimize Retry #{}: Too many peaks...'.format(retry_idx)) # If the sum of square error metric is to high => Restart if err > self.CONSTS['error_threshold']: restart = True if self.CONSTS['verbose']: print('CTROptimize Retry #{}: err is too high ({})...'.format(retry_idx,err)) # Break the loop if we are done if not restart: break if self.CONSTS['verbose']: print('CTROptimize terminated with values {} and err of {}'.format(xopt, err))
def minimize( self, problem: Problem, x0: np.ndarray, id: str, history_options: HistoryOptions = None, optimize_options: OptimizeOptions = None, ) -> OptimizerResult: """Perform optimization. Parameters: see `Optimizer` documentation.""" lb = problem.lb ub = problem.ub check_finite_bounds(lb, ub) objective = problem.objective if dlib is None: raise ImportError( "This optimizer requires an installation of dlib. You can " "install dlib via `pip install dlib`.") if not objective.has_fun: raise ValueError("For this optimizer, the objective must " "be able to return function values.") # dlib requires variable length arguments def get_fval_vararg(*x): return objective.get_fval(x) dlib.find_min_global( get_fval_vararg, list(lb), list(ub), int(self.options['maxiter']), 0.002, ) optimizer_result = OptimizerResult() return optimizer_result
def compute( self, x_min: Union[T, Iterable[T]], x_max: Union[T, Iterable[T]], num_evals: int, epsilon: Optional[float] = 0, ) -> Tuple[T, Union[int, float]]: return dlib.find_min_global( self._evaluate_objective, x_min if isinstance(x_min, list) else [x_min], x_max if isinstance(x_max, list) else [x_max], num_evals, solver_epsilon=epsilon, )
def optimize_inverse_uvl_coords(xyz_coords, rotate, layer_extents, pop_layers, optiter=100): import dlib f_uvl_distance = make_uvl_distance(xyz_coords, rotate=rotate) for layer, count in viewitems(pop_layers): if count > 0: min_extent = layer_extents[layer][0] max_extent = layer_extents[layer][1] uvl_coords, dist = dlib.find_min_global(f_uvl_distance, min_extent, max_extent, optiter) if uvl_in_bounds(uvl_coords, layer_extents, {layer: count}): return uvl_coords return None
def dlib_default_cube(objective, n_trials, n_dim, with_count=False): global feval_count feval_count = 0 lb = [0. for _ in range(n_dim)] ub = [1. for _ in range(n_dim)] def _objective(*args) -> float: global feval_count feval_count += 1 return objective(list(args)) best_x, best_val = find_min_global(_objective, lb, ub, n_trials) return (best_val, best_x, feval_count) if with_count else (best_val, best_x)
def test_global_optimization_nargs(): w0 = find_max_global(lambda *args: sum(args), [0, 0, 0], [1, 1, 1], 10) w1 = find_min_global(lambda *args: sum(args), [0, 0, 0], [1, 1, 1], 10) assert w0 == ([1, 1, 1], 3) assert w1 == ([0, 0, 0], 0) w2 = find_max_global(lambda a, b, c, *args: a + b + c - sum(args), [0, 0, 0], [1, 1, 1], 10) w3 = find_min_global(lambda a, b, c, *args: a + b + c - sum(args), [0, 0, 0], [1, 1, 1], 10) assert w2 == ([1, 1, 1], 3) assert w3 == ([0, 0, 0], 0) with raises(Exception): find_max_global(lambda a, b: 0, [0, 0, 0], [1, 1, 1], 10) with raises(Exception): find_min_global(lambda a, b: 0, [0, 0, 0], [1, 1, 1], 10) with raises(Exception): find_max_global(lambda a, b, c, d, *args: 0, [0, 0, 0], [1, 1, 1], 10) with raises(Exception): find_min_global(lambda a, b, c, d, *args: 0, [0, 0, 0], [1, 1, 1], 10)
def test_global_optimization_nargs(): w0 = find_max_global(lambda *args: sum(args), [0, 0, 0], [1, 1, 1], 10) w1 = find_min_global(lambda *args: sum(args), [0, 0, 0], [1, 1, 1], 10) assert w0 == ([1, 1, 1], 3) assert w1 == ([0, 0, 0], 0) w2 = find_max_global(lambda a, b, c, *args: a + b + c - sum(args), [0, 0, 0], [1, 1, 1], 10) w3 = find_min_global(lambda a, b, c, *args: a + b + c - sum(args), [0, 0, 0], [1, 1, 1], 10) assert w2 == ([1, 1, 1], 3) assert w3 == ([0, 0, 0], 0) with raises(Exception): find_max_global(lambda a, b: 0, [0, 0, 0], [1, 1, 1], 10) with raises(Exception): find_min_global(lambda a, b: 0, [0, 0, 0], [1, 1, 1], 10) with raises(Exception): find_max_global(lambda a, b, c, d, *args: 0, [0, 0, 0], [1, 1, 1], 10) with raises(Exception): find_min_global(lambda a, b, c, d, *args: 0, [0, 0, 0], [1, 1, 1], 10)
def method_dlib(): import dlib x = dlib.find_min_global(fdlib, *list(map(list, zip(*bounds))), args.opt_iters) return x[1], x[0]
options.lambda_param = lambda_param options.num_threads = 4 options.be_verbose = True print("start training") print(options) sys.stdout.flush() dlib.train_shape_predictor(training_xml_path, "bbr_predictor.dat", options) print("\nTraining error: ", dlib.test_shape_predictor(training_xml_path, "bbr_predictor.dat")) err = dlib.test_shape_predictor(testing_xml_path, "bbr_predictor.dat") print("\nTesting error: ", err) sys.stdout.flush() return err lower = [5, -0.2, 0.001, 2, 100, 0.01, 0] upper = [25, 0.2, 0.20, 5, 1000, 0.99, 0.3] isint = [True, False, False, True, True, False, False] x, y = dlib.find_min_global(test_params, bound1=lower, bound2=upper, is_integer_variable=isint, num_function_calls=100) print("optimal inputs: {}".format(x)) print("optimal output: {}".format(y)) test_params(x[0], x[1], x[2], x[3], x[4], x[5], x[6])
# root folder and run: # python setup.py install # # Compiling dlib should work on any operating system so long as you have # CMake and boost-python installed. On Ubuntu, this can be done easily by # running the command: # sudo apt-get install libboost-python-dev cmake # import dlib from math import sin, cos, pi, exp, sqrt # This is a standard test function for these kinds of optimization problems. # It has a bunch of local minima, with the global minimum resulting in # holder_table()==-19.2085025679. def holder_table(x0, x1): return -abs(sin(x0) * cos(x1) * exp(abs(1 - sqrt(x0 * x0 + x1 * x1) / pi))) # Find the optimal inputs to holder_table(). The print statements that follow # show that find_min_global() finds the optimal settings to high precision. x, y = dlib.find_min_global( holder_table, [-10, -10], # Lower bound constraints on x0 and x1 respectively [10, 10], # Upper bound constraints on x0 and x1 respectively 80) # The number of times find_min_global() will call holder_table() print("optimal inputs: {}".format(x)) print("optimal output: {}".format(y))
def run_hyperparameter_search(self): hyperparam_results_list = [] hyper_time = time.time() self.parameter_dict['training_early_stop'] = self.parameter_dict[ 'early_stop_cf'] training_batch_handler_cache = {} validation_batch_handler_cache = {} def hyper_training_helper(hyper_learning_rate, hyper_rnn_size, hyper_reg_embedding_beta, hyper_reg_l2_beta, hyper_learning_rate_decay, hyper_learning_rate_min, padding_loss_logit_weight, padding_loss_mixture_weight): """ Function used to wrap the hyperparameters and settings such that it fits the format used by dlib. Some variables need to be side-loaded, mostly reporting values. """ ############# SELECT NEW PARAMS self.parameter_dict['learning_rate'] = 10**hyper_learning_rate self.parameter_dict['rnn_size'] = int(hyper_rnn_size) self.parameter_dict[ 'reg_embedding_beta'] = 10**hyper_reg_embedding_beta self.parameter_dict['l2_reg_beta'] = 10**hyper_reg_l2_beta self.parameter_dict[ 'learning_rate_decay_factor'] = hyper_learning_rate_decay self.parameter_dict['learning_rate_min'] = \ (10 ** hyper_learning_rate_min) * self.parameter_dict['learning_rate'] self.parameter_dict['embedding_size'] = self.parameter_dict[ 'rnn_size'] self.parameter_dict[ 'padding_loss_logit_weight'] = padding_loss_logit_weight self.parameter_dict[ 'padding_loss_mixture_weight'] = padding_loss_mixture_weight # Update Cutoffs self.parameter_dict['long_training_time'] = self.parameter_dict[ 'early_stop_cf'] self.parameter_dict['long_training_steps'] = self.parameter_dict[ 'hyper_search_step_cutoff'] ######### / PARAMS print 'learning_rate ' + str(10**hyper_learning_rate) print 'rnn_size ' + str(hyper_rnn_size) print 'reg_embedding_beta ' + str( 10**hyper_reg_embedding_beta) print 'l2_reg_beta ' + str(10**hyper_reg_l2_beta) print 'learning_rate_decay_factor ' + str( hyper_learning_rate_decay) print 'padding_loss_logit_weight ' + str( padding_loss_logit_weight) print 'padding_loss_mixture_weight ' + str( padding_loss_mixture_weight) cf_fold = -1 # I should call this outside the crossfold, so it occurs once # This way all the crossfolds for the same hyperparameters are adjacent in the checkpoint dirs log_file_time = str(time.time()) cf_results_list = [] for train_pool, val_pool in self.cf_pool: cf_fold += 1 log_file_name = log_file_time + "-cf-" + str(cf_fold) print "Starting crossfold" # Collect batch_handlers, and check if they've been cached. try: training_batch_handler = training_batch_handler_cache[hash( tuple(np.sort(train_pool.uniqueId.unique())))] except KeyError: training_batch_handler = BatchHandler.BatchHandler( train_pool, self.parameter_dict, True) except AttributeError: print 'This should not be attainable, as crossfold==2 is invalid' try: validation_batch_handler = validation_batch_handler_cache[ hash(tuple(np.sort(val_pool.uniqueId.unique())))] except KeyError: validation_batch_handler = BatchHandler.BatchHandler( val_pool, self.parameter_dict, False) except AttributeError: print 'This should not be attainable, as crossfold==2 is invalid' # Add input_size, num_classes self.parameter_dict[ 'input_size'] = training_batch_handler.get_input_size() self.parameter_dict[ 'num_classes'] = training_batch_handler.get_num_classes() netManager = NetworkManager.NetworkManager( self.parameter_dict, log_file_name) netManager.build_model(self.encoder_means, self.encoder_stddev) try: cf_results = self.train_network(netManager, training_batch_handler, validation_batch_handler, hyper_search=True) except tf.errors.InvalidArgumentError: print "**********************caught error, probably gradients have exploded" return 99999999 # HUGE LOSS --> this was caused by bad init conditions, so it should be avoided. # Now assign the handlers to the cache IF AND ONLY IF the training was successful. # If it dies before the first pool sort in the training, the whole thing falls over. validation_batch_handler_cache[hash( tuple(np.sort(val_pool.uniqueId.unique())) )] = validation_batch_handler training_batch_handler_cache[hash( tuple(np.sort(train_pool.uniqueId.unique())) )] = training_batch_handler cf_results['crossfold_number'] = cf_fold # As pandas does not like lists when adding a list to a row of a dataframe, set to None (the lists are # a large amount of redundant data). This is why I copy out parameters.py for key, value in cf_results.iteritems(): if (type(value) is list or type(value) is np.ndarray or type(value) is tuple): cf_results[key] = pd.Series([value], dtype=object) cf_results_list.append(pd.DataFrame(cf_results, index=[0])) # plot print "Drawing html graph" if self.parameter_dict['model_type'] == 'categorical': netManager.draw_categorical_html_graphs( validation_batch_handler) else: netManager.draw_generative_html_graphs( validation_batch_handler, multi_sample=1) netManager.draw_generative_html_graphs( validation_batch_handler, multi_sample=20) # Here we have a fully trained model, but we are still in the cross fold. # FIXME Only do 1 fold per hyperparams. Its not neccessary to continue break # Run reportwriter here and return all_tracks..... euclidean loss? val_acc, val_loss, report_df =\ self.test_network(netManager, validation_batch_handler) cf_df = pd.concat(cf_results_list) # Condense results from cross fold (Average, best, worst, whatever selection method) hyperparam_results = copy.copy(self.parameter_dict) #hyperparam_results['input_columns'] = ",".join(hyperparam_results['input_columns']) hyperparam_results['eval_accuracy'] = np.min( cf_df['eval_accuracy']) hyperparam_results['final_learning_rate'] = np.min( cf_df['final_learning_rate']) hyperparam_results['training_accuracy'] = np.min( cf_df['training_accuracy']) hyperparam_results['training_loss'] = np.average( cf_df['training_loss']) hyperparam_results['validation_accuracy'] = np.average( cf_df['validation_accuracy']) hyperparam_results['validation_loss'] = np.average( cf_df['validation_loss']) track_scores = ReportWriter.ReportWriter.score_model_on_metric( self.parameter_dict, report_df) hyperparam_results['euclidean_err_sum'] = sum( track_scores['euclidean']) hyperparam_results['crossfold_number'] = -1 #FIXME What is this line doing? hyperparam_results['network_chkpt_dir'] = (cf_df.sort_values( 'eval_accuracy', ascending=False).iloc[[0]]['network_chkpt_dir']) hyperparam_results['cf_summary'] = True for key, value in hyperparam_results.iteritems(): if (type(value) is list or type(value) is np.ndarray or type(value) is tuple): hyperparam_results[key] = pd.Series( [value], dtype=object) # str(cf_results[key]) hyperparam_results_list.append( pd.DataFrame(hyperparam_results, index=[0])) hyperparam_results_list.append(cf_df) #Write results and hyperparams to hyperparameter_results_dataframe return hyperparam_results['euclidean_err_sum'] ################################ import dlib # http://blog.dlib.net/2017/12/a-global-optimization-algorithm-worth.html lowers = [ min(self.parameter_dict['hyper_learning_rate_args']), min(self.parameter_dict['hyper_rnn_size_args']), min(self.parameter_dict['hyper_reg_embedding_beta_args']), min(self.parameter_dict['hyper_reg_l2_beta_args']), min(self.parameter_dict['hyper_learning_rate_decay_args']), min(self.parameter_dict['hyper_learning_rate_min_args']), min(self.parameter_dict['hyper_padding_loss_logit_weight_args']), min(self.parameter_dict['hyper_padding_loss_mixture_weight_args']) ] uppers = [ max(self.parameter_dict['hyper_learning_rate_args']), max(self.parameter_dict['hyper_rnn_size_args']), max(self.parameter_dict['hyper_reg_embedding_beta_args']), max(self.parameter_dict['hyper_reg_l2_beta_args']), max(self.parameter_dict['hyper_learning_rate_decay_args']), max(self.parameter_dict['hyper_learning_rate_min_args']), max(self.parameter_dict['hyper_padding_loss_logit_weight_args']), max(self.parameter_dict['hyper_padding_loss_mixture_weight_args']) ] x, y = dlib.find_min_global( hyper_training_helper, lowers, uppers, [False, True, False, False, False, False, False, False ], # Is integer Variable self.parameter_dict['hyper_search_folds']) hyper_df = pd.concat(hyperparam_results_list, ignore_index=True) hyper_df.to_csv( os.path.join(self.parameter_dict['master_dir'], self.hyper_results_logfile)) summary_df = hyper_df[hyper_df['cf_summary'] == True] # Distance at which the classifier can make a sound judgement, lower is better if self.parameter_dict['evaluation_metric_type'] == 'perfect_distance': best_params = summary_df.sort_values( 'perfect_distance', ascending=True).iloc[0].to_dict() if self.parameter_dict[ 'evaluation_metric_type'] == 'validation_accuracy': # Higher better best_params = summary_df.sort_values( 'validation_accuracy', ascending=False).iloc[0].to_dict() if self.parameter_dict[ 'evaluation_metric_type'] == 'validation_loss': # Lower better best_params = summary_df.sort_values( 'validation_loss', ascending=True).iloc[0].to_dict() if self.parameter_dict[ 'evaluation_metric_type'] == 'euclidean_err_sum': # Lower better best_params = summary_df.sort_values( 'euclidean_err_sum', ascending=True).iloc[0].to_dict() # TODO eval_metric_type_reportwriter? return best_params
db = PcbDB.kicadPcbDataBase(kpfile) placer = PcbPlacer.GridBasedPlacer(db) placer.set_bb_ec(False) placer.set_rtree(True) placer.set_two_sided(True) placer.set_base_lam(lamtemp) placer.set_lamtemp_update(lam_temperature_update) placer.set_lambda_schedule(lamb) wl = placer.test_placer_flow() db.printKiCad("./cache") subprocess.call('mv ./cache ./' + fname + '_lambsched_' + str(lamb) + '_lamrate_' + str(lamtemp) + '_lam_temp_' + str(lam_temperature_update), shell=True) subprocess.call('mkdir ./cache', shell=True) subprocess.call('mkdir ./cache/img', shell=True) out = (str(lamb), str(lamtemp), str(lam_temperature_update), str(wl)) with open('./' + fname + '_log.txt', 'a+') as f: f.write(out[0] + ',' + out[1] + ',' + out[2] + ',' + out[3] + '\n') return wl x, wl = dlib.find_min_global( place, [lamrates[0], temperatures[0], lambda_schedules[0]], [lamrates[1], temperatures[1], lambda_schedules[1]], is_integer_variable, 100) print('params', x) print('wl', wl)
# # Alternatively, if you want to compile dlib yourself then go into the dlib # root folder and run: # python setup.py install # # Compiling dlib should work on any operating system so long as you have # CMake and boost-python installed. On Ubuntu, this can be done easily by # running the command: # sudo apt-get install libboost-python-dev cmake # import dlib from math import sin,cos,pi,exp,sqrt # This is a standard test function for these kinds of optimization problems. # It has a bunch of local minima, with the global minimum resulting in # holder_table()==-19.2085025679. def holder_table(x0,x1): return -abs(sin(x0)*cos(x1)*exp(abs(1-sqrt(x0*x0+x1*x1)/pi))) # Find the optimal inputs to holder_table(). The print statements that follow # show that find_min_global() finds the optimal settings to high precision. x,y = dlib.find_min_global(holder_table, [-10,-10], # Lower bound constraints on x0 and x1 respectively [10,10], # Upper bound constraints on x0 and x1 respectively 80) # The number of times find_min_global() will call holder_table() print("optimal inputs: {}".format(x)); print("optimal output: {}".format(y));
def test_on_holder_table(): x, y = find_min_global(holder_table, [-10, -10], [10, 10], 200) assert (y - -19.2085025679) < 1e-7
# Create an observer to obtain the beam sizes observer = SigmaObserver() # Create the optimization routine def parametric_tracking(kq1, kq2): manzoni_input.sequence[1].K1 = kq1 / _.m**2 manzoni_input.sequence[3].K1 = kq2 / _.m**2 manzoni_input.sequence[5].K1 = kq2 / _.m**2 track(beamline=manzoni_input, beam=beam, observer=observer) if np.isnan(observer.data[-1][1]) or np.isnan(observer.data[-1][3]): return 1000.0 return observer.data[-1][1]**2 + observer.data[-1][3] iters = [] v = [] for i in [5, 10, 25, 50, 75, 100, 125]: x, y = dlib.find_min_global( parametric_tracking, [0, -3.5], # Lower bound constraints [3.5, 0.0], # Upper bound constraints i) v.append(y) print(y) iters.append(i) plt.plot(iters, v, '*-') plt.show()
def test_on_holder_table(): x,y = find_min_global(holder_table, [-10,-10], [10,10], 200) assert (y - -19.2085025679) < 1e-7
def calculate_optimizer_metrics(problems, n_runs, plot_traces=False): """ Let the global optimizers rt_opt, scipy's differential_evolution, scipy's dual_annealing, and dlib's LIPO minimize a bunch of test functions and collect performance metrics. :param problems: [list<TestProblem instance>] List of test problems to be used :param n_runs: [int] How often each problem is solved by the different optimizers :param plot_traces: [bool] Whether to plot bacteria traces for the rt_opt :return: Performance metrics [dict] """ optimizer_results = { 'Run-and-Tumble': {}, 'Differential Evolution': {}, 'Dual Annealing': {}, 'LIPO': {} } if plot_traces: n_plots = len(problems) n_cols = int(np.ceil(np.sqrt(n_plots))) n_rows = int(np.ceil(n_plots / n_cols)) fig, axs = plt.subplots(n_rows, n_cols) n_total_steps = len(problems) * len(optimizer_results) * n_runs print('Collecting optimizer statistics...') with tqdm(total=n_total_steps) as pbar: for n, problem in enumerate(problems): name = problem.__class__.__name__ if problem.bounds.lower is not None: bounds_lower = problem.bounds.lower else: bounds_lower = np.repeat(-5, problem.ndims) if problem.bounds.upper is not None: bounds_upper = problem.bounds.upper else: bounds_upper = np.repeat(5, problem.ndims) # Run-and-tumble algorithm bounds = np.vstack((bounds_lower, bounds_upper)).T optimizer_results['Run-and-Tumble'][name] = { 'runtime': [], 'nfev': [], 'x': [], 'f': [] } for m in range(n_runs): start = time.time() ret = optimize(problem.f, bounds=bounds) end = time.time() runtime = end - start pbar.update(1) optimizer_results['Run-and-Tumble'][name]['runtime'].append( runtime) optimizer_results['Run-and-Tumble'][name]['nfev'].append( ret.nfev) optimizer_results['Run-and-Tumble'][name]['x'].append(ret.x) optimizer_results['Run-and-Tumble'][name]['f'].append(ret.fun) if plot_traces and m == 0: # Plot bacteria traces only once if problem.ndims != 2: raise NotImplementedError( 'Currently, plotting bacteria traces is ' + 'supported for 2D problems only.') # noinspection PyUnboundLocalVariable plot_row = n // n_cols # noinspection PyUnboundLocalVariable plot_col = n % n_cols X, Y, Z = gridmap2d( problem.f, (bounds_lower[0], bounds_upper[0], 100), (bounds_lower[1], bounds_upper[1], 100)) # noinspection PyUnboundLocalVariable cp = axs[plot_row, plot_col].contourf(X, Y, Z, levels=20) axs[plot_row, plot_col].set_xlim([bounds_lower[0], bounds_upper[0]]) axs[plot_row, plot_col].set_ylim([bounds_lower[1], bounds_upper[1]]) # noinspection PyUnboundLocalVariable fig.colorbar(cp, ax=axs[plot_row, plot_col]) for single_trace in ret.trace.transpose(1, 0, 2): axs[plot_row, plot_col].plot(single_trace[:, 0], single_trace[:, 1], 'o', c='white', ms=0.4) axs[plot_row, plot_col].set_xlabel('x') axs[plot_row, plot_col].set_ylabel('y') axs[plot_row, plot_col].set_title(f'Problem: {name}', fontsize=10) # Differential Evolution algorithm bounds = np.vstack((bounds_lower, bounds_upper)).T optimizer_results['Differential Evolution'][name] = { 'runtime': [], 'nfev': [], 'x': [], 'f': [] } for m in range(n_runs): start = time.time() ret = differential_evolution(problem.f, bounds) end = time.time() runtime = end - start pbar.update(1) optimizer_results['Differential Evolution'][name][ 'runtime'].append(runtime) optimizer_results['Differential Evolution'][name][ 'nfev'].append(ret.nfev) optimizer_results['Differential Evolution'][name]['x'].append( ret.x) optimizer_results['Differential Evolution'][name]['f'].append( ret.fun) # Dual Annealing algorithm bounds = np.vstack((bounds_lower, bounds_upper)).T optimizer_results['Dual Annealing'][name] = { 'runtime': [], 'nfev': [], 'x': [], 'f': [] } for m in range(n_runs): start = time.time() ret = dual_annealing(problem.f, bounds) end = time.time() runtime = end - start pbar.update(1) optimizer_results['Dual Annealing'][name]['runtime'].append( runtime) optimizer_results['Dual Annealing'][name]['nfev'].append( ret.nfev) optimizer_results['Dual Annealing'][name]['x'].append(ret.x) optimizer_results['Dual Annealing'][name]['f'].append(ret.fun) # LIPO algorithm nfev = 500 * problem.ndims lipoFun = LipoWrapper(problem.f) optimizer_results['LIPO'][name] = { 'runtime': [], 'nfev': [], 'x': [], 'f': [] } for m in range(n_runs): start = time.time() ret_lp = dlib.find_min_global(lipoFun.f, bounds_lower.tolist(), bounds_upper.tolist(), nfev) end = time.time() runtime = end - start pbar.update(1) optimizer_results['LIPO'][name]['runtime'].append(runtime) optimizer_results['LIPO'][name]['nfev'].append(nfev) optimizer_results['LIPO'][name]['x'].append(ret_lp[0]) optimizer_results['LIPO'][name]['f'].append(ret_lp[1]) if plot_traces: # Finalize bacteria traces plot fig.subplots_adjust(wspace=0.3, hspace=0.4) fig.suptitle('Run-and-tumble bacteria traces', fontsize=14) fig_manager = plt.get_current_fig_manager() fig_manager.window.showMaximized() fig.set_size_inches(25.6, 14.4) plt.savefig(join(SAVE_DIR, 'bacteria_traces.png'), bbox_inches='tight', dpi=150) plt.show() return optimizer_results
from math import sin, cos, exp, sqrt, pi import dlib from tuning.metaheuristic.function_utils import * def fitness(*args): # print(args) res = 0 for a in args: res += a**2 return res def holder_table(x0, x1): return -abs(sin(x0) * cos(x1) * exp(abs(1 - sqrt(x0 * x0 + x1 * x1) / pi))) x, y = dlib.find_min_global( fitness, [-10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10 ], # Lower bound constraints on x0 and x1 respectively [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10 ], # Upper bound constraints on x0 and x1 respectively 10) print("++++++++++++++++++++++++++++++=") print(y) print(x)
def minimizable(weights): results = [] t0 = time.time() for i, seed in zip(range(runs), seeds): task_queue.put((weights, seed)) while not len(results) == runs: results.append(result_queue.get()) if len(results) % 10 == 0: print(weights, sum(results), len(results), 'w/r', sum(results) / len(results)) print(weights, sum(results) / len(results), (time.time() - t0) / len(results)) return -sum(results) / len(results) starting_values = [0.02, 0.01, 0.05, 0.1, 0.01] bounds = [(0.00001, 0.9)] * len(starting_values) # Find the optimal inputs to holder_table(). The print statements that follow # show that find_min_global() finds the optimal settings to high precision. print( dlib.find_min_global( minimizable, [x[0] for x in bounds], # Lower bound constraints on x0 and x1 respectively [x[1] for x in bounds], # Upper bound constraints on x0 and x1 respectively 80)) # The number of times find_min_global() will call holder_table()
def icp_transform(comm, geometry_config, volume, make_surface, soma_coords, projection_ls, population_extents, rotate=None, populations=None, icp_iter=1000, opt_iter=100): """ Uses the iterative closest point (ICP) algorithm of the PCL library to transform soma coordinates onto a surface for a particular L value. http://pointclouds.org/documentation/tutorials/iterative_closest_point.php#iterative-closest-point """ import dlib, pcl rank = comm.rank size = comm.size if populations is None: populations = list(soma_coords.keys()) srf_resample = 25 layer_extents = geometry_config['Parametric Surface']['Layer Extents'] (extent_u, extent_v, extent_l) = get_total_extents(layer_extents) min_u, max_u = extent_u min_v, max_v = extent_v min_l, max_l = extent_l ## This parameter is used to expand the range of L and avoid ## situations where the endpoints of L end up outside of the range ## of the distance interpolant safety = 0.01 extent_u = (min_u - safety, max_u + safety) extent_v = (min_v - safety, max_v + safety) projection_ptclouds = [] for obs_l in projection_ls: srf = make_surface(extent_u, extent_v, obs_l, rotate=rotate) U, V = srf._resample_uv(srf_resample, srf_resample) meshpts = srf.ev(U, V) projection_ptcloud = pcl.PointCloud() projection_ptcloud.from_array(meshpts) projection_ptclouds.append(projection_ptcloud) soma_coords_dict = {} for pop in populations: coords_dict = soma_coords[pop] if rank == 0: logger.info('Computing point transformation for population %s...' % pop) count = 0 xyz_coords = [] gids = [] for gid, coords in viewitems(coords_dict): if gid % size == rank: soma_u, soma_v, soma_l = coords xyz_coords.append(volume(soma_u, soma_v, soma_l, rotate=rotate)) gids.append(gid) xyz_pts = np.vstack(xyz_coords) cloud_in = pcl.PointCloud() cloud_in.from_array(xyz_pts) icp = cloud_in.make_IterativeClosestPoint() all_est_xyz_coords = [] all_est_uvl_coords = [] all_interp_err = [] for (k, cloud_prj) in enumerate(projection_ls): k_est_xyz_coords = np.zeros((len(gids), 3)) k_est_uvl_coords = np.zeros((len(gids), 3)) interp_err = np.zeros((len(gids), )) converged, transf, estimate, fitness = icp.icp(cloud_in, cloud_prj, max_iter=icp_iter) logger.info('Transformation of population %s has converged: ' % (pop) + str(converged) + ' score: %f' % (fitness)) for i, gid in zip(list(range(0, estimate.size)), gids): est_xyz_coords = estimate[i] k_est_xyz_coords[i, :] = est_xyz_coords f_uvl_distance = make_uvl_distance(est_xyz_coords, rotate=rotate) uvl_coords, err = dlib.find_min_global(f_uvl_distance, limits[0], limits[1], opt_iter) k_est_uvl_coords[i, :] = uvl_coords interp_err[i, ] = err if rank == 0: logger.info( 'gid %i: u: %f v: %f l: %f' % (gid, uvl_coords[0], uvl_coords[1], uvl_coords[2])) all_est_xyz_coords.append(k_est_xyz_coords) all_est_uvl_coords.append(k_est_uvl_coords) all_interp_err.append(interp_err) coords_dict = {} for (i, gid) in enumerate(gids): coords_dict[gid] = { 'X Coordinate': np.asarray([col[i, 0] for col in all_est_xyz_coords], dtype='float32'), 'Y Coordinate': np.asarray([col[i, 1] for col in all_est_xyz_coords], dtype='float32'), 'Z Coordinate': np.asarray([col[i, 2] for col in all_est_xyz_coords], dtype='float32'), 'U Coordinate': np.asarray([col[i, 0] for col in all_est_uvl_coords], dtype='float32'), 'V Coordinate': np.asarray([col[i, 1] for col in all_est_uvl_coords], dtype='float32'), 'L Coordinate': np.asarray([col[i, 2] for col in all_est_uvl_coords], dtype='float32'), 'Interpolation Error': np.asarray([err[i] for err in all_interp_err], dtype='float32') } soma_coords_dict[pop] = coords_dict return soma_coords_dict
# lower range, upper range, and is/is not integer boolean, respectively params = OrderedDict([("tree_depth", (2, 5, True)), ("nu", (0.001, 0.2, False)), ("cascade_depth", (4, 25, True)), ("feature_pool_size", (100, 1000, True)), ("num_test_splits", (20, 300, True)), ("oversampling_amount", (1, 40, True)), ("oversampling_translation_jitter", (0.0, 0.3, False)), ("feature_pool_region_padding", (-0.2, 0.2, False)), ("lambda_param", (0.01, 0.99, False))]) # Use the ordered dictionary to easily extract the lower and upper boundaries of the hyperparamter range, # include whether or not the parameter is an integer or not lower = [v[0] for (k, v) in params.items()] upper = [v[1] for (k, v) in params.items()] isint = [v[2] for (k, v) in params.items()] # Utilize dlib to optimize our shape predictor hyperparameters (bestParams, bestLoss) = dlib.find_min_global(test_shape_predictor_params, bound1=lower, bound2=upper, is_integer_variable=isint, num_function_calls=config.MAX_FUNC_CALLS) # Display the optimal hyperparameters so we can reuse them in our training script print("[INFO] Optimal Parameters: {}".format(bestParams)) print("[INFO] Optimal Error: {}".format(bestLoss)) # delete the temporary model file os.remove(config.TEMP_MODEL_PATH)