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)