def test_corner_cases(): m1 = Graph() m2 = Graph() p1 = GP(EQ(), graph=m1) p2 = GP(EQ(), graph=m2) x = np.random.randn(10, 2) with pytest.raises(RuntimeError): p1 + p2 with pytest.raises(NotImplementedError): p1 + p1(x) with pytest.raises(NotImplementedError): p1 * p1(x) assert str(GP(EQ(), graph=m1)) == 'GP(EQ(), 0)'
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_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_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_multi_logpdf(): model = Graph() p1 = GP(EQ(), graph=model) p2 = GP(2 * Exp(), graph=model) p3 = p1 + p2 x1 = np.linspace(0, 2, 5) x2 = np.linspace(1, 3, 6) x3 = np.linspace(2, 4, 7) y1, y2, y3 = model.sample(p1(x1), p2(x2), p3(x3)) # Test case that only one process is fed. yield assert_allclose, p1(x1).logpdf(y1), model.logpdf(p1(x1), y1) yield assert_allclose, p1(x1).logpdf(y1), model.logpdf((p1(x1), y1)) # Test that all inputs must be specified. yield raises, ValueError, lambda: model.logpdf((x1, y1), (p2(x2), y2)) yield raises, ValueError, lambda: model.logpdf((p1(x1), y1), (x2, y2)) # Compute the logpdf with the product rule. logpdf1 = p1(x1).logpdf(y1) + \ p2(x2).logpdf(y2) + \ (p3 | ((p1(x1), y1), (p2(x2), y2)))(x3).logpdf(y3) logpdf2 = model.logpdf((p1(x1), y1), (p2(x2), y2), (p3(x3), y3)) yield assert_allclose, logpdf1, logpdf2
def test_case_fd_derivative(): x = np.linspace(0, 10, 50)[:, None] y = np.sin(x) model = Graph() p = GP(.7 * EQ().stretch(1.), graph=model) dp = (p.shift(-1e-3) - p.shift(1e-3)) / 2e-3 yield le, abs_err(np.cos(x) - dp.condition(p(x), y)(x).mean), 1e-4
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_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_case_blr(): model = Graph() x = np.linspace(0, 10, 100) slope = GP(1, graph=model) intercept = GP(1, graph=model) f = slope * (lambda x: x) + intercept y = f + 1e-2 * GP(Delta(), graph=model) # Sample observations, true slope, and intercept. y_obs, true_slope, true_intercept = \ model.sample(y(x), slope(0), intercept(0)) # Predict. post_slope, post_intercept = (slope, intercept) | Obs(y(x), y_obs) mean_slope, mean_intercept = post_slope(0).mean, post_intercept(0).mean yield le, np.abs(true_slope[0, 0] - mean_slope[0, 0]), 5e-2 yield le, np.abs(true_intercept[0, 0] - mean_intercept[0, 0]), 5e-2
def test_multi_sample(): model = Graph() p1 = GP(0, 1, graph=model) p2 = GP(0, 2, graph=model) p3 = GP(0, 3, graph=model) x1 = np.linspace(0, 1, 10) x2 = np.linspace(0, 1, 20) x3 = np.linspace(0, 1, 30) s1, s2, s3 = model.sample(p1(x1), p2(x2), p3(x3)) yield eq, s1.shape, (10, 1) yield eq, s2.shape, (20, 1) yield eq, s3.shape, (30, 1) yield eq, np.shape(model.sample(p1(x1))), (10, 1) yield le, abs_err(s1 - 1), 1e-4 yield le, abs_err(s2 - 2), 1e-4 yield le, abs_err(s3 - 3), 1e-4
def test_multi_sample(): model = Graph() p1 = GP(0, 1, graph=model) p2 = GP(0, 2, graph=model) p3 = GP(0, 3, graph=model) x1 = np.linspace(0, 1, 10) x2 = np.linspace(0, 1, 20) x3 = np.linspace(0, 1, 30) s1, s2, s3 = model.sample(p1(x1), p2(x2), p3(x3)) assert s1.shape == (10, 1) assert s2.shape == (20, 1) assert s3.shape == (30, 1) assert np.shape(model.sample(p1(x1))) == (10, 1) assert abs_err(s1 - 1) <= 1e-4 assert abs_err(s2 - 2) <= 1e-4 assert abs_err(s3 - 3) <= 1e-4
def test_derivative(): # Test construction: p = GP(EQ(), TensorProductMean(lambda x: x ** 2), graph=Graph()) assert str(p.diff(1)) == 'GP(d(1) EQ(), d(1) <lambda>)' # Test case: model = Graph() x = B.linspace(tf.float64, 0, 1, 100)[:, None] y = 2 * x p = GP(EQ(), graph=model) dp = p.diff() # Test conditioning on function. assert abs_err(dp.condition(p(x), y)(x).mean, 2) <= 1e-3 # Test conditioning on derivative. post = p.condition((B.cast(tf.float64, 0), B.cast(tf.float64, 0)), (dp(x), y)) assert abs_err(post(x).mean, x ** 2) <= 1e-3
def test_case_reflection(): model = Graph() p = GP(EQ(), graph=model) p2 = 5 - p x = np.linspace(0, 1, 10)[:, None] y = p(x).sample() yield le, abs_err(p2.condition(p(x), y)(x).mean - (5 - y)), 1e-5 yield le, abs_err(p.condition(p2(x), 5 - y)(x).mean - y), 1e-5 model = Graph() p = GP(EQ(), graph=model) p2 = -p x = np.linspace(0, 1, 10)[:, None] y = p(x).sample() yield le, abs_err(p2.condition(p(x), y)(x).mean + y), 1e-5 yield le, abs_err(p.condition(p2(x), -y)(x).mean - y), 1e-5
def test_case_summation_with_itself(): # Test summing the same GP with itself. model = Graph() p1 = GP(EQ(), graph=model) p2 = p1 + p1 + p1 + p1 + p1 x = np.linspace(0, 10, 5)[:, None] yield assert_allclose, p2(x).var, 25 * p1(x).var yield assert_allclose, p2(x).mean, np.zeros((5, 1)) y = np.random.randn(5, 1) yield assert_allclose, p2.condition(p1(x), y)(x).mean, 5 * y
def test_shorthands(): model = Graph() p = GP(EQ(), graph=model) # Construct a normal distribution that serves as in input. x = p(1) yield assert_instance, x, At yield ok, type_parameter(x) is p yield eq, x.get(), 1 yield eq, str(p(x)), '{}({})'.format(str(p), str(x)) yield eq, 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))) yield raises, RuntimeError, lambda: type_parameter(x) yield raises, RuntimeError, lambda: x.get() yield raises, RuntimeError, lambda: p | (x, 1) # Test shorthands for stretching and selection. p = GP(EQ(), graph=Graph()) yield eq, str(p > 2), str(p.stretch(2)) yield eq, str(p[0]), str(p.select(0))
def test_sum_other(): model = Graph() p1 = GP(EQ(), TensorProductMean(lambda x: x ** 2), graph=model) p2 = p1 + 5. p3 = 5. + p1 p4 = model.sum(5., p1) x = np.random.randn(5, 1) yield assert_allclose, p1.mean(x) + 5., p2.mean(x) yield assert_allclose, p1.mean(x) + 5., p3.mean(x) yield assert_allclose, p1.mean(x) + 5., p4.mean(x) yield assert_allclose, p1.kernel(x), p2.kernel(x) yield assert_allclose, p1.kernel(x), p3.kernel(x) yield assert_allclose, p1.kernel(x), p4.kernel(x) yield assert_allclose, p1.kernel(p2(x), p3(x)), \ p1.kernel(x) yield assert_allclose, p1.kernel(p2(x), p4(x)), \ p1.kernel(x) # Check that a `GP` cannot be summed with a `Normal`. yield raises, NotImplementedError, lambda: p1 + Normal(np.eye(3)) yield raises, NotImplementedError, lambda: Normal(np.eye(3)) + p1
def test_multi_conditioning(): model = Graph() p1 = GP(EQ(), graph=model) p2 = GP(2 * Exp().stretch(2), graph=model) p3 = GP(.5 * RQ(1e-1).stretch(.5), graph=model) p = p1 + p2 + p3 x1 = np.linspace(0, 2, 10) x2 = np.linspace(1, 3, 10) x3 = np.linspace(0, 3, 10) s1, s2 = model.sample(p1(x1), p2(x2)) post1 = ((p | (p1(x1), s1)) | ((p2 | (p1(x1), s1))(x2), s2))(x3) post2 = (p | ((p1(x1), s1), (p2(x2), s2)))(x3) post3 = (p | ((p2(x2), s2), (p1(x1), s1)))(x3) yield assert_allclose, post1.mean, post2.mean, 'means 1', 1e-6, 1e-6 yield assert_allclose, post1.mean, post3.mean, 'means 2', 1e-6, 1e-6 yield assert_allclose, post1.var, post2.var yield assert_allclose, post1.var, post3.var
def test_mul_other(): model = Graph() p1 = GP(EQ(), TensorProductMean(lambda x: x ** 2), graph=model) p2 = 5. * p1 p3 = p1 * 5. x = np.random.randn(5, 1) yield assert_allclose, 5. * p1.mean(x), p2.mean(x) yield assert_allclose, 5. * p1.mean(x), p3.mean(x) yield assert_allclose, 25. * p1.kernel(x), p2.kernel(x) yield assert_allclose, 25. * p1.kernel(x), p3.kernel(x) yield assert_allclose, model.kernels[p2, p3](x, x), 25. * p1.kernel(x) # Check that a `GP` cannot be multiplied with a `Normal`. yield raises, NotImplementedError, lambda: p1 * Normal(np.eye(3)) yield raises, NotImplementedError, lambda: Normal(np.eye(3)) * p1
def test_momean(): m = Graph() p1 = GP(1 * EQ(), lambda x: 2 * x, graph=m) p2 = GP(2 * EQ().stretch(2), 1, graph=m) mom = MultiOutputMean(p1, p2) ms = m.means x = np.linspace(0, 1, 10) assert str(mom) == 'MultiOutputMean(<lambda>, 1)' allclose(mom(x), np.concatenate([ms[p1](x), ms[p2](x)], axis=0)) allclose(mom(p1(x)), ms[p1](x)) allclose(mom(p2(x)), ms[p2](x)) allclose(mom(MultiInput(p2(x), p1(x))), np.concatenate([ms[p2](x), ms[p1](x)], axis=0))
def test_mul_other(): model = Graph() p1 = GP(EQ(), TensorProductMean(lambda x: x ** 2), graph=model) p2 = 5. * p1 p3 = p1 * 5. x = np.random.randn(5, 1) allclose(5. * p1.mean(x), p2.mean(x)) allclose(5. * p1.mean(x), p3.mean(x)) allclose(25. * p1.kernel(x), p2.kernel(x)) allclose(25. * p1.kernel(x), p3.kernel(x)) allclose(model.kernels[p2, p3](x, x), 25. * p1.kernel(x)) # Check that a `GP` cannot be multiplied with a `Normal`. with pytest.raises(NotImplementedError): p1 * Normal(np.eye(3)) with pytest.raises(NotImplementedError): Normal(np.eye(3)) * p1
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 p = p3 + p assert p.stationary == True p = p + GP(Linear(), graph=model) assert p.stationary == False
def test_construction(): model = Graph() p = GP(EQ(), graph=model) x = np.random.randn(10, 1) p.mean(x) p.mean(p(x)) p.kernel(x) p.kernel(p(x)) p.kernel(x, x) p.kernel(p(x), x) p.kernel(x, p(x)) p.kernel(p(x), p(x)) p.kernel.elwise(x) p.kernel.elwise(p(x)) p.kernel.elwise(x, x) p.kernel.elwise(p(x), x) p.kernel.elwise(x, p(x)) p.kernel.elwise(p(x), p(x)) # Test resolution of kernel and mean. k = EQ() m = TensorProductMean(lambda x: x ** 2) assert isinstance(GP(k, graph=model).mean, ZeroMean) assert isinstance(GP(k, 5, graph=model).mean, ScaledMean) assert isinstance(GP(k, 1, graph=model).mean, OneMean) assert isinstance(GP(k, 0, graph=model).mean, ZeroMean) assert isinstance(GP(k, m, graph=model).mean, TensorProductMean) assert isinstance(GP(k, graph=model).kernel, EQ) assert isinstance(GP(5, graph=model).kernel, ScaledKernel) assert isinstance(GP(1, graph=model).kernel, OneKernel) assert isinstance(GP(0, graph=model).kernel, ZeroKernel) # Test construction of finite-dimensional distribution. d = GP(k, m, graph=model)(x) allclose(d.var, k(x)) allclose(d.mean, m(x))
def test_naming(): model = Graph() p1 = GP(EQ(), 1, graph=model) p2 = GP(EQ(), 2, graph=model) # Test setting and getting names. p1.name = 'name' assert model['name'] is p1 assert p1.name == 'name' assert model[p1] == 'name' with pytest.raises(KeyError): model['other_name'] with pytest.raises(KeyError): model[p2] # Check that names can not be doubly assigned. def doubly_assign(): p2.name = 'name' with pytest.raises(RuntimeError): doubly_assign() # Move name to other GP. p1.name = 'other_name' p2.name = 'name' # Check that everything has been properly assigned. assert model['name'] is p2 assert p2.name == 'name' assert model[p2] == 'name' assert model['other_name'] is p1 assert p1.name == 'other_name' assert model[p1] == 'other_name' # Test giving a name to the constructor. p3 = GP(EQ(), name='yet_another_name', graph=model) assert model['yet_another_name'] is p3 assert p3.name == 'yet_another_name' assert model[p3] == 'yet_another_name'
def test_marginals(): model = Graph() p = GP(EQ(), TensorProductMean(lambda x: x ** 2), graph=model) x = np.linspace(0, 5, 10) # Check that `marginals` outputs the right thing. mean, lower, upper = p(x).marginals() var = B.diag(p.kernel(x)) yield assert_allclose, mean, p.mean(x)[:, 0] yield assert_allclose, lower, p.mean(x)[:, 0] - 2 * var ** .5 yield assert_allclose, upper, p.mean(x)[:, 0] + 2 * var ** .5 # Test correctness. y = p(x).sample() mean, lower, upper = (p | (x, y))(x).marginals() yield assert_allclose, mean, y[:, 0] yield le, B.mean(B.abs(upper - lower)), 1e-5 mean, lower, upper = (p | (x, y))(x + 100).marginals() yield assert_allclose, mean, p.mean(x + 100)[:, 0] yield assert_allclose, upper - lower, 4 * np.ones(10)
def test_case_approximate_derivative(): model = Graph() x = np.linspace(0, 1, 100)[:, None] y = 2 * x p = GP(EQ().stretch(1.), graph=model) dp = p.diff_approx() # Test conditioning on function. yield le, abs_err(dp.condition(p(x), y)(x).mean - 2), 1e-3 # Add some regularisation for this test case. orig_epsilon = B.epsilon B.epsilon = 1e-10 # Test conditioning on derivative. post = p.condition((0, 0), (dp(x), y)) yield le, abs_err(post(x).mean - x ** 2), 1e-3 # Set regularisation back. B.epsilon = orig_epsilon
def test_stretching(): model = Graph() # Test construction: p = GP(EQ(), TensorProductMean(lambda x: x ** 2), graph=model) assert str(p.stretch(1)) == 'GP(EQ() > 1, <lambda> > 1)' # Test case: p = GP(EQ(), graph=model) p2 = p.stretch(5) n = 5 x = np.linspace(0, 10, n)[:, None] y = p2(x).sample() post = p.condition(p2(x), y) allclose(post(x / 5).mean, y) assert abs_err(B.diag(post(x / 5).var)) <= 1e-10 post = p2.condition(p(x), y) allclose(post(x * 5).mean, y) assert abs_err(B.diag(post(x * 5).var)) <= 1e-10
def test_shifting(): model = Graph() # Test construction: p = GP(Linear(), TensorProductMean(lambda x: x ** 2), graph=model) yield eq, str(p.shift(1)), 'GP(Linear() shift 1, <lambda> shift 1)' # Test case: p = GP(EQ(), graph=model) p2 = p.shift(5) n = 5 x = np.linspace(0, 10, n)[:, None] y = p2(x).sample() post = p.condition(p2(x), y) yield assert_allclose, post(x - 5).mean, y yield le, abs_err(B.diag(post(x - 5).var)), 1e-10 post = p2.condition(p(x), y) yield assert_allclose, post(x + 5).mean, y yield le, abs_err(B.diag(post(x + 5).var)), 1e-10
def test_naming(): model = Graph() p1 = GP(EQ(), 1, graph=model) p2 = GP(EQ(), 2, graph=model) # Test setting and getting names. p1.name = 'name' yield ok, model['name'] is p1 yield eq, p1.name, 'name' yield eq, model[p1], 'name' yield raises, KeyError, lambda: model['other_name'] yield raises, KeyError, lambda: model[p2] # Check that names can not be doubly assigned. def doubly_assign(): p2.name = 'name' yield raises, RuntimeError, doubly_assign # Move name to other GP. p1.name = 'other_name' p2.name = 'name' # Check that everything has been properly assigned. yield ok, model['name'] is p2 yield eq, p2.name, 'name' yield eq, model[p2], 'name' yield ok, model['other_name'] is p1 yield eq, p1.name, 'other_name' yield eq, model[p1], 'other_name' # Test giving a name to the constructor. p3 = GP(EQ(), name='yet_another_name', graph=model) yield ok, model['yet_another_name'] is p3 yield eq, p3.name, 'yet_another_name' yield eq, model[p3], 'yet_another_name'
def test_input_transform(): model = Graph() # Test construction: p = GP(EQ(), TensorProductMean(lambda x: x ** 2), graph=model) yield eq, str(p.transform(lambda x, c: x)), \ 'GP(EQ() transform <lambda>, <lambda> transform <lambda>)' # Test case: p = GP(EQ(), graph=model) p2 = p.transform(lambda x, B: x / 5) n = 5 x = np.linspace(0, 10, n)[:, None] y = p2(x).sample() post = p.condition(p2(x), y) yield assert_allclose, post(x / 5).mean, y yield le, abs_err(B.diag(post(x / 5).var)), 1e-10 post = p2.condition(p(x), y) yield assert_allclose, post(x * 5).mean, y yield le, abs_err(B.diag(post(x * 5).var)), 1e-10
def test_uprank(): allclose(uprank(0), [[0]]) allclose(uprank(np.array([0])), [[0]]) allclose(uprank(np.array([[0]])), [[0]]) assert type(uprank(Component('test')(0))) == Component('test') k = OneKernel() assert B.shape(k(0, 0)) == (1, 1) assert B.shape(k(0, np.ones(5))) == (1, 5) assert B.shape(k(0, np.ones((5, 2)))) == (1, 5) assert B.shape(k(np.ones(5), 0)) == (5, 1) assert B.shape(k(np.ones(5), np.ones(5))) == (5, 5) assert B.shape(k(np.ones(5), np.ones((5, 2)))) == (5, 5) assert B.shape(k(np.ones((5, 2)), 0)) == (5, 1) assert B.shape(k(np.ones((5, 2)), np.ones(5))) == (5, 5) assert B.shape(k(np.ones((5, 2)), np.ones((5, 2)))) == (5, 5) with pytest.raises(ValueError): k(0, np.ones((5, 2, 1))) with pytest.raises(ValueError): k(np.ones((5, 2, 1))) m = OneMean() assert B.shape(m(0)) == (1, 1) assert B.shape(m(np.ones(5))) == (5, 1) assert B.shape(m(np.ones((5, 2)))) == (5, 1) p = GP(EQ(), graph=Graph()) x = np.linspace(0, 10, 10) approx(p.condition(1, 1)(1).mean, np.array([[1]])) approx(p.condition(x, x)(x).mean, x[:, None]) approx(p.condition(x, x[:, None])(x).mean, x[:, None])