Add paper link, GitHub repository, and metadata

README.md

@@ -1,3 +1,33 @@
+---
+task_categories:
+- other
+tags:
+- physics
+- scientific-computing
+- pde
+- inverse-problems
+---
+
+# PDEInvBench: A Comprehensive Dataset and Design Space Exploration of Neural Networks for PDE Inverse Problems
+
+This is the official dataset for the paper [PDEInvBench: A Comprehensive Dataset and Design Space Exploration of Neural Networks for PDE Inverse Problems](https://huggingface.co/papers/2605.25353).
+
+**Code**: [GitHub - ASK-Berkeley/PDEInvBench](https://github.com/ASK-Berkeley/PDEInvBench)
+
+## Sample Usage
+
+You can use the provided script from the codebase to batch download the data:
+
+```bash
+pip install huggingface_hub
+python3 huggingface_pdeinv_download.py --dataset darcy-flow-241 --split train --local-dir ./data
+```
+
+**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`
+
+---
+
 # PDEInvBench Data Guide
 Data guide for the dataset accompanying PDEInvBench.
 <img src="images/pde_objectives_main_fig_1.png" alt="" width="400">
@@ -25,15 +55,13 @@ Data guide for the dataset accompanying PDEInvBench.
 
 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
 
@@ -511,270 +539,4 @@ Contents:
 - `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`
+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).