def test_input_transform(): k = Linear().transform(lambda x, c: x - 5) yield eq, k.stationary, False yield raises, RuntimeError, lambda: k.length_scale yield raises, RuntimeError, lambda: k.var yield raises, RuntimeError, lambda: k.period def f1(x): return x def f2(x): return x**2 # Test equality. yield eq, EQ().transform(f1), EQ().transform(f1) yield neq, EQ().transform(f1), EQ().transform(f2) yield neq, EQ().transform(f1), Matern12().transform(f1) # Standard tests: for x in kernel_generator(k): yield x # Test computation of the kernel. k = Linear() x1, x2 = np.random.randn(10, 2), np.random.randn(10, 2) k2 = k.transform(lambda x, c: x**2) k3 = k.transform(lambda x, c: x**2, lambda x, c: x - 5) yield assert_allclose, k(x1**2, x2**2), k2(x1, x2) yield assert_allclose, k(x1**2, x2 - 5), k3(x1, x2)
def test_shifted(): k = ShiftedKernel(2 * EQ(), 5) assert k.stationary # Test equality. assert Linear().shift(2) == Linear().shift(2) assert Linear().shift(2) != Linear().shift(3) assert Linear().shift(2) != DecayingKernel(1, 1).shift(2) # Standard tests: standard_kernel_tests(k) k = (2 * EQ()).shift(5, 6) assert not k.stationary # Check computation. x1 = np.random.randn(10, 2) x2 = np.random.randn(5, 2) k = Linear() allclose(k.shift(5)(x1, x2), k(x1 - 5, x2 - 5)) # Check passing in a list. k = Linear().shift(np.array([1, 2])) k(np.random.randn(10, 2))
def test_approximate_multiplication(): model = Graph() # Construct model. p1 = GP(EQ(), 20, graph=model) p2 = GP(EQ(), 20, graph=model) p_prod = p1 * p2 x = np.linspace(0, 10, 50) # Sample functions. s1, s2 = model.sample(p1(x), p2(x)) # Infer product. post = p_prod.condition((p1(x), s1), (p2(x), s2)) yield le, rel_err(post(x).mean, s1 * s2), 1e-2 # Perform division. cur_epsilon = B.epsilon B.epsilon = 1e-8 post = p2.condition((p1(x), s1), (p_prod(x), s1 * s2)) yield le, rel_err(post(x).mean, s2), 1e-2 B.epsilon = cur_epsilon # Check graph check. model2 = Graph() p3 = GP(EQ(), graph=model2) yield raises, RuntimeError, lambda: p3 * p1
def test_corner_cases(): with pytest.raises(IndexError): EQ().stretch(1)[1] with pytest.raises(IndexError): (EQ() + RQ(1))[2] with pytest.raises(RuntimeError): mul(1, 1) with pytest.raises(RuntimeError): add(1, 1) with pytest.raises(RuntimeError): stretch(1, 1) with pytest.raises(RuntimeError): transform(1, 1) with pytest.raises(RuntimeError): differentiate(1, 1) with pytest.raises(RuntimeError): select(1, 1) with pytest.raises(RuntimeError): shift(1, 1) assert repr(EQ()) == str(EQ()) assert EQ().__name__ == 'EQ' with pytest.raises(NotImplementedError): WrappedElement(1).display(1, lambda x: x) with pytest.raises(NotImplementedError): JoinElement(1, 2).display(1, 2, lambda x: x)
def test_properties(): model = Graph() p1 = GP(EQ(), graph=model) p2 = GP(EQ().stretch(2), graph=model) p3 = GP(EQ().periodic(10), graph=model) p = p1 + 2 * p2 assert p.stationary == True, 'stationary' assert p.var == 1 + 2**2, 'var' allclose(p.length_scale, (1 + 2 * 2**2) / (1 + 2**2)) assert p.period == np.inf, 'period' assert p3.period == 10, 'period' p = p3 + p assert p.stationary == True, 'stationary 2' assert p.var == 1 + 2**2 + 1, 'var 2' assert p.period == np.inf, 'period 2' p = p + GP(Linear(), graph=model) assert p.stationary == False, 'stationary 3'
def test_input_transform(): assert str(EQ().transform(lambda x: x)) == 'EQ() transform <lambda>' assert str(EQ().transform(lambda x: x, lambda x: x)) == \ 'EQ() transform (<lambda>, <lambda>)' assert str(ZeroKernel().transform(lambda x: x)) == '0' assert str(OneMean().transform(lambda x: x)) == '1'
def test_input_transform(): k = Linear().transform(lambda x: x - 5) # Verify that the kernel has the right properties. assert not k.stationary def f1(x): return x def f2(x): return x**2 # Test equality. assert EQ().transform(f1) == EQ().transform(f1) assert EQ().transform(f1) != EQ().transform(f2) assert EQ().transform(f1) != Matern12().transform(f1) # Standard tests: standard_kernel_tests(k) # Test computation of the kernel. k = Linear() x1, x2 = B.randn(10, 2), B.randn(10, 2) k2 = k.transform(lambda x: x**2) k3 = k.transform(lambda x: x**2, lambda x: x - 5) approx(k(x1**2, x2**2), k2(x1, x2)) approx(k(x1**2, x2 - 5), k3(x1, x2))
def test_periodic(): k = EQ().stretch(2).periodic(3) assert k.stationary assert k.length_scale == 2 assert k.period == 3 assert k.var == 1 # Test equality. assert EQ().periodic(2) == EQ().periodic(2) assert EQ().periodic(2) != EQ().periodic(3) assert Matern12().periodic(2) != EQ().periodic(2) # Standard tests: standard_kernel_tests(k) k = 5 * k.stretch(5) assert k.stationary assert k.length_scale == 10 assert k.period == 15 assert k.var == 5 # Check passing in a list. k = EQ().periodic(np.array([1, 2])) k(np.random.randn(10, 2))
def test_periodic(): k = EQ().stretch(2).periodic(3) yield eq, k.stationary, True yield eq, k.length_scale, 2 yield eq, k.period, 3 yield eq, k.var, 1 # Test equality. yield eq, EQ().periodic(2), EQ().periodic(2) yield neq, EQ().periodic(2), EQ().periodic(3) yield neq, Matern12().periodic(2), EQ().periodic(2) # Standard tests: for x in kernel_generator(k): yield x k = 5 * k.stretch(5) yield eq, k.stationary, True yield eq, k.length_scale, 10 yield eq, k.period, 15 yield eq, k.var, 5 # Check passing in a list. k = EQ().periodic([1, 2]) yield k, np.random.randn(10, 2)
def test_properties(): model = Graph() p1 = GP(EQ(), graph=model) p2 = GP(EQ().stretch(2), graph=model) p3 = GP(EQ().periodic(10), graph=model) p = p1 + 2 * p2 yield eq, p.stationary, True, 'stationary' yield eq, p.var, 1 + 2 ** 2, 'var' yield assert_allclose, p.length_scale, \ (1 + 2 * 2 ** 2) / (1 + 2 ** 2) yield eq, p.period, np.inf, 'period' yield eq, p3.period, 10, 'period' p = p3 + p yield eq, p.stationary, True, 'stationary 2' yield eq, p.var, 1 + 2 ** 2 + 1, 'var 2' yield eq, p.period, np.inf, 'period 2' p = p + GP(Linear(), graph=model) yield eq, p.stationary, False, 'stationary 3'
def test_input_transform(): yield eq, str(EQ().transform(lambda x: x)), 'EQ() transform <lambda>' yield eq, str(EQ().transform(lambda x: x, lambda x: x)), \ 'EQ() transform (<lambda>, <lambda>)' yield eq, str(ZeroKernel().transform(lambda x: x)), '0' yield eq, str(OneMean().transform(lambda x: x)), '1'
def test_compare_noisy_kernel_and_additive_component_kernel(): def NoisyKernelCopy(k1, k2): return AdditiveComponentKernel({ Component('wiggly'): k1, Component('noise'): k2 }, latent=[Component('wiggly')]) x = np.random.randn(10, 2) k1 = EQ() k2 = RQ(1e-2) kn1 = NoisyKernel(k1, k2) kn2 = NoisyKernelCopy(k1, k2) yield ok, allclose(kn1(Latent(x)), k1(x)), 'noisy kernel 1' yield ok, allclose(kn1(Latent(x), Observed(x)), k1(x)), 'noisy kernel 2' yield ok, allclose(kn1(Observed(x), Latent(x)), k1(x)), 'noisy kernel 3' yield ok, allclose(kn1(Observed(x)), (k1 + k2)(x)), 'noisy kernel 4' yield ok, allclose(kn2(Latent(x)), k1(x)), 'noisy copy 1' yield ok, allclose(kn2(Latent(x), Observed(x)), k1(x)), 'noisy copy 2' yield ok, allclose(kn2(Observed(x), Latent(x)), k1(x)), 'noisy copy 3' yield ok, allclose(kn2(Observed(x)), (k1 + k2)(x)), 'noisy copy 4' yield ok, allclose(kn2(Latent(x), Component('noise')(x)), ZeroKernel()(x)), 'additive 1' yield ok, allclose(kn2(Component('noise')(x), Latent(x)), ZeroKernel()(x)), 'additive 2' yield ok, allclose(kn2(Observed(x), Component('noise')(x)), k2(x)), 'additive 3' yield ok, allclose(kn2(Component('noise')(x), Observed(x)), k2(x)), 'additive 4' yield eq, str(NoisyKernel(EQ(), RQ(1))), \ 'NoisyKernel(EQ(), RQ(1))'
def test_parentheses(): yield eq, str((reversed(Linear() * Linear() + 2 * EQ().stretch(1).periodic(2) + RQ(3).periodic(4))) * (EQ().stretch(1) + EQ())), \ '(Reversed(Linear()) * Reversed(Linear()) + ' \ '2 * ((EQ() > 1) per 2) + RQ(3) per 4) * (EQ() > 1 + EQ())'
def test_input_transform(): k = Linear().transform(lambda x: x - 5) assert not k.stationary with pytest.raises(RuntimeError): k.length_scale with pytest.raises(RuntimeError): k.var with pytest.raises(RuntimeError): k.period def f1(x): return x def f2(x): return x ** 2 # Test equality. assert EQ().transform(f1) == EQ().transform(f1) assert EQ().transform(f1) != EQ().transform(f2) assert EQ().transform(f1) != Matern12().transform(f1) # Standard tests: standard_kernel_tests(k) # Test computation of the kernel. k = Linear() x1, x2 = np.random.randn(10, 2), np.random.randn(10, 2) k2 = k.transform(lambda x: x ** 2) k3 = k.transform(lambda x: x ** 2, lambda x: x - 5) allclose(k(x1 ** 2, x2 ** 2), k2(x1, x2)) allclose(k(x1 ** 2, x2 - 5), k3(x1, x2))
def test_shorthands(): model = Graph() p = GP(EQ(), graph=model) # Construct a normal distribution that serves as in input. x = p(1) assert isinstance(x, At) assert type_parameter(x) is p assert x.get() == 1 assert str(p(x)) == '{}({})'.format(str(p), str(x)) assert repr(p(x)) == '{}({})'.format(repr(p), repr(x)) # Construct a normal distribution that does not serve as an input. x = Normal(np.ones((1, 1))) with pytest.raises(RuntimeError): type_parameter(x) with pytest.raises(RuntimeError): x.get() with pytest.raises(RuntimeError): p | (x, 1) # Test shorthands for stretching and selection. p = GP(EQ(), graph=Graph()) assert str(p > 2) == str(p.stretch(2)) assert str(p[0]) == str(p.select(0))
def test_shifted(): k = ShiftedKernel(2 * EQ(), 5) # Verify that the kernel has the right properties. assert k.stationary # Test equality. assert Linear().shift(2) == Linear().shift(2) assert Linear().shift(2) != Linear().shift(3) assert Linear().shift(2) != DecayingKernel(1, 1).shift(2) # Standard tests: standard_kernel_tests(k) k = (2 * EQ()).shift(5, 6) # Verify that the kernel has the right properties. assert not k.stationary # Check computation. x1 = B.randn(10, 2) x2 = B.randn(5, 2) k = Linear() approx(k.shift(5)(x1, x2), k(x1 - 5, x2 - 5)) # Check passing in a list. k = Linear().shift(np.array([1, 2])) k(B.randn(10, 2))
def test_shifted(): k = ShiftedKernel(2 * EQ(), 5) assert k.stationary assert k.length_scale == 1 assert k.period == np.inf assert k.var == 2 # Test equality. assert Linear().shift(2) == Linear().shift(2) assert Linear().shift(2) != Linear().shift(3) assert Linear().shift(2) != DecayingKernel(1, 1).shift(2) # Standard tests: standard_kernel_tests(k) k = (2 * EQ()).shift(5, 6) assert not k.stationary with pytest.raises(RuntimeError): k.length_scale assert k.period == np.inf assert k.var == 2 # Check computation. x1 = np.random.randn(10, 2) x2 = np.random.randn(5, 2) k = Linear() allclose(k.shift(5)(x1, x2), k(x1 - 5, x2 - 5)) # Check passing in a list. k = Linear().shift(np.array([1, 2])) k(np.random.randn(10, 2))
def test_reversal(): x1 = np.random.randn(10, 2) x2 = np.random.randn(5, 2) x3 = np.random.randn() # Test with a stationary and non-stationary kernel. for k in [EQ(), Linear()]: allclose(k(x1), reversed(k)(x1)) allclose(k(x3), reversed(k)(x3)) allclose(k(x1, x2), reversed(k)(x1, x2)) allclose(k(x1, x2), reversed(k)(x2, x1).T) # Test double reversal does the right thing. allclose(k(x1), reversed(reversed(k))(x1)) allclose(k(x3), reversed(reversed(k))(x3)) allclose(k(x1, x2), reversed(reversed(k))(x1, x2)) allclose(k(x1, x2), reversed(reversed(k))(x2, x1).T) # Verify that the kernel has the right properties. k = reversed(EQ()) assert k.stationary k = reversed(Linear()) assert not k.stationary assert str(k) == 'Reversed(Linear())' # Check equality. assert reversed(Linear()) == reversed(Linear()) assert reversed(Linear()) != Linear() assert reversed(Linear()) != reversed(EQ()) assert reversed(Linear()) != reversed(DecayingKernel(1, 1)) # Standard tests: standard_kernel_tests(k)
def test_shifted(): k = ShiftedKernel(2 * EQ(), 5) yield eq, k.stationary, True yield eq, k.length_scale, 1 yield eq, k.period, np.inf yield eq, k.var, 2 # Test equality. yield eq, Linear().shift(2), Linear().shift(2) yield neq, Linear().shift(2), Linear().shift(3) yield neq, Linear().shift(2), DecayingKernel(1, 1).shift(2) # Standard tests: for x in kernel_generator(k): yield x k = (2 * EQ()).shift(5, 6) yield eq, k.stationary, False yield raises, RuntimeError, lambda: k.length_scale yield eq, k.period, np.inf yield eq, k.var, 2 # Check computation. x1 = np.random.randn(10, 2) x2 = np.random.randn(5, 2) k = Linear() yield assert_allclose, k.shift(5)(x1, x2), k(x1 - 5, x2 - 5) # Check passing in a list. k = Linear().shift([1, 2]) yield k, np.random.randn(10, 2)
def test_derivative(): # Test construction: p = GP(EQ(), TensorProductMean(lambda x: x ** 2), graph=Graph()) yield eq, str(p.diff(1)), 'GP(d(1) EQ(), d(1) <lambda>)' # Test case: B.backend_to_tf() s = B.Session() model = Graph() x = np.linspace(0, 1, 100)[:, None] y = 2 * x p = GP(EQ(), graph=model) dp = p.diff() # Test conditioning on function. yield le, abs_err(s.run(dp.condition(p(x), y)(x).mean - 2)), 1e-3 # Test conditioning on derivative. post = p.condition((B.cast(0., np.float64), B.cast(0., np.float64)), (dp(x), y)) yield le, abs_err(s.run(post(x).mean - x ** 2)), 1e-3 s.close() B.backend_to_np()
def test_case_additive_model(): m = Measure() p1 = GP(EQ(), measure=m) p2 = GP(EQ(), measure=m) p_sum = p1 + p2 x = B.linspace(0, 5, 10) y1 = p1(x).sample() y2 = p2(x).sample() # First, test independence: assert m.kernels[p2, p1] == ZeroKernel() assert m.kernels[p1, p2] == ZeroKernel() # Now run through some test cases: post = (m | (p1(x), y1)) | (p2(x), y2) approx(post(p_sum)(x).mean, y1 + y2) post = (m | (p2(x), y2)) | (p1(x), y1) approx(post(p_sum)(x).mean, y1 + y2) post = (m | (p1(x), y1)) | (p_sum(x), y1 + y2) approx(post(p2)(x).mean, y2) post = (m | (p_sum(x), y1 + y2)) | (p1(x), y1) approx(post(p2)(x).mean, y2) post = (m | (p2(x), y2)) | (p_sum(x), y1 + y2) approx(post(p1)(x).mean, y1) post = (m | (p_sum(x), y1 + y2)) | (p2(x), y2) approx(post(p1)(x).mean, y1)
def test_selection(): # Test construction: p = GP(TensorProductMean(lambda x: x**2), EQ()) assert str(p.select(1)) == "GP(<lambda> : [1], EQ() : [1])" assert str(p.select(1, 2)) == "GP(<lambda> : [1, 2], EQ() : [1, 2])" # Test case: p = GP(EQ()) # 1D p2 = p.select(0) # 2D x = B.linspace(0, 5, 10) x21 = B.stack(x, B.randn(10), axis=1) x22 = B.stack(x, B.randn(10), axis=1) y = p2(x).sample() post = p.measure | (p2(x21), y) approx(post(p(x)).mean, y) assert_equal_normals(post(p(x)), post(p2(x21))) post = p.measure | (p2(x22), y) approx(post(p(x)).mean, y) assert_equal_normals(post(p(x)), post(p2(x22))) post = p.measure | (p(x), y) approx(post(p2(x21)).mean, y) approx(post(p2(x22)).mean, y) assert_equal_normals(post(p2(x21)), post(p(x))) assert_equal_normals(post(p2(x22)), post(p(x)))
def test_selection(): model = Graph() # Test construction: p = GP(EQ(), TensorProductMean(lambda x: x ** 2), graph=model) yield eq, str(p.select(1)), 'GP(EQ() : [1], <lambda> : [1])' yield eq, str(p.select(1, 2)), 'GP(EQ() : [1, 2], <lambda> : [1, 2])' # Test case: p = GP(EQ(), graph=model) # 1D p2 = p.select(0) # 2D n = 5 x = np.linspace(0, 10, n)[:, None] x1 = np.concatenate((x, np.random.randn(n, 1)), axis=1) x2 = np.concatenate((x, np.random.randn(n, 1)), axis=1) y = p2(x).sample() post = p.condition(p2(x1), y) yield assert_allclose, post(x).mean, y yield le, abs_err(B.diag(post(x).var)), 1e-10 post = p.condition(p2(x2), y) yield assert_allclose, post(x).mean, y yield le, abs_err(B.diag(post(x).var)), 1e-10 post = p2.condition(p(x), y) yield assert_allclose, post(x1).mean, y yield assert_allclose, post(x2).mean, y yield le, abs_err(B.diag(post(x1).var)), 1e-10 yield le, abs_err(B.diag(post(x2).var)), 1e-10
def test_nested_derivatives(dtype): x = B.randn(dtype, 10, 2) res = EQ().diff(0, 0).diff(0, 0)(x) assert ~B.isnan(res[0, 0]) res = EQ().diff(1, 1).diff(1, 1)(x) assert ~B.isnan(res[0, 0])
def test_derivative(): yield eq, str(EQ().diff(0)), 'd(0) EQ()' yield eq, str(EQ().diff(0, 1)), 'd(0, 1) EQ()' yield eq, str(ZeroKernel().diff(0)), '0' yield eq, str(OneKernel().diff(0)), '0' yield eq, str(ZeroMean().diff(0)), '0' yield eq, str(OneMean().diff(0)), '0'
def test_posterior_kernel(): k = PosteriorKernel(EQ(), EQ(), EQ(), B.randn(5, 2), EQ()(B.randn(5, 1))) # Verify that the kernel has the right properties. assert not k.stationary assert str(k) == "PosteriorKernel()" # Standard tests: standard_kernel_tests(k, shapes=[((10, 2), (5, 2))])
def test_derivative(): assert str(EQ().diff(0)) == 'd(0) EQ()' assert str(EQ().diff(0, 1)) == 'd(0, 1) EQ()' assert str(ZeroKernel().diff(0)) == '0' assert str(OneKernel().diff(0)) == '0' assert str(ZeroMean().diff(0)) == '0' assert str(OneMean().diff(0)) == '0'
def test_observations_and_conditioning(): model = Graph() p1 = GP(EQ(), graph=model) p2 = GP(EQ(), graph=model) p = p1 + p2 x = np.linspace(0, 5, 10) y = p(x).sample() y1 = p1(x).sample() # Test all ways of conditioning, including shorthands. obs1 = Obs(p(x), y) obs2 = Obs(x, y, ref=p) yield assert_allclose, obs1.y, obs2.y yield assert_allclose, obs1.K_x, obs2.K_x obs3 = Obs((p(x), y), (p1(x), y1)) obs4 = Obs((x, y), (p1(x), y1), ref=p) yield assert_allclose, obs3.y, obs4.y yield assert_allclose, obs3.K_x, obs4.K_x def assert_equal_mean_var(x, *ys): for y in ys: yield assert_allclose, x.mean, y.mean yield assert_allclose, x.var, y.var for test in assert_equal_mean_var( p.condition(x, y)(x), p.condition(p(x), y)(x), (p | (x, y))(x), (p | (p(x), y))(x), p.condition(obs1)(x), p.condition(obs2)(x), (p | obs1)(x), (p | obs2)(x)): yield test for test in assert_equal_mean_var( p.condition((x, y), (p1(x), y1))(x), p.condition((p(x), y), (p1(x), y1))(x), (p | [(x, y), (p1(x), y1)])(x), (p | [(p(x), y), (p1(x), y1)])(x), p.condition(obs3)(x), p.condition(obs4)(x), (p | obs3)(x), (p | obs4)(x)): yield test # Check conditioning multiple processes at once. p1_post, p2_post, p_post = (p1, p2, p) | obs1 p1_post, p2_post, p_post = p1_post(x), p2_post(x), p_post(x) p1_post2, p2_post2, p_post2 = (p1 | obs1)(x), (p2 | obs1)(x), (p | obs1)(x) yield assert_allclose, p1_post.mean, p1_post2.mean yield assert_allclose, p1_post.var, p1_post2.var yield assert_allclose, p2_post.mean, p2_post2.mean yield assert_allclose, p2_post.var, p2_post2.var yield assert_allclose, p_post.mean, p_post2.mean yield assert_allclose, p_post.var, p_post2.var # Test `At` check. yield raises, ValueError, lambda: Obs(0, 0) yield raises, ValueError, lambda: Obs((0, 0), (0, 0)) yield raises, ValueError, lambda: SparseObs(0, p, (0, 0))
def test_construction(): model = Graph() p = GP(EQ(), graph=model) x = np.random.randn(10, 1) c = Cache() yield p.mean, x yield p.mean, p(x) yield p.mean, x, c yield p.mean, p(x), c yield p.kernel, x yield p.kernel, p(x) yield p.kernel, x, c yield p.kernel, p(x), c yield p.kernel, x, x yield p.kernel, p(x), x yield p.kernel, x, p(x) yield p.kernel, p(x), p(x) yield p.kernel, x, x, c yield p.kernel, p(x), x, c yield p.kernel, x, p(x), c yield p.kernel, p(x), p(x), c yield p.kernel.elwise, x yield p.kernel.elwise, p(x) yield p.kernel.elwise, x, c yield p.kernel.elwise, p(x), c yield p.kernel.elwise, x, x yield p.kernel.elwise, p(x), x yield p.kernel.elwise, x, p(x) yield p.kernel.elwise, p(x), p(x) yield p.kernel.elwise, x, x, c yield p.kernel.elwise, p(x), x, c yield p.kernel.elwise, x, p(x), c yield p.kernel.elwise, p(x), p(x), c # Test resolution of kernel and mean. k = EQ() m = TensorProductMean(lambda x: x ** 2) yield assert_instance, GP(k, graph=model).mean, ZeroMean yield assert_instance, GP(k, 5, graph=model).mean, ScaledMean yield assert_instance, GP(k, 1, graph=model).mean, OneMean yield assert_instance, GP(k, 0, graph=model).mean, ZeroMean yield assert_instance, GP(k, m, graph=model).mean, TensorProductMean yield assert_instance, GP(k, graph=model).kernel, EQ yield assert_instance, GP(5, graph=model).kernel, ScaledKernel yield assert_instance, GP(1, graph=model).kernel, OneKernel yield assert_instance, GP(0, graph=model).kernel, ZeroKernel # Test construction of finite-dimensional distribution. d = GP(k, m, graph=model)(x) yield assert_allclose, d.var, k(x) yield assert_allclose, d.mean, m(x)
def test_corner_cases(): m1 = Graph() m2 = Graph() p1 = GP(EQ(), graph=m1) p2 = GP(EQ(), graph=m2) x = np.random.randn(10, 2) yield raises, RuntimeError, lambda: p1 + p2 yield raises, NotImplementedError, lambda: p1 + p1(x) yield raises, NotImplementedError, lambda: p1 * p1(x) yield eq, str(GP(EQ(), graph=m1)), 'GP(EQ(), 0)'