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_MixedKernelSeparateMof(): data = DataMixedKernel kern_list = [SquaredExponential() for _ in range(data.L)] inducing_variable_list = [ InducingPoints(data.X[:data.M, ...]) for _ in range(data.L) ] k1 = mk.LinearCoregionalization(kern_list, W=data.W) f1 = mf.SeparateIndependentInducingVariables(inducing_variable_list) 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)] inducing_variable_list = [ InducingPoints(data.X[:data.M, ...]) for _ in range(data.L) ] k2 = mk.LinearCoregionalization(kern_list, W=data.W) f2 = mf.SeparateIndependentInducingVariables(inducing_variable_list) model_2 = SVGP(k2, Gaussian(), inducing_variable=f2, q_mu=data.mu_data, q_sqrt=data.sqrt_data) check_equality_predictions(Data.data, [model_1, model_2])
def test_mixed_mok_with_Id_vs_independent_mok(): data = DataMixedKernelWithEye # Independent model k1 = mk.SharedIndependent(SquaredExponential(variance=0.5, lengthscales=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) set_trainable(model_1.q_sqrt, True) gpflow.optimizers.Scipy().minimize( model_1.training_loss_closure(Data.data), variables=model_1.trainable_variables, method="BFGS", compile=True, ) # Mixed Model kern_list = [SquaredExponential(variance=0.5, lengthscales=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) set_trainable(model_2.q_sqrt, True) gpflow.optimizers.Scipy().minimize( model_2.training_loss_closure(Data.data), variables=model_2.trainable_variables, method="BFGS", compile=True, ) check_equality_predictions(Data.data, [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_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_shapes_of_mok(): data = DataMixedKernel kern_list = [SquaredExponential() for _ in range(data.L)] k1 = mk.LinearCoregionalization(kern_list, W=data.W) assert k1.num_latent_gps == data.L k2 = mk.SeparateIndependent(kern_list) assert k2.num_latent_gps == data.L dims = 5 k3 = mk.SharedIndependent(SquaredExponential(), dims) assert k3.num_latent_gps == dims
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(lengthscales=0.5) elif conditional_type == "inducing_points": inducing_variable = gpflow.inducing_variables.InducingPoints(Data.Z) kernel = gpflow.kernels.Matern52(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) inducing_variable = mf.SharedIndependentInducingVariables( gpflow.inducing_variables.InducingPoints(Data.Z) ) kernel = mk.LinearCoregionalization( kernels=[gpflow.kernels.Matern52(lengthscales=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)
def test_kuf_fallback_shared_inducing_variables_shape(inducing_variable): kernel = mk.LinearCoregionalization(make_kernels(Datum.L), Datum.W) Kuf = mo_kufs.Kuf(inducing_variable, kernel, Datum.Xnew) assert Kuf.shape == (10, 2, 100, 3)
multioutput_inducing_variable_list = [ mf.SharedIndependentInducingVariables(make_ip()), mf.SeparateIndependentInducingVariables(make_ips(Datum.P)), ] multioutput_fallback_inducing_variable_list = [ mf.FallbackSharedIndependentInducingVariables(make_ip()), mf.FallbackSeparateIndependentInducingVariables(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_shape(inducing_variable, kernel): Kuu = mo_kuus.Kuu(inducing_variable, kernel, jitter=1e-9) t = tf.linalg.cholesky(Kuu) if isinstance(kernel, mk.SharedIndependent): if isinstance(inducing_variable, mf.SeparateIndependentInducingVariables): assert t.shape == (3, 10, 10) else: