def test_sequential_with_all_parameters_fixed():
mock_acquisition = mock.create_autospec(Acquisition)
mock_acquisition.has_gradients = False
mock_acquisition.evaluate = lambda x: np.sum(x**2, axis=1)[:, None]
space = ParameterSpace([ContinuousParameter('x', 0, 1), ContinuousParameter('y', 0, 1)])
acquisition_optimizer = AcquisitionOptimizer(space)
loop_state_mock = mock.create_autospec(LoopState)
seq = SequentialPointCalculator(mock_acquisition, acquisition_optimizer)
next_points = seq.compute_next_points(loop_state_mock, context={'x': 0.25, 'y': 0.25})
assert np.array_equiv(next_points, np.array([0.25, 0.25]))
def test_sequential_evaluator():
# SequentialPointCalculator should just return result of the acquisition optimizer
mock_acquisition = mock.create_autospec(Acquisition)
mock_acquisition_optimizer = mock.create_autospec(AcquisitionOptimizer)
mock_acquisition_optimizer.optimize.return_value = (np.array([[0.]]), None)
loop_state_mock = mock.create_autospec(LoopState)
seq = SequentialPointCalculator(mock_acquisition, mock_acquisition_optimizer)
next_points = seq.compute_next_points(loop_state_mock)
# "SequentialPointCalculator" should only ever return 1 value
assert(len(next_points) == 1)
# Value should be result of acquisition optimization
assert(np.equal(np.array([[0.]]), next_points[0]))
def test_sequential_with_context():
mock_acquisition = mock.create_autospec(Acquisition)
mock_acquisition.has_gradients = False
mock_acquisition.evaluate = lambda x: np.sum(x**2, axis=1)[:, None]
space = ParameterSpace([ContinuousParameter('x', 0, 1), ContinuousParameter('y', 0, 1)])
acquisition_optimizer = AcquisitionOptimizer(space)
loop_state_mock = mock.create_autospec(LoopState)
seq = SequentialPointCalculator(mock_acquisition, acquisition_optimizer)
next_points = seq.compute_next_points(loop_state_mock, context={'x': 0.25})
# "SequentialPointCalculator" should only ever return 1 value
assert(len(next_points) == 1)
# Context value should be what we set
assert np.isclose(next_points[0, 0], 0.25)
def test_iteration_end_event():
space = ParameterSpace([ContinuousParameter('x', 0, 1)])
def user_function(x):
return x
x_test = np.linspace(0, 1)[:, None]
y_test = user_function(x_test)
x_init = np.linspace(0, 1, 5)[:, None]
y_init = user_function(x_init)
gpy_model = GPy.models.GPRegression(x_init, y_init)
model = GPyModelWrapper(gpy_model)
mse = []
def compute_mse(self, loop_state):
mse.append(np.mean(np.square(model.predict(x_test)[0] - y_test)))
loop_state = create_loop_state(x_init, y_init)
acquisition = ModelVariance(model)
acquisition_optimizer = AcquisitionOptimizer(space)
candidate_point_calculator = SequentialPointCalculator(
acquisition, acquisition_optimizer)
model_updater = FixedIntervalUpdater(model)
loop = OuterLoop(candidate_point_calculator, model_updater, loop_state)
loop.iteration_end_event.append(compute_mse)
loop.run_loop(user_function, 5)
assert len(mse) == 5
def __init__(self,
model: VanillaBayesianQuadrature,
acquisition: Acquisition = None,
model_updater: ModelUpdater = None):
"""
The loop for vanilla Bayesian Quadrature
:param model: the vanilla Bayesian quadrature method
:param acquisition: The acquisition function that is be used to collect new points.
default, IntegralVarianceReduction
:param model_updater: Defines how and when the quadrature model is updated if new data arrives.
Defaults to updating hyper-parameters every iteration.
"""
self.model = model
if acquisition is None:
acquisition = IntegralVarianceReduction(self.model)
if model_updater is None:
model_updater = FixedIntervalUpdater(self.model, 1)
space = ParameterSpace(self.model.integral_bounds.
convert_to_list_of_continuous_parameters())
acquisition_optimizer = AcquisitionOptimizer(space)
candidate_point_calculator = SequentialPointCalculator(
acquisition, acquisition_optimizer)
loop_state = create_loop_state(self.model.X, self.model.Y)
super().__init__(candidate_point_calculator, model_updater, loop_state)
def test_multi_source_sequential_with_source_context():
# Check that we can fix a non-information source parameter with context
mock_acquisition = mock.create_autospec(Acquisition)
mock_acquisition.has_gradients = False
mock_acquisition.evaluate = lambda x: np.sum(x**2, axis=1)[:, None]
space = ParameterSpace(
[ContinuousParameter("x", 0, 1), ContinuousParameter("y", 0, 1), InformationSourceParameter(2)]
)
acquisition_optimizer = GradientAcquisitionOptimizer(space)
multi_source_acquisition_optimizer = MultiSourceAcquisitionOptimizer(acquisition_optimizer, space)
loop_state_mock = mock.create_autospec(LoopState)
seq = SequentialPointCalculator(mock_acquisition, multi_source_acquisition_optimizer)
next_points = seq.compute_next_points(loop_state_mock, context={"source": 1.0})
# "SequentialPointCalculator" should only ever return 1 value
assert len(next_points) == 1
# Context value should be what we set
assert np.isclose(next_points[0, 1], 1.0)
def test_multi_source_sequential_with_source_context():
# Check that we can fix a non-information source parameter with context
mock_acquisition = mock.create_autospec(Acquisition)
mock_acquisition.has_gradients = False
mock_acquisition.evaluate = lambda x: np.sum(x**2, axis=1)[:, None]
space = ParameterSpace([ContinuousParameter('x', 0, 1),
ContinuousParameter('y', 0, 1),
InformationSourceParameter(2)])
acquisition_optimizer = AcquisitionOptimizer(space)
multi_source_acquisition_optimizer = MultiSourceAcquisitionOptimizer(acquisition_optimizer, space)
loop_state_mock = mock.create_autospec(LoopState)
seq = SequentialPointCalculator(mock_acquisition, multi_source_acquisition_optimizer)
next_points = seq.compute_next_points(loop_state_mock, context={'source': 1.0})
# "SequentialPointCalculator" should only ever return 1 value
assert(len(next_points) == 1)
# Context value should be what we set
assert np.isclose(next_points[0, 1], 1.)
def __init__(self, space: ParameterSpace,
X_init: np.ndarray, Y_init: np.ndarray, cost_init: np.ndarray,
s_min: float, s_max: float,
update_interval: int = 1,
num_eval_points: int = 2000,
marginalize_hypers: bool = True):
"""
Implements FAst Bayesian Optimization for LArge DataSets as described in:
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 space: input space where the optimization is carried out.
:param X_init: initial data points
:param Y_init: initial function values
:param cost_init: initial costs
:param s_min: smallest possible dataset size
:param s_max: highest possible dataset size
:param update_interval: number of iterations between optimization of model hyper-parameters. Defaults to 1.
:param num_eval_points: number of points to evaluate the acquisition function
:param marginalize_hypers: if true, marginalize over the GP hyperparameters
"""
l = space.parameters
l.extend([ContinuousParameter("s", s_min, s_max)])
extended_space = ParameterSpace(l)
model_objective = FabolasModel(X_init=X_init, Y_init=Y_init, s_min=s_min, s_max=s_max)
model_cost = FabolasModel(X_init=X_init, Y_init=cost_init[:, None], s_min=s_min, s_max=s_max)
if marginalize_hypers:
acquisition_generator = lambda model: ContinuousFidelityEntropySearch(model_objective, space=extended_space,
target_fidelity_index=len(
extended_space.parameters) - 1)
entropy_search = IntegratedHyperParameterAcquisition(model_objective, acquisition_generator)
else:
entropy_search = ContinuousFidelityEntropySearch(model_objective, space=extended_space,
target_fidelity_index=len(extended_space.parameters) - 1)
acquisition = acquisition_per_expected_cost(entropy_search, model_cost)
model_updater_objective = FixedIntervalUpdater(model_objective, update_interval)
model_updater_cost = FixedIntervalUpdater(model_cost, update_interval, lambda state: state.cost)
acquisition_optimizer = RandomSearchAcquisitionOptimizer(extended_space, num_eval_points=num_eval_points)
candidate_point_calculator = SequentialPointCalculator(acquisition, acquisition_optimizer)
loop_state = create_loop_state(model_objective.X, model_objective.Y, model_cost.Y)
super(CostSensitiveBayesianOptimizationLoop, self).__init__(candidate_point_calculator,
[model_updater_objective, model_updater_cost],
loop_state)
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)
# Set up random seeding of parameter space
num_data_points = no_random_seeds
design = RandomDesign(parameter_space)
X = design.get_samples(num_data_points)
Y = q(X)
# Set up emukit model
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