def test_compare_mixed_kernel(session_tf):
data = DataMixedKernel
kern_list = [RBF(data.D) for _ in range(data.L)]
k1 = mk.SeparateMixedMok(kern_list, W=data.W)
f1 = mf.SharedIndependentMof(InducingPoints(data.X[:data.M, ...].copy()))
m1 = SVGP(data.X,
data.Y,
k1,
Gaussian(),
feat=f1,
q_mu=data.mu_data,
q_sqrt=data.sqrt_data)
kern_list = [RBF(data.D) for _ in range(data.L)]
k2 = mk.SeparateMixedMok(kern_list, W=data.W)
f2 = mf.MixedKernelSharedMof(InducingPoints(data.X[:data.M, ...].copy()))
m2 = SVGP(data.X,
data.Y,
k2,
Gaussian(),
feat=f2,
q_mu=data.mu_data,
q_sqrt=data.sqrt_data)
check_equality_predictions(session_tf, [m1, m2])
def fit(self, X, y):
self.scaler = StandardScaler()
X = self.scaler.fit_transform(X)
M = self.n_inducing
L = self.n_latent
self.Z = find_starting_z(X, self.n_inducing, use_minibatching=False)
q_mu = np.zeros((M, L))
q_sqrt = np.repeat(np.eye(M)[None, ...], L, axis=0) * 1.0
feature = mf.MixedKernelSharedMof(gpf.features.InducingPoints(self.Z))
self.m = gpf.models.SVGP(X,
y,
self.kernel,
gpf.likelihoods.Bernoulli(),
feat=feature,
q_mu=q_mu,
q_sqrt=q_sqrt,
whiten=self.whiten,
mean_function=self.mean_function())
self.m.feature.set_trainable(self.train_inducing_points)
opt = gpf.train.ScipyOptimizer(options={'maxfun': self.maxiter})
opt.minimize(self.m, disp=self.verbose_fit, maxiter=self.maxiter)
self.is_fit = True
def test_sample_conditional_mixedkernel(session_tf):
q_mu = np.random.randn(Data.M, Data.L) # M x L
q_sqrt = np.array([
np.tril(np.random.randn(Data.M, Data.M)) for _ in range(Data.L)
]) # L x M x M
Z = Data.X[:Data.M, ...] # M x D
N = int(10e5)
Xs = np.ones((N, Data.D), dtype=float_type)
values = {"Xnew": Xs, "q_mu": q_mu, "q_sqrt": q_sqrt}
placeholders = _create_placeholder_dict(values)
feed_dict = _create_feed_dict(placeholders, values)
# Path 1: mixed kernel: most efficient route
W = np.random.randn(Data.P, Data.L)
mixed_kernel = mk.SeparateMixedMok([RBF(Data.D) for _ in range(Data.L)], W)
mixed_feature = mf.MixedKernelSharedMof(InducingPoints(Z.copy()))
sample = sample_conditional(placeholders["Xnew"],
mixed_feature,
mixed_kernel,
placeholders["q_mu"],
q_sqrt=placeholders["q_sqrt"],
white=True)
value = session_tf.run(sample, feed_dict=feed_dict)
# Path 2: independent kernels, mixed later
separate_kernel = mk.SeparateIndependentMok(
[RBF(Data.D) for _ in range(Data.L)])
shared_feature = mf.SharedIndependentMof(InducingPoints(Z.copy()))
sample2 = sample_conditional(placeholders["Xnew"],
shared_feature,
separate_kernel,
placeholders["q_mu"],
q_sqrt=placeholders["q_sqrt"],
white=True)
value2 = session_tf.run(sample2, feed_dict=feed_dict)
value2 = np.matmul(value2, W.T)
# check if mean and covariance of samples are similar
np.testing.assert_array_almost_equal(np.mean(value, axis=0),
np.mean(value2, axis=0),
decimal=1)
np.testing.assert_array_almost_equal(np.cov(value, rowvar=False),
np.cov(value2, rowvar=False),
decimal=1)
def test_conditional_broadcasting(session_tf, full_cov, white,
conditional_type):
"""
Test that the `conditional` and `sample_conditional` broadcasts correctly
over leading dimensions of Xnew. Xnew can be shape [..., N, D],
and conditional should broadcast over the [...].
"""
X_ = tf.placeholder(tf.float64, [None, None])
q_mu = np.random.randn(Data.M, Data.Dy)
q_sqrt = np.tril(np.random.randn(Data.Dy, Data.M, Data.M), -1)
if conditional_type == "Z":
feat = Data.Z
kern = gpflow.kernels.Matern52(Data.Dx, lengthscales=0.5)
elif conditional_type == "inducing_points":
feat = gpflow.features.InducingPoints(Data.Z)
kern = gpflow.kernels.Matern52(Data.Dx, lengthscales=0.5)
elif conditional_type == "mixing":
# variational params have different output dim in this case
q_mu = np.random.randn(Data.M, Data.L)
q_sqrt = np.tril(np.random.randn(Data.L, Data.M, Data.M), -1)
feat = mf.MixedKernelSharedMof(gpflow.features.InducingPoints(Data.Z))
kern = mk.SeparateMixedMok(kernels=[
gpflow.kernels.Matern52(Data.Dx, lengthscales=0.5)
for _ in range(Data.L)
],
W=Data.W)
if conditional_type == "mixing" and full_cov:
pytest.skip("combination is not implemented")
num_samples = 5
sample_tf, mean_tf, cov_tf = sample_conditional(
X_,
feat,
kern,
tf.convert_to_tensor(q_mu),
q_sqrt=tf.convert_to_tensor(q_sqrt),
white=white,
full_cov=full_cov,
num_samples=num_samples)
ss, ms, vs = [], [], []
for X in Data.SX:
s, m, v = session_tf.run([sample_tf, mean_tf, cov_tf], {X_: X})
ms.append(m)
vs.append(v)
ss.append(s)
ms = np.array(ms)
vs = np.array(vs)
ss = np.array(ss)
ss_S12, ms_S12, vs_S12 = session_tf.run(
sample_conditional(Data.SX,
feat,
kern,
tf.convert_to_tensor(q_mu),
q_sqrt=tf.convert_to_tensor(q_sqrt),
white=white,
full_cov=full_cov,
num_samples=num_samples))
ss_S1_S2, ms_S1_S2, vs_S1_S2 = session_tf.run(
sample_conditional(Data.S1_S2_X,
feat,
kern,
tf.convert_to_tensor(q_mu),
q_sqrt=tf.convert_to_tensor(q_sqrt),
white=white,
full_cov=full_cov,
num_samples=num_samples))
assert_allclose(ss_S12.shape, ss.shape)
assert_allclose(ms_S12, ms)
assert_allclose(vs_S12, vs)
assert_allclose(ms_S1_S2.reshape(Data.S1 * Data.S2, Data.N, Data.Dy), ms)
assert_allclose(ss_S1_S2.shape,
[Data.S1, Data.S2, num_samples, Data.N, Data.Dy])
if full_cov:
assert_allclose(
vs_S1_S2.reshape(Data.S1 * Data.S2, Data.Dy, Data.N, Data.N), vs)
else:
assert_allclose(vs_S1_S2.reshape(Data.S1 * Data.S2, Data.N, Data.Dy),
vs)
# start = start[:, 0:2]
# predict = predict[:, 0:2]
D = start.shape[1] # number of input dimensions
M = 20 # number of inducing points
L = 1 # number of latent GPs
P = predict.shape[1] # number of observations = output dimensions
MAXITER = gpflow.test_util.notebook_niter(int(1e100))
q_mu = np.zeros((M, L))
q_sqrt = np.repeat(np.eye(M)[None, ...], L, axis=0) * 1.0
kern_list = [
gpflow.kernels.RBF(D) + gpflow.kernels.Linear(D) for _ in range(L)
]
kernel = mk.SeparateMixedMok(kern_list, W=np.random.randn(P, L))
feature = mf.MixedKernelSharedMof(
gpflow.features.InducingPoints(start[:M, ...].copy()))
m = gpflow.models.SVGP(start,
predict,
kernel,
gpflow.likelihoods.Gaussian(),
feat=feature,
q_mu=q_mu,
q_sqrt=q_sqrt)
opt = gpflow.train.ScipyOptimizer()
opt.minimize(m, disp=True, maxiter=MAXITER)
saver = gpflow.Saver()
saver.save('./model/multioutput.mdl', m)
def mixed_shared(self):
return mf.MixedKernelSharedMof(make_ip())
