def setUp(self):
self.X_lower = np.array([0])
self.X_upper = np.array([1])
self.X = init_random_uniform(self.X_lower, self.X_upper, 10)
self.Y = np.sin(self.X)
self.kernel = GPy.kern.RBF(input_dim=1)
self.model = GPyModel(self.kernel)
self.model.train(self.X, self.Y)
self.ei = EI(self.model, X_upper=self.X_upper, X_lower=self.X_lower)
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 setUp(self):
self.X_lower = np.array([0])
self.X_upper = np.array([6])
self.dims = 1
self.X = np.array([[1], [3.8], [0.9], [5.2], [3.4]])
self.X[:, 0] = self.X[:, 0].dot(self.X_upper[0] - self.X_lower[0]) + self.X_lower[0]
self.Y = objective_function(self.X)
kernel = GPy.kern.Matern52(input_dim=self.dims)
self.model = GPyModel(kernel, optimize=True,
noise_variance=1e-4, num_restarts=10)
self.model.train(self.X, self.Y)
self.acquisition_func = EI(self.model, X_upper=self.X_upper,
X_lower=self.X_lower,
par=0.1)
def setUp(self):
self.branin = Branin()
n_points = 5
rng = np.random.RandomState(42)
self.X = init_random_uniform(self.branin.X_lower,
self.branin.X_upper,
n_points,
rng=rng)
self.Y = self.branin.evaluate(self.X)
kernel = GPy.kern.Matern52(input_dim=self.branin.n_dims)
self.model = GPyModel(kernel,
optimize=True,
noise_variance=1e-4,
num_restarts=10)
self.model.train(self.X, self.Y)
self.acquisition_func = EI(self.model,
X_upper=self.branin.X_upper,
X_lower=self.branin.X_lower,
par=0.1)
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 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
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
from robo.maximizers.cmaes import CMAES
from robo.task.synthetic_functions.branin import Branin
from robo.solver.bayesian_optimization import BayesianOptimization
from robo.incumbent.posterior_optimization import PosteriorMeanAndStdOptimization
# 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,
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 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
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)
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)
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
