def GPLVM_model(name):
Q = 5
M = 20
N = Y.shape[0]
X_mean = gpflow.models.PCA_reduce(Y, Q) # Initialise via PCA
Z = np.random.permutation(X_mean.copy())[:M]
fHmmm = False
if (fHmmm):
k = (kernels.RBF(3, ARD=True, active_dims=slice(0, 3)) +
kernels.Linear(2, ARD=False, active_dims=slice(3, 5)))
else:
k = (kernels.RBF(3, ARD=True, active_dims=[0, 1, 2]) +
kernels.Linear(2, ARD=False, active_dims=[3, 4]))
# GPLVM
GPLVM = gpflow.models.GPLVM(Y=Y, latent_dim=Q, X_mean=X_mean, kern=k)
opt = gpflow.train.ScipyOptimizer()
GPLVM.compile()
opt.minimize(GPLVM) #, options=dict(disp=True, maxiter=100))
# Compute and sensitivity to input
# print(m.kern.kernels)
kern = GPLVM.kern.kernels[0]
sens = np.sqrt(kern.variance.read_value()) / kern.lengthscales.read_value()
print(GPLVM.kern)
print(sens)
# fig, ax = plt.subplots()
# ax.bar(np.arange(len(kern.lengthscales.read_value())) , sens, 0.1, color='y')
# ax.set_title('Sensitivity to latent inputs')
# plt.savefig("../res/oils_sen.png")
# plt.close(fig)
return GPLVM, sens
def BGPLVM_model(name, Q=10, M=20):
np.random.seed(22)
# Create Bayesian GPLVM model using additive kernel
# Q = 5
# M = 20 # number of inducing pts
N = Y.shape[0]
X_mean = gpflow.models.PCA_reduce(Y, Q) # Initialise via PCA
# X_mean = np.random.normal(size = [N, Q])
Z = np.random.permutation(X_mean.copy())[:M]
fHmmm = False
if (fHmmm):
k = (kernels.RBF(3, ARD=True, active_dims=slice(0, 3)) +
kernels.Linear(2, ARD=False, active_dims=slice(3, 5)))
else:
# k = (kernels.RBF(3, ARD=True, active_dims=[0,1,2]) +
# kernels.Linear(2, ARD=False, active_dims=[3, 4]))
k = kernels.RBF(Q, ARD=True)
# Bayesian GPLVM
BGPLVM = gpflow.models.BayesianGPLVM(X_mean=X_mean,
X_var=0.1 * np.ones((N, Q)),
Y=Y,
kern=k,
M=M,
Z=Z)
BGPLVM.likelihood.variance = 0.01
opt = gpflow.train.ScipyOptimizer()
BGPLVM.compile()
opt.minimize(BGPLVM, disp=False,
maxiter=1000) #, options=dict(disp=True, maxiter=100))
# print("###############################")
# print(BGPLVM.X_mean.read_value(), BGPLVM.X_var.read_value())
# print("###############################")
# Compute and sensitivity to input
# print(m.kern.kernels)
kern = BGPLVM.kern
sens = np.sqrt(kern.variance.read_value()) / kern.lengthscales.read_value()
print(BGPLVM.kern)
print(sens)
fig, ax = plt.subplots()
ax.bar(np.arange(len(kern.lengthscales.read_value())),
sens,
0.1,
color='y')
ax.set_title('Sensitivity to latent inputs')
plt.savefig("../res/{}_sen_bgplvm_Q{}_M{}.png".format(name, Q, M))
plt.close(fig)
with open("../res/{}_bgplvm_Q{}_M{}.pickle".format(name, Q, M),
"wb") as res:
pickle.dump(BGPLVM.X_mean.read_value(), res)
return BGPLVM, sens
return lik, sq_diff, m, v
if __name__ == "__main__":
np.random.seed(22)
n_input = 100
n_test = 20
X = np.random.rand(n_input, 1)
Y = np.sin(
2 * X) + 0.2 * np.cos(22 * X) + np.random.randn(n_input, 1) * 0.1
X_test = np.random.rand(n_test, 1)
F_test = np.sin(2 * X_test) + 0.2 * np.cos(22 * X_test)
Xs = np.linspace(0, 1, 100)[:, None]
Fs = np.sin(2 * Xs) + 0.2 * np.cos(22 * Xs)
k = kernels.Matern32(1) + kernels.Linear(1)
#
#
# # Gaussian Process Regression
# name = "1D_sim_GPR"
# m = GPR(X, Y, kern=k)
# m.likelihood.variance = 0.01
# # print(m.as_pandas_table())
#
# # Optimization
# m.compile()
# opt= ScipyOptimizer()
# opt.minimize(m, disp = False)
# # print(m.as_pandas_table())
#
def RVBGPLVM_model(name, Q=10, M=20, lamb=20, verbose=False):
np.random.seed(22)
# Create Regularzed GPLVM model using additive kernel
# Q = 5
# M = 20 # number of inducing pts
N, D = Y.shape
X_mean = gpflow.models.PCA_reduce(Y, Q) # Initialise via PCA
Z = np.random.permutation(X_mean.copy())[:M]
fHmmm = False
if (fHmmm):
k = (kernels.RBF(3, ARD=True, active_dims=slice(0, 3)) +
kernels.Linear(2, ARD=False, active_dims=slice(3, 5)))
else:
# k = (kernels.RBF(3, ARD=True, active_dims=[0,1,2]) +
# kernels.Linear(2, ARD=False, active_dims=[3, 4]))
k = kernels.RBF(Q, ARD=True)
# Regularized GPLVM
RVBGPLVM = gpflow.models.RegularizedVBGPLVM(X_mean=X_mean,
X_var=0.1 * np.ones((N, Q)),
U_mean=np.zeros((M, D)),
U_var=0.01 * np.ones((M, D)),
Y=Y,
kern=k,
M=M,
Z=Z,
lamb=lamb)
RVBGPLVM.likelihood.variance = 0.01
opt = gpflow.train.ScipyOptimizer()
RVBGPLVM.compile()
opt.minimize(RVBGPLVM,
disp=False) #, options=dict(disp=True, maxiter=100))
# print(m.X_mean, m.X_var)
# Compute and sensitivity to input
# print(m.kern.kernels)
kern = RVBGPLVM.kern
sens = np.sqrt(kern.variance.read_value()) / kern.lengthscales.read_value()
print(RVBGPLVM.kern)
print(sens)
if verbose:
fig, ax = plt.subplots()
ax.bar(np.arange(len(kern.lengthscales.read_value())),
sens,
0.1,
color='y')
ax.set_title('Sensitivity to latent inputs')
plt.savefig("../res/test/{}_sen_rvbgplvm_Q{}_M{}_LAM{}.png".format(
name, Q, M, lamb))
plt.close(fig)
colors = cm.rainbow(np.linspace(0, 1, len(np.unique(labels))))
sens_order = np.argsort(sens)
fig, ax = plt.subplots()
for i, c in zip(np.unique(labels), colors):
ax.scatter(RVBGPLVM.X_mean.read_value()[labels == i,
sens_order[-1]],
RVBGPLVM.X_mean.read_value()[labels == i,
sens_order[-2]],
color=c,
label=i)
ax.set_title('RVBGPLVM LAM = {}'.format(lamb))
ax.scatter(RVBGPLVM.feature.Z.read_value()[:, sens_order[-1]],
RVBGPLVM.feature.Z.read_value()[:, sens_order[-2]],
label="IP",
marker='x')
plt.savefig("../res/test/RVBGPLVM_LAM{}.png".format(lamb))
loglik = RVBGPLVM.compute_log_likelihood()
np.savetxt("../res/test/RVBGPLVM_LAM{}.csv".format(lamb),
np.asarray([loglik]))
with open(
"../res/{}_rvbgplvm_Q{}_M{}_LAM{}.pickle".format(name, Q, M, lamb),
"wb") as res:
pickle.dump([
RVBGPLVM.X_mean.read_value(),
RVBGPLVM.feature.Z.read_value(), labels, colors, sens_order
], res)
return RVBGPLVM, sens