README.md

metadata

pretty_name: PhysBiasBench
license: other
tags:
  - physics
  - pde
  - spatiotemporal-forecasting
  - scientific-machine-learning
  - benchmark
  - numpy
task_categories:
  - time-series-forecasting
size_categories:
  - 1K<n<10K

PhysBiasBench

This release contains a 64x64 PDE dynamics benchmark designed for evaluating spatiotemporal forecasting models under controlled shifts in initial-condition complexity and temporal dynamic scales. The benchmark is intended primarily for evaluating the general-purpose forecasting ability of physics foundation models, especially their robustness across PDE families, temporal scales, and in- and out-of-distribution ability.

The trajectories were generated with the APEBench/Exponax toolchain. We organize the data into a foundation-model benchmark with mixed training distributions and a 5x5 dynamic-by-IC test grid.

The data folder is named Data/ in this release. Each trajectory is stored as a NumPy array with 100 raw frames. The benchmark API constructs 20-frame dynamic sequences from those raw trajectories and provides the mixed train/validation settings and the full 5x5 test grid used in the experiments.

Repository Layout

This dataset is intended to be uploaded as a Hugging Face Dataset repository with the following files:

README.md
.gitattributes
requirements.txt
manifest.csv
benchmark_api.py
Data/

The large .npy arrays are tracked with Git LFS. The Hugging Face Dataset Viewer may not preview these multidimensional arrays directly; users should download the repository snapshot and load the data through benchmark_api.py.

Folder Structure

PhysBiasBench/
  README.md
  benchmark_api.py
  Data/
    gray_scott/
      metadata.json
      index.csv
      train/IC-simple.npy
      train/IC-medium.npy
      train/IC-complex.npy
      val/IC-OOD-simple.npy
      val/IC-simple.npy
      ...
      test/IC-OOD-complex.npy
    wave/
    fisher_kpp/
    burgers/
    swift_hohenberg/
    decay/
    kolmogorov/
    kuramoto_sivashinsky/

Each .npy file has shape:

(num_trajectories, 100, channels, 64, 64)

where channels depends on the PDE. For example, Gray-Scott and Wave have two channels, while Fisher-KPP, Swift-Hohenberg, Navier-Stokes decay, Kolmogorov flow, and Kuramoto-Sivashinsky are scalar fields. Burgers stores two velocity channels.

PDE Families

The benchmark contains 8 PDE families:

folder	PDE	channels
gray_scott	Gray-Scott reaction-diffusion	u, v concentrations
wave	Wave equation	height, velocity
fisher_kpp	Fisher-KPP reaction-diffusion	scalar population field
burgers	2D Burgers equation	u_x, u_y velocity
swift_hohenberg	Swift-Hohenberg equation	scalar field
decay	2D Navier-Stokes vorticity decay	vorticity
kolmogorov	2D Kolmogorov flow in vorticity form	vorticity
kuramoto_sivashinsky	Kuramoto-Sivashinsky equation	scalar field

Detailed generation parameters are stored in each metadata.json.

Initial-Condition Families

Validation and test contain five IC families ordered by complexity:

IC-OOD-simple, IC-simple, IC-medium, IC-complex, IC-OOD-complex

Training contains only the three in-distribution IC families:

IC-simple, IC-medium, IC-complex

For Fourier-based ICs, complexity is controlled by the spectral cutoff. For Gaussian-blob ICs, complexity is controlled by the number of blobs. Exact values are recorded in metadata.json.

Dynamic Sequences

The raw trajectory has 100 frames. A benchmark sample is a 20-frame sequence obtained by temporal subsampling from the first raw frame:

dynamic name	raw-frame stride	selected raw frames
Dynamic-OOD-small	1	0, 1, ..., 19
Dynamic-small	2	0, 2, ..., 38
Dynamic-medium	3	0, 3, ..., 57
Dynamic-large	4	0, 4, ..., 76
Dynamic-OOD-large	5	0, 5, ..., 95

The three in-distribution training complexity sources are:

simple  = Dynamic-small  + IC-simple
medium  = Dynamic-medium + IC-medium
complex = Dynamic-large  + IC-complex

