Upload folder using huggingface_hub

tests/test_kernels.py

@@ -0,0 +1,126 @@
+"""Correctness checks for the analytic kernels."""
+
+import jax
+import jax.numpy as jnp
+import numpy as np
+import pytest
+
+jax.config.update("jax_enable_x64", True)
+
+from ballast.kernels import (
+    HelmParams,
+    k_ext_full,
+    k_helm_mat,
+    k_thelm_mat,
+    matern32_blocks,
+)
+
+P = 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
+)
+
+
+def _m32(t, t2, ls, var):
+    """Reference Matern-3/2 written so autodiff is valid (no clipped distance)."""
+    r = jnp.abs(t - t2)
+    lam = jnp.sqrt(3.0) / ls
+    return var * (1 + lam * r) * jnp.exp(-lam * r)
+
+
+def test_matern32_derivatives_match_autodiff():
+    """Analytic d_t, d_t', d^2_tt' blocks agree with autodiff away from t=t'."""
+    ts = jnp.array([0.0, 0.3, 1.7, 4.2])
+    ts2 = jnp.array([0.5, 2.1, 3.3])
+    M = matern32_blocks(ts, ts2, P.time_ls, P.time_var)
+
+    k = jax.vmap(lambda a: jax.vmap(lambda b: _m32(a, b, P.time_ls, P.time_var))(ts2))(ts)
+    dt = jax.grad(_m32, argnums=0)
+    dt2 = jax.grad(_m32, argnums=1)
+    d2 = jax.grad(jax.grad(_m32, argnums=0), argnums=1)
+
+    f = lambda g: jax.vmap(lambda a: jax.vmap(lambda b: g(a, b, P.time_ls, P.time_var))(ts2))(ts)
+    np.testing.assert_allclose(M[..., 0, 0], k, rtol=1e-10)
+    np.testing.assert_allclose(M[..., 1, 0], f(dt), rtol=1e-8)
+    np.testing.assert_allclose(M[..., 0, 1], f(dt2), rtol=1e-8)
+    np.testing.assert_allclose(M[..., 1, 1], f(d2), rtol=1e-8)
+
+
+def test_matern32_second_derivative_at_zero():
+    """Paper Sec. H.2: d^2_{tt'} k at t=t' must be 3 sigma^2/l^2, not 0.
+
+    This is the value GPJax-style clipped-distance autodiff silently returns as
+    zero; it is also exactly P_inf[1,1] in the SPDE formulation, i.e. Var(d_t f).
+    """
+    t = jnp.array([1.0])
+    M = matern32_blocks(t, t, 1.0, 1.0)
+    assert np.isclose(M[0, 0, 1, 1], 3.0)
+    M2 = matern32_blocks(t, t, P.time_ls, P.time_var)
+    assert np.isclose(M2[0, 0, 1, 1], 3.0 * P.time_var / P.time_ls**2)
+
+
+def test_matern32_finite_difference():
+    """Independent finite-difference check of the mixed second derivative."""
+    # h chosen to balance the O(h^2) truncation error of the 4-point stencil
+    # against O(eps/h^2) round-off; 1e-5 leaves ~1e-4 relative truncation error
+    # on a value of ~5e-3 and would fail a 1e-4 tolerance for benign reasons.
+    h = 1e-3
+    a, b = 1.0, 2.4
+    num = (
+        _m32(a + h, b + h, P.time_ls, P.time_var)
+        - _m32(a + h, b - h, P.time_ls, P.time_var)
+        - _m32(a - h, b + h, P.time_ls, P.time_var)
+        + _m32(a - h, b - h, P.time_ls, P.time_var)
+    ) / (4 * h * h)
+    ana = matern32_blocks(jnp.array([a]), jnp.array([b]), P.time_ls, P.time_var)[0, 0, 1, 1]
+    assert np.isclose(num, ana, rtol=1e-4)
+
+
+def _helm_field_cov_reference(S, S2, p):
+    """Helmholtz kernel rebuilt by autodiff of the potential/stream construction.
+
+    F_1 = d_1 Phi + d_2 Psi,  F_2 = d_2 Phi - d_1 Psi, so
+    Cov(F_a(x), F_b(x')) is assembled from mixed second derivatives of k_Phi, k_Psi.
+    """
+    kphi = lambda x, y: p.phi_var * jnp.exp(-0.5 * jnp.sum((x - y) ** 2) / p.phi_ls**2)
+    kpsi = lambda x, y: p.psi_var * jnp.exp(-0.5 * jnp.sum((x - y) ** 2) / p.psi_ls**2)
+    Hphi = jax.jacfwd(jax.jacrev(kphi, argnums=0), argnums=1)
+    Hpsi = jax.jacfwd(jax.jacrev(kpsi, argnums=0), argnums=1)
+
+    def cov(x, y):
+        A, B = Hphi(x, y), Hpsi(x, y)
+        return jnp.array(
+            [
+                [A[0, 0] + B[1, 1], A[0, 1] - B[1, 0]],
+                [A[1, 0] - B[0, 1], A[1, 1] + B[0, 0]],
+            ]
+        )
+
+    return jax.vmap(lambda x: jax.vmap(lambda y: cov(x, y))(S2))(S)
+
+
+def test_helmholtz_matches_autodiff_construction():
+    S = jnp.array([[0.0, 0.0], [0.4, -0.7], [1.2, 0.3]])
+    S2 = jnp.array([[0.1, 0.2], [-0.5, 0.9]])
+    ref = _helm_field_cov_reference(S, S2, P)  # (3, 2, 2, 2)
+    got = k_helm_mat(S, S2, P).reshape(3, 2, 2, 2).transpose(0, 2, 1, 3)
+    # got is (i, j, c, c') after the transpose of the (i,c,j,c') flattening
+    np.testing.assert_allclose(got.transpose(0, 1, 2, 3), ref, rtol=1e-8, atol=1e-12)
+
+
+def test_gram_matrices_are_psd():
+    key = jax.random.PRNGKey(0)
+    S = jax.random.uniform(key, (12, 2), minval=-2, maxval=2)
+    t = jnp.linspace(0, 5, 12)
+    for K in (k_thelm_mat(S, t, S, t, P), k_ext_full(S, t, P), k_helm_mat(S, S, P)):
+        w = jnp.linalg.eigvalsh(0.5 * (K + K.T))
+        assert w.min() > -1e-8, f"min eigenvalue {w.min()}"
+
+
+def test_extended_kernel_blocks_are_consistent():
+    """The f-block of the extended kernel is exactly the plain kernel."""
+    key = jax.random.PRNGKey(1)
+    S = jax.random.uniform(key, (5, 2), minval=-1, maxval=1)
+    t = jnp.linspace(0, 3, 5)
+    E = k_ext_full(S, t, P).reshape(5, 2, 2, 5, 2, 2)
+    plain = k_thelm_mat(S, t, S, t, P).reshape(5, 2, 5, 2)
+    np.testing.assert_allclose(E[:, :, 0, :, :, 0], plain, rtol=1e-10)

