def _optimize(self, f, variables, X_init, Y_init, maxiter, maxeval, iter_callback): from GPyOpt.methods import BayesianOptimization from GPyOpt.core.task.objective import SingleObjective maxeval = get_maxeval_for_bo(maxeval, maxiter) ndim = len(variables) if len(Y_init) > 0: x_best = X_init[0] y_best = Y_init[0] iter_callback(x_best, y_best, X_init, Y_init) kernel = self.get_kernel(ndim) gpy_domain = self.get_domain(variables) Y_init = np.array(Y_init).reshape(len(Y_init), -1) X_init = np.array(X_init, dtype=float) bo = BayesianOptimization(f=f, domain=gpy_domain, model_type='GP', acquisition_type=self.acquisition_type, kernel=kernel, X=np.array(X_init), Y=np.array(Y_init), exact_feval=True, verbosity=True, ) bo.num_acquisitions = self.run_info.result.n_eval self.run_info.bo_obj = bo def f_in_gpyopt(X): Y = [] x_best = self.transform(self.run_info.result.x) y_best = self.sign * self.run_info.result.y for x in X: y = f(x) if y_best is None or y < y_best: x_best = x y_best = y Y.append(y) iter_callback(x=x_best, y=y_best, X_iter=X, Y_iter=Y) return np.array(Y).reshape(len(Y), -1) bo.f = bo._sign(f_in_gpyopt) bo.objective = SingleObjective( bo.f, bo.batch_size, bo.objective_name) bo.run_optimization(max_iter=maxeval-len(X_init), eps=0, verbosity=False) result = OptimizerResult.from_GPyOpt_OptimizerResult(bo) self.run_info.result.success = True self.run_info.status = result.status self.run_info.message = result.message return self.run_info.result
def optimize(self, f, variables, args=(), num_init=10, X_init=None, Y_init=None, linear_constrain=None, maxiter=100, maxeval=100, verbose=0, callback=None, report_file=None, eval_file=None, save_file=None): r""" Return best values of `variables` that minimizes/maximizes the function `f`. :param f: function to minimize/maximize. The usage must be the following: f(x, \*args), where x is list of values. :param variables: list of variables (instances of :class:`gadma.Variable` class) of the function. :param X_init: list of initial values. :param Y_init: value of function `f` on initial values from `X_init`. :param args: arguments of function `f`. :param maxiter: maximum number of genetic algorithm's generations. :param maxeval: maximum number of function evaluations. :param callback: callback to call after each generation. It will be called as callback(x, y), where x, y - best_solution of generation and its fitness. """ from GPyOpt.methods import BayesianOptimization if maxiter is None: maxiter = 100 # Create logging files if eval_file is not None: ensure_file_existence(eval_file) if verbose > 0 and report_file is not None: report_file = ensure_file_existence(report_file) if save_file is not None: ensure_file_existence(save_file) # Prepare function to use it. # Fix args and cache prepared_f = self.prepare_f_for_opt(f, args) # Wrap for automatic evaluation logging finally_wrapped_f = eval_wrapper(prepared_f, eval_file) f_in_opt = partial(self.evaluate, finally_wrapped_f) f_in_opt = fix_args(f_in_opt, (), linear_constrain) if callback is not None: callback = self.prepare_callback(callback) # Stuff for BO ndim = len(variables) if ndim == 0: x_best = [] y_best = f_in_opt([x_best]) return OptimizerResult(x=x_best, y=self.sign * y_best, success=True, status="0", message="Number of variables == 0", X=[x_best], Y=[y_best], n_eval=1, n_iter=1, X_out=[x_best], Y_out=[y_best]) kernel = self.get_kernel(ndim) gpy_domain = self.get_domain(variables) # Initial design X, Y = self.initial_design(finally_wrapped_f, variables, num_init, X_init, Y_init) Y = np.array(Y).reshape(len(Y), -1) bo = BayesianOptimization( f=f_in_opt, domain=gpy_domain, model_type='GP', acquisition_type=self.acquisition_type, kernel=kernel, ARD=self.ARD, X=np.array(X, dtype=object), Y=np.array(Y), exact_feval=True, verbosity=True, ) def union_callback(x, y): if verbose > 0: self.write_report(bo, report_file, x, y) if callback is not None: callback(x, y) f_in_opt = self._concatenate_f_and_callback(f_in_opt, union_callback) bo.f = bo._sign(f_in_opt) bo.objective = GPyOpt.core.task.objective.SingleObjective( bo.f, bo.batch_size, bo.objective_name) bo.run_optimization(max_iter=min(maxiter, maxeval) - len(X), eps=0, verbosity=False) result = OptimizerResult.from_GPyOpt_OptimizerResult(bo) return result