def test_multioutput_with_diag_q_sqrt(): data = DataMixedKernel q_sqrt_diag = np.ones((data.M, data.L)) * 2 q_sqrt = np.repeat(np.eye(data.M)[None, ...], data.L, axis=0) * 2 # L x M x M kern_list = [SquaredExponential() for _ in range(data.L)] k1 = mk.LinearCoregionalization(kern_list, W=data.W) f1 = mf.SharedIndependentInducingVariables( InducingPoints(data.X[:data.M, ...])) model_1 = SVGP(k1, Gaussian(), inducing_variable=f1, q_mu=data.mu_data, q_sqrt=q_sqrt_diag, q_diag=True) kern_list = [SquaredExponential() for _ in range(data.L)] k2 = mk.LinearCoregionalization(kern_list, W=data.W) f2 = mf.SharedIndependentInducingVariables( InducingPoints(data.X[:data.M, ...])) model_2 = SVGP(k2, Gaussian(), inducing_variable=f2, q_mu=data.mu_data, q_sqrt=q_sqrt, q_diag=False) check_equality_predictions(Data.data, [model_1, model_2])
def test_mixed_shared(fun): inducing_variable = mf.SharedIndependentInducingVariables(make_ip()) kernel = mk.LinearCoregionalization(make_kernels(Datum.L), Datum.W) if fun is mo_kuus.Kuu: t = tf.linalg.cholesky(fun(inducing_variable, kernel, jitter=1e-9)) else: t = fun(inducing_variable, kernel, Datum.Xnew) print(t.shape)
def test_MixedMok_Kgg(): data = DataMixedKernel kern_list = [SquaredExponential() for _ in range(data.L)] kernel = mk.LinearCoregionalization(kern_list, W=data.W) Kgg = kernel.Kgg(Data.X, Data.X) # L x N x N Kff = kernel.K(Data.X, Data.X) # N x P x N x P # Kff = W @ Kgg @ W^T Kff_infered = np.einsum("lnm,pl,ql->npmq", Kgg, data.W, data.W) np.testing.assert_array_almost_equal(Kff, Kff_infered, decimal=5)
def test_compare_mixed_kernel(): data = DataMixedKernel kern_list = [SquaredExponential() for _ in range(data.L)] k1 = mk.LinearCoregionalization(kern_list, W=data.W) f1 = mf.SharedIndependentInducingVariables( InducingPoints(data.X[:data.M, ...])) model_1 = SVGP(k1, Gaussian(), inducing_variable=f1, q_mu=data.mu_data, q_sqrt=data.sqrt_data) kern_list = [SquaredExponential() for _ in range(data.L)] k2 = mk.LinearCoregionalization(kern_list, W=data.W) f2 = mf.SharedIndependentInducingVariables( InducingPoints(data.X[:data.M, ...])) model_2 = SVGP(k2, Gaussian(), inducing_variable=f2, q_mu=data.mu_data, q_sqrt=data.sqrt_data) check_equality_predictions(Data.X, Data.Y, [model_1, model_2])
def test_mixed_mok_with_Id_vs_independent_mok(): data = DataMixedKernelWithEye # Independent model k1 = mk.SharedIndependent( SquaredExponential(variance=0.5, lengthscale=1.2), data.L) f1 = InducingPoints(data.X[:data.M, ...]) model_1 = SVGP(k1, Gaussian(), f1, q_mu=data.mu_data_full, q_sqrt=data.sqrt_data_full) set_trainable(model_1, False) model_1.q_sqrt.trainable = True @tf.function(autograph=False) def closure1(): return -model_1.log_marginal_likelihood(Data.X, Data.Y) gpflow.optimizers.Scipy().minimize(closure1, variables=model_1.trainable_variables, method='BFGS') # Mixed Model kern_list = [ SquaredExponential(variance=0.5, lengthscale=1.2) for _ in range(data.L) ] k2 = mk.LinearCoregionalization(kern_list, data.W) f2 = InducingPoints(data.X[:data.M, ...]) model_2 = SVGP(k2, Gaussian(), f2, q_mu=data.mu_data_full, q_sqrt=data.sqrt_data_full) set_trainable(model_2, False) model_2.q_sqrt.trainable = True @tf.function(autograph=False) def closure2(): return -model_2.log_marginal_likelihood(Data.X, Data.Y) gpflow.optimizers.Scipy().minimize(closure2, variables=model_2.trainable_variables, method='BFGS') check_equality_predictions(Data.X, Data.Y, [model_1, model_2])
def test_sample_conditional_mixedkernel(): q_mu = tf.random.uniform((Data.M, Data.L), dtype=tf.float64) # M x L q_sqrt = tf.convert_to_tensor([ np.tril(tf.random.uniform((Data.M, Data.M), dtype=tf.float64)) 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) # Path 1: mixed kernel: most efficient route W = np.random.randn(Data.P, Data.L) mixed_kernel = mk.LinearCoregionalization( [SquaredExponential() for _ in range(Data.L)], W) optimal_inducing_variable = mf.SharedIndependentInducingVariables( InducingPoints(Z)) value, mean, var = sample_conditional(Xs, optimal_inducing_variable, mixed_kernel, q_mu, q_sqrt=q_sqrt, white=True) # Path 2: independent kernels, mixed later separate_kernel = mk.SeparateIndependent( [SquaredExponential() for _ in range(Data.L)]) fallback_inducing_variable = mf.SharedIndependentInducingVariables( InducingPoints(Z)) value2, mean2, var2 = sample_conditional(Xs, fallback_inducing_variable, separate_kernel, q_mu, q_sqrt=q_sqrt, white=True) 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(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 [...]. """ 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": inducing_variable = Data.Z kernel = gpflow.kernels.Matern52(lengthscale=0.5) elif conditional_type == "inducing_points": inducing_variable = gpflow.inducing_variables.InducingPoints(Data.Z) kernel = gpflow.kernels.Matern52(lengthscale=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) inducing_variable = mf.SharedIndependentInducingVariables(gpflow.inducing_variables.InducingPoints(Data.Z)) kernel = mk.LinearCoregionalization( kernels=[gpflow.kernels.Matern52(lengthscale=0.5) for _ in range(Data.L)], W=Data.W ) else: raise (NotImplementedError) if conditional_type == "mixing" and full_cov: pytest.skip("combination is not implemented") num_samples = 5 def sample_conditional_fn(X): return sample_conditional(X, inducing_variable, kernel, tf.convert_to_tensor(q_mu), q_sqrt=tf.convert_to_tensor(q_sqrt), white=white, full_cov=full_cov, num_samples=num_samples) samples = np.array([sample_conditional_fn(X)[0] for X in Data.SX]) means = np.array([sample_conditional_fn(X)[1] for X in Data.SX]) variables = np.array([sample_conditional_fn(X)[2] for X in Data.SX]) samples_S12, means_S12, vars_S12 = \ sample_conditional(Data.SX, inducing_variable, kernel, tf.convert_to_tensor(q_mu), q_sqrt=tf.convert_to_tensor(q_sqrt), white=white, full_cov=full_cov, num_samples=num_samples) samples_S1_S2, means_S1_S2, vars_S1_S2 = \ sample_conditional(Data.S1_S2_X, inducing_variable, kernel, 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(samples_S12.shape, samples.shape) assert_allclose(samples_S1_S2.shape, [Data.S1, Data.S2, num_samples, Data.N, Data.Dy]) assert_allclose(means_S12, means) assert_allclose(vars_S12, variables) assert_allclose(means_S1_S2.numpy().reshape(Data.S1 * Data.S2, Data.N, Data.Dy), means) if full_cov: vars_s1_s2 = vars_S1_S2.numpy().reshape(Data.S1 * Data.S2, Data.Dy, Data.N, Data.N) assert_allclose(vars_s1_s2, variables) else: vars_s1_s2 = vars_S1_S2.numpy().reshape(Data.S1 * Data.S2, Data.N, Data.Dy) assert_allclose(vars_s1_s2, variables)
M = 10 N = 100 W = rng.randn(P, L) X = rng.randn(N)[:, None] Xnew = rng.randn(N)[:, None] multioutput_inducing_variable_list = [ mf.SharedIndependentInducingVariables(make_ip()), mf.SeparateIndependentInducingVariables(make_ips(Datum.P)) ] multioutput_kernel_list = [ mk.SharedIndependent(make_kernel(), Datum.P), mk.SeparateIndependent(make_kernels(Datum.L)), mk.LinearCoregionalization(make_kernels(Datum.L), Datum.W) ] @pytest.mark.parametrize('inducing_variable', multioutput_inducing_variable_list) @pytest.mark.parametrize('kernel', multioutput_kernel_list) def test_kuu(inducing_variable, kernel): Kuu = mo_kuus.Kuu(inducing_variable, kernel, jitter=1e-9) tf.linalg.cholesky(Kuu) @pytest.mark.parametrize('inducing_variable', multioutput_inducing_variable_list) @pytest.mark.parametrize('kernel', multioutput_kernel_list) def test_kuf(inducing_variable, kernel):