def gpr(x,
y,
x_pred,
return_std=True,
return_kernel=False,
exp_sine_sq_kernel=False):
mindt = np.min((x[1:] - x[:-1]))
maxdt = np.max((x[1:] - x[:-1]))
minY = min(np.min(y, axis=0))
maxY = max(np.max(y, axis=0))
avgY = np.average(np.average(y, axis=0))
if exp_sine_sq_kernel:
kernel = ConstantKernel(avgY**2, (minY**2, maxY**2)) *\
ExpSineSquared(1, 2.5*(maxdt-mindt),
(1.0*mindt, 10.0*maxdt),
periodicity_bounds=(1e-6, 1e+2)) +\
WhiteKernel()
else:
kernel = ConstantKernel(avgY**2, (minY**2, maxY**2)) *\
RBF(2.5*(maxdt-mindt), (1.0*mindt, 10.0*maxdt)) +\
WhiteKernel()
print("kernel: ", end='')
print(kernel)
print(kernel.get_params())
gp = GaussianProcessRegressor(kernel, normalize_y=True)
gp.fit(x, y)
if return_std:
x_predicetd, s_predicted = gp.predict(np.array(x_pred).reshape(-1, 1),
return_std=return_std)
if return_kernel:
return x_predicetd, s_predicted, gp.kernel_
else:
return x_predicetd, s_predicted
else:
x_predicetd = gp.predict(np.array(x_pred).reshape(-1, 1),
return_std=return_std)
if return_kernel:
return x_predicetd, gp.kernel_
else:
return x_predicetd
# for i in word_tokenize(word_token):
# print(i)
import numpy as np
X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])
Y = np.array([1, 1, 1, 2, 2, 2])
from sklearn.naive_bayes import GaussianNB
clf = GaussianNB()
clf.fit(X, Y)
print(clf.predict([[-0.8, -1]]))
clf_pf = GaussianNB()
clf_pf.partial_fit(X, Y, np.unique(Y))
print(clf_pf.predict([[-0.8, -1]]))
##################################
from sklearn.gaussian_process.kernels import ConstantKernel, RBF
kernel = ConstantKernel(constant_value=1.0, constant_value_bounds=(
0.0, 10.0)) * RBF(length_scale=0.5, length_scale_bounds=(0.0, 10.0)) + RBF(
length_scale=2.0, length_scale_bounds=(0.0, 10.0))
for hyperparameter in kernel.hyperparameters:
print(hyperparameter)
params = kernel.get_params()
for key in sorted(params):
print("%s : %s" % (key, params[key]))
print(kernel.theta) # Note: log-transformed
print(kernel.bounds) # Note: log-transformed
H_obs_ar_1 = np.zeros((1,9))
H_obs_ar_2 = np.zeros((1,9))
H_h_ar_1 = np.zeros((1))
H_h_ar_2 = np.zeros((1))
# Policy
P_kernel = ConstantKernel(.008)*Matern(length_scale=.4, nu=1.5) + WhiteKernel(noise_level=1e-7)
P_gp_1 = gaussian_process.GaussianProcessRegressor(kernel=P_kernel, optimizer = None, normalize_y=False)
P_gp_2 = gaussian_process.GaussianProcessRegressor(kernel=P_kernel, optimizer = None, normalize_y=False)
P_obs_ar_1 = np.zeros((1,8))
P_obs_ar_2 = np.zeros((1,8))
P_actions_1 = np.zeros((1))
P_actions_2 = np.zeros((1))
# Sparsification parameterization
thresshold_std = .5 * np.sqrt(P_kernel.get_params()['k1__k1__constant_value']) # * P_kernel.get_params()['k1__k2__length_scale'] # 1 * sqrt(Constant_kernel) * length_scale (standard deviation)
for i_episode in range(max_num_of_episodes):
print('Starting episode', i_episode+1)
# Initiate environement, agent and oracle
observation = env.reset()
# Cumulative reward set to 0
reward_c = 0.
feedback_e_1 = 0
feedback_e_2 = 0
for t in range(env._max_episode_steps+1):
class Normal_SEKernel(Kernel):
""" kernels for Normal pdf convolved with Squared Exponential kernel.
:math:`\\varphi(r) = \\exp(\\-theta_2^2||x-x'||^2) + \\theta_3^2\\delta_{ii'}` which is
positive definite.
"""
def __init__(self, Sigma):
super().__init__()
# squared exponential kernel for GP
self.GPkernel = ConstantKernel(1, (1e-3, 1e3)) * RBF(1, (1e-3, 100)) + \
WhiteKernel(1e-3, (1e-6, 1e-1))
self.Sigma = Sigma
self.dim = Sigma.shape[1]
def updatekernel(self, kernel):
""" update the GPkernel with a new kernel
"""
self.GPkernel = kernel
def get_hyperparameters(self):
""" get hyperparameters from GPkernel
"""
theta0 = self.GPkernel.get_params()['k1__k1__constant_value']
theta1 = self.GPkernel.get_params()['k1__k2__length_scale']
theta2 = self.GPkernel.get_params()['k2__noise_level']
return np.array([theta0, theta1, theta2])
def mollifiedx1(self, X, Y):
""" Once mollified kernel
"""
# get optimized hyperparameters
theta = self.get_hyperparameters()
# A + 2Sigma
A = (theta[1]**2) * np.eye(self.dim)
B = A + self.Sigma
Binv = np.linalg.inv(B)
# inv(A + Sigma)
# constant
c = theta[0] * np.sqrt(np.linalg.det(A) / np.linalg.det(B))
# kernel
kernel = lambda i, j: c * np.exp(-0.5 *
(X[i] - Y[j]) @ Binv @ (X[i] - Y[j]))
# kernel
g = np.vectorize(kernel)
# make kernel matrix
K = np.fromfunction(g, (len(X), len(Y)), dtype=int)
return K
def mollifiedx2(self, X):
""" Twice mollified kernel
"""
# get optimized hyperparameters
theta = self.get_hyperparameters()
# A + 2Sigma
A = (theta[1]**2) * np.eye(self.dim)
B = A + 2 * self.Sigma
Binv = np.linalg.inv(B)
# inv(A + 2Sigma)
# constant
c = theta[0] * np.sqrt(np.linalg.det(A) / np.linalg.det(B))
# kernel
kernel = lambda i, j: c * np.exp(-0.5 *
(X[i] - X[j]) @ Binv @ (X[i] - X[j]))
g = np.vectorize(kernel)
# make kernel matrix
K = np.fromfunction(g, (len(X), len(X)),
dtype=int) + (theta[2]) * np.eye(len(X))
return K
