Create README.md

README.md

@@ -0,0 +1,369 @@
+# Training Graph Neural Networks for Mesh-based Physics Simulations
+
+## Overview
+
+This repository let's you train Graph Neural Networks on meshes (e.g. fluid dynamics, material simulations, etc).
+It is based on the work from different papers:
+- [Learning Mesh-Based Simulation with Graph Networks](https://arxiv.org/abs/2010.03409)
+- [Multi-Grid Graph Neural Networks with Self-Attention for Computational Mechanics](https://arxiv.org/pdf/2409.11899)
+- [MeshMask: Physics Simulations with Masked Graph Neural Networks](https://arxiv.org/pdf/2501.08738)
+- [Training Transformers to Simulate Complex Physics](https://arxiv.org/abs/2508.18051)
+
+We offer a simple training script to:
+- Setup your model's architecture
+- Define your dataset with different augmentation functions
+- Follow the training live, including live vizualisations
+
+The code is based on Pytorch, and a JAX extension might follow at some point.
+
+At the moment, the repository supports the following:
+- architecture:
+  * [x] Mesh Graph Net
+  * [x] Transformers
+  * [ ] Multigrid
+- dataset:
+  * [x] matrix based, using .h5
+  * [x] .xdmf based (if you have .vtu, .vtk etc, you can easily convert them to .xdmf)
+- training methods and augmentations
+  * [x] K-hop neighbours 
+  * [x] Nodes Masking
+  * [x] Augmented Adjacency Matrix
+  * [ ] Sub-meshs
+
+Feel free to open a PR if you want to implement a new feature, or an issue to request one.
+
+## Datasets
+
+You can access the 3D Coarse Aneurysm dataset here ! 
+
+### Tutorials
+
+We offer 2 Google colab to showcase training on:
+- a Flow past a Cylinder Dataset with message passing
+  - [Colab](https://colab.research.google.com/drive/1DVOLrfPPLsjrsC8oq1KaDTIMHxHl1rgH?usp=sharing)
+  - dataset is from [Learning Mesh-Based Simulation with Graph Networks](https://arxiv.org/abs/2010.03409)
+- a blood flow inside a 3D Aneurysm with Transformers
+  - [Colab](https://colab.research.google.com/drive/1csjUx72GPcHzaaBC9z2b7wuxHVrAVsbO?usp=sharing)
+  - dataset is from [AnXplore: a comprehensive fluid-structure interaction study of 101 intracranial aneurysms](https://www.frontiersin.org/journals/bioengineering-and-biotechnology/articles/10.3389/fbioe.2024.1433811/full?field&journalName=Frontiers_in_Bioengineering_and_Biotechnology&id=1433811)
+
+## Vizualisations 
+
+We use [Weights and Biases](https://wandb.ai/site) to log most information during training. This includes:
+- training and validation loss
+  - per step
+  - per epoch 
+- All Rollout RMSE on validation dataset
+
+We also save:
+- Images of ground truth and 1-step prediction for specific indices
+  - `LogPyVistaPredictionsCallback(dataset=val_dataset, indices=[1, 2, 3])` in [train.py](https://github.com/DonsetPG/graph-physics/blob/main/graphphysics/train.py)
+- Video of ground truth and auto regressive prediction between the first and the last index of the same `indices` list as above
+- Meshes of auto regressive prediction as `.xdmf` file for the first trajectory of the validation dataset.
+
+> [!WARNING]  
+> If saving thoses meshes takes too much space, you can 1. monitor the disk usage using Weights and Biases, 2. Remove this functionnality in [lightning_module.py](https://github.com/DonsetPG/graph-physics/blob/0c9b6af20a25e7d08f2731efdfe4911f34fbc274/graphphysics/training/lightning_module.py#L154) (see the code below)
+
+https://github.com/DonsetPG/graph-physics/blob/6687b0bafabdd575d2ace6c0e7c39796e1f1624c/graphphysics/training/lightning_module.py#L151-L165
+
+## Setup
+
+### Default requirements
+
+```python
+import torch
+
+def format_pytorch_version(version):
+  return version.split('+')[0]
+
+TORCH_version = torch.__version__
+TORCH = format_pytorch_version(TORCH_version)
+
+def format_cuda_version(version):
+  return 'cu' + version.replace('.', '')
+
+CUDA_version = torch.version.cuda
+CUDA = format_cuda_version(CUDA_version)
+```
+
+```
+pip install torch-scatter     -f https://pytorch-geometric.com/whl/torch-{TORCH}+{CUDA}.html
+pip install torch-sparse      -f https://pytorch-geometric.com/whl/torch-{TORCH}+{CUDA}.html
+pip install torch-cluster     -f https://pytorch-geometric.com/whl/torch-{TORCH}+{CUDA}.html
+pip install torch-spline-conv -f https://pytorch-geometric.com/whl/torch-{TORCH}+{CUDA}.html
+pip install torch-geometric
+
+pip install loguru==0.7.2
+pip install autoflake==2.3.0
+pip install pytest==8.0.1
+pip install meshio==5.3.5
+pip install h5py==3.10.0
+
+!pip install pyvista lightning==2.5.0 wandb "wandb[media]"
+!pip install pytorch-lightning==2.5.0 torchmetrics==1.6.3
+```
+
+### DGL
+
+You will need to install DGL. You can find information on how to set it up for your environnement [here](https://www.dgl.ai/pages/start.html).
+
+In the case of a google colab, you can use:
+```
+pip install  dgl -f https://data.dgl.ai/wheels/torch-2.4/cu124/repo.html
+```
+
+### WandB
+
+We use Weights and Bias to log most of our metrics and vizualizations during the trainig. Make sure you create and account, and log in before you start training.
+
+```python
+import wandb
+wandb.login()
+```
+
+### Vizualization in Colab
+
+> [!WARNING]  
+> Note that if you train inside a notebook, you will need a specific set-up to allow for Pyvista to work
+
+```
+apt-get install -qq xvfb
+pip install pyvista panel -q
+```
+
+and run
+
+```python
+import os
+os.system('/usr/bin/Xvfb :99 -screen 0 1024x768x24 &')
+os.environ['DISPLAY'] = ':99'
+
+import panel as pn
+pn.extension('vtk')
+```
+
+in the same call as your training.
+
+## Documentation
+
+Most of setting up a new use case depends on two `.json` files: one to define the dataset details, and one for the training settings.
+
+Let's start with the training settings. An exemple is available [here](https://github.com/DonsetPG/graph-physics/blob/main/training_config/cylinder.json).
+
+### Dataset
+
+```json 
+"dataset": {
+    "extension": "h5",
+    "h5_path": "dataset/h5_dataset/cylinder_flow/train.h5",
+    "meta_path": "dataset/h5_dataset/cylinder_flow/meta.json",
+    "khop": 1
+}
+```
+
+- `extension`: If the dataset used is h5 or xdmf.
+- `h5_path` (`xdmf_folder` for an xdmf dataset): Path to the dataset.
+
+> [!NOTE]  
+> You will need a dataset at the same location with `test` instead of `train` in its name for the validation step to work. Otherwise, you can specify its name directly in `training.py`
+
+- `meta_path`: Location to the .json file with the dataset details (see below)
+- `khop`: K-hop neighbours size to use. You should start with 1.
+
+You also need to define a few other parameters: 
+
+```json
+"index": {
+    "feature_index_start": 0,
+    "feature_index_end": 2,
+    "output_index_start": 0,
+    "output_index_end": 2,
+    "node_type_index": 2
+}
+```
+- `feature_index_`: This is to define where we should look for nodes features. The end is excluded. For example, if you have 2D velocities at index 0 and 1, and pressure at index 2. If you want to use the pressure you should set  `feature_index_start=0` and  `feature_index_end=3`, otherwise, `feature_index_end=2`.
+
+- `output_index_`: We define our architectures to predict one of your feature for the enxt time steps. So you need to tell us where to look. For example, if you want to predict the velocity at the next step, since the velocity is at index 0 and 1, you will set  `output_index_start=0` and `output_index_end=2`.
+
+- `node_type_index`: Finally, we use a node type classification for each node:
+
+```python
+NORMAL = 0
+OBSTACLE = 1
+AIRFOIL = 2
+HANDLE = 3
+INFLOW = 4
+OUTFLOW = 5
+WALL_BOUNDARY = 6
+SIZE = 9
+```
+
+> [!WARNING]  
+> You should modify this if this is not at all representative of your use case. Those are taken from [Meshgraphnet](https://github.com/google-deepmind/deepmind-research/tree/master/meshgraphnets) and we found them to be general enough for all of our use cases. 
+
+This means that you either need to have such feature in your dataset, or to define a python function to build them (see below). After that, you need to tell us where to look. For example, if we only have velocity and node type, we will have  `node_type_index=2`. If we also had the pressure, we would set `node_type_index=3`
+
+> [!WARNING]  
+> H5-based dataloader does not support multiple workers. XDMF can.
+
+### Custom Processing Functions
+
+First, we allow you to add noise to your inputs to make the prediction of a trajectory more robust.
+
+```json
+"preprocessing": {
+    "noise": 0.02,
+    "noise_index_start": [0],
+    "noise_index_end": [2],
+    "masking": 0
+},
+```
+
+> [!WARNING]  
+> Masking is not implemented yet.
+
+```python
+def add_noise(
+    graph: Data,
+    noise_index_start: Union[int, List[int]],
+    noise_index_end: Union[int, List[int]],
+    noise_scale: Union[float, List[float]],
+    node_type_index: int,
+) -> Data:
+    """
+    Adds Gaussian noise to the specified features of the graph's nodes.
+
+    Parameters:
+        graph (Data): The graph to modify.
+        noise_index_start (Union[int, List[int]]): The starting index or indices for noise addition.
+        noise_index_end (Union[int, List[int]]): The ending index or indices for noise addition.
+        noise_scale (Union[float, List[float]]): The standard deviation(s) of the Gaussian noise.
+        node_type_index (int): The index of the node type feature.
+
+    Returns:
+        Data: The modified graph with noise added to node features.
+    """
+```
+
+Second, in the case of dealing with multiple meshes, you can add extra edges based on closeness of those different meshes:
+
+```json 
+"world_pos_parameters": {
+    "use": false,
+    "world_pos_index_start": 0,
+    "world_pos_index_end": 3
+}
+```
+
+See the [description](https://arxiv.org/abs/2010.03409) regarding world edges.
+
+Finally, in the case where: 
+- you need to build the node type 
+- you need to build extra features that were not in your dataset
+
+In `train.py`:
+
+```python
+# Build preprocessing function
+preprocessing = get_preprocessing(
+    param=parameters,
+    device=device,
+    use_edge_feature=use_edge_feature,
+    extra_node_features=None,
+)
+```
+
+where: 
+
+```python
+extra_node_features: Optional[
+        Union[Callable[[Data], Data], List[Callable[[Data], Data]]]
+    ] = None
+```
+
+You can define one or several functions that takes a graph as an input, and returns another graph with the new features. 
+
+> [!NOTE]  
+> In the case where you might need the previous graph as well (to compute acceleration for example, you can pass `get_previous_data` in the `get_dataset` function, and you will be able to access it using the `previous_data` attribute: `graph.previous_data`)
+> You can check [build_features](https://github.com/DonsetPG/graph-physics/blob/main/graphphysics/external/aneurysm.py) where we use `previous_velocity = torch.tensor(graph.previous_data["Vitesse"], device=device)`
+> It's important to note to if you do so, those previous data also need to be updated autoregressively during the validation steps. To do so, we added 2 parameters in `train.py`: `previous_data_start` and `previous_data_end`. By default, they are set to 4 and 7. This works if for example, you set the acceleration (computed using the previous velocity) at indexes 4, 5 and 6.
+
+For example, let's imagine we want to add the nodes position as a feature, one could define the following function: 
+
+```python
+def add_pos(graph: Data) -> Data:
+    graph.x = torch.cat(
+        (
+            graph.pos,
+            graph.x,
+        ),
+        dim=1,
+    )
+    return graph
+```
+
+<details>
+  <summary>In that case, the settings would need to be updated.</summary>
+  ```json
+  "index": {
+      "feature_index_start": 0,
+      "feature_index_end": 4,
+      "output_index_start": 2,
+      "output_index_end": 4,
+      "node_type_index": 4
+  }
+  ```
+</details>
+
+You can find more examples regarding adding features and building node type [here](https://github.com/DonsetPG/graph-physics/tree/main/graphphysics/external).
+
+We simply then call the function `add_pos` in `get_preprocessing`:
+
+```python
+# Build preprocessing function
+preprocessing = get_preprocessing(
+    param=parameters,
+    device=device,
+    use_edge_feature=use_edge_feature,
+    extra_node_features=add_pos,
+)
+```
+
+
+### Architecture
+
+```json
+"model": {
+    "type": "transformer",
+    "message_passing_num": 5,
+    "hidden_size": 32,
+    "node_input_size": 2,
+    "output_size": 2,
+    "edge_input_size": 0,
+    "num_heads": 4
+}
+```
+
+- `type`: Type of the model, either `transformer` or `epd` (message passing)
+- `message_passing_num`: Number of Layers
+- `hidden_size`: Number of hidden neurons
+- `node_input_size`: Number of node features
+
+> [!WARNING]  
+> This should not count the node type feature.
+
+- `edge_input_size`: Size of the edge features. 3 in 2D and 4 in 3D. 0 for transformer based model.
+- `output_size`: Size of the output
+- `num_heads`: Number of heads for transformer based model.
+
+### Dataset Settings
+
+You will also need to design a .json to define the dataset details. Those `meta.json` files are inspired from [Meshgraphnet](https://github.com/google-deepmind/deepmind-research/tree/master/meshgraphnets).
+
+You will need to define: 
+
+- `dt`: the time step of your simulation
+- `features`: a set of features used, including at least `cells` and `mesh_pos` for the .h5 dataset.
+- `field_names`: the list of all features
+- `trajectory_length`: the number of time steps per trajectory
+
+Examples can be found [here](https://github.com/DonsetPG/graph-physics/tree/main/dataset_config).