def test_vgp_update_updates_num_data() -> None:
x_np = np.arange(5, dtype=np.float64).reshape(-1, 1)
x = tf.convert_to_tensor(x_np, x_np.dtype)
y = fnc_3x_plus_10(x)
m = VariationalGaussianProcess(vgp_model(x, y))
num_data = m.model.num_data
x_new = tf.concat([x, [[10.0], [11.0]]], 0)
y_new = fnc_3x_plus_10(x_new)
m.update(Dataset(x_new, y_new))
new_num_data = m.model.num_data
assert new_num_data - num_data == 2
def test_find_best_model_initialization_improves_likelihood(
gpflow_interface_factory: ModelFactoryType, dim: int
) -> None:
x = tf.constant(
np.arange(1, 1 + 10 * dim).reshape(-1, dim), dtype=gpflow.default_float()
) # shape: [10, dim]
model, _ = gpflow_interface_factory(x, fnc_3x_plus_10(x)[:, 0:1])
model.model.kernel = gpflow.kernels.RBF(variance=1.0, lengthscales=[0.2] * dim)
if isinstance(model, (VariationalGaussianProcess, SparseVariational)):
pytest.skip("find_best_model_initialization is only implemented for the GPR models.")
model.model.kernel.variance.prior = tfp.distributions.LogNormal(
loc=np.float64(-2.0), scale=np.float64(1.0)
)
upper = tf.cast([10.0] * dim, dtype=tf.float64)
lower = upper / 100
model.model.kernel.lengthscales = gpflow.Parameter(
model.model.kernel.lengthscales, transform=tfp.bijectors.Sigmoid(low=lower, high=upper)
)
pre_init_loss = model.model.training_loss()
model.find_best_model_initialization(100)
post_init_loss = model.model.training_loss()
npt.assert_array_less(post_init_loss, pre_init_loss)
def test_find_best_model_initialization_changes_params_with_sigmoid_bijectors(
gpflow_interface_factory: ModelFactoryType, dim: int
) -> None:
x = tf.constant(
np.arange(1, 1 + 10 * dim).reshape(-1, dim), dtype=gpflow.default_float()
) # shape: [10, dim]
model, _ = gpflow_interface_factory(x, fnc_3x_plus_10(x)[:, 0:1])
model.model.kernel = gpflow.kernels.RBF(lengthscales=[0.2] * dim)
if isinstance(model, (VariationalGaussianProcess, SparseVariational)):
pytest.skip("find_best_model_initialization is only implemented for the GPR models.")
upper = tf.cast([10.0] * dim, dtype=tf.float64)
lower = upper / 100
model.model.kernel.lengthscales = gpflow.Parameter(
model.model.kernel.lengthscales, transform=tfp.bijectors.Sigmoid(low=lower, high=upper)
)
model.find_best_model_initialization(2)
npt.assert_allclose(1.0, model.model.kernel.variance)
npt.assert_array_equal(dim, model.model.kernel.lengthscales.shape)
npt.assert_raises(
AssertionError, npt.assert_allclose, [0.2, 0.2], model.model.kernel.lengthscales
)
def test_gpr_raises_for_invalid_num_kernel_samples() -> None:
x_np = np.arange(5, dtype=np.float64).reshape(-1, 1)
x = tf.convert_to_tensor(x_np, x_np.dtype)
y = fnc_3x_plus_10(x)
with pytest.raises(ValueError):
GaussianProcessRegression(gpr_model(x, y), num_kernel_samples=-1)
def test_model_stack_missing_predict_y() -> None:
x = tf.constant(np.arange(5).reshape(-1, 1), dtype=gpflow.default_float())
model1 = gpr_model(x, fnc_3x_plus_10(x))
model2 = _QuadraticModel([1.0], [2.0])
stack = ModelStack((model1, 1), (model2, 1))
x_predict = tf.constant([[0]], gpflow.default_float())
with pytest.raises(NotImplementedError):
stack.predict_y(x_predict)
def test_model_stack_predict_y() -> None:
x = tf.constant(np.arange(5).reshape(-1, 1), dtype=gpflow.default_float())
model1 = gpr_model(x, fnc_3x_plus_10(x))
model2 = sgpr_model(x, fnc_2sin_x_over_3(x))
stack = ModelStack((model1, 1), (model2, 1))
mean, variance = stack.predict_y(x)
npt.assert_allclose(mean[:, 0:1], model1.predict_y(x)[0])
npt.assert_allclose(mean[:, 1:2], model2.predict_y(x)[0])
npt.assert_allclose(variance[:, 0:1], model1.predict_y(x)[1])
npt.assert_allclose(variance[:, 1:2], model2.predict_y(x)[1])
def test_gpflux_model_config_raises_not_supported_model_type() -> None:
x = tf.constant(np.arange(5).reshape(-1, 1), dtype=gpflow.default_float())
y = fnc_3x_plus_10(x)
model_specs = {
"model":
GPMC((x, y), gpflow.kernels.Matern32(), gpflow.likelihoods.Gaussian())
}
with pytest.raises(NotImplementedError):
GPfluxModelConfig(**model_specs)
def test_vgp_update() -> None:
x = tf.constant(np.arange(5).reshape(-1, 1), dtype=gpflow.default_float())
data = Dataset(x, fnc_3x_plus_10(x))
m = VariationalGaussianProcess(vgp_model(data.query_points, data.observations))
reference_model = vgp_model(data.query_points, data.observations)
npt.assert_allclose(m.model.q_mu, reference_model.q_mu, atol=1e-5)
npt.assert_allclose(m.model.q_sqrt, reference_model.q_sqrt, atol=1e-5)
x_new = tf.concat([x, tf.constant([[10.0], [11.0]], dtype=gpflow.default_float())], 0)
new_data = Dataset(x_new, fnc_3x_plus_10(x_new))
m.update(new_data)
reference_model_new = vgp_model(new_data.query_points, new_data.observations)
npt.assert_allclose(m.model.q_mu, reference_model_new.q_mu, atol=1e-5)
npt.assert_allclose(m.model.q_sqrt, reference_model_new.q_sqrt, atol=1e-5)
def test_vgp_raises_for_invalid_init() -> None:
x_np = np.arange(5, dtype=np.float64).reshape(-1, 1)
x = tf.convert_to_tensor(x_np, x_np.dtype)
y = fnc_3x_plus_10(x)
with pytest.raises(ValueError):
VariationalGaussianProcess(vgp_model(x, y), natgrad_gamma=1)
with pytest.raises(ValueError):
optimizer = Optimizer(gpflow.optimizers.Scipy())
VariationalGaussianProcess(vgp_model(x, y), optimizer=optimizer, use_natgrads=True)
def test_dgp_loss(two_layer_model: Callable[[TensorType], DeepGP]) -> None:
x = tf.constant(np.arange(5).reshape(-1, 1), dtype=gpflow.default_float())
y = fnc_3x_plus_10(x)
reference_model = two_layer_model(x)
model = DeepGaussianProcess(two_layer_model(x))
internal_model = model.model_gpflux
npt.assert_allclose(internal_model.elbo((x, y)),
reference_model.elbo((x, y)),
rtol=1e-6)
def test_gaussian_process_regression_update(gpflow_interface_factory: ModelFactoryType) -> None:
x = tf.constant(np.arange(5).reshape(-1, 1), dtype=gpflow.default_float())
y = fnc_3x_plus_10(x)
model, _reference_model = gpflow_interface_factory(x, y)
x_new = tf.concat([x, tf.constant([[10.0], [11.0]], dtype=gpflow.default_float())], 0)
new_data = Dataset(x_new, fnc_3x_plus_10(x_new))
model.update(new_data)
reference_model = _reference_model(x_new, fnc_3x_plus_10(x_new))
internal_model = model.model
if isinstance(internal_model, SVGP):
args = {"data": (new_data.query_points, new_data.observations)}
else:
args = {}
npt.assert_allclose(
internal_model.training_loss(**args), reference_model.training_loss(**args), rtol=1e-6
)
def test_gaussian_process_regression_correctly_counts_params_that_can_be_sampled(
mocked_model_initializer: Any,
dim: int,
prior_for_lengthscale: bool,
gpr_interface_factory: ModelFactoryType,
) -> None:
x = tf.constant(np.arange(1, 5 * dim + 1).reshape(-1, dim),
dtype=tf.float64) # shape: [5, d]
model, _ = gpr_interface_factory(x, fnc_3x_plus_10(x))
model.model.kernel = gpflow.kernels.RBF(
lengthscales=tf.ones([dim], dtype=tf.float64))
model.model.likelihood.variance.assign(1.0)
gpflow.set_trainable(model.model.likelihood, True)
if prior_for_lengthscale:
model.model.kernel.lengthscales.prior = tfp.distributions.LogNormal(
loc=tf.math.log(model.model.kernel.lengthscales), scale=1.0)
else:
upper = tf.cast([10.0] * dim, dtype=tf.float64)
lower = upper / 100
model.model.kernel.lengthscales = gpflow.Parameter(
model.model.kernel.lengthscales,
transform=tfp.bijectors.Sigmoid(low=lower, high=upper))
model.model.likelihood.variance.prior = tfp.distributions.LogNormal(
loc=tf.cast(-2.0, dtype=tf.float64),
scale=tf.cast(5.0, dtype=tf.float64))
if isinstance(model, (VariationalGaussianProcess, SparseVariational)):
pytest.skip(
"find_best_model_initialization is only implemented for the GPR models."
)
dataset = Dataset(x, tf.cast(fnc_3x_plus_10(x), dtype=tf.float64))
model.optimize(dataset)
mocked_model_initializer.assert_called_once()
num_samples = mocked_model_initializer.call_args[0][0]
npt.assert_array_equal(num_samples, 10 * (dim + 1))
def test_gaussian_process_regression_loss(gpflow_interface_factory: ModelFactoryType) -> None:
x = tf.constant(np.arange(5).reshape(-1, 1), dtype=gpflow.default_float())
y = fnc_3x_plus_10(x)
model, _reference_model = gpflow_interface_factory(x, y)
internal_model = model.model
reference_model = _reference_model(x, y)
if isinstance(internal_model, SVGP):
args = {"data": (x, y)}
else:
args = {}
npt.assert_allclose(
internal_model.training_loss(**args), reference_model.training_loss(**args), rtol=1e-6
)
def test_gaussian_process_regression_pairwise_covariance(
gpflow_interface_factory: ModelFactoryType,
) -> None:
x = tf.constant(np.arange(1, 5).reshape(-1, 1), dtype=gpflow.default_float()) # shape: [4, 1]
y = fnc_3x_plus_10(x)
model, _ = gpflow_interface_factory(x, y)
if isinstance(model.model, (SGPR, VGP, SVGP)):
pytest.skip("covariance_between_points is only implemented for the GPR model.")
query_points_1 = tf.concat([0.5 * x, 0.5 * x], 0) # shape: [8, 1]
query_points_2 = tf.concat([2 * x, 2 * x, 2 * x], 0) # shape: [12, 1]
all_query_points = tf.concat([query_points_1, query_points_2], 0)
_, predictive_covariance = model.predict_joint(all_query_points)
expected_covariance = predictive_covariance[0, :8, 8:]
actual_covariance = model.covariance_between_points(query_points_1, query_points_2)
np.testing.assert_allclose(expected_covariance, actual_covariance, atol=1e-5)
def test_find_best_model_initialization_changes_params_with_priors(
gpr_interface_factory: ModelFactoryType, dim: int) -> None:
x = tf.constant(np.arange(1, 1 + 10 * dim).reshape(-1, dim),
dtype=gpflow.default_float()) # shape: [10, dim]
model, _ = gpr_interface_factory(x, fnc_3x_plus_10(x)[:, 0:1])
model.model.kernel = gpflow.kernels.RBF(lengthscales=[0.2] * dim)
if isinstance(model, (VariationalGaussianProcess, SparseVariational)):
pytest.skip(
"find_best_model_initialization is only implemented for the GPR models."
)
model.model.kernel.lengthscales.prior = tfp.distributions.LogNormal(
loc=tf.math.log(model.model.kernel.lengthscales), scale=1.0)
model.find_best_model_initialization(2)
npt.assert_allclose(1.0, model.model.kernel.variance)
npt.assert_array_equal(dim, model.model.kernel.lengthscales.shape)
npt.assert_raises(AssertionError, npt.assert_allclose, [0.2, 0.2],
model.model.kernel.lengthscales)
def test_dgp_resets_lr_with_lr_schedule(two_layer_model: Callable[[TensorType],
DeepGP],
keras_float: None) -> None:
x = tf.constant(np.arange(5).reshape(-1, 1), dtype=gpflow.default_float())
y = fnc_3x_plus_10(x)
epochs = 10
init_lr = 0.01
def scheduler(epoch: int, lr: float) -> float:
if epoch == epoch // 2:
return lr * 0.1
else:
return lr
fit_args = {
"epochs": epochs,
"batch_size": 100,
"verbose": 0,
"callbacks": tf.keras.callbacks.LearningRateScheduler(scheduler),
}
optimizer = tf.optimizers.Adam(init_lr)
model = DeepGaussianProcess(two_layer_model(x),
optimizer=optimizer,
fit_args=fit_args)
npt.assert_allclose(model.model_keras.optimizer.lr.numpy(),
init_lr,
rtol=1e-6)
dataset = Dataset(x, y)
model.optimize(dataset)
npt.assert_allclose(model.model_keras.optimizer.lr.numpy(),
init_lr,
rtol=1e-6)
def test_create_loss_function_raises_on_none() -> None:
x = tf.constant(np.arange(5).reshape(-1, 1), dtype=gpflow.default_float())
data = Dataset(x, fnc_3x_plus_10(x))
with pytest.raises(NotImplementedError):
create_loss_function(None, data)
def test_model_missing_abstract_method() -> None:
x = tf.constant(np.arange(5).reshape(-1, 1), dtype=gpflow.default_float())
model_specs = {"model": gpr_model(x, fnc_3x_plus_10(x))}
with pytest.raises(NotImplementedError):
ModelConfig(**model_specs)