The two OOD dynamics, Dynamic-OOD-small and Dynamic-OOD-large, are used only for testing.

Train and Validation Settings

The benchmark defines three mixed training distributions:

setting	simple	medium	complex	total train trajectories
Mix-simple	200	50	50	300
Mix-balance	100	100	100	300
Mix-complex	50	50	200	300

Validation uses the matched mixture proportions:

setting	simple	medium	complex	total val trajectories
Mix-simple	50	15	15	80
Mix-balance	25	25	25	75
Mix-complex	15	15	50	80

By default, training windows are drawn only from the first 15 frames of each 20-frame dynamic sequence. With input_frames=5 and target_frames=1, this produces one-step training windows while reserving the final 5 frames for rollout-OOD evaluation.

5x5 Test Grid

Testing uses all combinations of:

5 dynamics x 5 IC families = 25 test sets

For test evaluation, the default API returns:

x = first 5 frames
 y = following 15 frames

so a model can be evaluated on 15-step rollout behavior from the same 20-frame benchmark sequence.

Quick Start

cd PhysBiasBench
python benchmark_api.py --data-root Data
python benchmark_api.py --data-root Data --pde gray_scott --mix Mix-balance

Use from Python:

from benchmark_api import make_train_val_datasets, iter_test_grid

train_ds, val_ds = make_train_val_datasets(
    data_root="Data",
    pde="gray_scott",
    mix="Mix-balance",
    input_frames=5,
    target_frames=1,
    train_context_frames=15,
)

sample = train_ds[0]
print(sample["x"].shape)  # (5, C, 64, 64)
print(sample["y"].shape)  # (1, C, 64, 64)

for dynamic, ic, test_ds in iter_test_grid("Data", "gray_scott"):
    item = test_ds[0]
    print(dynamic, ic, item["x"].shape, item["y"].shape)
    # default test shapes: x=(5, C, 64, 64), y=(15, C, 64, 64)

With PyTorch:

from torch.utils.data import DataLoader
from benchmark_api import make_train_val_datasets

train_ds, val_ds = make_train_val_datasets("Data", "gray_scott", "Mix-balance")
loader = DataLoader(train_ds, batch_size=16, shuffle=True, num_workers=4)

batch = next(iter(loader))
print(batch["x"].shape)  # torch.Size([16, 5, C, 64, 64])
print(batch["y"].shape)  # torch.Size([16, 1, C, 64, 64])

Download From Hugging Face

After upload, users can download the full release with:

from huggingface_hub import snapshot_download

repo_path = snapshot_download(
    repo_id="YOUR_ORG_OR_USER/PhysBiasBench",
    repo_type="dataset",
)
print(repo_path)

Then load it locally:

from pathlib import Path
import sys

repo_path = Path(repo_path)
sys.path.insert(0, str(repo_path))

from benchmark_api import make_train_val_datasets

train_ds, val_ds = make_train_val_datasets(
    data_root=repo_path / "Data",
    pde="gray_scott",
    mix="Mix-balance",
)
print(len(train_ds), len(val_ds))

Citation

If you use this benchmark or dataset, please cite:

@misc{chu2026physicsfoundationmodels,
  title={Do Physics Foundation Models Learn Generalizable Physics? A Bias-Aware Benchmark Across Physical Regimes and Distribution Shifts},
  author={Mengdi Chu and Yang Liu and Ayan Biswas and Han-Wei Shen},
  year={2026},
  eprint={2605.29283},
  archivePrefix={arXiv},
  url={https://arxiv.org/abs/2605.29283}
}

Please also cite APEBench, whose tooling was used for procedural PDE generation:

@article{koehler2024apebench,
  title={{APEBench}: A Benchmark for Autoregressive Neural Emulators of {PDE}s},
  author={Felix Koehler and Simon Niedermayr and R{\"}udiger Westermann and Nils Thuerey},
  journal={Advances in Neural Information Processing Systems (NeurIPS)},
  volume={38},
  year={2024}
}

Notes

• Arrays are stored as float NumPy .npy files and are memory-mapped by the API.
• The API does not normalize the fields. Apply model-specific normalization in your training code if needed.