def plot_gp(optimizer, x=None, y=None, set_xlim=(-2, 10)):
"""
Plot the Gaussian posterior and the utility function after one or more
optimization steps.
Taken from
https://github.com/fmfn/BayesianOptimization/blob/master/examples/visualization.ipynb
"""
fig = plt.figure(figsize=(10, 5))
steps = len(optimizer.space)
fig.suptitle(
'Gaussian Process and Utility Function After {} Steps'.format(steps),
fontdict={'size': 30}
)
gs = gridspec.GridSpec(2, 1, height_ratios=[3, 1])
axis = plt.subplot(gs[0])
acq = plt.subplot(gs[1])
x_obs = np.array([[res["params"]["x"]] for res in optimizer.res])
y_obs = np.array([res["target"] for res in optimizer.res])
if x is not None:
mu, sigma = posterior(optimizer, x_obs, y_obs, x)
else:
bounds = optimizer._space._bounds[0]
x0, x1 = bounds
x = np.linspace(x0, x1, 1000).reshape(-1, 1)
mu, sigma = posterior(optimizer, x_obs, y_obs, x)
if (x is not None) and (y is not None):
axis.plot(x, y, linewidth=3, label='Target')
axis.plot(x_obs.flatten(), y_obs, 'D', markersize=8,
label=u'Observations', color='r')
axis.plot(x, mu, '--', color='k', label='Prediction')
axis.fill(np.concatenate([x, x[::-1]]),
np.concatenate([mu - 1.9600 * sigma,
(mu + 1.9600 * sigma)[::-1]]),
alpha=.6, fc='c', ec='None', label='95% confidence interval')
#axis.set_xlim(set_xlim)
axis.set_ylim((None, None))
axis.set_ylabel('f(x)', fontdict={'size': 20})
axis.set_xlabel('x', fontdict={'size': 20})
utility_function = UtilityFunction(kind="ucb", kappa=5, xi=0)
utility = utility_function.utility(x, optimizer._gp, 0)
acq.plot(x, utility, label='Utility Function', color='purple')
acq.plot(x[np.argmax(utility)], np.max(utility), '*', markersize=15,
label=u'Next Best Guess', markerfacecolor='gold',
markeredgecolor='k', markeredgewidth=1)
acq.set_xlim(set_xlim)
acq.set_ylim((0, np.max(utility) + 0.5))
acq.set_ylabel('Utility', fontdict={'size': 20})
acq.set_xlabel('x', fontdict={'size': 20})
axis.legend(loc=2, bbox_to_anchor=(1.01, 1), borderaxespad=0.)
acq.legend(loc=2, bbox_to_anchor=(1.01, 1), borderaxespad=0.)
def plot_gp(optimizer, x, y):
fig = plt.figure(figsize=(16, 10))
steps = len(optimizer.space)
fig.suptitle(
'Gaussian Process and Utility Function After {} Steps'.format(steps),
fontdict={'size': 30})
gs = gridspec.GridSpec(2, 1, height_ratios=[3, 1])
axis = plt.subplot(gs[0])
acq = plt.subplot(gs[1])
x_obs = np.array([[res["params"]["x"]] for res in optimizer.res])
y_obs = np.array([res["target"] for res in optimizer.res])
mu, sigma = posterior(optimizer, x_obs, y_obs, x)
axis.plot(x, y, linewidth=3, label='Target')
axis.plot(x_obs.flatten(),
y_obs,
'D',
markersize=8,
label=u'Observations',
color='r')
axis.plot(x, mu, '--', color='k', label='Prediction')
axis.fill(np.concatenate([x, x[::-1]]),
np.concatenate(
[mu - 1.9600 * sigma, (mu + 1.9600 * sigma)[::-1]]),
alpha=.6,
fc='c',
ec='None',
label='95% confidence interval')
axis.set_xlim((-2, 10))
axis.set_ylim((None, None))
axis.set_ylabel('f(x)', fontdict={'size': 20})
axis.set_xlabel('x', fontdict={'size': 20})
utility_function = UtilityFunction(kind="ei", kappa=None, xi=0)
utility = utility_function.utility(x, optimizer._gp, 0)
acq.plot(x, utility, label='Utility Function', color='purple')
acq.plot(x[np.argmax(utility)],
np.max(utility),
'*',
markersize=15,
label=u'Next Best Guess',
markerfacecolor='gold',
markeredgecolor='k',
markeredgewidth=1)
acq.set_xlim((-2, 10))
acq.set_ylim((0, np.max(utility) + 0.5))
acq.set_ylabel('Utility', fontdict={'size': 20})
acq.set_xlabel('x', fontdict={'size': 20})
axis.legend(loc=2, bbox_to_anchor=(1.01, 1), borderaxespad=0.)
acq.legend(loc=2, bbox_to_anchor=(1.01, 1), borderaxespad=0.)
plt.show()
def plot_gp(optimizer, x):
fig = plt.figure()
steps = len(optimizer.space)
fig.suptitle('Gaussian Process after {} steps'.format(steps),
fontdict={'size': 30})
axis = fig.add_subplot(111)
#gs = gridspec.GridSpec(2, 1, height_ratios=[3, 1])
#axis = plt.subplot(gs[0])
#acq = plt.subplot(gs[1])
x_obs = numpy.array([[res["params"]["learning_rate"]]
for res in optimizer.res])
y_obs = numpy.array([res["target"] for res in optimizer.res])
mu, sigma = posterior(optimizer, x_obs, y_obs, x)
#axis.plot(x, y, linewidth=3, label='Target')
unc = 0.0033 # calculated for Leptonic ttH vs ttGG
axis.errorbar(x_obs.flatten(),
y_obs,
yerr=numpy.ones(len(y_obs)) * unc,
label='Observations',
color='r',
marker='o',
markersize=8,
ls="none")
axis.plot(x, mu, '--', color='k', label='Prediction')
axis.fill(numpy.concatenate([x, x[::-1]]),
numpy.concatenate(
[mu - 1.9600 * sigma, (mu + 1.9600 * sigma)[::-1]]),
alpha=.6,
fc='c',
ec='None',
label='95% confidence interval')
axis.set_xlim((-5, -1))
axis.set_ylim((0.7, 0.82))
axis.set_ylabel('AUC', fontdict={'size': 20})
axis.set_xlabel('Learning Rate', fontdict={'size': 20})
utility_function = UtilityFunction(kind="ucb", kappa=5, xi=0)
#utility_function = UtilityFunction(kind="ei", xi=float(args.xi))
utility = utility_function.utility(x, optimizer._gp, 0)
#acq.plot(x, utility, label='Utility Function', color='purple')
#acq.plot(x[numpy.argmax(utility)], numpy.max(utility), '*', markersize=15,
#label=u'Next Best Guess', markerfacecolor='gold', markeredgecolor='k', markeredgewidth=1)
#acq.set_xlim((-2, 10))
#acq.set_ylim((0, numpy.max(utility) + 0.5))
#acq.set_ylabel('Utility', fontdict={'size':20})
#acq.set_xlabel('x', fontdict={'size':20})
axis.legend(loc='upper left')
#acq.legend(loc=2, bbox_to_anchor=(1.01, 1), borderaxespad=0.)
plt.savefig('optimization_step_%d.pdf' % (steps), bbox_inches='tight')
plt.clf()
def __init__(self, hyperparam_space, early_stopper, ensembler,
working_folder):
super(BayesianOptimizer,
self).__init__(hyperparam_space, early_stopper, ensembler,
working_folder)
self._cur_config = self.get_default()
self.bo_params = {}
pbounds = {}
for key, value in self._hyperparam_space.items():
if isinstance(value, Categoric):
sorted_categories = sorted(value.categories)
pbounds[key] = [0, len(sorted_categories) - 1e-10]
self._hyperparam_space[key].categories = sorted_categories
self.bo_params[key] = float(
list(self._hyperparam_space[key].categories).index(
self._cur_config[key]))
elif isinstance(value, Numeric):
assert value.low <= value.high
pbounds[key] = [value.low, value.high]
self.bo_params[key] = self._cur_config[key]
else:
raise NotImplementedError
self.bayesian_optimizer = BayesianOptimization(
f=None,
pbounds=pbounds,
verbose=2,
random_state=random.randint(0, 1e5))
self.utility = UtilityFunction(kind="ucb", kappa=2.5, xi=0.0)
def maximize(self, n_iter, kappa, acq='ucb', xi=0.0):
if self.params_init_probe_json:
#Probe with all known good points
for p in self.init_points_to_probe:
self.MaximizeStep(p, is_target_point=True)
# Suggest-Evaluate-Register paradigm
utility = UtilityFunction(kind=acq, kappa=kappa, xi=xi)
n = 0
while n < n_iter:
#create point to probe
p_opt = self.optimizer.suggest(utility)
n += self.MaximizeStep(p_opt, is_target_point=False)
p_opt_max = self.optimizer.max
p_target_max = self.TransformParams(p_opt_max['params'])
# for each param var up and down and try with edges parameter
for key, values in self.params_typed_range.items():
#Has some dependency wiht other variables
if 'depends_on' in self.params_typed_range[key] and p_target_max[
self.params_typed_range[key]['depends_on']] == 0:
continue
new_target_point = copy.deepcopy(p_target_max)
for v in values['range']:
new_target_point[key] = v
self.MaximizeStep(new_target_point, is_target_point=True)
return self.TransformParams(
self.optimizer.max['params']), self.optimizer.max['target']
def optimize():
"""
1. Basic 사용법
"""
# Parameter 들의 범위를 지정해줌
pbounds = {"x": (2, 4), "z": (0, 1), "y": (-3, 3)}
discrete = ["y"]
discrete_indices = get_discrete_idx(pbounds, discrete)
optimizer = BayesianOptimization(
f=black_box_function, # Maximize 하고자 하는 함수
pbounds=pbounds,
verbose=
2, # verbose = 1 prints only when a maximum is observed, verbose = 0 is silent
random_state=1, # Optional, BO 에서 randomness 통제하기 위해 seed 입력 가능
discrete=discrete_indices,
)
# init_points : 초기의 random exploration 개수
# n_iter : 이후에 진행할 BO step 개수
optimizer.maximize(init_points=2, n_iter=3)
"""
2. 'maximize' 함수는 'Suggest-Evaluate(Probe)-Register' 반복하는 loop 의 wrapper
"""
optimizer = BayesianOptimization(f=None,
pbounds={
"x": (-2, 2),
"y": (-3, 3)
},
verbose=2,
random_state=1)
# Exploration strategy. UCB (Upper Confidence Bound), EI (Expected Improvement) 등
utility = UtilityFunction(kind="ucb", kappa=2.5, xi=0.0)
# 1) Suggest
next_point_to_probe = optimizer.suggest(utility)
# 2) Evaluate
target = black_box_function(**next_point_to_probe)
# 3) Register
optimizer.register(params=next_point_to_probe, target=target)
"""
3. 추가로 가능한 것들
"""
# (일부) Parameter 의 범위 변경
optimizer.set_bounds(new_bounds={"x": (-2, 3)})
# Evaluate 할 특정 point 지정해주기
optimizer.probe(
params={
"x": 0.5,
"y": 0.7
},
lazy=True, # maximize 함수를 call 하는 시점에 evaluate 하겠다는 뜻
)
optimizer.maximize(init_points=0, n_iter=0)
# Gaussian Process regressor 의 parameter 변경
optimizer.set_gp_params(normalize_y=True)
def train_prominent():
# prominence
def black_box_function(weight_pos: float):
preds_dict = process_dataset(train,
cutoff=96.703,
scorer=1,
weight_pos=weight_pos)
accuracy = evaluate_prominence(preds_dict)
return accuracy
pbounds = {"weight_pos": [0, 1]}
optimizer = BayesianOptimization(f=black_box_function,
pbounds=pbounds,
verbose=2,
random_state=4)
utility = UtilityFunction(kind="ucb", kappa=1.96, xi=0.01)
# TRAINING LOOP
for i in range(25):
next_point = optimizer.suggest(utility)
target = black_box_function(weight_pos=next_point["weight_pos"])
try:
optimizer.register(params=next_point, target=target)
except:
pass
print(f"TARGET: {target} \n")
print(f'Weight_pos: {next_point["weight_pos"]}')
plot_results(optimizer)
def __init__(self,
reference_env,
randomized_env,
seed,
**kwargs):
self.reference_env = reference_env
self.randomized_env = randomized_env
self.seed = seed
self.statedifference_rewarder = StateDifferenceRewarder(weights=-1)
self.nparams = randomized_env.randomization_space.shape[0]
self.nenvs = randomized_env.nenvs
pbounds = {}
for i in range(self.nparams):
pbounds[str(i)] = (0, 1)
self.bayesianoptimizer = BayesianOptimization(
f=None,
pbounds=pbounds,
verbose=2,
random_state=seed,
)
self.utility = UtilityFunction(kind="ucb", kappa=2.5, xi=0.0)
self.registered_points = {}
self.agent_timesteps = 0
def compute_POIs(self):
# reset map
self.POIs = {"POIs": []}
# print("compute")
pbounds = {
'x': (self.x_low, self.x_up),
'y': (self.y_low, self.y_high)
}
# pbounds = {'x': (0, dim_x), 'y': (0, dim_y)}
num_suggested_points = self.num_of_points
samples = [({
'x': s['x'],
'y': s['y']
}, s['sample_value']) for s in self.json_dict_samples['sample_values']]
rospy.loginfo(samples)
utility = UtilityFunction(kind="ucb", kappa=10, xi=0.0)
suggested_points = suggest_points(num_suggested_points, utility,
pbounds, samples)
for i, point in enumerate(suggested_points):
# test occupency grid
#occupency_val = self.map.get_cell_val(point['x'], point['y'])
occupency_val = -888
if occupency_val < 0.1:
self.POIs['POIs'].append({
"x": point['x'],
"y": point['y'],
# "z": 0,
"poi_id": i,
"poi_reward": point['reward']
})
print('computed POIs are: ')
print(self.POIs)
def __init__(self,
# Maximizes target function
target_function,
parameters: dict,
alpha: float =1e-5,
n_restarts: int = 20,
acquisition: str='ei',
logger: Logger=NullLogger(),
):
"""Set op BO class, set up utility function (acqusition function) and gaussian process.
:param float alpha: Handles how much noise the GP can deal with
:param int n_restarts: Higher => more expensive, but more accurate
"""
super().__init__(target_function, parameters, logger)
self.optimizer = BayesianOptimization(
f=None,
pbounds=parameters,
verbose=0,
)
self.optimizer.set_gp_params(alpha=alpha, n_restarts_optimizer=n_restarts)
self.utility = UtilityFunction(kind=acquisition, kappa=2.5, xi=0.2)
self.logger(f"Created Bayesian Optimizer with alpha = {alpha} and {n_restarts} restarts for each optimization. Acquisition function is {acquisition}.")
def generate_new_points(input_points, opt_space, max_points, num_points):
# pbounds={'x': (-2, 2), 'y': (-3, 3)}
if len(input_points) > max_points:
return []
num_points = min(num_points, max_points - len(input_points))
utility = UtilityFunction(kind="ucb", kappa=2.5, xi=0.0)
optimizer = BayesianOptimization(f=None,
pbounds=opt_space,
verbose=2,
random_state=1)
unfinished_points = []
for input_point in input_points:
point, loss = input_point
if loss:
optimizer.register(point, loss)
else:
unfinished_points.append(point)
new_points = []
for _ in range(num_points):
x = optimizer.suggest(utility)
# TODO: check duplication
if x in unfinished_points:
continue
new_points.append(x)
# recommendation = optimizer.provide_recommendation()
return new_points
def train_fuzzy():
def black_box_function(cutoff: int, scorer):
preds_dict = process_dataset(train, cutoff=cutoff, scorer=scorer)
accuracy, diagnosis_dict = evaluate_fuzzy_matching(preds_dict)
return accuracy
pbounds = {"cutoff": [0, 100], "scorer": [0, len(FUZZUP_SCORERS) - 1]}
optimizer = BayesianOptimization(f=black_box_function,
pbounds=pbounds,
verbose=2,
random_state=4)
utility = UtilityFunction(kind="ucb", kappa=1.96, xi=0.01)
# TRAINING LOOP
for i in range(25):
next_point = optimizer.suggest(utility)
next_point["scorer"] = int(next_point["scorer"])
target = black_box_function(cutoff=next_point["cutoff"],
scorer=next_point["scorer"])
try:
optimizer.register(params=next_point, target=target)
except:
pass
print(f"TARGET: {target} \n")
print(
f'cutoff: {next_point["cutoff"]} \n scorer: {FUZZUP_SCORERS[next_point["scorer"]]} '
)
plot_results(optimizer)
def plot_gp(optimizer, x, y):
steps = len(optimizer.space)
x_obs = np.array([[res["params"]["x"]] for res in optimizer.res])
y_obs = np.array([res["target"] for res in optimizer.res])
mu, sigma = posterior(optimizer, x_obs, y_obs, x)
fig, axes = plt.subplots(2, 1, figsize=(9, 7))
ax = axes[0]
ax.plot(x, y, linewidth=3, label='Target')
ax.plot(x_obs.flatten(), y_obs, 'd', label=u'Observations', color='r')
ax.plot(x, mu, '--', color='k', label='Prediction')
ax.fill(np.concatenate([x, x[::-1]]),
np.concatenate([mu - 1.9600 * sigma, (mu + 1.9600 * sigma)[::-1]]),
alpha=.6,
fc='c',
ec='None',
label='95% confidence interval')
ax.set_ylabel('f(x)')
ax.set_xlabel('x')
ax.set_title(f'Gaussian Process and Utility Function After {steps} Steps')
ax.grid()
ax.legend(bbox_to_anchor=(1, 0.5))
utility_function = UtilityFunction(kind="ucb", kappa=5, xi=0)
utility = utility_function.utility(x, optimizer._gp, 0)
ax = axes[1]
ax.plot(x, utility, label='Utility function', color='purple')
ax.plot(x[np.argmax(utility)],
np.max(utility),
'*',
markersize=15,
label=u'Next best guess',
markerfacecolor='gold',
markeredgecolor='k',
markeredgewidth=1)
ax.set_ylim((0, np.max(utility) + 0.5))
ax.set_ylabel('Utility')
ax.set_xlabel('x')
ax.grid()
ax.legend(bbox_to_anchor=(1, 0.5))
return fig
def bo(self, opt_u_index=(1,1), u_range=(0,10)):
data = pd.read_csv(self.input, header=None, delimiter="\s",engine ='python')
num_rows, d = data.shape
num_variables = sum(opt_u_index)
variables_string = ascii_lowercase[:num_variables]
pbounds = {}
if num_variables == 1:
pbounds[variables_string[0]] = u_range
elif num_variables >= 2:
for variable in variables_string:
pbounds[variable] = u_range
utility = UtilityFunction(kind="ucb", kappa=self.kappa, xi=0.0)
optimizer = BayesianOptimization(
f=None,
pbounds=pbounds,
verbose=2,
random_state=1,
)
for i in range(num_rows):
values = list()
for j in range(len(opt_u_index)):
if opt_u_index[j]:
values.append(data.iloc[i][j])
params = {}
for (value, variable) in zip(values, variables_string):
params[variable] = value
target = self.loss(self.gap, list(data.iloc[i])[-2],list(data.iloc[i])[-1],self.a1,self.a2)
optimizer.register(
params=params,
target=target,
)
next_point_to_probe = optimizer.suggest(utility)
points = list(next_point_to_probe.values())
# if num_variables == 1:
# if opt_u_index[0] == 1 and opt_u_index[1] == 0:
# points.append(0)
# elif opt_u_index[0] == 0 and opt_u_index[1] == 1:
# points.insert(0,0)
points = [ round(elem,5) for elem in points]
U = [str(x) for x in points]
with open('input.json', 'r') as f:
data = json.load(f)
elements = list(data["pbe"]["ldau_luj"].keys())
for i in range(len(opt_u_index)):
if opt_u_index[i]:
try:
data["pbe"]["ldau_luj"][elements[i]]["U"] = round(float(U[i]),4)
except:
data["pbe"]["ldau_luj"][elements[i]]["U"] = round(float(U[i-1]),4)
f.close()
with open('input.json', 'w') as f:
json.dump(data,f,indent=4)
f.close()
return target
def test_suggest_at_random():
util = UtilityFunction(kind="ucb", kappa=5, xi=0)
optimizer = BayesianOptimization(target_func, PBOUNDS, PTYPES, random_state=1)
for _ in range(50):
sample = optimizer.space.params_to_array(optimizer.suggest(util))
assert len(sample) == optimizer.space.dim
assert all(sample >= optimizer.space.bounds[:, 0])
assert all(sample <= optimizer.space.bounds[:, 1])
def __init__(self, f, acquisition, x0, sigma, kappa=2.576, xi=0.0, **opts):
self.f = f
self.optimizer = BayesianOptimization_(
f=f,
pbounds=opts['bounds'],
random_state=1,
)
self.util = UtilityFunction(kind=acquisition, kappa=kappa, xi=xi)
opts['bounds'] = self.optimizer._space._bounds.T.tolist()
self.es = cma.CMAEvolutionStrategy(x0, sigma, opts)
def main():
pbounds = {
"batch_size_16": (0, 1),
"batch_size_32": (0, 1),
"batch_size_64": (0, 1),
"batch_size_128": (0, 1),
"batch_size_256": (0, 1),
"learning_rate": (0.1, 2.0),
}
discrete = []
# TODO: support multiple categorical parameters
# Parameter type 과 가능한 값들을 입력으로 받아서 직접 generate
categorical = [
"batch_size_16",
"batch_size_32",
"batch_size_64",
"batch_size_128",
"batch_size_256",
]
discrete_indices = get_idx(pbounds, discrete)
categorical_indices = get_idx(pbounds, categorical)
optimizer = BayesianOptimization(
strategy=FLAGS.strategy,
f=train,
pbounds=pbounds,
verbose=
2, # verbose = 1 prints only when a maximum is observed, verbose = 0 is silent
random_state=1, # Optional, BO 에서 randomness 통제하기 위해 seed 입력 가능
discrete=discrete_indices,
categorical=categorical_indices,
)
# TODO: points trained with init_points are not discretized as of now.
# Explicitly probing initial points with discrete values
# optimizer.probe(params={"batch_size": 20, "learning_rate": 1.0}, lazy=True)
# optimizer.probe(params={"batch_size": 20, "learning_rate": 0.1}, lazy=True)
optimizer.probe(
params={
"batch_size_16": 0,
"batch_size_32": 1,
"batch_size_64": 0,
"batch_size_128": 0,
"batch_size_256": 0,
"learning_rate": 0.001,
},
lazy=False,
)
utility = UtilityFunction(kind="ucb", kappa=2.5, xi=0.0)
next_point_to_probe = optimizer.suggest(utility)
print("Next point to probe is:", next_point_to_probe)
def test_suggest_with_one_observation():
util = UtilityFunction(kind="ucb", kappa=5, xi=0)
optimizer = BayesianOptimization(target_func, PBOUNDS, PTYPES, random_state=1)
optimizer.register(params={"p1": 1, "p2": 2}, target=3)
for _ in range(5):
sample = optimizer.space.params_to_array(optimizer.suggest(util))
assert len(sample) == optimizer.space.dim
assert all(sample >= optimizer.space.bounds[:, 0])
assert all(sample <= optimizer.space.bounds[:, 1])
def _update_ax_utility(self):
self.ax_utility.clear()
# 2.576 is the default kappa value in bayes_opt source (for whatever
# reason). The xi parameter is ignored when using UCB utility.
self.utility_function = UtilityFunction(kind='ucb', kappa=2.576, xi=0)
# Last argument (y_max) ignored when using UCB utility.
utility = self.utility_function.utility(self.design_matrix,
self.optimizer._gp, 0)
utility = np.resize(utility, (self.N, self.N))
self.ax_utility.plot_surface(self.X, self.Y, utility, alpha=0.8)
ind = utility.argmax()
i, j = np.unravel_index(ind, utility.shape)
self.ax_utility.scatter(self.X_[i],
self.Y_[j],
np.amax(utility),
s=50,
c='r')
self.ax_utility.view_init(self.phi, self.theta)
self.next_point = [self.X_[i], self.Y_[i], np.amax(utility)]
def generate_batch(self, batch_size=BATCH, verbose=0, random_state=None, utility_kind="ucb", kappa=2.5, xi=0.0,
sampler='greedy', **kwargs):
'''
Creates optimizer, registers all previous data, and generates a proposed batch.
Arguments
----------
batch_size: integer number of points to suggest per batch
verbose: 0 (quiet), 1 (printing only maxima as found), 2 (print every registered point)
random_state: integer for random number generator
utility_kind: Utility function to use ('ucb', 'ei', 'poi')
kappa: float, necessary for 'ucb' utility function
xi: float, translation of gaussian function
**kwargs: dictionary passed to suggestion function. See bayes_opt.parallel_opt.disc_acq_max() for options
Returns
----------
batch: list of dictionaries containing parameters for each variable in the experiment
'''
batch = []
# Update kwargs
if sampler == 'greedy' or sampler == 'capitalist':
kwargs['complements'] = bool(self.complements)
# Initialize optimizer and utility function
fname = os.path.join(self.directory_path, 'optimizer.pickle')
if os.path.isfile(fname):
with open(fname, 'rb') as handle:
data = pickle.load(handle)
dbo = data['model']
running_points = self.get_running_points()
for point in running_points:
dbo.partner_register(params=point, clear=False)
self.model_uuid = data['uuid']
else:
dbo = self.generate_model(verbose=verbose, random_state=random_state)
self.model_uuid = self.get_saved_model_uuid()
utility = UtilityFunction(kind=utility_kind, kappa=kappa, xi=xi)
# Generate batch of suggestions
dbo.reset_rng()
batch = dbo.suggest(utility, sampler=sampler, n_acqs=batch_size, fit_gp=False, **kwargs)
# Clear and re-register running data to partner space in optimizer (can be adjusted in capitalist)
running_points = self.get_running_points()
for idx, point in enumerate(running_points):
if idx == 0:
dbo.partner_register(params=point, clear=True)
else:
dbo.partner_register(params=point, clear=False)
for point in batch:
self.complement_mapping(point)
return batch
def __init__(self, starting_point=None):
self.hyperopt = BayesianOptimization(
f=None,
pbounds={'m': (0, 100)},
verbose=2,
random_state=1,
)
if starting_point:
self.hyperopt.probe({'m': starting_point})
# Prefer exploitation. We should experiment with some exploration tho
self.util_func = UtilityFunction(kind="ucb", kappa=2.5, xi=0.0)
self._next_probe = None
def __init__(self, n_init, n_iter, utility=None):
# These parameters are initialized by the runner
# updated by setExperiment()
self.experiment_id = None
self.parameters_by_name = None
self.optimizer = None
self.previous_trials = []
self.utility = utility if utility != None else UtilityFunction(
kind="ucb", kappa=2.5, xi=0.0)
self.n_init = n_init
self.n_iter = n_iter
self.n_initted = 0
self.n_itered = 0
self.previous_trials_loaded = False
def __init__(self, optimization_problem: OptimizationProblem,
optimizer_config: SimpleBayesianOptimizerConfig):
assert len(optimization_problem.objectives
) == 1, "This is a single-objective optimizer."
OptimizerInterface.__init__(self, optimization_problem)
self.minimize = self.optimization_problem.objectives[0].minimize
self._ordered_parameter_names = [
dimension.name for dimension in
self.optimization_problem.parameter_space.dimensions
if dimension.name not in OptimizationProblem.META_DIMENSION_NAMES
]
self._ordered_feature_names = [
dimension.name
for dimension in self.optimization_problem.feature_space.dimensions
if dimension.name not in OptimizationProblem.META_DIMENSION_NAMES
]
assert SimpleBayesianOptimizerConfig.contains(optimizer_config)
self._optimizer_config = optimizer_config
self._utility_function = UtilityFunction(
kind=self._optimizer_config.utility_function,
kappa=self._optimizer_config.kappa,
xi=self._optimizer_config.xi)
self._full_parameter_space_bounds = self._format_search_space(
self.optimization_problem.parameter_space)
self._full_feature_space_bounds = self._format_search_space(
self.optimization_problem.feature_space)
self._optimizer = BayesianOptimization(
f=None,
pbounds=self.
_full_feature_space_bounds # Both parameters and context are used for regression.
)
# Optionally the optimizer can focus on a subspace of the parameter search space.
#
self.focused = False
self._focused_parameter_space = None
self._focused_parameter_space_bounds = None
# HISTORY
self._registered_param_combos = []
self._observations = []
self._models = []
def maximize(optimizer, pbounds, n_probe, n_points, random, do_plot=False):
optimizer.set_bounds(new_bounds=pbounds)
utility_function = UtilityFunction(kind="ucb", kappa=5, xi=0)
for i in range(n_points):
if i % 3 == 0 or random:
print("Probing a RANDOM point")
optimizer.maximize(init_points=1,
n_iter=0,
alpha=float(args.alpha))
else:
next_point = optimizer.suggest(utility_function)
print("Probing this point next: ", next_point)
target = auc(**next_point)
print("Found AUC to be: ", target)
optimizer.register(params=next_point, target=target)
if do_plot:
plot_gp(optimizer, x)
def setup_gaussian(param_ranges, kappa, xi):
pbounds = {}
for param in param_ranges.keys():
pbounds[param] = (0, 1)
print(pbounds)
optimizer = BayesianOptimization(
f=None,
pbounds=pbounds,
verbose=
0, # verbose = 1 prints only when a maximum is observed, verbose = 0 is silent
random_state=None)
utility = UtilityFunction(kind="ucb", kappa=kappa, xi=xi)
return optimizer, utility
def __init__(self, space, max_num_steps):
super(self.__class__, self).__init__(space, max_num_steps)
# For UCB acquisition function, smaller kappa prefers exploitation (e.g., 1.0), larger kappa prefers
# exploration (e.g., 10.0). For EI or PI acquisition function, smaller xi prefers exploitation (e.g., 0.0),
# larger xi prefers exploration (e.g., 0.1).
# Check https://github.com/fmfn/BayesianOptimization/blob/master/examples/exploitation_vs_exploration.ipynb.
# self._utility = UtilityFunction(kind='ucb', kappa=2.5, xi=0.0)
self._utility = UtilityFunction(kind='ei', kappa=0.0, xi=0.1)
self._opt = BayesianOptimization(
f=None,
pbounds=self._space,
)
self._next_point = None
self._logger.info(
"Bayesian Search is enabled, space {}, max_num_steps {}.".format(
space, max_num_steps))
def __init__(self,
n_init,
n_iter,
alpha=1e-6,
kappa=2.5,
utility=None,
budget=None,
converge_thres=None,
converge_steps=None):
# These parameters are initialized by the runner
# updated by setExperiment()
self.optimizer = None
if alpha is None:
self.alpha = 1e-6
else:
self.alpha = alpha
if kappa is None:
self.kappa = 2.5
else:
self.kappa = kappa
self.utility = utility if utility != None else UtilityFunction(
kind="ucb", kappa=self.kappa, xi=0.0)
self.experiment_id = None
self.parameters_by_name = None
self.n_init = n_init
self.n_iter = n_iter
self.budget = budget
self.converge_thres = converge_thres
self.converge_steps = converge_steps
self.converge_steps_count = 0
self.stop_flag = False
self.using_budget_flag = False # check whether the current trial use budget
self.using_converge_flag = False # check whether the current tirl need to consider in convergence
self.previous_trials = []
self.n_initted = 0
self.n_itered = 0
self.previous_trials_loaded = False
self.all_trials = []
self.visited_config = {
} # store a string of config, and value is the index in previous_trials
def main():
bounds = {'alpha':(0.3,0.9),'temperature':(3,15)}
optimizer = BayesianOptimization(
f = KD_train,
pbounds = bounds,
verbose = 2,
random_state = 0)
utility = UtilityFunction(kind = 'ei', kappa= 1,xi=0.0)
for _ in range(5):
next_p = optimizer.suggest(utility)
print('suggest for next:',next_p)
result = KD_train(**next_p)
optimizer.register(params = next_p,target = result)
for i,res in enumerate(optimizer.res):
print("ite {} \t {}".format(i,res))
logger = JSONLogger(path = './BO_logs.json')
optimizer.subscribe(Events.OPTIMIZATION_STEP, logger)
def optimize():
pbounds = {"x": (-10, 10)}
discrete = ["x"]
optimizer = BayesianOptimization(
f=f, # Maximize 하고자 하는 함수
pbounds=pbounds,
verbose=
2, # verbose = 1 prints only when a maximum is observed, verbose = 0 is silent
random_state=1, # Optional, BO 에서 randomness 통제하기 위해 seed 입력 가능
strategy="proposed",
discrete=discrete,
)
optimizer.maximize(init_points=1, n_iter=10)
utility = UtilityFunction(kind="ucb", kappa=2.5, xi=0.0)
next_to_probe = optimizer.suggest(utility)
print(f"Next Point to Probe = {next_to_probe}")
plot_bo(f, optimizer, pbounds)
def bayes_opt_xgb(
log,
dmatrix,
opt_fun,
opt_rounds,
init_rounds,
params_ranges,
max_estimators
):
""" Function to perform bayesian optimization of model hyperparameters for xgboost models """
# Instatiate BO object, utilty function, and log
opt_xgb = BayesianOptimization(opt_fun, params_ranges)
utility = UtilityFunction(kind="ei", kappa=2.5, xi=0.0)
log_params = {}
# Manually loop through opimization process (wanted better logs than the built-in funtion)
for _ in range(opt_rounds):
# Start selecting non-random points after 10 rounds
if _ < init_rounds:
np.random.seed()
next_point = {key: np.random.uniform(value[0],value[1]) for key, value in params_ranges.items()}
else:
next_point = opt_xgb.suggest(utility)
# Fit xgb model with selected hyperparams
opt_params, fit_props = opt_fun(
dmatrix = dmatrix,
max_estimators = max_estimators,
**next_point
)
target = fit_props['val_score']
# Register results to BO object
opt_xgb.register(params=next_point, target=target)
# Print to keep user updated and save to log
log.info(str(_) + str(fit_props) + str(opt_params))
log_params.update({target:{'params':opt_params,'fit_props':fit_props}})
return log_params
