def learn_flow(X, y, lengthscales, variance=1.0):
dimensions = X.shape[1]
# lengthscales = [ l_scale for d in range(dimensions)]
kernel = GPy.kern.rbf(dimensions,
ARD=True,
lengthscale=lengthscales,
variance=variance)
m = GPRegression(X, y, kernel)
m.optimize('bfgs', max_iters=1000)
return m
def __init__(self,
x0,
y0,
cons=None,
alpha=opt.ke_alpha,
beta=opt.ke_beta,
input_size=opt.ke_input_size,
hidden_size=opt.ke_hidden_size,
num_layers=opt.ke_num_layers,
bidirectional=opt.ke_bidirectional,
lr=opt.ke_lr,
weight_decay=opt.ke_weight_decay):
super(Kernel, self).__init__()
self.alpha = alpha
self.beta = beta
self.lstm = nn.LSTM(input_size=input_size,
hidden_size=hidden_size,
num_layers=num_layers,
bidirectional=bidirectional)
self.lstm = self.lstm.to(opt.device)
self.input_size = input_size
self.hidden_size = hidden_size
self.num_layers = num_layers
self.bidirectional = bidirectional
self.bi = 2 if bidirectional else 1
self.x = [x0]
self.y = torch.tensor([y0],
dtype=torch.float,
device=opt.device,
requires_grad=False)
self.cons = [cons]
inp, out = clean_x(self.x, self.cons)
self.model = GPRegression(inp, out)
self.model.Gaussian_noise.constrain_fixed(1e-6, warning=False)
self.model.optimize()
self.x_best = x0
self.y_best = y0
self.i_best = 0
self.n = 1
self.E = self.embedding(x0).view(1, -1)
self.K = self.kernel(self.E[0], self.E[0]).view(1, 1)
self.K_inv = torch.inverse(self.K + self.beta *
torch.eye(self.n, device=opt.device))
self.optimizer = optim.Adam(self.lstm.parameters(),
lr=lr,
weight_decay=weight_decay)
def fit_GPy_kern(X, Y, kernel, restarts, score = BIC, **kwargs):
if len(np.shape(X)) == 1: X = np.array(X)[:, None]
if len(np.shape(Y)) == 1: Y = np.array(Y)[:, None]
m = GPRegression(X, Y, kernel)
m.optimize_restarts(num_restarts = restarts, **kwargs)
m.plot()
print(m.kern)
print(f'Log-Likelihood: {m.log_likelihood()}')
print(f'{score.__name__}: {score(m.log_likelihood(), len(X), m._size_transformed())}')
plt.show()
return m
def from_model_params(gp_config: GPConfig, model_params: ModelParameters,
X, Y) -> "GPyModel":
kernel = GPyModel.create_kernel(model_params.kernel,
X.shape[1],
ARD=gp_config.ard)
model = GPRegression(X, Y, kernel=kernel, normalizer=len(X) > 1)
for name, value in model_params.params.items():
model[name] = value
acquisition_fn = GPyModel.parse_acquisition_fn(
model_params.acquisition_fn)
return GPyModel(model, acquisition_fn)
def _fit_model(self, X, Y):
if max(Y) < 0:
self.transformed = True
else:
self.transformed = False
Y_trans = self._transform_score(Y)
model = GPRegression(X, Y_trans, self.kernel)
# Catch fitting error
try:
model.optimize_restarts(num_restarts=self.n_init, verbose=False)
self.model = model
except np.linalg.linalg.LinAlgError:
self.model = None
def rmse_rbf(x_train: np.ndarray, y_train: np.ndarray, x_test: np.ndarray,
y_test: np.ndarray) -> float:
"""RMSE of a GPy RBF kernel.
:param x_train:
:param y_train:
:param x_test:
:param y_test:
:return:
"""
model = GPRegression(x_train,
y_train,
kernel=RBF(input_dim=x_train.shape[1]))
model.optimize()
return compute_gpy_model_rmse(model, x_test, y_test)
def _create_model(self,
x: np.ndarray,
y: np.ndarray):
"""Create model given input data X and output data Y.
:param x: 2d array of indices of distance builder
:param y: model fitness scores
:return:
"""
# Make sure input data consists only of positive integers.
assert np.issubdtype(x.dtype, np.integer) and x.min() >= 0
# Define kernel
self.input_dim = x.shape[1]
# TODO: figure out default kernel kernel initialization
if self.covariance is None:
assert self.covariance is not None
# kern = GPy.kern.RBF(self.input_dim, variance=1.)
else:
kern = self.covariance.raw_kernel
self.covariance = None
# Define model
noise_var = y.var() * 0.01 if self.noise_var is None else self.noise_var
normalize = x.size > 1 # only normalize if more than 1 observation.
self.model = GPRegression(x, y, kern, noise_var=noise_var, normalizer=normalize)
# Set hyperpriors
if self.kernel_hyperpriors is not None:
if 'GP' in self.kernel_hyperpriors:
# Set likelihood hyperpriors.
likelihood_hyperprior = self.kernel_hyperpriors['GP']
set_priors(self.model.likelihood, likelihood_hyperprior, in_place=True)
if 'SE' in self.kernel_hyperpriors:
# Set kernel hyperpriors.
se_hyperprior = self.kernel_hyperpriors['SE']
set_priors(self.model.kern, se_hyperprior, in_place=True)
# Restrict variance if exact evaluations of the objective.
if self.exact_f_eval:
self.model.Gaussian_noise.constrain_fixed(1e-6, warning=False)
else:
# --- We make sure we do not get ridiculously small residual noise variance
if self.model.priors.size > 0:
# FIXME: shouldn't need this case, but GPy doesn't have log Jacobian implemented for Logistic
self.model.Gaussian_noise.constrain_positive(warning=False)
else:
self.model.Gaussian_noise.constrain_bounded(1e-9, 1e6, warning=False)
def predict(self, X):
"""
Predicts the conditional expectation $E[Y \mid X=x]$ for all x in $X$.
:param X: a numpy array of shape (num_predictions, num_dimensions)
:return: a numpy array of shape (num_predictions,)
"""
self._calculate_locregs()
self.gpr_ = GPRegression(self.x_mesh_,
np.atleast_2d(self.y_mesh_).T,
self.gpr_kernel)
self.gpr_.optimize(messages=False)
#self.gpr_.optimize_restarts(num_restarts = 10)
y_pred, self.gp_var_ = self.gpr_.predict(X)
self.gp_var_ = self.gp_var_.squeeze()
return y_pred.squeeze()
def test_add_training_data():
Xadd = np.array([11, 12]).reshape(-1, 1)
yadd = np.array([9, 10]).reshape(-1, 1)
Xfull = np.concatenate([Xtrain, Xadd])
yfull = np.concatenate([ytrain, yadd])
for label in ('Custom', 'GPy', 'Sklearn'):
sur = Surrogate[label]()
sur.Xtrain = Xtrain
sur.ytrain = ytrain
if label == 'GPy':
from GPy.models import GPRegression
sur.model = GPRegression(Xtrain, ytrain)
sur.add_training_data(Xadd, yadd)
assert np.all(sur.Xtrain == Xfull)
assert np.all(sur.ytrain == yfull)
if label == 'GPy':
assert np.all(sur.model.X == Xfull)
assert np.all(sur.model.Y == yfull)
def optimize_s_sn_l(self, sn, s, l):
assert (isinstance(sn, float))
assert (l.shape == (self.fix_W.shape[1], ))
# Create a GP
self.kernel.update_params(W=self.fix_W, s=s, l=l)
# TODO:
gp_reg = GPRegression(
self.X,
self.Y.reshape(-1, 1),
self.kernel,
noise_var=config['std_noise_var']) # config['std_noise_var']
gp_reg['Gaussian_noise.variance'].fix()
try:
gp_reg.optimize(
optimizer="lbfgs", max_iters=1
) # lbfgs # config['max_iter_parameter_optimization'])
except Exception as e:
print(e)
print(gp_reg.kern.K(gp_reg.X))
print("Error above!")
# TODO: does this optimization work in the correct direction?
new_variance = gp_reg.kern.inner_kernel.variance
new_lengthscale = gp_reg.kern.inner_kernel.lengthscale
new_sn = gp_reg['Gaussian_noise.variance']
# print("New values: ")
# print("variance")
# print(new_variance)
# print("lengthscales")
# print(new_lengthscale)
# print("variances")
# print(new_sn)
#
# exit(0)
assert gp_reg.kern.inner_kernel.lengthscale is not None
assert gp_reg.kern.inner_kernel.variance is not None
# assert not np.isclose(np.asarray(new_lengthscale), np.zeros_like(new_lengthscale) ).all(), new_lengthscale
return float(new_variance), new_lengthscale.copy(), float(new_sn)
def check_jacobian(self):
try:
import autograd.numpy as np, autograd as ag, GPy, matplotlib.pyplot as plt
from GPy.models import GradientChecker, GPRegression
except:
raise self.skipTest("autograd not available to check gradients")
def k(X, X2, alpha=1., lengthscale=None):
if lengthscale is None:
lengthscale = np.ones(X.shape[1])
exp = 0.
for q in range(X.shape[1]):
exp += ((X[:, [q]] - X2[:, [q]].T)/lengthscale[q])**2
#exp = np.sqrt(exp)
return alpha * np.exp(-.5*exp)
dk = ag.elementwise_grad(lambda x, x2: k(x, x2, alpha=ke.variance.values, lengthscale=ke.lengthscale.values))
dkdk = ag.elementwise_grad(dk, argnum=1)
ke = GPy.kern.RBF(1, ARD=True)
#ke.randomize()
ke.variance = .2#.randomize()
ke.lengthscale[:] = .5
ke.randomize()
X = np.linspace(-1, 1, 1000)[:,None]
X2 = np.array([[0.]]).T
np.testing.assert_allclose(ke.gradients_X([[1.]], X, X), dk(X, X))
np.testing.assert_allclose(ke.gradients_XX([[1.]], X, X).sum(0), dkdk(X, X))
np.testing.assert_allclose(ke.gradients_X([[1.]], X, X2), dk(X, X2))
np.testing.assert_allclose(ke.gradients_XX([[1.]], X, X2).sum(0), dkdk(X, X2))
m = GPRegression(self.X, self.Y)
def f(x):
m.X[:] = x
return m.log_likelihood()
def df(x):
m.X[:] = x
return m.kern.gradients_X(m.grad_dict['dL_dK'], X)
def ddf(x):
m.X[:] = x
return m.kern.gradients_XX(m.grad_dict['dL_dK'], X).sum(0)
gc = GradientChecker(f, df, self.X)
gc2 = GradientChecker(df, ddf, self.X)
assert(gc.checkgrad())
assert(gc2.checkgrad())
def _create_model(self, X, y):
"""
Creates the GPy model given some input data X and Y.
"""
# Define kernel
input_dim = X.shape[1]
if self._kernel is None:
kern = GPy.kern.Matern52(input_dim, variance=1., ARD=self._ARD)
else:
kern = self._kernel
self._kernel = None
# Define model
noise_var = y.var() * 0.01
if not self._sparse:
self.model = GPRegression(X, y, kernel=kern, noise_var=noise_var)
else:
self.model = SparseGPRegression(X, y, kernel=kern,
num_inducing=self._num_inducing)
self.model.Gaussian_noise.constrain_bounded(1e-9, 1e6, warning=False)
def fit(self,
restarts=None,
optimiser='lbfgsb',
verbose=False,
robust=False,
**kwargs):
if restarts is None:
if self.restarts is None:
raise ValueError('No restarts value specified')
else:
self.restarts = restarts
self.model = GPRegression(self.X, self.Y,
self.kernel_expression.to_kernel())
with warnings.catch_warnings(): # Ignore known numerical warnings
warnings.simplefilter('ignore')
self.model.optimize_restarts(num_restarts=self.restarts,
verbose=verbose,
robust=robust,
optimizer=optimiser,
**kwargs)
return self
def _fit(self, X, y, ECM=None):
self._X = X
self._y = y
kern_dict = {
'm32':
Matern32(input_dim=self._X.shape[1],
active_dims=list(range(self._X.shape[1])),
ARD=True),
'm52':
Matern52(input_dim=self._X.shape[1],
active_dims=list(range(self._X.shape[1])),
ARD=True),
'rbf':
RBF(input_dim=self._X.shape[1],
active_dims=list(range(self._X.shape[1])),
ARD=True)
}
self.__model = GPRegression(X, y, kern_dict[self.__kernel_name])
self.__model.optimize_restarts(self.__n_restarts,
verbose=self._verbose)
return self
def build_model(self, params, nrestarts=10, maxit=1000, seed=0):
print("Hyperparameters: ", params)
self.split_train_test(params)
np.random.seed(
seed) # make GPy deterministic for a given hyperparameter config
dim = self.X.shape[1]
if self.input_obj.keywords['gp_ard'] == 'opt':
ard_val = params['ARD']
elif self.input_obj.keywords['gp_ard'] == 'true':
ard_val = True
else:
ard_val = False
kernel = RBF(dim, ARD=ard_val) # TODO add HP control of kernel
self.model = GPRegression(self.Xtr,
self.ytr,
kernel=kernel,
normalizer=False)
self.model.optimize_restarts(nrestarts,
optimizer="lbfgsb",
robust=True,
verbose=False,
max_iters=maxit,
messages=False)
gc.collect(2) #fixes some memory leak issues with certain BLAS configs
def __fit_single_gaussian_process(variable, response_norm, num_restarts=7):
"""
GP fitting.
Returns the GP and kernel.
:param variable: time
:param response_norm: log-normalized target
:return [tuple] a tuple:
- the gp object
- the kernel
"""
obs_per_replicate = response_norm.shape[1]
kernel = RBF(input_dim=1, variance=1., lengthscale=10.)
variable = np.tile(variable, (response_norm.shape[0], 1))
response = np.resize(
response_norm,
(response_norm.shape[0] * response_norm.shape[1], 1))
gp = GPRegression(variable, response, kernel)
gp.optimize_restarts(num_restarts=num_restarts, messages=False)
return gp, kernel
n_samples = 5
parameter_space = ParameterSpace([ContinuousParameter('x1', 0., 157.)])
# parameter_space = ParameterSpace(
# [ContinuousParameter('x1', 0., 157.), ContinuousParameter('x2', 0., 157.), ContinuousParameter('x3', 0., 157.),
# ContinuousParameter('x4', 0., 157.), ContinuousParameter('x5', 0., 157.), ContinuousParameter('x6', 0., 5999.),
# ContinuousParameter('x7', 0., 999.), ContinuousParameter('x8', 0., 699.)])
latin_design = LatinDesign(parameter_space=parameter_space)
X0 = latin_design.get_samples(n_samples)
Y0 = training_function(X0)
#D0 = ((Y0 - target)**2).sum(axis=1)
#plotter = BayesOptPlotter(h_noiseless, target, xmin, xmax, X0=X0, Y0=Y0)
model = GPRegression(X0, Y0)
model_wrapped = GPyModelWrapper(model)
target = user_sample_vector
acq = L2_LCB(model=model_wrapped, target=target)
fit_update = lambda a, b: model.optimize_restarts(verbose=False)
bayesopt_loop = BayesianOptimizationLoop(model=model_wrapped,
space=parameter_space,
acquisition=acq)
bayesopt_loop.iteration_end_event.append(fit_update)
bayesopt_loop.run_loop(training_function, 5)
# 5. train and wrap the model in Emukit
# model_gpy = GPRegression(X, Y, normalizer=True)
#
# model_emukit = GPyModelWrapper(model_gpy)
def main():
print("######################")
global target, X0, Y0, values, frac_M, frac_X, bo_flag
#target_params = np.array([[0.14,0.4],[1.4,0.03]])
#target = LiX_wrapper(True,'LiF','Rocksalt','JC',
# target_params,False,False,eng)
target = np.array([[-764.5, 6.012 * 0.99, 6.012 * 0.99, 6.012 * 0.99]])
if focus == 'energy':
target_comp = target[0, 0].reshape(1, -1)
if focus == 'constant':
target_comp = target[0, 1].reshape(1, -1)
else:
target_comp = target[0, :4].reshape(1, -1)
print('Target initialized!')
latin_design = LatinDesign(parameter_space=parameter_space)
X0 = latin_design.get_samples(INIT_POINTS)
Y0 = np.array([])
for x in X0:
x = np.array([x])
Y0 = np.append(Y0, f.evaluate(x))
values = []
for y in Y0:
values.append(y.Y)
values = np.asarray(values, dtype=float)
### Redundancy check
if (values[:, 7:-1] == values[0, 7]).all():
values = values[:, :7]
frac_X = False
if (values[:, 4:7] == values[0, 4]).all():
values = values[:, :4]
frac_M = False
values = values.reshape(-1, np.max(np.shape(target)))
bo_flag = True
if focus == 'energy':
values = values[:, 0].reshape(-1, 1)
if focus == 'constant':
values = values[:, 1:4].reshape(-1, 3)
### BO Loop
kern = Matern52(X0.shape[1], variance=1)
model = GPRegression(X0,
values,
kernel=kern,
normalizer=True,
noise_var=NOISE) # Kernel = None: RBF default
model.optimize(optimizer='lbfgsb')
model.optimize_restarts(num_restarts=50, verbose=False)
model_wrapped = GPyModelWrapper(model)
acq = L2_LCB(model=model_wrapped, target=target_comp, beta=np.float64(1.))
# beta is the exploration constant
bayesopt_loop = BayesianOptimizationLoop(model=model_wrapped,
space=parameter_space,
acquisition=acq)
bayesopt_loop.run_loop(f, BO_ITER)
return save(bayesopt_loop)
PPO_totalR = []
EI_totalR = []
PI_totalR = []
for ep in range(30):
fun = env.reset(upper_bound=1, lower_bound=0)
ppo.ppoMax = 0
ppoMin = float('inf')
ppo.ep_r = 0
ppo.funCurMax = env.maxVal
ppo.curFun = env.getCurFun()
design = RandomDesign(parameter_space) # Collect random points
X = design.get_samples(num_data_points)
Y = fun(X)
model_gpy = GPRegression(X, Y) # Train and wrap the model in Emukit
model_emukit = GPyModelWrapper(model_gpy)
ppo.model = model_emukit
bo = BayesianOptimizationLoop(model=model_emukit,
space=parameter_space,
acquisition=ppo,
batch_size=1)
mu = np.array([np.mean(bo.loop_state.X)])[np.newaxis]
var = np.array([np.var(bo.loop_state.X)])[np.newaxis]
s = np.concatenate((mu, var), axis=1)
boPPOep_r = []
model_gpyEI = GPRegression(X, Y) # Train and wrap the model in Emukit
model_emukitEI = GPyModelWrapper(model_gpyEI)
boEI = BayesianOptimizationLoop(model=model_emukitEI,
space=parameter_space,
noise = 0.1 #################### # Noise free training data X_train = np.array([-4, -3, -2, -1, 3]).reshape(-1, 1) Y_train = np.sin(X_train) rbf = RBF(input_dim=1, variance=1.0, lengthscale=1.0) brownian = Brownian(input_dim=1, variance=1.0) periodic = PeriodicExponential(input_dim=1, variance=2.0, n_freq=100) cosine = Cosine(input_dim=1, variance=2) exponential = Exponential(input_dim=1, variance=2.0) integral = Integral(input_dim=1, variances=2.0) matern = Matern32(input_dim=1, variance=2.0) gpr = GPRegression(X_train, Y_train, matern) # Fix the noise variance to known value gpr.Gaussian_noise.variance = noise**2 gpr.Gaussian_noise.variance.fix() # Run optimization ret = gpr.optimize() print(ret) # Display optimized parameter values print(gpr) # Obtain optimized kernel parameters #l = gpr.rbf.lengthscale.values[0] #sigma_f = np.sqrt(gpr.rbf.variance.values[0])
return self.variance * K.diagonal()
def update_gradients_full(self, dL_dK, X, X2=None):
if X2 is None:
X2 = X
Xind = np.asarray(X, dtype=int).flatten()
X2ind = np.asarray(X2, dtype=int).flatten()
K = self.string_kernel[Xind][:, X2ind]
self.variance.gradient = np.einsum("ij,ij", dL_dK, K)
def update_gradients_diag(self, dL_dKdiag, X):
Xind = np.asarray(X, dtype=int).flatten()
K = self.string_kernel[Xind][:, Xind]
self.variance.gradient = np.einsum("i,i", dL_dKdiag, K)
if __name__ == "__main__":
x1 = "ATCGATCG"
x2 = "ATCGATCG"
x3 = "ATCGATCC"
x4 = "ATCGATAA"
x5 = "ANNNNNNN"
X = np.arange(5)[:, None]
y = np.random.randn(5, 1)
kern = WeightedDegree(1, np.array([x1, x2, x3, x4, x5]))
m = GPRegression(X, y, kernel=kern)
def model():
x_init = np.random.rand(5, 2)
y_init = np.random.rand(5, 1)
model = GPRegression(x_init, y_init, RBF(2))
return GPyModelWrapper(model)
from deepgp_gpy.utils import posterior_sample
from deepgp import DeepGP
from visualization import plot_gp, model_output, pred_range, visualize_pinball
data = pods.datasets.olympic_marathon_men()
x = data['X']
y = data['Y']
offset = np.mean(y)
scale = np.sqrt(np.var(y))
xlim = (1875, 2030)
ylim = (2.5, 6.5)
yhat = (y - offset) / scale
gp_regression = GPRegression(x, yhat)
gp_regression.optimize()
model_output(gp_regression)
###################deep gp
hidden = 1
dgp = DeepGP(
[y.shape[1], hidden, x.shape[1]],
Y=yhat,
X=x,
inits=['PCA', 'PCA'],
kernels=[RBF(hidden, ARD=True),
RBF(x.shape[1], ARD=True)], # the kernels for each layer
num_inducing=50,
back_constraint=False)
def acquisition():
rng = np.random.RandomState(42)
x_init = rng.rand(5, 2)
y_init = rng.rand(5, 1)
model = GPRegression(x_init, y_init, RBF(2))
return ProbabilityOfImprovement(GPyModelWrapper(model))
x_half = int(N / 2)
X[:x_half, :] = np.linspace(0, 2,
x_half)[:,
None] # First cluster of inputs/covariates
X[x_half:, :] = np.linspace(
8, 10, x_half)[:, None] # Second cluster of inputs/covariates
rbf = RBF(input_dim=1)
mu = np.zeros(N)
cov = rbf.K(X) + np.eye(N) * np.sqrt(noise_var)
y = np.random.multivariate_normal(mu, cov).reshape(-1, 1)
# plt.scatter(X, y)
# plt.show()
gp_regression = GPRegression(X, y)
gp_regression.optimize(messages=True)
log_likelihood1 = gp_regression.log_likelihood()
model_output(gp_regression,
title="GP Regression with loglikelihood: " + str(log_likelihood1))
#################################
# inducing variables, u. Each inducing variable has its own associated input index, Z, which lives in the same space as X.
Z = np.hstack((np.linspace(2.5, 4., 3), np.linspace(7, 8.5, 3)))[:, None]
sparse_regression = SparseGPRegression(X, y, kernel=rbf, Z=Z)
sparse_regression.noise_var = noise_var
sparse_regression.inducing_inputs.constrain_fixed()
def fit_gaussian_processes(self, control=None, num_restarts=7):
"""
This is the new version, which fits only on the `relevant' interval
Fits a GP for both the control and case growth curves,
H1 with time and treatment, and H0 with only time.
:param control If None, then just fits one GP - else, fits 3 different GPs
(one for case, two for gp_h0 and gp_h1):
:param num_restarts The number of restarts in the optimisation:
:return [None] creates the GP objects:
"""
logger.info("Fitting Gaussian processes for " + self.name)
# control for number of measurements per replicate if time not same length
# self.response_norm.shape[0] is num replicates, [1] is num measurements
## TODO:: Can we remove this line?
obs_per_replicate = self.response_norm.shape[1]
print("Now attempting to fit:")
print("self.name:")
print(self.name)
print("Self.source_id:")
print(self.source_id)
self.gp_kernel = RBF(input_dim=1, variance=1., lengthscale=10.)
response_norm_trunc = self.response_norm[:, self.
variable_treatment_start_index:
self.
variable_treatment_end_index]
# # Determine index of first mouse death to remove all NaNs before fitting the model
# first_death_idx = min(np.sum(~np.isnan(response_norm_trunc), axis=1))
#
# # Subset the independent variable and response data
# response_norm_trunc = response_norm_trunc[:, 0:first_death_idx]
# variable_trunc = self.variable[0:first_death_idx, :]
# Reshape the data to pass into GPRegression (flatten into a single column)
variable = np.tile(
self.variable[self.variable_treatment_start_index:self.
variable_treatment_end_index],
(len(self.replicates), 1))
response = np.resize(
response_norm_trunc,
(response_norm_trunc.shape[0] * response_norm_trunc.shape[1], 1))
self.gp = GPRegression(variable, response, self.gp_kernel)
self.gp.optimize_restarts(num_restarts=num_restarts, messages=False)
if control is not None:
# Subset full data for control calculations
# self.full_data = self.full_data[np.isin(self.full_data[:, 0], variable_trunc), :]
# kernels
self.gp_h0_kernel = RBF(input_dim=1, variance=1., lengthscale=10.)
self.gp_h1_kernel = RBF(input_dim=2, variance=1., ARD=True)
# GPs
self.gp_h0 = GPRegression(self.full_data[:, 0:1],
self.full_data[:,
2:3], self.gp_h0_kernel)
self.gp_h1 = GPRegression(self.full_data[:, 0:2],
self.full_data[:,
2:3], self.gp_h1_kernel)
# optimize GPs
self.gp_h0.optimize_restarts(num_restarts=num_restarts,
messages=False,
robust=True) # silent exceptions
self.gp_h1.optimize_restarts(num_restarts=num_restarts,
messages=False,
robust=True)
self.delta_log_likelihood_h0_h1 = self.gp_h1.log_likelihood(
) - self.gp_h0.log_likelihood()
return mu[0, 0], var[0, 0]
else:
mu, _ = model.predict(x_new)
return mu[0, 0]
list_mse_gpr = []
list_mse_lgb = []
list_mse_svr = []
for i in range(1):
print(i)
x_train_m, y_train_m = a_gpr.sample_point(x_train, y_train, iter=80)
k_rbf = RBF(input_dim=n, variance=0.5, lengthscale=1)
gp_model = GPRegression(x_train_m,
np.reshape(y_train_m, (-1, 1)),
kernel=k_rbf)
gp_model.optimize(messages=False)
model_lgb = lgb.LGBMRegressor()
model_lgb.fit(x_train_m, y_train_m)
model_svr = SVR()
model_svr.fit(x_train_m, y_train_m)
y_pre_con = [
pre_gp_mu_var(np.reshape(x_test[i], (1, -1)), gp_model)
for i in range(np.shape(x_test)[0])
]
y_pre_lgb = [
model_lgb.predict(np.reshape(x_test[i], (1, -1)))
'''
data = pods.datasets.della_gatta_TRP63_gene_expression(data_set='della_gatta',
gene_number=937)
x = data['X']
y = data['Y']
offset = np.mean(y)
scale = np.sqrt(np.var(y))
yhat = (y - offset) / scale
#kernel = RBF(input_dim=1, variance=100)
#kernel = Matern32(input_dim=1, variance=2.0, lengthscale=200)
model = GPRegression(x, yhat)
model.kern.lengthscale = 20 #this will widen with 100, 200
#gp_regression.likelihood.variance = 0.001
print(model.log_likelihood())
model.optimize()
print(model.log_likelihood())
xt = np.linspace(-20, 260, 100)[:, np.newaxis]
yt_mean, yt_var = model.predict(xt)
plot_gp(yt_mean,
yt_var,
xt,
X_train=model.X.flatten(),
Y_train=model.Y.flatten())
for g in range(len(l_ind)):
# Check that resonator geometry is sensible:
if l_ind[g] > l_cap[g]/2:
out[g,0] = 10e20 #Large cost to bad geometry
else:
out[g,0] = -simulation_wrapper(host, COMSOL_model, paramfile, w[g], t, l_ind[g], pen, omega, gap_cap[g], w_cap[g], l_cap[g], w_mesa, h_mesa, gap_ind[g])[0]
return out
# Set up random seeding of parameter space
num_data_points = no_random_seeds
design = RandomDesign(parameter_space)
X = design.get_samples(num_data_points)
Y = q(X)
# Set up emukit model
model_gpy = GPRegression(X,Y)
model_gpy.optimize()
model_emukit = GPyModelWrapper(model_gpy)
# Set up Bayesian optimisation routine
exp_imprv = ExpectedImprovement(model = model_emukit)
optimizer = GradientAcquisitionOptimizer(space = parameter_space)
point_calc = SequentialPointCalculator(exp_imprv,optimizer)
# Bayesian optimisation routine
bayesopt_loop = BayesianOptimizationLoop(model = model_emukit,
space = parameter_space,
acquisition=exp_imprv,
batch_size=1)
stopping_condition = FixedIterationsStoppingCondition(i_max = no_BO_sims)
init_design = RandomDesign(space)
X_init = init_design.get_samples(2)
Y_init = np.array([b.objective_function(xi)["function_value"] for xi in X_init])[:, None]
if args.model_type == "bnn":
model = Bohamiann(X_init=X_init, Y_init=Y_init, verbose=True)
elif args.model_type == "rf":
model = RandomForest(X_init=X_init, Y_init=Y_init)
with_gradients = False
elif args.model_type == "gp":
kernel = Matern52(len(list_params), variance=1., ARD=True)
gpmodel = GPRegression(X_init, Y_init, kernel)
gpmodel.optimize()
model = GPyModelWrapper(gpmodel)
acquisition = ExpectedImprovement(model)
acquisition_optimizer = DirectOptimizer(space)
candidate_point_calculator = Sequential(acquisition, acquisition_optimizer)
bo = BayesianOptimizationLoop(model=model, space=space, X_init=X_init, Y_init=Y_init, acquisition=acquisition,
candidate_point_calculator=candidate_point_calculator)
overhead = []
st = time.time()
for i in range(args.num_iterations):
t = time.time()
