class TestBayesianOptimization(unittest.TestCase):
def setUp(self):
lower = np.zeros([1])
upper = np.ones([1])
kernel = george.kernels.Matern52Kernel(np.array([1]), dim=1, ndim=1)
model = GaussianProcess(kernel)
lcb = LCB(model)
maximizer = RandomSampling(lcb, lower, upper)
self.solver = BayesianOptimization(objective_func, lower, upper, lcb,
model, maximizer)
def test_run(self):
n_iters = 4
inc, inc_val = self.solver.run(n_iters)
assert len(inc) == 1
assert np.array(inc) >= 0
assert np.array(inc) <= 1
assert len(self.solver.incumbents_values) == n_iters
assert len(self.solver.incumbents) == n_iters
assert len(self.solver.time_overhead) == n_iters
assert len(self.solver.time_func_evals) == n_iters
assert len(self.solver.runtime) == n_iters
assert self.solver.X.shape[0] == n_iters
assert self.solver.y.shape[0] == n_iters
def test_choose_next(self):
X = np.random.rand(10, 1)
y = np.array([objective_func(x) for x in X])
x_new = self.solver.choose_next(X, y)
assert x_new.shape[0] == 1
assert x_new >= 0
assert x_new <= 1
def bo(self, model, seed):
""" Bayesian Optimization for ABLR
Parameters:
model: Net Object
seed : int
"""
rng = np.random.RandomState(seed)
model1 = model
acq = EI(model1)
max_func = SciPyOptimizer(acq, self.lower_x, self.upper_x)
if model1.transfer: init = 1 # 1 initial point for transfer case
else: init = 5
bo = BayesianOptimization(self.f.call,
lower=self.lower_x,
upper=self.upper_x,
acquisition_func=acq,
model=model1,
maximize_func=max_func,
initial_points=init,
initial_design=init_latin_hypercube_sampling,
rng=rng)
bo.run(num_iterations=50)
return bo.incumbents_values
class TestBayesianOptimization(unittest.TestCase):
def setUp(self):
lower = np.zeros([1])
upper = np.ones([1])
kernel = george.kernels.Matern52Kernel(np.array([1]), dim=1, ndim=1)
model = GaussianProcess(kernel)
lcb = LCB(model)
maximizer = Direct(lcb, lower, upper, n_func_evals=10)
self.solver = BayesianOptimization(objective_func, lower, upper,
lcb, model, maximizer)
def test_run(self):
n_iters = 4
inc, inc_val = self.solver.run(n_iters)
assert len(inc) == 1
assert np.array(inc) >= 0
assert np.array(inc) <= 1
assert len(self.solver.incumbents_values) == n_iters
assert len(self.solver.incumbents) == n_iters
assert len(self.solver.time_overhead) == n_iters
assert len(self.solver.time_func_evals) == n_iters
assert len(self.solver.runtime) == n_iters
assert self.solver.X.shape[0] == n_iters
assert self.solver.y.shape[0] == n_iters
def test_choose_next(self):
X = np.random.rand(10, 1)
y = np.array([objective_func(x) for x in X])
x_new = self.solver.choose_next(X, y)
assert x_new.shape[0] == 1
assert x_new >= 0
assert x_new <= 1
def setUp(self):
lower = np.zeros([1])
upper = np.ones([1])
kernel = george.kernels.Matern52Kernel(np.array([1]), dim=1, ndim=1)
model = GaussianProcess(kernel)
lcb = LCB(model)
maximizer = RandomSampling(lcb, lower, upper)
self.solver = BayesianOptimization(objective_func, lower, upper, lcb,
model, maximizer)
def benchmark_function(
function,
seed,
n_eval=20,
n_initial_points=5,
model_class=None,
model_kwargs=None,
):
lower = np.array([-10])
upper = np.array([10])
rng1 = np.random.RandomState(seed)
rng2 = np.random.RandomState(seed)
cov_amp = 2
n_dims = lower.shape[0]
initial_ls = np.ones([n_dims])
exp_kernel = george.kernels.Matern52Kernel(initial_ls,
ndim=n_dims)
kernel = cov_amp * exp_kernel
prior = DefaultPrior(len(kernel) + 1)
if model_class is None:
model = GaussianProcess(
kernel,
prior=prior,
rng=rng1,
normalize_output=True,
normalize_input=True,
lower=lower,
upper=upper,
noise=1e-3,
)
else:
model = model_class(rng=rng1, **model_kwargs)
acq = LogEI(model)
max_func = SciPyOptimizer(acq, lower, upper, n_restarts=50, rng=rng2)
bo = BayesianOptimization(
objective_func=function,
lower=np.array([-10]),
upper=np.array([10]),
acquisition_func=acq,
model=model,
initial_points=n_initial_points,
initial_design=init_latin_hypercube_sampling,
rng=rng2,
maximize_func=max_func
)
bo.run(n_eval)
rval = np.minimum.accumulate(bo.y)
return rval
def fmin_task(task, num_iterations=30, model="GPy", maximizer="direct", kernel="Matern52", acquisition_fkt="EI"):
if model == "GPy":
k = get_gpy_kernel(kernel, task)
if k is None:
return None
m = gpy_model(k, optimize=True, noise_variance=1e-4, num_restarts=10)
elif model == "GPyMCMC":
k = get_gpy_kernel(kernel, task)
if k is None:
return None
m = GPyModelMCMC(k, optimize=True, noise_variance=1e-4, num_restarts=10)
elif model == "pyGPs":
k = get_pygps_kernel(kernel, task)
if k is None:
return None
m = PyGPModel(k, optimize=True, num_restarts=10)
else:
print(("ERROR: %s is not a valid model!" % (model)))
return None
if acquisition_fkt == "EI":
a = EI(m, X_upper=task.X_upper, X_lower=task.X_lower, compute_incumbent=compute_incumbent, par=0.1)
elif acquisition_fkt == "PI":
a = PI(model, X_upper=task.X_upper, X_lower=task.X_lower, compute_incumbent=compute_incumbent, par=0.1)
elif acquisition_fkt == "UCB":
a = UCB(model, X_upper=task.X_upper, X_lower=task.X_lower, compute_incumbent=compute_incumbent)
elif acquisition_fkt == "Entropy":
a = Entropy(model, X_upper=task.X_upper, X_lower=task.X_lower, compute_incumbent=compute_incumbent, par=0.1)
elif acquisition_fkt == "EntropyMC":
a = EntropyMC(model, X_upper=task.X_upper, X_lower=task.X_lower, compute_incumbent=compute_incumbent, par=0.1)
else:
print(("ERROR: %s is not a valid acquisition function!" % (acquisition_fkt)))
return None
if maximizer == "cmaes":
max_fkt = cmaes.CMAES(a, task.X_lower, task.X_upper)
elif maximizer == "direct":
max_fkt = direct.Direct(a, task.X_lower, task.X_upper)
elif maximizer == "stochastic_local_search":
max_fkt = stochastic_local_search.StochasticLocalSearch(a, task.X_lower, task.X_upper)
elif maximizer == "grid_search":
max_fkt = grid_search.GridSearch(a, task.X_lower, task.X_upper)
else:
print(("ERROR: %s is not a valid function to maximize the acquisition function!" % (acquisition_fkt)))
return None
bo = BayesianOptimization(acquisition_func=a,
model=m,
maximize_func=max_fkt,
task=task)
best_x, f_min = bo.run(num_iterations)
return best_x, f_min
def Gp(self, seed):
"""
Bayesian optimization with Gaussian process(mcmc)
"""
lower = np.zeros((self.x.shape[2]))
upper = np.ones((self.x.shape[2]))
inc = np.ones((self.T, 50))
for t in range(self.T):
rng = np.random.RandomState(seed) # this per task per random run
cov_amp = 2
n_dims = self.x.shape[2]
initial_ls = np.ones([n_dims])
exp_kernel = george.kernels.Matern52Kernel(initial_ls, ndim=n_dims)
kernel = cov_amp * exp_kernel
prior = DefaultPrior(len(kernel) + 1)
n_hypers = 3 * len(kernel)
if n_hypers % 2 == 1:
n_hypers += 1
model = GaussianProcess(kernel,
prior=prior,
rng=rng,
normalize_output=False,
normalize_input=False,
noise=1e-6)
acq = EI(model)
# for the initial design, initialize the class with x-task
f = Objective_function(self.x[t], self.y[t], self.metadata[t])
indes = InDesign(self.x[t])
randdes = Rand_Design(self.x[t])
max_func = RandomSampling(acq,
lower,
upper,
randdes,
n_samples=100,
rng=rng)
bo = BayesianOptimization(
f.call,
lower=lower,
upper=upper,
acquisition_func=acq,
model=model,
initial_design=randdes.initial_design_random,
initial_points=3,
rng=rng,
maximize_func=max_func)
bo.run(num_iterations=50)
inc[t] = bo.incumbents_values
return inc
def test_json_base_solver(self):
task = Levy()
kernel = george.kernels.Matern52Kernel([1.0], ndim=1)
model = GaussianProcess(kernel)
ei = EI(model, task.X_lower, task.X_upper)
maximizer = Direct(ei, task.X_lower, task.X_upper)
solver = BayesianOptimization(acquisition_func=ei,
model=model,
maximize_func=maximizer,
task=task)
solver.run(1, X=None, Y=None)
iteration = 0
data = solver.get_json_data(it=iteration)
assert data['iteration'] == iteration
def test_json_base_solver(self):
task = Levy()
kernel = george.kernels.Matern52Kernel([1.0], ndim=1)
model = GaussianProcess(kernel)
ei = EI(model, task.X_lower, task.X_upper)
maximizer = Direct(ei, task.X_lower, task.X_upper)
solver = BayesianOptimization(acquisition_func=ei,
model=model,
maximize_func=maximizer,
task=task
)
solver.run(1,X =None, Y=None)
iteration = 0
data = solver.get_json_data(it=iteration)
assert data['iteration'] == iteration
def bo(self, fun, seed, model_net, indes, randdes):
"""
Bayesian Optimization for ABLR
Parameters:
fun: Function_dataset object
mapping of the data
model: Net Object
seed : int
indes : Initial_design Object
"""
# BO for the network
lower = np.zeros((self.x.shape[2]))
upper = np.ones((self.x.shape[2]))
rng = np.random.RandomState(seed)
cov_amp = 2
n_dims = self.x.shape[2]
initial_ls = np.ones([n_dims])
exp_kernel = george.kernels.Matern52Kernel(initial_ls, ndim=n_dims)
kernel = cov_amp * exp_kernel
prior = DefaultPrior(len(kernel) + 1)
n_hypers = 3 * len(kernel)
if n_hypers % 2 == 1:
n_hypers += 1
model = model_net
acq = EI(model)
f = fun
#max_func = RandomSampling(acq,lower,upper,indes,n_samples=300,rng=rng)
max_func = RandomSampling(acq,
lower,
upper,
randdes,
n_samples=300,
rng=rng)
bo = BayesianOptimization(f.call,
lower=lower,
upper=upper,
acquisition_func=acq,
model=model,
initial_design=randdes.initial_design_random,
initial_points=3,
rng=rng,
maximize_func=max_func)
bo.run(num_iterations=50)
return bo.incumbents_values
def setUp(self):
lower = np.zeros([1])
upper = np.ones([1])
kernel = george.kernels.Matern52Kernel(np.array([1]), dim=1, ndim=1)
model = GaussianProcess(kernel)
lcb = LCB(model)
maximizer = Direct(lcb, lower, upper, n_func_evals=10)
self.solver = BayesianOptimization(objective_func, lower, upper,
lcb, model, maximizer)
def build_optimizer(model, maximizer, acquisition_func):
"""
General interface for Bayesian optimization for global black box
optimization problems.
Parameters
----------
maximizer: str
The optimizer for the acquisition function.
Can be one of ``{"random", "scipy", "differential_evolution"}``
acquisition_func:
The instantiated acquisition function
Returns
-------
Optimizer
"""
if maximizer == "random":
max_func = RandomSampling(acquisition_func,
model.lower,
model.upper,
rng=None)
elif maximizer == "scipy":
max_func = SciPyOptimizer(acquisition_func,
model.lower,
model.upper,
rng=None)
elif maximizer == "differential_evolution":
max_func = DifferentialEvolution(acquisition_func,
model.lower,
model.upper,
rng=None)
else:
raise ValueError("'{}' is not a valid function to maximize the "
"acquisition function".format(maximizer))
# NOTE: Internal RNG of BO won't be used.
# NOTE: Nb of initial points won't be used within BO, but rather outside
bo = BayesianOptimization(
lambda: None,
model.lower,
model.upper,
acquisition_func,
model,
max_func,
initial_points=None,
rng=None,
initial_design=init_latin_hypercube_sampling,
output_path=None,
)
return bo
def bohamiann(objective_function,
lower,
upper,
num_iterations=30,
acquisition_func="log_ei",
n_init=3,
rng=None):
"""
General interface for Bayesian optimization for global black box optimization problems.
Parameters
----------
objective_function: function
The objective function that is minimized. This function gets a numpy array (D,) as input and returns
the function value (scalar)
lower: np.ndarray (D,)
The lower bound of the search space
upper: np.ndarray (D,)
The upper bound of the search space
num_iterations: int
The number of iterations (initial design + BO)
acquisition_func: {"ei", "log_ei", "lcb", "pi"}
The acquisition function
n_init: int
Number of points for the initial design. Make sure that it is <= num_iterations.
rng: numpy.random.RandomState
Random number generator
Returns
-------
dict with all results
"""
assert upper.shape[0] == lower.shape[0]
assert n_init <= num_iterations, "Number of initial design point has to be <= than the number of iterations"
if rng is None:
rng = np.random.RandomState(np.random.randint(0, 10000))
model = BayesianNeuralNetwork(sampling_method="sghmc",
l_rate=np.sqrt(1e-4),
mdecay=0.05,
burn_in=3000,
n_iters=50000,
precondition=True,
normalize_input=True,
normalize_output=True)
if acquisition_func == "ei":
a = EI(model)
elif acquisition_func == "log_ei":
a = LogEI(model)
elif acquisition_func == "pi":
a = PI(model)
elif acquisition_func == "lcb":
a = LCB(model)
else:
print("ERROR: %s is not a valid acquisition function!" %
acquisition_func)
return
max_func = Direct(a, lower, upper, verbose=False)
bo = BayesianOptimization(objective_function,
lower,
upper,
a,
model,
max_func,
initial_points=n_init,
rng=rng)
x_best, f_min = bo.run(num_iterations)
results = dict()
results["x_opt"] = x_best
results["f_opt"] = f_min
results["incumbents"] = [inc for inc in bo.incumbents]
results["incumbent_values"] = [val for val in bo.incumbents_values]
results["runtime"] = bo.runtime
results["overhead"] = bo.time_overhead
return results
def entropy_search(objective_function,
lower,
upper,
num_iterations=30,
maximizer="random",
model="gp_mcmc",
n_init=3,
output_path=None,
rng=None):
"""
Entropy search for global black box optimization problems. This is a reimplemenation of the entropy search
algorithm by Henning and Schuler[1].
[1] Entropy search for information-efficient global optimization.
P. Hennig and C. Schuler.
JMLR, (1), 2012.
Parameters
----------
objective_function: function
The objective function that is minimized. This function gets a numpy array (D,) as input and returns
the function value (scalar)
lower: np.ndarray (D,)
The lower bound of the search space
upper: np.ndarray (D,)
The upper bound of the search space
num_iterations: int
The number of iterations (initial design + BO)
maximizer: {"random", "scipy", "differential_evolution"}
Defines how the acquisition function is maximized.
model: {"gp", "gp_mcmc"}
The model for the objective function.
n_init: int
Number of points for the initial design. Make sure that it is <= num_iterations.
output_path: string
Specifies the path where the intermediate output after each iteration will be saved.
If None no output will be saved to disk.
rng: numpy.random.RandomState
Random number generator
Returns
-------
dict with all results
"""
assert upper.shape[0] == lower.shape[0], "Dimension miss match"
assert np.all(lower < upper), "Lower bound >= upper bound"
assert n_init <= num_iterations, "Number of initial design point has to be <= than the number of iterations"
if rng is None:
rng = np.random.RandomState(np.random.randint(0, 10000))
cov_amp = 2
n_dims = lower.shape[0]
initial_ls = np.ones([n_dims])
exp_kernel = george.kernels.Matern52Kernel(initial_ls, ndim=n_dims)
kernel = cov_amp * exp_kernel
prior = DefaultPrior(len(kernel) + 1)
n_hypers = 3 * len(kernel)
if n_hypers % 2 == 1:
n_hypers += 1
if model == "gp":
gp = GaussianProcess(kernel,
prior=prior,
rng=rng,
normalize_output=False,
normalize_input=True,
lower=lower,
upper=upper)
elif model == "gp_mcmc":
gp = GaussianProcessMCMC(kernel,
prior=prior,
n_hypers=n_hypers,
chain_length=200,
burnin_steps=100,
normalize_input=True,
normalize_output=False,
rng=rng,
lower=lower,
upper=upper)
else:
print("ERROR: %s is not a valid model!" % model)
return
a = InformationGain(gp, lower=lower, upper=upper, sampling_acquisition=EI)
if model == "gp":
acquisition_func = a
elif model == "gp_mcmc":
acquisition_func = MarginalizationGPMCMC(a)
if maximizer == "random":
max_func = RandomSampling(acquisition_func, lower, upper, rng=rng)
elif maximizer == "scipy":
max_func = SciPyOptimizer(acquisition_func, lower, upper, rng=rng)
elif maximizer == "differential_evolution":
max_func = DifferentialEvolution(acquisition_func,
lower,
upper,
rng=rng)
else:
print(
"ERROR: %s is not a valid function to maximize the acquisition function!"
% maximizer)
return
bo = BayesianOptimization(objective_function,
lower,
upper,
acquisition_func,
gp,
max_func,
initial_design=init_latin_hypercube_sampling,
initial_points=n_init,
rng=rng,
output_path=output_path)
x_best, f_min = bo.run(num_iterations)
results = dict()
results["x_opt"] = x_best
results["f_opt"] = f_min
results["incumbents"] = [inc for inc in bo.incumbents]
results["incumbent_values"] = [val for val in bo.incumbents_values]
results["runtime"] = bo.runtime
results["overhead"] = bo.time_overhead
results["X"] = [x.tolist() for x in bo.X]
results["y"] = [y for y in bo.y]
return results
Created on Mar 16, 2016
@author: Aaron Klein
'''
import george
from robo.maximizers.direct import Direct
from robo.models.gaussian_process import GaussianProcess
from robo.task.synthetic_functions.levy import Levy
from robo.acquisition.ei import EI
from robo.solver.bayesian_optimization import BayesianOptimization
task = Levy()
kernel = george.kernels.Matern52Kernel([1.0], ndim=1)
model = GaussianProcess(kernel)
ei = EI(model, task.X_lower, task.X_upper)
maximizer = Direct(ei, task.X_lower, task.X_upper)
bo = BayesianOptimization(acquisition_func=ei,
model=model,
maximize_func=maximizer,
task=task)
print bo.run(10)
def fmin(objective_func,
X_lower,
X_upper,
num_iterations=30,
maximizer="direct",
acquisition="LogEI",
initX=None,
initY=None):
assert X_upper.shape[0] == X_lower.shape[0]
class Task(BaseTask):
def __init__(self, X_lower, X_upper, objective_fkt):
super(Task, self).__init__(X_lower, X_upper)
self.objective_function = objective_fkt
task = Task(X_lower, X_upper, objective_func)
cov_amp = 2
initial_ls = np.ones([task.n_dims])
exp_kernel = george.kernels.Matern52Kernel(initial_ls, ndim=task.n_dims)
kernel = cov_amp * exp_kernel
prior = DefaultPrior(len(kernel) + 1)
n_hypers = 3 * len(kernel)
if n_hypers % 2 == 1:
n_hypers += 1
model = GaussianProcessMCMC(kernel,
prior=prior,
n_hypers=n_hypers,
chain_length=200,
burnin_steps=100)
if acquisition == "EI":
a = EI(model, X_upper=task.X_upper, X_lower=task.X_lower)
elif acquisition == "LogEI":
a = LogEI(model, X_upper=task.X_upper, X_lower=task.X_lower)
elif acquisition == "PI":
a = PI(model, X_upper=task.X_upper, X_lower=task.X_lower)
elif acquisition == "UCB":
a = LCB(model, X_upper=task.X_upper, X_lower=task.X_lower)
elif acquisition == "InformationGain":
a = InformationGain(model, X_upper=task.X_upper, X_lower=task.X_lower)
elif acquisition == "InformationGainMC":
a = InformationGainMC(
model,
X_upper=task.X_upper,
X_lower=task.X_lower,
)
else:
logger.error("ERROR: %s is not a"
"valid acquisition function!" % (acquisition))
return None
acquisition_func = IntegratedAcquisition(model, a, task.X_lower,
task.X_upper)
if maximizer == "cmaes":
max_fkt = cmaes.CMAES(acquisition_func, task.X_lower, task.X_upper)
elif maximizer == "direct":
max_fkt = direct.Direct(acquisition_func, task.X_lower, task.X_upper)
elif maximizer == "stochastic_local_search":
max_fkt = stochastic_local_search.StochasticLocalSearch(
acquisition_func, task.X_lower, task.X_upper)
elif maximizer == "grid_search":
max_fkt = grid_search.GridSearch(acquisition_func, task.X_lower,
task.X_upper)
else:
logger.error("ERROR: %s is not a valid function"
"to maximize the acquisition function!" % (acquisition))
return None
bo = BayesianOptimization(acquisition_func=acquisition_func,
model=model,
maximize_func=max_fkt,
task=task)
best_x, f_min = bo.run(num_iterations, X=initX, Y=initY)
return task.retransform(best_x), f_min, model, acquisition_func, max_fkt
def fmin(objective_fkt,
X_lower,
X_upper,
num_iterations=30,
maximizer="direct",
acquisition_fkt="EI"):
assert X_upper.shape[0] == X_lower.shape[0]
class Task(BaseTask):
def __init__(self, X_lower, X_upper, objective_fkt):
super(Task, self).__init__(X_lower, X_upper)
self.objective_function = objective_fkt
task = Task(X_lower, X_upper, objective_fkt)
noise = 1.0
cov_amp = 2
initial_ls = np.ones([task.n_dims])
exp_kernel = george.kernels.Matern52Kernel(initial_ls, ndim=task.n_dims)
noise_kernel = george.kernels.WhiteKernel(noise, ndim=task.n_dims)
kernel = cov_amp * (exp_kernel + noise_kernel)
prior = DefaultPrior(len(kernel))
model = GaussianProcessMCMC(kernel,
prior=prior,
n_hypers=20,
chain_length=100,
burnin_steps=50)
if acquisition_fkt == "EI":
a = EI(model, X_upper=task.X_upper, X_lower=task.X_lower)
elif acquisition_fkt == "PI":
a = PI(model, X_upper=task.X_upper, X_lower=task.X_lower)
elif acquisition_fkt == "UCB":
a = LCB(model, X_upper=task.X_upper, X_lower=task.X_lower)
elif acquisition_fkt == "Entropy":
a = Entropy(model, X_upper=task.X_upper, X_lower=task.X_lower)
elif acquisition_fkt == "EntropyMC":
a = EntropyMC(
model,
X_upper=task.X_upper,
X_lower=task.X_lower,
)
else:
logger.error("ERROR: %s is not a"
"valid acquisition function!" % (acquisition_fkt))
return None
if maximizer == "cmaes":
max_fkt = cmaes.CMAES(a, task.X_lower, task.X_upper)
elif maximizer == "direct":
max_fkt = direct.Direct(a, task.X_lower, task.X_upper)
elif maximizer == "stochastic_local_search":
max_fkt = stochastic_local_search.StochasticLocalSearch(
a, task.X_lower, task.X_upper)
elif maximizer == "grid_search":
max_fkt = grid_search.GridSearch(a, task.X_lower, task.X_upper)
else:
logger.error("ERROR: %s is not a valid function"
"to maximize the acquisition function!" %
(acquisition_fkt))
return None
bo = BayesianOptimization(acquisition_func=a,
model=model,
maximize_func=max_fkt,
task=task)
best_x, f_min = bo.run(num_iterations)
return best_x, f_min
def main(method):
for i in range(1, 40):
task = WithinModelComparison(seed=i + 10)
#Entropy MC
try:
path = "/home/kleinaa/experiments/entropy_search/model_comparison/func_" + str(i) + "/"
os.makedirs(path)
except:
pass
if method == "entropy_mc":
save_dir = os.path.join(path, "entropy_mc/")
kernel = GPy.kern.RBF(2, lengthscale=0.1, variance=1.0)
model = GPyModel(kernel, optimize=False, noise_variance=1e-3)
acq = EntropyMC(model, task.X_lower, task.X_upper, optimize_posterior_mean_and_std, Nb=50, Nf=800, Np=100)
maximizer = Direct(acq, task.X_lower, task.X_upper)
bo = BayesianOptimization(model=model, acquisition_fkt=acq,
recommendation_strategy=optimize_posterior_mean_and_std,
maximize_fkt=maximizer, task=task, save_dir=save_dir)
bo.run(100)
elif method == "entropy_mc_light":
save_dir = os.path.join(path, "entropy_mc_light/")
kernel = GPy.kern.RBF(2, lengthscale=0.1, variance=1.0)
model = GPyModel(kernel, optimize=False, noise_variance=1e-3)
acq = EntropyMC(model, task.X_lower, task.X_upper, optimize_posterior_mean_and_std, Nb=50, Nf=50, Np=100)
maximizer = Direct(acq, task.X_lower, task.X_upper)
bo = BayesianOptimization(model=model, acquisition_fkt=acq,
recommendation_strategy=optimize_posterior_mean_and_std,
maximize_fkt=maximizer, task=task, save_dir=save_dir)
bo.run(100)
#EI
elif method == "ei":
save_dir = os.path.join(path, "ei/")
kernel = GPy.kern.RBF(2, lengthscale=0.1, variance=1.0)
model = GPyModel(kernel, optimize=False, noise_variance=1e-3)
acq = EI(model, task.X_lower, task.X_upper, compute_incumbent)
maximizer = Direct(acq, task.X_lower, task.X_upper)
bo = BayesianOptimization(model=model, acquisition_fkt=acq,
recommendation_strategy=optimize_posterior_mean_and_std,
maximize_fkt=maximizer, task=task, save_dir=save_dir)
bo.run(100)
#PI
elif method == "pi":
save_dir = os.path.join(path, "pi/")
kernel = GPy.kern.RBF(2, lengthscale=0.1, variance=1.0)
model = GPyModel(kernel, optimize=False, noise_variance=1e-3)
acq = PI(model, task.X_lower, task.X_upper, compute_incumbent)
maximizer = Direct(acq, task.X_lower, task.X_upper)
bo = BayesianOptimization(model=model, acquisition_fkt=acq,
recommendation_strategy=optimize_posterior_mean_and_std,
maximize_fkt=maximizer, task=task, save_dir=save_dir)
bo.run(100)
#UCB
elif method == "ucb":
save_dir = os.path.join(path, "ucb/")
kernel = GPy.kern.RBF(2, lengthscale=0.1, variance=1.0)
model = GPyModel(kernel, optimize=False, noise_variance=1e-3)
acq = UCB(model, task.X_lower, task.X_upper)
maximizer = Direct(acq, task.X_lower, task.X_upper)
bo = BayesianOptimization(model=model, acquisition_fkt=acq,
recommendation_strategy=optimize_posterior_mean_and_std,
maximize_fkt=maximizer, task=task, save_dir=save_dir)
bo.run(100)
#Entropy
elif method == "entropy":
save_dir = os.path.join(path, "entropy/")
kernel = GPy.kern.RBF(2, lengthscale=0.1, variance=1.0)
model = GPyModel(kernel, optimize=False, noise_variance=1e-3)
acq = Entropy(model, task.X_lower, task.X_upper, compute_inc=optimize_posterior_mean_and_std, Nb=50)
maximizer = Direct(acq, task.X_lower, task.X_upper)
bo = BayesianOptimization(model=model, acquisition_fkt=acq,
recommendation_strategy=optimize_posterior_mean_and_std,
maximize_fkt=maximizer, task=task, save_dir=save_dir)
bo.run(100)
import GPy
from robo.models.gpy_model_mcmc import GPyModelMCMC
from robo.acquisition.ei import EI
from robo.acquisition.integrated_acquisition import IntegratedAcquisition
from robo.maximizers.direct import Direct
from robo.recommendation.incumbent import compute_incumbent
from robo.recommendation.optimize_posterior import optimize_posterior_mean_and_std
from robo.task.branin import Branin
from robo.solver.bayesian_optimization import BayesianOptimization
branin = Branin()
kernel = GPy.kern.Matern52(input_dim=branin.n_dims, ARD=True)
model = GPyModelMCMC(kernel, burnin=100, chain_length=100, n_hypers=20)
ei = EI(model, X_upper=branin.X_upper, X_lower=branin.X_lower, compute_incumbent=compute_incumbent, par=0.1)
acquisition_func = IntegratedAcquisition(model, ei)
maximizer = Direct(acquisition_func, branin.X_lower, branin.X_upper)
bo = BayesianOptimization(acquisition_func=acquisition_func,
model=model,
maximize_func=maximizer,
recommendation_strategy=optimize_posterior_mean_and_std,
task=branin,
save_dir='/tmp'
)
bo.run(30)
def bayesian_optimization(objective_function,
lower,
upper,
num_iterations=30,
maximizer="random",
acquisition_func="log_ei",
model_type="gp_mcmc",
n_init=3,
rng=None,
output_path=None):
"""
General interface for Bayesian optimization for global black box
optimization problems.
Parameters
----------
objective_function: function
The objective function that is minimized. This function gets a numpy
array (D,) as input and returns the function value (scalar)
lower: np.ndarray (D,)
The lower bound of the search space
upper: np.ndarray (D,)
The upper bound of the search space
num_iterations: int
The number of iterations (initial design + BO)
maximizer: {"direct", "cmaes", "random", "scipy"}
The optimizer for the acquisition function. NOTE: "cmaes" only works in D > 1 dimensions
acquisition_func: {"ei", "log_ei", "lcb", "pi"}
The acquisition function
model_type: {"gp", "gp_mcmc", "rf"}
The model for the objective function.
n_init: int
Number of points for the initial design. Make sure that it
is <= num_iterations.
output_path: string
Specifies the path where the intermediate output after each iteration will be saved.
If None no output will be saved to disk.
rng: numpy.random.RandomState
Random number generator
Returns
-------
dict with all results
"""
assert upper.shape[0] == lower.shape[0], "Dimension miss match"
assert np.all(lower < upper), "Lower bound >= upper bound"
assert n_init <= num_iterations, "Number of initial design point has to be <= than the number of iterations"
if rng is None:
rng = np.random.RandomState(np.random.randint(0, 10000))
cov_amp = 2
n_dims = lower.shape[0]
initial_ls = np.ones([n_dims])
exp_kernel = george.kernels.Matern52Kernel(initial_ls, ndim=n_dims)
kernel = cov_amp * exp_kernel
prior = DefaultPrior(len(kernel) + 1)
n_hypers = 3 * len(kernel)
if n_hypers % 2 == 1:
n_hypers += 1
if model_type == "gp":
model = GaussianProcess(kernel,
prior=prior,
rng=rng,
normalize_output=False,
normalize_input=True,
lower=lower,
upper=upper)
elif model_type == "gp_mcmc":
model = GaussianProcessMCMC(kernel,
prior=prior,
n_hypers=n_hypers,
chain_length=200,
burnin_steps=100,
normalize_input=True,
normalize_output=True,
rng=rng,
lower=lower,
upper=upper)
elif model_type == "rf":
model = RandomForest(rng=rng)
else:
raise ValueError("'{}' is not a valid model".format(model_type))
if acquisition_func == "ei":
a = EI(model)
elif acquisition_func == "log_ei":
a = LogEI(model)
elif acquisition_func == "pi":
a = PI(model)
elif acquisition_func == "lcb":
a = LCB(model)
else:
raise ValueError("'{}' is not a valid acquisition function".format(
acquisition_func))
if model_type == "gp_mcmc":
acquisition_func = MarginalizationGPMCMC(a)
else:
acquisition_func = a
if maximizer == "cmaes":
max_func = CMAES(acquisition_func,
lower,
upper,
verbose=False,
rng=rng)
elif maximizer == "direct":
max_func = Direct(acquisition_func, lower, upper, verbose=True)
elif maximizer == "random":
max_func = RandomSampling(acquisition_func, lower, upper, rng=rng)
elif maximizer == "scipy":
max_func = SciPyOptimizer(acquisition_func, lower, upper, rng=rng)
else:
raise ValueError("'{}' is not a valid function to maximize the "
"acquisition function".format(maximizer))
bo = BayesianOptimization(objective_function,
lower,
upper,
acquisition_func,
model,
max_func,
initial_points=n_init,
rng=rng,
output_path=output_path)
x_best, f_min = bo.run(num_iterations)
results = dict()
results["x_opt"] = x_best
results["f_opt"] = f_min
results["incumbents"] = [inc for inc in bo.incumbents]
results["incumbent_values"] = [val for val in bo.incumbents_values]
results["runtime"] = bo.runtime
results["overhead"] = bo.time_overhead
results["X"] = [x.tolist() for x in bo.X]
results["y"] = [y for y in bo.y]
return results
from robo.acquisition.ei import EI
from robo.maximizers.direct import Direct
from robo.task.controlling_tasks.walker import Walker
from robo.solver.bayesian_optimization import BayesianOptimization
from robo.priors.default_priors import DefaultPrior
from robo.acquisition.integrated_acquisition import IntegratedAcquisition
task = Walker()
test = '/test'
kernel = 1 * george.kernels.Matern52Kernel(np.ones([task.n_dims]),
ndim=task.n_dims)
prior = DefaultPrior(len(kernel) + 1)
model = GaussianProcessMCMC(kernel,
prior=prior,
chain_length=100,
burnin_steps=200,
n_hypers=8)
ei = EI(model, task.X_lower, task.X_upper)
acquisition_func = IntegratedAcquisition(model, ei, task.X_lower, task.X_upper)
maximizer = Direct(acquisition_func, task.X_lower, task.X_upper)
bo = BayesianOptimization(acquisition_func=acquisition_func,
model=model,
maximize_func=maximizer,
task=task,
save_dir=test)
print bo.run(2)
# Specifies the task object that defines the objective functions and
# the bounds of the input space
branin = Branin()
# Instantiate the random forest. Branin does not have any categorical
# values thus we pass a np.zero vector here.
model = RandomForest(branin.types)
# Define the acquisition function
acquisition_func = EI(model,
X_upper=branin.X_upper,
X_lower=branin.X_lower,
par=0.1)
# Strategy of estimating the incumbent
rec = PosteriorMeanAndStdOptimization(model, branin.X_lower,
branin.X_upper, with_gradients=False)
# Define the maximizer
maximizer = CMAES(acquisition_func, branin.X_lower, branin.X_upper)
# Now we defined everything we need to instantiate the solver
bo = BayesianOptimization(acquisition_func=acquisition_func,
model=model,
maximize_func=maximizer,
task=branin,
incumbent_estimation=rec)
bo.run(100)
def bayesian_optimization(objective_function,
lower,
upper,
num_iterations=30,
maximizer="direct",
acquisition_func="log_ei",
model="gp_mcmc",
n_init=3,
rng=None):
"""
General interface for Bayesian optimization for global black box optimization problems.
Parameters
----------
objective_function: function
The objective function that is minimized. This function gets a numpy array (D,) as input and returns
the function value (scalar)
lower: np.ndarray (D,)
The lower bound of the search space
upper: np.ndarray (D,)
The upper bound of the search space
num_iterations: int
The number of iterations (initial design + BO)
maximizer: {"direct", "cmaes"}
Defines how the acquisition function is maximized. NOTE: "cmaes" only works in D > 1 dimensions
acquisition_func: {"ei", "log_ei", "lcb", "pi"}
The acquisition function
model: {"gp", "gp_mcmc"}
The model for the objective function.
n_init: int
Number of points for the initial design. Make sure that it is <= num_iterations.
rng: numpy.random.RandomState
Random number generator
Returns
-------
dict with all results
"""
assert upper.shape[0] == lower.shape[0]
assert n_init <= num_iterations, "Number of initial design point has to be <= than the number of iterations"
if rng is None:
rng = np.random.RandomState(np.random.randint(0, 10000))
cov_amp = 2
n_dims = lower.shape[0]
initial_ls = np.ones([n_dims])
exp_kernel = george.kernels.Matern52Kernel(initial_ls, ndim=n_dims)
kernel = cov_amp * exp_kernel
prior = DefaultPrior(len(kernel) + 1)
n_hypers = 3 * len(kernel)
if n_hypers % 2 == 1:
n_hypers += 1
if model == "gp":
gp = GaussianProcess(kernel,
prior=prior,
rng=rng,
normalize_output=True,
normalize_input=True,
lower=lower,
upper=upper)
elif model == "gp_mcmc":
gp = GaussianProcessMCMC(kernel,
prior=prior,
n_hypers=n_hypers,
chain_length=200,
burnin_steps=100,
normalize_input=True,
normalize_output=True,
rng=rng,
lower=lower,
upper=upper)
else:
print("ERROR: %s is not a valid model!" % model)
return
if acquisition_func == "ei":
a = EI(gp)
elif acquisition_func == "log_ei":
a = LogEI(gp)
elif acquisition_func == "pi":
a = PI(gp)
elif acquisition_func == "lcb":
a = LCB(gp)
else:
print("ERROR: %s is not a valid acquisition function!" %
acquisition_func)
return
if model == "gp":
acquisition_func = a
elif model == "gp_mcmc":
acquisition_func = MarginalizationGPMCMC(a)
if maximizer == "cmaes":
max_func = CMAES(acquisition_func,
lower,
upper,
verbose=False,
rng=rng)
elif maximizer == "direct":
max_func = Direct(acquisition_func, lower, upper, verbose=False)
else:
print(
"ERROR: %s is not a valid function to maximize the acquisition function!"
% maximizer)
return
bo = BayesianOptimization(objective_function,
lower,
upper,
acquisition_func,
gp,
max_func,
initial_points=n_init,
rng=rng)
x_best, f_min = bo.run(num_iterations)
results = dict()
results["x_opt"] = x_best
results["f_opt"] = f_min
results["incumbents"] = [inc for inc in bo.incumbents]
results["incumbent_values"] = [val for val in bo.incumbents_values]
results["runtime"] = bo.runtime
results["overhead"] = bo.time_overhead
return results
def build_optimizer(model,
maximizer="random",
acquisition_func="log_ei",
maximizer_seed=1):
"""
General interface for Bayesian optimization for global black box
optimization problems.
Parameters
----------
maximizer: {"random", "scipy", "differential_evolution"}
The optimizer for the acquisition function.
acquisition_func: {"ei", "log_ei", "lcb", "pi"}
The acquisition function
maximizer_seed: int
Seed for random number generator of the acquisition function maximizer
Returns
-------
Optimizer
"""
if acquisition_func == "ei":
a = EI(model)
elif acquisition_func == "log_ei":
a = LogEI(model)
elif acquisition_func == "pi":
a = PI(model)
elif acquisition_func == "lcb":
a = LCB(model)
else:
raise ValueError("'{}' is not a valid acquisition function".format(
acquisition_func))
if isinstance(model, GaussianProcessMCMC):
acquisition_func = MarginalizationGPMCMC(a)
else:
acquisition_func = a
maximizer_rng = numpy.random.RandomState(maximizer_seed)
if maximizer == "random":
max_func = RandomSampling(acquisition_func,
model.lower,
model.upper,
rng=maximizer_rng)
elif maximizer == "scipy":
max_func = SciPyOptimizer(acquisition_func,
model.lower,
model.upper,
rng=maximizer_rng)
elif maximizer == "differential_evolution":
max_func = DifferentialEvolution(acquisition_func,
model.lower,
model.upper,
rng=maximizer_rng)
else:
raise ValueError("'{}' is not a valid function to maximize the "
"acquisition function".format(maximizer))
# NOTE: Internal RNG of BO won't be used.
# NOTE: Nb of initial points won't be used within BO, but rather outside
bo = BayesianOptimization(lambda: None,
model.lower,
model.upper,
acquisition_func,
model,
max_func,
initial_points=None,
rng=None,
initial_design=init_latin_hypercube_sampling,
output_path=None)
return bo
from robo.task.rembo import REMBO
from robo.task.synthetic_functions.branin import Branin
from robo.models.gpy_model import GPyModel
from robo.maximizers.cmaes import CMAES
from robo.solver.bayesian_optimization import BayesianOptimization
from robo.acquisition.ei import EI
class BraninInBillionDims(REMBO):
def __init__(self):
self.b = Branin()
X_lower = np.concatenate((self.b.X_lower, np.zeros([999998])))
X_upper = np.concatenate((self.b.X_upper, np.ones([999998])))
super(BraninInBillionDims, self).__init__(X_lower, X_upper, d=2)
def objective_function(self, x):
return self.b.objective_function(x[:, :2])
task = BraninInBillionDims()
kernel = GPy.kern.Matern52(input_dim=task.n_dims)
model = GPyModel(kernel, optimize=True, num_restarts=10)
acquisition_func = EI(model, task.X_lower, task.X_upper)
maximizer = CMAES(acquisition_func, task.X_lower, task.X_upper)
bo = BayesianOptimization(acquisition_func=acquisition_func,
model=model,
maximize_func=maximizer,
task=task)
bo.run(500)
'''
import setup_logger
import GPy
from robo.models.gpy_model import GPyModel
from robo.acquisition.ei import EI
from robo.maximizers.cmaes import CMAES
from robo.task.synthetic_functions.branin import Branin
from robo.solver.bayesian_optimization import BayesianOptimization
branin = Branin()
kernel = GPy.kern.Matern52(input_dim=branin.n_dims)
model = GPyModel(kernel)
acquisition_func = EI(model,
X_upper=branin.X_upper,
X_lower=branin.X_lower,
par=0.1)
maximizer = CMAES(acquisition_func, branin.X_lower, branin.X_upper)
bo = BayesianOptimization(acquisition_func=acquisition_func,
model=model,
maximize_func=maximizer,
task=branin)
bo.run(10)
def __init__(self,
objective_func,
X_lower,
X_upper,
maximizer="direct",
acquisition="LogEI",
par=None,
n_func_evals=4000,
n_iters=500):
self.objective_func = objective_func
self.X_lower = X_lower
self.X_upper = X_upper
assert self.X_upper.shape[0] == self.X_lower.shape[0]
self.task = Task(self.X_lower, self.X_upper, self.objective_func)
cov_amp = 2
initial_ls = np.ones([self.task.n_dims])
exp_kernel = george.kernels.Matern32Kernel(initial_ls,
ndim=self.task.n_dims)
kernel = cov_amp * exp_kernel
#kernel = GPy.kern.Matern52(input_dim=task.n_dims)
prior = DefaultPrior(len(kernel) + 1)
n_hypers = 3 * len(kernel)
if n_hypers % 2 == 1:
n_hypers += 1
#self.model = GaussianProcessMCMC(kernel, prior=prior, n_hypers=n_hypers, chain_length=500, burnin_steps=100)
self.model = GaussianProcess(kernel,
prior=prior,
dim=self.X_lower.shape[0],
noise=1e-3)
#self.model = GPyModel(kernel)
#MAP ESTMIATE
if acquisition == "EI":
if par is not None:
self.a = EI(self.model,
X_upper=self.task.X_upper,
X_lower=self.task.X_lower,
par=par)
else:
self.a = EI(self.model,
X_upper=self.task.X_upper,
X_lower=self.task.X_lower)
elif acquisition == "LogEI":
if par is not None:
self.a = LogEI(self.model,
X_upper=self.task.X_upper,
X_lower=self.task.X_lower,
par=par)
else:
self.a = LogEI(self.model,
X_upper=self.task.X_upper,
X_lower=self.task.X_lower)
elif acquisition == "PI":
self.a = PI(self.model,
X_upper=self.task.X_upper,
X_lower=self.task.X_lower)
elif acquisition == "UCB":
if par is not None:
self.a = LCB(self.model,
X_upper=self.task.X_upper,
X_lower=self.task.X_lower,
par=par)
else:
self.a = LCB(self.model,
X_upper=self.task.X_upper,
X_lower=self.task.X_lower)
elif acquisition == "UCB_GP":
if par is not None:
self.a = LCB_GP(self.model,
X_upper=self.task.X_upper,
X_lower=self.task.X_lower,
par=par)
else:
self.a = LCB_GP(self.model,
X_upper=self.task.X_upper,
X_lower=self.task.X_lower)
elif acquisition == "InformationGain":
self.a = InformationGain(self.model,
X_upper=self.task.X_upper,
X_lower=self.task.X_lower)
elif acquisition == "InformationGainMC":
self.a = InformationGainMC(
self.model,
X_upper=self.task.X_upper,
X_lower=self.task.X_lower,
)
else:
logger.error("ERROR: %s is not a"
"valid acquisition function!" % (acquisition))
return None
#self.acquisition_func = IntegratedAcquisition(self.model, self.a, self.task.X_lower, self.task.X_upper)
self.acquisition_func = self.a
if maximizer == "cmaes":
self.max_fkt = cmaes.CMAES(self.acquisition_func,
self.task.X_lower, self.task.X_upper)
elif maximizer == "direct":
self.max_fkt = direct.Direct(
self.acquisition_func,
self.task.X_lower,
self.task.X_upper,
n_func_evals=n_func_evals,
n_iters=n_iters) #default is n_func_evals=400, n_iters=200
elif maximizer == "stochastic_local_search":
self.max_fkt = stochastic_local_search.StochasticLocalSearch(
self.acquisition_func, self.task.X_lower, self.task.X_upper)
elif maximizer == "grid_search":
self.max_fkt = grid_search.GridSearch(self.acquisition_func,
self.task.X_lower,
self.task.X_upper)
else:
logger.error("ERROR: %s is not a valid function"
"to maximize the acquisition function!" %
(acquisition))
return None
self.bo = BayesianOptimization(acquisition_func=self.acquisition_func,
model=self.model,
maximize_func=self.max_fkt,
task=self.task)
def fmin(objective_func,
X_lower,
X_upper,
num_iterations=30,
maximizer="direct",
acquisition="LogEI"):
assert X_upper.shape[0] == X_lower.shape[0]
class Task(BaseTask):
def __init__(self, X_lower, X_upper, objective_fkt):
super(Task, self).__init__(X_lower, X_upper)
self.objective_function = objective_fkt
task = Task(X_lower, X_upper, objective_func)
cov_amp = 2
initial_ls = np.ones([task.n_dims])
exp_kernel = george.kernels.Matern52Kernel(initial_ls,
ndim=task.n_dims)
kernel = cov_amp * exp_kernel
prior = DefaultPrior(len(kernel) + 1)
n_hypers = 3 * len(kernel)
if n_hypers % 2 == 1:
n_hypers += 1
model = GaussianProcessMCMC(kernel, prior=prior,
n_hypers=n_hypers,
chain_length=200,
burnin_steps=100)
if acquisition == "EI":
a = EI(model, X_upper=task.X_upper, X_lower=task.X_lower)
elif acquisition == "LogEI":
a = LogEI(model, X_upper=task.X_upper, X_lower=task.X_lower)
elif acquisition == "PI":
a = PI(model, X_upper=task.X_upper, X_lower=task.X_lower)
elif acquisition == "UCB":
a = LCB(model, X_upper=task.X_upper, X_lower=task.X_lower)
elif acquisition == "InformationGain":
a = InformationGain(model, X_upper=task.X_upper, X_lower=task.X_lower)
elif acquisition == "InformationGainMC":
a = InformationGainMC(model, X_upper=task.X_upper, X_lower=task.X_lower,)
else:
logger.error("ERROR: %s is not a"
"valid acquisition function!" % (acquisition))
return None
acquisition_func = IntegratedAcquisition(model, a,
task.X_lower,
task.X_upper)
if maximizer == "cmaes":
max_fkt = cmaes.CMAES(acquisition_func, task.X_lower, task.X_upper)
elif maximizer == "direct":
max_fkt = direct.Direct(acquisition_func, task.X_lower, task.X_upper)
elif maximizer == "stochastic_local_search":
max_fkt = stochastic_local_search.StochasticLocalSearch(acquisition_func,
task.X_lower,
task.X_upper)
elif maximizer == "grid_search":
max_fkt = grid_search.GridSearch(acquisition_func,
task.X_lower,
task.X_upper)
else:
logger.error(
"ERROR: %s is not a valid function"
"to maximize the acquisition function!" %
(acquisition))
return None
bo = BayesianOptimization(acquisition_func=acquisition_func,
model=model,
maximize_func=max_fkt,
task=task)
best_x, f_min = bo.run(num_iterations)
return task.retransform(best_x), f_min
n_hypers = 20
task = Branin()
cov_amp = 1.0
config_kernel = george.kernels.Matern52Kernel(np.ones([task.n_dims]),
ndim=task.n_dims)
kernel = cov_amp * config_kernel
prior = MyPrior(len(kernel) + 1)
model = GaussianProcessMCMC(kernel, prior=prior, burnin=burnin,
chain_length=chain_length, n_hypers=n_hypers)
ei = EI(model, X_upper=task.X_upper, X_lower=task.X_lower,)
acquisition_func = IntegratedAcquisition(model, ei,
task.X_lower, task.X_upper)
maximizer = Direct(acquisition_func, task.X_lower, task.X_upper)
bo = BayesianOptimization(acquisition_func=acquisition_func,
model=model,
maximize_func=maximizer,
task=task
)
bo.run(20)
def bayesian_optimization(objective_function,
lower,
upper,
num_iterations=30,
X_init=None,
Y_init=None,
maximizer="random",
acquisition_func="log_ei",
model_type="gp_mcmc",
n_init=3,
rng=None,
output_path=None,
kernel=None,
sampling_method="origin",
distance="cosine",
replacement=True,
pool=None,
best=None):
"""
General interface for Bayesian optimization for global black box
optimization problems.
Parameters
----------
objective_function: function
The objective function that is minimized. This function gets a numpy
array (D,) as input and returns the function value (scalar)
lower: np.ndarray (D,)
The lower bound of the search space
upper: np.ndarray (D,)
The upper bound of the search space
num_iterations: int
The number of iterations (initial design + BO)
X_init: np.ndarray(N,D)
Initial points to warmstart BO
Y_init: np.ndarray(N,1)
Function values of the already initial points
maximizer: {"random", "scipy", "differential_evolution"}
The optimizer for the acquisition function.
acquisition_func: {"ei", "log_ei", "lcb", "pi"}
The acquisition function
model_type: {"gp", "gp_mcmc", "rf", "bohamiann", "dngo"}
The model for the objective function.
n_init: int
Number of points for the initial design. Make sure that it
is <= num_iterations.
output_path: string
Specifies the path where the intermediate output after each iteration will be saved.
If None no output will be saved to disk.
rng: numpy.random.RandomState
Random number generator
kernel: george.kernels.ConstantKernel
{"constant", "polynomial", "linear", "dotproduct",
"exp", "expsquared", "matern32", "matern52", "rationalquadratic",
"cosine", "expsine2", "heuristic"}
Specify the kernel for Gaussian process.
sampling_method: {"origin", "approx", "exact"}
Specify the method to choose next sample to update model.
approx: choose the sample in the candidate pool that is closest (measured by distance
arg) to the one returned from maximizing acquisition function.
exact: evaluate all samples in the candidate pool on acquisition function
and choose the one with maximum output.
distance: {"cosine", "euclidean"}
The distance measurement for approximation sampling.
replacement: boolean
Whether to sample from pool with replacement.
pool: np.ndarray(N,D)
Candidate pool containing possible x
best: float
Stop training when the best point is sampled.
Returns
-------
dict with all results
"""
assert upper.shape[0] == lower.shape[0], "Dimension miss match"
assert np.all(lower < upper), "Lower bound >= upper bound"
assert n_init <= num_iterations, "Number of initial design point has to be <= than the number of iterations"
if rng is None:
rng = np.random.RandomState(np.random.randint(0, 10000))
cov_amp = 2
#n_dims = lower.shape[0]
#initial_ls = np.ones([n_dims])
# if kernel == "constant":
# exp_kernel = george.kernels.ConstantKernel(1, ndim=n_dims)
# elif kernel == "polynomial":
# exp_kernel = george.kernels.PolynomialKernel(log_sigma2=1, order=3, ndim=n_dims)
# elif kernel == "linear":
# exp_kernel = george.kernels.LinearKernel(log_gamma2=1, order=3, ndim=n_dims)
# elif kernel == "dotproduct":
# exp_kernel = george.kernels.DotProductKernel(ndim=n_dims)
# elif kernel == "exp":
# exp_kernel = george.kernels.ExpKernel(initial_ls, ndim=n_dims)
# elif kernel == "expsquared":
# exp_kernel = george.kernels.ExpSquaredKernel(initial_ls, ndim=n_dims)
# elif kernel == "matern32":
# exp_kernel = george.kernels.Matern32Kernel(initial_ls, ndim=n_dims)
# elif kernel == "matern52":
# exp_kernel = george.kernels.Matern52Kernel(initial_ls, ndim=n_dims)
# elif kernel == "rationalquadratic":
# exp_kernel = george.kernels.RationalQuadraticKernel(log_alpha=1, metric=initial_ls, ndim=n_dims)
# elif kernel == "cosine":
# exp_kernel = george.kernels.CosineKernel(4, ndim=n_dims)
# elif kernel == "expsine2":
# exp_kernel = george.kerngels.ExpSine2Kernel(1, 2, ndim=n_dims)
# elif kernel == "heuristic":
# exp_kernel = george.kernels.PythonKernel(heuristic_kernel_function, ndim=n_dims)
# else:
# raise ValueError("'{}' is not a valid kernel".format(kernel))
kernel = cov_amp * kernel
prior = DefaultPrior(len(kernel) + 1)
n_hypers = 3 * len(kernel)
if n_hypers % 2 == 1:
n_hypers += 1
if model_type == "gp":
model = GaussianProcess(kernel,
prior=prior,
rng=rng,
normalize_output=False,
normalize_input=True,
lower=lower,
upper=upper)
elif model_type == "gp_mcmc":
model = GaussianProcessMCMC(kernel,
prior=prior,
n_hypers=n_hypers,
chain_length=200,
burnin_steps=100,
normalize_input=True,
normalize_output=False,
rng=rng,
lower=lower,
upper=upper)
elif model_type == "rf":
model = RandomForest(rng=rng)
elif model_type == "bohamiann":
model = WrapperBohamiann()
elif model_type == "dngo":
model = DNGO()
else:
raise ValueError("'{}' is not a valid model".format(model_type))
if acquisition_func == "ei":
a = EI(model)
elif acquisition_func == "log_ei":
a = LogEI(model)
elif acquisition_func == "pi":
a = PI(model)
elif acquisition_func == "lcb":
a = LCB(model)
else:
raise ValueError("'{}' is not a valid acquisition function".format(
acquisition_func))
if model_type == "gp_mcmc":
acquisition_func = MarginalizationGPMCMC(a)
else:
acquisition_func = a
if maximizer == "random":
max_func = RandomSampling(acquisition_func, lower, upper, rng=rng)
elif maximizer == "scipy":
max_func = SciPyOptimizer(acquisition_func, lower, upper, rng=rng)
elif maximizer == "differential_evolution":
max_func = DifferentialEvolution(acquisition_func,
lower,
upper,
rng=rng)
else:
raise ValueError("'{}' is not a valid function to maximize the "
"acquisition function".format(maximizer))
if sampling_method == "exact":
max_func = ExactSampling(acquisition_func,
lower,
upper,
pool,
replacement,
rng=rng)
init_design = init_exact_random
elif sampling_method == "approx":
max_func = ApproxSampling(acquisition_func,
lower,
upper,
pool,
replacement,
distance,
rng=rng)
init_design = init_exact_random
else:
init_design = init_latin_hypercube_sampling
bo = BayesianOptimization(objective_function,
lower,
upper,
acquisition_func,
model,
max_func,
pool,
best,
sampling_method,
distance,
replacement,
initial_points=n_init,
rng=rng,
initial_design=init_design,
output_path=output_path)
x_best, f_min = bo.run(num_iterations, X=X_init, y=Y_init)
results = dict()
results["x_opt"] = x_best
results["f_opt"] = f_min
results["incumbents"] = [inc for inc in bo.incumbents]
results["incumbent_values"] = [val for val in bo.incumbents_values]
results["runtime"] = bo.runtime
results["overhead"] = bo.time_overhead
results["X"] = [x.tolist() for x in bo.X]
results["y"] = [y for y in bo.y]
return results
def entropy_search(objective_function, lower, upper, num_iterations=30,
maximizer="direct", model="gp_mcmc",
n_init=3, output_path=None, rng=None):
"""
Entropy search for global black box optimization problems. This is a reimplemenation of the entropy search
algorithm by Henning and Schuler[1].
[1] Entropy search for information-efficient global optimization.
P. Hennig and C. Schuler.
JMLR, (1), 2012.
Parameters
----------
objective_function: function
The objective function that is minimized. This function gets a numpy array (D,) as input and returns
the function value (scalar)
lower: np.ndarray (D,)
The lower bound of the search space
upper: np.ndarray (D,)
The upper bound of the search space
num_iterations: int
The number of iterations (initial design + BO)
maximizer: {"direct", "cmaes"}
Defines how the acquisition function is maximized. NOTE: "cmaes" only works in D > 1 dimensions
model: {"gp", "gp_mcmc"}
The model for the objective function.
n_init: int
Number of points for the initial design. Make sure that it is <= num_iterations.
output_path: string
Specifies the path where the intermediate output after each iteration will be saved.
If None no output will be saved to disk.
rng: numpy.random.RandomState
Random number generator
Returns
-------
dict with all results
"""
assert upper.shape[0] == lower.shape[0], "Dimension miss match"
assert np.all(lower < upper), "Lower bound >= upper bound"
assert n_init <= num_iterations, "Number of initial design point has to be <= than the number of iterations"
if rng is None:
rng = np.random.RandomState(np.random.randint(0, 10000))
cov_amp = 2
n_dims = lower.shape[0]
initial_ls = np.ones([n_dims])
exp_kernel = george.kernels.Matern52Kernel(initial_ls,
ndim=n_dims)
kernel = cov_amp * exp_kernel
prior = DefaultPrior(len(kernel) + 1)
n_hypers = 3 * len(kernel)
if n_hypers % 2 == 1:
n_hypers += 1
if model == "gp":
gp = GaussianProcess(kernel, prior=prior, rng=rng,
normalize_output=False, normalize_input=True,
lower=lower, upper=upper)
elif model == "gp_mcmc":
gp = GaussianProcessMCMC(kernel, prior=prior,
n_hypers=n_hypers,
chain_length=200,
burnin_steps=100,
normalize_input=True,
normalize_output=False,
rng=rng, lower=lower, upper=upper)
else:
print("ERROR: %s is not a valid model!" % model)
return
a = InformationGain(gp, lower=lower, upper=upper, sampling_acquisition=EI)
if model == "gp":
acquisition_func = a
elif model == "gp_mcmc":
acquisition_func = MarginalizationGPMCMC(a)
if maximizer == "cmaes":
max_func = CMAES(acquisition_func, lower, upper, verbose=False, rng=rng)
elif maximizer == "direct":
max_func = Direct(acquisition_func, lower, upper)
else:
print("ERROR: %s is not a valid function to maximize the acquisition function!" % maximizer)
return
bo = BayesianOptimization(objective_function, lower, upper, acquisition_func, gp, max_func,
initial_points=n_init, rng=rng, output_path=output_path)
x_best, f_min = bo.run(num_iterations)
results = dict()
results["x_opt"] = x_best
results["f_opt"] = f_min
results["incumbents"] = [inc for inc in bo.incumbents]
results["incumbent_values"] = [val for val in bo.incumbents_values]
results["runtime"] = bo.runtime
results["overhead"] = bo.time_overhead
results["X"] = [x.tolist() for x in bo.X]
results["y"] = [y for y in bo.y]
return results
from robo.acquisition.ei import EI
from robo.maximizers.direct import Direct
from robo.task.synthetic_functions.branin import Branin
from robo.solver.bayesian_optimization import BayesianOptimization
from robo.priors.default_priors import DefaultPrior
from robo.acquisition.integrated_acquisition import IntegratedAcquisition
task = Branin()
noise = 1.0
cov_amp = 2
exp_kernel = george.kernels.Matern52Kernel([1.0, 1.0], ndim=2)
kernel = cov_amp * exp_kernel
prior = DefaultPrior(len(kernel) + 1)
model = GaussianProcessMCMC(kernel, prior=prior,
chain_length=100, burnin_steps=200, n_hypers=20)
ei = EI(model, task.X_lower, task.X_upper)
acquisition_func = IntegratedAcquisition(model, ei, task.X_lower, task.X_upper)
maximizer = Direct(acquisition_func, task.X_lower, task.X_upper)
bo = BayesianOptimization(acquisition_func=acquisition_func,
model=model,
maximize_func=maximizer,
task=task)
print bo.run(10)
from robo.models.gaussian_process_mcmc import GaussianProcessMCMC
from robo.acquisition.ei import EI
from robo.maximizers.direct import Direct
from robo.task.controlling_tasks.walker import Walker
from robo.solver.bayesian_optimization import BayesianOptimization
from robo.priors.default_priors import DefaultPrior
from robo.acquisition.integrated_acquisition import IntegratedAcquisition
task = Walker()
test = '/test'
kernel = 1 * george.kernels.Matern52Kernel(np.ones([task.n_dims]),ndim=task.n_dims)
prior = DefaultPrior(len(kernel) + 1)
model = GaussianProcessMCMC(kernel, prior=prior,
chain_length=100, burnin_steps=200, n_hypers=8)
ei = EI(model, task.X_lower, task.X_upper)
acquisition_func = IntegratedAcquisition(model, ei, task.X_lower, task.X_upper)
maximizer = Direct(acquisition_func, task.X_lower, task.X_upper)
bo = BayesianOptimization(acquisition_func=acquisition_func,
model=model,
maximize_func=maximizer,
task=task,
save_dir = test)
print bo.run(2)
def fmin(objective_fkt,
X_lower,
X_upper,
num_iterations=30,
maximizer="direct",
acquisition_fkt="EI"):
assert X_upper.shape[0] == X_lower.shape[0]
class Task(BaseTask):
def __init__(self, X_lower, X_upper, objective_fkt):
super(Task, self).__init__(X_lower, X_upper)
self.objective_function = objective_fkt
task = Task(X_lower, X_upper, objective_fkt)
noise = 1.0
cov_amp = 2
initial_ls = np.ones([task.n_dims])
exp_kernel = george.kernels.Matern52Kernel(initial_ls,
ndim=task.n_dims)
noise_kernel = george.kernels.WhiteKernel(noise, ndim=task.n_dims)
kernel = cov_amp * (exp_kernel + noise_kernel)
prior = DefaultPrior(len(kernel))
model = GaussianProcessMCMC(kernel, prior=prior,
n_hypers=20,
chain_length=100,
burnin_steps=50)
if acquisition_fkt == "EI":
a = EI(model, X_upper=task.X_upper, X_lower=task.X_lower)
elif acquisition_fkt == "PI":
a = PI(model, X_upper=task.X_upper, X_lower=task.X_lower)
elif acquisition_fkt == "UCB":
a = LCB(model, X_upper=task.X_upper, X_lower=task.X_lower)
elif acquisition_fkt == "Entropy":
a = Entropy(model, X_upper=task.X_upper, X_lower=task.X_lower)
elif acquisition_fkt == "EntropyMC":
a = EntropyMC(model, X_upper=task.X_upper, X_lower=task.X_lower,)
else:
logger.error("ERROR: %s is not a"
"valid acquisition function!" % (acquisition_fkt))
return None
if maximizer == "cmaes":
max_fkt = cmaes.CMAES(a, task.X_lower, task.X_upper)
elif maximizer == "direct":
max_fkt = direct.Direct(a, task.X_lower, task.X_upper)
elif maximizer == "stochastic_local_search":
max_fkt = stochastic_local_search.StochasticLocalSearch(a,
task.X_lower,
task.X_upper)
elif maximizer == "grid_search":
max_fkt = grid_search.GridSearch(a, task.X_lower, task.X_upper)
else:
logger.error(
"ERROR: %s is not a valid function"
"to maximize the acquisition function!" %
(acquisition_fkt))
return None
bo = BayesianOptimization(acquisition_func=a,
model=model,
maximize_func=max_fkt,
task=task)
best_x, f_min = bo.run(num_iterations)
return best_x, f_min
@author: Aaron Klein
'''
import setup_logger
import GPy
from robo.models.gpy_model import GPyModel
from robo.acquisition.ei import EI
from robo.maximizers.cmaes import CMAES
from robo.task.synthetic_functions.branin import Branin
from robo.solver.bayesian_optimization import BayesianOptimization
branin = Branin()
kernel = GPy.kern.Matern52(input_dim=branin.n_dims)
model = GPyModel(kernel)
acquisition_func = EI(model,
X_upper=branin.X_upper,
X_lower=branin.X_lower,
par=0.1)
maximizer = CMAES(acquisition_func, branin.X_lower, branin.X_upper)
bo = BayesianOptimization(acquisition_func=acquisition_func,
model=model,
maximize_func=maximizer,
task=branin)
bo.run(10)
# the bounds of the input space
branin = Branin()
# Instantiate the random forest. Branin does not have any categorical
# values thus we pass a np.zero vector here.
model = RandomForest(branin.types)
# Define the acquisition function
acquisition_func = EI(model,
X_upper=branin.X_upper,
X_lower=branin.X_lower,
par=0.1)
# Strategy of estimating the incumbent
rec = PosteriorMeanAndStdOptimization(model,
branin.X_lower,
branin.X_upper,
with_gradients=False)
# Define the maximizer
maximizer = CMAES(acquisition_func, branin.X_lower, branin.X_upper)
# Now we defined everything we need to instantiate the solver
bo = BayesianOptimization(acquisition_func=acquisition_func,
model=model,
maximize_func=maximizer,
task=branin,
incumbent_estimation=rec)
bo.run(100)
''' Created on June 5th, 2016 @author: Numair Mansur ([email protected]) ''' import george from robo.maximizers.direct import Direct from robo.models.gaussian_process import GaussianProcess from robo.task.synthetic_functions.levy import Levy from robo.acquisition.ei import EI from robo.solver.bayesian_optimization import BayesianOptimization task = Levy() kernel = george.kernels.Matern52Kernel([1.0], ndim=1) model = GaussianProcess(kernel) ei = EI(model, task.X_lower, task.X_upper) maximizer = Direct(ei, task.X_lower, task.X_upper) bo = BayesianOptimization(acquisition_func=ei, model=model, maximize_func=maximizer, task=task, save_dir='../JsonDumps/') print bo.run(20)
def bohamiann(objective_function,
lower,
upper,
num_iterations=30,
maximizer="random",
acquisition_func="log_ei",
n_init=3,
output_path=None,
rng=None):
"""
Bohamiann uses Bayesian neural networks to model the objective function [1] inside Bayesian optimization.
Bayesian neural networks usually scale better with the number of function evaluations and the number of dimensions
than Gaussian processes.
[1] Bayesian optimization with robust Bayesian neural networks
J. T. Springenberg and A. Klein and S. Falkner and F. Hutter
Advances in Neural Information Processing Systems 29
Parameters
----------
objective_function: function
The objective function that is minimized. This function gets a numpy array (D,) as input and returns
the function value (scalar)
lower: np.ndarray (D,)
The lower bound of the search space
upper: np.ndarray (D,)
The upper bound of the search space
num_iterations: int
The number of iterations (initial design + BO)
acquisition_func: {"ei", "log_ei", "lcb", "pi"}
The acquisition function
maximizer: {"direct", "cmaes", "random", "scipy"}
The optimizer for the acquisition function. NOTE: "cmaes" only works in D > 1 dimensions
n_init: int
Number of points for the initial design. Make sure that it is <= num_iterations.
output_path: string
Specifies the path where the intermediate output after each iteration will be saved.
If None no output will be saved to disk.
rng: numpy.random.RandomState
Random number generator
Returns
-------
dict with all results
"""
assert upper.shape[0] == lower.shape[0]
assert n_init <= num_iterations, "Number of initial design point has to be <= than the number of iterations"
if rng is None:
rng = np.random.RandomState(np.random.randint(0, 10000))
model = BayesianNeuralNetwork(sampling_method="sghmc",
l_rate=np.sqrt(1e-4),
mdecay=0.05,
burn_in=3000,
n_iters=50000,
precondition=True,
normalize_input=True,
normalize_output=True)
if acquisition_func == "ei":
a = EI(model)
elif acquisition_func == "log_ei":
a = LogEI(model)
elif acquisition_func == "pi":
a = PI(model)
elif acquisition_func == "lcb":
a = LCB(model)
else:
print("ERROR: %s is not a valid acquisition function!" %
acquisition_func)
return
if maximizer == "cmaes":
max_func = CMAES(a, lower, upper, verbose=True, rng=rng)
elif maximizer == "direct":
max_func = Direct(a, lower, upper, verbose=True)
elif maximizer == "random":
max_func = RandomSampling(a, lower, upper, rng=rng)
elif maximizer == "scipy":
max_func = SciPyOptimizer(a, lower, upper, rng=rng)
bo = BayesianOptimization(objective_function,
lower,
upper,
a,
model,
max_func,
initial_points=n_init,
output_path=output_path,
rng=rng)
x_best, f_min = bo.run(num_iterations)
results = dict()
results["x_opt"] = x_best
results["f_opt"] = f_min
results["incumbents"] = [inc for inc in bo.incumbents]
results["incumbent_values"] = [val for val in bo.incumbents_values]
results["runtime"] = bo.runtime
results["overhead"] = bo.time_overhead
results["X"] = [x.tolist() for x in bo.X]
results["y"] = [y for y in bo.y]
return results
@author: Numair Mansur ([email protected]) ''' import george from robo.maximizers.direct import Direct from robo.models.gaussian_process import GaussianProcess from robo.task.synthetic_functions.levy import Levy from robo.acquisition.ei import EI from robo.solver.bayesian_optimization import BayesianOptimization task = Levy() kernel = george.kernels.Matern52Kernel([1.0], ndim=1) model = GaussianProcess(kernel) ei = EI(model, task.X_lower, task.X_upper) maximizer = Direct(ei, task.X_lower, task.X_upper) bo = BayesianOptimization(acquisition_func=ei, model=model, maximize_func=maximizer, task=task ,save_dir='../JsonDumps/' ) print bo.run(20)
