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 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 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()
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 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 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 lin_kern_act_dim_1():
return kernels.Linear(1, variance=rng.rand(), active_dims=[1])
def lin_kern():
return kernels.Linear(Data.D_in, variance=rng.rand())
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))
"gauss_diag":
DiagonalGaussian(Xmu, rng.rand(num_data, D_in)),
"dirac_diag":
DiagonalGaussian(Xmu, np.zeros((num_data, D_in))),
"dirac_markov_gauss":
MarkovGaussian(Xmu_markov, np.zeros((2, num_data + 1, D_in, D_in))),
"markov_gauss":
markov_gauss(),
}
_kerns = {
"rbf":
kernels.SquaredExponential(variance=rng.rand(),
lengthscales=rng.rand() + 1.0),
"lin":
kernels.Linear(variance=rng.rand()),
"matern":
kernels.Matern32(variance=rng.rand()),
"rbf_act_dim_0":
kernels.SquaredExponential(variance=rng.rand(),
lengthscales=rng.rand() + 1.0,
active_dims=[0]),
"rbf_act_dim_1":
kernels.SquaredExponential(variance=rng.rand(),
lengthscales=rng.rand() + 1.0,
active_dims=[1]),
"lin_act_dim_0":
kernels.Linear(variance=rng.rand(), active_dims=[0]),
"lin_act_dim_1":
kernels.Linear(variance=rng.rand(), active_dims=[1]),
"rbf_lin_sum":
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)
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')
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()
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))
