def update(self, batch, batch_index):
"""Update the GP regression model of the target node with a new batch.
Parameters
----------
batch : dict
dict with `self.outputs` as keys and the corresponding outputs for the batch
as values
batch_index : int
Index of batch.
"""
# Update the inference state
self.state['n_batches'] += 1
self.state['n_sim'] += self.batch_size * self.n_training_data
# Predict log-ratio
likelihood = self._generate_likelihood(
self._get_parameter_values(batch))
X, y = self._generate_training_data(likelihood, self.marginal)
negative_log_ratio_value = -1 * self.predict_log_ratio(
X, y, self.observed)
# Update classifier attributes list
self.classifier_attributes += [self.classifier.attributes]
# BO part
self.state['n_evidence'] += self.batch_size
parameter_values = batch_to_arr2d(batch, self.parameter_names)
optimize = self._should_optimize()
self.target_model.update(parameter_values, negative_log_ratio_value,
optimize)
if optimize:
self.state['last_GP_update'] = self.target_model.n_evidence
def update(self, batch, batch_index):
"""Update the GP regression model of the target node.
"""
super(BayesianOptimization, self).update(batch, batch_index)
self.state['n_evidence'] += self.batch_size
params = batch_to_arr2d(batch, self.parameter_names)
self._report_batch(batch_index, params, batch[self.target_name])
optimize = self._should_optimize()
self.target_model.update(params, batch[self.target_name], optimize)
if optimize:
self.state['last_GP_update'] = self.target_model.n_evidence
def update(self, batch, batch_index):
"""Update the GP regression model of the target node with a new batch.
Parameters
----------
batch : dict
dict with `self.outputs` as keys and the corresponding outputs for the batch
as values
batch_index : int
"""
super(BayesianOptimization, self).update(batch, batch_index)
self.state['n_evidence'] += self.batch_size
params = batch_to_arr2d(batch, self.parameter_names)
self._report_batch(batch_index, params, batch[self.target_name])
optimize = self._should_optimize()
self.target_model.update(params, batch[self.target_name], optimize)
if optimize:
self.state['last_GP_update'] = self.target_model.n_evidence
class BayesianOptimization(ParameterInference):
"""Bayesian Optimization of an unknown target function."""
def __init__(self,
model,
target_name=None,
bounds=None,
initial_evidence=None,
update_interval=10,
target_model=None,
acquisition_method=None,
acq_noise_var=0,
exploration_rate=10,
batch_size=1,
batches_per_acquisition=None,
async=False,
**kwargs):
"""Initialize Bayesian optimization.
Parameters
----------
model : ElfiModel or NodeReference
target_name : str or NodeReference
Only needed if model is an ElfiModel
bounds : dict, optional
The region where to estimate the posterior for each parameter in
model.parameters: dict('parameter_name':(lower, upper), ... )`. Not used if
custom target_model is given.
initial_evidence : int, dict, optional
Number of initial evidence or a precomputed batch dict containing parameter
and discrepancy values. Default value depends on the dimensionality.
update_interval : int, optional
How often to update the GP hyperparameters of the target_model
target_model : GPyRegression, optional
acquisition_method : Acquisition, optional
Method of acquiring evidence points. Defaults to LCBSC.
acq_noise_var : float or np.array, optional
Variance(s) of the noise added in the default LCBSC acquisition method.
If an array, should be 1d specifying the variance for each dimension.
exploration_rate : float, optional
Exploration rate of the acquisition method
batch_size : int, optional
Elfi batch size. Defaults to 1.
batches_per_acquisition : int, optional
How many batches will be requested from the acquisition function at one go.
Defaults to max_parallel_batches.
async : bool, optional
Allow acquisitions to be made asynchronously, i.e. do not wait for all the
results from the previous acquisition before making the next. This can be more
efficient with a large amount of workers (e.g. in cluster environments) but
forgoes the guarantee for the exactly same result with the same initial
conditions (e.g. the seed). Default False.
**kwargs
"""
model, target_name = self._resolve_model(model, target_name)
output_names = [target_name] + model.parameter_names
super(BayesianOptimization, self).__init__(
model, output_names, batch_size=batch_size, **kwargs)
target_model = target_model or GPyRegression(self.model.parameter_names, bounds=bounds)
self.target_name = target_name
self.target_model = target_model
n_precomputed = 0
n_initial, precomputed = self._resolve_initial_evidence(initial_evidence)
if precomputed is not None:
params = batch_to_arr2d(precomputed, self.parameter_names)
n_precomputed = len(params)
self.target_model.update(params, precomputed[target_name])
self.batches_per_acquisition = batches_per_acquisition or self.max_parallel_batches
self.acquisition_method = acquisition_method or LCBSC(self.target_model,
prior=ModelPrior(self.model),
noise_var=acq_noise_var,
exploration_rate=exploration_rate,
seed=self.seed)
self.n_initial_evidence = n_initial
self.n_precomputed_evidence = n_precomputed
self.update_interval = update_interval
self.async = async