def setUp(self):
with self.test_session():
self.rng = np.random.RandomState(0)
self.N = 4
self.D = 2
self.Xmu = self.rng.rand(self.N, self.D)
self.Z = self.rng.rand(3, self.D)
unconstrained = self.rng.randn(self.N, 2 * self.D, self.D)
t = TriDiagonalBlockRep()
self.Xcov = t.forward(unconstrained)
variance = 0.3 + self.rng.rand()
k1 = ekernels.RBF(1, variance, active_dims=[0])
k2 = ekernels.RBF(1, variance, active_dims=[1])
klin = ekernels.Linear(1, variance, active_dims=[1])
self.ekernels = [k1, k2, klin]
k1 = ekernels.RBF(2, variance)
k2 = ekernels.RBF(2, variance)
klin = ekernels.Linear(2, variance)
self.pekernels = [k1, k2, klin]
k1 = kernels.RBF(1, variance, active_dims=[0])
klin = kernels.Linear(1, variance, active_dims=[1])
self.kernels = [k1, klin]
k1 = kernels.RBF(2, variance)
klin = kernels.Linear(2, variance)
self.pkernels = [k1, klin]
def setUp(self):
self.test_graph = tf.Graph()
with self.test_context():
self.N = 4
self.D = 2
self.rng = np.random.RandomState(0)
self.Xmu = self.rng.rand(self.N, self.D)
self.Z = self.rng.rand(3, self.D)
unconstrained = self.rng.randn(self.N, 2 * self.D, self.D)
t = TriDiagonalBlockRep()
self.Xcov = t.forward(unconstrained)
variance = 0.3 + self.rng.rand()
k1 = ekernels.RBF(1, variance, active_dims=[0])
k2 = ekernels.RBF(1, variance, active_dims=[1])
klin = ekernels.Linear(1, variance, active_dims=[1])
self.ekernels = [k1, k2, klin] # Kernels doing the expectation in closed form, doing the slicing
k1 = ekernels.RBF(1, variance)
k2 = ekernels.RBF(1, variance)
klin = ekernels.Linear(1, variance)
self.pekernels = [k1, k2, klin] # kernels doing the expectations in closed form, without slicing
k1 = kernels.RBF(1, variance, active_dims=[0])
klin = kernels.Linear(1, variance, active_dims=[1])
self.kernels = [k1, klin]
k1 = kernels.RBF(1, variance)
klin = kernels.Linear(1, variance)
self.pkernels = [k1, klin]
def setUp(self):
self.test_graph = tf.Graph()
with self.test_context():
self.rng = np.random.RandomState(0)
self.N = 4
self.D = 2
self.Xmu = self.rng.rand(self.N, self.D)
self.Z = self.rng.rand(3, self.D)
unconstrained = self.rng.randn(self.N, 2 * self.D, self.D)
t = TriDiagonalBlockRep()
self.Xcov_pairwise = t.forward(unconstrained)
self.Xcov = self.Xcov_pairwise[0] # no cross-covariances
variance = 0.3 + self.rng.rand()
k1 = ekernels.RBF(1, variance, active_dims=[0])
k2 = ekernels.RBF(1, variance, active_dims=[1])
klin = ekernels.Linear(1, variance, active_dims=[1])
self.ekernels = [k1, k2, klin]
k1 = ekernels.RBF(2, variance)
k2 = ekernels.RBF(2, variance)
klin = ekernels.Linear(2, variance)
self.pekernels = [k1, k2, klin]
k1 = kernels.RBF(1, variance, active_dims=[0])
klin = kernels.Linear(1, variance, active_dims=[1])
self.kernels = [k1, klin]
k1 = kernels.RBF(2, variance)
klin = kernels.Linear(2, variance)
self.pkernels = [k1, klin]
def myKL2(self):
X = np.array([[1., 2., 3.], [1., 2.1, 3.], [1.1, 2., 3.],
[1., 2., 3.1]])
Y = np.array([[1.], [2.], [.2], [3.]])
Z = np.array([[1., 2., 3.], [1.3, 2.2, 3.1]])
A = np.tril(np.random.rand(6, 6)) #"cholesky" of S_M
B = np.random.rand(6, 1) #mu_M
all_kernels = [
kernels.RBF(3),
kernels.RBF(2, lengthscales=3., variance=2.)
]
all_Zs, all_mfs = init_linear(X, Z, all_kernels)
mylayers = Fully_Coupled_Layers(X,
Y,
Z,
all_kernels,
all_mfs,
all_Zs,
mu_M=B,
S_M=A)
kl = mylayers.KL()
session = get_default_session()
kl = session.run(kl)
Kmm1 = all_kernels[0].compute_K_symm(
all_Zs[0]) + np.eye(Z.shape[0]) * settings.jitter
Kmm2 = all_kernels[1].compute_K_symm(
all_Zs[1]) + np.eye(all_Zs[1].shape[0]) * settings.jitter
K_big = scipy.linalg.block_diag(Kmm1, Kmm1, Kmm2)
tfKL = gauss_kl(tf.constant(B),
tf.constant(A[np.newaxis]),
K=tf.constant(K_big))
sess = tf.Session()
return kl, sess.run(tfKL)
def setUp(self):
self.test_graph = tf.Graph()
self.rng = np.random.RandomState(
1) # this seed works with 60 GH points
self.N = 4
self.D = 2
self.Xmu = self.rng.rand(self.N, self.D)
self.Z = self.rng.rand(2, self.D)
unconstrained = self.rng.randn(self.N, 2 * self.D, self.D)
t = TriDiagonalBlockRep()
self.Xcov = t.forward(unconstrained)
# Set up "normal" kernels
ekernel_classes = [ekernels.RBF, ekernels.Linear]
kernel_classes = [kernels.RBF, kernels.Linear]
params = [(self.D, 0.3 + self.rng.rand(),
self.rng.rand(2) + [0.5, 1.5], None, True),
(self.D, 0.3 + self.rng.rand(), None)]
self.ekernels = [c(*p) for c, p in zip(ekernel_classes, params)]
self.kernels = [c(*p) for c, p in zip(kernel_classes, params)]
# Test summed kernels, non-overlapping
rbfvariance = 0.3 + self.rng.rand()
rbfard = [self.rng.rand() + 0.5]
linvariance = 0.3 + self.rng.rand()
self.kernels.append(
kernels.Add([
kernels.RBF(1, rbfvariance, rbfard, [1], False),
kernels.Linear(1, linvariance, [0])
]))
self.kernels[-1].input_size = self.kernels[-1].input_dim
for k in self.kernels[-1].kern_list:
k.input_size = self.kernels[-1].input_size
self.ekernels.append(
ekernels.Add([
ekernels.RBF(1, rbfvariance, rbfard, [1], False),
ekernels.Linear(1, linvariance, [0])
]))
self.ekernels[-1].input_size = self.ekernels[-1].input_dim
for k in self.ekernels[-1].kern_list:
k.input_size = self.ekernels[-1].input_size
# Test summed kernels, overlapping
rbfvariance = 0.3 + self.rng.rand()
rbfard = [self.rng.rand() + 0.5]
linvariance = 0.3 + self.rng.rand()
self.kernels.append(
kernels.Add([
kernels.RBF(self.D, rbfvariance, rbfard, active_dims=[0, 1]),
kernels.Linear(self.D, linvariance, active_dims=[0, 1])
]))
self.ekernels.append(
ekernels.Add([
ekernels.RBF(self.D, rbfvariance, rbfard, active_dims=[0, 1]),
ekernels.Linear(self.D, linvariance, active_dims=[0, 1])
]))
self.assertTrue(self.ekernels[-2].on_separate_dimensions)
self.assertTrue(not self.ekernels[-1].on_separate_dimensions)
def rbf_lin_sum_kern2():
return kernels.Sum([
kernels.Linear(Data.D_in, variance=rng.rand()),
kernels.RBF(Data.D_in, variance=rng.rand(), lengthscales=rng.rand() + 1.),
kernels.Linear(Data.D_in, variance=rng.rand()),
kernels.RBF(Data.D_in, variance=rng.rand(), lengthscales=rng.rand() + 1.),
])
def test_2d(self):
with self.test_context():
# test default Z on 2_D example
Q = 2 # latent dimensions
X_mean = gpflow.models.PCA_reduce(self.Y, Q)
k = kernels.RBF(Q, ARD=False)
m = gpflow.models.BayesianGPLVM(X_mean=X_mean,
X_var=np.ones((self.N, Q)),
Y=self.Y,
kern=k,
M=self.M)
linit = m.compute_log_likelihood()
opt = gpflow.train.ScipyOptimizer()
opt.minimize(m, maxiter=2)
self.assertTrue(m.compute_log_likelihood() > linit)
# test prediction
Xtest = self.rng.randn(10, Q)
mu_f, var_f = m.predict_f(Xtest)
mu_fFull, var_fFull = m.predict_f_full_cov(Xtest)
self.assertTrue(np.allclose(mu_fFull, mu_f))
# check full covariance diagonal
for i in range(self.D):
self.assertTrue(
np.allclose(var_f[:, i], np.diag(var_fFull[:, :, i])))
def __init__(self,
Y,
latent_dim,
X_mean=None,
kern=None,
mean_function=Zero()):
"""
Initialise GPLVM object. This method only works with a Gaussian likelihood.
:param Y: data matrix, size N (number of points) x D (dimensions)
:param Z: matrix of inducing points, size M (inducing points) x Q (latent dimensions)
:param X_mean: latent positions (N x Q), for the initialisation of the latent space.
:param kern: kernel specification, by default RBF
:param mean_function: mean function, by default None.
"""
if kern is None:
kern = kernels.RBF(latent_dim, ARD=True)
if X_mean is None:
X_mean = PCA_initialization(Y, latent_dim)
assert X_mean.shape[1] == latent_dim, \
'Passed in number of latent ' + str(latent_dim) + ' does not match initial X ' + str(X_mean.shape[1])
self.num_latent = X_mean.shape[1]
assert Y.shape[
1] >= self.num_latent, 'More latent dimensions than observed.'
GPR.__init__(self, X_mean, Y, kern, mean_function=mean_function)
del self.X # in GPLVM this is a Param
self.X = Param(X_mean)
def setUp(self):
with self.test_session():
self._threshold = 0.5
self.rng = np.random.RandomState(0)
self.N = 4
self.D = 2
# Test summed kernels, non-overlapping
rbfvariance = 0.3 + self.rng.rand()
rbfard = [self.rng.rand() + 0.5]
linvariance = 0.3 + self.rng.rand()
self.kernel = kernels.Prod([
kernels.RBF(1, rbfvariance, rbfard, [1], False),
kernels.Linear(1, linvariance, [0])
])
self.ekernel = ekernels.Prod([
ekernels.RBF(1, rbfvariance, rbfard, [1], False),
ekernels.Linear(1, linvariance, [0])
])
self.Xmu = self.rng.rand(self.N, self.D)
self.Xcov = self.rng.rand(self.N, self.D)
self.Z = self.rng.rand(2, self.D)
def train(self, Y):
self.models = []
N = Y.shape[0]
for i in range(self.n_layers):
M = self.inducing_pts[i]
kernel = kernels.RBF(self.kernel_dims[i],
ARD=True,
active_dims=slice(0, self.kernel_dims[i]))
Q = self.latent_dims[i]
X_mean = gpflow.models.PCA_reduce(Y, Q)
Z = np.random.permutation(X_mean.copy())[:M]
m1 = gpflow.models.BayesianGPLVM(X_mean=X_mean,
X_var=0.1 * np.ones((N, Q)),
Y=Y,
kern=kernel,
M=M,
Z=Z)
m1.likelihood.variance = 0.01
m1.compile()
opt = gpflow.train.ScipyOptimizer()
opt.minimize(m1,
maxiter=gpflow.test_util.notebook_niter(
self.max_iters))
self.models.append(m1)
Y = m1.X_mean.read_value()
self.means = Y.copy()
def rbf_lin_prod_kern():
return kernels.Product([
kernels.RBF(1,
variance=rng.rand(),
lengthscales=rng.rand() + 1.,
active_dims=[0]),
kernels.Linear(1, variance=rng.rand(), active_dims=[1])
])
def create_meta_learning_model(**kwargs):
Z = np.random.randn(kwargs["n_inducing_points"],
kwargs["dim_in"] + kwargs["dim_h"])
mean_func = None
kernel = kernels.RBF(kwargs["dim_in"] + kwargs["dim_h"], ARD=True)
likelihood = likelihoods.MultiGaussian(dim=kwargs["dim_out"])
latent_to_conf_space_kernel = kernels.RBF(kwargs["dim_h"], ARD=True)
latent_to_conf_space_likelihood = likelihoods.Gaussian()
model = MLSVGP(
dim_in=kwargs["dim_in"],
dim_out=kwargs["dim_out"],
dim_h=kwargs["dim_h"],
num_h=kwargs["n_envs"],
kern=kernel,
likelihood=likelihood,
mean_function=mean_func,
Z=Z,
observed_config_space_dim=kwargs["observed_config_space_dim"],
latent_to_conf_space_kernel=latent_to_conf_space_kernel,
latent_to_conf_space_likelihood=latent_to_conf_space_likelihood)
return model
def create_model(**kwargs):
if "BASESVGP" in kwargs["model_name"]:
Z = np.random.randn(kwargs["n_inducing"], kwargs["dim_in"])
mean_func = None
kernel = kernels.RBF(kwargs["dim_in"], ARD=True)
likelihood = likelihoods.MultiGaussian(dim=kwargs["dim_out"])
model = BASESVGP(dim_in=kwargs["dim_in"],
dim_out=kwargs["dim_out"],
kern=kernel,
likelihood=likelihood,
mean_function=mean_func,
Z=Z,
name=kwargs["model_name"])
elif kwargs["model_name"] == "MLSVGP":
Z = np.random.randn(kwargs["n_inducing"],
kwargs["dim_in"] + kwargs["dim_h"])
mean_func = None
kernel = kernels.RBF(kwargs["dim_in"] + kwargs["dim_h"], ARD=True)
likelihood = likelihoods.MultiGaussian(dim=kwargs["dim_out"])
model = MLSVGP(dim_in=kwargs["dim_in"],
dim_out=kwargs["dim_out"],
dim_h=kwargs["dim_h"],
num_h=kwargs["n_envs"],
kern=kernel,
likelihood=likelihood,
mean_function=mean_func,
Z=Z,
name=kwargs["model_name"])
return model
def test_1d(self):
with self.test_context():
Q = 1 # latent dimensions
k = kernels.RBF(Q)
Z = np.linspace(0, 1, self.M)
Z = np.expand_dims(Z, Q) # inducing points
m = gpflow.models.BayesianGPLVM(X_mean=np.zeros((self.N, Q)),
X_var=np.ones((self.N, Q)),
Y=self.Y,
kern=k,
M=self.M,
Z=Z)
linit = m.compute_log_likelihood()
opt = gpflow.train.ScipyOptimizer()
opt.minimize(m, maxiter=2)
self.assertTrue(m.compute_log_likelihood() > linit)
def _conv_layer(self,
NHWC_X,
M,
feature_map,
filter_size,
stride,
layer_params=None):
if layer_params is None:
layer_params = {}
NHWC = NHWC_X.shape
view = FullView(input_size=NHWC[1:3],
filter_size=filter_size,
feature_maps=NHWC[3],
stride=stride)
if self.flags.identity_mean:
conv_mean = Conv2dMean(filter_size,
NHWC[3],
feature_map,
stride=stride)
else:
conv_mean = gpflow.mean_functions.Zero()
conv_mean.set_trainable(False)
output_shape = image_HW(view.patch_count) + [feature_map]
H_X = identity_conv(NHWC_X, filter_size, NHWC[3], feature_map, stride)
if len(layer_params) == 0:
conv_features = PatchInducingFeatures.from_images(
NHWC_X, M, filter_size)
else:
conv_features = PatchInducingFeatures(layer_params.get('Z'))
patch_length = filter_size**2 * NHWC[3]
if self.flags.base_kernel == 'rbf':
lengthscales = layer_params.get('base_kernel/lengthscales', 5.0)
variance = layer_params.get('base_kernel/variance', 5.0)
base_kernel = kernels.RBF(patch_length,
variance=variance,
lengthscales=lengthscales)
elif self.flags.base_kernel == 'acos':
base_kernel = kernels.ArcCosine(patch_length, order=0)
else:
raise ValueError("Not a valid base-kernel value")
q_mu = layer_params.get('q_mu')
q_sqrt = layer_params.get('q_sqrt')
conv_layer = ConvLayer(base_kernel=base_kernel,
mean_function=conv_mean,
feature=conv_features,
view=view,
white=self.flags.white,
gp_count=feature_map,
q_mu=q_mu,
q_sqrt=q_sqrt)
if q_sqrt is None:
# Start with low variance.
conv_layer.q_sqrt = conv_layer.q_sqrt.value * 1e-5
return conv_layer, H_X
def rbf_prod_seperate_dims():
return kernels.Product([
kernels.RBF(1, variance=rng.rand(), lengthscales=rng.rand(), active_dims=[0]),
kernels.RBF(1, variance=rng.rand(), lengthscales=rng.rand(), active_dims=[1])
])
def setUp(self):
with self.test_session():
self.rng = np.random.RandomState(0)
self.N = 4
self.D = 2
self.Xmu = self.rng.rand(self.N, self.D)
self.Z = self.rng.rand(2, self.D)
self.Xcov_diag = 0.05 + self.rng.rand(self.N, self.D)
self.Xcov = np.zeros(
(self.Xcov_diag.shape[0], self.Xcov_diag.shape[1],
self.Xcov_diag.shape[1]))
self.Xcov[
(np.s_[:], ) +
np.diag_indices(self.Xcov_diag.shape[1])] = self.Xcov_diag
# Set up "normal" kernels
ekernel_classes = [ekernels.RBF, ekernels.Linear]
kernel_classes = [kernels.RBF, kernels.Linear]
params = [(self.D, 0.3 + self.rng.rand(),
self.rng.rand(2) + [0.5, 1.5], None, True),
(self.D, 0.3 + self.rng.rand(), None)]
self.ekernels = [c(*p) for c, p in zip(ekernel_classes, params)]
self.kernels = [c(*p) for c, p in zip(kernel_classes, params)]
# Test summed kernels, non-overlapping
rbfvariance = 0.3 + self.rng.rand()
rbfard = [self.rng.rand() + 0.5]
linvariance = 0.3 + self.rng.rand()
self.kernels.append(
kernels.Add([
kernels.RBF(1, rbfvariance, rbfard, [1], False),
kernels.Linear(1, linvariance, [0])
]))
self.kernels[-1].input_size = self.kernels[-1].input_dim
for k in self.kernels[-1].kern_list:
k.input_size = self.kernels[-1].input_size
self.ekernels.append(
ekernels.Add([
ekernels.RBF(1, rbfvariance, rbfard, [1], False),
ekernels.Linear(1, linvariance, [0])
]))
self.ekernels[-1].input_size = self.ekernels[-1].input_dim
for k in self.ekernels[-1].kern_list:
k.input_size = self.ekernels[-1].input_size
# Test summed kernels, overlapping
rbfvariance = 0.3 + self.rng.rand()
rbfard = [self.rng.rand() + 0.5]
linvariance = 0.3 + self.rng.rand()
self.kernels.append(
kernels.Add([
kernels.RBF(self.D, rbfvariance, rbfard),
kernels.Linear(self.D, linvariance)
]))
self.ekernels.append(
ekernels.Add([
ekernels.RBF(self.D, rbfvariance, rbfard),
ekernels.Linear(self.D, linvariance)
]))
self.assertTrue(self.ekernels[-2].on_separate_dimensions)
self.assertTrue(not self.ekernels[-1].on_separate_dimensions)
data = np.load('data/three_phase_oil_flow.npz')
Y = data['Y']
labels = data['labels']
print('Number of points x Number of dimensions', Y.shape)
Q = 5
M = 20 # number of inducing pts
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]))
m = gpflow.models.BayesianGPLVM(X_mean=X_mean,
X_var=0.1 * np.ones((N, Q)),
Y=Y,
kern=k,
M=M,
Z=Z)
m.likelihood.variance = 0.01
opt = gpflow.train.ScipyOptimizer()
m.compile()
import numpy as np
import gpflow
import gpflow.kernels as kernels
from gpflow.models.vgpds import VGPDS
from gpflow.training.tensorflow_optimizer import _TensorFlowOptimizer
from gpflow.training.scipy_optimizer import ScipyOptimizer
import matplotlib.pyplot as plt
T = np.linspace(0, 4 * np.pi, 40)
kern = kernels.RBF(2, ARD=True)
#generate some data
Y1 = np.sin(T)
Y2 = np.cos(Y1)
Y3 = Y1 - Y2
Y4 = Y1 + Y2
Y5 = np.multiply(Y1, Y2)
Y = np.stack((Y1, Y2, Y3, Y4, Y5), axis=1)
m = VGPDS(Y, T, kern, num_latent=2)
m.likelihood.variance = 0.01
print('initial parameters')
print(m.as_pandas_table())
print('optimizing parameters')
def __init__(self,
Y,
T,
kern,
M=10,
num_latent=3,
dynamic_kern=None,
Z=None,
KL_weight=None):
"""
Initialise VGPDS. This only works with Gaussian Likelihood for now
:param Y: data matrix, size T (number of time points) x D (dimensions)
:param T: time vector, positive real value, size 1 x T
:param kern: Mapping kernel X -> Y specification, by default RBF
:param M: Number of inducing points
:param num_latent: Number of latent dimension. This is automatically found unless user force latent dimension
:param force_latent_dim: Specify whether strict latent dimension is enforced
:param dynamic_kern: temporal dynamics kernel specification, by default RBF
:param Z: matrix of inducing points
:param KL_weight: Weight of KL . weight of bound = 1 - w(KL)
"""
X_mean = large_PCA(Y, num_latent)
GPModel.__init__(self,
X_mean,
Y,
kern,
likelihood=likelihoods.Gaussian(),
mean_function=Zero())
del self.X # This is a params
self.T = np.transpose(T[np.newaxis])
self.num_latent = num_latent
if KL_weight is None:
self.KL_weight = 0.5
else:
assert KL_weight <= 1
assert KL_weight >= 0
self.KL_weight = KL_weight
#This is only one way to initialize mu_bar_q
mu_bar_q = X_mean
lambda_q = np.ones((self.T.shape[0], self.num_latent))
if dynamic_kern is None:
self.dynamic_kern = kernels.RBF(1) + kernels.Bias(
1) + kernels.White(1)
else:
self.dynamic_kern = dynamic_kern
self.mu_bar_q = Parameter(mu_bar_q)
self.lambda_q = Parameter(lambda_q)
self.num_time, self.num_latent = X_mean.shape
self.output_dim = Y.shape[1]
# inducing points
if Z is None:
# By default we initialize by subset of initial latent points
Z = np.random.permutation(X_mean.copy())[:M]
self.feature = features.InducingPoints(Z)
assert len(self.feature) == M
def test_kernelsActiveDims(self):
''' Test sum and product compositional kernels '''
with self.test_context():
Q = 2 # latent dimensions
X_mean = gpflow.models.PCA_reduce(self.Y, Q)
kernsQuadratu = [
kernels.RBF(1, active_dims=[0]) + kernels.Linear(1, active_dims=[1]),
kernels.RBF(1, active_dims=[0]) + kernels.Periodic(1, active_dims=[1]),
kernels.RBF(1, active_dims=[0]) * kernels.Linear(1, active_dims=[1]),
kernels.RBF(Q)+kernels.Linear(Q)] # non-overlapping
kernsAnalytic = [
ekernels.Sum([
ekernels.RBF(1, active_dims=[0]),
ekernels.Linear(1, active_dims=[1])]),
ekernels.Sum([
ekernels.RBF(1, active_dims=[0]),
kernels.Periodic(1, active_dims=[1])]),
ekernels.Product([
ekernels.RBF(1, active_dims=[0]),
ekernels.Linear(1, active_dims=[1])]),
ekernels.Sum([
ekernels.RBF(Q),
ekernels.Linear(Q)])
]
fOnSeparateDims = [True, True, True, False]
Z = np.random.permutation(X_mean.copy())[:self.M]
# Also test default N(0,1) is used
X_prior_mean = np.zeros((self.N, Q))
X_prior_var = np.ones((self.N, Q))
Xtest = self.rng.randn(10, Q)
for kq, ka, sepDims in zip(kernsQuadratu, kernsAnalytic, fOnSeparateDims):
with self.test_context():
kq.num_gauss_hermite_points = 20 # speed up quadratic for tests
# RBF should throw error if quadrature is used
ka.kern_list[0].num_gauss_hermite_points = 0
if sepDims:
self.assertTrue(
ka.on_separate_dimensions,
'analytic kernel must not use quadrature')
mq = gpflow.models.BayesianGPLVM(
X_mean=X_mean,
X_var=np.ones((self.N, Q)),
Y=self.Y,
kern=kq,
M=self.M,
Z=Z,
X_prior_mean=X_prior_mean,
X_prior_var=X_prior_var)
ma = gpflow.models.BayesianGPLVM(
X_mean=X_mean,
X_var=np.ones((self.N, Q)),
Y=self.Y,
kern=ka,
M=self.M,
Z=Z)
ql = mq.compute_log_likelihood()
al = ma.compute_log_likelihood()
self.assertTrue(np.allclose(ql, al, atol=1e-2),
'Likelihood not equal %f<>%f' % (ql, al))
mu_f_a, var_f_a = ma.predict_f(Xtest)
mu_f_q, var_f_q = mq.predict_f(Xtest)
self.assertTrue(np.allclose(mu_f_a, mu_f_q, atol=1e-4),
('Posterior means different', mu_f_a-mu_f_q))
self.assertTrue(np.allclose(mu_f_a, mu_f_q, atol=1e-4),
('Posterior vars different', var_f_a-var_f_q))
dataset = data.MultiTaskData(
X, Y, D, ARGS.n_train_data, ARGS.n_tasks, ARGS.n_train_tasks,
ARGS.dim_in, ARGS.dim_out, normalize=True)
""" Train MLGP """
X_train = dataset.data["training"]["X"].reshape(-1, ARGS.dim_in)
Z = X_train.copy()
np.random.shuffle(Z)
Z = Z[:ARGS.n_inducing]
Z = np.hstack([Z, np.zeros_like(Z)])
#mean_func = None
mean_func = mean_functions.Linear(A=np.ones((ARGS.dim_in+ARGS.dim_h, ARGS.dim_out)), b=None, name=ARGS.model_name+"_linear_mean")
kernel = kernels.RBF(ARGS.dim_in+ARGS.dim_h, ARD=True, name=ARGS.model_name+"_kernel")
likelihood = likelihoods.MultiGaussian(dim=ARGS.dim_out, name=ARGS.model_name+"_likelihood")
# Create graph
model = MLSVGP(
dim_in=ARGS.dim_in, dim_out=ARGS.dim_out, dim_h=ARGS.dim_h, num_h=ARGS.n_tasks,
kern=kernel, likelihood=likelihood, mean_function=mean_func, Z=Z,
max_lik_h=ARGS.max_lik_h, name=ARGS.model_name)
likelihood = model._build_likelihood()
objective = -likelihood
if ARGS.train:
session, saver = training.train(model, objective, dataset, ARGS)
else:
session = tf.Session()
def bayesian_gplvm_example():
np.random.seed(42)
pods.datasets.overide_manual_authorize = True # Dont ask to authorize.
gpflow.settings.numerics.quadrature = 'error' # Throw error if quadrature is used for kernel expectations.
# Data.
data = pods.datasets.oil_100()
Y = data['X']
print('Number of points X Number of dimensions', Y.shape)
data['citation']
# Model construction.
Q = 5
M = 20 # Number of inducing pts.
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]))
m = gpflow.models.BayesianGPLVM(X_mean=X_mean,
X_var=0.1 * np.ones((N, Q)),
Y=Y,
kern=k,
M=M,
Z=Z)
m.likelihood.variance = 0.01
opt = gpflow.train.ScipyOptimizer()
m.compile()
opt.minimize(m) #, options=dict(disp=True, maxiter=100))
# Compute and sensitivity to input.
# Sensitivity is a measure of the importance of each latent dimension.
kern = m.kern.kernels[0]
sens = np.sqrt(kern.variance.read_value()) / kern.lengthscales.read_value()
print(m.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')
# Plot vs PCA.
XPCAplot = gpflow.models.PCA_reduce(data['X'], 2)
f, ax = plt.subplots(1, 2, figsize=(10, 6))
labels = data['Y'].argmax(axis=1)
colors = cm.rainbow(np.linspace(0, 1, len(np.unique(labels))))
for i, c in zip(np.unique(labels), colors):
ax[0].scatter(XPCAplot[labels == i, 0],
XPCAplot[labels == i, 1],
color=c,
label=i)
ax[0].set_title('PCA')
ax[1].scatter(m.X_mean.read_value()[labels == i, 1],
m.X_mean.read_value()[labels == i, 2],
color=c,
label=i)
ax[1].set_title('Bayesian GPLVM')
def rbf_kern():
return kernels.RBF(Data.D_in, variance=rng.rand(), lengthscales=rng.rand() + 1.)
def rbf_kern_2():
# Additional cached rbf kernel for rbf cross covariance tests
return kernels.RBF(Data.D_in,
variance=rng.rand(),
lengthscales=rng.rand() + 1.)
def rbf_kern_act_dim_1():
return kernels.RBF(1, variance=rng.rand(), lengthscales=rng.rand() + 1., active_dims=[1])
class Data:
rng = np.random.RandomState(1)
num_data = 5
num_ind = 4
D_in = 2
D_out = 2
Xmu = rng.randn(num_data, D_in)
L = gen_L(rng, num_data, D_in, D_in)
Xvar = np.array([l @ l.T for l in L])
Z = rng.randn(num_ind, D_in)
# distributions don't need to be compiled (No Parameter objects)
# but the members should be Tensors created in the same graph
graph = tf.Graph()
with test_util.session_context(graph) as sess:
gauss = Gaussian(tf.constant(Xmu), tf.constant(Xvar))
dirac = Gaussian(tf.constant(Xmu),
tf.constant(np.zeros((num_data, D_in, D_in))))
gauss_diag = DiagonalGaussian(tf.constant(Xmu),
tf.constant(rng.rand(num_data, D_in)))
dirac_diag = DiagonalGaussian(tf.constant(Xmu),
tf.constant(np.zeros((num_data, D_in))))
dirac_markov_gauss = MarkovGaussian(
tf.constant(Xmu), tf.constant(np.zeros((2, num_data, D_in, D_in))))
# create the covariance for the pairwise markov-gaussian
dummy_gen = lambda rng, n, *shape: np.array(
[rng.randn(*shape) for _ in range(n)])
L_mg = dummy_gen(rng, num_data, D_in, 2 * D_in) # N+1 x D x 2D
LL = np.concatenate((L_mg[:-1], L_mg[1:]), 1) # N x 2D x 2D
Xcov = LL @ np.transpose(LL, (0, 2, 1))
Xc = np.concatenate((Xcov[:, :D_in, :D_in], Xcov[-1:, D_in:, D_in:]),
0) # N+1 x D x D
Xcross = np.concatenate(
(Xcov[:, :D_in, D_in:], np.zeros(
(1, D_in, D_in))), 0) # N+1 x D x D
Xcc = np.stack([Xc, Xcross]) # 2 x N+1 x D x D
markov_gauss = MarkovGaussian(Xmu, Xcc)
with gpflow.decors.defer_build():
# features
ip = features.InducingPoints(Z)
# kernels
rbf_prod_seperate_dims = kernels.Product([
kernels.RBF(1,
variance=rng.rand(),
lengthscales=rng.rand(),
active_dims=[0]),
kernels.RBF(1,
variance=rng.rand(),
lengthscales=rng.rand(),
active_dims=[1])
])
rbf_lin_sum = kernels.Sum([
kernels.RBF(D_in, variance=rng.rand(), lengthscales=rng.rand()),
kernels.RBF(D_in, variance=rng.rand(), lengthscales=rng.rand()),
kernels.Linear(D_in, variance=rng.rand())
])
rbf = kernels.RBF(D_in, variance=rng.rand(), lengthscales=rng.rand())
lin_kern = kernels.Linear(D_in, variance=rng.rand())
# mean functions
lin = mean_functions.Linear(rng.rand(D_in, D_out), rng.rand(D_out))
iden = mean_functions.Identity(
D_in) # Note: Identity can only be used if Din == Dout
zero = mean_functions.Zero(output_dim=D_out)
const = mean_functions.Constant(rng.rand(D_out))
