def __init__(self):
"""Initializes the algorithm with a parameter configuration. """
# TODO: enter your code here
# speed threshold
epsilon = 0.01
self.kappa = 1.2 + epsilon # 1.21 / 1.20
# Validation Function F
self.f_noise = 0.5 # 0.5 / 0.15 /0.4 changing this change the results, higher noises gave better results
self.f_var = 0.5
self.f_lenscale = 0.5
self.f_nu = 2.5
k_1 = Matern(length_scale=self.f_lenscale,
length_scale_bounds="fixed",
nu=self.f_nu)
k_2 = ConstantKernel(constant_value=self.f_var,
constant_value_bounds="fixed")
k_3 = WhiteKernel(noise_level=self.f_noise)
self.f_kernel = Sum(Product(k_1, k_2), k_3)
# Default GaussianProcessRegressor (check argument possibilities)
self.gp_f = GaussianProcessRegressor(kernel=self.f_kernel,
alpha=1e-10,
optimizer='fmin_l_bfgs_b',
n_restarts_optimizer=0,
normalize_y=False,
copy_X_train=True,
random_state=None)
# Speed Function V
self.v_noise = 0.0001
self.v_var = np.sqrt(2)
self.v_lenscale = 0.5
self.v_mean = 1.5
self.v_nu = 2.5
kv_1 = Matern(length_scale=self.v_lenscale,
length_scale_bounds=[1e-5, 1e5],
nu=self.v_nu)
kv_2 = ConstantKernel(constant_value=self.v_var)
kv_3 = WhiteKernel(noise_level=self.v_noise)
kv_4 = ConstantKernel(constant_value=self.v_mean)
self.v_kernel = Sum(Sum(kv_4, Product(kv_1, kv_2)), kv_3)
# Default GaussianProcessRegressor (check argument possibilities)
self.gp_v = GaussianProcessRegressor(kernel=self.v_kernel,
alpha=1e-10,
optimizer='fmin_l_bfgs_b',
n_restarts_optimizer=0,
normalize_y=False,
copy_X_train=True,
random_state=None)
# Create the array to store data (x, f and v) + a boolean to be used later
self.delete_first_raw = False
self.xfv = np.zeros([1, 3])
def test_kernel_ker2_def_ort(self):
ker = Sum(
CK(0.1, (1e-3, 1e3)) * RBF(length_scale=10,
length_scale_bounds=(1e-3, 1e3)),
CK(0.1, (1e-3, 1e3)) * RBF(length_scale=1,
length_scale_bounds=(1e-3, 1e3)))
onx = convert_kernel(ker, 'X', output_names=['Y'], dtype=numpy.float32,
op_version=get_opset_number_from_onnx())
model_onnx = onx.to_onnx(
inputs=[('X', FloatTensorType([None, None]))],
outputs=[('Y', FloatTensorType([None, None]))],
target_opset=get_opset_number_from_onnx())
model_onnx.ir_version = get_ir_version_from_onnx()
sess = _capture_output(
lambda: OnnxInference(model_onnx.SerializeToString(),
runtime="onnxruntime2"), 'c')[0]
try:
res = sess.run({'X': Xtest_.astype(numpy.float32)})
except RuntimeError as e:
if "Got invalid dimensions for input" in str(e):
# probable bug somewhere
return
raise e
m1 = res['Y']
m2 = ker(Xtest_)
self.assertEqualArray(m1, m2, decimal=5)
def _cast(self, n, X, y):
"""
Evaluates and optimizes all legitimate combinations of length `n`
:param n: The length of pipelines
:param X: Training data
:param y: Observed values
:return: None
"""
from .structsearch import SurrogateRandomCV, BoxSample, CompactSample
from importlib import import_module
if self.couldBfirst == []:
from sklearn.pipeline import Pipeline
else:
from imblearn.pipeline import Pipeline
from sklearn.model_selection import RandomizedSearchCV
if self.surrogates is None:
from numpy import logspace
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.kernel_ridge import KernelRidge
from sklearn.gaussian_process.kernels import Matern, Sum, ExpSineSquared, WhiteKernel
param_grid_gpr = {"alpha": logspace(-8, 1, 20),
"kernel": [Sum(Matern(length_scale=l, nu=p), WhiteKernel(noise_level=q))
for l in logspace(-3, 3, 20)
for p in [0.5, 1.5, 2.5]
for q in logspace(-3, 1.5, 20)]}
GPR = RandomizedSearchCV(GaussianProcessRegressor(), param_distributions=param_grid_gpr, n_iter=20, cv=2)
param_grid_krr = {"alpha": logspace(-4, 0, 10),
"kernel": [Sum(Matern(), ExpSineSquared(l, p))
for l in logspace(-2, 2, 20)
for p in logspace(0, 2, 20)]}
KRR = RandomizedSearchCV(KernelRidge(), param_distributions=param_grid_krr, n_iter=30, cv=2)
self.surrogates = [(KRR, 35, CompactSample, 'L-BFGS-B'), (GPR, 50, BoxSample, 'L-BFGS-B')]
self.min_random_evals = 10
Pop = []
candidates = self.words.Generate(n)
for cnddt in candidates:
if self._validate_sequence(cnddt):
Pop.append(cnddt)
for seq in Pop:
if not self._validate_sequence(seq):
continue
best_mdl, best_scr = self.optimize_pipeline(seq, X, y)
self.models[seq] = (best_mdl, best_scr)
if self.verbose > 0:
print("score:%f" % best_scr)
print(best_mdl)
def plot_action_correlations(self):
# simply chop off all the extra numbers untill they are the same size
data = self.iter_data.all_data
is_player_0 = data['Player'] == 0
player_df = data[is_player_0]
adversary_df = data[is_player_0 == False]
cutoff = min(len(player_df), len(adversary_df))
player_df = player_df.iloc[:cutoff - 1]
adversary_df = adversary_df.iloc[:cutoff - 1]
# get data into right format
player_policy = list(zip(*player_df['PolicyAction']))[self.default_action]
adv_policy = list(zip(*adversary_df['PolicyAction']))[self.default_action]
player_mcts = list(zip(*player_df['MCTSAction']))[self.default_action]
adv_mcts = list(zip(*adversary_df['MCTSAction']))[self.default_action]
player_policy, adv_policy = np.array(player_policy), np.array(adv_policy)
player_mcts, adv_mcts = np.array(player_mcts), np.array(adv_mcts)
# Instantiate a Gaussian Process model, note DotProduct is just <x, y> == Rotation of linear kernel therefore good for this
# kernel = Sum(DotProduct(sigma_0=0.1), WhiteKernel(noise_level=0.1))
kernel = Sum(Product(DotProduct(sigma_0=0.1), RBF(0.1, (1e-2, 1e1))), WhiteKernel(noise_level=0.5))
gp_policy = GaussianProcessRegressor(kernel=kernel, alpha=0.25 ** 2, n_restarts_optimizer=1)
gp_mcts = GaussianProcessRegressor(kernel=kernel, alpha=0.25 ** 2, n_restarts_optimizer=1)
# Fit to data using Maximum Likelihood Estimation of the parameters
X_policy, X_mcts = np.atleast_2d(adv_policy).T, np.atleast_2d(adv_mcts).T
gp_policy.fit(X_policy, player_policy)
gp_mcts.fit(X_mcts, player_mcts)
x = np.atleast_2d(np.linspace(0, 1, 100)).T
y_policy, s_policy = gp_policy.predict(x, return_std=True)
y_mcts, s_mcts = gp_mcts.predict(x, return_std=True)
# CALCULATE CORRELATION
corr_player = np.corrcoef(player_policy, adv_policy)[0][1] # take a non-diagonal element
corr_mcts = np.corrcoef(player_mcts, adv_mcts)[0][1] # take a non-diagonal element
correlation = [corr_player, corr_mcts]
# SCATTER PLOTS AND FITS
titles = ['Policy Predictions', 'MCTS Predictions']
fig, axes = plt.subplots(ncols=2, nrows=1, figsize=(17, 8))
player_actions, adv_actions = [player_policy, player_mcts], [adv_policy, adv_mcts]
y_pred, sigma = [y_policy, y_mcts], [s_policy, s_mcts]
for axis in range(len(axes)):
axes[axis].scatter(adv_actions[axis], player_actions[axis], marker='x')
axes[axis].set_title("{}, Correlation Coef: {}".format(titles[axis], correlation[axis]))
# Plot the function, the prediction and the 95% confidence interval based on the MSE
axes[axis].plot(x, y_pred[axis], 'b-', label='GP Prediction')
axes[axis].fill(np.concatenate([x, x[::-1]]),
np.concatenate([y_pred[axis] - 1.9600 * sigma[axis],
(y_pred[axis] + 1.9600 * sigma[axis])[::-1]]),
alpha=.5, fc='b', ec='None', label='95% confidence interval')
axes[axis].set_xlabel('p(Adversary Action = Left)')
axes[axis].set_ylabel('p(Player Action = Left)')
axes[axis].set_ylim(0, 1)
axes[axis].set_xlim(0, 1)
axes[axis].legend()
def test_sum():
# define rbf and dot product custom kernels, and set hyperparameters
custom_rbf_kernel = generate_kernel(rbf, rbf_grad)
custom_dot_prod_kernel = generate_kernel(dot_prod, dot_prod_grad)
sum_custom_kernel = Sum(custom_dot_prod_kernel, custom_rbf_kernel)
model = GaussianProcessRegressor(kernel=sum_custom_kernel, random_state=0)
model.fit(X_train, Y_train)
preds1 = model.predict(X_test)
sum_kernel = Sum(DotProduct(), RBF())
model = GaussianProcessRegressor(kernel=sum_kernel, random_state=0)
model.fit(X_train, Y_train)
preds2 = model.predict(X_test)
assert (np.all(np.isclose(preds1, preds2)))
def test_kernel_ker12_def(self):
ker = (Sum(CK(0.1, (1e-3, 1e3)), CK(0.1, (1e-3, 1e3)) *
RBF(length_scale=1, length_scale_bounds=(1e-3, 1e3))))
onx = convert_kernel(ker, 'X', output_names=['Y'], dtype=numpy.float32)
model_onnx = onx.to_onnx(
inputs=[('X', FloatTensorType([None, None]))],
outputs=[('Y', FloatTensorType([None, None]))])
sess = OnnxInference(model_onnx.SerializeToString())
res = sess.run({'X': Xtest_.astype(numpy.float32)})
m1 = res['Y']
m2 = ker(Xtest_)
self.assertEqualArray(m1, m2)
def test_kernel_ker12_def(self):
ker = (Sum(
C(0.1, (1e-3, 1e3)),
C(0.1, (1e-3, 1e3)) *
RBF(length_scale=1, length_scale_bounds=(1e-3, 1e3))))
onx = convert_kernel(ker, 'X', output_names=['Y'], dtype=np.float32)
model_onnx = onx.to_onnx(inputs=[('X', FloatTensorType([None, None]))],
dtype=np.float32)
sess = InferenceSession(model_onnx.SerializeToString())
res = sess.run(None, {'X': Xtest_.astype(np.float32)})[0]
m1 = res
m2 = ker(Xtest_)
assert_almost_equal(m1, m2, decimal=5)
def test_gpr_rbf_unfitted(self):
se = (C(1.0, (1e-3, 1e3)) *
RBF(length_scale=10, length_scale_bounds=(1e-3, 1e3)))
kernel = (Sum(se, C(0.1, (1e-3, 1e3)) *
RBF(length_scale=1, length_scale_bounds=(1e-3, 1e3))))
gp = GaussianProcessRegressor(alpha=1e-5, kernel=kernel,
n_restarts_optimizer=25,
normalize_y=True)
# return_cov=False, return_std=False
model_onnx = to_onnx(
gp, initial_types=[('X', FloatTensorType([]))],
target_opset=_TARGET_OPSET_)
self.assertTrue(model_onnx is not None)
dump_data_and_model(Xtest_.astype(np.float32), gp, model_onnx,
verbose=False,
basename="SklearnGaussianProcessRBFUnfitted")
# return_cov=True, return_std=True
options = {GaussianProcessRegressor: {"return_std": True,
"return_cov": True}}
try:
to_onnx(gp, Xtrain_.astype(np.float32), options=options,
target_opset=TARGET_OPSET)
except RuntimeError as e:
assert "Not returning standard deviation" in str(e)
# return_std=True
options = {GaussianProcessRegressor: {"return_std": True}}
model_onnx = to_onnx(
gp, options=options,
initial_types=[('X', FloatTensorType([None, None]))],
target_opset=TARGET_OPSET)
self.assertTrue(model_onnx is not None)
self.check_outputs(gp, model_onnx, Xtest_.astype(np.float32),
predict_attributes=options[
GaussianProcessRegressor])
# return_cov=True
options = {GaussianProcessRegressor: {"return_cov": True}}
# model_onnx = to_onnx(gp, Xtrain_.astype(np.float32), options=options)
model_onnx = to_onnx(
gp, options=options,
initial_types=[('X', FloatTensorType([None, None]))],
target_opset=TARGET_OPSET)
self.assertTrue(model_onnx is not None)
self.check_outputs(gp, model_onnx, Xtest_.astype(np.float32),
predict_attributes=options[
GaussianProcessRegressor])
def test_kernel_ker2_def_ort1(self):
ker = Sum(
CK(0.1, (1e-3, 1e3)) * RBF(length_scale=10,
length_scale_bounds=(1e-3, 1e3)),
CK(0.1, (1e-3, 1e3)) * RBF(length_scale=1,
length_scale_bounds=(1e-3, 1e3))
)
onx = convert_kernel(ker, 'X', output_names=['Y'], dtype=numpy.float32)
model_onnx = onx.to_onnx(
inputs=[('X', FloatTensorType([None, None]))],
outputs=[('Y', FloatTensorType([None, None]))])
sess = OnnxInference(model_onnx.SerializeToString(),
runtime="onnxruntime1")
rows = []
def myprint(*args, **kwargs):
rows.append(" ".join(map(str, args)))
res = sess.run({'X': Xtest_.astype(numpy.float32)},
intermediate=True, verbose=1, fLOG=myprint)
self.assertGreater(len(rows), 2)
m1 = res['Y']
self.assertNotEmpty(m1)
self.assertGreater(len(res), 2)
# m2 = ker(Xtest_)
# self.assertEqualArray(m1, m2, decimal=5)
cpu = OnnxInference(model_onnx.SerializeToString())
sbs = side_by_side_by_values(
[cpu, sess], inputs={'X': Xtest_.astype(numpy.float32)})
self.assertGreater(len(sbs), 2)
self.assertIsInstance(sbs, list)
self.assertIsInstance(sbs[0], dict)
self.assertIn('step', sbs[0])
self.assertIn('step', sbs[1])
self.assertIn('metric', sbs[0])
self.assertIn('metric', sbs[1])
self.assertIn('cmp', sbs[0])
self.assertIn('cmp', sbs[1])
sess3 = OnnxInference(model_onnx.SerializeToString(),
runtime="onnxruntime2")
sbs = side_by_side_by_values(
[cpu, sess, sess3], inputs={'X': Xtest_.astype(numpy.float32)})
self.assertNotEmpty(sbs)
inputs = {'X': Xtest_.astype(numpy.float32)}
sbs = side_by_side_by_values(
[(cpu, inputs), (sess, inputs), (sess3, inputs)])
self.assertNotEmpty(sbs)
def _eval(ppl):
if self.couldBfirst == []:
from sklearn.pipeline import Pipeline
else:
from imblearn.pipeline import Pipeline
from sklearn.model_selection import RandomizedSearchCV
if self.surrogates is None:
from numpy import logspace
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.kernel_ridge import KernelRidge
from sklearn.gaussian_process.kernels import Matern, Sum, ExpSineSquared, WhiteKernel
param_grid_gpr = {"alpha": logspace(-8, 1, 20),
"kernel": [Sum(Matern(length_scale=l_, nu=p), WhiteKernel(noise_level=q))
for l_ in logspace(-3, 3, 20)
for p in [0.5, 1.5, 2.5]
for q in logspace(-3, 1.5, 20)]}
GPR = RandomizedSearchCV(GaussianProcessRegressor(), param_distributions=param_grid_gpr, n_iter=20,
cv=2)
param_grid_krr = {"alpha": logspace(-4, 0, 10),
"kernel": [Sum(Matern(), ExpSineSquared(l_, p))
for l_ in logspace(-2, 2, 20)
for p in logspace(0, 2, 20)]}
KRR = RandomizedSearchCV(KernelRidge(), param_distributions=param_grid_krr, n_iter=30, cv=2)
self.surrogates = [(KRR, 35, CompactSample, 'L-BFGS-B'), (GPR, 50, BoxSample, 'L-BFGS-B')]
self.min_random_evals = 10
from collections import OrderedDict
fitted = OrderedDict([])
for seq in ppl:
best_mdl, best_scr = self.optimize_pipeline(seq, X_, y_)
if seq not in self.models:
self.models[seq] = (best_mdl, best_scr)
if self.verbose > 0:
print("score:%f" % best_scr)
print(best_mdl)
fitted[seq] = -best_scr
return fitted
def test_kernel_ker2_def(self):
ker = Sum(
CK(0.1, (1e-3, 1e3)) * RBF(length_scale=10,
length_scale_bounds=(1e-3, 1e3)),
CK(0.1, (1e-3, 1e3)) * RBF(length_scale=1,
length_scale_bounds=(1e-3, 1e3))
)
onx = convert_kernel(ker, 'X', output_names=['Y'], dtype=numpy.float32,
op_version=get_opset_number_from_onnx())
model_onnx = onx.to_onnx(
inputs=[('X', FloatTensorType([None, None]))],
outputs=[('Y', FloatTensorType([None, None]))],
target_opset=get_opset_number_from_onnx())
sess = OnnxInference(model_onnx.SerializeToString())
res = sess.run({'X': Xtest_.astype(numpy.float32)})
m1 = res['Y']
m2 = ker(Xtest_)
self.assertEqualArray(m1, m2)
res = sess.run({'X': Xtest_.astype(numpy.float32)}, intermediate=True)
self.assertGreater(len(res), 30)
self.assertIsInstance(res, dict)
def __init__(self):
"""Initializes the algorithm with a parameter configuration. """
# TODO: enter your code here
# #noise perturbation sttdev
# self.noise_nu_v = 0.0001
# self.noise_nu_f = 0.15
# #f's kernel
# self.kernel_variance_f = 0.5
# self.kernel_lenghtscale_f = 0.5
# self.kernel_smoothness_f = 2.5
# #v's constant mean
# self.meanean_v = 1.5
# #v's kernel
# self.kernel_variance_v = math.sqrt(2)
# self.kernel_lenghtscale_v = 0.5
# self.kernel_smoothness_v = 2.5
# self.K = 1.2 #minimum speed K
# #init x, v, f tensors as None as no data yet (--> add_data_point handles)
self.x = np.random.rand(1) * 5
self.v = np.random.rand(1)
# #objective function's or surrogate function's values
self.f = np.random.rand(1) + 1.5
self.xi = 0.01
# #self.model_v = None
# #self.model_f = None ? ? sait aps
# self.likelihood_f = gpytorch.likelihoods.GaussianLikelihood()
# self.likelihood_v = gpytorch.likelihoods.GaussianLikelihood()
# #init the kernels of f and v
# #init the gaussian process regressors of f and v
# #------test1-------
# self.kernel_f = gpytorch.kernels.ScaleKernel(base_kernel = gpytorch.kernels.MaternKernel(nu=self.kernel_smoothness_f, length_scale=torch.Tensor([self.kernel_lenghtscale_f])), output_scale = self.kernel_variance_f)
# self.kernel_v = gpytorch.kernels.ScaleKernel(base_kernel = gpytorch.kernels.MaternKernel(nu=self.kernel_smoothness_v, length_scale=self.kernel_lenghtscale_v), kernels.ConstantKernel(self.kernel_variance_v))
# self.gp_f = ExactGPModel(kernel = self.kernel_f, train_x = self.x, train_y = self.f, likelihood = self.likelihood_f)
# self.gp_v = ExactGPModel(mean=self.mean_v, kernel=self.kernel_v, train_x=self.x, train_y=self.v, likelihood=self.likelihood_v)
#------test2-------
#self.kernel_f = Matern(nu=self.kernel_smoothness_f, length_scale=self.kernel_lenghtscale_f)* kernels.ConstantKernel(self.kernel_variance_f)
#self.kernel_v = Matern(nu=self.kernel_smoothness_v, length_scale=self.kernel_lenghtscale_v) * kernels.ConstantKernel(self.kernel_variance_v)
#self.gp_f = GaussianProcessRegressor(kernel = self.kernel_f, alpha = self.noise_nu_f * self.noise_nu_f)
#self.gp_v = GaussianProcessRegressor(kernel = self.kernel_v + kernels.ConstantKernel(self.mean_v), alpha = self.noise_nu_v * self.noise_nu_v)
###self.x0 = domain[:, 0] + (domain[:, 1] - domain[:, 0]) * \
### np.random.rand(domain.shape[0])
###self.gp_f.fit(x0, 0)
###self.gp_v.fit(x0, self.mean_v)
#self.f = matern...
#self.v = matern + mean...
#self.gp = gaussian process... :p
#ok c bon avec le ScaleKernel
# TODO: enter your code here
#
epsilon = 1e-7
self.kappa = 1.2 + epsilon
# Validation Function F
self.f_noise = 0.15
self.f_var = 0.5
self.f_lenscale = 0.5
self.f_nu = 2.5
k_1 = Matern(length_scale=self.f_lenscale,
length_scale_bounds="fixed",
nu=self.f_nu)
k_2 = ConstantKernel(constant_value=self.f_var,
constant_value_bounds="fixed")
k_3 = WhiteKernel(noise_level=self.f_noise)
self.f_kernel = Sum(Product(k_1, k_2), k_3)
# Default GaussianProcessRegressor (check argument possibilities)
self.gp_f = GaussianProcessRegressor(kernel=self.f_kernel)
# Speed Function V
self.v_noise = 0.0001
self.v_var = np.sqrt(2)
self.v_lenscale = 0.5
self.v_mean = 1.5
self.v_nu = 2.5
kv_1 = Matern(length_scale=self.v_lenscale,
length_scale_bounds="fixed",
nu=self.v_nu)
kv_2 = ConstantKernel(constant_value=self.v_var,
constant_value_bounds="fixed")
kv_3 = WhiteKernel(noise_level=self.v_noise)
kv_4 = ConstantKernel(constant_value=self.v_mean,
constant_value_bounds="fixed")
self.v_kernel = Sum(Sum(kv_4, Product(kv_1, kv_2)), kv_3)
# Default GaussianProcessRegressor (check argument possibilities)
self.gp_v = GaussianProcessRegressor(kernel=self.v_kernel)
def test_kernel_ker2_def_ort1(self):
ker = Sum(
CK(0.1, (1e-3, 1e3)) * RBF(length_scale=10,
length_scale_bounds=(1e-3, 1e3)),
CK(0.1, (1e-3, 1e3)) * RBF(length_scale=1,
length_scale_bounds=(1e-3, 1e3))
)
onx = convert_kernel(ker, 'X', output_names=['Y'], dtype=numpy.float32,
op_version=get_opset_number_from_onnx())
model_onnx = onx.to_onnx(
inputs=[('X', FloatTensorType([None, None]))],
outputs=[('Y', FloatTensorType([None, None]))],
target_opset=get_opset_number_from_onnx())
model_onnx.ir_version = get_ir_version_from_onnx()
sess = OnnxInference(model_onnx.SerializeToString(),
runtime="onnxruntime1")
rows = []
def myprint(*args, **kwargs):
rows.append(" ".join(map(str, args)))
res = _capture_output(
lambda: sess.run({'X': Xtest_.astype(numpy.float32)},
intermediate=True, verbose=1, fLOG=myprint),
'c')[0]
self.assertGreater(len(rows), 2)
m1 = res['Y']
self.assertNotEmpty(m1)
self.assertGreater(len(res), 2)
# m2 = ker(Xtest_)
# self.assertEqualArray(m1, m2, decimal=5)
cpu = OnnxInference(model_onnx.SerializeToString())
sbs = side_by_side_by_values(
[cpu, sess], inputs={'X': Xtest_.astype(numpy.float32)})
self.assertGreater(len(sbs), 2)
self.assertIsInstance(sbs, list)
self.assertIsInstance(sbs[0], dict)
self.assertIn('step', sbs[0])
self.assertIn('step', sbs[1])
self.assertIn('metric', sbs[0])
self.assertIn('metric', sbs[1])
self.assertIn('cmp', sbs[0])
self.assertIn('cmp', sbs[1])
sess3 = _capture_output(
lambda: OnnxInference(model_onnx.SerializeToString(),
runtime="onnxruntime2"), 'c')[0]
try:
sbs = side_by_side_by_values(
[cpu, sess, sess3], inputs={'X': Xtest_.astype(numpy.float32)})
except RuntimeError as e:
if "Got invalid dimensions for input" in str(e):
# probable bug somewhere
return
raise e
self.assertNotEmpty(sbs)
inputs = {'X': Xtest_.astype(numpy.float32)}
sbs = side_by_side_by_values(
[(cpu, inputs), (sess, inputs), (sess3, inputs)])
self.assertNotEmpty(sbs)
# Find an optimum classification pipeline
import pandas as pd
import numpy as np
from sklearn.model_selection import RandomizedSearchCV
from sklearn.kernel_ridge import KernelRidge
from sklearn.gaussian_process.kernels import Matern, Sum, ExpSineSquared
from SKSurrogate import *
param_grid_krr = {
"alpha": np.logspace(-4, 0, 5),
"kernel": [
Sum(Matern(), ExpSineSquared(l, p))
for l in np.logspace(-2, 2, 10)
for p in np.logspace(0, 2, 10)
],
}
regressor = RandomizedSearchCV(
KernelRidge(), param_distributions=param_grid_krr, n_iter=5, cv=2
)
config = {
# Classifiers
"sklearn.naive_bayes.GaussianNB": {"var_smoothing": Real(1.0e-9, 2.0e-1)},
"sklearn.linear_model.LogisticRegression": {
"penalty": Categorical(["l1", "l2"]),
"C": Real(1.0e-6, 10.0),
"class_weight": HDReal((1.0e-5, 1.0e-5), (20.0, 20.0))
# 'dual': Categorical([True, False])
},
"sklearn.svm.SVC": {
XcTrain, normalizer_c = normalize(XcTrain)
XcTest = normalizer_c.transform(XcTest)
yTrain, normalizer_y = normalize(yTrain)
print('----------------------------------------------------------------------')
print('training a Gaussian Process on selected features... \n')
print('using %s samples for training' % n_samples)
XTrain = np.concatenate((XdTrain, XcTrain), axis=1)
k1 = 1.0**2 * RBF(length_scale=np.ones(XTrain.shape[1]),
length_scale_bounds=(1e-7, 1e7))
k2 = ConstantKernel(0.1, (1e-7, 1e7))
k3 = 1.0**2 * RationalQuadratic(
length_scale=1.0, length_scale_bounds=(1e-7, 1e7), alpha=0.1)
kernel = Product(Sum(k1, k2), k3)
# generate data and fit GP
model = GaussianProcessRegressor(kernel=kernel, normalize_y=True)
start = time.time()
model.fit(XTrain, yTrain.reshape(-1, 1))
end = time.time()
print('elapsed time: %ss \n' % (end - start))
print('final kernel: %s' % (model.kernel_))
print('----------------------------------------------------------------------')
print('calculating posterior on test data... \n')
start = time.time()
XTest = np.concatenate((XdTest, XcTest), axis=1)
def set_params(self,
n_small_stop=None,
n_large_stop=None,
kernel=None,
length=1.0,
length_bounds=(1e-5, 1e5),
sigma_0=1.0,
periodicity=1.0,
gamma=1.0,
alpha_rquad=1.0,
nu=1.0,
**kwargs):
# Define the interpolation region in N
self.n_small_stop = n_small_stop
self.n_large_stop = n_large_stop
self.kernel_name = kernel
# Kernels taken from tuned_parameters list
if kernel == "dotprod":
new_kernel = C(length, (1e-3, 1e3)) * DotProduct(
sigma_0=sigma_0, sigma_0_bounds=(1e-5, 1e5))
elif kernel == "expsin":
new_kernel = C(1.0, (1e-3, 1e3)) * ExpSineSquared(
length_scale=length,
periodicity=periodicity,
length_scale_bounds=length_bounds)
elif kernel == "exp":
new_kernel = C(1.0, (1e-3, 1e3)) * Exponentiation(
RBF(length_scale=length, length_scale_bounds=length_bounds), 2)
elif kernel == "matern":
new_kernel = C(1.0, (1e-3, 1e3)) * Matern(
length_scale=length, length_scale_bounds=length_bounds, nu=nu)
elif kernel == "pairwise":
new_kernel = C(1.0, (1e-3, 1e3)) * PairwiseKernel(
gamma=gamma, gamma_bounds=(1e-5, 1e5))
elif kernel == "rbf":
new_kernel = C(1.0, (1e-3, 1e3)) * RBF(
length_scale=length, length_scale_bounds=length_bounds)
elif kernel == "rquad":
new_kernel = C(1.0, (1e-3, 1e3)) * RationalQuadratic(
length_scale=length,
alpha=alpha_rquad,
length_scale_bounds=length_bounds,
alpha_bounds=(1e-5, 1e5))
# Combinations of basic kernels
elif kernel == "prod":
new_kernel = C(1.0, (1e-3, 1e3)) * Product(
RBF(length, length_bounds), Matern(
length, length_bounds, nu=nu))
elif kernel == "sum":
new_kernel = C(1.0, (1e-3, 1e3)) * Sum(
RBF(length, length_bounds), Matern(
length, length_bounds, nu=nu))
elif kernel == "prod2":
new_kernel = C(1.0, (1e-3, 1e3)) * Product(
RationalQuadratic(length_scale=length,
alpha=alpha_rquad,
length_scale_bounds=length_bounds,
alpha_bounds=(1e-5, 1e5)),
Matern(length, length_bounds, nu=nu))
elif kernel == "sum2":
new_kernel = C(1.0, (1e-3, 1e3)) * Sum(
RationalQuadratic(length_scale=length,
alpha=alpha_rquad,
length_scale_bounds=length_bounds,
alpha_bounds=(1e-5, 1e5)),
Matern(length, length_bounds, nu=nu))
else:
raise NotImplementedError(f"Kernel not implemented {kernel}")
# Call the super() class (GaussianProcessRegressor)
# and give manually the parameteres taken from tuned_parameters list
result = super().set_params(kernel=new_kernel, **kwargs)
return result
# Set the parameters to hyperoptimize
kernel1 = DotProduct(sigma_0=1.0, sigma_0_bounds=(1e-5, 1e5))
kernel2 = ExpSineSquared(length_scale=1.0,
periodicity=1.0,
length_scale_bounds=(1e-5, 1e5))
kernel3 = Exponentiation(
RBF(length_scale=1.0, length_scale_bounds=(1e-2, 1e2)), 2)
kernel4 = Matern(length_scale=1.0, length_scale_bounds=(1e-5, 1e5), nu=1.5)
kernel5 = PairwiseKernel(gamma=1.0, gamma_bounds=(1e-5, 1e5))
kernel6 = Product(RBF(1.0, (1e-5, 1e5)), Matern(1.0, (1e-5, 1e5), nu=1.5))
kernel7 = RBF(length_scale=1.0, length_scale_bounds=(1e-5, 1e5))
kernel8 = RationalQuadratic(length_scale=1.0,
alpha=1.0,
length_scale_bounds=(1e-5, 1e5),
alpha_bounds=(1e-5, 1e5))
kernel9 = Sum(RBF(1.0, (1e-2, 1e2)), Matern(10, (1e-2, 1e2), nu=1.5))
# List of hyperparameters given to the GridSearchCV()
tuned_parameters = [{
"kernel": [
kernel1, kernel2, kernel3, kernel4, kernel5, kernel6, kernel7, kernel8,
kernel9
]
}]
kernel_names = ["DP", "ES", "Exp", "Mat", "PW", "Prod", "RBF", "RQ", "Sum"]
# Instance the GridSearchCV()
gp_hyper = GridSearchCV(GaussianProcessRegressor(), tuned_parameters)
gp_hyper.fit(np.log10(pt), sigma)
# Compute means and standard deviations
print("\nChecking performance")
training_data = [nou, bits, pktNum, sigS, dataRate, phyB, phyG, phyN]
test_data = [nou_tst, bits_tst, pkt_tst, sigS_tst, dR_tst, b_tst, g_tst, n_tst]
labels = ["Number of users", "Bits", "Number of Packets", "Signal Strength",\
"Data Rate(MB)", "802.11b bits", "802.11g bits", "802.11n bits"]
#
#Number of test samples
p = 0
r = 100
#Window size
D = 15
kernel1 = LK(sigma_0=1, sigma_0_bounds=(1e-1, 1e1))
kernel2 = CK(constant_value=1)
kernel3 = WK(0.1)
kernel = Sum(kernel1, kernel2)
kernel = Sum(kernel, kernel3)
#1e-1 for linear + constant, 1e-3 for RBF
gp = GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=10,\
normalize_y=False, alpha=1e-1)
#print gp.get_params()['kernel']
for z in range(len(labels)): #len(labels)
total_samp, Xtr, Ytr, Xtst, Ycomp, Ytst = GP_prep(training_data[z],
test_data[z], 60, p, r,
D)
print(Xtr.shape, Ytr.shape, Xtst.shape, Ytst.shape)
#Testing if it overfits
Xtr_1 = [Xtr[i] for i in range(D, r)]