Upload folder using huggingface_hub

ballast/gp.py

@@ -190,7 +190,7 @@ def base_factor(
     return L, 2.0 * jnp.sum(jnp.log(jnp.diag(L)))
 
 
-def rank_q_logdet(
+def rank_q_logdet_batch(
     L_base: jnp.ndarray,
     logdet_base: jnp.ndarray,
     S_base: jnp.ndarray,
@@ -202,27 +202,40 @@ def rank_q_logdet(
     p: HelmParams,
     sigma: float,
 ) -> jnp.ndarray:
-    """logdet(I + sigma^-2 K(Z u P)) via the App. E.2 block-determinant update.
+    """logdet(I + sigma^-2 K(Z u P_c)) for a batch of candidates c, via the
+    App. E.2 block-determinant update
 
         det [[A, B], [B^T, D]] = det(A) det(D - B^T A^{-1} B)
 
-    with A = I + sigma^-2 K(Z) already factorised (independent of the candidate),
-    B = sigma^-2 K(Z, P), D = I + sigma^-2 K(P). Cost is O(n^2 q + q^3) per
-    candidate instead of O((n+q)^3), which is what makes the 625-candidate x
-    20-sample inner loop of Algorithm 2 affordable.
+    with A = I + sigma^-2 K(Z) already factorised (Z is independent of the
+    candidate), B = sigma^-2 K(Z, P_c), D = I + sigma^-2 K(P_c). Cost is
+    O(n^2 q + q^3) per candidate instead of O((n+q)^3) -- this is what makes the
+    625-candidate x 20-sample inner loop of Algorithm 2 affordable.
+
+    Shapes: S_new (C, q, 2), t_new (q,), new_mask (C, q) -> returns (C,).
+
+    All C candidates share the single triangular factor L_base, so they are
+    solved as ONE solve against a (2n, C*2q) right-hand side. Doing this with
+    vmap instead makes JAX's triangular-solve batching rule materialise one copy
+    of L_base per candidate (C x 2n x 2n -- tens of GB, and correspondingly
+    slow); the shared-factor structure is the whole point of the rank-q trick.
 
     Masked-out new points contribute e_i rows to the Schur complement and hence
     nothing to the logdet.
     """
-    B = k_thelm_mat(S_base, t_base, S_new, t_new, p) / sigma**2  # (2n, 2q)
-    D = noise_gram(S_new, t_new, p, sigma, new_mask)  # (2q, 2q)
+    C, q = new_mask.shape
+    Sn = S_new.reshape(C * q, 2)
+    tn = jnp.tile(t_new, C)
 
-    mnew = _expand_mask(new_mask).astype(B.dtype)
+    B = k_thelm_mat(S_base, t_base, Sn, tn, p) / sigma**2  # (2n, 2Cq)
+    mnew = _expand_mask(new_mask.reshape(-1)).astype(B.dtype)  # (2Cq,)
     B = B * mnew[None, :]
     if base_mask is not None:
         B = B * _expand_mask(base_mask).astype(B.dtype)[:, None]
 
-    V = solve_triangular(L_base, B, lower=True)  # (2n, 2q)
-    Sc = D - V.T @ V
-    # keep the masked rows/cols exactly e_i (V columns there are already zero)
-    return logdet_base + logdet_chol(Sc)
+    V = solve_triangular(L_base, B, lower=True)  # (2n, 2Cq) -- one solve
+    V = V.reshape(V.shape[0], C, 2 * q)
+    VtV = jnp.einsum("ncp,ncr->cpr", V, V)  # (C, 2q, 2q)
+
+    D = jax.vmap(lambda s, m: noise_gram(s, t_new, p, sigma, m))(S_new, new_mask)
+    return logdet_base + logdet_chol(D - VtV)

ballast/policies.py

@@ -12,7 +12,7 @@ import jax.numpy as jnp
 import numpy as np
 from scipy.stats import qmc
 
-from .gp import base_factor, rank_q_logdet, posterior_ext_state, sample_ext_state
+from .gp import base_factor, rank_q_logdet_batch, posterior_ext_state, sample_ext_state
 from .kernels import HelmParams
 from .spde import SpdeOps, propagate
 from .trajectory import Grid, advect
@@ -109,16 +109,16 @@ def ballast_sample_utilities(
         m_base = jnp.concatenate([om, eval_.reshape(-1)], axis=0)
         L, ld = base_factor(S_base, t_base, p, sigma, m_base)
 
-        def one(i):
-            return rank_q_logdet(
+        # candidates are chunked only to bound the size of the (2n, C*2q)
+        # right-hand side; within a chunk it is a single shared-factor solve
+        vals = jnp.concatenate([
+            rank_q_logdet_batch(
                 L, ld, S_base, t_base, m_base,
-                cpos[:, i, :], t_traj, cval[:, i], p, sigma,
+                jnp.swapaxes(cpos[:, a:a + chunk, :], 0, 1), t_traj,
+                jnp.swapaxes(cval[:, a:a + chunk], 0, 1), p, sigma,
             )
-
-        vals = jnp.concatenate(
-            [jax.vmap(one)(jnp.arange(a, min(a + chunk, grid.n)))
-             for a in range(0, grid.n, chunk)]
-        )
+            for a in range(0, grid.n, chunk)
+        ])
         out.append(vals)
     return jnp.stack(out)
 
@@ -162,15 +162,14 @@ def true_field_utilities(
     m_base = jnp.concatenate([om, eval_.reshape(-1)], axis=0)
     L, ld = base_factor(S_base, t_base, p, sigma, m_base)
 
-    def one(i):
-        return rank_q_logdet(
-            L, ld, S_base, t_base, m_base, cpos[:, i, :], t_traj, cval[:, i], p, sigma
+    return jnp.concatenate([
+        rank_q_logdet_batch(
+            L, ld, S_base, t_base, m_base,
+            jnp.swapaxes(cpos[:, a:a + chunk, :], 0, 1), t_traj,
+            jnp.swapaxes(cval[:, a:a + chunk], 0, 1), p, sigma,
         )
-
-    return jnp.concatenate(
-        [jax.vmap(one)(jnp.arange(a, min(a + chunk, grid.n)))
-         for a in range(0, grid.n, chunk)]
-    )
+        for a in range(0, grid.n, chunk)
+    ])
 
 
 # --------------------------------------------------------------------------
@@ -185,17 +184,15 @@ def eig_utilities(
     """logdet(I + sigma^-2 K(X_n u {(s, t_n)})) for every candidate s."""
     L, ld = base_factor(S_obs, t_obs, p, sigma, mask)
     tv = jnp.array([t_m])
+    ones = jnp.ones((grid.n, 1), dtype=bool)
 
-    def one(i):
-        return rank_q_logdet(
+    return jnp.concatenate([
+        rank_q_logdet_batch(
             L, ld, S_obs, t_obs, mask,
-            grid.R[i][None, :], tv, jnp.ones(1, dtype=bool), p, sigma,
+            grid.R[a:a + chunk][:, None, :], tv, ones[a:a + chunk], p, sigma,
         )
-
-    return jnp.concatenate(
-        [jax.vmap(one)(jnp.arange(a, min(a + chunk, grid.n)))
-         for a in range(0, grid.n, chunk)]
-    )
+        for a in range(0, grid.n, chunk)
+    ])
 
 
 # --------------------------------------------------------------------------