tests/test_spde.py

@@ -0,0 +1,176 @@
+"""Exactness checks for the SPDE formulation -- the machinery behind Claim 2.
+
+These are *analytic* comparisons (not Monte Carlo): the SPDE propagation is
+linear-Gaussian, so the joint law it induces over the field at future times can
+be written in closed form and compared to the dense GP built from k_tHelm.
+"""
+
+import jax
+import jax.numpy as jnp
+import numpy as np
+
+jax.config.update("jax_enable_x64", True)
+
+from ballast.gp import posterior_ext_state
+from ballast.kernels import HelmParams, k_helm_mat, k_thelm_mat
+from ballast.spde import make_ops, temporal_matrices
+
+P = 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
+)
+
+
+def _grid(n=3):
+    xs = jnp.linspace(-1.0, 1.0, n)
+    X, Y = jnp.meshgrid(xs, xs, indexing="ij")
+    return jnp.stack([X.reshape(-1), Y.reshape(-1)], -1)
+
+
+def _full_matrices(R, p, dt):
+    """Explicit Phi_full = I_{2N} (x) Phi and Q_full = K_space (x) Q for the
+    flattened state layout (i, c, b) -> i*4 + c*2 + b."""
+    phi, q, pinf = temporal_matrices(p.time_ls, p.time_var, dt)
+    Ks = k_helm_mat(R, R, p)
+    n2 = Ks.shape[0]
+    return (
+        jnp.kron(jnp.eye(n2), phi),
+        jnp.kron(Ks, q),
+        jnp.kron(Ks, pinf),
+    )
+
+
+def _spde_joint_cov(R, p, dt, n_steps, Sigma0, mu0):
+    """Joint mean/cov of the f-component at steps 0..n_steps under the SPDE.
+
+    Propagates the Gaussian analytically:
+        mu_{k+1}    = Phi_full mu_k
+        Var_{k+1}   = Phi_full Var_k Phi_full^T + Q_full
+        Cov(X_j,X_i) = Phi_full^{j-i} Var_i     (j > i)
+    """
+    Phi_f, Q_f, _ = _full_matrices(R, p, dt)
+    d = Phi_f.shape[0]
+    mus = [mu0]
+    vars_ = [Sigma0]
+    for _ in range(n_steps):
+        mus.append(Phi_f @ mus[-1])
+        vars_.append(Phi_f @ vars_[-1] @ Phi_f.T + Q_f)
+
+    nT = n_steps + 1
+    C = jnp.zeros((nT * d, nT * d))
+    for i in range(nT):
+        for j in range(nT):
+            if j >= i:
+                blk = jnp.linalg.matrix_power(Phi_f, j - i) @ vars_[i]
+                C = C.at[j * d : (j + 1) * d, i * d : (i + 1) * d].set(blk)
+            else:
+                blk = vars_[j] @ jnp.linalg.matrix_power(Phi_f, i - j).T
+                C = C.at[j * d : (j + 1) * d, i * d : (i + 1) * d].set(blk)
+    mu = jnp.concatenate(mus)
+    # select the f-component (b = 0) of every (location, velocity component)
+    sel = jnp.arange(d).reshape(-1, 2)[:, 0]
+    sel_all = jnp.concatenate([sel + k * d for k in range(nT)])
+    return mu[sel_all], C[jnp.ix_(sel_all, sel_all)]
+
+
+def test_prior_matches_dense_gp():
+    """SPDE prior started at equilibrium reproduces k_tHelm exactly."""
+    R = _grid(3)
+    dt, n_steps = 0.37, 4
+    _, _, Pinf_full = _full_matrices(R, P, dt)
+    d = Pinf_full.shape[0]
+    mu, C = _spde_joint_cov(R, P, dt, n_steps, Pinf_full, jnp.zeros(d))
+
+    times = jnp.arange(n_steps + 1) * dt
+    Rr = jnp.tile(R, (n_steps + 1, 1))
+    tr = jnp.repeat(times, R.shape[0])
+    K = k_thelm_mat(Rr, tr, Rr, tr, P)
+
+    np.testing.assert_allclose(mu, 0.0, atol=1e-12)
+    np.testing.assert_allclose(C, K, rtol=1e-8, atol=1e-10)
+
+
+def test_posterior_sampling_is_exact_with_nongridded_observations():
+    """The Sec. 4.1 scheme is exact: extended-state posterior at t_m + SPDE
+    propagation == dense GP posterior at future times, even though the
+    observations sit at non-gridded (Lagrangian) locations.
+
+    This is the core correctness claim of BALLAST's sampler, and the reason it
+    can avoid filtering over the observation locations.
+    """
+    key = jax.random.PRNGKey(0)
+    R = _grid(3)
+    sigma = 0.1
+    dt, n_steps, t_m = 0.37, 4, 1.5
+
+    # observations at random NON-grid locations, all strictly before t_m
+    k1, k2, k3 = jax.random.split(key, 3)
+    S_obs = jax.random.uniform(k1, (7, 2), minval=-1.4, maxval=1.4)
+    t_obs = jax.random.uniform(k2, (7,), minval=0.0, maxval=t_m)
+    y_obs = jax.random.normal(k3, (7, 2))
+
+    # --- SPDE route: posterior of the extended state at t_m, then propagate
+    mean, chol = posterior_ext_state(S_obs, t_obs, y_obs, R, t_m, P, sigma, jitter=0.0)
+    Sigma0 = chol @ chol.T
+    mu_s, C_s = _spde_joint_cov(R, P, dt, n_steps, Sigma0, mean)
+
+    # --- dense route: GP posterior directly at R x future times
+    times = t_m + jnp.arange(n_steps + 1) * dt
+    Rr = jnp.tile(R, (n_steps + 1, 1))
+    tr = jnp.repeat(times, R.shape[0])
+    K_oo = k_thelm_mat(S_obs, t_obs, S_obs, t_obs, P) + sigma**2 * jnp.eye(14)
+    K_ot = k_thelm_mat(S_obs, t_obs, Rr, tr, P)
+    K_tt = k_thelm_mat(Rr, tr, Rr, tr, P)
+    sol = jnp.linalg.solve(K_oo, K_ot)
+    mu_d = sol.T @ y_obs.reshape(-1)
+    C_d = K_tt - K_ot.T @ sol
+
+    np.testing.assert_allclose(mu_s, mu_d, rtol=1e-6, atol=1e-9)
+    np.testing.assert_allclose(C_s, C_d, rtol=1e-6, atol=1e-9)
+
+
+def test_sampler_empirical_moments():
+    """End-to-end: the actual sampling code path reproduces the analytic posterior."""
+    from ballast.gp import sample_ext_state
+    from ballast.spde import propagate
+
+    key = jax.random.PRNGKey(2)
+    R = _grid(2)
+    sigma, dt, n_steps, t_m = 0.1, 0.25, 3, 1.0
+    ops = make_ops(R, P, dt, jitter=0.0)
+
+    k1, k2, k3 = jax.random.split(key, 3)
+    S_obs = jax.random.uniform(k1, (5, 2), minval=-1.0, maxval=1.0)
+    t_obs = jax.random.uniform(k2, (5,), minval=0.0, maxval=t_m)
+    y_obs = jax.random.normal(k3, (5, 2))
+    mean, chol = posterior_ext_state(S_obs, t_obs, y_obs, R, t_m, P, sigma, jitter=1e-12)
+
+    n = 40000
+    keys = jax.random.split(jax.random.PRNGKey(7), n)
+
+    def one(k):
+        ka, kb = jax.random.split(k)
+        X0 = sample_ext_state(ka, mean, chol, R.shape[0])
+        return propagate(X0, kb, ops, n_steps)[-1].reshape(-1)
+
+    draws = jax.vmap(one)(keys)
+    emp_mu = draws.mean(0)
+    emp_cov = jnp.cov(draws.T)
+
+    _, C_an = _spde_joint_cov(
+        R, P, dt, n_steps, chol @ chol.T, mean
+    )
+    mu_an, _ = _spde_joint_cov(R, P, dt, n_steps, chol @ chol.T, mean)
+    d = 2 * R.shape[0]
+    mu_last = mu_an[-d:]
+    C_last = C_an[-d:, -d:]
+
+    # Statistical tolerances: fixed rtol/atol are meaningless here because the
+    # small off-diagonal covariance entries are dominated by Monte Carlo noise.
+    se_mu = jnp.sqrt(jnp.diag(C_last) / n)
+    assert jnp.all(jnp.abs(emp_mu - mu_last) < 5 * se_mu), "sample mean off"
+
+    # SE of an empirical covariance entry: sqrt((C_ii C_jj + C_ij^2)/n)
+    d_ = jnp.diag(C_last)
+    se_cov = jnp.sqrt((d_[:, None] * d_[None, :] + C_last**2) / n)
+    z = jnp.abs(emp_cov - C_last) / se_cov
+    assert z.max() < 5.0, f"max z-score {z.max():.2f} between empirical and analytic cov"