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_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_function():
def f():
pass
assert str(ZeroKernel() * f) == '0'
assert str(f * ZeroKernel()) == '0'
assert str(OneKernel() * f) == 'f'
assert str(f * OneKernel()) == 'f'
assert str(EQ() * f) == 'EQ() * f'
assert str(f * EQ()) == 'f * EQ()'
assert str((EQ() * EQ()) * f) == 'EQ() * EQ() * f'
assert str(f * (EQ() * EQ())) == 'f * EQ() * EQ()'
assert str((5 * EQ()) * f) == '5 * EQ() * f'
assert str(f * (5 * EQ())) == '5 * f * EQ()'
assert str(ZeroKernel() + f) == 'f'
assert str(f + ZeroKernel()) == 'f'
assert str(OneKernel() + f) == '1 + f'
assert str(f + OneKernel()) == 'f + 1'
assert str(EQ() + f) == 'EQ() + f'
assert str(f + EQ()) == 'f + EQ()'
assert str((EQ() + RQ(1)) + f) == 'EQ() + RQ(1) + f'
assert str(f + (EQ() + RQ(1))) == 'f + EQ() + RQ(1)'
assert str((5 + EQ()) + f) == '5 * 1 + EQ() + f'
assert str(f + (5 + EQ())) == 'f + 5 * 1 + EQ()'
assert str(OneKernel() * f) == 'f'
assert str(OneKernel() * TensorProductKernel((lambda x, c: x), f)) == \
'(<lambda> x f)'
assert str(OneKernel() *
TensorProductKernel(f, (lambda x, c: x))) == '(f x <lambda>)'
def test_function():
def f():
pass
yield eq, str(ZeroKernel() * f), '0'
yield eq, str(f * ZeroKernel()), '0'
yield eq, str(OneKernel() * f), 'f'
yield eq, str(f * OneKernel()), 'f'
yield eq, str(EQ() * f), 'EQ() * f'
yield eq, str(f * EQ()), 'f * EQ()'
yield eq, str((EQ() * EQ()) * f), 'EQ() * EQ() * f'
yield eq, str(f * (EQ() * EQ())), 'f * EQ() * EQ()'
yield eq, str((5 * EQ()) * f), '5 * EQ() * f'
yield eq, str(f * (5 * EQ())), '5 * f * EQ()'
yield eq, str(ZeroKernel() + f), 'f'
yield eq, str(f + ZeroKernel()), 'f'
yield eq, str(OneKernel() + f), '1 + f'
yield eq, str(f + OneKernel()), 'f + 1'
yield eq, str(EQ() + f), 'EQ() + f'
yield eq, str(f + EQ()), 'f + EQ()'
yield eq, str((EQ() + RQ(1)) + f), 'EQ() + RQ(1) + f'
yield eq, str(f + (EQ() + RQ(1))), 'f + EQ() + RQ(1)'
yield eq, str((5 + EQ()) + f), '5 * 1 + EQ() + f'
yield eq, str(f + (5 + EQ())), 'f + 5 * 1 + EQ()'
yield eq, str(OneKernel() * f), 'f'
yield eq, str(OneKernel() * TensorProductKernel((lambda x, c: x), f)), \
'(<lambda> x f)'
yield eq, str(OneKernel() * TensorProductKernel(f, (lambda x, c: x))), \
'(f x <lambda>)'
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():
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_periodic():
k = EQ().stretch(2).periodic(3)
# Verify that the kernel has the right properties.
assert str(k) == "(EQ() > 2) per 3"
assert k.stationary
# 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)
# Verify that the kernel has the right properties.
assert k.stationary
# Check passing in a list.
k = EQ().periodic(np.array([1, 2]))
k(B.randn(10, 2))
# Check periodication of a zero.
k = ZeroKernel()
assert k.periodic(3) is k
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_zero():
k = ZeroKernel()
x1 = np.random.randn(10, 2)
x2 = np.random.randn(5, 2)
# Test that the kernel computes correctly.
allclose(k(x1, x2), np.zeros((10, 5)))
# Verify that the kernel has the right properties.
assert k.stationary
assert str(k) == '0'
# Test equality.
assert ZeroKernel() == ZeroKernel()
assert ZeroKernel() != Linear()
# Standard tests:
standard_kernel_tests(k)
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_zero():
k = ZeroKernel()
x1 = np.random.randn(10, 2)
x2 = np.random.randn(5, 2)
# Test that the kernel computes correctly.
yield assert_allclose, k(x1, x2), np.zeros((10, 5))
# Verify that the kernel has the right properties.
yield eq, k.stationary, True
yield eq, k.var, 0
yield eq, k.length_scale, 0
yield eq, k.period, 0
yield eq, str(k), '0'
# Test equality.
yield eq, ZeroKernel(), ZeroKernel()
yield neq, ZeroKernel(), Linear()
# Standard tests:
for x in kernel_generator(k):
yield x
def test_shifting():
# Kernels:
assert str(ZeroKernel().shift(5)) == '0'
assert str(EQ().shift(5)) == 'EQ()'
assert str(Linear().shift(5)) == 'Linear() shift 5'
assert str((5 * EQ()).shift(5)) == '5 * EQ()'
assert str((5 * Linear()).shift(5)) == '(5 * Linear()) shift 5'
# Means:
def mean(x):
return x
m = TensorProductMean(mean)
assert str(ZeroMean().shift(5)) == '0'
assert str(m.shift(5)) == 'mean shift 5'
assert str(m.shift(5).shift(5)) == 'mean shift 10'
assert str((5 * m).shift(5)) == '(5 * mean) shift 5'
def test_shifting():
# Kernels:
yield eq, str(ZeroKernel().shift(5)), '0'
yield eq, str(EQ().shift(5)), 'EQ()'
yield eq, str(Linear().shift(5)), 'Linear() shift 5'
yield eq, str((5 * EQ()).shift(5)), '5 * EQ()'
yield eq, str((5 * Linear()).shift(5)), '(5 * Linear()) shift 5'
# Means:
def mean(x):
return x
m = TensorProductMean(mean)
yield eq, str(ZeroMean().shift(5)), '0'
yield eq, str(m.shift(5)), 'mean shift 5'
yield eq, str(m.shift(5).shift(5)), 'mean shift 10'
yield eq, str((5 * m).shift(5)), '(5 * mean) shift 5'
def test_selection():
yield assert_allclose, _to_list((1, 2)), [1, 2]
yield assert_allclose, _to_list([1, 2]), [1, 2]
yield assert_allclose, _to_list(np.array([1, 2])), [1, 2]
yield assert_allclose, _to_list(1), [1]
yield raises, ValueError, lambda: _to_list(np.ones((1, 1)))
yield eq, str(EQ().select(0)), 'EQ() : [0]'
yield eq, str(EQ().select([0, 2])), 'EQ() : [0, 2]'
yield eq, str(EQ().select(0, 2)), 'EQ() : ([0], [2])'
yield eq, str(EQ().select([0], 2)), 'EQ() : ([0], [2])'
yield eq, str(EQ().select(0, [2])), 'EQ() : ([0], [2])'
yield eq, str(EQ().select([0, 1], [2])), 'EQ() : ([0, 1], [2])'
yield eq, str(EQ().select(None, [2])), 'EQ() : (None, [2])'
yield eq, str(EQ().select(None)), 'EQ() : None'
yield eq, str(EQ().select(None, None)), 'EQ() : (None, None)'
yield eq, str(EQ().select([1], None)), 'EQ() : ([1], None)'
yield eq, str(ZeroKernel().select(0)), '0'
yield eq, str(OneMean().select(0)), '1'
def test_component_kernel():
x = np.random.randn(10, 2)
k1 = EQ()
k2 = RQ(1e-1)
kzero = ZeroKernel()
kc = ComponentKernel({
(Component(1), Component(1)): k1,
(Component(1), Component(2)): kzero,
(Component(2), Component(1)): kzero,
(Component(2), Component(2)): k2
})
yield ok, allclose(kc(Component(1)(x)), k1(x))
yield ok, allclose(kc(Component(2)(x)), k2(x))
yield ok, allclose(kc(Component(1)(x), Component(2)(x)), kzero(x))
yield ok, allclose(kc(Component(2)(x), Component(1)(x)), kzero(x))
yield eq, str(ComponentKernel({Component(1): EQ(),
Component(2): EQ()})), \
'ComponentKernel(EQ(), EQ())'
def test_selection():
allclose(_to_list((1, 2)), [1, 2])
allclose(_to_list([1, 2]), [1, 2])
allclose(_to_list(np.array([1, 2])), [1, 2])
allclose(_to_list(1), [1])
with pytest.raises(ValueError):
_to_list(np.ones((1, 1)))
assert str(EQ().select(0)) == 'EQ() : [0]'
assert str(EQ().select([0, 2])) == 'EQ() : [0, 2]'
assert str(EQ().select(0, 2)) == 'EQ() : ([0], [2])'
assert str(EQ().select([0], 2)) == 'EQ() : ([0], [2])'
assert str(EQ().select(0, [2])) == 'EQ() : ([0], [2])'
assert str(EQ().select([0, 1], [2])) == 'EQ() : ([0, 1], [2])'
assert str(EQ().select(None, [2])) == 'EQ() : (None, [2])'
assert str(EQ().select(None)) == 'EQ() : None'
assert str(EQ().select(None, None)) == 'EQ() : (None, None)'
assert str(EQ().select([1], None)) == 'EQ() : ([1], None)'
assert str(ZeroKernel().select(0)) == '0'
assert str(OneMean().select(0)) == '1'
def test_cancellations_zero():
# With constants:
yield eq, str(1 * EQ()), 'EQ()'
yield eq, str(EQ() * 1), 'EQ()'
yield eq, str(0 * EQ()), '0'
yield eq, str(EQ() * 0), '0'
yield eq, str(0 + EQ()), 'EQ()'
yield eq, str(EQ() + 0), 'EQ()'
yield eq, str(0 + OneMean()), '1'
yield eq, str(OneMean() + 0), '1'
# Adding to zero:
yield eq, str(0 + ZeroKernel()), '0'
yield eq, str(ZeroKernel() + 0), '0'
yield eq, str(1 + ZeroKernel()), '1'
yield eq, str(ZeroKernel() + 1), '1'
yield eq, str(2 + ZeroKernel()), '2 * 1'
yield eq, str(ZeroKernel() + 2), '2 * 1'
# Sums:
yield eq, str(EQ() + EQ()), '2 * EQ()'
yield eq, str(ZeroKernel() + EQ()), 'EQ()'
yield eq, str(EQ() + ZeroKernel()), 'EQ()'
yield eq, str(ZeroKernel() + ZeroKernel()), '0'
# Products:
yield eq, str(EQ() * EQ()), 'EQ() * EQ()'
yield eq, str(ZeroKernel() * EQ()), '0'
yield eq, str(EQ() * ZeroKernel()), '0'
yield eq, str(ZeroKernel() * ZeroKernel()), '0'
# Scales:
yield eq, str(5 * ZeroKernel()), '0'
yield eq, str(ZeroKernel() * 5), '0'
yield eq, str(EQ() * 5), '5 * EQ()'
yield eq, str(5 * EQ()), '5 * EQ()'
# Stretches:
yield eq, str(ZeroKernel().stretch(5)), '0'
yield eq, str(EQ().stretch(5)), 'EQ() > 5'
# Periodicisations:
yield eq, str(ZeroKernel().periodic(5)), '0'
yield eq, str(EQ().periodic(5)), 'EQ() per 5'
# Reversals:
yield eq, str(reversed(ZeroKernel())), '0'
yield eq, str(reversed(EQ())), 'EQ()'
yield eq, str(reversed(Linear())), 'Reversed(Linear())'
# Integration:
yield eq, str(EQ() * EQ() + ZeroKernel() * EQ()), 'EQ() * EQ()'
yield eq, str(EQ() * ZeroKernel() + ZeroKernel() * EQ()), '0'
