gpflow 2.11.0__tar.gz → 2.11.2__tar.gz

{gpflow-2.11.0/gpflow.egg-info → gpflow-2.11.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gpflow
-Version: 2.11.0
+Version: 2.11.2
 Summary: Gaussian process methods in TensorFlow
 Home-page: https://www.gpflow.org
 Author: James Hensman, Alex Matthews
@@ -23,6 +23,7 @@ Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Typing :: Typed
 Requires-Python: >=3.7

{gpflow-2.11.0 → gpflow-2.11.2}/RELEASE.md

@@ -33,35 +33,40 @@ This release contains contributions from:
 <INSERT>, <NAME>, <HERE>, <USING>, <GITHUB>, <HANDLE>
 
 
-# Release 2.11.0 (next release)
+# Release 2.11.2
 
-<INSERT SMALL BLURB ABOUT RELEASE FOCUS AREA AND POTENTIAL TOOLCHAIN CHANGES>
+This release adds support for TensorFlow 2.18.
 
-## Breaking Changes
+## Known Caveats
 
-* <DOCUMENT BREAKING CHANGES HERE>
-* <THIS SECTION SHOULD CONTAIN API AND BEHAVIORAL BREAKING CHANGES>
+* GPflow no longer depends on `tensorflow-macos` on Apple Silicon Macs, as that package is no longer released after TensorFlow 2.16. The regular `tensorflow` package is used on all platforms instead. Note that it only provides Apple Silicon wheels for TensorFlow 2.13 and later.
 
-## Known Caveats
+## Bug Fixes and Other Changes
 
-* <CAVEATS REGARDING THE RELEASE (BUT NOT BREAKING CHANGES).>
-* <ADDING/BUMPING DEPENDENCIES SHOULD GO HERE>
-* <KNOWN LACK OF SUPPORT ON SOME PLATFORM SHOULD GO HERE>
+* Fix an issue with Tensorflow's Cholesky decomposition where it can fail silently.
+* Support and test against TensorFlow 2.18 (and TensorFlow Probability 0.25).
+* Test the production configuration against Python 3.11.
 
-## Major Features and Improvements
+## Thanks to our Contributors
 
-* <INSERT MAJOR FEATURE HERE, USING MARKDOWN SYNTAX>
-* <IF RELEASE CONTAINS MULTIPLE FEATURES FROM SAME AREA, GROUP THEM TOGETHER>
+This release contains contributions from:
+
+uri-granta
+
+
+# Release 2.11.1
+
+This release fixes a bug in the hierarchical kernels introduced in 2.11.0.
 
 ## Bug Fixes and Other Changes
 
-* <SIMILAR TO ABOVE SECTION, BUT FOR OTHER IMPORTANT CHANGES / BUG FIXES>
-* <IF A CHANGE CLOSES A GITHUB ISSUE, IT SHOULD BE DOCUMENTED HERE>
-* <NOTES SHOULD BE GROUPED PER AREA>
+* Fix `ArcHierarchical` and `WedgeHierarchical` parameter bounds to be per-conditional-column vectors rather than scalars, enabling correct multistart hyperparameter sampling (e.g. via `randomize_hyperparameters`).
 
 ## Thanks to our Contributors
 
-<INSERT>, <NAME>, <HERE>, <USING>, <GITHUB>, <HANDLE>
+This release contains contributions from:
+
+mawbray
 
 
 # Release 2.11.0

gpflow-2.11.2/VERSION

@@ -0,0 +1 @@
+2.11.2

{gpflow-2.11.0 → gpflow-2.11.2}/doc/sphinx/conf.py

@@ -24,7 +24,7 @@ copyright = "2023, The GPflow Contributors"
 author = "The GPflow Contributors"
 
 # The full version, including alpha/beta/rc tags
-release = "2.11.0"
+release = "2.11.2"
 
 # -- General configuration ---------------------------------------------------
 

{gpflow-2.11.0 → gpflow-2.11.2}/gpflow/kernels/hierarchical.py

@@ -51,6 +51,17 @@ def _check_non_negative_unique(values: Sequence[int], name: str) -> None:
         raise ValueError(f"`{name}` contains duplicate entries: {list(values)}.")
 
 
+def _vector_sigmoid(low: float, high: float, n: int) -> tfp.bijectors.Sigmoid:
+    """A ``Sigmoid`` bijector whose ``low``/``high`` are length-``n`` vectors, so
+    per-element bounds line up with an ``[n]``-shaped Parameter (e.g. for
+    bound-aware multistart restart sampling)."""
+    ones = tf.ones(n, dtype=default_float())
+    return tfp.bijectors.Sigmoid(
+        low=to_default_float(low) * ones,
+        high=to_default_float(high) * ones,
+    )
+
+
 def _active_dims_width(active_dims: NormalizedActiveDims) -> Optional[int]:
     """Number of columns selected by ``active_dims``, or ``None`` if it cannot
     be determined without knowing the input dimension (an open-ended slice)."""
@@ -442,7 +453,7 @@ class ArcHierarchical(HierarchicalEmbeddingKernel):
         if self._n_cond > 0:
             self.angle = Parameter(
                 0.5 * tf.ones(self._n_cond, dtype=default_float()),
-                transform=tfp.bijectors.Sigmoid(to_default_float(0.1), to_default_float(0.9)),
+                transform=_vector_sigmoid(0.1, 0.9, self._n_cond),
                 name="angle",
             )
             self.radius = Parameter(
@@ -499,7 +510,7 @@ class WedgeHierarchical(HierarchicalEmbeddingKernel):
             )
             self.rho = Parameter(
                 0.5 * np.pi * tf.ones(self._n_cond, dtype=default_float()),
-                transform=tfp.bijectors.Sigmoid(to_default_float(1e-6), to_default_float(np.pi)),
+                transform=_vector_sigmoid(1e-6, np.pi, self._n_cond),
                 name="rho",
             )
 

{gpflow-2.11.0 → gpflow-2.11.2}/gpflow/posteriors.py

@@ -420,6 +420,7 @@ class GPRPosterior(AbstractPosterior):
         Kmm = self.kernel(X_data)
         Kmm_plus_s = add_likelihood_noise_cov(Kmm, self.likelihood, X_data)
         Lm = tf.linalg.cholesky(Kmm_plus_s)
+        tf.debugging.check_numerics(Lm, "GPR posterior Cholesky factor is non-finite")
 
         D = err.shape[1]
         M = X_data.shape[0]
@@ -531,11 +532,13 @@ class SGPRPosterior(AbstractPosterior):
         sigma = tf.sqrt(sigma_sq)
 
         L = tf.linalg.cholesky(kuu)  # cache alpha, qinv
+        tf.debugging.check_numerics(L, "SGPR posterior inducing Cholesky factor is non-finite")
         A = tf.linalg.triangular_solve(L, kuf / sigma, lower=True)
         B = tf.linalg.matmul(A, A, transpose_b=True) + tf.eye(
             num_inducing, dtype=default_float()
         )  # cache qinv
         LB = tf.linalg.cholesky(B)  # cache alpha
+        tf.debugging.check_numerics(LB, "SGPR posterior Cholesky factor is non-finite")
         Aerr = tf.linalg.matmul(A, err / sigma[..., None])
         c = tf.linalg.triangular_solve(LB, Aerr, lower=True)
 
@@ -622,6 +625,7 @@ class VGPPosterior(AbstractPosterior):
             tf.shape(X_data)[-2], value=default_jitter(), dtype=X_data.dtype
         )  # [..., M, M]
         Lm = tf.linalg.cholesky(Kmm)
