Reset history

.gitignore

@@ -0,0 +1,206 @@
+# Ignore W&B 
+wandb/**
+
+# Mac os files
+.DS_Store
+
+# Ignore .specstory directory
+.specstory/
+
+# Local data store
+**.npz
+**.json
+
+# Ignore model files
+**.pt
+**.pth
+
+# Ignore local scripts (and local images)
+local_scripts/**
+tests/test-images
+# **.png 
+**.jpeg
+**.pdf 
+
+
+#ignore runner scripts
+runner*
+slurm*
+# Ignore local directories
+notebooks/** 
+local-scripts/**
+.vscode/**
+
+# Logging folders
+test-images/**
+logs/**
+wandb/**
+outputs/**
+
+# wandb artifacts containing model checkpoints
+artifacts/**
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+temp.ipynb
+
+# Model checkpoints
+*ckpt
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

DATA_GUIDE.md

@@ -0,0 +1,817 @@
+# PDEInvBench Data Guide
+
+## Table of Contents
+
+1. [Dataset Link](#1-dataset-link)
+2. [Downloading Data](#2-downloading-data)
+3. [Overview](#3-overview)
+   - [3.1 Data Format](#31-data-format)
+   - [3.2 Parameter Extraction from Filenames](#32-parameter-extraction-from-filenames)
+   - [3.3 Working with High-Resolution Data](#33-working-with-high-resolution-data)
+   - [3.4 Data Loading Parameters](#34-data-loading-parameters)
+   - [3.5 Parameter Normalization](#35-parameter-normalization)
+4. [Datasets](#4-datasets)
+   - [4a. 2D Reaction Diffusion](#4a-2d-reaction-diffusion)
+   - [4b. 2D Navier Stokes (Unforced)](#4b-2d-navier-stokes-unforced)
+   - [4c. 2D Turbulent Flow (Forced Navier Stokes)](#4c-2d-turbulent-flow-forced-navier-stokes)
+   - [4d. 1D Korteweg-De Vries](#4d-1d-korteweg-de-vries)
+   - [4e. 2D Darcy Flow](#4e-2d-darcy-flow)
+5. [Adding a New Dataset](#5-adding-a-new-dataset)
+
+
+## 1. Dataset Link
+
+The dataset used in this project can be found here:
+https://huggingface.co/datasets/DabbyOWL/PDE_Inverse_Problem_Benchmarking/tree/main
+
+## 2. Downloading Data
+
+We provide a python script: [`huggingface_pdeinv_download.py`](huggingface_pdeinv_download.py) to batch download our hugging-face data. We will update the readme of our hugging-face dataset and our github repo to reflect this addition. To run this:
+
+```bash
+pip install huggingface_hub
+python3 huggingface_pdeinv_download.py [--dataset DATASET_NAME] [--split SPLIT] [--local-dir PATH]
+```
+
+**Available datasets:** `darcy-flow-241`, `darcy-flow-421`, `korteweg-de-vries-1d`, `navier-stokes-forced-2d-2048`, `navier-stokes-forced-2d`, `navier-stokes-unforced-2d`, `reaction-diffusion-2d-du-512`, `reaction-diffusion-2d-du`, `reaction-diffusion-2d-k-512`, `reaction-diffusion-2d-k`
+
+**Available splits:** `*` (all), `train`, `validation`, `test`, `out_of_distribution`, `out_of_distribution_extreme`
+
+
+## 3. Overview
+
+The PDEInvBench dataset contains five PDE systems spanning parabolic, hyperbolic, and elliptic classifications, designed for benchmarking inverse parameter estimation.
+
+### Dataset Scale and Scope
+
+The dataset encompasses **over 1.2 million individual simulations** across five PDE systems, with varying spatial and temporal resolutions:
+
+- **2D Reaction Diffusion**: 28×28×27 = 21,168 parameter combinations × 5 trajectories = 105,840 simulations
+- **2D Navier Stokes**: 101 parameter values × 192 trajectories = 19,392 simulations  
+- **2D Turbulent Flow**: 120 parameter values × 108 trajectories = 12,960 simulations
+- **1D Korteweg-De Vries**: 100 parameter values × 100 trajectories = 10,000 simulations
+- **2D Darcy Flow**: 2,048 unique coefficient fields
+
+### Multi-Resolution Architecture
+
+The dataset provides multiple spatial resolutions for each system, enabling studies on resolution-dependent generalization:
+
+- **Low Resolution**: 64×64 (2D systems), 256 (1D KdV), 241×241 (Darcy Flow)
+- **Medium Resolution**: 128×128 (2D systems), 256×256 (Turbulent Flow)
+- **High Resolution**: 256×256, 512×512, 1024×1024 (2D systems), 421×421 (Darcy Flow)
+
+### Physical and Mathematical Diversity
+
+**Parabolic Systems** (Time-dependent, diffusive):
+- **2D Reaction Diffusion**: Chemical pattern formation with Fitzhugh-Nagumo dynamics
+- **2D Navier Stokes**: Fluid flow without external forcing
+- **2D Turbulent Flow**: Forced fluid dynamics with Kolmogorov forcing
+
+**Hyperbolic Systems** (Wave propagation):
+- **1D Korteweg-De Vries**: Soliton dynamics in shallow water waves
+
+**Elliptic Systems** (Steady-state):
+- **2D Darcy Flow**: Groundwater flow through porous media
+
+### Parameter Space Coverage
+
+The dataset systematically explores parameter spaces across different physical regimes:
+
+- **Reaction Diffusion**: k ∈ [0.005,0.1], Du ∈ [0.01,0.5], Dv ∈ [0.01,0.5] (Turing bifurcations)
+- **Navier Stokes**: ν ∈ [10⁻⁴,10⁻²] (Reynolds: 80-8000, laminar to transitional)
+- **Turbulent Flow**: ν ∈ [10⁻⁵,10⁻²] (fully developed turbulence)
+- **Korteweg-De Vries**: δ ∈ [0.8,5] (dispersion strength in shallow water)
+- **Darcy Flow**: Piecewise constant diffusion coefficients (porous media heterogeneity)
+
+### Evaluation Framework
+
+The dataset implements a sophisticated three-tier evaluation system for comprehensive generalization testing:
+
+1. **In-Distribution (ID)**: Parameters within training ranges for baseline performance
+2. **Out-of-Distribution (Non-Extreme)**: Middle-range parameters excluded from training
+3. **Out-of-Distribution (Extreme)**: Extremal parameter values for stress testing
+
+This framework enables systematic evaluation of model robustness across parameter space, critical for real-world deployment where models must generalize beyond training distributions.
+
+
+### Data Organization and Accessibility
+
+The dataset is organized in a standardized HDF5 format with:
+
+- **Hierarchical Structure**: Train/validation/test splits with consistent naming conventions
+- **Parameter Encoding**: Filenames encode parameter values for easy parsing
+- **Multi-Channel Support**: 2D systems support multiple solution channels (velocity components, chemical species)
+- **Grid Information**: Complete spatial and temporal coordinate information
+- **Normalization Statistics**: Pre-computed parameter normalization for consistent preprocessing
+
+### Key Features for Inverse Problem Benchmarking
+
+1. **Multi-Physics Coverage**: Spans chemical, fluid, wave, and porous media physics
+2. **Resolution Scalability**: Enables studies on resolution-dependent model behavior
+3. **Parameter Diversity**: Systematic exploration of parameter spaces across physical regimes
+4. **Generalization Testing**: Built-in evaluation framework for out-of-distribution performance
+5. **Computational Efficiency**: Optimized data loading and preprocessing pipelines
+6. **Reproducibility**: Complete documentation of generation parameters and solver configurations
+
+This comprehensive dataset provides researchers with a unified platform for developing and evaluating inverse problem solving methods across diverse scientific domains, enabling systematic comparison of approaches and identification of fundamental limitations in current methodologies.
+
+### 3.1 Data Format
+
+All datasets are stored in HDF5 format with specific structure depending on the PDE system.
+
+#### Directory Structure
+
+Datasets should be organized in the following directory structure:
+
+```
+/path/to/data/
+├── train/
+│   ├── param_file_1.h5
+│   ├── param_file_2.h5
+│   └── ...
+├── validation/
+│   ├── param_file_3.h5
+│   └── ...
+└── test/
+    ├── param_file_4.h5
+    └── ...
+```
+
+### 3.2 Parameter Extraction from Filenames
+
+Parameters are extracted from filenames using pattern matching. For example:
+
+- **2D Reaction Diffusion**: `Du=0.1_Dv=0.2_k=0.05.h5`
+  - Du = 0.1, Dv = 0.2, k = 0.05
+  
+- **2D Navier Stokes**: `83.0.h5` 
+  - Reynolds number = 83.0
+  
+- **1D KdV**: `delta=3.5_ic=42.h5`
+  - δ = 3.5
+
+### 3.3 Working with High-Resolution Data
+
+For high-resolution datasets, we provide configurations for downsampling:
+
+| PDE System | Original Resolution | High-Resolution |
+|------------|:-------------------:|:---------------:|
+| 2D Reaction Diffusion | 128×128 | 256×256, 512×512 |
+| 2D Navier Stokes | 64×64 | 128×128, 256×256 |
+| 2D Turbulent Flow | 256×256 | 512×512, 1024×1024 |
+| Darcy Flow | 241×241 | 421×421 |
+
+When working with high-resolution data, set the following parameters:
+
+```bash
+high_resolution=True
+data.downsample_factor=4  # e.g., for 512×512 → 128×128
+data.batch_size=2         # Reduce batch size for GPU memory
+```
+
+### 3.4 Data Loading Parameters
+
+Key parameters for loading data:
+
+- `data.every_nth_window`: Controls sampling frequency of time windows
+- `data.frac_ics_per_param`: Fraction of initial conditions per parameter to use
+- `data.frac_param_combinations`: Fraction of parameter combinations to use
+- `data.train_window_end_percent`: Percentage of trajectory used for training
+- `data.test_window_start_percent`: Percentage where test window starts
+
+### 3.5 Parameter Normalization
+
+Parameters are normalized using the following statistics, where the mean and standard deviation are computed using the span of the parameters in the dataset:
+
+```python
+PARAM_NORMALIZATION_STATS = {
+    PDE.ReactionDiffusion2D: {
+        "k": (0.06391126306498819, 0.029533048151465856),    # (mean, std)
+        "Du": (0.3094992685910578, 0.13865605073673604),     # (mean, std)
+        "Dv": (0.259514500345804, 0.11541850276902947),      # (mean, std)
+    },
+    PDE.NavierStokes2D: {"re": (1723.425, 1723.425)},        # (mean, std)
+    PDE.TurbulentFlow2D: {"nu": (0.001372469573118451, 0.002146258280849241)},
+    PDE.KortewegDeVries1D: {"delta": (2.899999997019768, 1.2246211546444339)},
+    # Add more as needed
+}
+```
+
+## 4. Datasets
+
+This section provides detailed information about each PDE system in the dataset. Each subsection includes visualizations, descriptions, and technical specifications.
+
+### 4a. 2D Reaction Diffusion
+
+<img src="images/2drd_u_channel.png" alt="2DRD-Activator" width="400">
+<img src="images/2drd_v_channel.png" alt="2DRD-Inhibitor" width="400">
+
+**Description:** The 2D Reaction-Diffusion system models chemical reactions with spatial diffusion using the Fitzhugh-Nagumo equations. This dataset contains two-channel solutions (activator u and inhibitor v) with parameters k (threshold for excitement), Du (activator diffusivity), and Dv (inhibitor diffusivity). The system exhibits complex pattern formation including spots, stripes, and labyrinthine structures, spanning from dissipative to Turing bifurcations.
+
+**Mathematical Formulation:**
+The activator u and inhibitor v coupled system follows:
+
+```
+∂tu = Du∂xxu + Du∂yyu + Ru
+∂tv = Dv∂xxv + Dv∂yyv + Rv
+```
+
+where Ru and Rv are defined by the Fitzhugh-Nagumo equations:
+
+```
+Ru(u,v) = u - u³ - k - v
+Rv(u,v) = u - v
+```
+
+**Parameters of Interest:**
+- **Du**: Activator diffusion coefficient
+- **Dv**: Inhibitor diffusion coefficient  
+- **k**: Threshold for excitement
+
+**Data Characteristics:**
+- Partial Derivatives: 5
+- Time-dependent: Yes (parabolic)
+- Spatial Resolutions: 64×64, 128×128, 256×256
+- Parameters: k ∈ [0.005,0.1], Du ∈ [0.01,0.5], Dv ∈ [0.01,0.5]
+- Temporal Resolution: 0.049/5 seconds
+- Parameter Values: k - 28, Du - 28, Dv - 27
+- Initial Conditions/Trajectories: 5
+
+**Evaluation Splits:**
+- **Test (ID)**: k ∈ [0.01,0.04] ∪ [0.08,0.09], Du ∈ [0.08,0.2] ∪ [0.4,0.49], Dv ∈ [0.08,0.2] ∪ [0.4,0.49]
+- **OOD (Non-Extreme)**: k ∈ [0.04,0.08], Du ∈ [0.2,0.4], Dv ∈ [0.2,0.4]
+- **OOD (Extreme)**: k ∈ [0.001,0.01] ∪ [0.09,0.1], Du ∈ [0.02,0.08] ∪ [0.49,0.5], Dv ∈ [0.02,0.08] ∪ [0.49,0.5]
+
+**Generation Parameters:**
+- **Solver**: Explicit Runge-Kutta method of order 5(4) (RK45)
+- **Error Tolerance**: Relative error tolerance of 10⁻⁶
+- **Spatial Discretization**: Finite Volume Method (FVM) with uniform 128×128 grid
+- **Domain**: [-1,1] × [-1,1] with cell size Δx = Δy = 0.015625
+- **Burn-in Period**: 1 simulation second
+- **Dataset Simulation Time**: [0,5] seconds, 101 time steps
+- **Nominal Time Step**: Δt ≈ 0.05 seconds (adaptive)
+- **Generation Time**: ≈ 1 week on CPU
+
+**File Structure:**
+```
+filename: Du=0.1_Dv=0.2_k=0.05.h5
+```
+Contents:
+- `0001/data`: Solution field [time, spatial_dim_1, spatial_dim_2, channels]
+- `0001/grid/x`: x-coordinate grid points
+- `0001/grid/y`: y-coordinate grid points
+- `0001/grid/t`: Time points
+
+### 4b. 2D Navier Stokes (Unforced)
+
+<img src="images/2dns.png" alt="2DNS" width="400">
+
+**Description:** The 2D Navier-Stokes equations describe incompressible fluid flow without external forcing. This dataset contains velocity field solutions with varying Reynolds numbers, showcasing different flow regimes from laminar to transitional flows.
+
+**Mathematical Formulation:**
+We consider the vorticity form of the unforced Navier-Stokes equations:
+
+```
+∂w(t,x,y)/∂t + u(t,x,y)·∇w(t,x,y) = νΔw(t,x,y)
+```
+
+for t ∈ [0,T] and (x,y) ∈ (0,1)², with auxiliary conditions:
+- w = ∇ × u
+- ∇ · u = 0
+- w(0,x,y) = w₀(x,y) (Boundary Conditions)
+
+**Parameters of Interest:**
+- **ν**: The physical parameter of interest, representing viscosity
+
+**Data Characteristics:**
+- Partial Derivatives: 3
+- Time-dependent: Yes (parabolic)
+- Spatial Resolutions: 64×64, 128×128, 256×256
+- Parameters: ν ∈ [10⁻⁴,10⁻²] (Reynolds: 80-8000)
+- Temporal Resolution: 0.0468/3 seconds
+- Parameter Values: 101
+- Initial Conditions/Trajectories: 192
+
+**Evaluation Splits:**
+- **Test (ID)**: ν ∈ [10⁻³·⁸, 10⁻³·²] ∪ [10⁻²·⁸, 10⁻²·²]
+- **OOD (Non-Extreme)**: ν ∈ [10⁻³·², 10⁻²·⁸]
+- **OOD (Extreme)**: ν ∈ [10⁻⁴, 10⁻³·⁸] ∪ [10⁻²·², 10⁻²]
+
+**Generation Parameters:**
+- **Solver**: Pseudo-spectral solver with Crank-Nicolson time-stepping
+- **Implementation**: Written in Jax and GPU-accelerated
+- **Generation Time**: ≈ 3.5 GPU days (batch size=32)
+- **Burn-in Period**: 15 simulation seconds
+- **Saved Data**: Next 3 simulation seconds saved as dataset
+- **Initial Conditions**: Sampled according to Gaussian random field (length scale=0.8)
+- **Recording**: Solution recorded every 1 simulation second
+- **Simulation dt**: 1e-4
+- **Resolution**: 256×256
+
+**File Structure:**
+```
+filename: 83.0.h5
+```
+Contents:
+- `0001/data`: Solution field [time, spatial_dim_1, spatial_dim_2, channels]
+- `0001/grid/x`: x-coordinate grid points
+- `0001/grid/y`: y-coordinate grid points
+- `0001/grid/t`: Time points
+
+### 4c. 2D Turbulent Flow (Forced Navier Stokes)
+
+<img src="images/2dtf.png" alt="2DTF" width="400">
+
+**Description:** The 2D Turbulent Flow dataset represents forced Navier-Stokes equations that generate fully developed turbulent flows. This dataset is particularly valuable for studying complex, multi-scale fluid dynamics and turbulent phenomena. All solutions exhibit turbulence across various Reynolds numbers.
+
+**Mathematical Formulation:**
+The forced Navier-Stokes equations with the Kolmogorov forcing function are similar to the unforced case with an additional forcing term:
+
+```
+∂ₜw + u·∇w = νΔw + f(k,y) - αw
+```
+
+where the forcing function f(k,y) is defined as:
+```
+f(k,y) = -kcos(ky)
+```
+
+**Parameters of Interest:**
+- **ν**: Kinematic viscosity (similar to unforced NS)
+- **α**: Drag coefficient (fixed at α = 0.1)
+- **k**: Forced wavenumber (fixed at k = 2)
+
+The drag coefficient α primarily serves to keep the total energy of the system constant, acting as drag. The task is to predict ν.
+
+**Data Characteristics:**
+- Partial Derivatives: 3
+- Time-dependent: Yes (parabolic)
+- Spatial Resolutions: 256×256, 512×512, 1024×1024
+- Parameters: ν ∈ [10⁻⁵,10⁻²]
+- Temporal Resolution: 0.23/14.75 seconds
+- Parameter Values: 120
+- Initial Conditions/Trajectories: 108
+
+**Evaluation Splits:**
+- **Test (ID)**: ν ∈ [10⁻⁴·⁷, 10⁻³·⁸] ∪ [10⁻³·², 10⁻²·³]
+- **OOD (Non-Extreme)**: ν ∈ [10⁻³·⁸, 10⁻³·²]
+- **OOD (Extreme)**: ν ∈ [10⁻⁵, 10⁻⁴·⁷] ∪ [10⁻²·³, 10⁻²]
+
+**Generation Parameters:**
+- **Solver**: Pseudo-spectral solver with Crank-Nicolson time-stepping
+- **Implementation**: Written in Jax (leveraging Jax-CFD), similar to 2D NS
+- **Generation Time**: ≈ 4 GPU days (A100)
+- **Burn-in Period**: 40 simulation seconds
+- **Saved Data**: Next 15 simulation seconds saved as dataset
+- **Simulator Resolution**: 256×256
+- **Downsampling**: Downsamples to 64×64 before saving
+- **Temporal Resolution (Saved)**: ∂t = 0.25 simulation seconds
+
+**File Structure:**
+```
+filename: nu=0.001.h5
+```
+Contents:
+- `0001/data`: Solution field [time, spatial_dim_1, spatial_dim_2, channels]
+- `0001/grid/x`: x-coordinate grid points
+- `0001/grid/y`: y-coordinate grid points
+- `0001/grid/t`: Time points
+
+### 4d. 1D Korteweg-De Vries
+
+<img src="images/1dkdv.png" alt="KdV" width="400">
+
+**Description:** The Korteweg-De Vries (KdV) equation is a nonlinear partial differential equation that describes shallow water waves and solitons. This 1D dataset contains soliton solutions with varying dispersion parameters, demonstrating wave propagation and interaction phenomena.
+
+**Mathematical Formulation:**
+KdV is a 1D PDE representing waves on a shallow-water surface. The governing equation follows the form:
+
+```
+0 = ∂ₜu + u·∂ₓu + δ²∂ₓₓₓu
+```
+
+**Parameters of Interest:**
+- **δ**: The physical parameter representing the strength of the dispersive effect on the system
+- In shallow water wave theory, δ is a unit-less quantity roughly indicating the relative depth of the water
+
+**Data Characteristics:**
+- Partial Derivatives: 3
+- Time-dependent: Yes (hyperbolic)
+- Spatial Resolution: 256
+- Parameters: δ ∈ [0.8,5]
+- Temporal Resolution: 0.73/102 seconds
+- Parameter Values: 100
+- Initial Conditions/Trajectories: 100
+
+**Evaluation Splits:**
+- **Test (ID)**: δ ∈ [1.22, 2.48] ∪ [3.32, 4.58]
+- **OOD (Non-Extreme)**: δ ∈ [2.48, 3.32]
+- **OOD (Extreme)**: δ ∈ [0.8, 1.22] ∪ [4.58, 5]
+
+**Generation Parameters:**
+- **Domain**: Periodic domain [0,L]
+- **Spatial Discretization**: Pseudospectral method with Fourier basis (Nₓ = 256 grid points)
+- **Time Integration**: Implicit Runge-Kutta method (Radau IIA, order 5)
+- **Implementation**: SciPy's `solve_ivp` on CPU
+- **Generation Time**: ≈ 12 hours
+- **Burn-in Period**: 40 simulation seconds
+
+**Initial Conditions:**
+Initial conditions are sampled from a distribution over a truncated Fourier Series:
+
+```
+u₀(x) = Σ_{k=1}^K A_k sin(2πl_k x/L + φ_k)
+```
+
+where:
+- A_k, φ_k ~ U(0,1)
+- l_k ~ U(1,3)
+
+**File Structure:**
+```
+filename: delta=3.5_ic=42.h5
+```
+Contents:
+- `tensor`: Solution field with shape [time, spatial_dim]
+- `x-coordinate`: Spatial grid points
+- `t-coordinate`: Time points
+
+### 4e. 2D Darcy Flow
+
+<img src="images/2ddf.png" alt="2DDF" width="400">
+
+**Description:** The 2D Darcy Flow dataset represents steady-state flow through porous media with piecewise constant diffusion coefficients. This time-independent system is commonly used in groundwater flow modeling and subsurface transport problems. All solutions converge to a non-trivial steady-state solution based on the diffusion coefficient field.
+
+**Mathematical Formulation:**
+The 2D steady-state Darcy flow equation on a unit box Ω = (0,1)² is a second-order linear elliptic PDE with Dirichlet boundary conditions:
+
+```
+-∇·(a(x)∇u(x)) = f(x), for x ∈ Ω
+u(x) = 0, for x ∈ ∂Ω
+```
+
+where:
+- a ∈ L∞((0,1)²;R⁺) is a piecewise constant diffusion coefficient
+- u(x) is the pressure field
+- f(x) = 1 is a fixed forcing function
+
+**Parameters of Interest:**
+- **a(x)**: Piecewise constant diffusion coefficient field (spatially varying parameter)
+
+**Data Characteristics:**
+- Partial Derivatives: 2
+- Time-dependent: No (elliptic)
+- Spatial Resolutions: 241×241, 421×421
+- Parameters: Piecewise constant diffusion coefficient a ∈ L∞((0,1)²;R⁺)
+- Temporal Resolution: N/A (steady-state)
+- Parameter Values: 2048
+- Initial Conditions/Trajectories: N/A
+
+**Evaluation Splits:**
+
+Unlike time-dependent systems with scalar parameters, Darcy Flow does not admit parameter splits based on numeric ranges.  Instead, splits are defined using a derived statistic of the coefficient field.
+
+Let \( r(a) \) denote the fraction of grid points in the coefficient field \( a(x) \) that take the maximum value (12).  
+This statistic is approximately normally distributed across coefficient fields.
+
+Splits are defined as:
+
+- **Test (ID):** Coefficient fields whose \( r(a) \) lies within the central mass of the distribution  
+- **OOD (Non-Extreme):** Not applicable  
+- **OOD (Extreme):** Coefficient fields whose \( r(a) \) lies in the tails beyond \( \pm 1.5\sigma \)
+
+
+**Generation Parameters:**
+- **Solver**: Second-order finite difference method
+- **Implementation**: Originally written in Matlab, runs on CPU
+- **Resolution**: 421×421 (original), with lower resolution dataset generated by downsampling
+- **Coefficient Field Sampling**: a(x) is sampled from μ = Γ(N(0, -Δ + 9I)⁻²)
+- **Gamma Mapping**: Element-wise map where a_i ~ N(0, -Δ + 9I)⁻² → {3,12}
+  - a_i → 12 when a_i ≥ 0
+  - a_i → 3 when a_i < 0
+- **Boundary Conditions**: Zero Neumann boundary conditions on the Laplacian over the coefficient field
+
+**File Structure:**
+```
+filename: sample_1024.h5
+```
+Contents:
+- `coeff`: Piecewise constant coefficient field
+- `sol`: Solution field
+
+
+## 5. Adding a New Dataset
+
+The PDEInvBench framework is designed to be modular, allowing you to add new PDE systems. This section describes how to add a new dataset to the repository. For information about data format requirements, see [Section 4.1](#41-data-format).
+
+### Table of Contents
+  - [Step 1: Add PDE Type to Utils](#step-1-add-pde-type-to-utils)
+  - [Step 2: Add PDE Attributes](#step-2-add-pde-attributes)
+  - [Step 3: Add Parameter Normalization Stats](#step-3-add-parameter-normalization-stats)
+  - [Step 4: Add Parameter Extraction Logic](#step-4-add-parameter-extraction-logic)
+  - [Step 5: Create a Dataset Handler](#step-5-create-a-dataset-handler-if-needed)
+  - [Step 6: Create a Data Configuration](#step-6-create-a-data-configuration)
+  - [Step 7: Add Residual Functions](#step-7-add-residual-functions)
+  - [Step 8: Create a Combined Configuration](#step-8-create-a-combined-configuration)
+  - [Step 9: Generate and Prepare Data](#step-9-generate-and-prepare-data)
+  - [Step 10: Run Experiments](#step-10-run-experiments)
+  - [Data Format Requirements](#data-format-requirements)
+
+### Step 1: Add PDE Type to Utils
+
+First, add your new PDE system to `pdeinvbench/utils/types.py`:
+
+```python
+class PDE(enum.Enum):
+    """
+    Describes which PDE system currently being used.
+    """
+    # Existing PDEs...
+    ReactionDiffusion1D = "Reaction Diffusion 1D"
+    ReactionDiffusion2D = "Reaction Diffusion 2D"
+    NavierStokes2D = "Navier Stokes 2D"
+    # Add your new PDE
+    YourNewPDE = "Your New PDE Description"
+```
+
+### Step 2: Add PDE Attributes
+
+Update the attribute dictionaries in `pdeinvbench/utils/types.py` with information about your new PDE:
+
+```python
+# Number of partial derivatives
+PDE_PARTIALS = {
+    # Existing PDEs...
+    PDE.YourNewPDE: 3,  # Number of partial derivatives needed
+}
+
+# Number of spatial dimensions
+PDE_NUM_SPATIAL = {
+    # Existing PDEs...
+    PDE.YourNewPDE: 2,  # 1 for 1D PDEs, 2 for 2D PDEs
+}
+
+# Spatial size of the grid
+PDE_SPATIAL_SIZE = {
+    # Existing PDEs...
+    PDE.YourNewPDE: [128, 128],  # Spatial dimensions of your dataset
+}
+
+# High-resolution spatial size (if applicable)
+HIGH_RESOLUTION_PDE_SPATIAL_SIZE = {
+    # Existing PDEs...
+    PDE.YourNewPDE: [512, 512],  # High-res dimensions
+}
+
+# Number of parameters
+PDE_NUM_PARAMETERS = {
+    # Existing PDEs...
+    PDE.YourNewPDE: 2,  # Number of parameters in your PDE
+}
+
+# Parameter values
+PDE_PARAM_VALUES = {
+    # Existing PDEs...
+    PDE.YourNewPDE: {
+        "param1": [0.1, 0.2, 0.3],  # List of possible values for param1
+        "param2": [1.0, 2.0, 3.0],  # List of possible values for param2
+    },
+}
+
+# Number of data channels
+PDE_NUM_CHANNELS = {
+    # Existing PDEs...
+    PDE.YourNewPDE: 2,  # Number of channels in your solution field
+}
+
+# Number of timesteps in the trajectory
+PDE_TRAJ_LEN = {
+    # Existing PDEs...
+    PDE.YourNewPDE: 100,  # Number of timesteps in your trajectories
+}
+```
+
+### Step 3: Add Parameter Normalization Stats
+
+Update `pdeinvbench/data/utils.py` with normalization statistics for your PDE parameters:
+
+```python
+PARAM_NORMALIZATION_STATS = {
+    # Existing PDEs...
+    PDE.YourNewPDE: {
+        "param1": (0.2, 0.05),  # (mean, std) for param1
+        "param2": (2.0, 0.5),   # (mean, std) for param2
+    },
+}
+```
+
+### Step 4: Add Parameter Extraction Logic
+
+Add logic to extract parameters from your dataset files in `extract_params_from_path` function inside the dataset class:
+
+```python
+def extract_params_from_path(path: str, pde: PDE) -> dict:
+    # Existing code...
+    elif pde == PDE.YourNewPDE:
+        # Parse the filename to extract parameters
+        name = os.path.basename(path)
+        # Example: extract parameters from filename format "param1=X_param2=Y.h5"
+        param1 = torch.Tensor([float(name.split("param1=")[1].split("_")[0])])
+        param2 = torch.Tensor([float(name.split("param2=")[1].split(".")[0])])
+        param_dict = {"param1": param1, "param2": param2}
+    # Existing code...
+    return param_dict
+```
+
+### Step 5: Create a Dataset Handler (if needed)
+
+If your PDE requires special handling beyond what `PDE_MultiParam` provides, create a new dataset class in `pdeinvbench/data/`:
+
+```python
+# Example: pdeinvbench/data/your_new_pde_dataset.py
+import torch
+from torch.utils.data import Dataset
+
+class YourNewPDEDataset(Dataset):
+    """
+    Custom dataset class for your new PDE system.
+    """
+    def __init__(
+        self,
+        data_root: str,
+        pde: PDE,
+        n_past: int,
+        n_future: int,
+        mode: str,
+        train: bool,
+        # Other parameters...
+    ):
+        # Initialization code...
+        pass
+        
+    def __len__(self):
+        # Implementation...
+        pass
+        
+    def __getitem__(self, index: int):
+        # Implementation...
+        pass
+```
+
+Add your new dataset to `pdeinvbench/data/__init__.py`:
+
+```python
+from .pde_multiparam import PDE_MultiParam
+from .your_new_pde_dataset import YourNewPDEDataset
+
+__all__ = ["PDE_MultiParam", "YourNewPDEDataset"]
+```
+
+```markdown
+### Step 6: Create System Configuration
+
+Create `configs/system_params/your_new_pde.yaml`:
+
+```yaml
+# configs/system_params/your_new_pde.yaml
+defaults:
+  - base
+
+# ============ Data Parameters ============
+name: "your_new_pde_inverse"
+data_root: "/path/to/your/data"
+pde_name: "Your New PDE Description"  # Must match PDE enum value
+num_channels: 2  # Number of solution channels (e.g., u and v)
+cutoff_first_n_frames: 0  # How many initial frames to skip
+
+# ============ Model Parameters ============
+downsampler_input_dim: 2  # 1 for 1D systems, 2 for 2D systems
+params_to_predict: ["param1", "param2"]  # What parameters to predict
+normalize: True  # Whether to normalize predicted parameters
+```
+
+Then create the top-level config `configs/your_new_pde.yaml`:
+
+```yaml
+# configs/your_new_pde.yaml
+name: your_new_pde
+defaults:
+  - _self_
+  - base
+  - override system_params: your_new_pde
+```
+
+The existing configs/data/base.yaml automatically references ${system_params.*} so data loading works out of the box. Run experiments with:
+
+
+```yaml
+    python train_inverse.py --config-name=your_new_pde
+    python train_inverse.py --config-name=your_new_pde model=fno
+    python train_inverse.py --config-name=your_new_pde model=resnet
+```
+
+### Step 7: Add Residual Functions
+
+Implement residual functions for your PDE in `pdeinvbench/losses/pde_residuals.py`:
+
+```python
+def your_new_pde_residual(
+    sol: torch.Tensor,
+    params: Dict[str, torch.Tensor],
+    spatial_grid: Tuple[torch.Tensor, ...],
+    t: torch.Tensor,
+    return_partials: bool = False,
+) -> Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:
+    """
+    Compute the residual for your new PDE.
+    
+    Args:
+        sol: Solution field
+        params: Dictionary of PDE parameters
+        spatial_grid: Spatial grid coordinates
+        t: Time coordinates
+        return_partials: Whether to return partial derivatives
+        
+    Returns:
+        Residual tensor or (residual, partials) if return_partials=True
+    """
+    # Implementation...
+    pass
+```
+
+Register your residual function in `get_pde_residual_function`:
+
+```python
+def get_pde_residual_function(pde: PDE) -> Callable:
+    """Return the appropriate residual function for the given PDE."""
+    if pde == PDE.ReactionDiffusion2D:
+        return reaction_diffusion_2d_residual
+    # Add your PDE
+    elif pde == PDE.YourNewPDE:
+        return your_new_pde_residual
+    # Other PDEs...
+    else:
+        raise ValueError(f"Unknown PDE type: {pde}")
+```
+
+### Step 8: Create a Combined Configuration
+
+Create a combined configuration that uses your dataset:
+
+```yaml
+# configs/your_new_pde.yaml
+name: "your_new_pde"
+defaults:
+  - _self_
+  - base
+  - override data: your_new_pde
+```
+
+### Step 9: Generate and Prepare Data
+
+Make sure your data is properly formatted and stored in the expected directory structure:
+
+```
+/path/to/your/data/
+├── train/
+│   ├── param1=0.1_param2=1.0.h5
+│   ├── param1=0.2_param2=2.0.h5
+│   └── ...
+├── validation/
+│   ├── param1=0.15_param2=1.5.h5
+│   └── ...
+└── test/
+    ├── param1=0.25_param2=2.5.h5
+    └── ...
+```
+
+Each HDF5 file should contain:
+- Solution trajectories
+- Grid information (x, y, t)
+- Any other metadata needed for your PDE
+
+### Step 10: Run Experiments
+
+You can now run experiments with your new dataset:
+
+```bash
+python train_inverse.py --config-name=your_new_pde
+```
+
+### Data Format Requirements
+
+The primary dataset class `PDE_MultiParam` expects data in HDF5 format with specific structure:
+
+- **1D PDEs**: Each HDF5 file contains a single trajectory with keys:
+  - `tensor`: The solution field with shape `[time, spatial_dim]`
+  - `x-coordinate`: Spatial grid points
+  - `t-coordinate`: Time points
+
+- **2D PDEs**: Each HDF5 file contains multiple trajectories (one per IC):
+  - `0001/data`: Solution field with shape `[time, spatial_dim_1, spatial_dim_2, channels]`
+  - `0001/grid/x`: x-coordinates
+  - `0001/grid/y`: y-coordinates
+  - `0001/grid/t`: Time points
+
+- **File naming**: The filename should encode the PDE parameters, following the format expected by `extract_params_from_path`
+

MODEL_GUIDE.md

@@ -0,0 +1,352 @@
+# PDEInvBench
+## Adding a New Model
+
+The PDEInvBench framework is designed to be modular, allowing you to easily add new model architectures. This section describes how to add a new encoder architecture to the repository.
+
+## Table of Contents
+- [Model Architecture Components](#model-architecture-components)
+- [Adding a new model](#adding-a-new-model)
+    - [Step 1: Create a New Encoder Class](#step-1-create-a-new-encoder-class)
+    - [Step 2: Import and Register Your Model](#step-2-import-and-register-your-model)
+    - [Step 3: Create a Configuration File](#step-3-create-a-configuration-file)
+    - [Step 4: Run Experiments with Your Model](#step-4-run-experiments-with-your-model)
+
+## Model Architecture Components
+
+The inverse model architecture in PDEInvBench consists of three main components:
+
+
+```
+Input Solution Field → Encoder → Downsampler → Parameter Network → PDE Parameters
+```
+
+1. **Encoder**: Extracts features from the input solution field (e.g., FNO, ResNet, ScOT)
+2. **Downsampler**: Reduces the spatial dimensions of the features (e.g., ConvDownsampler)
+3. **Parameter Network**: Predicts PDE parameters from the downsampled features
+
+
+## Adding a new model
+
+When creating a new model, you typically only need to modify one of these components while keeping the others the same.
+
+### Step 1: Create a New Encoder Class
+
+First, create a new encoder class in `pdeinvbench/models/encoder.py`. Your new encoder should follow the interface of existing encoders like `FNOEncoder`, `ResnetEncoder`, or `SwinEncoder`:
+
+```python
+import torch
+import torch.nn as nn
+from pdeinvbench.utils.types import PDE
+from pdeinvbench.models.encoder import resolve_number_input_channels
+
+class YourEncoder(nn.Module):
+    """
+    Your custom encoder for PDE inverse problems.
+    """
+    
+    def __init__(
+        self,
+        n_modes: int,  # Or equivalent parameter for your architecture
+        n_layers: int,
+        n_past: int,
+        n_future: int,
+        pde: PDE,
+        data_channels: int,
+        hidden_channels: int,
+        use_partials: bool,
+        mode: str,
+        batch_size: int
+        # Add any architecture-specific parameters
+    ):
+        super(YourEncoder, self).__init__()
+        
+        # Store essential parameters
+        self.n_past = n_past
+        self.n_future = n_future
+        self.pde = pde
+        self.data_channels = data_channels
+        self.hidden_channels = hidden_channels
+        self.use_partials = use_partials
+        self.mode = mode
+        self.batch_size = batch_size
+
+        
+        # Calculate input channels similar to existing encoders
+        in_channels = resolve_number_input_channels(
+            n_past=n_past,
+            data_channels=data_channels,
+            use_partials=use_partials,
+            pde=pde,
+        )
+        
+        # Define your model architecture
+        # Example: Custom neural network layers
+        self.encoder_layers = nn.ModuleList([
+            # Your custom layers here
+            nn.Conv2d(in_channels, hidden_channels, kernel_size=3, padding=1),
+            nn.ReLU(),
+            # Add more layers as needed
+        ])
+        
+        # Output layer to match expected output dimensions
+        self.output_layer = nn.Conv2d(hidden_channels, hidden_channels, kernel_size=1)
+        
+    def forward(self, x, **kwargs):
+        """
+        Forward pass of your encoder.
+        
+        Args:
+            x: Input tensor of shape [batch, channels, height, width]
+            **kwargs: Additional arguments (may include 't' for time-dependent models)
+            
+        Returns:
+            Output tensor of shape [batch, hidden_channels, height, width]
+        """
+        # Implement your forward pass
+        for layer in self.encoder_layers:
+            x = layer(x)
+        
+        x = self.output_layer(x)
+        return x
+```
+
+#### Creating Custom Downsamplers
+
+If you need a custom downsampler, create it in `pdeinvbench/models/downsampler.py`:
+
+```python
+import torch
+import torch.nn as nn
+
+class YourDownsampler(nn.Module):
+    """
+    Your custom downsampler for reducing spatial dimensions.
+    """
+    
+    def __init__(
+        self,
+        input_dimension: int,
+        n_layers: int,
+        in_channels: int,
+        out_channels: int,
+        kernel_size: int,
+        stride: int,
+        padding: int,
+        dropout: float,
+    ):
+        super(YourDownsampler, self).__init__()
+        
+        # Define your downsampling layers
+        self.layers = nn.ModuleList([
+            # Your custom downsampling layers here
+            nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding),
+            nn.ReLU(),
+            nn.Dropout(dropout),
+        ])
+        
+    def forward(self, x):
+        """
+        Forward pass of your downsampler.
+        
+        Args:
+            x: Input tensor of shape [batch, channels, height, width]
+            
+        Returns:
+            Downsampled tensor
+        """
+        for layer in self.layers:
+            x = layer(x)
+        return x
+```
+
+#### Creating Custom MLPs
+
+If you need a custom MLP, create it in `pdeinvbench/models/mlp.py`:
+
+```python
+import torch
+import torch.nn as nn
+
+class YourMLP(nn.Module):
+    """
+    Your custom MLP for parameter prediction.
+    """
+    
+    def __init__(
+        self,
+        in_dim: int,
+        hidden_size: int,
+        dropout: float,
+        out_dim: int,
+        num_layers: int,
+        activation: str,
+    ):
+        super(YourMLP, self).__init__()
+        
+        # Define your MLP layers
+        layers = []
+        current_dim = in_dim
+        
+        for i in range(num_layers):
+            layers.append(nn.Linear(current_dim, hidden_size))
+            layers.append(nn.ReLU() if activation == "relu" else nn.Tanh())
+            layers.append(nn.Dropout(dropout))
+            current_dim = hidden_size
+            
+        layers.append(nn.Linear(current_dim, out_dim))
+        self.layers = nn.Sequential(*layers)
+        
+    def forward(self, x):
+        """
+        Forward pass of your MLP.
+        
+        Args:
+            x: Input tensor of shape [batch, features]
+            
+        Returns:
+            Output tensor of shape [batch, out_dim]
+        """
+        return self.layers(x)
+```
+
+### Step 2: Import and Register Your Model
+
+Make sure your encoder is imported in `pdeinvbench/models/__init__.py`:
+
+```python
+from .encoder import FNOEncoder, ResnetEncoder, ScOTEncoder, YourEncoder
+```
+
+This makes your encoder available for use in configuration files.
+
+### Step 3: Create a Configuration File
+
+The configuration system has three levels:
+
+#### 3.1: Create Model Architecture Config
+
+Create `configs/model/yourmodel.yaml`:
+
+```yaml
+# configs/model/yourmodel.yaml
+name: "${system_params.name}_yourmodel"
+dropout: ${system_params.yourmodel_dropout}
+predict_variance: False
+hidden_channels: ${system_params.yourmodel_hidden_channels}
+encoder_layers: ${system_params.yourmodel_encoder_layers}
+downsampler_layers: ${system_params.yourmodel_downsampler_layers}
+mlp_layers: ${system_params.yourmodel_mlp_layers}
+
+model_config:
+  _target_: pdeinvbench.models.inverse_model.InverseModel
+  paramnet: 
+    _target_: pdeinvbench.models.inverse_model.ParameterNet
+    pde: ${data.pde}
+    normalize: ${system_params.normalize}
+    logspace: ${system_params.logspace}
+    params_to_predict: ${system_params.params_to_predict}
+    predict_variance: ${model.predict_variance}
+    mlp_type: ${system_params.mlp_type}
+    encoder:
+      _target_: pdeinvbench.models.encoder.YourEncoder
+      n_modes: ${system_params.yourmodel_n_modes}
+      n_past: ${n_past}
+      n_future: ${n_future}
+      n_layers: ${model.encoder_layers}
+      data_channels: ${data.num_channels}
+      hidden_channels: ${model.hidden_channels}
+      use_partials: True
+      pde: ${data.pde}
+      mode: ${mode}
+      batch_size: ${data.batch_size}
+      use_cn: false
+      task: inverse
+    downsampler: ${system_params.yourmodel_downsampler}
+    mlp_hidden_size: ${model.hidden_channels}
+    mlp_layers: ${model.mlp_layers}
+    mlp_activation: "relu"
+    mlp_dropout: ${model.dropout}
+    downsample_factor: ${data.downsample_factor}
+```
+
+#### 3.2: Add Defaults to `configs/system_params/base.yaml`
+
+Add architecture defaults that work across all PDE systems:
+
+```yaml
+# configs/system_params/base.yaml
+
+# ============ YourModel Architecture ============
+yourmodel_hidden_channels: 64
+yourmodel_encoder_layers: 4
+yourmodel_downsampler_layers: 4
+yourmodel_dropout: 0
+yourmodel_mlp_layers: 1
+yourmodel_n_modes: 16
+
+yourmodel_downsampler:
+  _target_: pdeinvbench.models.downsampler.ConvDownsampler
+  input_dimension: ${system_params.downsampler_input_dim}
+  n_layers: ${model.downsampler_layers}
+  in_channels: ${model.hidden_channels}
+  out_channels: ${model.hidden_channels}
+  kernel_size: 3
+  stride: 1
+  padding: 2
+  dropout: ${model.dropout}
+```
+
+#### 3.3: (Optional) Add System-Specific Overrides
+
+Override defaults for specific systems in `configs/system_params/{system}.yaml`:
+
+```yaml
+# configs/system_params/2dtf.yaml
+defaults:
+  - base
+
+# ... existing system config ...
+
+# Override architecture for this system
+yourmodel_hidden_channels: 128  # Needs larger model
+yourmodel_encoder_layers: 6
+```
+
+**That's it!** Your model now works with all PDE systems:
+```bash
+python train_inverse.py --config-name=1dkdv model=yourmodel
+python train_inverse.py --config-name=2dtf model=yourmodel
+```
+
+
+#### Important Notes
+
+- **System-specific parameters** (like `params_to_predict`, `normalize`, `downsampler_input_dim`) go in `configs/system_params/{system}.yaml`
+- **Architecture defaults** go in `configs/system_params/base.yaml`
+- **Model structure** goes in `configs/model/{architecture}.yaml`
+- For special cases like Darcy Flow, override the downsampler in the system_params file:
+  ```yaml
+  # configs/system_params/2ddf.yaml
+  yourmodel_downsampler:
+    _target_: pdeinvbench.models.downsampler.IdentityMap
+  ```
+
+### Step 4: Run Experiments with Your Model
+
+You can now run experiments with your custom model on **any** PDE system:
+
+```bash
+# Use your model with different PDE systems
+python train_inverse.py --config-name=1dkdv model=yourmodel
+python train_inverse.py --config-name=2dtf model=yourmodel
+python train_inverse.py --config-name=2dns model=yourmodel
+
+# Use model variants if you created them
+python train_inverse.py --config-name=2drdk model=yourmodel_large
+
+# Override parameters from command line
+python train_inverse.py --config-name=2dtf model=yourmodel model.hidden_channels=96
+
+# Combine multiple overrides
+python train_inverse.py --config-name=2ddf model=yourmodel data.batch_size=16 model.encoder_layers=6
+```

README.md

@@ -0,0 +1,515 @@
+# PDEInvBench
+
+A one-stop shop repository for the benchmarking Neural Operators on inverse problems in partial differential equations.
+
+<img src="images/pde_objectives_main_fig_1.png" alt="" width="400">
+
+## Overview
+
+Inverse problems in partial differential equations (PDEs) involve recovering unknown physical parameters of a system—such as viscosity, diffusivity, or reaction coefficients—from observed spatiotemporal solution fields. Formally, given a PDE
+
+`\[F_{\phi}(u(x,t)) = 0,\]`
+
+where `\(u(x,t)\)` is the solution field and `\(\phi\)` represents physical parameters, the **forward problem** maps `\(\phi \mapsto u\)`, while the **inverse problem** seeks the reverse mapping `\(u \mapsto \phi\)`.
+
+Inverse problems are inherently ill-posed and highly sensitive to noise, making them a challenging yet foundational task in scientific computing and engineering. They arise in diverse applications such as geophysical exploration, fluid mechanics, biomedical imaging, and materials design—where estimating hidden parameters from observed dynamics is essential.
+
+**PDEInvBench** provides a comprehensive benchmark for inverse problems in partial differential equations (PDEs). The codebase supports multiple PDE systems, training strategies, and neural network architectures.
+
+## DATASET LINK:
+The datasets used in this project can be found here:
+https://huggingface.co/datasets/DabbyOWL/PDE_Inverse_Problem_Benchmarking/tree/main
+
+
+## Table of Contents
+1. [Overview](#overview)
+2. [Supported Systems](#supported-systems)
+3. [Supported Inverse Methods](#supported-inverse-methods)
+4. [Models Implemented](#models-implemented)
+5. [Directory Structure](#directory-structure)
+6. [Environment Setup](#environment-setup)
+7. [Downloading Data](#downloading-data)
+8. [Running Experiments](#running-experiments)
+   - [How Configs Work](#how-configs-work)
+   - [Basic Commands](#basic-commands)
+   - [Common Overrides](#common-overrides)
+   - [Multi-GPU and Distributed Training](#multi-gpu-and-distributed-training)
+   - [Experiment Patterns Along Core Design Axes](#-experiment-patterns-along-core-design-axes)
+      - [Training/Optimization Strategies](#1️⃣-trainingoptimization-strategies)
+      - [Problem Representation and Inductive Bias](#2️⃣-problem-representation-and-inductive-bias)
+      - [Scaling Experiments](#3️⃣-scaling-experiments)
+
+9. [Testing](#Testing)
+10. [Shape Checking](#Shape-Checking)
+11. [Adding a New Model](#adding-a-new-model)
+12. [Adding a New Dataset](#adding-a-new-dataset)
+
+## Supported Systems
+
+- **[1D Korteweg–De Vries (KdV) Equation](DATA_GUIDE.md#4d-1d-korteweg-de-vries)**
+- **[2D Reaction Diffusion](DATA_GUIDE.md#4a-2d-reaction-diffusion)**
+- **[2D Unforced Navier Stokes](DATA_GUIDE.md#4b-2d-navier-stokes-unforced)**
+- **[2D Forced Navier Stokes](DATA_GUIDE.md#4c-2d-turbulent-flow-forced-navier-stokes)**
+- **[2D Darcy Flow](DATA_GUIDE.md#4e-2d-darcy-flow)**
+
+For detailed technical information on each PDE system — including governing equations, parameter ranges, and dataset download instructions — refer to the [Data Guide](DATA_GUIDE.md).
+
+## Supported Inverse Methods
+
+- **Fully data-driven**
+- **PDE Residual Loss**
+- **Test-Time Tailoring (TTT)**
+
+## Models Implemented
+
+- **[FNO (Fourier Neural Operator)](https://arxiv.org/pdf/2010.08895)**
+- **[scOT (scalable Operator Transformer)](https://proceedings.neurips.cc/paper_files/paper/2024/file/84e1b1ec17bb11c57234e96433022a9a-Paper-Conference.pdf)**
+- **[ResNet](https://arxiv.org/pdf/1512.03385)**
+
+For detailed technical information on the model architecture, refer to the [Model Guide](MODEL_GUIDE.md).
+
+
+## Directory Structure
+
+```
+PDEInvBench
+├── configs/                          # Inverse problem Hydra configuration files
+│   ├── callbacks/                # Training callbacks (checkpointing, logging)
+│   ├── data/                     # Dataset and data loading configurations
+│   ├── lightning_module/         # PyTorch Lightning module configurations
+│   ├── logging/                  # Weights & Biases logging configurations
+│   ├── loss/                     # Loss function configurations
+│   ├── lr_scheduler/             # Learning rate scheduler configurations
+│   ├── model/                    # Neural network model configurations
+│   ├── optimizer/                # Optimizer configurations
+|   ├── system_params             # PDE-specific model and experiment parameters
+│   ├── tailoring_optimizer/      # Test-time tailoring optimizer configs
+│   └── trainer/                  # PyTorch Lightning trainer configurations
+├── scripts/                          # Utility and data processing scripts
+│   ├── darcy-flow-scripts/           # Darcy flow specific data processing
+│   ├── parameter-perturb/            # Parameter perturbation utilities
+│   ├── reaction-diffusion-scripts/   # Reaction-diffusion data processing
+│   ├── data_splitter.py             # Splits datasets into train/validation sets
+│   └── process_navier_stokes.py     # Processes raw Navier-Stokes data
+├── pdeinvbench/                        # Main package source code
+│   ├── data/                         # Data loading and preprocessing modules
+│   ├── lightning_modules/            # PyTorch Lightning training modules
+│   ├── losses/                       # Loss function implementations
+│   ├── models/                       # Neural network model implementations
+│   │   ├── __init__.py              # Package initialization
+│   │   ├── conv_head.py             # Convolutional head for parameter prediction
+│   │   ├── downsampler.py           # Spatial downsampling layers
+│   │   ├── encoder.py               # FNO and other encoder architectures
+│   │   ├── inverse_model.py         # Main inverse problem model
+│   │   └── mlp.py                   # Multi-layer perceptron components
+│   └── utils/                        # Utility functions and type definitions
+│       ├── __init__.py              # Package initialization
+│       ├── config_utils.py          # Hydra configuration utilities
+│       ├── types.py                 # Type definitions and PDE system constants
+│       └── ...                      # Additional utility modules
+└── train_inverse.py                 # Main training script for inverse problems
+```
+
+## Environment Setup
+
+This project requires **Python 3.11** with PyTorch 2.7, PyTorch Lightning, and several scientific computing libraries.
+
+### Quick Setup (Recommended)
+
+Using the provided `environment.yml`:
+
+```bash
+# Create environment (use micromamba or conda)
+conda env create -f environment.yml
+conda activate inv-env-tmp
+
+# Install the package in editable mode
+pip install -e .
+```
+
+### Manual Setup
+
+Alternatively, use the `build_env.sh` script:
+
+```bash
+chmod +x build_env.sh
+./build_env.sh
+```
+
+### Key Dependencies
+
+- **Deep Learning**: PyTorch 2.7, PyTorch Lightning 2.5
+- **Neural Operators**: neuraloperator 0.3.0, scOT (Poseidon fork)
+- **Scientific Computing**: scipy, numpy, h5py, torch-harmonics
+- **Configuration**: Hydra 1.3, OmegaConf 2.3
+- **Logging**: Weights & Biases (wandb)
+- **Type Checking**: jaxtyping 0.3.2, typeguard 2.13.3
+
+**Note**: The scOT architecture requires a custom fork installed from GitHub (automatically handled in setup scripts).
+
+### Verify Installation
+
+```bash
+python -c "import torch; import lightning; import pdeinvbench; print('Setup successful!')"
+```
+
+## Downloading Data
+
+We provide datasets on [HuggingFace](https://huggingface.co/datasets/DabbyOWL/PDE_Inverse_Problem_Benchmarking/tree/main) with a convenient download script. Use `huggingface_pdeinv_download.py` to batch download specific datasets and splits:
+
+```bash
+pip install huggingface_hub
+python3 huggingface_pdeinv_download.py --dataset darcy-flow-241 --split train --local-dir ./data
+```
+
+Available datasets include `darcy-flow-241`, `korteweg-de-vries-1d`, `navier-stokes-forced-2d`, `reaction-diffusion-2d-du`, and more. For complete dataset documentation, parameter ranges, and detailed download instructions, see the [Data Guide](DATA_GUIDE.md#2-downloading-data).
+
+## Running Experiments
+
+We use `hydra` to manage experiment configurations. The repository supports all combinations of:
+- **PDE Systems**: `1dkdv`, `2drd`, `2dns`, `2dtf`, `2ddf`
+- **Problem Representation**:
+  - **Derivative conditioning**
+  - **Temporal conditioning**: conditioning on 2, 5,10,15,20,25
+  - **Model architectures**: FNO, ResNet, scOT (scalable Operator Transformer)
+- **Training / Optimization strategies**: 
+  - **Fully data-driven supervision** — standard supervised training using paired parameter–solution data  
+  - **Physics-informed (residual) training** — includes a PDE residual loss term for self-supervised regularization  
+  - **Test-Time Tailoring (TTT)** — post-training fine-tuning using the PDE residual at inference time to adapt to new parameter regimes
+- **Scaling**:
+  - **Model Scaling**: 500k parameters, 5 million parameters, 50 million parameters 
+  - **Data scaling**: parameter, initial condition, temporal horizon
+  - **Resolution scaling**: 64×64, 128×128, 256×256, 512×512
+
+### How Configs Work
+
+#### Base Configs
+
+Base configs are located in `configs` and provide starting points for experiments:
+
+- Top-level configs (e.g., `1dkdv.yaml`, `2drd.yaml`) combine specific options for datasets, models, and training settings
+- Individual component configs are in subdirectories (e.g., `configs/data/`, `configs/model/`)
+
+#### Hydra Override Mechanism
+
+Hydra allows you to override any configuration parameter via command line:
+
+1. **Simple parameter override**: `parameter=value`
+2. **Nested parameter override**: `group.parameter=value`
+3. **Adding new parameters**: `+new_parameter=value`
+
+All overrides are automatically appended to the W&B experiment name for easy tracking.
+
+### Basic Commands
+
+```bash
+# Run with a predefined config
+python3 train_inverse.py --config-name={pde_system}
+
+# Run in test mode (evaluation only)
+python3 train_inverse.py --config-name={pde_system} +test_run=true
+
+# Load a model from W&B
+python3 train_inverse.py --config-name={pde_system} +inverse_model_wandb_run={project_id}/{project_name}/model-{model_id}:{version}
+```
+pde_system: `1dkdv`, `2dtf`, `2dns`, `2drdk`, `2drddu`, `2ddf`
+### Common Overrides
+
+#### Data-related Overrides
+```bash
+# Specify data root directory
+data.data_root=/path/to/data
+
+# Control time window sampling
+data.every_nth_window=10
+
+# Control fraction of data used
+data.frac_ics_per_param=0.5
+data.frac_param_combinations=0.5
+
+# Control train/test temporal split
+data.train_window_end_percent=0.5
+data.test_window_start_percent=0.76
+
+# High-resolution data processing
+high_resolution=True
+data.downsample_factor=4  # Downsample from 512x512 to 128x128
+data.downsample_factor=2  # Downsample from 256x256 to 128x128
+data.batch_size=2  # Reduce batch size for higher resolution data
+```
+
+#### Model-related Overrides
+```bash
+# Choose a model
+model=fno
+model=scot
+model=resnet
+model=fno_50mil  # Higher capacity model
+model=fno_500k   # Lower capacity model
+
+# Configure model parameters
+model.model_config.paramnet.encoder.use_partials=False
+
+# Specify which parameters to predict (e.g., for ablation studies)
+model.paramnet.params_to_predict=['Du']
+model.paramnet.params_to_predict=['Dv']
+```
+
+#### Training Overrides
+```bash
+# Control distributed training
++trainer.num_nodes=2
+
+# Set random seed
+seed=0
+
+# Load a pre-trained model
++inverse_model_wandb_run={project_id}/{project_name}/model-{model_id}:{version}
+
+# Enable test-only mode (no training)
++test_run=true
+```
+
+#### Loss-related Overrides
+```bash
+# Adjust loss weights
+loss.inverse_param_loss_weight=0
+loss.inverse_residual_loss_weight=1
+```
+
+#### Logging Overrides
+```bash
+# Set W&B project and directory
+logging.project=my_project
+logging.save_dir=/path/to/wandb/cache
+```
+
+### Multi-GPU and Distributed Training
+
+```bash
+# Single GPU
+CUDA_VISIBLE_DEVICES=0 python3 train_inverse.py --config-name={pde_system}
+
+# Multi-node with SLURM
+srun python3 train_inverse.py --config-name={pde_system} +trainer.num_nodes={num_nodes}
+# num_nodes = 1, 2, 4, etc.
+```
+
+### 🧪 Experiment Patterns Along Core Design Axes
+
+This section provides ready-to-run experiment templates organized by the core research dimensions of the benchmark. Each pattern includes concrete commands and parameter sweep recommendations.
+
+---
+
+#### 1️⃣ Training/Optimization Strategies
+
+Experiments exploring different supervision and optimization approaches for inverse problems.
+
+##### 1.1 Fully Data-Driven vs Physics-Informed Training
+
+```bash
+# Fully data-driven (no residual loss)
+python3 train_inverse.py --config-name={pde_system} \
+    loss.inverse_residual_loss_weight=0
+
+# Physics-informed with varying residual weights
+python3 train_inverse.py --config-name={pde_system} \
+    loss.inverse_residual_loss_weight={weight}
+# Recommended sweep: weight = 1.0, 0.1, 0.01, 0.001, 0.0001
+```
+
+This allows you to control the balance between data-driven supervision and physics-based regularization for parameter identification.
+
+##### 1.2 Test-Time Tailoring (TTT)
+
+At test time, given an observed PDE trajectory `u_{t-k}, ..., u_t`, the inverse model `f_θ` predicts parameters `φ̂ = f_θ(u_{t-k}, ..., u_t)`.  
+Test-Time Tailoring (TTT) adapts `f_θ` by minimizing a physics-based self-supervised loss derived from the PDE residual:
+
+`L_Tailor = ||F_{φ̂}(u_{t-k}, ..., u_t)||² + α * ( ||f_θ(u_{t-k}, ..., u_t) - f_{θ_frozen}(u_{t-k}, ..., u_t)||² / ||f_{θ_frozen}(u_{t-k}, ..., u_t)||² )`
+
+Here `F_{φ̂}` is a discrete approximation of the PDE operator, and `α` controls the strength of the *anchor loss* that stabilizes adaptation. Optimization is performed for a small number of gradient steps on `L_Tailor`, allowing the model to specialize to new or out-of-distribution parameter regimes at inference time.
+
+```bash
+# Basic TTT with pre-trained model
+python3 train_inverse.py --config-name={pde_system}_ttt \
+    inverse_model_wandb_run={project_id}/{project_name}/model-{model_id}:{version} \
+    tailor_anchor_loss_weight={alpha} \
+    num_tailoring_steps={steps} \
+    tailoring_optimizer_lr={lr}
+
+```
+
+---
+
+#### 2️⃣ Problem Representation and Inductive Bias
+
+Experiments exploring how to encode physical problems and what architectural inductive biases work best.
+
+##### 2.1 Conditioning Strategy: Derivatives vs Raw Solutions
+
+```bash
+# Derivative conditioning (spatial/temporal derivatives as input)
+python3 train_inverse.py --config-name={pde_system} \
+    model.model_config.paramnet.encoder.use_partials=True
+
+# Temporal conditioning (raw solution snapshots only)
+python3 train_inverse.py --config-name={pde_system} \
+    model.model_config.paramnet.encoder.use_partials=False
+```
+
+Derivative conditioning provides explicit gradient information from the frames.
+
+##### 2.2 Model Architecture: Inductive Biases
+
+```bash
+# Fourier Neural Operator (spectral bias)
+python3 train_inverse.py --config-name={pde_system} model=fno
+
+# ResNet (convolutional locality bias)
+python3 train_inverse.py --config-name={pde_system} model=resnet
+
+# scOT - Scalable Operator Transformer (attention-based)
+python3 train_inverse.py --config-name={pde_system} model=scot
+```
+
+##### 2.3 Temporal Conditioning Frames
+
+```bash
+# Fourier Neural Operator (spectral bias)
+python3 train_inverse.py --config-name={pde_system} n_past={num_frames}
+
+# num_frames=2,5,10,15,20
+```
+
+
+---
+
+#### 3️⃣ Scaling Experiments
+
+Experiments investigating how performance scales with model capacity, data quantity, and spatial resolution.
+
+##### 3.1 Model Capacity Scaling
+
+```bash
+# Small model: ~500k parameters
+python3 train_inverse.py --config-name={pde_system} model=fno_500k
+
+# Base model: ~5M parameters
+python3 train_inverse.py --config-name={pde_system} model=fno
+
+# Large model: ~50M parameters
+python3 train_inverse.py --config-name={pde_system} model=fno_50mil
+```
+
+
+##### 3.2 Data Quantity Scaling
+
+###### 3.2.1 Initial Condition Diversity Scaling
+```bash
+python3 train_inverse.py --config-name={pde_system} \
+    data.frac_ics_per_param={frac}
+# Recommended sweep: frac = 0.2, 0.35, 0.5, 0.75
+```
+
+Only `frac_ics_per_param` percent of initial trajectories per parameter will be sampled during training, allowing you to control the amount of initial condition diversity and study data efficiency across different initial states.
+
+###### 3.2.2 Parameter Space Coverage Scaling
+```bash
+python3 train_inverse.py --config-name={pde_system} \
+    data.frac_param_combinations={frac}
+# Recommended sweep: frac = 0.2, 0.35, 0.5, 0.75
+```
+
+Only `frac_param_combinations` percent of parameters from the train set will be sampled, allowing you to control parameter space coverage and understand how model performance scales with the diversity of parameter combinations in the training data.
+
+###### 3.2.3 Temporal Horizon Scaling
+```bash
+python3 train_inverse.py --config-name={pde_system} \
+    data.train_window_end_percent={train_end} \
+    data.test_window_start_percent={test_start}
+# Recommended sweeps:
+# train_end = 0.25, 0.5, 0.76, 1.0
+# test_start =  0.76
+```
+
+Only the first `train_window_end_percent` of trajectories are used for training, while the last `test_window_start_percent` are used for evaluation. This enables studies on temporal extrapolation and how much temporal dynamics are needed for accurate parameter identification.
+
+##### 3.3 Spatial Resolution Scaling
+
+```bash
+# High-resolution experiments with online downsampling
+python3 train_inverse.py --config-name={pde_system} \
+    high_resolution=True \
+    data.downsample_factor={factor} \
+    data.batch_size={batch_size}
+
+# Example configurations:
+# factor=1,   512×512 (full resolution)
+# factor=2,   256×256
+# factor=4,   128×128
+# factor=8,   64×64
+```
+
+The `HIGH_RESOLUTION_PDE_SPATIAL_SIZE` in `pdeinvbench/utils/types.py` defines the maximum resolution (typically 512×512), and the downsampling factor reduces from this maximum. These experiments help determine how resolution affects identifiability of parameters and whether models trained on low-resolution data can generalize to high-resolution inputs.
+
+## Testing
+
+The `tests/` directory contains validation scripts to verify the correctness of PDE residual computations and numerical implementations.
+
+### Test Structure
+
+- **`test_fluids.py`**: Validates turbulent flow and Navier-Stokes residual computations by comparing PyTorch implementations against NumPy reference implementations
+- **`fluids_numpy_reference.py`**: NumPy reference implementations for fluid dynamics operators (stream function, advection, Laplacian)
+- **`reaction-diffusion-residuals.py`**: Validates reaction-diffusion residual computations and generates visualization GIFs
+
+### Running Tests
+
+**Standard pytest (skips tests requiring external data):**
+```bash
+pytest tests/ -v
+```
+
+### Test Validation
+
+The validation tests verify:
+1. **Numerical accuracy**: Finite difference operators match reference implementations (error < 1e-3)
+2. **PDE residuals**: Ground-truth solutions produce near-zero residuals (typically < 1e-4)
+3. **Operator correctness**: Stream function, advection, Laplacian, and gradient computations
+4. **Batch independence**: No cross-contamination between batch elements
+
+### Data Requirements
+
+Some tests require external HDF5 datasets:
+- Tests automatically **skip** (not fail) when data is unavailable
+- Suitable for CI/CD environments without large datasets
+- For full validation, download datasets following the [Data Guide](DATA_GUIDE.md)
+
+### Visualization
+
+Residual validation scripts generate animated GIFs in `test-images/` showing:
+- Temporal evolution of PDE residuals
+- Spatial distribution of numerical errors
+- Threshold-based error highlighting
+
+
+## Shape-Checking
+
+This codebase uses [jaxtyping](https://github.com/google/jaxtyping) for runtime tensor shape validation, which helps catch dimension mismatches.
+
+**To disable shape checking for faster execution:**
+```bash
+# Disable for production runs
+export JAXTYPING_DISABLE=1
+python train_inverse.py --config-name=2dtf model=fno
+
+# Or inline
+JAXTYPING_DISABLE=1 python train_inverse.py --config-name=2dtf model=fno
+```
+
+## Adding a New Dataset
+
+To add a new PDE system to the benchmark, follow the guide in [Data Guide - Section 5: Adding a New Dataset](DATA_GUIDE.md#5-adding-a-new-dataset).
+
+## Adding a New Model
+
+To add a new encoder architecture (e.g., Transformer, U-Net), follow the guide in [Model Guide - Adding a New Model](MODEL_GUIDE.md#adding-a-new-model).

configs/1dkdv.yaml

@@ -0,0 +1,5 @@
+name: 1dkdv
+defaults:
+  - _self_
+  - base
+  - override system_params: 1dkdv

configs/1dkdv_ttt.yaml

@@ -0,0 +1,8 @@
+name: 1dkdv
+defaults:
+  - _self_
+  - ttt_base
+  - override system_params: 1dkdv
+
+inverse_model_wandb_run: ml-pdes/1dkdv_test_time_tuning/model-4j475b9v:v199
+# inverse_model_wandb_run: ml-pdes/time_logging_test/model-tw4k8e8h:best

configs/2ddf.yaml

@@ -0,0 +1,8 @@
+name: 2ddf 
+defaults:
+  - base
+  - _self_
+  - override callbacks: 2ddf
+  - override system_params: 2ddf
+
+n_past: 1

configs/2ddf_ttt.yaml

@@ -0,0 +1,9 @@
+name: 2ddf 
+defaults:
+  - ttt_base    # Load base first
+  - _self_      # Then override with this file's values
+  - override callbacks: 2ddf
+  - override system_params: 2ddf
+
+inverse_model_wandb_run: ml-pdes/2ddf_compilation_folded/model-r5fj8hr1:best
+n_past: 1

configs/2dns.yaml

@@ -0,0 +1,5 @@
+name: 2dns
+defaults:
+  - _self_
+  - base
+  - override system_params: 2dns

configs/2dns_ttt.yaml

@@ -0,0 +1,10 @@
+name: 2dns
+defaults:
+  - _self_
+  - ttt_base
+  - override system_params: 2dns
+
+
+test_run: true
+inverse_model_wandb_run: ml-pdes/tailoring_redone/model-wuhbdlqr:v200
+# inverse_model_wandb_run: ml-pdes/time_logging_test/model-8mwjk5v0:best

configs/2drddu.yaml

@@ -0,0 +1,7 @@
+name: 2drd
+defaults:
+  - _self_
+  - base
+  - override system_params: 2drddu
+
+# Note: params_to_predict is already set to ["Du"] in system_params/2drddu.yaml

configs/2drddu_ttt.yaml

@@ -0,0 +1,12 @@
+name: 2drd
+defaults:
+  - _self_
+  - ttt_base
+  - override system_params: 2drddu
+
+
+test_run: true
+inverse_model_wandb_run: ml-pdes/2drddu_compilation/model-lslyzo92:v184 # 100 % ics
+# inverse_model_wandb_run: ml-pdes/2drddu_compilation/model-jupsos6p:best # 20 % ics
+# inverse_model_wandb_run: ml-pdes/time_logging_test/model-71xuth62:best
+

configs/2drdk.yaml

@@ -0,0 +1,6 @@
+name: 2drd
+defaults:
+  - _self_
+  - base
+  - override system_params: 2drdk
+

configs/2drdk_ttt.yaml

@@ -0,0 +1,10 @@
+name: 2drd
+defaults:
+  - _self_
+  - ttt_base
+  - override system_params: 2drdk
+
+
+test_run: true
+inverse_model_wandb_run: ml-pdes/2drdk_compilation/model-30801ssy:v189
+# inverse_model_wandb_run: ml-pdes/time_logging_test/model-o2v1e8oa:best

configs/2dtf.yaml

@@ -0,0 +1,6 @@
+name: 2dtf
+defaults:
+  - _self_
+  - base
+  - override system_params: 2dtf
+

configs/2dtf_ttt.yaml

@@ -0,0 +1,11 @@
+name: 2dtf
+defaults:
+  - _self_
+  - ttt_base
+  - override system_params: 2dtf
+
+
+test_run: true
+# inverse_model_wandb_run: ml-pdes/2dtf_compilation/model-kjskfseu:v172
+inverse_model_wandb_run: ml-pdes/tailoring_redone/model-h6cc91c4:v182
+# inverse_model_wandb_run: ml-pdes/time_logging_test/model-irns4x30:best

configs/base.yaml

@@ -0,0 +1,19 @@
+name: base
+defaults:
+  - _self_
+  - callbacks: base
+  - model: fno
+  - lightning_module: base
+  - logging: base
+  - loss: relative
+  - optimizer: adam
+  - trainer: trainer
+  - lr_scheduler: cosine 
+  - system_params: Null
+  - data: base
+
+n_past: 2
+n_future: -1 #doesn't matter for inverse problems
+mode: "inverse"
+seed: 0
+high_resolution: false

configs/callbacks/2ddf.yaml

@@ -0,0 +1,9 @@
+- _target_: lightning.pytorch.callbacks.ModelCheckpoint # save model checkpoints
+  monitor: validation/loss
+  mode: min
+  save_last: True
+- _target_: lightning.pytorch.callbacks.LearningRateMonitor # log learning rate
+  logging_interval: epoch
+- _target_: pdeinvbench.lightning_modules.logging_callbacks.InverseErrorByTailoringStepCallback # log error by tailoring step
+- _target_: pdeinvbench.lightning_modules.logging_callbacks.PDEParamErrorTestTimeTailoringCallback
+- _target_: pdeinvbench.lightning_modules.logging_callbacks.PDEParamErrorPlottingCallback # stratify error by PDE parameter

configs/callbacks/base.yaml

@@ -0,0 +1,10 @@
+- _target_: pdeinvbench.lightning_modules.logging_callbacks.PDEParamErrorPlottingCallback # stratify error by PDE parameter
+- _target_: lightning.pytorch.callbacks.ModelCheckpoint # save model checkpoints
+  monitor: validation/loss
+  mode: min
+  save_last: True
+  save_top_k: 1
+- _target_: lightning.pytorch.callbacks.LearningRateMonitor # log learning rate
+  logging_interval: epoch
+- _target_: pdeinvbench.lightning_modules.logging_callbacks.InverseErrorByTailoringStepCallback # log error by tailoring step
+- _target_: pdeinvbench.lightning_modules.logging_callbacks.PDEParamErrorTestTimeTailoringCallback

configs/data/base.yaml

@@ -0,0 +1,112 @@
+# These will be overridden by child configs
+name: "placeholder_inverse"
+data_root: "placeholder_path"
+train_data_root: ${system_params.train_data_root}
+val_data_root: ${system_params.val_data_root}
+ood_data_root: ${system_params.ood_data_root}
+ood_data_root_extreme: ${system_params.ood_data_root_extreme}
+test_data_root: ${system_params.test_data_root}
+num_channels: ${system_params.num_channels}
+batch_size: 8
+dilation: 1
+cutoff_first_n_frames: ${system_params.cutoff_first_n_frames}
+frac_param_combinations: 1
+frac_ics_per_param: 1
+random_sample_param: True
+downsample_factor: 0
+every_nth_window: 10
+train_window_start_percent: 0
+train_window_end_percent: 1
+test_window_start_percent: 0
+test_window_end_percent: 1
+
+pde:
+  _target_: pdeinvbench.utils.types.PDE
+  value: ${system_params.pde_name}
+
+train_dataloader:
+  _target_: torch.utils.data.DataLoader
+  dataset:
+    _target_: pdeinvbench.data.PDE_MultiParam
+    data_root: ${data.train_data_root}
+    pde: ${data.pde}
+    n_past: ${n_past}
+    train: True
+    dilation: ${data.dilation}
+    cutoff_first_n_frames: ${data.cutoff_first_n_frames}
+    frac_param_combinations: ${data.frac_param_combinations}
+    frac_ics_per_param: ${data.frac_ics_per_param}
+    random_sample_param: ${data.random_sample_param}
+    downsample_factor: ${data.downsample_factor}
+    every_nth_window: ${data.every_nth_window}
+    window_start_percent: ${data.train_window_start_percent}
+    window_end_percent: ${data.train_window_end_percent}
+  batch_size: ${data.batch_size}
+  shuffle: True
+
+val_dataloader:
+  _target_: torch.utils.data.DataLoader
+  dataset:
+    _target_: pdeinvbench.data.PDE_MultiParam
+    data_root: ${data.val_data_root}
+    pde: ${data.pde}
+    n_past: ${n_past}
+    train: False
+    dilation: ${data.dilation}
+    cutoff_first_n_frames: ${data.cutoff_first_n_frames}
+    frac_param_combinations: ${data.frac_param_combinations}
+    frac_ics_per_param: ${data.frac_ics_per_param}
+    random_sample_param: ${data.random_sample_param}
+    downsample_factor: ${data.downsample_factor}
+    every_nth_window: ${data.every_nth_window}
+    window_start_percent: ${data.train_window_start_percent}
+    window_end_percent: ${data.train_window_end_percent}
+  batch_size: ${data.batch_size}
+  shuffle: False
+
+ood_dataloader:
+  _target_: torch.utils.data.DataLoader
+  dataset:
+    _target_: pdeinvbench.data.PDE_MultiParam
+    data_root: ${data.ood_data_root}
+    pde: ${data.pde}
+    n_past: ${n_past}
+    train: False
+    dilation: ${data.dilation}
+    cutoff_first_n_frames: ${data.cutoff_first_n_frames}
+    downsample_factor: ${data.downsample_factor}
+    every_nth_window: ${data.every_nth_window}
+  batch_size: ${data.batch_size}
+  shuffle: False
+
+ood_dataloader_extreme:
+  _target_: torch.utils.data.DataLoader
+  dataset:
+    _target_: pdeinvbench.data.PDE_MultiParam
+    data_root: ${data.ood_data_root_extreme}
+    pde: ${data.pde}
+    n_past: ${n_past}
+    train: False
+    dilation: ${data.dilation}
+    cutoff_first_n_frames: ${data.cutoff_first_n_frames}
+    downsample_factor: ${data.downsample_factor}
+    every_nth_window: ${data.every_nth_window}
+  batch_size: ${data.batch_size}
+  shuffle: False
+
+test_dataloader:
+  _target_: torch.utils.data.DataLoader
+  dataset:
+    _target_: pdeinvbench.data.PDE_MultiParam
+    data_root: ${data.test_data_root}
+    pde: ${data.pde}
+    n_past: ${n_past}
+    train: False
+    dilation: ${data.dilation}
+    cutoff_first_n_frames: ${data.cutoff_first_n_frames}
+    downsample_factor: ${data.downsample_factor}
+    every_nth_window: ${data.every_nth_window}
+    window_start_percent: ${data.test_window_start_percent}
+    window_end_percent: ${data.test_window_end_percent}
+  batch_size: ${data.batch_size}
+  shuffle: False

configs/lightning_module/base.yaml

@@ -0,0 +1,10 @@
+_target_: pdeinvbench.lightning_modules.InverseModule
+pde: ${data.pde}
+n_past: ${n_past}
+batch_size: ${data.batch_size}
+use_partials: ${model.model_config.paramnet.encoder.use_partials}
+params_to_predict: ${model.model_config.paramnet.params_to_predict}
+param_loss_metric: ${loss.param_loss_metric}
+inverse_residual_loss_weight: ${loss.inverse_residual_loss_weight}
+inverse_param_loss_weight: ${loss.inverse_param_loss_weight}
+residual_filter: False

configs/lightning_module/ttt.yaml

@@ -0,0 +1,8 @@
+defaults:
+  - base
+
+_target_: pdeinvbench.lightning_modules.InverseTestTimeTailoringModule
+num_tailoring_steps: ${num_tailoring_steps}
+tailor_per_batch: ${tailor_per_batch}
+tailor_anchor_loss_weight: ${tailor_anchor_loss_weight}
+tailor_residual_loss_weight: ${tailor_residual_loss_weight}

configs/logging/base.yaml

@@ -0,0 +1,4 @@
+_target_: pdeinvbench.utils.logging_utils.CustomWandbLogger
+entity: "ml-pdes"
+save_dir: "logs"
+project: ${data.name}

configs/loss/mse.yaml

@@ -0,0 +1,5 @@
+param_loss_metric:
+  _target_: pdeinvbench.utils.types.ParamMetrics
+  value: "Mean Squared Error"
+inverse_residual_loss_weight: 0
+inverse_param_loss_weight: 1

configs/loss/relative.yaml

@@ -0,0 +1,5 @@
+param_loss_metric:
+  _target_: pdeinvbench.utils.types.ParamMetrics
+  value: "Relative Error"
+inverse_residual_loss_weight: 0
+inverse_param_loss_weight: 1

configs/lr_scheduler/cosine.yaml

@@ -0,0 +1,2 @@
+_target_: torch.optim.lr_scheduler.CosineAnnealingLR
+T_max: ${trainer.max_epochs}

configs/model/fno.yaml

@@ -0,0 +1,36 @@
+# Shared FNO model configuration
+# Interpolates ALL parameters from system_params
+name: "${system_params.name}_fno"
+dropout: ${system_params.fno_dropout}
+hidden_channels: ${system_params.fno_hidden_channels}
+encoder_layers: ${system_params.fno_encoder_layers}
+downsampler_layers: ${system_params.fno_downsampler_layers}
+mlp_layers: ${system_params.fno_mlp_layers}
+
+model_config:
+  _target_: pdeinvbench.models.inverse_model.InverseModel
+  paramnet: 
+    _target_: pdeinvbench.models.inverse_model.ParameterNet
+    pde: ${data.pde}
+    normalize: ${system_params.normalize}
+    logspace: ${system_params.logspace}
+    params_to_predict: ${system_params.params_to_predict}
+    mlp_type: ${system_params.mlp_type}
+    encoder:
+      _target_: pdeinvbench.models.encoder.FNOEncoder
+      n_modes: ${system_params.fno_n_modes}
+      n_past: ${n_past}
+      n_future: ${n_future}
+      n_layers: ${model.encoder_layers}
+      data_channels: ${data.num_channels}
+      hidden_channels: ${model.hidden_channels}
+      use_partials: True
+      pde: ${data.pde}
+      batch_size: ${data.batch_size}
+    downsampler: ${system_params.fno_downsampler}
+    mlp_hidden_size: ${model.hidden_channels}
+    mlp_layers: ${model.mlp_layers}
+    mlp_activation: "relu"
+    mlp_dropout: ${model.dropout}
+    downsample_factor: ${data.downsample_factor}
+

configs/model/fno_50k.yaml

@@ -0,0 +1,9 @@
+# Small FNO variant (500k params)
+# Inherits structure from fno.yaml, only overrides size parameters
+defaults:
+  - fno
+
+name: "${system_params.name}_fno_50k"
+hidden_channels: ${system_params.fno_hidden_channels_50k}
+encoder_layers: ${system_params.fno_encoder_layers_50k}
+

configs/model/fno_50mil.yaml

@@ -0,0 +1,9 @@
+# Large FNO variant (50 million params)
+# Inherits structure from fno.yaml, only overrides size parameters
+defaults:
+  - fno
+
+name: "${system_params.name}_fno_50mil"
+hidden_channels: ${system_params.fno_hidden_channels_50mil}
+encoder_layers: ${system_params.fno_encoder_layers_50mil}
+

configs/model/resnet.yaml

@@ -0,0 +1,35 @@
+# Shared ResNet model configuration
+# Interpolates ALL parameters from system_params
+name: "${system_params.name}_resnet"
+dropout: ${system_params.resnet_dropout}
+hidden_channels: ${system_params.resnet_hidden_channels}
+encoder_layers: ${system_params.resnet_encoder_layers}
+downsampler_layers: ${system_params.resnet_downsampler_layers}
+mlp_layers: ${system_params.resnet_mlp_layers}
+
+model_config:
+  _target_: pdeinvbench.models.inverse_model.InverseModel
+  paramnet: 
+    _target_: pdeinvbench.models.inverse_model.ParameterNet
+    pde: ${data.pde}
+    normalize: ${system_params.normalize}
+    logspace: ${system_params.logspace}
+    params_to_predict: ${system_params.params_to_predict}
+    mlp_type: ${system_params.mlp_type}
+    encoder:
+      _target_: pdeinvbench.models.encoder.ResnetEncoder
+      n_past: ${n_past}
+      n_future: ${n_future}
+      n_layers: ${model.encoder_layers}
+      data_channels: ${data.num_channels}
+      hidden_channels: ${model.hidden_channels}
+      use_partials: True
+      pde: ${data.pde}
+      batch_size: ${data.batch_size}
+    downsampler: ${system_params.resnet_downsampler}
+    mlp_hidden_size: ${model.hidden_channels}
+    mlp_layers: ${model.mlp_layers}
+    mlp_activation: "relu"
+    mlp_dropout: ${model.dropout}
+    downsample_factor: ${data.downsample_factor}
+

configs/model/scot.yaml

@@ -0,0 +1,41 @@
+# Shared ScOT model configuration
+# Interpolates ALL parameters from system_params
+name: "${system_params.name}_scot"
+dropout: ${system_params.scot_dropout}
+hidden_channels: ${system_params.scot_hidden_channels}
+encoder_layers: ${system_params.scot_encoder_layers}
+downsampler_layers: ${system_params.scot_downsampler_layers}
+mlp_layers: ${system_params.scot_mlp_layers}
+
+model_config:
+  _target_: pdeinvbench.models.inverse_model.InverseModel
+  paramnet: 
+    _target_: pdeinvbench.models.inverse_model.ParameterNet
+    pde: ${data.pde}
+    normalize: ${system_params.normalize}
+    logspace: ${system_params.logspace}
+    params_to_predict: ${system_params.params_to_predict}
+    mlp_type: ${system_params.mlp_type}
+    encoder:
+      _target_: pdeinvbench.models.encoder.ScOTEncoder
+      embed_dim: ${system_params.scot_embed_dim}
+      n_layers: ${model.encoder_layers}
+      hidden_size: ${system_params.scot_hidden_size}
+      patch_size: ${system_params.scot_patch_size}
+      num_heads: ${system_params.scot_num_heads}
+      skip_connections: ${system_params.scot_skip_connections}
+      depths: ${system_params.scot_depths}
+      n_past: ${n_past}
+      n_future: ${n_future}
+      use_partials: True
+      data_channels: ${data.num_channels}
+      pde: ${data.pde}
+      batch_size: ${data.batch_size}
+    downsampler: ${system_params.scot_downsampler}
+    mlp_hidden_size: ${system_params.scot_mlp_hidden_size}
+    mlp_layers: ${model.mlp_layers}
+    mlp_activation: "relu"
+    mlp_dropout: ${model.dropout}
+    condition_on_time: ${system_params.scot_condition_on_time}
+    downsample_factor: ${data.downsample_factor}
+

configs/optimizer/adam.yaml

@@ -0,0 +1,2 @@
+_target_: torch.optim.Adam
+lr: 0.0001

configs/system_params/1dkdv.yaml

@@ -0,0 +1,17 @@
+# ============================================
+# 1DKDV SYSTEM PARAMETERS
+# ============================================
+defaults:
+  - base
+
+# ============ Data Parameters ============
+name: "1dkdv_inverse"
+data_root: "/data/shared/meta-pde/folded_data/kdv/fold_2"
+pde_name: "Korteweg-de Vries 1D"
+num_channels: 1
+cutoff_first_n_frames: 0
+
+# ============ Model Parameters ============
+downsampler_input_dim: 1  # 1D system
+params_to_predict: ["delta"]
+normalize: True

configs/system_params/2ddf.yaml

@@ -0,0 +1,27 @@
+# ============================================
+# 2DDF SYSTEM PARAMETERS
+# ============================================
+defaults:
+  - base
+
+# ============ Data Parameters ============
+name: "2ddf_inverse"
+data_root: "/data/shared/meta-pde/darcy-flow/r241_folded/"
+pde_name: "Darcy Flow 2D"
+num_channels: 1
+cutoff_first_n_frames: 0
+
+# ============ Model Parameters ============
+params_to_predict: ["coeff"]
+normalize: False
+mlp_type: "conv"  # Special: 2ddf uses conv MLP
+
+# Override downsamplers: 2ddf uses IdentityMap instead of ConvDownsampler
+fno_downsampler:
+  _target_: pdeinvbench.models.downsampler.IdentityMap
+
+resnet_downsampler:
+  _target_: pdeinvbench.models.downsampler.IdentityMap
+
+scot_downsampler:
+  _target_: pdeinvbench.models.downsampler.IdentityMap

configs/system_params/2dns.yaml

@@ -0,0 +1,16 @@
+# ============================================
+# 2DNS SYSTEM PARAMETERS
+# ============================================
+defaults:
+  - base
+
+# ============ Data Parameters ============
+name: "2dns_inverse"
+data_root: "/data/divyam123/meta-pde/sampled_parameters_split/navierstokes64"
+pde_name: "Navier Stokes 2D"
+num_channels: 1
+cutoff_first_n_frames: 0
+
+# ============ Model Parameters ============
+params_to_predict: ["re"]
+normalize: False

configs/system_params/2drddu.yaml

@@ -0,0 +1,9 @@
+# ============================================
+# 2DRD-DU SYSTEM PARAMETERS
+# ============================================
+defaults:
+  - 2drdk
+data_root: "/data/shared/meta-pde/folded_data/reaction-diffusion-2d/Du_fold_2"
+
+# ============ Model Parameters ============
+params_to_predict: ["Du"]

configs/system_params/2drdk.yaml

@@ -0,0 +1,18 @@
+# ============================================
+# 2DRD-K SYSTEM PARAMETERS
+# ============================================
+defaults:
+  - base
+
+# ============ Data Parameters ============
+name: "2drdk_inverse"
+data_root: "/data/shared/meta-pde/folded_data/reaction-diffusion-2d/k_fold_2"
+pde_name: "Reaction Diffusion 2D"
+num_channels: 2
+cutoff_first_n_frames: 2
+# Special override for corner extreme OOD
+ood_data_root_extreme: ${system_params.data_root}/out_of_distribution_corner_extreme
+
+# ============ Model Parameters ============
+params_to_predict: ["k"]
+normalize: False

configs/system_params/2dtf.yaml

@@ -0,0 +1,16 @@
+# ============================================
+# 2DTF SYSTEM PARAMETERS
+# ============================================
+defaults:
+  - base
+
+# ============ Data Parameters ============
+name: "2dtf_inverse"
+data_root: "/data/shared/meta-pde/folded_data/turbulent-flow-2d/fold_2"
+pde_name: "Turbulent Flow 2D"
+num_channels: 1
+cutoff_first_n_frames: 0
+
+# ============ Model Parameters ============
+params_to_predict: ["nu"]
+normalize: True

configs/system_params/base.yaml

@@ -0,0 +1,91 @@
+# Base system parameters
+# Defines common structure and defaults for BOTH data AND model
+# Each system inherits this and overrides specific values
+
+# ============ Data Parameters ============
+name: "placeholder_inverse"
+data_root: "placeholder_path"
+train_data_root: ${system_params.data_root}/train
+val_data_root: ${system_params.data_root}/validation
+ood_data_root: ${system_params.data_root}/out_of_distribution
+ood_data_root_extreme: ${system_params.data_root}/out_of_distribution_extreme
+test_data_root: ${system_params.data_root}/test
+pde_name: "placeholder_pde"
+num_channels: 1
+cutoff_first_n_frames: 0
+
+# ============ Model - System-Specific Parameters ============
+params_to_predict: []
+normalize: False
+logspace: False
+mlp_type: "mlp"  # Default to standard MLP (2ddf overrides to "conv")
+downsampler_input_dim: 2  # 1 for 1D systems, 2 for 2D systems
+
+# ============ FNO Architecture ============
+fno_hidden_channels: 64
+fno_encoder_layers: 4
+fno_downsampler_layers: 4
+fno_dropout: 0
+fno_mlp_layers: 1
+fno_n_modes: 16
+
+fno_hidden_channels_50k: 16
+fno_encoder_layers_50k: 6
+
+fno_hidden_channels_50mil: 200
+fno_encoder_layers_50mil: 4
+
+fno_downsampler:
+  _target_: pdeinvbench.models.downsampler.ConvDownsampler
+  input_dimension: ${system_params.downsampler_input_dim}
+  n_layers: ${model.downsampler_layers}
+  in_channels: ${model.hidden_channels}
+  out_channels: ${model.hidden_channels}
+  kernel_size: 3
+  stride: 1
+  padding: 2
+  dropout: ${model.dropout}
+
+# ============ ResNet Architecture ============
+resnet_hidden_channels: 128
+resnet_encoder_layers: 13
+resnet_downsampler_layers: 4
+resnet_dropout: 0
+resnet_mlp_layers: 1
+
+resnet_downsampler:
+  _target_: pdeinvbench.models.downsampler.ConvDownsampler
+  input_dimension: ${system_params.downsampler_input_dim}
+  n_layers: ${model.downsampler_layers}
+  in_channels: ${model.hidden_channels}
+  out_channels: ${model.hidden_channels}
+  kernel_size: 3
+  stride: 1
+  padding: 2
+  dropout: ${model.dropout}
+
+# ============ ScOT Architecture ============
+scot_hidden_channels: 32
+scot_encoder_layers: 4
+scot_downsampler_layers: 4
+scot_dropout: 0
+scot_mlp_layers: 1
+scot_mlp_hidden_size: 32
+scot_condition_on_time: False
+scot_embed_dim: 36
+scot_hidden_size: 32
+scot_patch_size: 4
+scot_num_heads: [3, 6, 12, 24]
+scot_skip_connections: [2, 2, 2, 2]
+scot_depths: [1, 1, 1, 1]
+
+scot_downsampler:
+  _target_: pdeinvbench.models.downsampler.ConvDownsampler
+  input_dimension: ${system_params.downsampler_input_dim}
+  n_layers: ${model.downsampler_layers}
+  in_channels: ${model.hidden_channels}
+  out_channels: ${model.hidden_channels}
+  kernel_size: 3
+  stride: 1
+  padding: 2
+  dropout: ${model.dropout}

configs/tailoring_optimizer/adam.yaml

@@ -0,0 +1,2 @@
+_target_: torch.optim.Adam
+lr: ${tailoring_optimizer_lr}

configs/tailoring_optimizer/sgd.yaml

@@ -0,0 +1,2 @@
+_target_: torch.optim.SGD
+lr: ${tailoring_optimizer_lr}

configs/trainer/trainer.yaml

@@ -0,0 +1,4 @@
+_target_: lightning.Trainer
+max_epochs: 200
+log_every_n_steps: 10
+callbacks: ${callbacks}

configs/ttt_base.yaml

@@ -0,0 +1,14 @@
+name: ttt_base
+defaults:
+  - _self_
+  - base
+  - tailoring_optimizer: adam
+  - override lightning_module: ttt
+
+test_run: true
+
+tailor_anchor_loss_weight: 1
+tailor_residual_loss_weight: 1
+tailor_per_batch: True
+num_tailoring_steps: 50
+tailoring_optimizer_lr: 0.00001

environment.yml

@@ -0,0 +1,144 @@
+name: inv-env-tmp
+channels:
+  - defaults
+  - conda-forge
+dependencies:
+  - _libgcc_mutex=0.1=main
+  - _openmp_mutex=5.1=1_gnu
+  - bzip2=1.0.8=h5eee18b_6
+  - ca-certificates=2025.2.25=h06a4308_0
+  - ld_impl_linux-64=2.40=h12ee557_0
+  - libffi=3.4.4=h6a678d5_1
+  - libgcc-ng=11.2.0=h1234567_1
+  - libgomp=11.2.0=h1234567_1
+  - libstdcxx-ng=11.2.0=h1234567_1
+  - libuuid=1.41.5=h5eee18b_0
+  - ncurses=6.4=h6a678d5_0
+  - openssl=1.1.1w=h7f8727e_0
+  - pip=25.1=pyhc872135_2
+  - python=3.11.0=h7a1cb2a_3
+  - readline=8.2=h5eee18b_0
+  - setuptools=78.1.1=py311h06a4308_0
+  - sqlite=3.45.3=h5eee18b_0
+  - tk=8.6.14=h39e8969_0
+  - wheel=0.45.1=py311h06a4308_0
+  - xz=5.6.4=h5eee18b_1
+  - zlib=1.2.13=h5eee18b_1
+  - pip:
+      - accelerate==1.7.0
+      - aiohappyeyeballs==2.6.1
+      - aiohttp==3.11.18
+      - aiosignal==1.3.2
+      - annotated-types==0.7.0
+      - antlr4-python3-runtime==4.9.3
+      - attrs==25.3.0
+      - black==25.1.0
+      - certifi==2025.4.26
+      - charset-normalizer==3.4.2
+      - click==8.2.0
+      - configmypy==0.2.0
+      - contourpy==1.3.2
+      - crc32c==2.7.1
+      - cycler==0.12.1
+      - decorator==5.2.1
+      - docker-pycreds==0.4.0
+      - donfig==0.8.1.post1
+      - filelock==3.18.0
+      - fonttools==4.58.0
+      - frozenlist==1.6.0
+      - fsspec==2025.3.2
+      - gitdb==4.0.12
+      - gitpython==3.1.44
+      - h5py==3.13.0
+      - huggingface-hub==0.31.2
+      - hydra-core==1.3.2
+      - idna==3.10
+      - imageio==2.37.0
+      - imageio-ffmpeg==0.6.0
+      - iniconfig==2.1.0
+      - jaxtyping==0.3.2
+      - jinja2==3.1.6
+      - kiwisolver==1.4.8
+      - lightning==2.5.1.post0
+      - lightning-utilities==0.14.3
+      - markupsafe==3.0.2
+      - matplotlib==3.10.3
+      - moviepy==2.1.2
+      - mpmath==1.3.0
+      - multidict==6.4.3
+      - mypy-extensions==1.1.0
+      - narwhals==1.39.1
+      - networkx==3.4.2
+      - neuraloperator==0.3.0
+      - numcodecs==0.16.0
+      - numpy==2.2.5
+      - nvidia-cublas-cu12==12.6.4.1
+      - nvidia-cuda-cupti-cu12==12.6.80
+      - nvidia-cuda-nvrtc-cu12==12.6.77
+      - nvidia-cuda-runtime-cu12==12.6.77
+      - nvidia-cudnn-cu12==9.5.1.17
+      - nvidia-cufft-cu12==11.3.0.4
+      - nvidia-cufile-cu12==1.11.1.6
+      - nvidia-curand-cu12==10.3.7.77
+      - nvidia-cusolver-cu12==11.7.1.2
+      - nvidia-cusparse-cu12==12.5.4.2
+      - nvidia-cusparselt-cu12==0.6.3
+      - nvidia-nccl-cu12==2.26.2
+      - nvidia-nvjitlink-cu12==12.6.85
+      - nvidia-nvtx-cu12==12.6.77
+      - omegaconf==2.3.0
+      - opt-einsum==3.4.0
+      - packaging==24.2
+      - pandas==2.2.3
+      - pathspec==0.12.1
+      - pillow==10.4.0
+      - platformdirs==4.3.8
+      - plotly==6.1.0
+      - pluggy==1.6.0
+      - proglog==0.1.12
+      - propcache==0.3.1
+      - protobuf==6.31.0
+      - psutil==7.0.0
+      - pydantic==2.11.4
+      - pydantic-core==2.33.2
+      - pyparsing==3.2.3
+      - pytest==8.3.5
+      - pytest-mock==3.14.0
+      - python-dateutil==2.9.0.post0
+      - python-dotenv==1.1.0
+      - pytorch-lightning==2.5.1.post0
+      - pytz==2025.2
+      - pyyaml==6.0.2
+      - regex==2024.11.6
+      - requests==2.32.3
+      - ruamel-yaml==0.18.10
+      - ruamel-yaml-clib==0.2.12
+      - safetensors==0.5.3
+      - scipy==1.15.3
+      - scoringrules==0.7.1
+      - scot==1.0.0
+      - sentry-sdk==2.28.0
+      - setproctitle==1.3.6
+      - six==1.17.0
+      - smmap==5.0.2
+      - sympy==1.14.0
+      - tensorly==0.9.0
+      - tensorly-torch==0.5.0
+      - tokenizers==0.21.1
+      - torch==2.7.0
+      - torch-harmonics==0.7.3
+      - torchmetrics==1.7.1
+      - torchvision==0.22.0
+      - tqdm==4.67.1
+      - transformers==4.51.3
+      - triton==3.3.0
+      - typeguard==2.13.3
+      - typing-extensions==4.13.2
+      - typing-inspection==0.4.0
+      - tzdata==2025.2
+      - urllib3==2.4.0
+      - wadler-lindig==0.1.6
+      - wandb==0.19.11
+      - yarl==1.20.0
+      - zarr==3.0.7
+prefix: /home/divyam123/miniconda3/envs/inv-env-tmp

fluid_stats.py

@@ -0,0 +1,418 @@
+#!/usr/bin/env python3
+"""
+Compute energy spectra from vorticity field data.
+
+This script loads vorticity trajectory data from a .npy file and computes
+the azimuthally averaged energy spectrum E(k). It outputs both the spectrum
+data as a .npz file and a visualization plot as a .png file.
+
+To run direct numerical simulations and get fluid fields, please use Jax-CFD: https://github.com/google/jax-cfd
+Commit hash we used: 0c17e3855702f884265b97bd6ff0793c34f3155e
+
+Usage:
+    uv run python fluid_stats.py path/to/vorticity.npy --out_dir results/
+"""
+
+import argparse
+import logging
+import os
+from functools import partial
+
+import jax
+import jax.numpy as jnp
+import matplotlib.pyplot as plt
+import numpy as np
+from jax import jit, vmap
+from tqdm import tqdm
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S",
+)
+logger = logging.getLogger(__name__)
+
+
+# =============================================================================
+# Core computation functions
+# =============================================================================
+
+
+@jit
+def vorticity_to_velocity(vorticity):
+    """
+    Convert vorticity to velocity components using the streamfunction.
+
+    Solves the Poisson equation in Fourier space: psi_hat = -vorticity_hat / k^2
+    Then computes velocity from streamfunction: u_x = -d(psi)/dy, u_y = d(psi)/dx
+
+    Parameters
+    ----------
+    vorticity : jnp.ndarray, shape (X, Y)
+        2D vorticity field on a square grid.
+
+    Returns
+    -------
+    u_x : jnp.ndarray, shape (X, Y)
+        x-component of velocity.
+    u_y : jnp.ndarray, shape (X, Y)
+        y-component of velocity.
+    """
+    N = vorticity.shape[0]
+
+    # Compute streamfunction from vorticity using Poisson equation
+    # In Fourier space: psi_hat = -vorticity_hat / k^2
+    vort_hat = jnp.fft.fft2(vorticity)
+
+    # Create wavenumber arrays
+    kx = jnp.fft.fftfreq(N, d=1.0) * 2 * jnp.pi
+    ky = jnp.fft.fftfreq(N, d=1.0) * 2 * jnp.pi
+    KX, KY = jnp.meshgrid(kx, ky, indexing="ij")
+    K2 = KX**2 + KY**2
+
+    # Avoid division by zero at k=0
+    K2 = K2.at[0, 0].set(1.0)
+    psi_hat = -vort_hat / K2
+    psi_hat = psi_hat.at[0, 0].set(0.0)  # Set mean streamfunction to zero
+
+    # Compute velocity components from streamfunction
+    # u_x = -d(psi)/dy, u_y = d(psi)/dx
+    u_x_hat = -1j * KY * psi_hat
+    u_y_hat = 1j * KX * psi_hat
+
+    u_x = jnp.real(jnp.fft.ifft2(u_x_hat))
+    u_y = jnp.real(jnp.fft.ifft2(u_y_hat))
+
+    return u_x, u_y
+
+
+@partial(jit, static_argnames=["k_max"])
+def energy_spectrum_single(u_x, u_y, k_max=None):
+    """
+    Compute azimuthally averaged energy spectrum E(k) for a single velocity field.
+
+    The energy spectrum is computed by binning the 2D Fourier-transformed
+    velocity field by wavenumber magnitude |k|.
+
+    Parameters
+    ----------
+    u_x : jnp.ndarray, shape (X, Y)
+        x-component of velocity.
+    u_y : jnp.ndarray, shape (X, Y)
+        y-component of velocity.
+    k_max : int, optional
+        Maximum wavenumber to compute. If None, uses N//3 (2/3 dealiasing rule).
+
+    Returns
+    -------
+    E : jnp.ndarray, shape (k_max+1,)
+        Energy spectrum E(k) for k = 0, 1, ..., k_max.
+    """
+    N = u_x.shape[0]
+
+    # FFT, shifted so k=0 is at centre
+    Ux = jnp.fft.fftshift(jnp.fft.fft2(u_x))
+    Ux = Ux / (N**2)
+    Uy = jnp.fft.fftshift(jnp.fft.fft2(u_y))
+    Uy = Uy / (N**2)
+
+    # Integer wave numbers
+    kx = jnp.fft.fftshift(jnp.fft.fftfreq(N)) * N
+    ky = kx
+    KX, KY = jnp.meshgrid(kx, ky)
+    K = jnp.hypot(KX, KY).astype(jnp.int32)
+
+    if k_max is None:  # Nyquist under 2/3 de-alias
+        k_max = N // 3
+
+    # Vectorized computation of energy spectrum
+    def compute_E_k(k):
+        mask = K == k
+        return 0.5 * jnp.sum(jnp.abs(Ux) ** 2 * mask + jnp.abs(Uy) ** 2 * mask)
+
+    k_vals = jnp.arange(k_max + 1)
+    E = vmap(compute_E_k)(k_vals)
+
+    return E
+
+
+@partial(jit, static_argnames=["k_max"])
+def energy_spectrum_from_vorticity(vorticity, k_max=None):
+    """
+    Compute energy spectrum from vorticity field using vmap.
+
+    Suitable for moderate resolution fields (up to ~1024x1024).
+    For larger resolutions, use energy_spectrum_from_vorticity_lax_map.
+
+    Parameters
+    ----------
+    vorticity : jnp.ndarray, shape (T, X, Y)
+        Vorticity field over T time steps on an X x Y grid.
+    k_max : int, optional
+        Maximum wavenumber. If None, uses N//3 (2/3 dealiasing rule).
+
+    Returns
+    -------
+    E : jnp.ndarray, shape (T, k_max+1)
+        Energy spectrum for each time step.
+    """
+    N = vorticity.shape[1]
+
+    if k_max is None:
+        k_max = N // 3
+
+    def process_timestep(vort_t):
+        u_x, u_y = vorticity_to_velocity(vort_t)
+        return energy_spectrum_single(u_x, u_y, k_max)
+
+    # Vectorize over time dimension
+    E = vmap(process_timestep)(vorticity)
+
+    return E
+
+
+@partial(jit, static_argnames=["k_max", "batch_size"])
+def energy_spectrum_from_vorticity_lax_map(vorticity, k_max=None, batch_size=16):
+    """
+    Compute energy spectrum from vorticity field using jax.lax.map.
+
+    Memory-efficient version suitable for high resolution fields (>1024x1024).
+    Processes timesteps sequentially to reduce memory footprint.
+
+    Parameters
+    ----------
+    vorticity : jnp.ndarray, shape (T, X, Y)
+        Vorticity field over T time steps on an X x Y grid.
+    k_max : int, optional
+        Maximum wavenumber. If None, uses N//3 (2/3 dealiasing rule).
+    batch_size : int, optional
+        Batch size for lax.map processing. Default is 16.
+
+    Returns
+    -------
+    E : jnp.ndarray, shape (T, k_max+1)
+        Energy spectrum for each time step.
+    """
+    N = vorticity.shape[1]
+
+    if k_max is None:
+        k_max = N // 3
+
+    def process_timestep(vort_t):
+        u_x, u_y = vorticity_to_velocity(vort_t)
+        return energy_spectrum_single(u_x, u_y, k_max)
+
+    # Use lax.map instead of vmap for memory efficiency
+    E = jax.lax.map(process_timestep, vorticity, batch_size=batch_size)
+
+    return E
+
+
+# =============================================================================
+# Main script
+# =============================================================================
+
+
+def parse_args():
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(
+        description=(
+            "Compute energy spectra from 2D vorticity trajectory data. "
+            "Loads vorticity fields from a .npy file, computes the azimuthally "
+            "averaged energy spectrum E(k), and saves both the spectrum data "
+            "and a visualization plot."
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+    uv run python fluid_stats.py simulation.npy
+    uv run python fluid_stats.py data/vorticity.npy --out_dir results/
+
+Input format:
+    The input .npy file should contain a 4D array with shape (batch, time, X, Y)
+    where batch is the number of independent trajectories, time is the number
+    of snapshots, and X, Y are the spatial grid dimensions.
+        """,
+    )
+
+    parser.add_argument(
+        "input_file",
+        type=str,
+        help=(
+            "Path to the input .npy file containing vorticity data. "
+            "Expected shape: (batch, time, X, Y) where X and Y are the "
+            "spatial grid dimensions (must be square, i.e., X == Y)."
+        ),
+    )
+
+    parser.add_argument(
+        "--out_dir",
+        type=str,
+        default=".",
+        help=(
+            "Directory to save output files. Will be created if it does not "
+            "exist. Output files are named based on the input filename. "
+            "Default: current directory."
+        ),
+    )
+
+    return parser.parse_args()
+
+
+def main():
+    """Main entry point for energy spectrum computation."""
+    args = parse_args()
+
+    # Setup
+    logger.info("JAX devices: %s", jax.devices())
+
+    # Validate input file
+    if not os.path.exists(args.input_file):
+        logger.error("Input file not found: %s", args.input_file)
+        raise FileNotFoundError(f"Input file not found: {args.input_file}")
+
+    if not args.input_file.endswith(".npy"):
+        logger.warning(
+            "Input file does not have .npy extension: %s", args.input_file
+        )
+
+    # Create output directory
+    os.makedirs(args.out_dir, exist_ok=True)
+
+    # Generate output filenames from input filename
+    input_basename = os.path.splitext(os.path.basename(args.input_file))[0]
+    data_filename = f"{input_basename}_spectrum_data.npz"
+    plot_filename = f"{input_basename}_spectrum.png"
+    data_path = os.path.join(args.out_dir, data_filename)
+    plot_path = os.path.join(args.out_dir, plot_filename)
+
+    # Load data
+    logger.info("Loading data from: %s", args.input_file)
+    field = np.load(args.input_file)
+    logger.info("Loaded field with shape: %s", field.shape)
+
+    # Validate shape
+    if field.ndim != 4:
+        logger.error(
+            "Expected 4D array (batch, time, X, Y), got %dD array", field.ndim
+        )
+        raise ValueError(
+            f"Expected 4D array (batch, time, X, Y), got {field.ndim}D array"
+        )
+
+    batch_size, time_steps, height, width = field.shape
+    if height != width:
+        logger.error(
+            "Expected square spatial grid (X == Y), got %d x %d", height, width
+        )
+        raise ValueError(
+            f"Expected square spatial grid (X == Y), got {height} x {width}"
+        )
+
+    resolution = height
+    k_max = resolution // 3
+    logger.info(
+        "Processing %d trajectories with %d timesteps at %dx%d resolution",
+        batch_size,
+        time_steps,
+        resolution,
+        resolution,
+    )
+    logger.info("Maximum wavenumber (k_max): %d", k_max)
+
+    # Compute energy spectrum
+    logger.info("Computing energy spectra...")
+    spectra_list = []
+
+    for i in tqdm(range(batch_size), desc="Computing spectra"):
+        if resolution > 1024:
+            # Use memory-efficient lax.map for large resolutions
+            single_spectrum = energy_spectrum_from_vorticity_lax_map(
+                field[i], k_max
+            )
+        else:
+            # Use vmap for moderate resolutions
+            single_spectrum = energy_spectrum_from_vorticity(field[i], k_max)
+        spectra_list.append(single_spectrum)
+
+    # Stack all spectra
+    all_spectra = jnp.stack(spectra_list)
+    logger.info("All spectra shape: %s", all_spectra.shape)
+
+    # Compute mean spectrum (over batch and time)
+    mean_spectrum = all_spectra.reshape(-1, all_spectra.shape[-1]).mean(axis=0)
+    logger.info("Mean spectrum shape: %s", mean_spectrum.shape)
+
+    # Save spectrum data
+    logger.info("Saving spectrum data to: %s", data_path)
+    np.savez_compressed(
+        data_path,
+        mean_spectrum=np.array(mean_spectrum),
+        all_spectra=np.array(all_spectra),
+        k_values=np.arange(len(mean_spectrum)),
+        resolution=resolution,
+        batch_size=batch_size,
+        time_steps=time_steps,
+    )
+
+    # Generate plot
+    logger.info("Generating energy spectrum plot...")
+    plt.figure(figsize=(10, 6))
+
+    # Plot mean spectrum (skip k=0)
+    offset = 1
+    spectrum = mean_spectrum[offset:]
+    k_values = np.arange(offset, len(mean_spectrum))
+    plt.loglog(k_values, spectrum, "b-", linewidth=2, label="Mean spectrum")
+
+    # Add k^{-5/3} reference line (Kolmogorov scaling for 3D turbulence)
+    # and k^{-3} reference line (enstrophy cascade in 2D turbulence)
+    k_match = min(10, len(spectrum) // 3)
+    if k_match > 0:
+        ref_value = float(spectrum[k_match - 1])
+
+        # k^{-3} line (2D enstrophy cascade)
+        scaling_k3 = ref_value * (k_match**3)
+        k_theory = np.logspace(0, np.log10(len(mean_spectrum)), 100)
+        power_law_k3 = scaling_k3 * k_theory ** (-3)
+        plt.loglog(
+            k_theory,
+            power_law_k3,
+            "k--",
+            alpha=0.7,
+            linewidth=1.5,
+            label=r"$k^{-3}$ (enstrophy cascade)",
+        )
+
+        # k^{-5/3} line (inverse energy cascade)
+        scaling_k53 = ref_value * (k_match ** (5 / 3))
+        power_law_k53 = scaling_k53 * k_theory ** (-5 / 3)
+        plt.loglog(
+            k_theory,
+            power_law_k53,
+            "r--",
+            alpha=0.7,
+            linewidth=1.5,
+            label=r"$k^{-5/3}$ (energy cascade)",
+        )
+
+    plt.xlabel("Wavenumber k", fontsize=12)
+    plt.ylabel("Energy Spectrum E(k)", fontsize=12)
+    plt.title(f"Energy Spectrum ({resolution}x{resolution} resolution)", fontsize=14)
+    plt.legend()
+    plt.grid(True, alpha=0.3)
+    xlim = plt.xlim()
+    plt.xlim(1, xlim[1])
+    plt.tight_layout()
+
+    # Save plot
+    plt.savefig(plot_path, dpi=300, bbox_inches="tight")
+    plt.close()
+    logger.info("Plot saved to: %s", plot_path)
+
+    logger.info("Done!")
+
+
+if __name__ == "__main__":
+    main()

huggingface_pdeinv_download.py

@@ -0,0 +1,60 @@
+import argparse
+from huggingface_hub import snapshot_download
+
+datasets = [
+    "darcy-flow-241",
+    "darcy-flow-421",
+    "korteweg-de-vries-1d",
+    "navier-stokes-forced-2d-2048",
+    "navier-stokes-forced-2d",
+    "navier-stokes-unforced-2d",
+    "reaction-diffusion-2d-du-512",
+    "reaction-diffusion-2d-du",
+    "reaction-diffusion-2d-k-512",
+    "reaction-diffusion-2d-k",
+]
+
+splits = [
+    "*",
+    "train",
+    "validation",
+    "test",
+    "out_of_distribution",
+    "out_of_distribution_extreme",
+]
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Download PDE Inverse Problem Benchmarking datasets"
+    )
+    parser.add_argument(
+        "--dataset",
+        type=str,
+        default="darcy-flow-241",
+        choices=datasets,
+        help="Dataset to download",
+    )
+    parser.add_argument(
+        "--split", type=str, default="*", choices=splits, help="Data split to download"
+    )
+    parser.add_argument(
+        "--local-dir", type=str, default="", help="Local directory to save data"
+    )
+
+    args = parser.parse_args()
+
+    data_bucket = "DabbyOWL/PDE_Inverse_Problem_Benchmarking"
+
+    print(f"Downloading {args.dataset}/{args.split} to {args.local_dir}")
+
+    snapshot_download(
+        data_bucket,
+        allow_patterns=[f"{args.dataset}/{args.split}/*"],
+        local_dir=args.local_dir,
+        repo_type="dataset",
+    )
+
+
+if __name__ == "__main__":
+    main()

pdeinvbench/__init__.py

@@ -0,0 +1,5 @@
+from pdeinvbench import data
+from pdeinvbench import lightning_modules
+from pdeinvbench import losses
+from pdeinvbench import losses
+from pdeinvbench import utils

pdeinvbench/data/__init__.py

@@ -0,0 +1 @@
+from pdeinvbench.data.dataset import PDE_MultiParam

pdeinvbench/data/dataset.py

@@ -0,0 +1,360 @@
+import glob
+import logging
+import math
+
+import h5py
+import numpy as np
+import torch
+from scipy import signal
+from torch.utils.data import Dataset
+
+from pdeinvbench.data.transforms import collapse_time_and_channels_torch_transform
+from pdeinvbench.data.utils import extract_params_from_path
+from pdeinvbench.utils.types import PDE, PDE_NUM_SPATIAL, PDE_TRAJ_LEN
+
+
+class PDE_MultiParam(Dataset):
+    """Data Loader that loads the multiple parameter version of PDE Datasets."""
+
+    def __init__(
+        self,
+        data_root: str,
+        pde: PDE,
+        n_past: int,
+        dilation: int,
+        cutoff_first_n_frames: int,
+        train: bool,
+        frac_param_combinations: float = 1,
+        frac_ics_per_param: float = 1,
+        random_sample_param: bool = True,
+        downsample_factor: int = 0,
+        every_nth_window: int = 1,
+        window_start_percent: float = 0.0,
+        window_end_percent: float = 1.0,
+    ):
+        """
+        Args:
+            data_root: path containing the h5 files for the current data split
+            pde: name of the PDE system - one of the enum values.
+            n_past: number of conditioning frames
+            dilation: frequency at which to subsample the ground truth trajectories in the time dimension
+            cutoff_first_n_frames: number of initial frames to cutoff in each trajectory (may want to do this e.g. if initial PDE residuals are very high)
+            train: if training dataloader, windows are randomly sampled from each trajecory, if non-training dataloader we loop through all non-overlapping windows
+            frac_param_combinations: fraction of parameter combinations to use. 1 takes all parameters. "0.x" takes x percent of total parameters
+            frac_ics_per_param: fraction of initial conditions per parameter combination to keep.
+            random_sample_param: (bool) If frac_param_combinations < 1, true means we randomly sample params and false means we grab the first n_frac params. Defaults to true.
+            downsample_factor: downsample a solution field spatially by the 'downsample_factor'. eg if downsample_factor=4, sol field spatial size=[128,128] --downsample--> final spatial size = [32,32]
+            every_nth_window: take every nth window from the list of non-over-lapping windows
+            window_start_percent: percent of the way through the trajectory to start the window after cutoff_first_n_frames
+            window_end_percent: percent of the way through the trajectory to end the window
+        """
+
+        self.data_root = data_root
+        self.pde = pde
+        self.n_past = n_past
+        self.dilation = dilation
+        self.cutoff_first_n_frames = cutoff_first_n_frames
+        self.frac_param_combinations = frac_param_combinations
+        self.frac_ics_per_param = frac_ics_per_param
+        self.random_sample_param = random_sample_param
+        self.train = train
+        self.every_nth_window = every_nth_window
+        assert (
+            window_start_percent < window_end_percent
+        ), "window_start_percent must be less than window_end_percent"
+        self.window_start_index = int(
+            (PDE_TRAJ_LEN[self.pde] - self.cutoff_first_n_frames) * window_start_percent
+            + self.cutoff_first_n_frames
+        )
+        self.window_end_index = int(
+            (PDE_TRAJ_LEN[self.pde] - self.cutoff_first_n_frames) * window_end_percent
+            + self.cutoff_first_n_frames
+        )
+        self.total_trajectory_length = self.window_end_index - self.window_start_index
+
+        if self.train:
+            self.num_windows = self.total_trajectory_length - self.n_past - 1
+        else:
+            self.num_windows = (self.total_trajectory_length) // (
+                (self.n_past) * self.every_nth_window
+            )
+
+            if self.num_windows == 0 and self.every_nth_window > 1:
+                self.every_nth_window = 1
+                self.num_windows = (self.total_trajectory_length) // ((self.n_past))
+
+        # Quick check basically force a non-AR dataloader for darcy flow
+        if self.pde == PDE.DarcyFlow2D:
+            self.num_windows = 1
+
+        self.downsample_factor = downsample_factor
+
+        if PDE_NUM_SPATIAL[pde] == 2:
+            self.transforms = [collapse_time_and_channels_torch_transform]
+        else:
+            self.transforms = None
+
+        # get all h5 paths in the root folder and read them
+        # each h5 path represents a set of trajectories with a different PDE parameter
+        self.h5_paths = glob.glob(f"{self.data_root}/*.h5")
+        if len(self.h5_paths) == 0:
+            self.h5_paths = glob.glob(f"{self.data_root}/*.hdf5")
+        if self.pde == PDE.DarcyFlow2D:
+            self.h5_files = [file for file in self.h5_paths]
+        else:
+            self.h5_files = [h5py.File(file, "r") for file in self.h5_paths]
+
+        # extract the individual trajectories from each h5 file
+        if self.pde == PDE.ReactionDiffusion2D or self.pde == PDE.TurbulentFlow2D:
+            self.seqs = [list(h5_file.keys()) for h5_file in self.h5_files]
+        elif self.pde == PDE.NavierStokes2D:
+            # The individual trajectories are stored in key: 'solutions'
+            self.seqs = [h5_file["solutions"] for h5_file in self.h5_files]
+        elif self.pde == PDE.KortewegDeVries1D:
+            self.seqs = [h5_file["tensor"] for h5_file in self.h5_files]
+        elif self.pde == PDE.DarcyFlow2D:
+            # There is an issue where too many files are open, os throws errno 24
+            self.seqs = [file for file in self.h5_paths]
+        else:
+            self.seqs = [h5py.File(file, "r") for file in self.h5_paths]
+        if self.frac_param_combinations < 1:
+            total_params = math.ceil(len(self.seqs) * self.frac_ics_per_param)
+
+            logging.info(
+                f"trimming dataset from length {len(self.seqs)} to {total_params}"
+            )
+            if self.random_sample_param:
+                # Just a quick sanity check to ensure that all of the variables are the same length
+                # If this fails, something has gone VERY wrong
+                assert len(self.seqs) == len(self.h5_paths) and len(
+                    self.h5_paths
+                ) == len(
+                    self.h5_files
+                ), f"The dataloader variables are mismatched. seqs = {len(self.seqs)}, h5_paths = {len(self.h5_paths)}, h5_files = {len(self.h5_files)}"
+
+                # We've had issues in the past with reproducibility so this forces a seed
+                # Also will keep the datasets the same regardless of the training and weight init seeds
+                num_sequences: int = len(self.seqs)
+                requested_dataset_size: int = int(
+                    num_sequences * self.frac_param_combinations
+                )
+                indices = np.arange(num_sequences)
+                sample_seed: int = 42
+                rng_generator = np.random.default_rng(seed=sample_seed)
+                sampled_indices = rng_generator.choice(
+                    indices, size=requested_dataset_size, replace=False
+                )
+                logging.info(
+                    f"Using random sampling to trim the dataset down from length {len(self.seqs)} to {requested_dataset_size}"
+                )
+                assert (
+                    len(set(sampled_indices.tolist())) == sampled_indices.shape[0]
+                ), f"Duplicate items in random sampling of PDE parameters!"
+                assert (
+                    sampled_indices.shape[0] == requested_dataset_size
+                ), f"Mismatch between the requested dataset sample size and the new sampled dataset. frac requested = {self.frac_param_combinations}, requested size = {requested_dataset_size}, new size = {sampled_indices.shape[0]}"
+                self.seqs = [self.seqs[i] for i in sampled_indices]
+                self.h5_paths = [self.h5_paths[i] for i in sampled_indices]
+                self.h5_files = [self.h5_files[i] for i in sampled_indices]
+            else:
+                self.seqs = self.seqs[:total_params]
+                self.h5_paths = self.h5_paths[:total_params]
+                self.h5_files = self.h5_files[:total_params]
+
+        self.num_params = len(self.seqs)
+        if self.pde == PDE.KortewegDeVries1D:
+            # Since it follows the same format at 1D reaction diffusion
+            self.num_ics_per_param = self.seqs[0].shape[0]
+        elif self.pde == PDE.DarcyFlow2D:
+            self.num_ics_per_param = 1  # Each param only has one IC
+        elif self.pde != PDE.NavierStokes2D:
+            self.num_ics_per_param = len(
+                min([self.seqs[i] for i in range(len(self.seqs))])
+            )  # to manage un-even number of ICs per param
+        else:
+            self.num_ics_per_param = min(
+                [self.seqs[i].shape[0] for i in range(len(self.seqs))]
+            )
+
+        # Trim nmber of ICs per parameter
+
+        self.num_ics_per_param = math.ceil(
+            self.num_ics_per_param * self.frac_ics_per_param
+        )
+        # We also need to save the dx, dt, dy information in order to compute the PDE residual
+        if pde == PDE.ReactionDiffusion2D or pde == PDE.TurbulentFlow2D:
+            self.x = self.h5_files[0]["0001"]["grid"]["x"][:]
+            self.y = self.h5_files[0]["0001"]["grid"]["y"][:]
+            self.t = torch.Tensor(self.h5_files[0]["0001"]["grid"]["t"][:])
+        elif pde == PDE.NavierStokes2D:
+            self.x = self.h5_files[0]["x-coordinate"][:]
+            self.y = self.h5_files[0]["y-coordinate"][:]
+            self.t = torch.Tensor(self.h5_files[0]["t-coordinate"][:])
+        elif pde == PDE.DarcyFlow2D:
+            # Not ideal but it's fine to just hard code the current coordinates darcy flow
+            domain_len = 1  # Uniform grid with 1 - same regardless of resolution
+            d = h5py.File(self.seqs[0], "r")
+            size, _, _ = d["sol"].shape
+            d.close()
+            x = np.linspace(0, domain_len, size, endpoint=False)
+            self.x = torch.from_numpy(x)
+            self.y = torch.from_numpy(x)
+            self.t = (
+                torch.ones(10, dtype=float) * -1
+            )  # Darcy flow is non time dependent so we use -1
+        else:
+            # All of the 1D systems
+            self.y = None  # There is no y component
+            self.x = self.h5_files[0]["x-coordinate"][:]
+            self.t = torch.Tensor(self.h5_files[0]["t-coordinate"][:])
+
+        if self.downsample_factor != 0:
+            self.y = (
+                None
+                if self.y is None
+                else signal.decimate(self.y, q=self.downsample_factor, axis=0).copy()
+            )
+            self.x = signal.decimate(self.x, q=self.downsample_factor, axis=0).copy()
+        self.x = torch.Tensor(self.x)
+        self.y = torch.Tensor(self.y) if self.y is not None else None
+
+        logging.info(
+            f"Initialized dataset with {self.num_params} parameter combinations"
+        )
+
+    def __len__(self):
+        """
+        Number of parameters * number of ICs = number of full trajectories.
+        """
+        if self.train:
+            return self.num_params * self.num_ics_per_param
+        else:
+            return self.num_params * self.num_ics_per_param * self.num_windows
+
+    def __getitem__(self, index: int):
+        """
+        Loops over all parameters and ICs, and randomly samples time windows.
+        Returns:
+            x: conditioning frames, shape of [n_past, spatial/channel dims]
+            y: target frame(s), shape of [n_future, spatial/channel dims]
+            param_dict: dictionary containing the true PDE parameter for the trajectory.
+        """
+        # Compute the parameter and ic index for train loader
+        if self.train:
+            param_index = index // self.num_ics_per_param
+            ic_index = index % self.num_ics_per_param
+        else:
+            # Compute the parameter, ic index, and window index for validation/test loaders
+            # index is assumed to be in row major format of [num_params, num_ics_per_param, num_windows] dataset matrix organization
+            param_index = index // (self.num_ics_per_param * self.num_windows)
+            ic_index = (index // self.num_windows) % self.num_ics_per_param
+            window_index = index % self.num_windows
+        # get the corresponding trajectory and parameters
+        h5_file = self.h5_files[param_index]
+        h5_path = self.h5_paths[param_index]
+        param_dict = extract_params_from_path(h5_path, self.pde)
+
+        if self.pde == PDE.ReactionDiffusion2D or self.pde == PDE.TurbulentFlow2D:
+            # get data
+            seq = self.seqs[param_index][ic_index]
+            traj = torch.Tensor(
+                np.array(h5_file[f"{seq}/data"], dtype="f")
+            )  # dim = [seq_len, spatial_dim_1, spatial_dim_2, channels]
+        elif self.pde == PDE.NavierStokes2D:
+            seq = self.seqs[param_index]
+            traj = torch.Tensor(seq[ic_index])
+            # dim = [seq_len (t), spatial_dim_1, spatial_dim_2, channels]
+
+        elif self.pde == PDE.DarcyFlow2D:
+            # Unique since there is no time dim
+            # There is also only one ic per param
+            seq = h5py.File(self.seqs[param_index], "r")
+
+            coeff = torch.from_numpy(np.asarray(seq["coeff"]))
+            coeff = torch.squeeze(coeff)
+            coeff = torch.unsqueeze(coeff, dim=0)  # Channel first repr
+            # We treat the coeff as a binary mask
+            min_val = coeff.min()
+            max_val = coeff.max()
+            # generate the binary mask
+            coeff = coeff - min_val
+            binary_mask = coeff > 0
+
+            def wrap_scalar(x):
+                return torch.Tensor([x.item()])
+
+            param_dict["coeff"] = binary_mask.float()
+            param_dict["max_val"] = wrap_scalar(max_val)
+            param_dict["min_val"] = wrap_scalar(min_val)
+            traj = torch.from_numpy(np.asarray(seq["sol"]))
+            seq.close()
+        else:
+            seq = self.seqs[param_index]
+            traj = torch.Tensor(np.array(h5_file["tensor"][ic_index]))
+        traj = traj[:: self.dilation]  # subsample based on dilation
+
+        # sample a random window of length [n_past] from this trajectory
+        if traj.shape[0] - self.n_past == 0:
+            start = 0
+            # if n_past > 1, problem is well posed
+            if self.n_past == 1:
+                raise ValueError("Problem is ill-posed when n_past == 1. ")
+        else:
+            if self.train:
+                start = np.random.randint(
+                    self.window_start_index,
+                    self.window_end_index - self.n_past,
+                )
+            else:
+                # multiply with self.n_past to avoid overlapping in validation/test samples
+                start = self.window_start_index + (
+                    window_index * (self.n_past) * self.every_nth_window
+                )
+
+        if self.pde != PDE.DarcyFlow2D:
+            traj = traj[start : start + self.n_past]
+            time_frames = self.t[start : start + self.n_past]
+        else:
+            time_frames = -1 * torch.ones(self.n_past, dtype=float)
+        # 2D systems
+        if len(traj.shape) == 4:
+            # [T, Channels, Spatial, Spatial]
+            traj = traj.permute((0, 3, 1, 2))
+
+        if self.downsample_factor != 0:
+            traj = signal.decimate(traj, q=self.downsample_factor, axis=-1)
+            traj = (
+                torch.Tensor(
+                    signal.decimate(traj, q=self.downsample_factor, axis=-2).copy()
+                )
+                if len(traj.shape) == 4
+                else torch.Tensor(traj.copy())
+            )
+
+        # split into conditioning and target frames
+        if self.pde == PDE.DarcyFlow2D:
+            # Transforms to reshape the traj to the expected shape
+            # nx x ny x 1 -> T, C, X, Y
+            # T == C == 1
+            traj = torch.squeeze(traj)
+            traj = torch.unsqueeze(traj, dim=0)
+            traj = torch.unsqueeze(traj, dim=0)
+            x, y = (
+                traj,
+                traj,
+            )
+            x = x.float()
+            y = y.float()
+        else:
+            x, y = torch.split(traj, [self.n_past, 0], dim=0)
+
+        if self.transforms is not None:
+            # Perform any data transforms if specified
+            for T in self.transforms:
+                x, y, param_dict = T((x, y, param_dict))
+
+        # return spatial/temporal grid, frames and parameters
+        spatial_grid = (self.x, self.y) if self.y is not None else (self.x,)
+
+        ic_index = torch.tensor([ic_index], dtype=float)
+        return spatial_grid, self.t, x, y, time_frames, ic_index, param_dict

pdeinvbench/data/transforms.py

@@ -0,0 +1,80 @@
+import pdb
+from typing import Dict, Tuple
+
+import jaxtyping
+import torch
+import typeguard
+from jaxtyping import Float, jaxtyped
+
+"""
+Set of utility functions for data transformations.
+"""
+
+
+@jaxtyped(typechecker=typeguard.typechecked)
+def collapse_time_and_channels(
+    x: Float[torch.Tensor, "time channel xspace yspace"],
+) -> Float[torch.Tensor, "time*channel xspace yspace"]:
+    """
+    Collapses the time and channel dimensions of a tensor into a single dimension.
+    NOTE: This is only applicable to 2D systems and this is NOT batched!
+    We do this to be compatible with FNO. FNO can't handle multiple function outputs
+    at once since we're already using the channel dimension to represent time.
+    :param x: Input tensor of shape (time, channel, xspace, yspace).
+    :return: Output tensor of shape (time*channel, xspace, yspace).
+    """
+    x_flattened = torch.flatten(x, start_dim=0, end_dim=1)
+    return x_flattened
+
+
+@jaxtyped(typechecker=typeguard.typechecked)
+def collapse_time_and_channels_torch_transform(
+    batch: Tuple[
+        Float[torch.Tensor, "time_n_past in_channels xspace yspace"],
+        Float[torch.Tensor, "time_n_fut out_channels xspace yspace"],
+        Dict[
+            str, Float[torch.Tensor, "param"] | Float[torch.Tensor, "xspace yspace 1"]
+        ],
+    ],
+) -> Tuple[
+    Float[torch.Tensor, "time_n_past*in_channels xspace yspace"],
+    Float[torch.Tensor, "time_n_fut*out_channels xspace yspace"],
+    Dict[str, Float[torch.Tensor, "param"] | Float[torch.Tensor, "xspace yspace 1"]],
+]:
+    """
+    Wrapper for ```collapse_time_and_channels``` to be used with PyTorch's dataloader transforms.
+    Accepts a batch and for the first two elements of the batch, collapses the time and channel dimensions.
+    :param batch: Tuple of (input, target, pde_params).
+    :return: Tuple of (input, target, pde_params)
+    """
+    input, target, pde_params = batch
+    input = collapse_time_and_channels(input)
+    target = collapse_time_and_channels(target)
+    return input, target, pde_params
+
+
+@jaxtyped(typechecker=typeguard.typechecked)
+def expand_time_and_channels(
+    x: Float[torch.Tensor, "timexchannel xspace yspace"],
+    num_channels: int = -1,
+    num_timesteps: int = -1,
+) -> Float[torch.Tensor, "time channel xspace yspace"]:
+    """
+    Expands the time and channel dimensions of a tensor into separate dimensions.
+    Either number of channels or number of timesteps must be specified.
+    NOTE: This is only applicable to 2D systems.
+    :param x: Input tensor of shape (time*channel, xspace, yspace).
+    :param num_channels: Number of channels to expand to. OPTIONAL if num_timesteps is specified.
+    :param num_timesteps: Number of timesteps to expand to. OPTIONAL if num_channels is specified.
+    :return: Output tensor of shape (time, channel, xspace, yspace).
+    """
+    assert (
+        num_channels != -1 or num_timesteps != -1
+    ), "Either num_channels or num_timesteps must be specified!"
+    if num_channels != -1:
+        # Case we infer the number of timesteps
+        x_unflattened = torch.unflatten(x, 0, (-1, num_channels))
+    else:
+        # Case we infer the number of channels
+        x_unflattened = torch.unflatten(x, 0, (num_timesteps, -1))
+    return x_unflattened