def test_fixed_iteration_stopping_condition():
stopping_condition = FixedIterationsStoppingCondition(5)
loop_state_mock = mock.create_autospec(LoopState)
loop_state_mock.iteration = 0
assert(stopping_condition.should_stop(loop_state_mock) is False)
loop_state_mock = mock.create_autospec(LoopState)
loop_state_mock.iteration = 5
assert(stopping_condition.should_stop(loop_state_mock) is True)
def test_fixed_iteration_stopping_condition():
n_iterations = 5
stopping_condition = FixedIterationsStoppingCondition(n_iterations)
loop_state_mock = mock.create_autospec(LoopState)
loop_state_mock.iteration = 0
assert stopping_condition.should_stop(loop_state_mock) is False
loop_state_mock.iteration = n_iterations - 1
assert stopping_condition.should_stop(loop_state_mock) is False
loop_state_mock.iteration = n_iterations
assert stopping_condition.should_stop(loop_state_mock) is True
def test_loop():
n_iterations = 5
x_init = np.random.rand(5, 1)
y_init = np.random.rand(5, 1)
# Make GPy model
gpy_model = GPy.models.GPRegression(x_init, y_init)
model = GPyModelWrapper(gpy_model)
space = ParameterSpace([ContinuousParameter('x', 0, 1)])
acquisition = ExpectedImprovement(model)
# Make loop and collect points
bo = BayesianOptimizationLoop(model=model,
space=space,
acquisition=acquisition)
bo.run_loop(UserFunctionWrapper(f),
FixedIterationsStoppingCondition(n_iterations))
# Check we got the correct number of points
assert bo.loop_state.X.shape[0] == n_iterations + 5
# Check the obtained results
results = bo.get_results()
assert results.minimum_location.shape[0] == 1
assert results.best_found_value_per_iteration.shape[0] == n_iterations + 5
def test_loop():
n_iterations = 5
x_init = np.random.rand(5, 1)
y_init, y_constraint_init = f(x_init)
# Make GPy objective model
gpy_model = GPy.models.GPRegression(x_init, y_init)
model = GPyModelWrapper(gpy_model)
# Make GPy constraint model
gpy_constraint_model = GPy.models.GPRegression(x_init, y_init)
constraint_model = GPyModelWrapper(gpy_constraint_model)
space = ParameterSpace([ContinuousParameter("x", 0, 1)])
acquisition = ExpectedImprovement(model)
# Make loop and collect points
bo = UnknownConstraintBayesianOptimizationLoop(
model_objective=model, space=space, acquisition=acquisition, model_constraint=constraint_model
)
bo.run_loop(
UserFunctionWrapper(f, extra_output_names=["Y_constraint"]), FixedIterationsStoppingCondition(n_iterations)
)
# Check we got the correct number of points
assert bo.loop_state.X.shape[0] == n_iterations + 5
def run_optimisation(current_range, freq_range, power_range):
parameter_space = ParameterSpace([\
ContinuousParameter('current', current_range[0], current_range[1]), \
ContinuousParameter('freq', freq_range[0], freq_range[1]), \
ContinuousParameter('power', power_range[0], power_range[1])
])
def function(X):
current = X[:, 0]
freq = X[:, 1]
power = X[:, 2]
out = np.zeros((len(current), 1))
for g in range(len(current)):
'''
Set JPA Current, Frequency & Power
'''
out[g, 0] = -get_SNR(
plot=False)[-1] #Negative as want to maximise SNR
return out
num_data_points = 10
design = RandomDesign(parameter_space)
X = design.get_samples(num_data_points)
Y = function(X)
model_gpy = GPRegression(X, Y)
model_gpy.optimize()
model_emukit = GPyModelWrapper(model_gpy)
exp_imprv = ExpectedImprovement(model=model_emukit)
optimizer = GradientAcquisitionOptimizer(space=parameter_space)
point_calc = SequentialPointCalculator(exp_imprv, optimizer)
coords = []
min = []
bayesopt_loop = BayesianOptimizationLoop(model=model_emukit,
space=parameter_space,
acquisition=exp_imprv,
batch_size=1)
stopping_condition = FixedIterationsStoppingCondition(i_max=100)
bayesopt_loop.run_loop(q, stopping_condition)
coord_results = bayesopt_loop.get_results().minimum_location
min_value = bayesopt_loop.get_results().minimum_value
step_results = bayesopt_loop.get_results().best_found_value_per_iteration
print(coord_results)
print(min_value)
return coord_results, abs(min_value)
def fmin_fabolas(func, space: ParameterSpace, s_min: float, s_max: float, n_iters: int,
n_init: int = 20, marginalize_hypers: bool = True) -> LoopState:
"""
Simple interface for Fabolas which optimizes the hyperparameters of machine learning algorithms
by reasoning across training data set subsets. For further details see:
Fast Bayesian hyperparameter optimization on large datasets
A. Klein and S. Falkner and S. Bartels and P. Hennig and F. Hutter
Electronic Journal of Statistics (2017)
:param func: objective function which gets a hyperparameter configuration x and training dataset size s as input,
and return the validation error and the runtime after training x on s datapoints.
:param space: input space
:param s_min: minimum training dataset size (linear scale)
:param s_max: maximum training dataset size (linear scale)
:param n_iters: number of iterations
:param n_init: number of initial design points (needs to be smaller than num_iters)
:param marginalize_hypers: determines whether to use a MAP estimate or to marginalize over the GP hyperparameters
:return: LoopState with all evaluated data points
"""
initial_design = LatinDesign(space)
grid = initial_design.get_samples(n_init)
X_init = np.zeros([n_init, grid.shape[1] + 1])
Y_init = np.zeros([n_init, 1])
cost_init = np.zeros([n_init])
subsets = np.array([s_max // 2 ** i for i in range(2, 10)])[::-1]
idx = np.where(subsets < s_min)[0]
subsets[idx] = s_min
for it in range(n_init):
func_val, cost = func(x=grid[it], s=subsets[it % len(subsets)])
X_init[it] = np.concatenate((grid[it], np.array([subsets[it % len(subsets)]])))
Y_init[it] = func_val
cost_init[it] = cost
def wrapper(x):
y, c = func(x[0, :-1], np.exp(x[0, -1]))
return np.array([[y]]), np.array([[c]])
loop = FabolasLoop(X_init=X_init, Y_init=Y_init, cost_init=cost_init, space=space, s_min=s_min,
s_max=s_max, marginalize_hypers=marginalize_hypers)
loop.run_loop(user_function=UserFunctionWrapper(wrapper),
stopping_condition=FixedIterationsStoppingCondition(n_iters - n_init))
return loop.loop_state
def test_loop():
n_iterations = 5
x_init = np.random.rand(5, 1)
y_init = np.random.rand(5, 1)
# Make GPy model
gpy_model = GPy.models.GPRegression(x_init, y_init)
model = GPyModelWrapper(gpy_model)
space = ParameterSpace([ContinuousParameter('x', 0, 1)])
acquisition = ModelVariance(model)
# Make loop and collect points
exp_design = ExperimentalDesignLoop(space, model, acquisition)
exp_design.run_loop(UserFunctionWrapper(f), FixedIterationsStoppingCondition(n_iterations))
# Check we got the correct number of points
assert exp_design.loop_state.X.shape[0] == 10
model_gpy = GPRegression(X,Y)
model_gpy.optimize()
model_emukit = GPyModelWrapper(model_gpy)
# Set up Bayesian optimisation routine
exp_imprv = ExpectedImprovement(model = model_emukit)
optimizer = GradientAcquisitionOptimizer(space = parameter_space)
point_calc = SequentialPointCalculator(exp_imprv,optimizer)
# Bayesian optimisation routine
bayesopt_loop = BayesianOptimizationLoop(model = model_emukit,
space = parameter_space,
acquisition=exp_imprv,
batch_size=1)
stopping_condition = FixedIterationsStoppingCondition(i_max = no_BO_sims)
bayesopt_loop.run_loop(q, stopping_condition)
# Results of Bayesian optimisation
coord_results = bayesopt_loop.get_results().minimum_location
min_value = bayesopt_loop.get_results().minimum_value
step_results = bayesopt_loop.get_results().best_found_value_per_iteration
print(coord_results)
print(min_value)
# Save the pararmeters of the best resonator
results = [coord_results,min_value]
results_file = open('results.txt','w')
results_file.write(str(results))
results_file.close()
acquisition = LogExpectedImprovement(model)
elif args.acquisition_type == "entropy_search":
model = BOGP(X_init=X_init, Y_init=Y_init)
acquisition = EntropySearch(model, space=space)
# if with_gradients:
# acquisition_optimizer = AcquisitionOptimizer(space)
# else:
acquisition_optimizer = DirectOptimizer(space)
candidate_point_calculator = Sequential(acquisition, acquisition_optimizer)
bo = BayesianOptimizationLoop(model=model, space=space, X_init=X_init, Y_init=Y_init, acquisition=acquisition,
candidate_point_calculator=candidate_point_calculator)
bo.run_loop(user_function=obj, stopping_condition=FixedIterationsStoppingCondition(args.num_iterations))
curr_inc = np.inf
traj = []
regret = []
for yi in bo.loop_state.Y:
if curr_inc > yi:
curr_inc = yi[0]
traj.append(curr_inc)
regret.append(curr_inc - f_opt)
data = dict()
data["regret"] = regret
path = os.path.join(args.output_path, args.benchmark)
os.makedirs(path, exist_ok=True)
gpmodel.optimize()
model = GPyModelWrapper(gpmodel)
acquisition = ExpectedImprovement(model)
acquisition_optimizer = DirectOptimizer(space)
candidate_point_calculator = Sequential(acquisition, acquisition_optimizer)
bo = BayesianOptimizationLoop(model=model, space=space, X_init=X_init, Y_init=Y_init, acquisition=acquisition,
candidate_point_calculator=candidate_point_calculator)
overhead = []
st = time.time()
for i in range(args.num_iterations):
t = time.time()
bo.run_loop(user_function=obj, stopping_condition=FixedIterationsStoppingCondition(i + X_init.shape[0]))
overhead.append(time.time() - t)
print(i)
data = dict()
data["overhead"] = overhead
data["runtime"] = np.cumsum(overhead).tolist()
path = os.path.join(args.output_path, args.benchmark)
os.makedirs(path, exist_ok=True)
fname = os.path.join(path, "%s_run_%d.json" % (args.model_type, args.run_id))
fh = open(fname, "w")
json.dump(data, fh)
fh.close()
acquisition = LogExpectedImprovement(model)
# acquisition_optimizer = DirectOptimizer(space)
acquisition_optimizer = DifferentialEvolution(space)
candidate_point_calculator = Sequential(acquisition, acquisition_optimizer)
bo = BayesianOptimizationLoop(model=model, space=space, X_init=X_init, Y_init=Y_init, acquisition=acquisition,
candidate_point_calculator=candidate_point_calculator)
initial_results = []
for i in range(X_init.shape[0]):
initial_results.append(UserFunctionResult(X_init[i], Y_init[i], C_init[i]))
loop_state = LoopState(initial_results)
bo.loop_state = loop_state
bo.run_loop(user_function=obj,
stopping_condition=FixedIterationsStoppingCondition(args.num_iterations - args.n_init))
C = bo.loop_state.C
incumbents = []
curr_inc = None
curr_inc_val = np.inf
for yi, xi in zip(bo.loop_state.Y, bo.loop_state.X):
if curr_inc_val > yi[0]:
curr_inc = xi
curr_inc_val = yi[0]
incumbents.append(curr_inc)
elif args.method == "gp_ei_per_cost":
obj = UserFunctionWithCostWrapper(evaluate)
init_design = RandomDesign(space)