+        tf.debugging.check_numerics(Lm, "VGP posterior Cholesky factor is non-finite")
 
         M = X_data.shape[0]
         M_dynamic = M is None
@@ -701,6 +705,7 @@ class BasePosterior(AbstractPosterior):
         if Kuu.shape.ndims == 3:
             q_mu = tf.linalg.adjoint(self._q_dist.q_mu)[..., None]  # [..., R, M, 1]
         L = tf.linalg.cholesky(Kuu)
+        tf.debugging.check_numerics(L, "SVGP posterior Cholesky factor is non-finite")
 
         if not self.whiten:
             # alpha = Kuu⁻¹ q_mu

{gpflow-2.11.0 → gpflow-2.11.2/gpflow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gpflow
-Version: 2.11.0
+Version: 2.11.2
 Summary: Gaussian process methods in TensorFlow
 Home-page: https://www.gpflow.org
 Author: James Hensman, Alex Matthews
@@ -23,6 +23,7 @@ Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Typing :: Typed
 Requires-Python: >=3.7

{gpflow-2.11.0 → gpflow-2.11.2}/gpflow.egg-info/requires.txt

@@ -7,13 +7,8 @@ scipy
 setuptools>=41.0.0
 tabulate
 tensorflow-probability[tf]>=0.12.0
-typing_extensions
-
-[:platform_system != "Darwin" or platform_machine != "arm64"]
 tensorflow>=2.4.0
-
-[:platform_system == "Darwin" and platform_machine == "arm64"]
-tensorflow-macos>=2.4.0
+typing_extensions
 
 [:python_version < "3.8"]
 importlib_metadata

{gpflow-2.11.0 → gpflow-2.11.2}/setup.py

@@ -20,9 +20,7 @@ requirements = [
     "setuptools>=41.0.0",  # to satisfy dependency constraints
     "tabulate",
     "tensorflow-probability[tf]>=0.12.0",
-    "tensorflow>=2.4.0; platform_system!='Darwin' or platform_machine!='arm64'",
-    # NOTE: Support of Apple Silicon MacOS platforms is in an experimental mode
-    "tensorflow-macos>=2.4.0; platform_system=='Darwin' and platform_machine=='arm64'",
+    "tensorflow>=2.4.0",
     # NOTE: once we require tensorflow-probability>=0.12, we can remove our custom deepcopy handling
     "typing_extensions",
 ]
@@ -79,6 +77,7 @@ setup(
         "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
         "Topic :: Scientific/Engineering :: Artificial Intelligence",
         "Typing :: Typed",
     ],

{gpflow-2.11.0 → gpflow-2.11.2}/tests/gpflow/kernels/test_broadcasting.py

@@ -164,12 +164,14 @@ def test_broadcasting(
     rank2 = len(batch2_shape) - 1
 
     if isinstance(kernel, kernels.MultioutputKernel):
-        mo_kernel = cast(kernels.MultioutputKernel, kernel)  # type: ignore[redundant-cast]
+        mo_kernel: kernels.MultioutputKernel = kernel
 
         loop = cs(
             unroll_batches(
                 lambda x: unroll_batches(
-                    lambda x2: mo_kernel(x, x2, full_cov=True, full_output_cov=True), X2, 2
+                    lambda x2: mo_kernel(x, x2, full_cov=True, full_output_cov=True),
+                    X2,
+                    2,
                 ),
                 X,
                 2,
@@ -200,7 +202,9 @@ def test_broadcasting(
         loop = cs(
             unroll_batches(
                 lambda x: unroll_batches(
-                    lambda x2: mo_kernel(x, x2, full_cov=True, full_output_cov=False), X2, 2
+                    lambda x2: mo_kernel(x, x2, full_cov=True, full_output_cov=False),
+                    X2,
+                    2,
                 ),
                 X,
                 2,
@@ -274,7 +278,9 @@ def test_broadcasting(
     else:  # Single-output kernel:
         loop = cs(
             unroll_batches(
-                lambda x: unroll_batches(lambda x2: kernel(x, x2, full_cov=True), X2, 2), X, 2
+                lambda x: unroll_batches(lambda x2: kernel(x, x2, full_cov=True), X2, 2),
+                X,
+                2,
             ),
             "[batch..., batch2..., N, N2]",
         )
@@ -282,7 +288,12 @@ def test_broadcasting(
             tf.transpose(
                 loop,
                 tf.concat(
-                    [np.arange(rank), [rank + rank2], np.arange(rank2) + rank, [rank + rank2 + 1]],
+                    [
+                        np.arange(rank),
+                        [rank + rank2],
+                        np.arange(rank2) + rank,
+                        [rank + rank2 + 1],
+                    ],
                     0,
                 ),
             ),

{gpflow-2.11.0 → gpflow-2.11.2}/tests/gpflow/kernels/test_hierarchical.py

@@ -941,6 +941,44 @@ class TestArcHierarchical:
         kernel = _arc()
         np.testing.assert_allclose(kernel.radius.numpy(), [1.0, 1.0])
 
+    def test_angle_sigmoid_bounds_are_per_conditional_vectors(self) -> None:
+        # Bounds must be [n_cond] vectors so a multistart scheme that samples
+        # `tf.random.uniform(bijector.low.shape, ...)` gets a per-column restart.
+        kernel = _arc()
+        transform = kernel.angle.transform
+        assert transform is not None
+        low = transform.low
+        high = transform.high
+        assert tuple(low.shape) == (2,)
+        assert tuple(high.shape) == (2,)
+        np.testing.assert_allclose(low.numpy(), [0.1, 0.1])
+        np.testing.assert_allclose(high.numpy(), [0.9, 0.9])
+
+    def test_angle_multistart_restart_roundtrip(self) -> None:
+        kernel = _arc()
+        param = kernel.angle
+        transform = param.transform
+        assert transform is not None
+        low, high = transform.low, transform.high
+        sample = tf.random.uniform(low.shape, minval=low, maxval=high, dtype=low.dtype)
+        assert tuple(sample.shape) == (2,)
+        param.assign(sample)
+        assert tuple(param.shape) == (2,)
+        assert np.all(param.numpy() >= low.numpy())
+        assert np.all(param.numpy() <= high.numpy())
+        X = tf.constant(
+            [
+                [0.5, 1.0, 2.5, 0.0],
+                [0.5, 0.0, 2.5, 0.5],
+                [0.3, 1.0, 4.0, 0.0],
+            ],
+            dtype=tf.float64,
+        )
+        K = kernel.K(X).numpy()
+        assert np.all(np.isfinite(K))
+        eigs = np.linalg.eigvalsh(K + 1e-10 * np.eye(3))
+        assert eigs.min() > -1e-8
+
     def test_K_shape_and_psd(self) -> None:
         kernel = _arc()
         X = tf.constant(
@@ -1004,6 +1042,44 @@ class TestWedgeHierarchical:
         kernel = _wedge()
         np.testing.assert_allclose(kernel.rho.numpy(), [np.pi / 2, np.pi / 2])
 
+    def test_rho_sigmoid_bounds_are_per_conditional_vectors(self) -> None:
+        # Bounds must be [n_cond] vectors so a multistart scheme that samples
+        # `tf.random.uniform(bijector.low.shape, ...)` gets a per-column restart.
+        kernel = _wedge()
+        transform = kernel.rho.transform
+        assert transform is not None
+        low = transform.low
+        high = transform.high
+        assert tuple(low.shape) == (2,)
+        assert tuple(high.shape) == (2,)
+        np.testing.assert_allclose(low.numpy(), [1e-6, 1e-6])
+        np.testing.assert_allclose(high.numpy(), [np.pi, np.pi])
+
+    def test_rho_multistart_restart_roundtrip(self) -> None:
+        kernel = _wedge()
+        param = kernel.rho
+        transform = param.transform
+        assert transform is not None
+        low, high = transform.low, transform.high
+        sample = tf.random.uniform(low.shape, minval=low, maxval=high, dtype=low.dtype)
+        assert tuple(sample.shape) == (2,)
+        param.assign(sample)
+        assert tuple(param.shape) == (2,)
+        assert np.all(param.numpy() >= low.numpy())
+        assert np.all(param.numpy() <= high.numpy())
+        X = tf.constant(
+            [
+                [0.5, 1.0, 2.5, 0.0],
+                [0.5, 0.0, 2.5, 0.5],
+                [0.3, 1.0, 4.0, 0.0],
+            ],
+            dtype=tf.float64,
+        )
+        K = kernel.K(X).numpy()
+        assert np.all(np.isfinite(K))
+        eigs = np.linalg.eigvalsh(K + 1e-10 * np.eye(3))
+        assert eigs.min() > -1e-8
+
     def test_K_shape_and_psd(self) -> None:
         kernel = _wedge()
         X = tf.constant(

{gpflow-2.11.0 → gpflow-2.11.2}/tests/gpflow/models/test_gpr.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import numpy as np
+import pytest
 import tensorflow as tf
 
 import gpflow
@@ -73,3 +74,40 @@ def test_varying_data() -> None:
     assert (
         np.abs((old_lml - new_lml) / (new_lml + old_lml)) > 0.1
     ), "we expect the LML for different data to be significantly different"
+
+
+def test_non_finite_posterior_cholesky_raises() -> None:
+    """A collapsed ARD lengthscale on a binary column makes K non-positive-definite.
+
+    Cholesky then returns a NaN factor. Prediction and posterior construction
+    must raise rather than cache that factor and return NaN means.
+    """
+    data_rng = np.random.RandomState(0)
+    n = 10
+    binary = np.array([0.0, 1.0] * (n // 2))[:, None]
+    X = np.hstack([data_rng.randn(n, 2), binary])
+    Y = data_rng.randn(n, 1)
+    collapsed = gpflow.models.GPR(
+        (X, Y),
+        kernel=gpflow.kernels.SquaredExponential(lengthscales=[1.0, 1.0, 1e-8]),
+        noise_variance=1e-5,
+    )
+
+    with pytest.raises(
+        tf.errors.InvalidArgumentError,
+        match=r"Cholesky factor is non-finite|Cholesky decomposition was not successful",
+    ):
+        collapsed.predict_f(X[:2])
+    with pytest.raises(
+        tf.errors.InvalidArgumentError,
+        match=r"Cholesky factor is non-finite|Cholesky decomposition was not successful",
+    ):
+        collapsed.posterior()
+
+    healthy = gpflow.models.GPR(
+        (X, Y),
+        kernel=gpflow.kernels.SquaredExponential(lengthscales=[1.0, 1.0, 1.0]),
+        noise_variance=1e-5,
+    )
+    mean, _ = healthy.predict_f(X[:2])
+    assert np.all(np.isfinite(mean))

{gpflow-2.11.0 → gpflow-2.11.2}/tests/gpflow/models/test_sgpr.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import numpy as np
+import pytest
 import tensorflow as tf
 
 import gpflow
@@ -77,3 +78,38 @@ def test_sgpr_svgp_qu_equivivalent() -> None:
         svgp.predict_f(Xnew),
         atol=1e-4,
     )
+
+
+def test_non_finite_posterior_cholesky_raises() -> None:
+    """A collapsed ARD lengthscale on a binary column makes Kuu non-positive-definite."""
+    data_rng = np.random.RandomState(0)
+    n = 10
+    binary = np.array([0.0, 1.0] * (n // 2))[:, None]
+    X = np.hstack([data_rng.randn(n, 2), binary])
+    Y = data_rng.randn(n, 1)
+    collapsed = gpflow.models.SGPR(
+        (X, Y),
+        kernel=gpflow.kernels.SquaredExponential(lengthscales=[1.0, 1.0, 1e-8]),
+        inducing_variable=X,
+        noise_variance=1e-5,
+    )
+
+    with pytest.raises(
+        tf.errors.InvalidArgumentError,
+        match=r"Cholesky factor is non-finite|Cholesky decomposition was not successful",
+    ):
+        collapsed.predict_f(X[:2])
+    with pytest.raises(
+        tf.errors.InvalidArgumentError,
+        match=r"Cholesky factor is non-finite|Cholesky decomposition was not successful",
+    ):
+        collapsed.posterior()
+
+    healthy = gpflow.models.SGPR(
+        (X, Y),
+        kernel=gpflow.kernels.SquaredExponential(lengthscales=[1.0, 1.0, 1.0]),
+        inducing_variable=X,
+        noise_variance=1e-5,
+    )
+    mean, _ = healthy.predict_f(X[:2])
+    assert np.all(np.isfinite(mean))

{gpflow-2.11.0 → gpflow-2.11.2}/tests/gpflow/models/test_svgp.py

@@ -197,3 +197,34 @@ def test_stochastic_gradients(
     model_1 = training_loop(indices_1, num_data=num_data1, max_iter=max_iter)
     model_2 = training_loop(indices_2, num_data=num_data2, max_iter=max_iter)
     assert _check_models_close(model_1, model_2)
+
+
+def test_non_finite_posterior_cholesky_raises() -> None:
+    """A collapsed ARD lengthscale on a binary column makes Kuu non-positive-definite.
+
+    The cached posterior factorises Kuu in BasePosterior._precompute.
+    """
+    data_rng = np.random.RandomState(0)
+    n = 10
+    binary = np.array([0.0, 1.0] * (n // 2))[:, None]
+    X = np.hstack([data_rng.randn(n, 2), binary])
+    Y = data_rng.randn(n, 1)
+    collapsed = gpflow.models.SVGP(
+        kernel=gpflow.kernels.SquaredExponential(lengthscales=[1.0, 1.0, 1e-8]),
+        likelihood=gpflow.likelihoods.Gaussian(),
+        inducing_variable=X,
+    )
+
+    with pytest.raises(
+        tf.errors.InvalidArgumentError,
+        match=r"Cholesky factor is non-finite|Cholesky decomposition was not successful",
+    ):
+        collapsed.posterior()
+
+    healthy = gpflow.models.SVGP(
+        kernel=gpflow.kernels.SquaredExponential(lengthscales=[1.0, 1.0, 1.0]),
+        likelihood=gpflow.likelihoods.Gaussian(),
+        inducing_variable=X,
+    )
+    mean, _ = healthy.predict_f(X[:2])
+    assert np.all(np.isfinite(mean))

{gpflow-2.11.0 → gpflow-2.11.2}/tests/gpflow/models/test_vgp.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import numpy as np
+import pytest
 import tensorflow as tf
 
 import gpflow
@@ -59,3 +60,36 @@ def test_update_vgp_data() -> None:
 
     np.testing.assert_allclose(mean_before, mean_after, atol=1e-5)
     np.testing.assert_allclose(var_before, var_after, atol=1e-6)
+
+
+def test_non_finite_posterior_cholesky_raises() -> None:
+    """A collapsed ARD lengthscale on a binary column makes K non-positive-definite."""
+    data_rng = np.random.RandomState(0)
+    n = 10
+    binary = np.array([0.0, 1.0] * (n // 2))[:, None]
+    X = np.hstack([data_rng.randn(n, 2), binary])
+    Y = data_rng.randn(n, 1)
+    collapsed = gpflow.models.VGP(
+        (X, Y),
+        kernel=gpflow.kernels.SquaredExponential(lengthscales=[1.0, 1.0, 1e-8]),
+        likelihood=gpflow.likelihoods.Gaussian(),
+    )
+
+    with pytest.raises(
+        tf.errors.InvalidArgumentError,
+        match=r"Cholesky factor is non-finite|Cholesky decomposition was not successful",
+    ):
+        collapsed.predict_f(X[:2])
+    with pytest.raises(
+        tf.errors.InvalidArgumentError,
+        match=r"Cholesky factor is non-finite|Cholesky decomposition was not successful",
+    ):
+        collapsed.posterior()
+
+    healthy = gpflow.models.VGP(
+        (X, Y),
+        kernel=gpflow.kernels.SquaredExponential(lengthscales=[1.0, 1.0, 1.0]),
+        likelihood=gpflow.likelihoods.Gaussian(),
+    )
+    mean, _ = healthy.predict_f(X[:2])
+    assert np.all(np.isfinite(mean))

gpflow-2.11.0/VERSION

@@ -1 +0,0 @@
-2.11.0