diff --git a/GPy/testing/kernel_tests.py b/GPy/testing/kernel_tests.py index 4f6016e0..c7ef9f09 100644 --- a/GPy/testing/kernel_tests.py +++ b/GPy/testing/kernel_tests.py @@ -1,13 +1,9 @@ # Copyright (c) 2012, 2013 GPy authors (see AUTHORS.txt). # Licensed under the BSD 3-clause license (see LICENSE.txt) - -import unittest -from unittest.case import skip - import GPy +import pytest from GPy.core.parameterization.param import Param import numpy as np -import random from ..util.config import config @@ -441,8 +437,8 @@ def check_kernel_gradient_functions( return pass_checks -class KernelGradientTestsContinuous(unittest.TestCase): - def setUp(self): +class TestKernelGradientContinuous: + def setup(self): self.N, self.D = 10, 5 self.X = np.random.randn(self.N, self.D + 1) self.X2 = np.random.randn(self.N + 10, self.D + 1) @@ -451,61 +447,55 @@ class KernelGradientTestsContinuous(unittest.TestCase): self.kernclasses = [getattr(GPy.kern, s) for s in continuous_kerns] def test_MLP(self): + self.setup() k = GPy.kern.MLP(self.D, ARD=True) k.randomize() - self.assertTrue( - check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) - ) + assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) def test_Matern32(self): + self.setup() k = GPy.kern.Matern32(self.D) k.randomize() - self.assertTrue( - check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) - ) + assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) def test_Prod(self): + self.setup() k = GPy.kern.Matern32(2, active_dims=[2, 3]) * GPy.kern.RBF( 2, active_dims=[0, 4] ) + GPy.kern.Linear(self.D) k.randomize() - self.assertTrue( - check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) - ) + assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) def test_Prod1(self): + self.setup() k = GPy.kern.RBF(self.D) * GPy.kern.Linear(self.D) k.randomize() - self.assertTrue( - check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) - ) + assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) def test_Prod2(self): + self.setup() k = GPy.kern.RBF(2, active_dims=[0, 4]) * GPy.kern.Linear(self.D) k.randomize() - self.assertTrue( - check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) - ) + assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) def test_Prod3(self): + self.setup() k = GPy.kern.RBF(self.D) * GPy.kern.Linear(self.D) * GPy.kern.Bias(self.D) k.randomize() - self.assertTrue( - check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) - ) + assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) def test_Prod4(self): + self.setup() k = ( GPy.kern.RBF(2, active_dims=[0, 4]) * GPy.kern.Linear(self.D) * GPy.kern.Matern32(2, active_dims=[0, 1]) ) k.randomize() - self.assertTrue( - check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) - ) + assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) def test_Add(self): + self.setup() k = ( GPy.kern.Matern32(2, active_dims=[2, 3]) + GPy.kern.RBF(2, active_dims=[0, 4]) @@ -517,18 +507,18 @@ class KernelGradientTestsContinuous(unittest.TestCase): + GPy.kern.Linear(self.D) ) k.randomize() - self.assertTrue( - check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) - ) + assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) def test_Add_dims(self): + self.setup() k = ( GPy.kern.Matern32(2, active_dims=[2, self.D]) + GPy.kern.RBF(2, active_dims=[0, 4]) + GPy.kern.Linear(self.D) ) k.randomize() - self.assertRaises(IndexError, k.K, self.X[:, : self.D]) + with pytest.raises(IndexError): + self.X[:, : self.D] k = ( GPy.kern.Matern32(2, active_dims=[2, self.D - 1]) + GPy.kern.RBF(2, active_dims=[0, 4]) @@ -542,18 +532,16 @@ class KernelGradientTestsContinuous(unittest.TestCase): raise AssertionError("k.K(X) should run on self.D-1 dimension") def test_Matern52(self): + self.setup() k = GPy.kern.Matern52(self.D) k.randomize() - self.assertTrue( - check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) - ) + assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) def test_RBF(self): + self.setup() k = GPy.kern.RBF(self.D - 1, ARD=True) k.randomize() - self.assertTrue( - check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) - ) + assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) def test_OU(self): k = GPy.kern.OU(self.D - 1, ARD=True) @@ -563,119 +551,108 @@ class KernelGradientTestsContinuous(unittest.TestCase): ) def test_Cosine(self): + self.setup() # Don't test Cosine directly as it fails positive definite test. k = GPy.kern.RBF(self.D - 1, ARD=False) * GPy.kern.Cosine(self.D - 1, ARD=True) k.randomize() - self.assertTrue( - check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) - ) + assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) def test_ExpQuadCosine(self): + self.setup() k = GPy.kern.ExpQuadCosine(self.D - 1, ARD=True) k.randomize() - self.assertTrue( - check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) - ) + assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) def test_Sinc(self): + self.setup() k = GPy.kern.Sinc(self.D - 1, ARD=True) k.randomize() - self.assertTrue( - check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) - ) + assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) def test_RatQuad(self): + self.setup() k = GPy.kern.RatQuad(self.D - 1, ARD=True) k.randomize() - self.assertTrue( - check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) - ) + assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) def test_ExpQuad(self): + self.setup() k = GPy.kern.ExpQuad(self.D - 1, ARD=True) k.randomize() - self.assertTrue( - check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) - ) + assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) def test_integral(self): + self.setup() k = GPy.kern.Integral(1) k.randomize() - self.assertTrue( - check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) - ) + assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) def test_multidimensional_integral_limits(self): + self.setup() k = GPy.kern.Multidimensional_Integral_Limits(2) k.randomize() - self.assertTrue( - check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) - ) + assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) def test_integral_limits(self): + self.setup() k = GPy.kern.Integral_Limits(2) k.randomize() - self.assertTrue( - check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) - ) + assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) def test_Linear(self): + self.setup() k = GPy.kern.Linear(self.D) k.randomize() - self.assertTrue( - check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) - ) + assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) def test_LinearFull(self): + self.setup() k = GPy.kern.LinearFull(self.D, self.D - 1) k.randomize() - self.assertTrue( - check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) - ) + assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) def test_Fixed(self): + self.setup() cov = np.dot(self.X, self.X.T) X = np.arange(self.N).reshape(self.N, 1) k = GPy.kern.Fixed(1, cov) k.randomize() - self.assertTrue( - check_kernel_gradient_functions(k, X=X, X2=None, verbose=verbose) - ) + assert check_kernel_gradient_functions(k, X=X, X2=None, verbose=verbose) def test_Poly(self): + self.setup() k = GPy.kern.Poly(self.D, order=5) k.randomize() - self.assertTrue( - check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) - ) + assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) def test_WhiteHeteroscedastic(self): + self.setup() k = GPy.kern.WhiteHeteroscedastic(self.D, self.X.shape[0]) k.randomize() - self.assertTrue( - check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) - ) + assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) def test_standard_periodic(self): + self.setup() k = GPy.kern.StdPeriodic(self.D) k.randomize() - self.assertTrue( - check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) - ) + assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) def test_symmetric_even(self): + self.setup() k_base = GPy.kern.Linear(1) + GPy.kern.RBF(1) transform = -np.array([[1.0]]) k = GPy.kern.Symmetric(k_base, transform, "even") - self.assertTrue(check_kernel_gradient_functions(k)) + assert check_kernel_gradient_functions(k) def test_symmetric_odd(self): + self.setup() k_base = GPy.kern.Linear(1) + GPy.kern.RBF(1) transform = -np.array([[1.0]]) k = GPy.kern.Symmetric(k_base, transform, "odd") - self.assertTrue(check_kernel_gradient_functions(k)) + assert check_kernel_gradient_functions(k) def test_MultioutputKern(self): + self.setup() k1 = GPy.kern.RBF(self.D, ARD=True) k1.randomize() k2 = GPy.kern.RBF(self.D, ARD=True) @@ -684,26 +661,24 @@ class KernelGradientTestsContinuous(unittest.TestCase): k = GPy.kern.MultioutputKern([k1, k2]) Xt, _, _ = GPy.util.multioutput.build_XY([self.X, self.X]) X2t, _, _ = GPy.util.multioutput.build_XY([self.X2, self.X2]) - self.assertTrue( - check_kernel_gradient_functions( - k, X=Xt, X2=X2t, verbose=verbose, fixed_X_dims=-1 - ) + assert check_kernel_gradient_functions( + k, X=Xt, X2=X2t, verbose=verbose, fixed_X_dims=-1 ) def test_Precomputed(self): + self.setup() Xall = np.concatenate([self.X, self.X2]) cov = np.dot(Xall, Xall.T) X = np.arange(self.N).reshape(self.N, 1) X2 = np.arange(self.N, 2 * self.N + 10).reshape(self.N + 10, 1) k = GPy.kern.Precomputed(1, cov) k.randomize() - self.assertTrue( - check_kernel_gradient_functions( - k, X=X, X2=X2, verbose=verbose, fixed_X_dims=[0] - ) + assert check_kernel_gradient_functions( + k, X=X, X2=X2, verbose=verbose, fixed_X_dims=[0] ) def test_basis_func_linear_slope(self): + self.setup() start_stop = np.random.uniform( self.X.min(0), self.X.max(0), (4, self.X.shape[1]) ).T @@ -717,11 +692,10 @@ class KernelGradientTestsContinuous(unittest.TestCase): ) ) k = GPy.kern.Add(ks) - self.assertTrue( - check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) - ) + assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) def test_basis_func_changepoint(self): + self.setup() points = np.random.uniform(self.X.min(0), self.X.max(0), (self.X.shape[1])) ks = [] for i in range(points.shape[0]): @@ -731,11 +705,10 @@ class KernelGradientTestsContinuous(unittest.TestCase): ) ) k = GPy.kern.Add(ks) - self.assertTrue( - check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) - ) + assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) def test_basis_func_poly(self): + self.setup() ks = [] for i in range(self.X.shape[1]): ks.append( @@ -744,11 +717,10 @@ class KernelGradientTestsContinuous(unittest.TestCase): ) ) k = GPy.kern.Add(ks) - self.assertTrue( - check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) - ) + assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) def test_basis_func_domain(self): + self.setup() start_stop = np.random.uniform( self.X.min(0), self.X.max(0), (4, self.X.shape[1]) ).T @@ -760,13 +732,11 @@ class KernelGradientTestsContinuous(unittest.TestCase): GPy.kern.DomainKernel(1, start, stop, ARD=i % 2 == 0, active_dims=[i]) ) k = GPy.kern.Add(ks) - self.assertTrue( - check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) - ) + assert check_kernel_gradient_functions(k, X=self.X, X2=self.X2, verbose=verbose) -class KernelTestsMiscellaneous(unittest.TestCase): - def setUp(self): +class TestKernelMiscellaneous: + def setup(self): N, D = 100, 10 self.X = np.linspace(-np.pi, +np.pi, N)[:, None] * np.random.uniform(-10, 10, D) self.rbf = GPy.kern.RBF(2, active_dims=np.arange(0, 4, 2)) @@ -780,26 +750,22 @@ class KernelTestsMiscellaneous(unittest.TestCase): # self.sumkern.randomize() def test_which_parts(self): - self.assertTrue( - np.allclose( - self.sumkern.K(self.X, which_parts=[self.linear, self.matern]), - self.linear.K(self.X) + self.matern.K(self.X), - ) + self.setup() + assert np.allclose( + self.sumkern.K(self.X, which_parts=[self.linear, self.matern]), + self.linear.K(self.X) + self.matern.K(self.X), ) - self.assertTrue( - np.allclose( - self.sumkern.K(self.X, which_parts=[self.linear, self.rbf]), - self.linear.K(self.X) + self.rbf.K(self.X), - ) + assert np.allclose( + self.sumkern.K(self.X, which_parts=[self.linear, self.rbf]), + self.linear.K(self.X) + self.rbf.K(self.X), ) - self.assertTrue( - np.allclose( - self.sumkern.K(self.X, which_parts=self.sumkern.parts[0]), - self.rbf.K(self.X), - ) + assert np.allclose( + self.sumkern.K(self.X, which_parts=self.sumkern.parts[0]), + self.rbf.K(self.X), ) def test_active_dims(self): + self.setup() np.testing.assert_array_equal(self.sumkern.active_dims, [0, 1, 2, 3, 7, 9]) np.testing.assert_array_equal(self.sumkern._all_dims_active, range(10)) tmp = self.linear + self.rbf @@ -819,8 +785,8 @@ class KernelTestsMiscellaneous(unittest.TestCase): np.testing.assert_array_equal(tmp._all_dims_active, range(10)) -class KernelTestsNonContinuous(unittest.TestCase): - def setUp(self): +class TestKernelNonContinuous: + def setup(self): N0 = 3 N1 = 9 N2 = 4 @@ -837,6 +803,7 @@ class KernelTestsNonContinuous(unittest.TestCase): self.X2[(N0 * 2) :, -1] = 1 def test_IndependentOutputs(self): + self.setup() k = [ GPy.kern.RBF(1, active_dims=[1], name="rbf1"), GPy.kern.RBF(self.D, active_dims=range(self.D), name="rbf012"), @@ -846,7 +813,8 @@ class KernelTestsNonContinuous(unittest.TestCase): np.testing.assert_array_equal(kern.active_dims, [-1, 0, 1, 2]) np.testing.assert_array_equal(kern._all_dims_active, [0, 1, 2, -1]) - def testIndependendGradients(self): + def test_IndependendGradients(self): + self.setup() k = GPy.kern.RBF(self.D, active_dims=range(self.D)) kern = GPy.kern.IndependentOutputs(k, -1, "ind_single") self.assertTrue( @@ -860,13 +828,12 @@ class KernelTestsNonContinuous(unittest.TestCase): GPy.kern.RBF(2, active_dims=[0, 2], name="rbf02"), ] kern = GPy.kern.IndependentOutputs(k, -1, name="ind_split") - self.assertTrue( - check_kernel_gradient_functions( - kern, X=self.X, X2=self.X2, verbose=verbose, fixed_X_dims=-1 - ) + assert check_kernel_gradient_functions( + kern, X=self.X, X2=self.X2, verbose=verbose, fixed_X_dims=-1 ) def test_Hierarchical(self): + self.setup() k = [ GPy.kern.RBF(2, active_dims=[0, 2], name="rbf1"), GPy.kern.RBF(2, active_dims=[0, 2], name="rbf2"), @@ -876,52 +843,50 @@ class KernelTestsNonContinuous(unittest.TestCase): np.testing.assert_array_equal(kern._all_dims_active, [0, 1, 2, -1]) def test_Hierarchical_gradients(self): + self.setup() k = [ GPy.kern.RBF(2, active_dims=[0, 2], name="rbf1"), GPy.kern.RBF(2, active_dims=[0, 2], name="rbf2"), ] kern = GPy.kern.IndependentOutputs(k, -1, name="ind_split") - self.assertTrue( - check_kernel_gradient_functions( - kern, X=self.X, X2=self.X2, verbose=verbose, fixed_X_dims=-1 - ) + assert check_kernel_gradient_functions( + kern, X=self.X, X2=self.X2, verbose=verbose, fixed_X_dims=-1 ) def test_ODE_UY(self): + self.setup() kern = GPy.kern.ODE_UY(2, active_dims=[0, self.D]) X = self.X[self.X[:, -1] != 2] X2 = self.X2[self.X2[:, -1] != 2] - self.assertTrue( - check_kernel_gradient_functions( - kern, X=X, X2=X2, verbose=verbose, fixed_X_dims=-1 - ) + assert check_kernel_gradient_functions( + kern, X=X, X2=X2, verbose=verbose, fixed_X_dims=-1 ) def test_Coregionalize(self): + self.setup() kern = GPy.kern.Coregionalize(1, output_dim=3, active_dims=[-1]) - self.assertTrue( - check_kernel_gradient_functions( - kern, X=self.X, X2=self.X2, verbose=verbose, fixed_X_dims=-1 - ) + assert check_kernel_gradient_functions( + kern, X=self.X, X2=self.X2, verbose=verbose, fixed_X_dims=-1 ) -@unittest.skipIf( +@pytest.skipIf( not cython_coregionalize_working, "Cython coregionalize module has not been built on this machine", ) -class Coregionalize_cython_test(unittest.TestCase): +class TestCoregionalizeCython: """ Make sure that the coregionalize kernel work with and without cython enabled """ - def setUp(self): + def setup(self): self.k = GPy.kern.Coregionalize(1, output_dim=12) self.N1, self.N2 = 100, 200 self.X = np.random.randint(0, 12, (self.N1, 1)) self.X2 = np.random.randint(0, 12, (self.N2, 1)) def test_sym(self): + self.setup() dL_dK = np.random.randn(self.N1, self.N1) K_cython = self.k._K_cython(self.X) self.k.update_gradients_full(dL_dK, self.X) @@ -938,10 +903,11 @@ class Coregionalize_cython_test(unittest.TestCase): self.k._gradient_reduce_cython = _gradient_reduce_cython grads_numpy = self.k.gradient.copy() - self.assertTrue(np.allclose(K_numpy, K_cython)) - self.assertTrue(np.allclose(grads_numpy, grads_cython)) + assert np.allclose(K_numpy, K_cython) + assert np.allclose(grads_numpy, grads_cython) def test_nonsym(self): + self.setup() dL_dK = np.random.randn(self.N1, self.N2) K_cython = self.k._K_cython(self.X, self.X2) self.k.gradient = 0.0 @@ -958,28 +924,28 @@ class Coregionalize_cython_test(unittest.TestCase): self.k._gradient_reduce_cython = _gradient_reduce_cython grads_numpy = self.k.gradient.copy() - self.assertTrue(np.allclose(K_numpy, K_cython)) - self.assertTrue(np.allclose(grads_numpy, grads_cython)) + assert np.allclose(K_numpy, K_cython) + assert np.allclose(grads_numpy, grads_cython) -class KernelTestsProductWithZeroValues(unittest.TestCase): - def setUp(self): +class TestKernelProductWithZeroValues: + def setup(self): self.X = np.array([[0, 1], [1, 0]]) self.k = GPy.kern.Linear(2) * GPy.kern.Bias(2) def test_zero_valued_kernel_full(self): + self.setup() self.k.update_gradients_full(1, self.X) - self.assertFalse( - np.isnan(self.k["linear.variances"].gradient), "Gradient resulted in NaN" - ) + assert np.isnan(self.k["linear.variances"].gradient), "Gradient resulted in NaN" def test_zero_valued_kernel_gradients_X(self): + self.seutp() target = self.k.gradients_X(1, self.X) - self.assertFalse(np.any(np.isnan(target)), "Gradient resulted in NaN") + assert np.any(np.isnan(target)), "Gradient resulted in NaN" -class Kernel_Psi_statistics_GradientTests(unittest.TestCase): - def setUp(self): +class TestKernelPsiStatisticsGradient: + def setup(self): from GPy.core.parameterization.variational import NormalPosterior N, M, Q = 100, 20, 3 @@ -997,6 +963,7 @@ class Kernel_Psi_statistics_GradientTests(unittest.TestCase): self.w3n = self.w3n + np.swapaxes(self.w3n, 1, 2) def test_kernels(self): + self.setup() from GPy.kern import RBF, Linear, MLP, Bias, White Q = self.Z.shape[1] @@ -1049,7 +1016,7 @@ class Kernel_Psi_statistics_GradientTests(unittest.TestCase): m = GradientChecker(f, df, kernel.param_array.copy()) m.checkgrad(verbose=1) - self.assertTrue(m.checkgrad()) + assert m.checkgrad() def _test_Z(self, kernel, psi2n=False): def f(p): @@ -1079,7 +1046,7 @@ class Kernel_Psi_statistics_GradientTests(unittest.TestCase): from GPy.models import GradientChecker m = GradientChecker(f, df, self.Z.copy()) - self.assertTrue(m.checkgrad()) + assert m.checkgrad() def _test_qX(self, kernel, psi2n=False): def f(p): @@ -1114,31 +1081,4 @@ class Kernel_Psi_statistics_GradientTests(unittest.TestCase): from GPy.models import GradientChecker m = GradientChecker(f, df, self.qX.param_array.copy()) - self.assertTrue(m.checkgrad()) - - -if __name__ == "__main__": - print("Running unit tests, please be (very) patient...") - unittest.main() - -# np.random.seed(0) -# N0 = 3 -# N1 = 9 -# N2 = 4 -# N = N0+N1+N2 -# D = 3 -# X = np.random.randn(N, D+1) -# indices = np.random.random_integers(0, 2, size=N) -# X[indices==0, -1] = 0 -# X[indices==1, -1] = 1 -# X[indices==2, -1] = 2 -# #X = X[X[:, -1].argsort(), :] -# X2 = np.random.randn((N0+N1)*2, D+1) -# X2[:(N0*2), -1] = 0 -# X2[(N0*2):, -1] = 1 -# k = [GPy.kern.RBF(1, active_dims=[1], name='rbf1'), GPy.kern.RBF(D, name='rbf012'), GPy.kern.RBF(2, active_dims=[0,2], name='rbf02')] -# kern = GPy.kern.IndependentOutputs(k, -1, name='ind_split') -# assert(check_kernel_gradient_functions(kern, X=X, X2=X2, verbose=verbose, fixed_X_dims=-1)) -# k = GPy.kern.RBF(D) -# kern = GPy.kern.IndependentOutputs(k, -1, 'ind_single') -# assert(check_kernel_gradient_functions(kern, X=X, X2=X2, verbose=verbose, fixed_X_dims=-1)) + assert m.checkgrad()