manyagupta13/apebench-supK-vs-pfK

APEBench 1D: sup-K vs pf-K unrolled training

Trained weights, test errors and training histories of 1,100 autoregressive neural PDE emulators. They cover 5 one-dimensional PDEs, 2 parameter-matched architectures (ResNet and FNO, ≈33k parameters each), 2 ways of training through an autoregressive rollout (sup-K and pf-K), 6 training horizons K ∈ {1, 2, 3, 4, 6, 8}, and 10 random seeds per configuration.

• sup-K: full backpropagation through the K-step rollout.
• pf-K: pushforward, i.e. a stop-gradient after every step.

The full analysis is in report/kstudy_report.pdf.

Layout

<pde>/<sup-k | pf-k>/K<k>/<resnet | fno>/
    config.json          settings of this training job (shared by its 10 seeds)
    log.txt              original Kaggle training log of the job
    progress.json        original Kaggle status file of the job
    seed_0/ … seed_9/
        weights_best.npz     best-by-validation weights (leaf_000, leaf_001, …)
        results.npz          test errors of this seed (see below)
        history.csv          training history (one row per 1,000 updates)
        meta.json            stop point, best update, headline metrics
        milestones/ms_<N>.npz  best-so-far and current weights after N network applications

• <pde>: advection, diffusion, burgers, kdv, ks.
• K = 1 is one-step training, which is the same objective for sup-K and pf-K. Each (PDE, architecture) has a single K=1 job, stored as identical copies under both sup-k/K1 and pf-k/K1 (config.json says so). The CSV tables list it once, as objective one-step (K=1).
• per_seed_results.csv has one row per trained model (1,100 rows), with its folder path(s). data/<pde>.csv holds the same rows split by PDE. manifest.csv has one row per training job (110 rows).
• code/ contains the training code (kstudy.py, Kaggle notebook), the analysis and verification scripts, build_pde_dataset.py (which produced this layout), and load_seed.py.

Files

File	Contents
results.npz	test_err_best (30 × 200): nRMSE of the best checkpoint on each of the 30 APEBench test trajectories at rollout steps 1…200. test_err_final: same, for the final weights. test_1step_best: one-step test nRMSE. ms<N>_test_err_best: test errors of the best-so-far checkpoint at compute budget N, with ms<N>_update giving the update at which it was taken
meta.json	stop_update, stop_reason, best_update, best_val_gmean100, lr_reductions, final_lr_factor, test_gmean100 (headline metric: geometric mean of the trajectory-averaged nRMSE over the first 100 steps), test_gmean200, test_nrmse_t, blowup_trajectories_200 (test trajectories whose nRMSE becomes non-finite or exceeds 10 within 200 steps)
history.csv	Per 1,000 updates: validation metric, one-step validation error, training loss, gradient norm (mean/max), clipped and non-finite step counts, LR factor, stopped. Rows after stop_update are recorded after the seed had stopped, when its weights no longer change
weights_best.npz	The weight arrays of an APEBench/Equinox network, in jax.tree.flatten order. Use code/load_seed.py to turn them back into a model
milestones/ms_<N>.npz	best_leaf_###: best-so-far weights after N = K × updates network applications. cur_leaf_###: weights at that moment. Budgets are 24k × 2ⁿ

Loading

# tables
import pandas as pd
df = pd.read_csv("hf://datasets/<user>/<repo>/per_seed_results.csv")

# only one PDE's folders
from huggingface_hub import snapshot_download
path = snapshot_download("<user>/<repo>", repo_type="dataset", allow_patterns=["advection/**", "code/*"])

# a trained model (pip install apebench==0.1.1)
import sys; sys.path.insert(0, f"{path}/code")
from load_seed import load_seed, test_trajectories
model, cfg, meta = load_seed(f"{path}/advection/sup-k/K4/fno/seed_3")

Experimental setup

Benchmark	APEBench 0.1.1 (JAX/Equinox); scenarios diff_adv (γ = −4), diff_diff, diff_burgers_sc, diff_kdv, diff_ks; N = 160 grid points
Architectures	Res;26;8;relu (32,943 params), FNO;12;18;4;gelu (32,527 params); both predict the next state
Loss	Sum over the K rollout steps of the per-step MSE (Trainax Supervised; cut_bptt=False for sup-K, True for pf-K)
Data	Train 200 trajectories × 50 steps (seed 0); validation 30 × 100 (seed 4242, early stopping only); test 30 × 200 (seed 773, APEBench default)
Optimisation	Adam, lr 1e-3, batch 20, 2k warmup, per-seed plateau halving (patience 10 × 1k updates, ≤5 halvings) then early stop; min 20k, cap 300k updates; adaptive gradient clipping (5 × EMA)
Seeds	0–9: network initialisation and minibatch order. For a given scenario, architecture and K, sup-K seed s and pf-K seed s share initialisation and batches (paired design)
Compute	Kaggle 2 × T4, 215.6 GPU-h of training; all 1,100 seeds stopped by the convergence rule (73k–298k updates)

The training, validation and test trajectories are not included. They are regenerated deterministically by APEBench from the seeds above (test_trajectories(cfg) in code/load_seed.py).

Provenance notes

• Training is deterministic: an accidental second run of one Kaggle session reproduced it bit for bit.
• advection/pf-k/K8/resnet and ks/pf-k/K6/resnet: the progress.json and log.txt in these folders are stale copies from an earlier, paused run, because the Kaggle output was copied without overwriting. Weights, histories and test results come from the finished run and were verified (see config.json → note). Stop points in meta.json come from the final checkpoint.
• Kaggle resume files (state.pkl, which include optimizer state) are not included.

Citation

<add citation / DOI here>