def __init__(self, model, X_lower, X_upper, par=0.01, **kwargs):
r"""
Computes for a given x the logarithm expected improvement as
acquisition value.
Parameters
----------
model: Model object
A model that implements at least
- predict(X)
If you want to calculate derivatives than it should also support
- predictive_gradients(X)
X_lower: np.ndarray (D)
Lower bounds of the input space
X_upper: np.ndarray (D)
Upper bounds of the input space
par: float
Controls the balance between exploration
and exploitation of the acquisition function. Default is 0.01
"""
super(LogEI, self).__init__(model, X_lower, X_upper)
self.par = par
self.rec = BestObservation(self.model, self.X_lower, self.X_upper)
def __init__(self, model, X_lower, X_upper, par=0.0, **kwargs):
r"""
Probability of Improvement solves the following equation
:math:`PI(X) := \mathbb{P}\left( f(\mathbf{X^+}) - f_{t+1}(\mathbf{X}) > \xi\right)`, where
:math:`f(X^+)` is the best input found so far.
Parameters
----------
model: Model object
A model that implements at least
- predict(X)
- getCurrentBestX().
If you want to calculate derivatives than it should also support
- predictive_gradients(X)
X_lower: np.ndarray (D)
Lower bounds of the input space
X_upper: np.ndarray (D)
Upper bounds of the input space
par: float
Controls the balance between exploration
and exploitation of the acquisition function. Default is 0.01
"""
super(PI, self).__init__(model, X_lower, X_upper)
self.par = par
self.rec = BestObservation(self.model, self.X_lower, self.X_upper)
def test(self):
X_lower = np.array([0])
X_upper = np.array([1])
X = init_random_uniform(X_lower, X_upper, 10)
Y = np.sin(X)
kernel = george.kernels.Matern52Kernel(np.ones([1]),
ndim=1)
prior = TophatPrior(-2, 2)
model = GaussianProcess(kernel, prior=prior)
model.train(X, Y)
rec = BestObservation(model, X_lower, X_upper)
startpoints = init_random_uniform(X_lower, X_upper, 10)
inc, inc_val = rec.estimate_incumbent(startpoints)
# Check shapes
assert len(inc.shape) == 2
assert inc.shape[0] == 1
assert inc.shape[1] == X_lower.shape[0]
assert len(inc_val.shape) == 2
assert inc_val.shape[0] == 1
assert inc_val.shape[1] == 1
# Check if incumbent is in the bounds
assert not np.any([np.any(inc[:, i] < X_lower[i])
for i in range(X_lower.shape[0])])
assert not np.any([np.any(inc[:, i] > X_upper[i])
for i in range(X_upper.shape[0])])
def __init__(self, model, X_lower, X_upper, par=0.0, **kwargs):
r"""
Computes for a given x the expected improvement as
acquisition value.
:math:`EI(X) :=
\mathbb{E}\left[ \max\{0, f(\mathbf{X^+}) -
f_{t+1}(\mathbf{X}) - \xi\right] \} ]`, with
:math:`f(X^+)` as the incumbent.
Parameters
----------
model: Model object
A model that implements at least
- predict(X)
- getCurrentBestX().
If you want to calculate derivatives than it should also support
- predictive_gradients(X)
X_lower: np.ndarray (D)
Lower bounds of the input space
X_upper: np.ndarray (D)
Upper bounds of the input space
compute_incumbent: func
A python function that takes as input a model and returns
a np.array as incumbent
par: float
Controls the balance between exploration
and exploitation of the acquisition function. Default is 0.01
"""
super(EI, self).__init__(model, X_lower, X_upper)
self.par = par
self.rec = BestObservation(self.model, self.X_lower, self.X_upper)
def update(self, model):
"""
This method will be called if the model is updated.
Parameters
----------
model : Model object
Models the objective function.
"""
super(PI, self).update(model)
self.rec = BestObservation(self.model, self.X_lower, self.X_upper)
def __init__(self, task=None, save_dir=None, num_save=1, rng=None):
"""
Random Search [1] that simply evaluates random points. We do not have
any priors thus we sample points uniformly at random.
[1] J. Bergstra and Y. Bengio.
Random search for hyper-parameter optimization.
JMLR, 2012.
Parameters
----------
task: TaskObject
Task object that contains the objective function and additional
meta information such as the lower and upper bound of the search
space.
num_save: int
Defines after how many iteration the output is saved.
save_dir: String
Output path
rng: numpy.random.RandomState
"""
if rng is None:
self.rng = np.random.RandomState(42)
else:
self.rng = rng
self.task = task
self.save_dir = save_dir
self.X = None
self.Y = None
self.estimator = BestObservation(self,
self.task.X_lower,
self.task.X_upper)
self.time_func_eval = None
self.time_overhead = None
self.num_save = num_save
self.model_untrained = True
self.incumbent = None
self.incumbents = []
self.incumbent_values = []
self.runtime = []
if self.save_dir is not None:
self.create_save_dir()
def __init__(self,
acquisition_func,
model,
maximize_func,
task,
save_dir=None,
initial_design=None,
initial_points=3,
incumbent_estimation=None,
num_save=1,
train_intervall=1,
n_restarts=1):
"""
Implementation of the standard Bayesian optimization loop that uses
an acquisition function and a model to optimize a given task.
This module keeps track of additional information such as runtime,
optimization overhead, evaluated points and saves the output
in a csv file.
Parameters
----------
acquisition_func: BaseAcquisitionFunctionObject
The acquisition function which will be maximized.
model: ModelObject
Model (i.e. GaussianProcess, RandomForest) that models our current
believe of the objective function.
task: TaskObject
Task object that contains the objective function and additional
meta information such as the lower and upper bound of the search
space.
save_dir: String
Output path
initial_design: function
Function that returns some points which will be evaluated before
the Bayesian optimization loop is started. This allows to
initialize the model.
initial_points: int
Defines the number of initial points that are evaluated before the
actual Bayesian optimization.
incumbent_estimation: IncumbentEstimationObject,
Object to estimate the incumbent based on the current model. The
incumbent is the current best guess of the global optimum and is
estimated in each iteration.
num_save: int
Defines after how many iteration the output is saved.
train_intervall: int
Specifies after how many iterations the model is retrained.
n_restarts: int
How often the incumbent estimation is repeated.
"""
super(BayesianOptimization,
self).__init__(acquisition_func, model, maximize_func, task,
save_dir)
self.start_time = time.time()
if initial_design == None:
self.initial_design = init_random_uniform
else:
self.initial_design = initial_design
self.X = None
self.Y = None
self.time_func_eval = None
self.time_overhead = None
self.train_intervall = train_intervall
self.num_save = num_save
self.time_start = None
self.model_untrained = True
if incumbent_estimation is None:
self.estimator = BestObservation(self.model, self.task.X_lower,
self.task.X_upper)
else:
self.estimator = incumbent_estimation
self.incumbent = None
self.incumbents = []
self.incumbent_values = []
self.n_restarts = n_restarts
self.init_points = initial_points
self.runtime = []
def test(self):
X_lower = np.array([0])
X_upper = np.array([1])
X = init_random_uniform(X_lower, X_upper, 10)
Y = np.sin(X)
kernel = george.kernels.Matern52Kernel(np.ones([1]), ndim=1)
prior = TophatPrior(-2, 2)
model = GaussianProcess(kernel, prior=prior)
model.train(X, Y)
x_test = init_random_uniform(X_lower, X_upper, 3)
# Shape matching predict
m, v = model.predict(x_test)
assert len(m.shape) == 2
assert m.shape[0] == x_test.shape[0]
assert m.shape[1] == 1
assert len(v.shape) == 2
assert v.shape[0] == x_test.shape[0]
assert v.shape[1] == x_test.shape[0]
#TODO: check gradients
# Shape matching function sampling
x_ = np.linspace(X_lower, X_upper, 10)
x_ = x_[:, np.newaxis]
funcs = model.sample_functions(x_, n_funcs=2)
assert len(funcs.shape) == 2
assert funcs.shape[0] == 2
assert funcs.shape[1] == x_.shape[0]
# Shape matching predict variance
x_test1 = np.array([np.random.rand(1)])
x_test2 = np.random.rand(10)[:, np.newaxis]
var = model.predict_variance(x_test1, x_test2)
assert len(var.shape) == 2
assert var.shape[0] == x_test2.shape[0]
assert var.shape[1] == 1
# Check compatibility with all acquisition functions
acq_func = EI(model, X_upper=X_upper, X_lower=X_lower)
acq_func.update(model)
acq_func(x_test)
acq_func = PI(model, X_upper=X_upper, X_lower=X_lower)
acq_func.update(model)
acq_func(x_test)
acq_func = LCB(model, X_upper=X_upper, X_lower=X_lower)
acq_func.update(model)
acq_func(x_test)
acq_func = InformationGain(model, X_upper=X_upper, X_lower=X_lower)
acq_func.update(model)
acq_func(x_test)
# Check compatibility with all incumbent estimation methods
rec = BestObservation(model, X_lower, X_upper)
inc, inc_val = rec.estimate_incumbent(None)
assert len(inc.shape) == 2
assert inc.shape[0] == 1
assert inc.shape[1] == X_upper.shape[0]
assert len(inc_val.shape) == 2
assert inc_val.shape[0] == 1
assert inc_val.shape[1] == 1
rec = PosteriorMeanOptimization(model, X_lower, X_upper)
startpoints = init_random_uniform(X_lower, X_upper, 4)
inc, inc_val = rec.estimate_incumbent(startpoints)
assert len(inc.shape) == 2
assert inc.shape[0] == 1
assert inc.shape[1] == X_upper.shape[0]
assert len(inc_val.shape) == 2
assert inc_val.shape[0] == 1
assert inc_val.shape[1] == 1
rec = PosteriorMeanAndStdOptimization(model, X_lower, X_upper)
startpoints = init_random_uniform(X_lower, X_upper, 4)
inc, inc_val = rec.estimate_incumbent(startpoints)
assert len(inc.shape) == 2
assert inc.shape[0] == 1
assert inc.shape[1] == X_upper.shape[0]
assert len(inc_val.shape) == 2
assert inc_val.shape[0] == 1
assert inc_val.shape[1] == 1
def test(self):
X_lower = np.array([0])
X_upper = np.array([1])
X = init_random_uniform(X_lower, X_upper, 10)
Y = np.sin(X)
model = RandomForest(types=np.zeros([X_lower.shape[0]]))
model.train(X, Y)
x_test = init_random_uniform(X_lower, X_upper, 3)
# Shape matching predict
m, v = model.predict(x_test)
assert len(m.shape) == 2
assert m.shape[0] == x_test.shape[0]
assert m.shape[1] == 1
assert len(v.shape) == 2
assert v.shape[0] == x_test.shape[0]
assert v.shape[1] == 1
# Shape matching function sampling
x_ = np.linspace(X_lower, X_upper, 10)
x_ = x_[:, np.newaxis]
#funcs = model.sample_functions(x_, n_funcs=2)
#assert len(funcs.shape) == 2
#assert funcs.shape[0] == 2
#assert funcs.shape[1] == x_.shape[0]
# Check compatibility with all acquisition functions
acq_func = EI(model, X_upper=X_upper, X_lower=X_lower)
acq_func.update(model)
acq_func(x_test)
acq_func = PI(model, X_upper=X_upper, X_lower=X_lower)
acq_func.update(model)
acq_func(x_test)
acq_func = LCB(model, X_upper=X_upper, X_lower=X_lower)
acq_func.update(model)
acq_func(x_test)
# Check compatibility with all incumbent estimation methods
rec = BestObservation(model, X_lower, X_upper)
inc, inc_val = rec.estimate_incumbent(None)
assert len(inc.shape) == 2
assert inc.shape[0] == 1
assert inc.shape[1] == X_upper.shape[0]
assert len(inc_val.shape) == 2
assert inc_val.shape[0] == 1
assert inc_val.shape[1] == 1
rec = PosteriorMeanOptimization(model, X_lower, X_upper)
startpoints = init_random_uniform(X_lower, X_upper, 4)
inc, inc_val = rec.estimate_incumbent(startpoints)
assert len(inc.shape) == 2
assert inc.shape[0] == 1
assert inc.shape[1] == X_upper.shape[0]
assert len(inc_val.shape) == 2
assert inc_val.shape[0] == 1
assert inc_val.shape[1] == 1
rec = PosteriorMeanAndStdOptimization(model, X_lower, X_upper)
startpoints = init_random_uniform(X_lower, X_upper, 4)
inc, inc_val = rec.estimate_incumbent(startpoints)
assert len(inc.shape) == 2
assert inc.shape[0] == 1
assert inc.shape[1] == X_upper.shape[0]
assert len(inc_val.shape) == 2
assert inc_val.shape[0] == 1
assert inc_val.shape[1] == 1
def test(self):
X_lower = np.array([0])
X_upper = np.array([1])
X = init_random_uniform(X_lower, X_upper, 10)
Y = np.sin(X)
kernel = GPy.kern.Matern52(input_dim=1)
model = GPyModel(kernel)
model.train(X, Y)
x_test = init_random_uniform(X_lower, X_upper, 3)
# Shape matching predict
m, v = model.predict(x_test, full_cov=True)
assert len(m.shape) == 2
assert m.shape[0] == x_test.shape[0]
assert m.shape[1] == 1
assert len(v.shape) == 2
assert v.shape[0] == x_test.shape[0]
assert v.shape[1] == x_test.shape[0]
# Check gradients
dm, dv = model.predictive_gradients(x_test)
assert len(dm.shape) == 2
assert dm.shape[0] == x_test.shape[0]
assert dm.shape[1] == x_test.shape[1]
assert len(dv.shape) == 2
assert dv.shape[0] == x_test.shape[0]
assert dv.shape[1] == 1
# Shape matching function sampling
x_ = np.linspace(X_lower, X_upper, 10)
x_ = x_[:, np.newaxis]
funcs = model.sample_functions(x_, n_funcs=2)
assert len(funcs.shape) == 2
assert funcs.shape[0] == 2
assert funcs.shape[1] == x_.shape[0]
# Shape matching predict variance
x_test2 = np.array([np.random.rand(1)])
x_test1 = np.random.rand(10)[:, np.newaxis]
var = model.predict_variance(x_test1, x_test2)
assert len(var.shape) == 2
assert var.shape[0] == x_test1.shape[0]
assert var.shape[1] == 1
# Check compatibility with all acquisition functions
acq_func = EI(model,
X_upper=X_upper,
X_lower=X_lower)
acq_func.update(model)
acq_func(x_test)
acq_func = PI(model,
X_upper=X_upper,
X_lower=X_lower)
acq_func.update(model)
acq_func(x_test)
acq_func = LCB(model,
X_upper=X_upper,
X_lower=X_lower)
acq_func.update(model)
acq_func(x_test)
acq_func = InformationGain(model,
X_upper=X_upper,
X_lower=X_lower)
acq_func.update(model)
acq_func(x_test)
# Check compatibility with all incumbent estimation methods
rec = BestObservation(model, X_lower, X_upper)
inc, inc_val = rec.estimate_incumbent(None)
assert len(inc.shape) == 2
assert inc.shape[0] == 1
assert inc.shape[1] == X_upper.shape[0]
assert len(inc_val.shape) == 2
assert inc_val.shape[0] == 1
assert inc_val.shape[1] == 1
rec = PosteriorMeanOptimization(model, X_lower, X_upper)
startpoints = init_random_uniform(X_lower, X_upper, 4)
inc, inc_val = rec.estimate_incumbent(startpoints)
assert len(inc.shape) == 2
assert inc.shape[0] == 1
assert inc.shape[1] == X_upper.shape[0]
assert len(inc_val.shape) == 2
assert inc_val.shape[0] == 1
assert inc_val.shape[1] == 1
rec = PosteriorMeanAndStdOptimization(model, X_lower, X_upper)
startpoints = init_random_uniform(X_lower, X_upper, 4)
inc, inc_val = rec.estimate_incumbent(startpoints)
assert len(inc.shape) == 2
assert inc.shape[0] == 1
assert inc.shape[1] == X_upper.shape[0]
assert len(inc_val.shape) == 2
assert inc_val.shape[0] == 1
assert inc_val.shape[1] == 1
