def test_user_provided_invalid_kernel():
params, test = pop_elements(get_uniform_params(2, 6), 10, 12)
ensemble = get_1d_two_param_cube(params)
with pytest.raises(ValueError):
m = gp_model(params, ensemble, kernel=5)
def test_sample():
training_params = get_uniform_params(2)
training_ensemble = get_1d_two_param_cube(training_params)
m = gp_model(training_params, training_ensemble)
m.train()
# Test that sample returns the correct shape array for
# the given model, obs and params.
obs_uncertainty = training_ensemble.data.std(axis=0)
# Perturbing the obs by one sd should lead to an implausibility of 1.
obs = training_ensemble[10].copy() + obs_uncertainty
sampler = MCMCSampler(m,
obs,
obs_uncertainty=obs_uncertainty / obs.data,
interann_uncertainty=0.,
repres_uncertainty=0.,
struct_uncertainty=0.)
# Generate only valid samples, don't bother with burn-in
valid_samples = sampler.sample(n_samples=10,
mcmc_kwargs=dict(num_burnin_steps=0))
# Just check the shape. We test the actual probabilities above
# and we don't need to test the tf mcmc code
assert valid_samples.shape == (10, 2)
def test_construct_emulator_with_different_training_params(
training_params, expectation):
# Test the interface correctly deals with a cube training data
with expectation:
emulator = Emulator(get_mock_model(), training_params,
get_1d_two_param_cube(get_uniform_params(3)))
assert_array_equal(emulator.training_params, training_params)
def test_leave_one_out(model, model_kwargs):
from esem.utils import leave_one_out
params = get_uniform_params(2, 4)
ensemble = get_1d_two_param_cube(params)
res = leave_one_out(params, ensemble, model=model, **model_kwargs)
assert len(res) == 16
def test_user_specified_kernel():
"""
Setup for the simple 1D 2 parameter test case with user specified kernel
"""
params, test = pop_elements(get_uniform_params(2, 6), 10, 12)
ensemble = get_1d_two_param_cube(params)
m = gp_model(params, ensemble, kernel=['Bias', "Polynomial", 'Linear', "RBF"])
m.train()
def test_user_specified_invalid_op():
"""
Setup for the simple 1D 2 parameter test case with user specified kernel
"""
params, test = pop_elements(get_uniform_params(2, 6), 10, 12)
ensemble = get_1d_two_param_cube(params)
with pytest.raises(ValueError):
m = gp_model(params, ensemble, kernel=['RBF', 'White'], kernel_op='Blah')
def test_user_specified_single_kernel():
"""
Setup for the simple 1D 2 parameter test case with user specified kernel
"""
params, test = pop_elements(get_uniform_params(2, 6), 10, 12)
ensemble = get_1d_two_param_cube(params)
m = gp_model(params, ensemble, kernel=['RBF'])
m.train()
def setup_class(cls) -> None:
params, test = pop_elements(get_uniform_params(3), 50)
ensemble = get_three_param_cube(params)
m = gp_model(params, ensemble)
m.train()
cls.model = m
cls.params = params
cls.test_params = test
cls.eval_fn = eval_cube
def setup_class(cls) -> None:
params, test = pop_elements(get_uniform_params(3), 50)
ensemble = get_three_param_cube(params)
m = rf_model(training_params=params,
training_data=ensemble,
random_state=0)
m.train()
cls.model = m
cls.params = params
cls.test_params = test
cls.eval_fn = eval_cube
def setup_class(cls) -> None:
params, test = pop_elements(get_uniform_params(2, 6), 10, 12)
ensemble = get_1d_two_param_cube(params)
m = gp_model(params, ensemble, kernel=['Bias', "Polynomial", 'Linear', "RBF"])
m.train()
cls.model = m
cls.params = params
cls.test_params = test
cls.eval_fn = eval_1d_cube
def setup_class(cls) -> None:
params, test = pop_elements(get_uniform_params(3), 50)
ensemble = get_three_param_cube(params)
# Create a new, ensemble at lower precision
ensemble = ensemble.copy(data=ensemble.data.astype('float32'))
m = gp_model(params, ensemble)
m.train()
cls.model = m
cls.params = params
cls.test_params = test
cls.eval_fn = eval_cube
def setup_class(cls) -> None:
params, test = pop_elements(get_uniform_params(2, 6), 10, 12)
ensemble = get_1d_two_param_cube(params)
m = gp_model(params, ensemble)
m.train()
cls.model = m
cls.params = params
cls.test_params = test
cls.eval_fn = eval_1d_cube
def test_emulator_prediction_cube():
# Test the interface correctly deals with a cube training data
params = get_uniform_params(3)
training_ensemble = get_1d_two_param_cube(params)
m = get_mock_model()
emulator = Emulator(m, params, training_ensemble)
pred_mean, pred_var = emulator.predict(None)
assert pred_mean.name() == 'Emulated unknown'
assert pred_var.name() == 'Variance in emulated unknown'
assert pred_mean.units == training_ensemble.units
assert_array_equal(pred_mean.data, m.predict(None)[0])
def test_get_param_mask():
X = get_uniform_params(n_params=2, n_samples=5)
y = simple_polynomial_fn_two_param(*X.T)
# Test that the two valid parameters get picked out
mask = get_param_mask(X, y)
assert_array_equal(mask, np.asarray([True, True]))
# Test that if we add a nonsense parameter this gets rejected
X2 = np.hstack([X, np.ones((25, 1))])
mask = get_param_mask(X2, y)
assert_array_equal(mask, np.asarray([True, True, False]))
# Test that you can use the mask as in the documentation
assert_array_equal(X, X2[:, mask])
def test_user_provided_kernel():
"""
Setup for the simple 1D 2 parameter test case with user provided kernel
"""
import gpflow
kernel = gpflow.kernels.RBF(lengthscales=[0.5] * 2, variance=0.01) + \
gpflow.kernels.Linear(variance=[1.] * 2) + \
gpflow.kernels.Polynomial(variance=[1.] * 2) + \
gpflow.kernels.Bias()
params, test = pop_elements(get_uniform_params(2, 6), 10, 12)
ensemble = get_1d_two_param_cube(params)
m = gp_model(params, ensemble, kernel=kernel)
m.train()
def setup_class(cls) -> None:
import gpflow
kernel = gpflow.kernels.RBF(lengthscales=[0.5] * 2, variance=0.01) + \
gpflow.kernels.Linear(variance=[1.] * 2) + \
gpflow.kernels.Polynomial(variance=[1.] * 2) + \
gpflow.kernels.Bias()
params, test = pop_elements(get_uniform_params(2, 6), 10, 12)
ensemble = get_1d_two_param_cube(params)
m = gp_model(params, ensemble, kernel=kernel)
m.train()
cls.model = m
cls.params = params
cls.test_params = test
cls.eval_fn = eval_1d_cube
def test_simple_sample():
from iris.cube import Cube
X = get_uniform_params(2)
z = simple_polynomial_fn_two_param(*X.T)
m = gp_model(X, z)
m.train()
sampler = MCMCSampler(m,
Cube(np.asarray([2.])),
obs_uncertainty=0.1,
interann_uncertainty=0.,
repres_uncertainty=0.,
struct_uncertainty=0.)
# Use as few burn-in steps as we can get away with to speed up the test
samples = sampler.sample(n_samples=500,
mcmc_kwargs=dict(num_burnin_steps=50))
Zs = simple_polynomial_fn_two_param(*samples.T)
assert_allclose(Zs.mean(), 2., rtol=0.1)
from esem.emulator import Emulator
from esem.utils import get_uniform_params
from esem.wrappers import CubeWrapper
from tests.mock import get_mock_model, get_1d_two_param_cube
from numpy.testing import assert_array_equal
from contextlib import nullcontext
import pandas as pd
import pytest
@pytest.mark.parametrize(
"training_data,expectation",
[
(get_1d_two_param_cube(get_uniform_params(3)), nullcontext()),
(get_1d_two_param_cube(get_uniform_params(3)).data, nullcontext()),
(CubeWrapper(get_1d_two_param_cube(
get_uniform_params(3))), nullcontext()),
([100., 50.], pytest.raises(ValueError)),
],
)
def test_construct_emulator_with_different_training_data(
training_data, expectation):
# Test the interface correctly deals with a cube training data
with expectation:
emulator = Emulator(get_mock_model(), get_uniform_params(3),
training_data)
assert_array_equal(emulator.training_data.data, training_data.data)
@pytest.mark.parametrize(
def setup_method(self):
self.training_params = get_uniform_params(3)
self.training_ensemble = get_three_param_cube(self.training_params)
self.m = gp_model(self.training_params, self.training_ensemble)
self.m.train()