def create_gp(self):
gp_mean = []
gp_std = []
for i in range(self.dim):
# gp_mean.append(gaussian_process.GaussianProcessRegressor(kernel=1.0 * RBF(length_scale=1.0) +
# ConstantKernel(0.02, constant_value_bounds=(0.01, 0.05)) * \
# WhiteKernel(0.1, noise_level_bounds=(0.01, 0.2)),
# n_restarts_optimizer=3))
gp_mean.append(
gaussian_process.GaussianProcessRegressor(
kernel=1.0 * RBF(length_scale=1.0) +
0.1 * WhiteKernel(0.1, noise_level_bounds=(0.01, 0.2)),
n_restarts_optimizer=3))
# gp_std.append(gaussian_process.GaussianProcessRegressor(kernel=1.0 * RBF(length_scale=0.3) +
# 0.01 * WhiteKernel(0.01),
# n_restarts_optimizer=3))
kernel_std = 1.0 * ExpSineSquared(length_scale=1.0, periodicity=3.0,
length_scale_bounds=(0.5, 5.0),
periodicity_bounds=(1.0, 10.0)) + \
ConstantKernel(0.1, constant_value_bounds=(0.05, 0.2)) * \
WhiteKernel(0.01, noise_level_bounds=(0.01, 0.1))
gp_std.append(
gaussian_process.GaussianProcessRegressor(
kernel=kernel_std, n_restarts_optimizer=3))
return gp_mean, gp_std
def loadEmulators(file1=r_sh_file,
file2=v_con_file,
file3=y_e_file,
file4=s_file):
r_sh_load = gaussian_process.GaussianProcessRegressor(kernel=kernel_choice)
v_con_load = gaussian_process.GaussianProcessRegressor(
kernel=kernel_choice)
y_e_load = gaussian_process.GaussianProcessRegressor(kernel=kernel_choice)
s_load = gaussian_process.GaussianProcessRegressor(kernel=kernel_choice)
with open(file1, "rb") as f1:
r_sh_load = pickle.load(f1)
with open(file2, "rb") as f2:
v_con_load = pickle.load(f2)
with open(file3, "rb") as f3:
y_e_load = pickle.load(f3)
with open(file4, "rb") as f4:
s_load = pickle.load(f4)
global r_sh_emul
global v_con_emul
global y_e_emul
global s_emul
r_sh_emul = r_sh_load
v_con_emul = v_con_load
y_e_emul = y_e_load
s_emul = s_load
def fit(self, X, y):
self.ages_ = y
degree = 4
ages_t = y.reshape(-1, 1)
wm_model = sklearn.pipeline.make_pipeline(
sklearn.preprocessing.PolynomialFeatures(degree),
sklearn.linear_model.LinearRegression())
gm_model = sklearn.pipeline.make_pipeline(
sklearn.preprocessing.PolynomialFeatures(1),
sklearn.linear_model.LinearRegression())
self.wm_model_ = wm_model.fit(ages_t, X[:, 0])
self.gm_model_ = gm_model.fit(ages_t, X[:, 1])
self.ages_ = y
self.ages_grid_ = np.arange(15, 100).reshape(-1, 1)
ages_kde = skn.KernelDensity(kernel="gaussian", bandwidth=3)
ages_kde.fit(ages_t)
prior = np.exp(
ages_kde.score_samples(self.ages_grid_))
self.prior_ = prior / np.sum(prior)
wm_residuals = np.abs(wm_model.predict(ages_t) - X[:, 0])
gm_kernel = (
44.7 ** 2
* skg.kernels.RBF(length_scale=30, length_scale_bounds=(10, 60))
+ skg.kernels.WhiteKernel(noise_level=1e4,
noise_level_bounds=(1e3, 1e5))
)
wm_kernel = (
44.7 ** 2
* skg.kernels.RBF(length_scale=30, length_scale_bounds=(10, 60))
+ skg.kernels.WhiteKernel(noise_level=1e4,
noise_level_bounds=(1e3, 1e5))
)
self.wm_gp_ = skg.GaussianProcessRegressor(
kernel=wm_kernel,
n_restarts_optimizer=0)
self.wm_gp_.fit(ages_t, wm_residuals)
gm_residuals = np.abs(gm_model.predict(ages_t) - X[:, 1])
self.gm_gp_ = skg.GaussianProcessRegressor(
kernel=gm_kernel,
n_restarts_optimizer=0)
self.gm_gp_.fit(ages_t, gm_residuals)
# plt.figure()
# plt.scatter(y, X[:, 0])
# plt.plot(self.ages_grid_, wm_model.predict(self.ages_grid_))
# plt.figure()
# plt.scatter(y, gm_residuals)
# plt.plot(self.ages_grid_, self.gm_gp_.predict(self.ages_grid_))
# plt.show()
# input()
return self
def build_surrogate(self):
"""Builds a surrogate based on sample evalations using a Guassian process.
Assumptions:
None
Source:
N/A
Inputs:
self.training.
coefficients [-] CM, Cm_alpha, Cn_beta
neutral point [meters] NP
grid_points [radians,-] angles of attack and mach numbers
Outputs:
self.surrogates.
moment_coefficient <Guassian process surrogate>
Cm_alpha_moment_coefficient <Guassian process surrogate>
Cn_beta_moment_coefficient <Guassian process surrogate>
neutral_point <Guassian process surrogate>
Properties Used:
No others
"""
# Unpack data
training = self.training
AoA_data = training.angle_of_attack
mach_data = training.Mach
CM_data = training.coefficients[:, 0]
Cm_alpha_data = training.coefficients[:, 1]
Cn_beta_data = training.coefficients[:, 2]
NP_data = training.coefficients[:, 3]
xy = training.grid_points
# Gaussian Process New
regr_cm = gaussian_process.GaussianProcessRegressor()
regr_cm_alpha = gaussian_process.GaussianProcessRegressor()
regr_cn_beta = gaussian_process.GaussianProcessRegressor()
regr_np = gaussian_process.GaussianProcessRegressor()
cm_surrogate = regr_cm.fit(xy, CM_data)
cm_alpha_surrogate = regr_cm_alpha.fit(xy, Cm_alpha_data)
cn_beta_surrogate = regr_cn_beta.fit(xy, Cn_beta_data)
neutral_point_surrogate = regr_np.fit(xy, NP_data)
self.surrogates.moment_coefficient = cm_surrogate
self.surrogates.Cm_alpha_moment_coefficient = cm_alpha_surrogate
self.surrogates.Cn_beta_moment_coefficient = cn_beta_surrogate
self.surrogates.neutral_point = neutral_point_surrogate
return
def from_drpall(cls, drpall, n=None, **kwargs):
'''
read in lots of IFUs' LSFs, assume a redshift
'''
import sklearn.gaussian_process as gp
if n is None:
n = len(drpall)
lam, specres, dspecres = zip(*[
m.hdu_data_extract(hdulist=m.load_drp_logcube(
plate=row['plate'], ifu=row['ifudsgn'], mpl_v=mpl_v),
names=['WAVE', 'SPECRES', 'SPECRESD'])
for row in drpall[:n]
])
lam = np.concatenate(lam)
specres = np.concatenate(specres)
dspecres = np.concatenate(dspecres)
good = np.logical_and.reduce(
list(map(np.isfinite, [lam, specres, dspecres])))
lam, specres, dspecres = lam[good], specres[good], dspecres[good]
kernel_ = gp.kernels.RBF(
length_scale=1., length_scale_bounds=(.2, 5.)) + \
gp.kernels.WhiteKernel(
noise_level=.02, noise_level_bounds=(.002, 2.))
regressor = gp.GaussianProcessRegressor(normalize_y=True,
kernel=kernel_)
regressor.fit(X=np.atleast_2d(lam).T, y=specres)
return cls(LSF_R_obs_gpr=regressor, **kwargs)
def __init__(self, D, K, beta_t, kernel, sigma2):
"""Initializes a GP contextual bandit object
Parameters
----------
D : int
Dimension of the context features
K : int
Number of arms
beta_t: float
width parameter of the ucb
kernel: kernel obj
kernel for the gaussian processes from sklearn
sigma2:
noise level of the observations in the GP
"""
self.D = D
self.K = K
self.beta_t = beta_t
# TODO: Make this varinputin for the kernel --> default use RBF kernel?
self.GpObj = gp.GaussianProcessRegressor(kernel=kernel, alpha=sigma2)
# initialization
self.S = np.array([]).reshape(0, 1)
self.Z = np.array([]).reshape(0, D)
self.X = np.hstack((self.S, self.Z))
self.y = np.array([]).reshape(0, 1)
self.sigma2 = sigma2
def identify_outliers_GP(x, y, mag):
# mag -> magnitude in units std
# if len(y)<11 flag all
idx = []
if len(y) < 11:
print("block too short with length " + str(int(len(y))) +
", values flagged")
x_pred = []
y_pred = []
sigma = []
for i in range(len(y)):
idx.append(i)
x_pred.append(np.nan)
y_pred.append(np.nan)
sigma.append(np.nan)
else:
kernel = 1 * RBF(length_scale=1) + WhiteKernel(noise_level=1)
gp = gaussian_process.GaussianProcessRegressor(kernel=kernel)
gp.fit(x.reshape(-1, 1), y.reshape(-1, 1))
print gp.kernel_
x_pred = x.reshape(-1, 1)
y_pred, sigma = gp.predict(x_pred, return_std=True)
for i in range(len(y)):
if ((y[i] > (y_pred[i] + (mag * sigma[i]))[0])
or (y[i] < (y_pred[i] - (mag * sigma[i]))[0])):
idx.append(i)
return idx, x_pred, y_pred, sigma
def store_anm(progress_counter, list_data):
# For loop for calculating the result
for data_num in list_data:
file_name = "datasets/" + data_num + ".txt"
print(file_name + " In Progress (" + str(
float("{0:.2f}".format(progress_counter / len(list_data) * 100))) +
" % Done)")
progress_counter += 1
df = pd.read_csv(file_name, delim_whitespace=True, header=None)
df.columns = ["x", "y"]
x = sk.scale(df['x'].tolist()).reshape((-1, 1))
y = sk.scale(df['y'].tolist()).reshape((-1, 1))
gp = sk_gp.GaussianProcessRegressor().fit(x, y)
anm = anm_store.ANM_store()
anm_result.append(anm.predict_proba(df['x'].tolist(),
df['y'].tolist()))
# indepscoreX_result.append(anm.anm_score(sk.scale(df['x'].tolist()).reshape((-1, 1)), sk.scale(df['y'].tolist()).reshape((-1, 1)))) # x -> y direction
# indepscoreY_result.append(anm.anm_score(sk.scale(df['y'].tolist()).reshape((-1, 1)),
# sk.scale(df['x'].tolist()).reshape((-1, 1)))) # y -> x direction
y_predict_result.append(y_predict_calculator(x, gp))
y_predict_result.append(y_predict_calculator(y, gp))
y_predict_std.append(y_predict_calculator(x, gp, True, False))
y_predict_std.append(y_predict_calculator(y, gp, True, False))
y_predict_cov.append(y_predict_calculator(x, gp, False, True))
y_predict_cov.append(y_predict_calculator(y, gp, False, True))
def __init__(self, bounds, f=None, init_num=5, inputs=None, vals=None,
kernel=gaussian_process.kernels.Matern(nu=1.5), acq_func=EI,
explicit_f=True):
self._f = f
self._iterations = 0
self._bounds = bounds
if explicit_f: #if an explicit function is given
self._inputs = []
self._func_vals = [] #List of tuples of function inputs and function outputs
# Random initial inputs to obtain some function values
for i in range(init_num):
inputs = (uniform(bounds[0, :], bounds[1, :]))
self._inputs.append(inputs)
self._func_vals.append(self._f(inputs))
else: #if no explicit function is given
self._inputs = inputs
self._func_vals = vals
id = np.argmax(self._func_vals)
self._current_opt = (self._inputs[id], self._func_vals[id])
self._gpr = gaussian_process.GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=2).fit(self._inputs, self._func_vals)
self._recommended_point = self._inputs[-1]
def gpr(data, xseq, **params):
"""
Fit gaussian process
"""
try:
from sklearn import gaussian_process
except ImportError:
raise PlotnineError(
"To use gaussian process smoothing, "
"You need to install scikit-learn.")
kwargs = params['method_args']
if not kwargs:
warnings.warn(
"See sklearn.gaussian_process.GaussianProcessRegressor "
"for parameters to pass in as 'method_args'")
regressor = gaussian_process.GaussianProcessRegressor(**kwargs)
X = np.atleast_2d(data['x']).T
n = len(data)
Xseq = np.atleast_2d(xseq).T
regressor.fit(X, data['y'])
data = pd.DataFrame({'x': xseq})
if params['se']:
y, stderr = regressor.predict(Xseq, return_std=True)
data['y'] = y
data['se'] = stderr
data['ymin'], data['ymax'] = tdist_ci(
y, n-1, stderr, params['level'])
else:
data['y'] = regressor.predict(Xseq, return_std=True)
return data
def upper_confidence_bound(param_array, train_dic, greater_is_better=True):
pred = {}
train_index = train_dic.keys()
train_Y = []
train_X = []
test_X = []
test_X_index = []
for i, ele in enumerate(param_array):
if i in train_index:
train_X.append(param_array[i])
train_Y.append(train_dic[i])
else:
test_X.append(param_array[i])
test_X_index.append(i)
kernel = Matern(length_scale=1.0, length_scale_bounds=(1e-1, 10.0), nu=2.5)
gpr = gaussian_process.GaussianProcessRegressor(kernel=kernel).fit(
train_X, train_Y)
avg_pred, std_pred = gpr.predict(test_X, return_std=True, return_cov=False)
scaling_factor = (-1)**(not greater_is_better)
beta = 1.96
for i, avg_pred_i in enumerate(avg_pred):
pred[
test_X_index[i]] = avg_pred_i + scaling_factor * std_pred[i] * beta
return pred
def create_model(samples_x,
samples_y_aggregation,
n_restarts_optimizer=250,
is_white_kernel=False):
'''
Trains GP regression model
'''
kernel = gp.kernels.ConstantKernel(constant_value=1,
constant_value_bounds=(1e-12, 1e12)) * \
gp.kernels.Matern(nu=1.5)
if is_white_kernel is True:
kernel += gp.kernels.WhiteKernel(noise_level=1,
noise_level_bounds=(1e-12, 1e12))
regressor = gp.GaussianProcessRegressor(
kernel=kernel,
n_restarts_optimizer=n_restarts_optimizer,
normalize_y=True,
alpha=1e-10)
regressor.fit(numpy.array(samples_x), numpy.array(samples_y_aggregation))
model = {}
model['model'] = regressor
model['kernel_prior'] = str(kernel)
model['kernel_posterior'] = str(regressor.kernel_)
model['model_loglikelihood'] = regressor.log_marginal_likelihood(
regressor.kernel_.theta)
return model
def fit_gp(x, y, yerr):
from sklearn import gaussian_process
from sklearn.gaussian_process.kernels import (
Matern, WhiteKernel,
# ConstantKernel,
)
# _, ystd = eu.stat.sigma_clip(smooth_data_hann3(y) - y)
# ystd = (smooth_data_hann3(y) - y).std()
spacing = x[1] - x[0]
kernel = (
# ConstantKernel() +
Matern(length_scale=spacing, nu=5/2) +
WhiteKernel(noise_level=yerr**2)
)
gp = gaussian_process.GaussianProcessRegressor(
kernel=kernel, normalize_y=True,
)
X = x.reshape(-1, 1)
gp.fit(X, y)
return gp
def expected_improvement(param_array, train_dic, greater_is_better=True):
train_index = train_dic.keys()
train_Y = []
train_X = []
test_X = []
test_X_index = []
for i, ele in enumerate(param_array):
if i in train_index:
train_X.append(param_array[i])
train_Y.append(train_dic[i])
else:
test_X.append(param_array[i])
test_X_index.append(i)
kernel = Matern(length_scale=1.0, length_scale_bounds=(1e-1, 10.0), nu=2.5)
gpr = gaussian_process.GaussianProcessRegressor(kernel=kernel).fit(
train_X, train_Y)
avg_pred, std_pred = gpr.predict(test_X, return_std=True, return_cov=False)
if greater_is_better:
loss_optimum = np.max(train_Y)
else:
loss_optimum = np.min(train_Y)
scaling_factor = (-1)**(not greater_is_better)
# In case sigma equals zero
with np.errstate(divide='ignore'):
Z = scaling_factor * (avg_pred - loss_optimum) / std_pred
expected_improvement = scaling_factor * (
avg_pred - loss_optimum) * norm.cdf(Z) + std_pred * norm.pdf(Z)
expected_improvement[std_pred == 0.0] == 0.0
return dict(zip(test_X_index, expected_improvement))
def optimize(self, param_opt, itr):
if param_opt == 'MLE':
optimizer_input = 'fmin_l_bfgs_b'
elif param_opt == 'Not_optimize':
optimizer_input = None
else:
return (
"This library does not support the specified Parameter optimizer"
)
self.model = sklearn_gp.GaussianProcessRegressor(
kernel=self.kernel_function,
n_restarts_optimizer=itr,
alpha=self.nugget,
optimizer=optimizer_input,
normalize_y=self.mean_function,
copy_X_train=True,
random_state=None)
print('Kernel hyperparameters before optimization :\n',
self.model.kernel)
self.model.fit(self.x_train, self.z_train)
print('Kernel hyperparameters after optimization :\n',
self.model.kernel_)
print("Nuggets before optimization :\n", self.model.alpha)
def __init__(self,
objective,
max_trials,
num_initial_points=None,
alpha=1e-4,
beta=2.6,
seed=None,
hyperparameters=None,
allow_new_entries=True,
tune_new_entries=True):
super(BayesianOptimizationOracle,
self).__init__(objective=objective,
max_trials=max_trials,
hyperparameters=hyperparameters,
tune_new_entries=tune_new_entries,
allow_new_entries=allow_new_entries)
self.num_initial_points = num_initial_points
self.alpha = alpha
self.beta = beta
self.seed = seed or random.randint(1, 1e4)
self._seed_state = self.seed
self._tried_so_far = set()
self._max_collisions = 20
self.gpr = gaussian_process.GaussianProcessRegressor(
kernel=gaussian_process.kernels.Matern(),
n_restarts_optimizer=20,
normalize_y=True,
alpha=self.alpha,
random_state=self.seed)
def test_GaussianProcess_ge_018(self):
X = np.atleast_2d([1., 3., 5., 6., 7., 8.]).T
y = np.sin(X).ravel()
df = pdml.ModelFrame(X, target=y)
k1 = (df.gp.kernels.ConstantKernel(1.0, (1e-3, 1e3)) *
df.gp.kernels.RBF(10, (1e-2, 1e2)))
g1 = df.gp.GaussianProcessRegressor(kernel=k1,
n_restarts_optimizer=9,
random_state=self.random_state)
k2 = (gp.kernels.ConstantKernel(1.0, (1e-3, 1e3)) *
gp.kernels.RBF(10, (1e-2, 1e2)))
g2 = gp.GaussianProcessRegressor(kernel=k2,
n_restarts_optimizer=9,
random_state=self.random_state)
g1.fit(X, y)
g2.fit(X, y)
x = np.atleast_2d(np.linspace(0, 10, 1000)).T
tdf = pdml.ModelFrame(x)
y_result = tdf.predict(g1)
y_expected = g2.predict(x)
self.assertIsInstance(y_result, pdml.ModelSeries)
tm.assert_index_equal(y_result.index, tdf.index)
self.assert_numpy_array_almost_equal(y_result, y_expected)
def test_Gaussian2D_std(self):
# http://scikit-learn.org/stable/auto_examples/gaussian_process/plot_gp_probabilistic_classification_after_regression.html
def g(x):
"""The function to predict (classification will then consist in predicting
whether g(x) <= 0 or not)"""
return 5. - x[:, 1] - .5 * x[:, 0]**2.
# Design of experiments
X = np.array([[-4.61611719, -6.00099547], [4.10469096, 5.32782448],
[0.00000000, -0.50000000], [-6.17289014, -4.6984743],
[1.3109306, -6.93271427], [-5.03823144, 3.10584743],
[-2.87600388, 6.74310541], [5.21301203, 4.26386883]])
y = g(X)
df = pdml.ModelFrame(X, target=y)
gpm1 = df.gaussian_process.GaussianProcessRegressor()
df.fit(gpm1)
result, std_result = df.predict(gpm1, return_std=True)
gpm2 = gp.GaussianProcessRegressor()
gpm2.fit(X, y)
expected, std_expected = gpm2.predict(X, return_std=True)
self.assert_numpy_array_almost_equal(result.values, expected)
self.assert_numpy_array_almost_equal(std_result.values, std_expected)
def __init__(self, kernel, verbose=False):
self.K, self.parameters_search_space = kernel()
self.model = gp.GaussianProcessRegressor(kernel=self.K)
self.verbose = verbose
self.logger = config.getlogger("GP")
self.best_param = None
self.trained = False
def interpolate(x, y, new_x, kind):
"""Interpolate 1D array y at values x to new_x values.
Parameters
----------
x : array
x values of input y
y : array
1D array to interpolate
new_x : array
x values of desired interpolated output
kind : str
Perform either 'cubic' or 'gp' interpolation
Returns
-------
new_y, interpolated values of y at positions new_x
"""
if kind == 'cubic':
f_y = interp1d(x, y, kind='cubic')
new_y = f_y(new_x)
elif kind == 'gp':
from sklearn import gaussian_process
gp = gaussian_process.GaussianProcessRegressor(normalize_y=True,
alpha=1e-3,
n_restarts_optimizer=5)
gp.fit(x.reshape(-1, 1), y.reshape(-1, 1))
new_y = gp.predict(new_x.reshape(-1, 1))
return new_y
def bayesian_optimisation2(n_iters,
loss_fn,
bounds,
x_list=[],
y_list=[],
n_pre_samples=5,
alpha=1e-5,
epsilon=1e-7):
# Handle any specifically-asked for "guesses" first
for i, v in enumerate(y_list):
if v[0] is None:
print("Running guess values")
y_list[i] = loss_fn(x_list[i])
n_pre_samples -= len(x_list)
if n_pre_samples > 0:
for params in np.random.uniform(bounds[:, 0], bounds[:, 1],
(n_pre_samples, bounds.shape[0])):
x_list.append(params)
y_list.append(loss_fn(params))
xp = np.array(x_list)
yp = np.array(y_list)
# Create the GP
kernel = gp.kernels.Matern()
model = gp.GaussianProcessRegressor(kernel=kernel,
alpha=alpha,
n_restarts_optimizer=10,
normalize_y=True)
for n in range(n_iters):
print("Fitting GP")
model.fit(xp, yp)
# Sample next hyperparameter
next_sample = sample_next_hyperparameter(expected_improvement,
model,
yp,
greater_is_better=True,
bounds=bounds,
n_restarts=100)
# Duplicates will break the GP. In case of a duplicate, we will randomly sample a next query point.
if np.any(np.abs(next_sample - xp) <= epsilon):
next_sample = np.random.uniform(bounds[:, 0], bounds[:, 1],
bounds.shape[0])
# Sample loss for new set of parameters
cv_score = loss_fn(next_sample)
# Update lists
x_list.append(next_sample)
y_list.append(cv_score)
# Update xp and yp
xp = np.array(x_list)
yp = np.array(y_list)
return xp, yp
def interp_krige(data):
stream_trans = data.stream_dist.values
sample_z = data.sample_z.values
valid = np.isfinite(stream_trans[:, 0])
if valid.sum() == 0:
return np.nan
# gp = GP.GaussianProcessRegressor(kernel=GP.kernels.ConstantKernel(1.0),n_restarts_optimizer=9)
# kernel=GP.kernels.ConstantKernel(1.0))
# kernel=None
# takes 4 seconds to fit.
#kernel=( GP.kernels.ConstantKernel(1.0,[0.1,10]) * GP.kernels.RBF(1,[0.1,10])
# + GP.kernels.WhiteKernel(noise_level=1) )
# takes 0.4s to fit.
kernel = GP.kernels.Matern(length_scale=2, nu=1.5)
# Warnings
# kernel=GP.kernels.ConstantKernel(1.0,[0.1,10])
# kernel=GP.kernels.RBF(1.0,[0.1,10])
gp = GP.GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=1)
offset = sample_z[valid].mean()
start = time.time()
gp.fit(stream_trans[valid], sample_z[valid] - offset)
#print("Fit: %fs"%(time.time()-start))
#import pdb
#pdb.set_trace()
z_pred = gp.predict(np.array([[0, 0]]))[0]
return z_pred + offset
def _make_gpr(self):
return gaussian_process.GaussianProcessRegressor(
kernel=gaussian_process.kernels.Matern(nu=2.5),
n_restarts_optimizer=20,
normalize_y=True,
alpha=self.alpha,
random_state=self.seed)
def loo_rsquared(self):
"""Get leave-one-out R-squared value
Kernel parameters and normalization constants are not changed.
The intent is to test holding out the observations but not
re-fitting the kernel parameters.
"""
Xtrans = self.x_scaler.transform(self.X)
Ytrans = (self.Y - self.y_mean) / self.y_std
preds = []
for i in range(len(Ytrans)):
X = np.delete(Xtrans, i, axis=0)
Y = np.delete(Ytrans, i)
gp = gaussian_process.GaussianProcessRegressor(
kernel=self.gp.kernel_,
alpha=self.gp.alpha,
normalize_y=False,
optimizer=None).fit(X, Y)
preds.append(gp.predict([Xtrans[i, :]], return_std=False)[0])
return self._rsquared(Ytrans, np.array(preds))
def bayesian_optimization(n_iters, sample_loss, xp, yp):
"""
Arguments:
----------
n_iters: int.
Number of iterations to run the algorithm for.
sample_loss: function.
Loss function that takes an array of parameters.
xp: array-like, shape = [n_samples, n_params].
Array of previously evaluated hyperparameters.
yp: array-like, shape = [n_samples, 1].
Array of values of `sample_loss` for the hyperparameters
in `xp`.
"""
# Define the GP
kernel = gp.kernels.Matern()
model = gp.GaussianProcessRegressor(kernel=kernel,
alpha=1e-4,
n_restarts_optimizer=10,
normalize_y=True)
for i in range(n_iters):
# Update our belief of the loss function
model.fit(xp, yp)
# sample_next_hyperparameter is a method that computes the arg
# max of the acquisition function
next_sample = sample_next_hyperparameter(model, yp)
# Evaluate the loss for the new hyperparameters
next_loss = sample_loss(next_sample)
def __init__(self, X: np.ndarray, Y: np.ndarray):
""" Constructor for PosGP
Parameters:
X (numpy.ndarray): Training inputs on the form (n, 5) where the innermost dimension corresponds to [p_x, p_y, cog, sog, t]
Y (numpy.ndarray): Training outputs on the form (n, 2) where the innermost dimension is the true position at time t
variance (float): Kernel amplitude/variance
center (numpy.ndarray): Position used to calculate distance to each position in X. Used to sort the input data by distance.
N (int): Number of samples to include in the model. If N is less than the number of samples in (X, Y), N samples are collected. If center != None, the N samples with shortest distance between center and X[:, :2] are used, otherwise random.
"""
assert X.shape[0] == Y.shape[0], "Shapes not matching"
kernel = sgp.kernels.ConstantKernel(1.0) * sgp.kernels.RBF(length_scale=[1000.0, 1000.0, 50.0, 50.0, 60.0]) \
+ sgp.kernels.ConstantKernel(1.0) * sgp.kernels.RBF(length_scale=[1.0, 1.0, 1.0, 1.0, 1.0]) \
+ sgp.kernels.WhiteKernel(1)
Y = Y[:, :2]
self.y_mean = Y.mean(axis=0)
self.y_scale = Y.std(axis=0)
self.gp = sgp.GaussianProcessRegressor(
kernel=kernel,
n_restarts_optimizer=10,
)
self.gp.fit(X, (Y - self.y_mean) / self.y_scale)
def gausian_model(kern, xx, yy):
model = gp.GaussianProcessRegressor(kernel=kern, alpha=noise_level,
n_restarts_optimizer=10, normalize_y=True)
model.fit(xx, yy)
return model
def fit_gps(signals,
length=None,
samples=8,
kernel=None,
noise_tolerance=5,
truncate=False):
if kernel is None:
kernel = (
sgp.kernels.ConstantKernel(1) * sgp.kernels.RBF(1e7, (1e6, 1e8)) +
sgp.kernels.ConstantKernel(1) * sgp.kernels.RBF(1.5e6,
(1e6, 1e7)) +
sgp.kernels.ConstantKernel(.0001) *
sgp.kernels.RBF(1.5e4, (1e4, 1e5)))
gp = sgp.GaussianProcessRegressor(kernel=kernel,
alpha=noise_tolerance,
n_restarts_optimizer=12)
if length is None:
longest = max(max(x) for x, y in signals)
else:
longest = length
fit_gp_to_length = partial(fit_gp, longest, gp, 2**samples, truncate)
with Pool(cpu_count() - 1) as p:
results = p.map(fit_gp_to_length, signals)
return zip(*results)
def __init__(self,
configs,
pred_model,
datahandler,
random_search=False,
param_range=[1, 30],
num_iterations=10,
init_params=None,
alpha=1e-5,
epsilon=1e-7):
self.configs = configs
self.pred_model = pred_model
self.datahandler = datahandler
self.param_range = np.array(param_range)
self.num_iterations = num_iterations
self.random_search = random_search
self.alpha = alpha
self.epsilon = epsilon
if init_params is not None:
self.xp = np.array(init_params[0])
self.yp = np.array(init_params[1])
else:
self.init_params = None
self.kernel = Matern()
self.gp = gp.GaussianProcessRegressor(kernel=self.kernel,
alpha=alpha,
n_restarts_optimizer=10,
normalize_y=True)
def gpr_forecast(columns, df_in, df_forecast, df_out):
X_train = df_in[columns]
y_train = df_out
X_test = df_forecast[columns]
# normalise the inputs
sc_x = StandardScaler()
sc_y = StandardScaler()
X_train = sc_x.fit_transform(X_train.values.astype(np.float32))
y_train = sc_y.fit_transform(
y_train.values.astype(np.float32).reshape(-1, 1))
# normalise the inputs (using same max as for the model)
X_test = sc_x.transform(X_test.values.astype(np.float32))
kernel = gp.kernels.ConstantKernel(1.0, (1e-1, 1e3)) * gp.kernels.RBF(
10.0, (1e-3, 1e8))
model = gp.GaussianProcessRegressor(kernel=kernel,
n_restarts_optimizer=10,
alpha=0.1,
normalize_y=False,
random_state=0)
model.fit(X_train, y_train)
y_pred, std = model.predict(X_test, return_std=True)
y_pred = y_pred.reshape(len(X_test), )
y_pred = sc_y.inverse_transform(y_pred)
return y_pred
