def randomize(self, seed):
np.random.seed(seed)
kernel = generate_rbfkern(2, 1.0, 1.5)
xs = generate_grid(lb=-2.0, ub=2.0, res=self.res)
ys = np.random.normal(size=(self.res * self.res, 1))
model = GPy.models.GPRegression(xs, ys, kernel, noise_var=1e-10)
x_disc = generate_grid(lb=-2.0, ub=2.0, res=self.true_res)
self.truesignal = model.posterior_samples(x_disc, size=1).reshape(
self.true_res, self.true_res)
ys = np.random.normal(size=(self.res * self.res, 1))
model = GPy.models.GPRegression(xs, ys, kernel, noise_var=1e-10)
x_disc = generate_grid(lb=-2.0, ub=2.0, res=self.true_res)
print(x_disc)
self.randsignal = model.posterior_samples(x_disc, size=1).reshape(
self.true_res, self.true_res)
ys = np.random.normal(size=(self.res * self.res, 1))
model = GPy.models.GPRegression(xs, ys, kernel, noise_var=1e-10)
x_disc = generate_grid(lb=-2.0, ub=2.0, res=self.true_res)
self.randsignal2 = model.posterior_samples(x_disc, size=1).reshape(
self.true_res, self.true_res)
ys = np.random.normal(size=(self.res * self.res, 1))
model = GPy.models.GPRegression(xs, ys, kernel, noise_var=1e-10)
x_disc = generate_grid(lb=-2.0, ub=2.0, res=self.true_res)
self.randsignal3 = model.posterior_samples(x_disc, size=1).reshape(
self.true_res, self.true_res)
def load_prior_data(self, start_loc=[0, 0]):
''' inputs: none
outputs:
x_task: a numpy array of input-values for each sample for each function
y_task: a numpy array of output-values for each sample from each function
num_funcs: the number of state variables in the dataset
'''
n_sample = [13**2, 13**2, 1, 1]
num_funcs = len(self.func)
x_task = np.array([None for i in range(num_funcs)])
y_task = np.array([None for i in range(num_funcs)])
### generate training data from functions
for i in range(num_funcs):
if i == 2:
#x_task[i] = np.array([np.random.rand(n_sample[i]) * -1, np.random.rand(n_sample[i]) * -1]).T
x_task[i] = np.array([[start_loc[0]], [start_loc[1]]]).T
elif i == 1:
#poss = [(-2.0, 0.0), (2.0, 0.0), (0.0, -2.0), (0.0, 2.0)]
#real = np.random.choice(poss)
real = (0, 1.8)
x_task[i] = generate_grid(real[0], real[1], int(math.sqrt(n_sample[i])))
print('x_task:', x_task[i])
else:
x_task[i] = generate_grid(-1.8, 1.8, int(math.sqrt(n_sample[i])))
y_task[i] = np.array([self.func[i](xp) for xp in x_task[i]])
return x_task, y_task, num_funcs
def plotMOGP(model, x_train, output, title, res=30):
X_guess = np.concatenate(
[generate_grid(-2.0, 2.0, res),
np.ones((res * res, 1)) * output],
axis=1)
Y_pred = model.predict(X_guess)
plt.figure()
CS = plt.contour(np.linspace(-2, 2, res), np.linspace(-2, 2, res),
Y_pred[0].reshape(res, res))
plt.clabel(CS, inline=1, fontsize=10)
#print(x_train[output].T[0])
plt.plot(x_train[output].T[0], x_train[output].T[1])
plt.title('Mean, ' + title)
if 'signal field' in title:
plt.scatter(points.T[0], points.T[1], c="r")
elif 'hardness field' in title:
plt.scatter(points.T[0], points.T[1], c="r")
plt.figure()
CS = plt.contour(np.linspace(-2, 2, res), np.linspace(-2, 2, res), \
np.sqrt(Y_pred[1].reshape(res, res)))
plt.clabel(CS, inline=1, fontsize=10)
plt.scatter(x_train[output].T[0], x_train[output].T[1])
plt.title('Stdev, ' + title)
def evaluate_MSE(self, true_func, res=41):
data = np.concatenate([generate_grid(-2.0, 2.0, res), np.ones((res*res, 1))*2], axis=1)
model = self.infer_joint_distribution(res=res)
m_pred, s_pred = model.predict(data)
m_true = np.apply_along_axis(true_func, axis=1, arr=data).reshape(-1, 1)
return np.sum((m_pred - m_true)**2) / (res * res)
def infer_joint_distribution(self, res):
### train GP priors
priors = [[] for i in range(self.num_features)]
for i in range(self.num_features):
priors[i] = GP(self.x_train[i], self.y_train[i], self.kernel)
#plotGP(priors[i], x_train[i], 'Feature '+str(i))
m = np.ndarray((self.num_features, res * res))
s = np.ndarray((self.num_features, res * res))
x_candidates = generate_grid(-2, 2, res)
### sample variable distributions
for x in range(len(x_candidates)):
for i in range(self.num_features):
pred = priors[i].predict(np.array([x_candidates[x]]))
m[i, x], s[i, x] = pred[0][0][0], pred[1][0][0]
### compute weighted covariance
W = self.generate_weights(s)
X = np.array([m[i] - np.mean(m[i]) for i in range(self.num_features)])
w_cov = np.cov(X, aweights=W)
### use lasso to estimate a sparse precision matrix? (GGM model estimation)
### construct correlated joint distribution GP
joint_distribution = MOGP(self.x_train, self.y_train, w_cov,
self.kernel)
#plotMOGP(joint_distribution, x_train, 2, 'Output 2')
return joint_distribution
def policy(self, alpha, inference_model, loc):
stepsize = 0.5
candidates = generate_grid(-2.0, 2.0, self.res)
### Entropy minimization acquisition function
'''
min_entropy = inference_model.compute_entropy()
print('initial entropy')
print(inference_model.compute_entropy())
for candidate in candidates:
print(candidate)
predictedBelief = inference_model.copy()
observation = predictedBelief.observe(np.array([[candidate[0], candidate[1], self.observed_feature]]))
predictedBelief.update(np.array([candidate[0], candidate[1], self.observed_feature]), observation, self.observed_feature)
print(predictedBelief.compute_entropy())
if predictedBelief.compute_entropy() <= min_entropy:
min_entropy = predictedBelief.compute_entropy()
nextSample = candidate
'''
# UCB acquisition function
mean, var = inference_model.infer_independent_distribution(feature=2, res=30).predict(candidates)
dist = np.linalg.norm(candidates - loc, axis=1)
dist_corrected = np.amax(dist.reshape(-1, 1), axis=1, initial=0.3).reshape(1, -1).T
ucb = (mean + 2.0 * var) / dist_corrected
#ucb = (mean - 0.0) * norm.cdf((mean - 0.0) / np.sqrt(var)) + np.sqrt(var) * norm.pdf((mean - 0.0) / np.sqrt(var))
nextSample = (candidates[np.argmax(ucb)] - loc) / (np.linalg.norm(candidates[np.argmax(ucb)] - loc) * 3) + loc
return nextSample
def infer_joint_distribution(self, res):
### train GP priors
priors = [[] for i in range(self.num_features)]
for i in range(self.num_features):
priors[i] = GP(self.x_train[i], self.y_train[i], self.kernel)
#plotGP(priors[i], x_train[i], 'Feature '+str(i))
m_obs = [[] for i in range(self.num_features)]
m_exp = [[] for i in range(self.num_features)]
s_obs = [[] for i in range(self.num_features)]
x_candidates = generate_grid(-2, 2, res)
### sample variable distributions
#for x in range(len(x_candidates)):
for i in range(self.num_features):
pred_obs = priors[2].predict(self.x_train[i])
m_obs[i], s_obs[i] = pred_obs[0].flatten(), pred_obs[1].flatten()
m_expert[i] = self.y_train[i]
#print(pred[0].flatten())
self.count = np.zeros(self.num_features)
m_obs_trust = [[] for i in range(self.num_features)]
m_exp_trust = [[] for i in range(self.num_features)]
for i in range(self.num_features):
for j in range(len(self.x_train[i])):
if s_obs[i][
j] < 0.3: # if sufficiently confident about feature of interest where the side feature has been observed
count[
i] += 1 # we know more about the relationship between those features
self.feature_var = np.array([1.0 / math.sqrt(n) for n in count])
#print(m[0, :])
#for x in range(len(x_candidates)):
# for i in range(self.num_features):
# pred = priors[i].predict(np.array([x_candidates[x]]))
# m[i, x], s[i, x] = pred[0][0][0], pred[1][0][0]
for i in range(self.num_features):
pred = priors[i].predict(x_candidates)
m[i], s[i] = pred[0].flatten(), pred[1].flatten()
### compute weighted covariance
W = self.generate_weights(s)
X = np.array([m[i] - np.mean(m[i]) for i in range(self.num_features)])
w_cov = np.cov(X, aweights=W)
### use lasso to estimate a sparse precision matrix? (GGM model estimation)
### construct correlated joint distribution GP
joint_distribution = MOGP(self.x_train, self.y_train, w_cov,
self.kernel)
#plotMOGP(joint_distribution, x_train, 2, 'Output 2')
return joint_distribution
def evaluate_MSE(self, true_func, res=30):
data = generate_grid(-2.0, 2.0, res)
self.model = GP(self.x_train[2], self.y_train[2], self.kernel)
m_pred, s_pred = self.model.predict(data)
m_true = np.apply_along_axis(true_func, axis=1,
arr=data).reshape(-1, 1)
return np.sum((m_pred - m_true)**2) / (res * res)
def exploit(self, model):
joint_distribution = model.infer_joint_distribution(res=self.res)
independent_distribution = model.infer_independent_distribution(feature=2, res=self.res)
x_candidates = np.concatenate([generate_grid(-2.0, 2.0, self.res), np.ones((self.res*self.res, 1))*2], axis=1)
utilities = self.compute_utilities(joint_distribution, independent_distribution, x_candidates)
nextSample = x_candidates[np.argmax(utilities)]
return nextSample #, joint_distribution, independent_distribution
def __init__(self, points):
self.points = points
self.func = [self.hardness_field, self.depth_field, self.signal_field, self.random_field]
self.func_names = ['hardness field', 'depth field', 'signal field', 'random field']
self.res = 8
kernel = generate_rbfkern(2, 1.0, 1.5)
xs = generate_grid(lb=-2.0, ub=2.0, res=self.res)
ys = np.random.normal(size=(self.res * self.res, 1))
print(xs, ys)
self.true_res = 41
model = GPy.models.GPRegression(xs, ys, kernel, noise_var=1e-10)
x_disc = generate_grid(lb=-2.0, ub=2.0, res=self.true_res)
print(x_disc)
#model.plot()
#self.truesignal = model.predict(x_disc)[0].reshape(true_res, true_res)
#print(self.truesignal)
#kernel = lambda x1, x2: math.exp(- np.linalg.norm(x1 - x2)**2 / 2.0)
#training_inputs = generate_grid(lb=-2.0, ub=2.0, res=20)
#K =
#for i in range(400):
# for j in range(400):
# kernel(training_inputs[i], training_inputs[j])
self.truesignal = model.posterior_samples(x_disc, size=1).reshape(self.true_res, self.true_res)
kernel = generate_rbfkern(2, 1.0, 1.5)
xs = generate_grid(lb=-2.0, ub=2.0, res=self.res)
ys = np.random.normal(size=(self.res * self.res, 1))
model = GPy.models.GPRegression(xs, ys, kernel, noise_var=1e-10)
x_disc = generate_grid(lb=-2.0, ub=2.0, res=self.true_res)
print(x_disc)
self.randsignal = model.posterior_samples(x_disc, size=1).reshape(self.true_res, self.true_res)
print(self.truesignal)
def compute_entropy(self, res=21):
#print(self.x_train[2], self.y_train[2])
self.model = GP(self.x_train[2], self.y_train[2], self.kernel)
x_candidates = generate_grid(-2.0, 2.0, res)
mean, var = self.model.predict(x_candidates)
self.entropy = np.sum(np.log(var))
#self.entropy = mean + 0.3 * var
#print(self.entropy)
return self.entropy
def compute_entropy(self, res=21):
#model = self.infer_joint_distribution(res=res)
#x_candidates = np.concatenate([generate_grid(-2.0, 2.0, res), np.ones((res*res, 1))*2], axis=1)
model = self.infer_independent_distribution(2, res=res)
x_candidates = generate_grid(-2.0, 2.0, res)
mean, var = model.predict(x_candidates)
entropy = np.sum(np.log(var))
print(entropy)
return entropy
def explore(self, model):
joint_distribution = model.infer_joint_distribution(res=self.res)
independent_distribution = model.infer_independent_distribution(feature=2, res=self.res)
### compute predicted novelty metric
x_candidates = np.concatenate([generate_grid(-2.0, 2.0, self.res), np.ones((self.res*self.res, 1))*0], axis=1)
novelties = self.compute_novelties(joint_distribution, model.x_train)
nextSample = model.x_train[1][np.argmax(novelties)]
#nextSample = x_candidates[np.random.randint(len(x_candidates))]
### Sample and update model
return nextSample #, joint_distribution, independent_distribution
def load_environment(self, env, start_loc=[0, 0]):
self.x_train, self.y_train, self.num_features = env.load_prior_data(start_loc)
# compute true covariance
xs = generate_grid(-2.0, 2.0, res=self.res)
y_true = np.zeros((self.num_features, self.res*self.res))
for feature in range(self.num_features):
y_true[feature, :] = np.apply_along_axis(env.func[feature], axis=1, arr=xs).reshape(-1, 1).flatten()
Y_true = np.array([y_true[i] - np.mean(y_true[i]) for i in range(self.num_features)])
print("loaded")
self.cov = np.cov(Y_true)
self.env = env
def plot_environment():
env = new SideInformationEnvironmentRandomGP()
num_features = len(env.func)
res=20
x_test = generate_grid(lb=-2.0, ub=2.0, res=res)
y_test = [[] for i in range(num_features)]
for i in range(num_features):
y_test[i] = [env.observe(xo, i) for xo in x_test]
for i in range(num_features):
plt.figure()
CS = plt.contour(np.linspace(-2, 2, res), np.linspace(-2, 2, res), y_test[i].reshape(res, res))
plt.clabel(CS, inline=1, fontsize=10)
plt.plot(x_train[:, 0], x_train[:, 1])
plt.title('i')
def compute_entropy(self, res=21):
#model = self.infer_joint_distribution(res=res)
#x_candidates = np.concatenate([generate_grid(-2.0, 2.0, res), np.ones((res*res, 1))*2], axis=1)
self.compute_belief_variance()
model = self.infer_independent_distribution(2, res=res)
x_candidates = generate_grid(-2.0, 2.0, res)
mean, var = model.predict(x_candidates)
entropy = np.sum(np.log(var))
beta = 100
entropy += beta * np.sum(np.log(self.feature_var))
print(self.count)
print('Map entropy', np.sum(np.log(var)))
print('Knowledge model entropy',
beta * np.sum(np.log(self.feature_var)))
print(entropy)
return entropy
def plot_environment():
env = SideInformationEnvironmentRandomGP(points=[])
num_features = len(env.func)
res=20
x_test = generate_grid(lb=-2.0, ub=2.0, res=res)
y_test = [[] for i in range(num_features)]
for i in range(num_features):
y_test[i] = np.array([env.observe(xo, i) for xo in x_test])
titles = ["Temperature", "Sea Floor Depth", "Luminosity", "Ocean Current Intensity"]
plt.figure()
for i in range(num_features):
plt.subplot(1, num_features, i+1)
CS = plt.contourf(np.linspace(0, 600, res), np.linspace(0, 600, res), y_test[i].reshape(res, res))
#plt.clabel(CS, inline=1, fontsize=10)
plt.title(titles[i])
plt.show()
def plotGP(model, x_train, title, res=30):
X_guess = generate_grid(-2.0, 2.0, res)
Y_pred = model.predict(X_guess)
plt.figure()
CS = plt.contour(np.linspace(-2, 2, res), np.linspace(-2, 2, res),
Y_pred[0].reshape(res, res))
plt.clabel(CS, inline=1, fontsize=10)
plt.plot(x_train[:, 0], x_train[:, 1])
plt.title('Mean, ' + title)
if 'signal field' in title:
plt.scatter(points.T[0], points.T[1], c="r")
elif 'hardness field' in title:
plt.scatter(points.T[0], points.T[1], c="r")
plt.figure()
CS = plt.contour(np.linspace(-2, 2, res), np.linspace(-2, 2, res), \
np.sqrt(Y_pred[1].reshape(res, res)))
plt.clabel(CS, inline=1, fontsize=10)
plt.plot(x_train[:, 0], x_train[:, 1])
plt.title('Stdev, ' + title)
def load_prior_data(self, start_loc=[0, 0]):
''' inputs: none
outputs:
x_task: a numpy array of input-values for each sample for each function
y_task: a numpy array of output-values for each sample from each function
num_funcs: the number of state variables in the dataset
'''
n_sample = [100, 100, 1, 10]
num_funcs = len(self.func)
x_task = np.array([None for i in range(num_funcs)])
y_task = np.array([None for i in range(num_funcs)])
### generate training data from functions
for i in range(num_funcs):
if i == 2:
#x_task[i] = np.array([np.random.rand(n_sample[i]) * -1, np.random.rand(n_sample[i]) * -1]).T
x_task[i] = np.array([[start_loc[0]], [start_loc[1]]]).T
else:
x_task[i] = generate_grid(-2.0, 2.0,
int(math.sqrt(n_sample[i])))
y_task[i] = np.array([self.func[i](xp) for xp in x_task[i]])
return x_task, y_task, num_funcs
