---
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:

```text
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

```text
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:

```text
(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:

```text
IC-OOD-simple, IC-simple, IC-medium, IC-complex, IC-OOD-complex
```

Training contains only the three in-distribution IC families:

```text
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:

```text
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:

```text
5 dynamics x 5 IC families = 25 test sets
```

For test evaluation, the default API returns:

```text
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

```bash
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:

```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:

```python
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:

```python
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:

```python
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:

```bibtex
@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:

```bibtex
@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.