Upload folder using huggingface_hub

ballast/experiment.py

@@ -64,6 +64,38 @@ class Config:
             jnp.linspace(self.y_lo, self.y_hi, self.grid_ny),
         )
 
+    def n_past_max(self, m: int) -> int:
+        """Upper bound on observations available at decision time t_m.
+
+        Drifter i (released at i*deploy_every) has measured
+        (t_m - t_i)/obs_dt times by t_m if it never left the region. Summing
+        gives a bound that depends only on m -- so padding to it keeps every
+        array shape a function of the deployment index alone, and XLA compiles
+        each shape once for the whole job instead of once per campaign.
+        """
+        k = int(round(self.deploy_every / self.obs_dt))
+        return k * m * (m + 1) // 2
+
+    def n_all_max(self, m: int) -> int:
+        """Upper bound on observations from drifters 0..m over the whole campaign."""
+        k = int(round(self.deploy_every / self.obs_dt))
+        return sum(self.n_obs_total - i * k for i in range(m + 1))
+
+
+def _pad(S, t, y, n):
+    """Pad observation arrays to exactly n points; return (S, t, y, mask).
+
+    Padding points are parked far outside the region so their kernel entries are
+    numerically zero anyway; the mask is what actually neutralises them.
+    """
+    k = S.shape[0]
+    assert k <= n, f"more observations ({k}) than the bound ({n})"
+    Sp = np.concatenate([S, np.full((n - k, 2), 1e6)])
+    tp = np.concatenate([t, np.zeros(n - k)])
+    yp = np.concatenate([y, np.zeros((n - k, 2))])
+    mask = np.concatenate([np.ones(k, bool), np.zeros(n - k, bool)])
+    return (jnp.asarray(Sp), jnp.asarray(tp), jnp.asarray(yp), jnp.asarray(mask))
+
 
 SYNTH_PARAMS = HelmParams(
     phi_ls=0.8, phi_var=0.5, psi_ls=0.5, psi_var=0.5, time_ls=2.5, time_var=1.0
@@ -160,11 +192,15 @@ def run_campaign(
         k_m = int(round(t_m / cfg.dt))
         key, kp, ks, ko = jax.random.split(key, 4)
 
-        # ---- data available at decision time (strictly before/at t_m)
+        # ---- data available at decision time (strictly before/at t_m),
+        #      padded to a bound that depends only on m (see Config.n_past_max)
         past = val_all & (np.asarray(tg)[None, :] <= t_m + 1e-9)
-        S_obs = jnp.asarray(pos_all[past])
-        t_obs = jnp.asarray(np.broadcast_to(np.asarray(tg)[None, :], past.shape)[past])
-        y_obs = jnp.asarray(y_all[past])
+        S_obs, t_obs, y_obs, m_obs = _pad(
+            pos_all[past],
+            np.broadcast_to(np.asarray(tg)[None, :], past.shape)[past],
+            y_all[past],
+            cfg.n_past_max(m),
+        )
 
         # ---- choose the placement
         if m == 0:
@@ -174,41 +210,42 @@ def run_campaign(
         elif policy == "sobol":
             idx = int(sobol_indices(grid, cfg.n_deploy, seed_offset)[m])
         else:
-            exist_idx = np.arange(m)
             j_at = int(round(t_m / cfg.obs_dt)) - 1  # obs index whose time is t_m
-            # project from the drifters' true positions, not their reported cells
-            exist_pos = jnp.asarray(raw_all[exist_idx, j_at])
-            exist_live = jnp.asarray(val_all[exist_idx, j_at])
-            # drifters that already left contribute nothing: park them outside
-            exist_pos = jnp.where(
-                exist_live[:, None], exist_pos, jnp.array([1e6, 1e6])
-            )
+            # Pad the existing-drifter set to n_deploy so this shape is also
+            # constant; drifters that already left are parked far outside, where
+            # advection freezes them and the Gram mask drops their trajectory.
+            exist_pos = np.full((cfg.n_deploy, 2), 1e6)
+            live = val_all[np.arange(m), j_at]
+            exist_pos[np.arange(m)[live]] = raw_all[np.arange(m), j_at][live]
+            exist_pos = jnp.asarray(exist_pos)
 
             p_pol, sig_pol = true_params, cfg.sigma_obs
             if policy == "ballast_opt":
                 p_pol, sig_pol = optimise_hypers(
-                    S_obs, t_obs, y_obs, cfg, bounds, true_params
+                    S_obs, t_obs, y_obs, cfg, bounds, true_params, mask=m_obs
                 )
 
             if policy == "eig":
-                sc = eig_utilities(grid, S_obs, t_obs, t_m, p_pol, sig_pol, cfg.chunk)
+                sc = eig_utilities(
+                    grid, S_obs, t_obs, t_m, p_pol, sig_pol, cfg.chunk, mask=m_obs
+                )
             else:
                 ops_pol = ops_true if policy != "ballast_opt" else make_ops(
                     grid.R, p_pol, cfg.dt
                 )
                 mean, chol = posterior_ext_state(
-                    S_obs, t_obs, y_obs, grid.R, t_m, p_pol, sig_pol
+                    S_obs, t_obs, y_obs, grid.R, t_m, p_pol, sig_pol, mask=m_obs
                 )
                 if policy == "dist_sep":
                     sc = dist_sep_scores(
                         ks, grid, ops_pol, mean, chol, exist_pos, S_obs, t_m,
-                        cfg.T, cfg.dt, cfg.obs_every, cfg.n_samples,
+                        cfg.T, cfg.dt, cfg.obs_every, cfg.n_samples, obs_mask=m_obs,
                     )
                 else:  # ballast_true / ballast_opt
                     u = ballast_sample_utilities(
                         ks, grid, ops_pol, S_obs, t_obs, mean, chol, exist_pos,
                         t_m, cfg.T, cfg.dt, cfg.obs_every, p_pol, sig_pol,
-                        cfg.n_samples, cfg.chunk,
+                        cfg.n_samples, cfg.chunk, obs_mask=m_obs,
                     )
                     sc = jnp.mean(u, axis=0)
             idx = int(jnp.argmax(sc))
@@ -232,11 +269,14 @@ def run_campaign(
 
         # ---- evaluate: all data from the m+1 drifters over the whole campaign
         sel = val_all[: m + 1]
-        S_e = jnp.asarray(pos_all[: m + 1][sel])
-        t_e = jnp.asarray(np.broadcast_to(np.asarray(tg)[None, :], sel.shape)[sel])
-        y_e = jnp.asarray(y_all[: m + 1][sel])
+        S_e, t_e, y_e, m_e = _pad(
+            pos_all[: m + 1][sel],
+            np.broadcast_to(np.asarray(tg)[None, :], sel.shape)[sel],
+            y_all[: m + 1][sel],
+            cfg.n_all_max(m),
+        )
         mu = posterior_mean_field(
-            S_e, t_e, y_e, grid.R, t_eval, eval_params, cfg.sigma_obs
+            S_e, t_e, y_e, grid.R, t_eval, eval_params, cfg.sigma_obs, mask=m_e
         )
         gt_at_eval = gt_fields[(jnp.round(t_eval / cfg.dt)).astype(int)]
         err = float(jnp.mean(jnp.linalg.norm(mu - gt_at_eval, axis=-1)))

ballast/gp.py

@@ -54,25 +54,47 @@ def logdet_chol(M: jnp.ndarray) -> jnp.ndarray:
     return 2.0 * jnp.sum(jnp.log(jnp.diagonal(L, axis1=-2, axis2=-1)), axis=-1)
 
 
+def reg_matrix(S, t, p: HelmParams, sigma, mask=None):
+    """A = K(X) + sigma^2 I for regression, with padded points neutralised.
+
+    Observation arrays are padded to shapes that depend only on the deployment
+    index (never on how many drifters happen to still be inside the region), so
+    that XLA compiles each shape once and reuses it across all runs. A padded
+    row i is turned into e_i and paired with y_i = 0, which leaves
+    alpha = A^{-1} y zero there and every downstream quantity untouched.
+    """
+    K = k_thelm_mat(S, t, S, t, p)
+    n = K.shape[0]
+    A = K + (sigma**2) * jnp.eye(n)
+    if mask is not None:
+        m = _expand_mask(mask).astype(A.dtype)
+        A = A * m[:, None] * m[None, :] + jnp.diag(1.0 - m)
+    return A
+
+
 # --------------------------------------------------------------------------
 # Regression
 # --------------------------------------------------------------------------
 
 
 def log_marginal_likelihood(
-    p: HelmParams, S: jnp.ndarray, t: jnp.ndarray, y: jnp.ndarray, sigma: float
+    p: HelmParams, S: jnp.ndarray, t: jnp.ndarray, y: jnp.ndarray, sigma: float, mask=None
 ) -> jnp.ndarray:
     """Log marginal likelihood of the plain (non-extended) temporal Helmholtz GP.
 
     y is (n, 2) velocity observations; flattened point-major/component-minor.
+    Padded entries contribute a unit diagonal block and zero residual, i.e.
+    nothing to the log-likelihood beyond an additive constant (which does not
+    move the optimiser's argmax).
     """
-    K = k_thelm_mat(S, t, S, t, p)
-    n = K.shape[0]
-    A = K + (sigma**2) * jnp.eye(n)
+    A = reg_matrix(S, t, p, sigma, mask)
     c, low = cho_factor(A)
     yy = y.reshape(-1)
+    if mask is not None:
+        yy = yy * _expand_mask(mask).astype(yy.dtype)
     alpha = cho_solve((c, low), yy)
     ld = 2.0 * jnp.sum(jnp.log(jnp.diag(c)))
+    n = A.shape[0]
     return -0.5 * yy @ alpha - 0.5 * ld - 0.5 * n * jnp.log(2 * jnp.pi)
 
 
@@ -84,6 +106,7 @@ def posterior_mean_field(
     t_eval: jnp.ndarray,
     p: HelmParams,
     sigma: float,
+    mask=None,
 ) -> jnp.ndarray:
     """Posterior predictive mean of the velocity field on R x t_eval.
 
@@ -91,16 +114,18 @@ def posterior_mean_field(
     average L2 error of the posterior mean field over the spatial grid and the
     full set of deployment times.
     """
-    K = k_thelm_mat(S, t, S, t, p)
-    A = K + (sigma**2) * jnp.eye(K.shape[0])
+    A = reg_matrix(S, t, p, sigma, mask)
     c, low = cho_factor(A)
-    alpha = cho_solve((c, low), y.reshape(-1))
+    yy = y.reshape(-1)
+    if mask is not None:
+        yy = yy * _expand_mask(mask).astype(yy.dtype)
+    alpha = cho_solve((c, low), yy)
 
     N = R.shape[0]
     Rr = jnp.tile(R, (t_eval.shape[0], 1))  # (nt*N, 2)
     tr = jnp.repeat(t_eval, N)
     Kx = k_thelm_mat(S, t, Rr, tr, p)  # (2n, 2*nt*N)
-    mu = Kx.T @ alpha
+    mu = Kx.T @ alpha  # padded rows carry alpha = 0 and drop out
     return mu.reshape(t_eval.shape[0], N, 2)
 
 
@@ -113,6 +138,7 @@ def posterior_ext_state(
     p: HelmParams,
     sigma: float,
     jitter: float = 1e-8,
+    mask=None,
 ):
     """Posterior of the extended state f(R, t_m) = [f, d_t f]^T given D_m.
 
@@ -123,8 +149,7 @@ def posterior_ext_state(
 
     Returns (mean (4N,), chol of covariance (4N, 4N)).
     """
-    K = k_thelm_mat(S, t, S, t, p)
-    A = K + (sigma**2) * jnp.eye(K.shape[0])
+    A = reg_matrix(S, t, p, sigma, mask)
     c, low = cho_factor(A)
 
     N = R.shape[0]
@@ -132,7 +157,13 @@ def posterior_ext_state(
     K_ot = k_ext_cross(S, t, R, tvec, p)  # (2n, 4N)
     K_tt = k_ext_full(R, tvec, p)  # (4N, 4N)
 
-    mean = K_ot.T @ cho_solve((c, low), y.reshape(-1))
+    yy = y.reshape(-1)
+    if mask is not None:
+        mm = _expand_mask(mask).astype(K_ot.dtype)
+        yy = yy * mm
+        K_ot = K_ot * mm[:, None]  # padded rows must not leak into the posterior
+
+    mean = K_ot.T @ cho_solve((c, low), yy)
     cov = K_tt - K_ot.T @ cho_solve((c, low), K_ot)
     cov = 0.5 * (cov + cov.T) + jitter * jnp.eye(cov.shape[0])
     return mean, jnp.linalg.cholesky(cov)

ballast/policies.py

@@ -80,6 +80,7 @@ def ballast_sample_utilities(
     sigma: float,
     n_samples: int,
     chunk: int = 64,
+    obs_mask=None,
 ):
     """Per-sample BALLAST utilities: returns (n_samples, N_space).
 
@@ -104,9 +105,8 @@ def ballast_sample_utilities(
         t_base = jnp.concatenate(
             [t_obs, jnp.repeat(t_traj[:, None], n_e, axis=1).reshape(-1)], axis=0
         )
-        m_base = jnp.concatenate(
-            [jnp.ones(S_obs.shape[0], dtype=bool), eval_.reshape(-1)], axis=0
-        )
+        om = jnp.ones(S_obs.shape[0], dtype=bool) if obs_mask is None else obs_mask
+        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):
@@ -135,6 +135,7 @@ def true_field_utilities(
     p: HelmParams,
     sigma: float,
     chunk: int = 64,
+    obs_mask=None,
 ):
     """B(s; true): utilities with trajectories simulated in the ground-truth field.
 
@@ -157,9 +158,8 @@ def true_field_utilities(
     t_base = jnp.concatenate(
         [t_obs, jnp.repeat(t_traj[:, None], n_e, axis=1).reshape(-1)], axis=0
     )
-    m_base = jnp.concatenate(
-        [jnp.ones(S_obs.shape[0], dtype=bool), eval_.reshape(-1)], axis=0
-    )
+    om = jnp.ones(S_obs.shape[0], dtype=bool) if obs_mask is None else obs_mask
+    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):
@@ -179,15 +179,16 @@ def true_field_utilities(
 
 
 def eig_utilities(
-    grid: Grid, S_obs, t_obs, t_m: float, p: HelmParams, sigma: float, chunk: int = 128
+    grid: Grid, S_obs, t_obs, t_m: float, p: HelmParams, sigma: float,
+    chunk: int = 128, mask=None,
 ):
     """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, None)
+    L, ld = base_factor(S_obs, t_obs, p, sigma, mask)
     tv = jnp.array([t_m])
 
     def one(i):
         return rank_q_logdet(
-            L, ld, S_obs, t_obs, None,
+            L, ld, S_obs, t_obs, mask,
             grid.R[i][None, :], tv, jnp.ones(1, dtype=bool), p, sigma,
         )
 
@@ -215,6 +216,7 @@ def dist_sep_scores(
     dt: float,
     obs_every: int,
     n_samples: int,
+    obs_mask=None,
 ):
     """Rank-average of (i) expected drifter path length and (ii) separation.
 
@@ -237,6 +239,8 @@ def dist_sep_scores(
     length = jnp.mean(jnp.stack(lengths), axis=0)  # (N,)
 
     d = jnp.linalg.norm(grid.R[:, None, :] - S_obs[None, :, :], axis=-1)
+    if obs_mask is not None:  # padded points sit at 1e6 and must not be "closest"
+        d = jnp.where(obs_mask[None, :], d, jnp.inf)
     separation = -jnp.min(d, axis=1)  # negative distance to closest observation
 
     r1 = jnp.argsort(jnp.argsort(length))