diff --git a/.gitattributes b/.gitattributes index 9f79d93..18fc997 100644 --- a/.gitattributes +++ b/.gitattributes @@ -2,3 +2,5 @@ *.h5 filter=lfs diff=lfs merge=lfs -text *.pickle filter=lfs diff=lfs merge=lfs -text *.npy filter=lfs diff=lfs merge=lfs -text +*.png filter=lfs diff=lfs merge=lfs -text +*.gif filter=lfs diff=lfs merge=lfs -text diff --git a/CHANGELOG.md b/CHANGELOG.md index 789d49d..993006a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -28,6 +28,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Added a CHANGELOG.md - Ahmed body recipe +- Documentation for SFNO, GraphCast, vortex shedding, and Ahmed body ### Changed diff --git a/docs/img/FourCastNet.gif b/docs/img/FourCastNet.gif new file mode 100644 index 0000000..b5e8580 --- /dev/null +++ b/docs/img/FourCastNet.gif @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:116dc478929961eb30d7ad5430dadda5fbb11f41bf7495d5ccaef6a196b0d640 +size 2175324 diff --git a/docs/img/ahmed_body_results.png b/docs/img/ahmed_body_results.png new file mode 100644 index 0000000..85821af Binary files /dev/null and b/docs/img/ahmed_body_results.png differ diff --git a/docs/img/vortex_shedding.gif b/docs/img/vortex_shedding.gif new file mode 100644 index 0000000..cb29361 Binary files /dev/null and b/docs/img/vortex_shedding.gif differ diff --git a/examples/cfd/ahmed_body_mgn/README.md b/examples/cfd/ahmed_body_mgn/README.md new file mode 100644 index 0000000..d9e9622 --- /dev/null +++ b/examples/cfd/ahmed_body_mgn/README.md @@ -0,0 +1,119 @@ +# AeroGraphNet for external aerodynamic evaluation + +This example demonstrates how to train the AeroGraphNet model for external aerodynamic +analysis of simplified (Ahmed body-type) car geometries. AeroGraphNet is based on the +MeshGraphNet architecture. It achieves good accuracy on predicting the pressure and +wall shear stresses on the surface mesh of the Ahmed body-type geometries, as well as +the drag coefficient. + +## Problem overview + +To goal is to develop an AI surrogate model that can use simulation data to learn the +external aerodynamic flow over parameterized Ahmed body shape. This serves as a baseline +for more refined models for realistic car geometries. The trained model can be used to +predict the change in drag coefficient,and surface pressure and wall shear stresses due +to changes in the car geometry. This is a stepping stone to applying similar approaches +to other application areas such as aerodynamic analysis of aircraft wings, real car +geometries, etc. + +## Dataset + +Industry-standard Ahmed-body geometries are characterized by six design parameters: +length, width, height, ground clearance, slant angle, and fillet radius. Refer +to the [wiki](https://www.cfd-online.com/Wiki/Ahmed_body) for details on Ahmed +body geometry. In addition to these design parameters, we include the inlet velocity to +address a wide variation in Reynolds number. We identify the design points using the +Latin hypercube sampling scheme for space filling design of experiments and generate +around 500 design points. + +The aerodynamic simulations were performed using the GPU-accelerated OpenFOAM solver +for steady-state analysis, applying the SST K-omega turbulence model. These simulations +consist of 7.2 million mesh points on average, but we use the surface mesh as the input +to training which is roughly around 70k mesh nodes. + +To request access to the full dataset, please reach out to the +[NVIDIA Modulus team](simnet-team@nvidia.com). + +## Model overview and architecture + +The AeroGraphNet model is based on the MeshGraphNet architecture which is instrumental +for learning from mesh-based data using GNNs. The inputs to the model are: + +- Ahmed body surface mesh +- Reynolds number +- Geometry parameters (optional, including length, width, height, ground clearance, +slant angle, and fillet radius) +- surface normals (optional) + +Output of the model are: + +- Surface pressure +- Wall shear stresses +- Drag coefficient + +![Comparison between the AeroGraphNet prediction and the +ground truth for surface pressure, wall shear stresses, and the drag coefficient for one +of the samples from the test dataset.](../../../docs/img/ahmed_body_results.png) + +The input to the model is in form of a `.vtp` file and is then converted to +bi-directional DGL graphs in the dataloader. The final results are also written in the +form of `.vtp` files in the inference code. A hidden dimensionality of 256 is used in +the encoder, processor, and decoder. The encoder and decoder consist of two hidden +layers, and the processor includes 15 message passing layers. Batch size per GPU is +set to 1. Summation aggregation is used in the +processor for message aggregation. A learning rate of 0.0001 is used, decaying +exponentially with a rate of 0.99985. Training is performed on 8 NVIDIA A100 +GPUs, leveraging data parallelism. Total training time is 4 hours, and training is +performed for 500 epochs. + +## Getting Started + +The dataset for this example is not publicly available. To get access, please reach out +to the [NVIDIA Modulus team](simnet-team@nvidia.com). + +This example requires the `pyvista` and `vtk` libraries. Install with + +```bash +pip install pyvista vtk +``` + +To train the model, run + +```bash +python train.py +``` + +Data parallelism is also supported with multi-GPU runs. To launch a multi-GPU training, +run + +```bash +mpirun -np python train.py +``` + +If running in a docker container, you may need to include the `--allow-run-as-root` in +the multi-GPU run command. + +Progress and loss logs can be monitored using Weights & Biases. To activate that, +set `wandb_mode` to `online` in the `constants.py`. This requires to have an active +Weights & Biases account. You also need to provide your API key. There are multiple ways +for providing the API key but you can simply export it as an environment variable + +```bash +export WANDB_API_KEY= +``` + +The URL to the dashboard will be displayed in the terminal after the run is launched. +Alternatively, the logging utility in `train.py` can be switched to MLFlow. + +Once the model is trained, run + +```bash +python inference.py +``` + +This will save the predictions for the test dataset in `.vtp` format in the `results` +directory. Use Paraview to open and explore the results. + +## References + +- [Learning Mesh-Based Simulation with Graph Networks](https://arxiv.org/abs/2010.03409) diff --git a/examples/cfd/ahmed_body_mgn/constants.py b/examples/cfd/ahmed_body_mgn/constants.py index e575bc1..e33dd8e 100644 --- a/examples/cfd/ahmed_body_mgn/constants.py +++ b/examples/cfd/ahmed_body_mgn/constants.py @@ -42,7 +42,6 @@ class Constants(BaseModel): lr: float = 1e-4 lr_decay_rate: float = 0.99985 - drag_loss_weight: float = 1.0 amp: bool = False jit: bool = False diff --git a/examples/cfd/vortex_shedding_mgn/README.md b/examples/cfd/vortex_shedding_mgn/README.md new file mode 100644 index 0000000..3b9c282 --- /dev/null +++ b/examples/cfd/vortex_shedding_mgn/README.md @@ -0,0 +1,130 @@ +# MeshGraphNet for transient vortex shedding + +This example is a re-implementation of the DeepMind's vortex shedding example + in PyTorch. +It demonstrates how to train a Graph Neural Network (GNN) for evaluation of the +transient vortex shedding on parameterized geometries. + +## Problem overview + +Mesh-based simulations play a central role in modeling complex physical systems across +various scientific and engineering disciplines. They offer robust numerical integration +methods and allow for adaptable resolution to strike a balance between accuracy and +efficiency. Machine learning surrogate models have emerged as powerful tools to reduce +the cost of tasks like design optimization, design space exploration, and what-if +analysis, which involve repetitive high-dimensional scientific simulations. + +However, some existing machine learning surrogate models, such as CNN-type models, +are constrained by structured grids, +making them less suitable for complex geometries or shells. The homogeneous fidelity of +CNNs is a significant limitation for many complex physical systems that require an +adaptive mesh representation to resolve multi-scale physics. + +Graph Neural Networks (GNNs) present a viable approach for surrogate modeling in science +and engineering. They are data-driven and capable of handling complex physics. Being +mesh-based, GNNs can handle geometry irregularities and multi-scale physics, +making them well-suited for a wide range of applications. + +## Dataset + +We rely on DeepMind's vortex shedding dataset for this example. The dataset includes +1000 training, 100 validation, and 100 test samples that are simulated using COMSOL +with irregular triangle 2D meshes, each for 600 time steps with a time step size of +0.01s. These samples vary in the size and the position of the cylinder. Each sample +has a unique mesh due to geometry variations across samples, and the meshes have 1885 +nodes on average. Note that the model can handle different meshes with different number +of nodes and edges as the input. + +## Model overview and architecture + +The model is free-running and auto-regressive. It takes the initial condition as the +input and predicts the solution at the first time step. It then takes the prediction at +the first time step to predict the solution at the next time step. The model continues +to use the prediction at time step $t$ to predict the solution at time step $t+1$, until +the rollout is complete. Note that the model is also able to predict beyond the +simulation time span and extrapolate in time. However, the accuracy of the prediction +might degrade over time and if possible, extrapolation should be avoided unless +the underlying data patterns remain stationary and consistent. + +The model uses the input mesh to construct a bi-directional DGL graph for each sample. +The node features include (6 in total): + +- Velocity components at time step $t$, i.e., $u_t$, $v_t$ +- One-hot encoded node type (interior node, no-slip node, inlet node, outlet node) + +The edge features for each sample are time-independent and include (3 in total): + +- Relative $x$ and $y$ distance between the two end nodes of an edge +- L2 norm of the relative distance vector + +The output of the model is the velocity components at time step t+1, i.e., +$u_{t+1}$, $v_{t+1}$, as well as the pressure $p_{t+1}$. + +![Comparison between the MeshGraphNet prediction and the +ground truth for the horizontal velocity for different test samples. +](../../../docs/img/vortex_shedding.gif) + +A hidden dimensionality of 128 is used in the encoder, +processor, and decoder. The encoder and decoder consist of two hidden layers, and +the processor includes 15 message passing layers. Batch size per GPU is set to 1. +Summation aggregation is used in the +processor for message aggregation. A learning rate of 0.0001 is used, decaying +exponentially with a rate of 0.9999991. Training is performed on 8 NVIDIA A100 +GPUs, leveraging data parallelism for 25 epochs. + +## Getting Started + +This example requires the `tensorflow` library to load the data in the `.tfrecord` +format. Install with + +```bash +pip install tensorflow +``` + +To download the data from DeepMind's repo, run + +```bash +cd raw_dataset +sh download_dataset.sh cylinder_flow +``` + +To train the model, run + +```bash +python train.py +``` + +Data parallelism is also supported with multi-GPU runs. To launch a multi-GPU training, +run + +```bash +mpirun -np python train.py +``` + +If running in a docker container, you may need to include the `--allow-run-as-root` in +the multi-GPU run command. + +Progress and loss logs can be monitored using Weights & Biases. To activate that, +set `wandb_mode` to `online` in the `constants.py`. This requires to have an active +Weights & Biases account. You also need to provide your API key. There are multiple ways +for providing the API key but you can simply export it as an environment variable + +```bash +export WANDB_API_KEY= +``` + +The URL to the dashboard will be displayed in the terminal after the run is launched. +Alternatively, the logging utility in `train.py` can be switched to MLFlow. + +Once the model is trained, run + +```bash +python inference.py +``` + +This will save the predictions for the test dataset in `.gif` format in the `animations` +directory. + +## References + +- [Learning Mesh-Based Simulation with Graph Networks](https://arxiv.org/abs/2010.03409) diff --git a/examples/weather/fcn_afno/README.md b/examples/weather/fcn_afno/README.md new file mode 100644 index 0000000..02596af --- /dev/null +++ b/examples/weather/fcn_afno/README.md @@ -0,0 +1,115 @@ +# Adaptive Fourier Neural Operator (AFNO) for weather forecasting + +This repository contains the code used for [FourCastNet: A Global Data-driven +High-resolution Weather Model using Adaptive Fourier Neural +Operators](https://arxiv.org/abs/2202.11214) + +The code was developed by the authors of the preprint: +Jaideep Pathak, Shashank Subramanian, Peter Harrington, Sanjeev Raja, +Ashesh Chattopadhyay, Morteza Mardani, Thorsten Kurth, David Hall, Zongyi Li, +Kamyar Azizzadenesheli, Pedram Hassanzadeh, Karthik Kashinath, Animashree Anandkumar + +## Problem overview + +FourCastNet, short for Fourier Forecasting Neural Network, is a global data-driven +weather forecasting model that provides accurate short to medium-range global +predictions at 0.25∘ resolution. FourCastNet accurately forecasts high-resolution, +fast-timescale variables such as the surface wind speed, precipitation, and atmospheric +water vapor. It has important implications for planning wind energy resources, +predicting extreme weather events such as tropical cyclones, extra-tropical cyclones, +and atmospheric rivers. FourCastNet matches the forecasting accuracy of the ECMWF +Integrated Forecasting System (IFS), a state-of-the-art Numerical Weather Prediction +(NWP) model, at short lead times for large-scale variables, while outperforming IFS +for variables with complex fine-scale structure, including precipitation. FourCastNet +generates a week-long forecast in less than 2 seconds, orders of magnitude faster than +IFS. The speed of FourCastNet enables the creation of rapid and inexpensive +large-ensemble forecasts with thousands of ensemble-members for improving probabilistic +forecasting. We discuss how data-driven deep learning models such as FourCastNet are a +valuable addition to the meteorology toolkit to aid and augment NWP models. + +FourCastNet is based on the [vision transformer architecture with Adaptive Fourier +Neural Operator (AFNO) attention](https://openreview.net/pdf?id=EXHG-A3jlM) + +![Comparison between the FourCastNet and the ground truth (ERA5) for $u-10$ for +different lead times.](../../../docs/img/FourCastNet.gif) + +## Dataset + +The model is trained on a 20-channel subset of the ERA5 reanalysis data on single levels and +pressure levels that is pre-processed and stored into HDF5 files. +The subset of the ERA5 training data that FCN was trained on is hosted at the +National Energy Research Scientific Computing Center (NERSC). For convenience +[it is available to all via Globus](https://app.globus.org/file-manager?origin_id=945b3c9e-0f8c-11ed-8daf-9f359c660fbd&origin_path=%2F~%2Fdata%2F). +You will need a Globus account and will need to be logged in to your account in order +to access the data. You may also need the [Globus Connect](https://www.globus.org/globus-connect) +to transfer data. The full dataset that this version of FourCastNet was trained on is +approximately 5TB in size. + +## Model overview and architecture + +Please refer to the [reference paper](https://arxiv.org/abs/2202.11214) to learn about +the model architecture. + +## Getting Started + +To train the model, run + +```bash +python train_era5.py +``` + +Progress can be monitored using MLFlow. Open a new terminal and navigate to the training +directory, then run: + +```bash +mlflow ui -p 2458 +``` + +View progress in a browser at + +Data parallelism is also supported with multi-GPU runs. To launch a multi-GPU training, +run + +```bash +mpirun -np python train_era5.py +``` + +If running inside a docker container, you may need to include the `--allow-run-as-root` +in the multi-GPU run command. + +## References + +If you find this work useful, cite it using: + +```text +@article{pathak2022fourcastnet, + title={Fourcastnet: A global data-driven high-resolution weather model + using adaptive fourier neural operators}, + author={Pathak, Jaideep and Subramanian, Shashank and Harrington, Peter + and Raja, Sanjeev and Chattopadhyay, Ashesh and Mardani, Morteza + and Kurth, Thorsten and Hall, David and Li, Zongyi and Azizzadenesheli, Kamyar + and Hassanzadeh, Pedram and Kashinath, Karthik and Anandkumar, Animashree}, + journal={arXiv preprint arXiv:2202.11214}, + year={2022} +} +``` + +ERA5 data was downloaded from the Copernicus Climate Change Service (C3S) +Climate Data Store. + +```text +Hersbach, H., Bell, B., Berrisford, P., Biavati, G., Horányi, A., Muñoz Sabater, J., +Nicolas, J., Peubey, C., Radu, R., Rozum, I., Schepers, D., Simmons, A., Soci, C., +Dee, D., Thépaut, J-N. (2018): ERA5 hourly data on pressure levels from 1959 to present. +Copernicus Climate Change Service (C3S) Climate Data Store (CDS). 10.24381/cds.bd0915c6 + +Hersbach, H., Bell, B., Berrisford, P., Biavati, G., Horányi, A., Muñoz Sabater, J., +Nicolas, J., Peubey, C., Radu, R., Rozum, I., Schepers, D., Simmons, A., Soci, C., +Dee, D., Thépaut, J-N. (2018): ERA5 hourly data on single levels from 1959 to present. +Copernicus Climate Change Service (C3S) Climate Data Store (CDS). 10.24381/cds.adbb2d47 +``` + +Other references: + +[Adaptive Fourier Neural Operators: +Efficient Token Mixers for Transformers](https://openreview.net/pdf?id=EXHG-A3jlM) diff --git a/examples/weather/fcn_sfno/README.md b/examples/weather/fcn_sfno/README.md new file mode 100644 index 0000000..bf1cf27 --- /dev/null +++ b/examples/weather/fcn_sfno/README.md @@ -0,0 +1,131 @@ +# Spherical Fourier Neural Operator (SFNO) for weather forecasting + +This repository contains the code used for [Spherical Fourier Neural Operators: +Learning Stable Dynamics on the Sphere](https://arxiv.org/abs/2306.03838) + +The code was developed by the authors of the preprint: +Boris Bonev, Thorsten Kurth, Christian Hundt, Jaideep Pathak, Maximilian Baust, +Karthik Kashinath, Anima Anandkumar. Other contributors are David Pruitt, Jean Kossaifi, +and Noah Brenowitz. + +## Problem overview + +Fourier Neural Operators (FNOs) have proven to be an efficient and effective method for +resolution independent operator learning in a broad variety of application areas across +scientific machine learning. A key reason for their success is their +ability to accurately model long-range dependencies in spatio-temporal data by learning +global convolutions in a computationally efficient manner. To this end, FNOs rely on the +discrete Fourier transform (DFT), however, DFTs cause visual and spectral artifacts as +well as pronounced dissipation when learning operators in spherical coordinates since +they incorrectly assume a flat geometry. To overcome this limitation, FNOs are +generalized on the sphere by introducing Spherical FNOs (SFNOs) for learning +operators on spherical +geometries. In this example, SFNO is applied to forecasting atmospheric dynamics, +and demonstrates stable autoregressive rollouts for a year of simulated time +(1,460 steps), while retaining +physically plausible dynamics. The SFNO has important implications for machine +learning-based simulation of climate dynamics that could eventually help accelerate +our response to climate change. + +## Dataset + +The model is trained on a 73-channel subset of the ERA5 reanalysis data on single levels and +pressure levels that is pre-processed and stored into HDF5 files. +A 20-channel subset of the ERA5 training data is hosted at the +National Energy Research Scientific Computing Center (NERSC). For convenience +[it is available to all via Globus](https://app.globus.org/file-manager?origin_id=945b3c9e-0f8c-11ed-8daf-9f359c660fbd&origin_path=%2F~%2Fdata%2F). +You will need a Globus account and will need to be logged in to your account in order +to access the data. You may also need the [Globus Connect](https://www.globus.org/globus-connect) +to transfer data. + +## Model overview and architecture + +Please refer to the [reference paper](https://arxiv.org/abs/2306.03838) to learn about +the model architecture. + +## Getting Started + +To train the model on a single GPU, run + +```bash +python train.py --yaml_config=config/sfnonet.yaml --config=base_config +``` + +This will launch a SFNO training using the base configs specified in the +`config/sfnonet.yaml` file. + +You can include other arguments in the run command to change some of the defaults. +For example, for a mock-up training using synthetic data, run + +```bash +python train.py --yaml_config=config/sfnonet.yaml --config=base_config --enable_synthetic_data +``` + +Other arguments include, but not limited to: + +- fin_parallel_size: Input feature parallelization +- fout_parallel_size: Output feature parallelization +- h_parallel_size: Spatial parallelism dimension in h +- w_parallel_size: Spatial parallelism dimension in w +- amp mode: The mixed precision mode +- cuda_graph_mode: Specified which parts of the training to capture under CUDA graphs +- checkpointing_level: Specifies how aggressively the gradient checkpointing is used +- mode: Specifies the run mode, i.e., training, inference, or ensemble. +- multistep_count: Number of autoregressive training steps. + +To see a list of all available options with description, run + +```bash +python train.py --help +``` + +Other configurations that are not covered by these options can be specified or +overwritten in the config files. Those include, but not limited to, the loss function +type, learning rate, path to the dataset, number of channels, type of activation or +normalization, number of layers, etc. + +Progress and loss logs can be monitored using Weights & Biases. This requires to have an +active Weights & Biases account. You also need to provide your API key. There are +multiple ways for providing the API key but you can simply export it as an environment +variable + +```bash +export WANDB_API_KEY= +``` + +The URL to the dashboard will be displayed in the terminal after the run is launched. + +If needed, Weights & Biases can be disabled by + +```bash +export WANDB_MODE='disabled' +``` + +## References + +If you find this work useful, cite it using: + +```text +@article{bonev2023spherical, + title={Spherical Fourier Neural Operators: Learning Stable Dynamics on the Sphere}, + author={Bonev, Boris and Kurth, Thorsten and Hundt, Christian and Pathak, Jaideep + and Baust, Maximilian and Kashinath, Karthik and Anandkumar, Anima}, + journal={arXiv preprint arXiv:2306.03838}, + year={2023} +} +``` + +ERA5 data was downloaded from the Copernicus Climate Change Service (C3S) +Climate Data Store. + +```text +Hersbach, H., Bell, B., Berrisford, P., Biavati, G., Horányi, A., Muñoz Sabater, J., +Nicolas, J., Peubey, C., Radu, R., Rozum, I., Schepers, D., Simmons, A., Soci, C., +Dee, D., Thépaut, J-N. (2018): ERA5 hourly data on pressure levels from 1959 to present. +Copernicus Climate Change Service (C3S) Climate Data Store (CDS). 10.24381/cds.bd0915c6 + +Hersbach, H., Bell, B., Berrisford, P., Biavati, G., Horányi, A., Muñoz Sabater, J., +Nicolas, J., Peubey, C., Radu, R., Rozum, I., Schepers, D., Simmons, A., Soci, C., +Dee, D., Thépaut, J-N. (2018): ERA5 hourly data on single levels from 1959 to present. +Copernicus Climate Change Service (C3S) Climate Data Store (CDS). 10.24381/cds.adbb2d47 +``` diff --git a/examples/weather/graphcast/README.md b/examples/weather/graphcast/README.md new file mode 100644 index 0000000..d3db431 --- /dev/null +++ b/examples/weather/graphcast/README.md @@ -0,0 +1,71 @@ +# GraphCast for weather forecasting + +This example is a lightweight implementation of the DeepMind's +[GraphCast](https://arxiv.org/abs/2212.12794) model in PyTorch, to provide a recipe on +how to train such GNN models in Modulus. + +## Problem overview + +GraphCast is a multi-scale graph neural network-based autoregressive model. It is +trained on historical weather data from ECMWF's ERA5 reanalysis archive. GraphCast +generates predictions at 6-hour time steps for a set of surface and atmospheric +variables. This prediction covers a 0.25-degree latitude-longitude grid, +providing approximately 25 x 25 kilometer resolution at the equator. + +## Dataset + +The model is trained on a 73-channel subset of the ERA5 reanalysis data on single levels +and pressure levels that are pre-processed and stored into HDF5 files. +A 20-channel subset of the ERA5 training data is hosted at the +National Energy Research Scientific Computing Center (NERSC). For convenience +[it is available to all via Globus](https://app.globus.org/file-manager?origin_id=945b3c9e-0f8c-11ed-8daf-9f359c660fbd&origin_path=%2F~%2Fdata%2F). +You will need a Globus account and will need to be logged in to your account in order +to access the data. You may also need the [Globus Connect](https://www.globus.org/globus-connect) +to transfer data. + +## Model overview and architecture + +Please refer to the [reference paper](https://arxiv.org/abs/2212.12794) to learn about +the model architecture. + +## Getting Started + +To train the model on a single GPU, run + +```bash +python train_graphcast.py +``` + +This will launch a GraphCast training with up to 12 steps of fine-tuning using the base +configs specified in the `constants.py` file. + +Data parallelism is also supported with multi-GPU runs. To launch a multi-GPU training, +run + +```bash +mpirun -np python train_graphcast.py +``` + +If running in a docker container, you may need to include the `--allow-run-as-root` in +the multi-GPU run command. + +Progress and loss logs can be monitored using Weights & Biases. This requires to have an +active Weights & Biases account. You also need to provide your API key. There are +multiple ways for providing the API key but you can simply export it as an environment +variable + +```bash +export WANDB_API_KEY= +``` + +The URL to the dashboard will be displayed in the terminal after the run is launched. + +If needed, Weights & Biases can be disabled by + +```bash +export WANDB_MODE='disabled' +``` + +## References + +- [GraphCast: Learning skillful medium-range global weather forecasting](https://arxiv.org/abs/2212.12794)