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
