def test_mul_other():
p = GP(TensorProductMean(lambda x: x ** 2), EQ())
def five(y):
return 5 * B.ones(B.shape(y)[0], 1)
x = B.randn(5, 1)
for p_mul in [
# Multiply numeric thing.
p * 5.0,
5.0 * p,
p.measure.mul(GP(), p, 5.0),
p.measure.mul(GP(), 5.0, p),
# Multiply with a function.
p * five,
five * p,
p.measure.mul(GP(), p, five),
p.measure.mul(GP(), five, p),
]:
approx(5.0 * p.mean(x), p_mul.mean(x))
approx(5.0 * p.mean(x), p_mul.mean(x))
approx(25.0 * p.kernel(x), p_mul.kernel(x))
approx(25.0 * p.kernel(x), p_mul.kernel(x))
# Check that a `GP` cannot be multiplied with a `Normal`.
with pytest.raises(NotFoundLookupError):
p * Normal(np.eye(3))
with pytest.raises(NotFoundLookupError):
Normal(np.eye(3)) * p
def test_sum_other():
p = GP(TensorProductMean(lambda x: x ** 2), EQ())
def five(y):
return 5 * B.ones(B.shape(y)[0], 1)
x = B.randn(5, 1)
for p_sum in [
# Add a numeric thing.
p + 5.0,
5.0 + p,
p.measure.sum(GP(), p, 5.0),
p.measure.sum(GP(), 5.0, p),
# Add a function.
p + five,
five + p,
p.measure.sum(GP(), p, five),
p.measure.sum(GP(), five, p),
]:
approx(p.mean(x) + 5.0, p_sum.mean(x))
approx(p.mean(x) + 5.0, p_sum.mean(x))
approx(p.kernel(x), p_sum.kernel(x))
approx(p.kernel(x), p_sum.kernel(x))
# Check that a `GP` cannot be summed with a `Normal`.
with pytest.raises(NotFoundLookupError):
p + Normal(np.eye(3))
with pytest.raises(NotFoundLookupError):
Normal(np.eye(3)) + p
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_shifting():
# Test construction:
p = GP(TensorProductMean(lambda x: x**2), Linear())
assert str(p.shift(1)) == "GP(<lambda> shift 1, Linear() shift 1)"
# Test case:
p = GP(EQ())
p_shifted = p.shift(5)
x = B.linspace(0, 5, 10)
y = p_shifted(x).sample()
post = p.measure | (p_shifted(x), y)
assert_equal_normals(post(p(x - 5)), post(p_shifted(x)))
assert_equal_normals(post(p(x)), post(p_shifted(x + 5)))
def test_stretching():
# Test construction:
p = GP(TensorProductMean(lambda x: x**2), EQ())
assert str(p.stretch(1)) == "GP(<lambda> > 1, EQ() > 1)"
# Test case:
p = GP(EQ())
p_stretched = p.stretch(5)
x = B.linspace(0, 5, 10)
y = p_stretched(x).sample()
post = p.measure | (p_stretched(x), y)
assert_equal_normals(post(p(x / 5)), post(p_stretched(x)))
assert_equal_normals(post(p(x)), post(p_stretched(x * 5)))
def test_input_transform():
# Test construction:
p = GP(TensorProductMean(lambda x: x**2), EQ())
assert (str(p.transform(lambda x: x)) ==
"GP(<lambda> transform <lambda>, EQ() transform <lambda>)")
# Test case:
p = GP(EQ())
p_transformed = p.transform(lambda x: B.sqrt(x))
x = B.linspace(0, 5, 10)
y = p_transformed(x).sample()
post = p.measure | (p_transformed(x), y)
assert_equal_normals(post(p(B.sqrt(x))), post(p_transformed(x)))
assert_equal_normals(post(p(x)), post(p_transformed(x * x)))
def test_derivative():
# Test construction:
p = GP(TensorProductMean(lambda x: x**2), EQ())
assert str(p.diff(1)) == "GP(d(1) <lambda>, d(1) EQ())"
# Test case:
p = GP(EQ())
dp = p.diff()
x = B.linspace(tf.float64, 0, 1, 100)
y = 2 * x
x_check = B.linspace(tf.float64, 0.2, 0.8, 100)
# Test conditioning on function.
post = p.measure | (p(x), y)
approx(post(dp)(x_check).mean, 2 * B.ones(100, 1), atol=1e-4)
# Test conditioning on derivative.
zero = B.cast(tf.float64, 0)
post = p.measure | ((p(zero), zero), (dp(x), y))
approx(post(p)(x_check).mean, x_check[:, None]**2, atol=1e-4)
def test_marginals():
p = GP(TensorProductMean(lambda x: x ** 2), EQ())
x = B.linspace(0, 5, 10)
# Check that `marginals` outputs the right thing.
mean, var = p(x).marginals()
var = B.diag(p.kernel(x))
approx(mean, p.mean(x)[:, 0])
approx(var, B.diag(p.kernel(x)))
# Test correctness.
y = p(x).sample()
post = p.measure | (p(x), y)
# Concentration on data:
mean, var = post(p)(x).marginals()
approx(mean, y[:, 0])
approx(var, B.zeros(10), atol=1e-5)
# Reversion to prior:
mean, var = post(p)(x + 100).marginals()
approx(mean, p.mean(x + 100)[:, 0])
approx(var, B.diag(p.kernel(x + 100)))
def test_construction():
p = GP(EQ())
x = B.randn(10, 1)
p.mean(x)
p.kernel(x)
p.kernel(x, x)
p.kernel.elwise(x)
p.kernel.elwise(x, x)
# Test resolution of kernel and mean.
k = EQ()
m = TensorProductMean(lambda x: x ** 2)
assert isinstance(GP(k).mean, ZeroMean)
assert isinstance(GP(5, k).mean, ScaledMean)
assert isinstance(GP(1, k).mean, OneMean)
assert isinstance(GP(0, k).mean, ZeroMean)
assert isinstance(GP(m, k).mean, TensorProductMean)
assert isinstance(GP(k).kernel, EQ)
assert isinstance(GP(5).kernel, ScaledKernel)
assert isinstance(GP(1).kernel, OneKernel)
assert isinstance(GP(0).kernel, ZeroKernel)
# Test construction of finite-dimensional distribution without noise.
d = GP(m, k)(x)
approx(d.var, k(x))
approx(d.mean, m(x))
# Test construction of finite-dimensional distribution with noise.
d = GP(m, k)(x, 1)
approx(d.var, k(x) + B.eye(k(x)))
approx(d.mean, m(x))