def maximize(
self,
runhistory: HistoryContainer,
num_points: int, # todo useless
**kwargs) -> Iterable[Configuration]:
"""Maximize acquisition function using ``_maximize``.
Parameters
----------
runhistory: ~litebo.utils.history_container.HistoryContainer
runhistory object
num_points: int
number of points to be sampled
**kwargs
passed to acquisition function
Returns
-------
Iterable[Configuration]
to be concrete: ~litebo.ei_optimization.ChallengerList
"""
def inverse_acquisition(x):
# shape of x = (d,)
return -self.acquisition_function(x,
convert=False)[0] # shape=(1,)
d = len(self.config_space.get_hyperparameters())
bound = (0.0, 1.0) # todo only on continuous dims (int, float) now
bounds = [bound] * d
acq_configs = []
# MC
x_tries = self.rng.uniform(bound[0], bound[1], size=(self.num_mc, d))
acq_tries = self.acquisition_function(x_tries, convert=False)
for i in range(x_tries.shape[0]):
# convert array to Configuration
config = Configuration(self.config_space, vector=x_tries[i])
config.origin = 'Random Search'
acq_configs.append((acq_tries[i], config))
# L-BFGS-B
x_seed = self.rng.uniform(low=bound[0],
high=bound[1],
size=(self.num_opt, d))
for i in range(x_seed.shape[0]):
x0 = x_seed[i].reshape(1, -1)
result = self.minimizer(inverse_acquisition,
x0=x0,
method='L-BFGS-B',
bounds=bounds)
if not result.success:
continue
# convert array to Configuration
config = Configuration(self.config_space, vector=result.x)
config.origin = 'Scipy'
acq_val = self.acquisition_function(result.x, convert=False) # [0]
acq_configs.append((acq_val, config))
# shuffle for random tie-break
self.rng.shuffle(acq_configs)
# sort according to acq value
acq_configs.sort(reverse=True, key=lambda x: x[0])
configs = [_[1] for _ in acq_configs]
challengers = ChallengerList(configs, self.config_space,
self.random_chooser)
self.random_chooser.next_smbo_iteration()
return challengers
def maximize(
self,
runhistory: HistoryContainer,
num_points: int, # todo useless
**kwargs) -> List[Tuple[float, Configuration]]:
# print('start optimize') # todo remove
# import time
# t0 = time.time()
acq_configs = []
# random points
random_points = self.rng.uniform(self.bound[0],
self.bound[1],
size=(self.num_random, self.dim))
acq_random = self.acquisition_function(random_points, convert=False)
for i in range(random_points.shape[0]):
# convert array to Configuration
config = Configuration(self.config_space, vector=random_points[i])
config.origin = 'Random Search'
acq_configs.append((acq_random[i], config))
# scipy points
initial_points = self.gen_initial_points(
num_restarts=self.num_restarts, raw_samples=self.raw_samples)
for start_idx in range(0, self.num_restarts, self.batch_limit):
end_idx = min(start_idx + self.batch_limit, self.num_restarts)
# optimize using random restart optimization
scipy_points = self.gen_batch_scipy_points(
initial_points[start_idx:end_idx])
if scipy_points is None:
continue
acq_scipy = self.acquisition_function(scipy_points, convert=False)
for i in range(scipy_points.shape[0]):
# convert array to Configuration
config = Configuration(self.config_space,
vector=scipy_points[i])
config.origin = 'Batch Scipy'
acq_configs.append((acq_scipy[i], config))
# shuffle for random tie-break
self.rng.shuffle(acq_configs)
# sort according to acq value
acq_configs.sort(reverse=True, key=lambda x: x[0])
configs = [_[1] for _ in acq_configs]
challengers = ChallengerList(configs, self.config_space,
self.random_chooser)
self.random_chooser.next_smbo_iteration()
# t1 = time.time() # todo remove
# print('==time total=%.2f' % (t1-t0,))
# for x1 in np.linspace(0, 1, 20):
# optimal_point = np.array([x1.item()] + [0.5] * (self.dim-1))
# print('optimal_point acq=', self.acquisition_function(optimal_point, convert=False))
# print('best point acq=', acq_configs[0])
# time.sleep(2)
return challengers
