From c1cfdd413069f4dda7792008f3647dffdf1aefc9 Mon Sep 17 00:00:00 2001 From: Lionel VINCENT <97742788+A669015@users.noreply.github.com> Date: Wed, 23 Apr 2025 10:56:16 +0200 Subject: [PATCH] SBRA-800 fix model collection dependabot upgrade (#1) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Sbra 634 documentation of reactive flows (#47) Co-authored-by: root Co-authored-by: Léo Nicoletti * Fix doc (#48) * Upgrade all use-cases to pytorch/lightning 2 (#49) * Fix base requirements for gnns (#50) * Fix dependabot permissions (#52) * Bump jinja2 from 3.1.4 to 3.1.5 in /reactive-flows/cnf-combustion/unets (#51) Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: Lionel VINCENT <97742788+A669015@users.noreply.github.com> * Bump jinja2 from 3.1.4 to 3.1.5 in /weather-forecast/ecrad-3d-correction/unets in the pip group across 1 directory (#53) * SBRA-714 add dependabot workflow to auto merge its PR (#55) * Bump the pip group across 2 directories with 1 update (#54) Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> * SBRA-708 validate docker images before publishing them (#68) * SBRA-709 automate linting (#69) * SBRA-720 remove notebooks (#70) * SBRA-718 refactor reactive-flows/cnf-combustion/gnns to remove config.py (#71) * SBRA-718 refactor reactive-flows/cnf-combustion/unets to remove config.py (#72) * SBRA-718 refactor weather-forecast/gravity-wave-drag/cnns to remove config.py (#74) * SBRA-718 refactor weather-forecast/ecrad-3d-correction/unets to remove config.py (#73) * SBRA-732 Add omegaconf (#75) * SBRA-736 add coverage for the functional tests (#77) * SBRA-731 Clean trainer (#76) * SBRA-738 expose splitting strategy in the config files (#78) * Bump keras from 3.7.0 to 3.9.0 in /weather-forecast/ecrad-3d-correction/unets in the pip group across 1 directory (#80) Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> * Bump the pip group across 4 directories with 1 update (#81) Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: VINCENT, LIONEL * clean nox venv after each session to save space --------- Signed-off-by: dependabot[bot] Co-authored-by: Léo Nicoletti Co-authored-by: root Co-authored-by: Léo Nicoletti Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- .github/workflows/ai4sim-ci-cd.yaml | 62 ++- .github/workflows/images-ci-cd.yaml | 39 +- .gitignore | 4 +- README.md | 42 ++- cfd/README.md | 17 - cfd/combustion/__init__.py | 0 cfd/combustion/gnns/.gitignore | 5 - cfd/combustion/gnns/README.md | 27 -- cfd/combustion/gnns/ci/requirements_data.txt | 4 - cfd/combustion/gnns/config.py | 108 ------ .../gnns/notebooks/R2-GIN-to-R3.ipynb | 355 ------------------ cfd/combustion/gnns/plotters.py | 243 ------------ cfd/combustion/gnns/requirements.txt | 86 ----- cfd/combustion/gnns/tests/test_config.py | 91 ----- .../gnns/tests/test_data/test_model.ckpt | Bin 96730 -> 0 bytes cfd/combustion/gnns/tests/test_plotter.py | 117 ------ cfd/combustion/gnns/tests/test_trainer.py | 51 --- cfd/combustion/gnns/trainer.py | 89 ----- cfd/combustion/unets/.gitignore | 4 - cfd/combustion/unets/README.md | 24 -- cfd/combustion/unets/ci/requirements_data.txt | 4 - cfd/combustion/unets/config.py | 45 --- cfd/combustion/unets/requirements.txt | 62 --- cfd/combustion/unets/tests/test_config.py | 36 -- cfd/combustion/unets/tests/test_trainer.py | 41 -- cfd/combustion/unets/trainer.py | 71 ---- cfd/get-started.ipynb | 67 ---- docker/Dockerfile | 21 +- {cfd => reactive-flows}/__init__.py | 0 reactive-flows/cnf-combustion/README.md | 25 ++ .../cnf-combustion}/__init__.py | 0 .../cnf-combustion/gnns}/.coveragerc | 1 + reactive-flows/cnf-combustion/gnns/.gitignore | 32 ++ reactive-flows/cnf-combustion/gnns/README.md | 15 + .../cnf-combustion/gnns}/__init__.py | 0 .../gnns/ci/configs/gat_test.yaml | 11 +- .../gnns/ci/configs/gcn_test.yaml | 13 +- .../gnns/ci/configs/gin_test.yaml | 13 +- .../gnns/ci/configs/gunet_test.yaml | 11 +- .../gnns/ci/generate_synthetic_data.py | 43 ++- reactive-flows/cnf-combustion/gnns/ci/run.sh | 33 ++ .../cnf-combustion}/gnns/configs/gat.yaml | 11 +- .../cnf-combustion}/gnns/configs/gcn.yaml | 13 +- .../cnf-combustion}/gnns/configs/gin.yaml | 14 +- .../cnf-combustion}/gnns/configs/gunet.yaml | 11 +- .../cnf-combustion}/gnns/data.py | 153 ++++++-- .../cnf-combustion}/gnns/env.yaml | 4 +- .../cnf-combustion}/gnns/inferer.py | 46 +-- .../cnf-combustion}/gnns/models.py | 209 ++++++----- .../cnf-combustion}/gnns/noxfile.py | 2 +- .../cnf-combustion/gnns/plotters.py | 310 +++++++++++++++ .../cnf-combustion/gnns/requirements.txt | 113 ++++++ .../cnf-combustion}/gnns/run.sh | 0 .../cnf-combustion/gnns/tests/__init__.py | 7 +- .../cnf-combustion}/gnns/tests/test_data.py | 118 ++++-- .../gnns/tests/test_data/test_model.ckpt | Bin 0 -> 84535 bytes .../gnns/tests/test_inferer.py | 74 ++-- .../cnf-combustion}/gnns/tests/test_models.py | 102 +++-- .../cnf-combustion/gnns/tests/test_plotter.py | 146 +++++++ reactive-flows/cnf-combustion/gnns/trainer.py | 20 + .../cnf-combustion/unets}/.coveragerc | 1 + .../cnf-combustion/unets/.gitignore | 32 ++ reactive-flows/cnf-combustion/unets/README.md | 27 ++ .../cnf-combustion/unets}/__init__.py | 2 - .../unets/ci/configs/unets_test.yaml | 12 +- .../unets/ci/generate_synthetic_data.py | 34 +- .../cnf-combustion/unets}/ci/run.sh | 21 +- .../cnf-combustion}/unets/configs/unet.yaml | 14 +- .../cnf-combustion}/unets/data.py | 102 +++-- .../cnf-combustion}/unets/env.yaml | 4 +- .../cnf-combustion}/unets/models.py | 7 +- .../cnf-combustion}/unets/noxfile.py | 2 +- .../cnf-combustion/unets/requirements.txt | 87 +++++ .../cnf-combustion/unets}/tests/__init__.py | 2 - .../cnf-combustion}/unets/tests/test_data.py | 55 +-- .../unets/tests/test_models.py | 23 +- .../cnf-combustion}/unets/tests/test_unet.py | 24 +- .../cnf-combustion}/unets/tests/test_utils.py | 6 +- .../cnf-combustion/unets/trainer.py | 23 ++ .../cnf-combustion}/unets/unet.py | 51 ++- .../cnf-combustion}/unets/utils.py | 9 +- tools/flake8/flake8.cfg | 4 +- tools/nox/nox_ref_file.py | 89 ++++- .../ecrad-3d-correction/unets/.coveragerc | 1 + .../ecrad-3d-correction/unets/.gitignore | 36 +- .../unets/ci/configs/unet_test.yaml | 12 +- .../unets/ci/generate_synthetic_data.py | 106 ++++-- .../unets/ci/requirements_data.txt | 6 - .../ecrad-3d-correction/unets/ci/run.sh | 18 +- .../ecrad-3d-correction/unets/config.py | 32 -- .../unets/configs/unet.yaml | 14 +- .../ecrad-3d-correction/unets/data.py | 52 +-- .../ecrad-3d-correction/unets/dataproc.py | 126 ++++--- .../ecrad-3d-correction/unets/env.yaml | 4 +- .../ecrad-3d-correction/unets/models.py | 53 +-- .../ecrad-3d-correction/unets/noxfile.py | 2 +- .../unets/requirements.txt | 199 ++++++---- .../unets/tests/test_config.py | 36 -- .../unets/tests/test_data.py | 42 ++- .../unets/tests/test_dataproc.py | 15 +- .../unets/tests/test_models.py | 48 +-- .../unets/tests/test_trainer.py | 41 -- .../unets/tests/test_unet.py | 6 +- .../ecrad-3d-correction/unets/trainer.py | 64 +--- .../ecrad-3d-correction/unets/unet.py | 36 +- .../gravity-wave-drag/cnns/.coveragerc | 1 + .../gravity-wave-drag/cnns/.gitignore | 14 +- .../gravity-wave-drag/cnns/__init__.py | 2 - .../cnns/ci/configs/cnn_test.yaml | 49 +-- .../cnns/ci/configs/mlp_test.yaml | 45 ++- .../cnns/ci/generate_synthetic_data.py | 64 ++-- .../cnns/ci/requirements_data.txt | 4 - .../gravity-wave-drag/cnns/ci/run.sh | 20 +- .../gravity-wave-drag/cnns/config.py | 50 --- .../gravity-wave-drag/cnns/configs/cnn.yaml | 46 ++- .../cnns/configs/default.yaml | 42 ++- .../gravity-wave-drag/cnns/configs/mlp.yaml | 42 ++- .../gravity-wave-drag/cnns/data.py | 81 ++-- .../gravity-wave-drag/cnns/env.yaml | 4 +- .../gravity-wave-drag/cnns/models.py | 70 ++-- .../cnns/notebooks/get-started.ipynb | 67 ---- .../gravity-wave-drag/cnns/noxfile.py | 3 +- .../gravity-wave-drag/cnns/requirements.txt | 129 ++++--- .../cnns/tests/test_config.py | 46 --- .../gravity-wave-drag/cnns/tests/test_data.py | 72 ++-- .../cnns/tests/test_models.py | 50 ++- .../cnns/tests/test_trainer.py | 76 ---- .../cnns/tests/test_utils.py | 12 +- .../gravity-wave-drag/cnns/trainer.py | 66 +--- 129 files changed, 2783 insertions(+), 3117 deletions(-) delete mode 100644 cfd/README.md delete mode 100644 cfd/combustion/__init__.py delete mode 100644 cfd/combustion/gnns/.gitignore delete mode 100644 cfd/combustion/gnns/README.md delete mode 100644 cfd/combustion/gnns/ci/requirements_data.txt delete mode 100755 cfd/combustion/gnns/config.py delete mode 100644 cfd/combustion/gnns/notebooks/R2-GIN-to-R3.ipynb delete mode 100644 cfd/combustion/gnns/plotters.py delete mode 100644 cfd/combustion/gnns/requirements.txt delete mode 100644 cfd/combustion/gnns/tests/test_config.py delete mode 100644 cfd/combustion/gnns/tests/test_data/test_model.ckpt delete mode 100644 cfd/combustion/gnns/tests/test_plotter.py delete mode 100644 cfd/combustion/gnns/tests/test_trainer.py delete mode 100755 cfd/combustion/gnns/trainer.py delete mode 100644 cfd/combustion/unets/.gitignore delete mode 100644 cfd/combustion/unets/README.md delete mode 100644 cfd/combustion/unets/ci/requirements_data.txt delete mode 100755 cfd/combustion/unets/config.py delete mode 100644 cfd/combustion/unets/requirements.txt delete mode 100644 cfd/combustion/unets/tests/test_config.py delete mode 100644 cfd/combustion/unets/tests/test_trainer.py delete mode 100755 cfd/combustion/unets/trainer.py delete mode 100644 cfd/get-started.ipynb rename {cfd => reactive-flows}/__init__.py (100%) create mode 100644 reactive-flows/cnf-combustion/README.md rename {cfd/combustion/unets => reactive-flows/cnf-combustion}/__init__.py (100%) rename {cfd/combustion/unets => reactive-flows/cnf-combustion/gnns}/.coveragerc (65%) create mode 100644 reactive-flows/cnf-combustion/gnns/.gitignore create mode 100644 reactive-flows/cnf-combustion/gnns/README.md rename {cfd/combustion/unets/tests => reactive-flows/cnf-combustion/gnns}/__init__.py (100%) rename {cfd/combustion => reactive-flows/cnf-combustion}/gnns/ci/configs/gat_test.yaml (73%) rename {cfd/combustion => reactive-flows/cnf-combustion}/gnns/ci/configs/gcn_test.yaml (72%) rename {cfd/combustion => reactive-flows/cnf-combustion}/gnns/ci/configs/gin_test.yaml (72%) rename {cfd/combustion => reactive-flows/cnf-combustion}/gnns/ci/configs/gunet_test.yaml (72%) rename {cfd/combustion => reactive-flows/cnf-combustion}/gnns/ci/generate_synthetic_data.py (57%) create mode 100644 reactive-flows/cnf-combustion/gnns/ci/run.sh rename {cfd/combustion => reactive-flows/cnf-combustion}/gnns/configs/gat.yaml (73%) rename {cfd/combustion => reactive-flows/cnf-combustion}/gnns/configs/gcn.yaml (72%) rename {cfd/combustion => reactive-flows/cnf-combustion}/gnns/configs/gin.yaml (71%) rename {cfd/combustion => reactive-flows/cnf-combustion}/gnns/configs/gunet.yaml (72%) rename {cfd/combustion => reactive-flows/cnf-combustion}/gnns/data.py (63%) rename {cfd/combustion => reactive-flows/cnf-combustion}/gnns/env.yaml (82%) rename {cfd/combustion => reactive-flows/cnf-combustion}/gnns/inferer.py (86%) rename {cfd/combustion => reactive-flows/cnf-combustion}/gnns/models.py (56%) rename {cfd/combustion => reactive-flows/cnf-combustion}/gnns/noxfile.py (100%) create mode 100644 reactive-flows/cnf-combustion/gnns/plotters.py create mode 100644 reactive-flows/cnf-combustion/gnns/requirements.txt rename {cfd/combustion => reactive-flows/cnf-combustion}/gnns/run.sh (100%) rename cfd/combustion/unets/ci/run.sh => reactive-flows/cnf-combustion/gnns/tests/__init__.py (87%) rename {cfd/combustion => reactive-flows/cnf-combustion}/gnns/tests/test_data.py (55%) create mode 100644 reactive-flows/cnf-combustion/gnns/tests/test_data/test_model.ckpt rename {cfd/combustion => reactive-flows/cnf-combustion}/gnns/tests/test_inferer.py (73%) rename {cfd/combustion => reactive-flows/cnf-combustion}/gnns/tests/test_models.py (66%) create mode 100644 reactive-flows/cnf-combustion/gnns/tests/test_plotter.py create mode 100755 reactive-flows/cnf-combustion/gnns/trainer.py rename {cfd/combustion/gnns => reactive-flows/cnf-combustion/unets}/.coveragerc (65%) create mode 100644 reactive-flows/cnf-combustion/unets/.gitignore create mode 100644 reactive-flows/cnf-combustion/unets/README.md rename {cfd/combustion/gnns => reactive-flows/cnf-combustion/unets}/__init__.py (87%) rename {cfd/combustion => reactive-flows/cnf-combustion}/unets/ci/configs/unets_test.yaml (81%) rename {cfd/combustion => reactive-flows/cnf-combustion}/unets/ci/generate_synthetic_data.py (58%) rename {cfd/combustion/gnns => reactive-flows/cnf-combustion/unets}/ci/run.sh (63%) rename {cfd/combustion => reactive-flows/cnf-combustion}/unets/configs/unet.yaml (72%) rename {cfd/combustion => reactive-flows/cnf-combustion}/unets/data.py (58%) rename {cfd/combustion => reactive-flows/cnf-combustion}/unets/env.yaml (82%) rename {cfd/combustion => reactive-flows/cnf-combustion}/unets/models.py (92%) rename {cfd/combustion => reactive-flows/cnf-combustion}/unets/noxfile.py (100%) create mode 100644 reactive-flows/cnf-combustion/unets/requirements.txt rename {cfd/combustion/gnns => reactive-flows/cnf-combustion/unets}/tests/__init__.py (87%) rename {cfd/combustion => reactive-flows/cnf-combustion}/unets/tests/test_data.py (69%) rename {cfd/combustion => reactive-flows/cnf-combustion}/unets/tests/test_models.py (77%) rename {cfd/combustion => reactive-flows/cnf-combustion}/unets/tests/test_unet.py (83%) rename {cfd/combustion => reactive-flows/cnf-combustion}/unets/tests/test_utils.py (97%) create mode 100755 reactive-flows/cnf-combustion/unets/trainer.py rename {cfd/combustion => reactive-flows/cnf-combustion}/unets/unet.py (79%) rename {cfd/combustion => reactive-flows/cnf-combustion}/unets/utils.py (90%) delete mode 100644 weather-forecast/ecrad-3d-correction/unets/ci/requirements_data.txt delete mode 100644 weather-forecast/ecrad-3d-correction/unets/config.py delete mode 100644 weather-forecast/ecrad-3d-correction/unets/tests/test_config.py delete mode 100644 weather-forecast/ecrad-3d-correction/unets/tests/test_trainer.py delete mode 100644 weather-forecast/gravity-wave-drag/cnns/ci/requirements_data.txt delete mode 100644 weather-forecast/gravity-wave-drag/cnns/config.py delete mode 100644 weather-forecast/gravity-wave-drag/cnns/notebooks/get-started.ipynb delete mode 100644 weather-forecast/gravity-wave-drag/cnns/tests/test_config.py delete mode 100644 weather-forecast/gravity-wave-drag/cnns/tests/test_trainer.py diff --git a/.github/workflows/ai4sim-ci-cd.yaml b/.github/workflows/ai4sim-ci-cd.yaml index de13a3f8..7aa92f0d 100644 --- a/.github/workflows/ai4sim-ci-cd.yaml +++ b/.github/workflows/ai4sim-ci-cd.yaml @@ -2,6 +2,12 @@ name: ai4sim-ci-cd on: [push, pull_request] +permissions: + actions: write + checks: write + contents: write + pull-requests: write + jobs: run-checks: runs-on: ubuntu-latest @@ -9,8 +15,8 @@ jobs: strategy: matrix: model-project: - - cfd/combustion/gnns - - cfd/combustion/unets + - reactive-flows/cnf-combustion/gnns + - reactive-flows/cnf-combustion/unets - weather-forecast/gravity-wave-drag/cnns - weather-forecast/ecrad-3d-correction/unets fail-fast: false @@ -35,15 +41,39 @@ jobs: - name: Analysing the code with flake8 working-directory: ${{ matrix.model-project }} - run: nox -s lint -v + run: | + nox -s lint -v + rm -rf .nox + + - name: Analysing the code with isort + working-directory: ${{ matrix.model-project }} + run: | + nox -s import_sort -v -- check-only + rm -rf .nox + + - name: Analysing the code with black + working-directory: ${{ matrix.model-project }} + run: | + nox -s black -v -- check-only + rm -rf .nox - name: Run unit tests with coverage report working-directory: ${{ matrix.model-project }} - run: nox -s tests -v + run: | + nox -s tests -v + rm -rf .nox - name: Run functional tests working-directory: ${{ matrix.model-project }} - run: nox -s train_test -v -- clean_data + run: | + nox -s train_test -v -- clean_data + rm -rf .nox + + - name: Combine coverage reports + working-directory: ${{ matrix.model-project }} + run: | + nox -s coverage_report -R -v -- combine + rm -rf .nox - name: Coverage Commentator uses: 5monkeys/cobertura-action@master @@ -56,3 +86,25 @@ jobs: link_missing_lines: true link_missing_lines_source_dir: ${{ matrix.model-project }} report_name: Coverage report for ${{ matrix.model-project }} model project + + dependabot-auto-merge: + runs-on: ubuntu-latest + + needs: run-checks + if: github.event.pull_request.user.login == 'dependabot[bot]' + + steps: + - name: Checkout sources + uses: actions/checkout@v2 + + - name: Approve a PR + run: gh pr review --approve "$PR_URL" + env: + PR_URL: ${{ github.event.pull_request.html_url }} + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} + + - name: Enable auto-merge for Dependabot PRs + run: gh pr merge --auto --squash "$PR_URL" + env: + PR_URL: ${{ github.event.pull_request.html_url }} + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} \ No newline at end of file diff --git a/.github/workflows/images-ci-cd.yaml b/.github/workflows/images-ci-cd.yaml index 07197052..a5724a40 100644 --- a/.github/workflows/images-ci-cd.yaml +++ b/.github/workflows/images-ci-cd.yaml @@ -19,8 +19,8 @@ jobs: strategy: matrix: model-project: - - cfd/combustion/gnns - - cfd/combustion/unets + - reactive-flows/cnf-combustion/gnns + - reactive-flows/cnf-combustion/unets - weather-forecast/gravity-wave-drag/cnns - weather-forecast/ecrad-3d-correction/unets fail-fast: false @@ -59,14 +59,43 @@ jobs: separator: ":" limit: -1 + - name: Build the Docker image name and tag + id: image + run: | + echo "name=${{ steps.split_tag.outputs._0 }}" >> "$GITHUB_OUTPUT" + echo "tag=${{ steps.split_path.outputs._0 }}-${{ steps.split_path.outputs._1 }}-${{ steps.split_path.outputs._2 }}" >> "$GITHUB_OUTPUT" + - name: Read model-project env.yaml file uses: pietrobolcato/action-read-yaml@1.1.0 id: uc_env with: config: ${{ matrix.model-project }}/env.yaml - - name: Build and push Docker images - uses: docker/build-push-action@v5 + - name: Build the Docker image + uses: docker/build-push-action@v6 + with: + context: . + file: "./docker/Dockerfile" + build-args: | + UBUNTU_IMAGE_NAME=${{ steps.uc_env.outputs['ubuntu_base_image.name'] }} + UBUNTU_IMAGE_TAG=${{ steps.uc_env.outputs['ubuntu_base_image.tag'] }} + PYTHON_VERS=${{ steps.uc_env.outputs['python_version'] }} + MODEL_PROJECT_PATH=${{ matrix.model-project }} + load: true + tags: "${{ steps.image.outputs.name }}:${{ steps.image.outputs.tag }}" + labels: ${{ steps.meta.outputs.labels }} + + - name: Test the Docker image + working-directory: ${{ matrix.model-project }} + run: | + docker run \ + --rm \ + -w /home/ai4sim/${{ matrix.model-project }} \ + ${{ steps.image.outputs.name }}:${{ steps.image.outputs.tag }} \ + nox -s train_test --no-venv -v -- clean_data + + - name: Push the previously built Docker image + uses: docker/build-push-action@v6 with: context: . file: "./docker/Dockerfile" @@ -76,5 +105,5 @@ jobs: PYTHON_VERS=${{ steps.uc_env.outputs['python_version'] }} MODEL_PROJECT_PATH=${{ matrix.model-project }} push: true - tags: "${{ steps.split_tag.outputs._0 }}:${{ steps.split_path.outputs._0 }}-${{ steps.split_path.outputs._1 }}-${{ steps.split_path.outputs._2 }}" + tags: "${{ steps.image.outputs.name }}:${{ steps.image.outputs.tag }}" labels: ${{ steps.meta.outputs.labels }} diff --git a/.gitignore b/.gitignore index ce48d529..a0cd6fce 100644 --- a/.gitignore +++ b/.gitignore @@ -27,5 +27,5 @@ venv.bak/ # Data data/ -# Experiments -experiments/ \ No newline at end of file +# logs +lightning_logs/ \ No newline at end of file diff --git a/README.md b/README.md index 305a2a3c..95cc9b29 100644 --- a/README.md +++ b/README.md @@ -49,7 +49,7 @@ All the models are placed in the repository with a path following the rule: ``//`` -For example, the code in the path ``cfd/combustion/gnns`` implements some **Graph Neural Network (GNN)** architectures developed for **Computational Fluid Dynamics (CFD)** and applied to a **Combustion** use-case. +For example, the code in the path ``reactive-flows/cnf-combustion/gnns`` implements some **Graph Neural Network (GNN)** architectures developed for **Computational Fluid Dynamics (CFD)** and applied to a **Combustion** use-case. ### Model Project Files @@ -136,8 +136,8 @@ You can find, in all model project directories, a ``README.md`` file that descri - Computational Fluid Dynamics - Combustion - - [Unets](cfd/combustion/unets/README.md) - - [GNNs](cfd/combustion/gnns/README.md) + - [Unets](reactive-flows/cnf-combustion/unets/README.md) + - [GNNs](reactive-flows/cnf-combustion/gnns/README.md) - Weather Forecast - Gravity Wave Drag @@ -147,6 +147,14 @@ You can find, in all model project directories, a ``README.md`` file that descri ### Launch the Training +The trainings are launched using the Lightning CLI, configured using YAML files. In the configuration files, you can use the variables interpolation feature from [Omegaconf](https://omegaconf.readthedocs.io/en/latest/), to set some variables. + +By default, you can set 2 environment variables that will be passed to the Lightning CLI configuration files: +- **DATADIR**: the path where your dataset is stored, +- **LOGDIR**: the path where the lightning logs, artifacts and plots will be stored. + +These environment variables are optional, while the Lightning CLI configuration files set default values for these variables. + #### Docker Container Using the docker image described at [Setting-up the environment](#setting-up-the-environment), you can launch the training of the model with: @@ -338,7 +346,7 @@ The 4 following parameters are mandatory and must be passed to the Dockerfile, u - UBUNTU_IMAGE_TAG: the base Ubuntu docker image tag indicated in the ``env.yaml`` file. - PYTHON_VERS: the Python version indicated in the ``env.yaml`` file. -To build the Docker image from the repository root directory: +To build the Docker image from the repository root directory, for example: ```bash docker build \ @@ -347,7 +355,11 @@ docker build \ --build-arg MODEL_PROJECT_PATH=// \ --build-arg UBUNTU_IMAGE_NAME=nvidia/cuda \ --build-arg UBUNTU_IMAGE_TAG=11.7.1-cudnn8-runtime-ubuntu20.04 \ - --build-arg PYTHON_VERS=3.8 + --build-arg PYTHON_VERS=3.8 \ + --build-arg uid=$(id -u) \ + --build-arg gid=$(id -g) \ + --build-arg uname=$(id -un) \ + --build-arg gname=$(id -gn) ``` Finally, start the container, binding your source code path to ease the development: @@ -398,6 +410,20 @@ Nevertheless, if after all your best effort, you think a checkstyle violation ca example = lambda: 'example' # noqa: E731 ``` +In addition to the pure flake8 linting the CI/CD will check the import sorting using [isort](https://pycqa.github.io/isort/) and the code format using [black](https://github.com/psf/black). + +You can evaluate the compliancy of your code running: +```bash +nox -s import_sort -v -- check-only +nox -s black -v -- check-only +``` + +In case of unconsistencies, you can let *isort* and *black* do the job, removing the `-- check-only` option to the previous nox targets: +```bash +nox -s import_sort -v +nox -s black -v +``` + ##### Unit Tests The new code should be provided with as many unit tests as possible. Because the main part of the code is based on *lightning* and *torch*, it is not interesting to test all classes and methods inherited from these libraries, but there is still some part of the code interesting to be tested. @@ -455,7 +481,7 @@ Before creating the *Pull Request* itself, you must generate the final *requirem In your development environment use: ```bash -pip freeze > requirements.txt +pip freeze --all > requirements.txt ``` Then commit this last change. @@ -477,8 +503,8 @@ jobs: strategy: matrix: model-project: - - cfd/combustion/gnns - - cfd/combustion/unets + - reactive-flows/cnf-combustion/gnns + - reactive-flows/cnf-combustion/unets - weather-forecast/gravity-wave-drag/cnns - weather-forecast/ecrad-3d-correction/unets - // <-- Your new model project path diff --git a/cfd/README.md b/cfd/README.md deleted file mode 100644 index 85c7558a..00000000 --- a/cfd/README.md +++ /dev/null @@ -1,17 +0,0 @@ -# CNF Use-Case - -The following is an effort to improve sub-grid scale LES models for combustion using artificial intelligence. This work is made under the RAISE european project: https://www.coe-raise.eu/ - -## Description - -In the combustion community, the determination of the sub-grid scale contribution to the filtered reaction rate in reacting flows Large Eddy Simulation (LES) is an example of closure problem that has been daunting for a long time. A new approach is proposed for premixed turbulent combustion modeling based on convolutional neural networks by reformulating the problem of subgrid flame surface density estimation as a machine learning task. In order to train a neural network for this task, a Direct Numerical Simulation (DNS) and the equivalent LES obtained by a spatial filtering of this DNS is needed. -In a first step, two DNS of a methane-air slot burner are run and then filtered to create the training dataset. Models are trained on this data in a supervised manner. In a second step, a new, unseen and more difficult case was used to ensure network capabilities. -This third DNS is a short-term transient started from the last field of the second DNS, where inlet velocity is doubled, going from 10 to 20 m/s for 1 ms, and then set back to its original value for 2 more ms. - -## Dataset - -The dataset can be [downloaded here](https://www.coe-raise.eu/open-data), which contains 113 scalar fields for a progress variable (input) and the target value of the flame surface density (output) used in for a LES combustion model. Those fields are obtained from DNS simulations and filtered to match a typical LES simulation. More details on how the dataset is created in the preprint [Lapeyre et al. (2018)](https://arxiv.org/abs/1810.03691) - -## Models - -This problem is approached two ways: via CNNs and with GNNs. A 3D U-net approach is used first to match the Lapeyre's paper. However, CNNs are hardly applicable in complex non-structured grids. GNNs, however, are more suitable for working with unstructured, complex geometries. diff --git a/cfd/combustion/__init__.py b/cfd/combustion/__init__.py deleted file mode 100644 index e69de29b..00000000 diff --git a/cfd/combustion/gnns/.gitignore b/cfd/combustion/gnns/.gitignore deleted file mode 100644 index ca0dfbf5..00000000 --- a/cfd/combustion/gnns/.gitignore +++ /dev/null @@ -1,5 +0,0 @@ -data/* -experiments/ -_/ -*.ipynb_checkpoints -**/__pycache__ diff --git a/cfd/combustion/gnns/README.md b/cfd/combustion/gnns/README.md deleted file mode 100644 index 05e06855..00000000 --- a/cfd/combustion/gnns/README.md +++ /dev/null @@ -1,27 +0,0 @@ -# Combustion - -## Description - - -## Dataset - -Download the dataset using ... - -## Models - -X: - -- ?? - - -Y: - -- ?? - - -Four GNN approaches were considered: - -1. A GAT ... -2. A GCN ... -3. A GIN ... -4. A GUnet ... diff --git a/cfd/combustion/gnns/ci/requirements_data.txt b/cfd/combustion/gnns/ci/requirements_data.txt deleted file mode 100644 index 65932375..00000000 --- a/cfd/combustion/gnns/ci/requirements_data.txt +++ /dev/null @@ -1,4 +0,0 @@ -randomname==0.1.5 -numpy==1.21.2 -pyyaml==6.0 -h5py==3.4.0 \ No newline at end of file diff --git a/cfd/combustion/gnns/config.py b/cfd/combustion/gnns/config.py deleted file mode 100755 index afc8f46a..00000000 --- a/cfd/combustion/gnns/config.py +++ /dev/null @@ -1,108 +0,0 @@ -"""This module configures the experiment environment.""" -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -import os -import yaml -import randomname - - -# CAUTION : A refactoring of this file might be requiered for further development -# raw_data_path to be adapted to your local data path. -source_raw_data_path = "/path/to/your/local/data" -# - -root_path = os.path.dirname(os.path.realpath(__file__)) -data_path = os.path.join(root_path, 'data') - -# Create all path for the current experiment -experiments_path = os.path.join(root_path, 'experiments') -os.makedirs(experiments_path, exist_ok=True) -_existing_xps = os.listdir(experiments_path) - -# Generate experiment name -_randomize_name = True -while _randomize_name: - _experiment_name = randomname.get_name() - if _experiment_name not in _existing_xps: - break - -experiment_path = os.path.join(experiments_path, _experiment_name) - -if os.getenv("AI4SIM_EXPERIMENT_PATH") is None: - os.environ["AI4SIM_EXPERIMENT_PATH"] = experiment_path -else: - experiment_path = os.getenv("AI4SIM_EXPERIMENT_PATH") - -logs_path = os.path.join(experiment_path, 'logs') -artifacts_path = os.path.join(experiment_path, 'artifacts') -plots_path = os.path.join(experiment_path, 'plots') - -_paths = [ - experiment_path, - logs_path, - artifacts_path, - plots_path -] -for path in _paths: - os.makedirs(path, exist_ok=True) - - -class LinkRawData: - """Link dataset to the use case.""" - - def __init__(self, source_raw_data_path, data_path): - """Link the source_raw_data_path in the data_path, if it does not already exists.""" - self.source_raw_data_path = source_raw_data_path - self.local_data_path = data_path - self.local_raw_data = os.path.join(self.local_data_path, 'raw') - - if os.path.exists(self.source_raw_data_path): - if os.path.exists(self.local_raw_data): - try: - if len(os.listdir(self.local_raw_data)) == 0 \ - or os.readlink(self.local_raw_data) != self.source_raw_data_path: - self.rm_old_dataset() - self.symlink_dataset() - else: - pass - except OSError: - pass - else: - self.symlink_dataset() - - def symlink_dataset(self): - """Create the filenames.yaml file from the content of the source_raw_data_path.""" - filenames = os.listdir(self.source_raw_data_path) - temp_file_path = os.path.join(self.local_data_path, 'filenames.yaml') - with open(temp_file_path, 'w') as file: - yaml.dump(filenames, file) - - if not os.path.exists(self.local_raw_data): - os.makedirs(self.local_raw_data, exist_ok=True) - - for filename in filenames: - os.symlink( - os.path.join(self.source_raw_data_path, filename), - os.path.join(self.local_raw_data, filename) - ) - - def rm_old_dataset(self): - """Clean the local_data_path.""" - for item in ['raw', 'filenames.yaml', 'processed']: - file_location = os.path.join(self.local_data_path, item) - try: - os.remove(file_location) - except IsADirectoryError: - os.rmdir(file_location) - else: - pass diff --git a/cfd/combustion/gnns/notebooks/R2-GIN-to-R3.ipynb b/cfd/combustion/gnns/notebooks/R2-GIN-to-R3.ipynb deleted file mode 100644 index 748307fc..00000000 --- a/cfd/combustion/gnns/notebooks/R2-GIN-to-R3.ipynb +++ /dev/null @@ -1,355 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "4e551f1c", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - }, - { - "data": { - "text/html": [ - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "%reload_ext autoreload\n", - "%load_ext autoreload\n", - "%autoreload 2\n", - "\n", - "from IPython.display import display, HTML\n", - "display(HTML(\"\"))\n", - "\n", - "import os\n", - "import sys\n", - "import torch\n", - "from pytorch_lightning.utilities.cli import LightningCLI\n", - "import numpy as np\n", - "\n", - "# Add GNN use-case modules to the python path while it is not importable as a lib.\n", - "sys.path.append(os.path.dirname(os.getcwd()))\n", - "from plotters import Plotter\n", - "from inferer import InferencePthGnn\n", - "import data # required for CLI be functional. WHy Lightning is so capricious ??" - ] - }, - { - "cell_type": "markdown", - "id": "c27c72f0", - "metadata": {}, - "source": [ - "# Inference" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "c8e7795e", - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "GPU available: True, used: True\n", - "TPU available: False, using: 0 TPU cores\n", - "IPU available: False, using: 0 IPUs\n" - ] - } - ], - "source": [ - "# patch the sys.argv to add the GIN config file used from the training of this GNN\n", - "sys.argv = [sys.argv[0]]\n", - "sys.argv.extend([\"--config\", \"../configs/gin.yaml\"])\n", - "cli = LightningCLI(run=False)\n", - "\n", - "inferer = InferencePthGnn(\n", - " model_path=\"/scratch/vincentl/ai4sim/gnn_r2_r3_exp/exp_save/gin_1000epoch_0.96r2/offline-burrito/logs/version_0/checkpoints/epoch=999-step=35999.ckpt\",\n", - " data_path='/net/172.16.118.188/data/raise/R2_flame/combustiondatabase/R2-filtered/R3-data/smaller_new_filt_15_F_4_cropped_progvar_R3.h5',\n", - " model_class=cli.model.__class__,\n", - " wkd = \"/scratch/vincentl/ai4sim/gnn_r2_r3_exp/\"\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "ddd88eb7", - "metadata": {}, - "outputs": [], - "source": [ - "inferer.preprocess(save=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "0be30aee", - "metadata": {}, - "outputs": [], - "source": [ - "output = inferer.predict()" - ] - }, - { - "cell_type": "markdown", - "id": "cef8019f", - "metadata": {}, - "source": [ - "# Post inference analysis" - ] - }, - { - "cell_type": "markdown", - "id": "ffb7d1c3", - "metadata": {}, - "source": [ - "## Data formating and Ground truth retrieval" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "7c031072", - "metadata": {}, - "outputs": [], - "source": [ - "NORM_VAL = 3295.4\n", - "\n", - "output = torch.reshape(output, (29, 241, 699))\n", - "\n", - "out = output.detach().numpy().T\n", - "y_gt_dns = inferer.load_y_dns().T / NORM_VAL\n", - "y_gt_les = inferer.load_y_les().T / NORM_VAL\n", - "\n", - "out_n = out[np.newaxis]\n", - "y_gt_dns_n = y_gt_dns[np.newaxis]\n", - "y_gt_les_n = y_gt_les[np.newaxis]" - ] - }, - { - "cell_type": "markdown", - "id": "0b2106c4", - "metadata": {}, - "source": [ - "## Plotting" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "2db0dfa5", - "metadata": {}, - "outputs": [], - "source": [ - "# If the plot will be saved as image or not\n", - "save = False" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "f11560eb", - "metadata": {}, - "outputs": [ - { - "data": { - "image/jpeg": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot = Plotter('R2 to R3', out_n[0].shape)\n", - "plot.total_flame_surface(y_gt_dns_n, out_n, save=save)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "d900c1fe", - "metadata": {}, - "outputs": [ - { - "data": { - "image/jpeg": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "section = 14\n", - "plot.cross_section(section, y_gt_dns_n, out_n, \"DNS\", \"GNN prediction\", norm_val=NORM_VAL, save=save)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "f96b0eb3", - "metadata": {}, - "outputs": [ - { - "data": { - "image/jpeg": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot = Plotter('DNS vs LES', out_n[0].shape)\n", - "plot.cross_section(section, y_gt_dns_n, y_gt_les_n, \"DNS\", \"LES\", norm_val=NORM_VAL, save=save)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "505267f1", - "metadata": {}, - "outputs": [ - { - "data": { - "image/jpeg": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot = Plotter('GNN vs LES', out_n[0].shape)\n", - "plot.cross_section(section, y_gt_les_n, out_n, \"LES\", \"GNN prediction\", norm_val=NORM_VAL, save=save)" - ] - }, - { - "cell_type": "markdown", - "id": "95ff0009", - "metadata": {}, - "source": [ - "## Comparison with the CERFAS CNN" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "cc52456e", - "metadata": {}, - "outputs": [], - "source": [ - "#Load the inference result of the CNN (!! cerfacs_cnn.npy file not provided, please refer to the notebook \"atos_predict_R3.ipynb\" provided by the CERFACS to generate these data !!)\n", - "pred = np.load(\"/scratch/vincentl/ai4sim/gnn_r2_r3_exp/cerfacs_cnn.npy\")\n", - "pred_n = pred[np.newaxis]" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "125e7165", - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "image/jpeg": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_cnn = Plotter('CNN vs GNN', pred_n[0].shape)\n", - "plot_cnn.total_flame_surface(y_target=y_gt_dns_n, y_hat=out_n, y_hat_2=pred_n, y_hat_3=y_gt_les_n, target_title=\"Ground Truth DNS\", pred_3_title='LES', save=save)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "42478adc", - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "image/jpeg": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_cnn.cross_section(zslice=section, y_val=pred_n, y_hat=out_n[:, :480, :-1, :-1], y_title=\"CNN Prediction\", y_hat_title=\"GNN prediction\", norm_val=NORM_VAL, save=save)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "6ec8bb34", - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "image/jpeg": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_cnn = Plotter('DNS vs CNN', pred_n[0].shape)\n", - "plot_cnn.cross_section(zslice=section, y_hat=pred_n, y_val=y_gt_dns_n[:, :480, :-1, :-1], y_hat_title=\"CNN Prediction\", y_title=\"DNS\", norm_val=NORM_VAL, save=save)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.0" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": {}, - "version_major": 2, - "version_minor": 0 - } - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} \ No newline at end of file diff --git a/cfd/combustion/gnns/plotters.py b/cfd/combustion/gnns/plotters.py deleted file mode 100644 index 7cff7c95..00000000 --- a/cfd/combustion/gnns/plotters.py +++ /dev/null @@ -1,243 +0,0 @@ -"""This module proposes some utils features to plot results of the model.""" -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -import os -import matplotlib.pyplot as plt -from matplotlib.lines import Line2D -from matplotlib.colors import LogNorm -import numpy as np -import plotly.graph_objects as go -from plotly.subplots import make_subplots -import torch - -import config - -plt.style.use('bmh') -plt.rcParams.update({'font.size': 22}) - - -class Plotter: - """The Plotter class aims at providing some utils to appreciate the training results..""" - - def __init__(self, - model_type: torch.Tensor, - grid_shape: torch.Tensor, - zslice: int = 16) -> None: - """Init the Plotter.""" - self.model_type = model_type - self.grid_shape = grid_shape - self.zslice = zslice - - self.label_target = r"$\overline{\Sigma}_{target}$" - self.label_predicted = rf"$\overline{{\Sigma}}_{{{self.model_type}}}$" - - def dispersion_plot(self, - y_val: np.ndarray, - y_hat: np.ndarray, - plot_path=config.plots_path) -> None: - """Plot the dispersion and save it in image.""" - bins = np.linspace(0, 1250, 10) - error = np.zeros((bins.shape[0], 2)) - err = np.sqrt((y_val - y_hat)**2) - for i in range(len(bins) - 1): - idx = np.logical_and(y_val.flatten() >= bins[i], y_val.flatten() < bins[i + 1]) - if np.all(idx): - error[i, 0] = err.flatten()[idx].mean() - error[i, 1] = err.flatten()[idx].std() - - fig, ax = plt.subplots(figsize=(15, 8)) - ax.plot(bins[:-1], error[:-1, 0]) - ax.fill_between(bins[:-1], - (error[:-1, 0] - error[:-1, 1]), - (error[:-1, 0] + error[:-1, 1]), - color='b', - alpha=.1) - ax.set_xlabel(self.label_target) - ax.set_ylabel(f"$RMSE$({self.label_predicted}, {self.label_target})") - plt.savefig(os.path.join(plot_path, f"dispersion-plot-{self.model_type}.png")) - plt.close() - - def histo(self, y_val: np.ndarray, y_hat: np.ndarray, plot_path=config.plots_path) -> None: - """Plot the histo and save it in image.""" - fig, ax = plt.subplots(figsize=(15, 7)) - ax.hist(y_val.flatten(), - bins=50, - density=False, - histtype="step", - lw=3, - label=self.label_target) - ax.hist(y_hat.flatten(), - bins=50, - density=False, - histtype="step", - lw=3, - label=self.label_predicted) - ax.set_yscale("log") - ax.set_xlabel(r"$\overline{\Sigma}$") - # Create new legend handles but use the colors from the existing ones - handles, labels = ax.get_legend_handles_labels() - new_handles = [Line2D([], [], c=h.get_edgecolor()) for h in handles] - - plt.legend(handles=new_handles, labels=labels) - plt.savefig(os.path.join(plot_path, f"histogram-{self.model_type}.png")) - plt.close() - - def histo2d(self, y_val: np.ndarray, y_hat: np.ndarray, plot_path=config.plots_path) -> None: - """Plot the histo2d and save it in image.""" - fig, ax = plt.subplots(figsize=(12, 8)) - ax.plot(np.linspace(0, 1200, 100), np.linspace(0, 1200, 100), 'black') - histo = ax.hist2d(y_val.flatten(), y_hat.flatten(), bins=100, norm=LogNorm(), cmap='Blues') - plt.colorbar(histo[3]) - ax.set_xlim(-50, 1200) - ax.set_ylim(-50, 1200) - ax.set_xlabel(self.label_target) - ax.set_ylabel(self.label_predicted) - plt.savefig(os.path.join(plot_path, f"histogram2d-{self.model_type}.png")) - plt.close() - - def boxplot(self, y_val: np.ndarray, y_hat: np.ndarray, plot_path=config.plots_path) -> None: - """Plot the boxplot and save it in image.""" - flat_err = [] - y_val = y_val.reshape((-1,) + self.grid_shape) - y_hat = y_hat.reshape((-1,) + self.grid_shape) - for i in range(y_val.shape[0]): - flat_err.append(np.sqrt((y_val[i, :, :, :] - y_hat[i, :, :, :])**2).flatten()) - - fig, ax = plt.subplots(figsize=(20, 10)) - ax.boxplot(flat_err, labels=np.arange(y_val.shape[0]), showmeans=True) - ax.set_xlabel("Snapshot") - ax.set_ylabel(f"$RMSE$({self.label_predicted}, {self.label_target})") - plt.savefig(os.path.join(plot_path, f"boxplot-{self.model_type}")) - plt.close() - - def total_flame_surface(self, - y_target: np.ndarray, - y_hat: np.ndarray, - y_hat_2: np.ndarray = None, - y_hat_3: np.ndarray = None, - target_title: str = "Ground Truth", - pred_title: str = "Prediction GNN", - pred_2_title: str = "Prediction CNN", - pred_3_title: str = "Pred", - save: bool = False, - plot_path=config.plots_path) -> None: - """Plot the total_flame_surface and save it in image.""" - gt_total_flame_surface = np.stack(y_target, axis=0) - gt_total_flame_surface = np.sum(gt_total_flame_surface, axis=(2, 3)) - - pred_total_flame_surface = np.stack(y_hat, axis=0) - pred_total_flame_surface = np.sum(pred_total_flame_surface, axis=(2, 3)) - - if y_hat_2 is not None: - pred_total_flame_surface_2 = np.stack(y_hat_2, axis=0) - pred_total_flame_surface_2 = np.sum(pred_total_flame_surface_2, axis=(2, 3)) - - if y_hat_3 is not None: - pred_total_flame_surface_3 = np.stack(y_hat_3, axis=0) - pred_total_flame_surface_3 = np.sum(pred_total_flame_surface_3, axis=(2, 3)) - - for i in range(gt_total_flame_surface.shape[0]): - fig = go.Figure() - fig.add_trace(go.Scatter(x=np.arange(gt_total_flame_surface.shape[1]), - y=gt_total_flame_surface[i, :], - mode="lines+markers", - name=target_title)) - fig.add_trace(go.Scatter(x=np.arange(gt_total_flame_surface.shape[1]), - y=pred_total_flame_surface[i, :], - mode="lines+markers", - name=pred_title)) - if y_hat_2 is not None: - fig.add_trace(go.Scatter(x=np.arange(gt_total_flame_surface.shape[1]), - y=pred_total_flame_surface_2[i, :], - mode="lines+markers", - name=pred_2_title)) - if y_hat_3 is not None: - fig.add_trace(go.Scatter(x=np.arange(gt_total_flame_surface.shape[1]), - y=pred_total_flame_surface_3[i, :], - mode="lines+markers", - name=pred_3_title)) - fig.update_layout(width=1280, height=640) - fig.update_xaxes(title_text="x position") - fig.update_yaxes(title_text="Total flame surface") - - # fig.show() - if save: - fig.write_image(os.path.join(plot_path, - f"total-flame-surface-{self.model_type}-{i}.png")) - - def cross_section(self, - zslice: int, - y_val: np.ndarray, - y_hat: np.ndarray, - y_title: str = 'Ground Truth', - y_hat_title: str = 'Prediction', - norm_val: float = 1, - save: bool = False, - plot_path=config.plots_path) -> None: - """Plot the cross_section and save it in image.""" - for i in range(y_hat.shape[0]): - y_val = y_val.reshape((-1,) + self.grid_shape) - y_hat = y_hat.reshape((-1,) + self.grid_shape) - - sigma = y_val[i, :, :, :] - sigma = np.moveaxis(sigma, [0, -1], [-1, 0]) - - prediction = y_hat[i, :, :, :] - prediction = np.moveaxis(prediction, [0, -1], [-1, 0]) - - fig = make_subplots(rows=1, cols=6, - subplot_titles=[y_title, y_hat_title, "Difference"], - specs=[[{}, None, {}, None, {}, None]]) - fig.add_trace(go.Contour(z=sigma[zslice, :, :], - zmin=0, - zmax=950 / norm_val, - contours=dict(showlines=False, - showlabels=False,), - line=dict(width=0), - contours_coloring='heatmap', - colorscale="IceFire", - colorbar=dict(x=0.27)), row=1, col=1) - fig.add_trace(go.Contour(z=prediction[zslice, :, :], - zmin=0, - zmax=950 / norm_val, - contours=dict(showlines=False, - showlabels=False,), - line=dict(width=0), - contours_coloring='heatmap', - colorscale="IceFire", - colorbar=dict(x=0.62)), row=1, col=3) - fig.add_trace(go.Contour(z=sigma[zslice, :, :] - prediction[zslice, :, :], - zmin=-300 / norm_val, - zmax=300 / norm_val, - contours=dict(showlines=False, - showlabels=False,), - line=dict(width=0), - contours_coloring='heatmap', - colorscale="RdBu_r", - colorbar=dict(x=0.97)), row=1, col=5) - - fig.update_layout(width=1756, height=450) - fig.update_xaxes(title_text="x direction", row=1, col=1) - fig.update_xaxes(title_text="x direction", row=1, col=3) - fig.update_xaxes(title_text="x direction", row=1, col=5) - fig.update_yaxes(title_text="y direction", row=1, col=1) - fig.update_yaxes(title_text="y direction", row=1, col=3) - fig.update_yaxes(title_text="y direction", row=1, col=5) - fig.update_layout(xaxis=dict(domain=[0, 0.27]), - xaxis2=dict(domain=[0.35, 0.62]), - xaxis3=dict(domain=[0.7, 0.97]) - ) - - # fig.show() - if save: - fig.write_image(os.path.join(plot_path, f"cross-section-{self.model_type}-{i}.png")) diff --git a/cfd/combustion/gnns/requirements.txt b/cfd/combustion/gnns/requirements.txt deleted file mode 100644 index 2faf56af..00000000 --- a/cfd/combustion/gnns/requirements.txt +++ /dev/null @@ -1,86 +0,0 @@ -absl-py==2.1.0 -aiohttp==3.9.5 -aiosignal==1.3.1 -argcomplete==3.3.0 -async-timeout==4.0.3 -attrs==23.2.0 -cachetools==5.3.3 -certifi==2024.2.2 -charset-normalizer==3.3.2 -colorlog==6.8.2 -cycler==0.12.1 -distlib==0.3.8 -docstring_parser==0.16 -filelock==3.14.0 -fire==0.6.0 -frozenlist==1.4.1 -fsspec==2024.5.0 -future==1.0.0 -google-auth==2.29.0 -google-auth-oauthlib==1.0.0 -googledrivedownloader==0.4 -grpcio==1.64.0 -h5py==3.4.0 -idna==3.7 -importlib_metadata==7.1.0 -isodate==0.6.1 -Jinja2==3.1.4 -joblib==1.4.2 -jsonargparse==4.3.0 -kaleido==0.2.1 -kiwisolver==1.4.5 -Markdown==3.6 -MarkupSafe==2.1.5 -matplotlib==3.4.3 -multidict==6.0.5 -networkx==2.6.3 -nox==2024.4.15 -numpy==1.21.2 -oauthlib==3.2.2 -packaging==24.0 -pandas==2.0.3 -pillow==10.3.0 -pip==24.0 -platformdirs==4.2.2 -plotly==5.3.1 -protobuf==5.27.0 -pyasn1==0.6.0 -pyasn1_modules==0.4.0 -pyDeprecate==0.3.1 -pyparsing==3.1.2 -python-dateutil==2.9.0.post0 -pytorch-lightning==1.5.7 -pytorch-ranger==0.1.1 -pytz==2024.1 -PyYAML==6.0 -randomname==0.1.5 -rdflib==7.0.0 -requests==2.32.3 -requests-oauthlib==2.0.0 -rsa==4.9 -scikit-learn==1.3.2 -scipy==1.10.1 -setuptools==45.2.0 -six==1.16.0 -tenacity==8.3.0 -tensorboard==2.14.0 -tensorboard-data-server==0.7.2 -termcolor==2.4.0 -threadpoolctl==3.5.0 -tomli==2.0.1 -torch==1.13.1+cu117 -torch-geometric==2.0.3 -torch-optimizer==0.1.0 -torch-scatter==2.0.9 -torch-sparse==0.6.17+pt113cu117 -torchmetrics==0.5.1 -tqdm==4.66.4 -typing_extensions==4.12.0 -tzdata==2024.1 -urllib3==2.2.1 -virtualenv==20.26.2 -Werkzeug==3.0.3 -wheel==0.34.2 -yacs==0.1.8 -yarl==1.9.4 -zipp==3.19.0 \ No newline at end of file diff --git a/cfd/combustion/gnns/tests/test_config.py b/cfd/combustion/gnns/tests/test_config.py deleted file mode 100644 index 7417e5fe..00000000 --- a/cfd/combustion/gnns/tests/test_config.py +++ /dev/null @@ -1,91 +0,0 @@ -"""This module provides a test suite for the config.py file.""" -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -import h5py -import os -import tempfile -import unittest -import yaml -import warnings -import numpy as np -import subprocess - -import config - - -class TestConfig(unittest.TestCase): - """Config test file.""" - - def test_experiment_path(self): - """Test if config creates the correct experiment path.""" - self.assertTrue(os.path.exists(config.experiment_path)) - self.assertTrue(os.getenv("AI4SIM_EXPERIMENT_PATH"), config.experiment_path) - # Execute again config.py to ensure experiment_path is given by AISIM_EXPERIMENT_PATH - subprocess.run(['python3', os.path.join(os.path.dirname(os.getcwd()), "config.py")]) - self.assertTrue(config.experiment_path, os.getenv("AI4SIM_EXPERIMENT_PATH")) - - def test_logs_path(self): - """Test if config creates the correct logs path.""" - self.assertTrue(os.path.exists(config.logs_path)) - - def test_artifacts_path(self): - """Test if config creates the correct artifacts path.""" - self.assertTrue(os.path.exists(config.artifacts_path)) - - def test_plots_path(self): - """Test if config creates the correct plots path.""" - self.assertTrue(os.path.exists(config.plots_path)) - - def create_env(self, tempdir): - """Create a test environment and data test.""" - os.makedirs(os.path.join(tempdir, "raw_data"), exist_ok=True) - os.makedirs(os.path.join(tempdir, "local_data"), exist_ok=True) - os.makedirs(os.path.join(tempdir, "local_data", "raw"), exist_ok=True) - os.makedirs(os.path.join(tempdir, "local_data", "processed"), exist_ok=True) - - self.filenames = ['DNS1_00116000.h5', 'DNS1_00117000.h5', 'DNS1_00118000.h5'] - for file_h5 in self.filenames: - with h5py.File(os.path.join(tempdir, "raw_data", file_h5), 'w') as file: - file['filt_8'] = np.zeros((10, 10, 10)) - file['filt_grad_8'] = np.zeros((10, 10, 10)) - file['grad_filt_8'] = np.zeros((10, 10, 10)) - - temp_file_path = os.path.join(tempdir, 'local_data', 'filenames.yaml') - with open(temp_file_path, 'w') as tmpfile: - _ = yaml.dump(self.filenames, tmpfile) - - def create_obj_rm_warning(self, raw_path, local_path): - """Instantiante the CombustionDataset object with a warning filtering.""" - with warnings.catch_warnings(): - warnings.simplefilter("ignore") - return config.LinkRawData(raw_path, local_path) - - def test_linkrawdata(self): - """Test the LinkRawData class.""" - with tempfile.TemporaryDirectory() as tempdir: - self.create_env(tempdir) - - self.create_obj_rm_warning( - os.path.join(tempdir, "raw_data"), - os.path.join(tempdir, "local_data") - ) - num_files_raw_path = len(os.listdir(os.path.join(tempdir, "raw_data"))) - local_filenames = os.listdir(os.path.join(tempdir, "local_data", "raw")) - num_files_local_path = len(local_filenames) - - self.assertTrue(num_files_raw_path, num_files_local_path) - self.assertTrue(self.filenames, local_filenames) - - -if __name__ == '__main__': - unittest.main() diff --git a/cfd/combustion/gnns/tests/test_data/test_model.ckpt b/cfd/combustion/gnns/tests/test_data/test_model.ckpt deleted file mode 100644 index dc75242e515f6cc8081757e12d58c4d76dd2fd31..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 96730 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 diff --git a/cfd/combustion/gnns/tests/test_plotter.py b/cfd/combustion/gnns/tests/test_plotter.py deleted file mode 100644 index 3f3c4d4f..00000000 --- a/cfd/combustion/gnns/tests/test_plotter.py +++ /dev/null @@ -1,117 +0,0 @@ -"""This module provide a test suite for the plotter.py file.""" -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -import unittest -import plotters -import tempfile -import numpy as np -import os - - -class TestPlotters(unittest.TestCase): - """Plotter test file.""" - - def setUp(self) -> None: - """Define default parameters.""" - grid = 10 - self.f_num = 3 - - self.grid = (grid, grid, grid) - self.model_type = "pytorch" - self.y = np.stack( - [1 + np.random.randn(grid, grid, grid) for _ in range(self.f_num)], - axis=0 - ) - self.y_hat = np.stack( - [1 + np.random.randn(grid, grid, grid) for _ in range(self.f_num)], - axis=0 - ) - - def test_dispersion_plot(self): - """Test the "dispersion_plot" produces the result file.""" - with tempfile.TemporaryDirectory() as tempdir: - tt = plotters.Plotter(self.model_type, self.grid) - tt.dispersion_plot(self.y, self.y_hat, tempdir) - - self.assertTrue(len(os.listdir(tempdir)) == 1) - self.assertTrue(os.path.exists(os.path.join(tempdir, - f"dispersion-plot-{self.model_type}.png"))) - - def test_histo(self): - """Test the "histo" produces the result file.""" - with tempfile.TemporaryDirectory() as tempdir: - tt = plotters.Plotter(self.model_type, self.grid) - tt.histo(self.y, self.y_hat, tempdir) - - self.assertTrue(len(os.listdir(tempdir)) == 1) - self.assertTrue(os.path.exists(os.path.join(tempdir, - f"histogram-{self.model_type}.png"))) - - def test_histo2d(self): - """Test the "histo2d" produces the result file.""" - with tempfile.TemporaryDirectory() as tempdir: - - tt = plotters.Plotter(self.model_type, self.grid) - tt.histo2d(self.y, self.y_hat, tempdir) - - self.assertTrue(len(os.listdir(tempdir)) == 1) - self.assertTrue(os.path.exists(os.path.join(tempdir, - f"histogram2d-{self.model_type}.png"))) - - def test_boxplot(self): - """Test the "boxplot" produces the result file.""" - with tempfile.TemporaryDirectory() as tempdir: - tt = plotters.Plotter(self.model_type, self.grid) - tt.boxplot(self.y, self.y_hat, tempdir) - - self.assertTrue(len(os.listdir(tempdir)) == 1) - self.assertTrue(os.path.exists(os.path.join(tempdir, - f"boxplot-{self.model_type}.png"))) - - def test_total_flame_surface(self): - """Test the "total_flame_surface" produces the result files.""" - with tempfile.TemporaryDirectory() as tempdir: - tt = plotters.Plotter(self.model_type, self.grid) - tt.total_flame_surface(self.y, self.y_hat, plot_path=tempdir, save=True) - - self.assertEqual(len(os.listdir(tempdir)), self.f_num) - self.assertTrue(os.path.exists(os.path.join( - tempdir, - f"total-flame-surface-{self.model_type}-0.png")) - ) - self.assertTrue(os.path.exists(os.path.join( - tempdir, - f"total-flame-surface-{self.model_type}-1.png")) - ) - self.assertTrue(os.path.exists(os.path.join( - tempdir, - f"total-flame-surface-{self.model_type}-2.png")) - ) - - def test_cross_section(self): - """Test the "cross_section" produces the result files.""" - with tempfile.TemporaryDirectory() as tempdir: - tt = plotters.Plotter(self.model_type, self.grid) - tt.cross_section(1, self.y, self.y_hat, plot_path=tempdir, save=True) - - self.assertEqual(len(os.listdir(tempdir)), self.f_num) - self.assertTrue(os.path.exists(os.path.join(tempdir, - f"cross-section-{self.model_type}-0.png"))) - self.assertTrue(os.path.exists(os.path.join(tempdir, - f"cross-section-{self.model_type}-1.png"))) - self.assertTrue(os.path.exists(os.path.join(tempdir, - f"cross-section-{self.model_type}-2.png"))) - - -if __name__ == '__main__': - unittest.main() diff --git a/cfd/combustion/gnns/tests/test_trainer.py b/cfd/combustion/gnns/tests/test_trainer.py deleted file mode 100644 index 4d35cc2b..00000000 --- a/cfd/combustion/gnns/tests/test_trainer.py +++ /dev/null @@ -1,51 +0,0 @@ -"""This module proposes a test suite for the trainer module.""" -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -import unittest -import warnings -import torch - -from trainer import Trainer - - -class TestTrainer(unittest.TestCase): - """Trainer test suite.""" - - def setUp(self) -> None: - """Define default parameters.""" - self.args_cpu = { - "max_epochs": 1, - "accelerator": "cpu", - "devices": [0] - } - self.args_gpu = { - "max_epochs": 1, - "accelerator": "gpu", - "devices": [0] - } - - def test_trainer(self) -> None: - """Test trainer file.""" - if torch.cuda.is_available(): - _ = Trainer(**self.args_gpu) - - # avoids GPU warning when testing CPU usage. - with warnings.catch_warnings(): - warnings.simplefilter("ignore") - - test_trainer_cpu = Trainer(**self.args_cpu) - self.assertEqual(test_trainer_cpu._devices, None) - - -if __name__ == '__main__': - unittest.main() diff --git a/cfd/combustion/gnns/trainer.py b/cfd/combustion/gnns/trainer.py deleted file mode 100755 index e58eb283..00000000 --- a/cfd/combustion/gnns/trainer.py +++ /dev/null @@ -1,89 +0,0 @@ -"""This module proposes a Pytorch Lightning style Trainer class for the gnn use-case.""" -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -import json -import logging -import os -import pytorch_lightning as pl -from pytorch_lightning.callbacks.base import Callback -from pytorch_lightning.utilities.cli import LightningCLI -import torch -from typing import List, Union - -import config -import data # noqa: F401 'data' imported but unused - - -class Trainer(pl.Trainer): - """ - Modified PyTorch Lightning Trainer that automatically tests, logs, and writes artifacts by - the end of training. - """ - - def __init__(self, - accelerator: Union[str, pl.accelerators.Accelerator, None], - devices: Union[List[int], str, int, None], - max_epochs: int, - # TODO: delete. - # For some reason, those two are mandatory in current version of Lightning. - fast_dev_run: Union[int, bool] = False, - callbacks: Union[List[Callback], Callback, None] = None) -> None: - """Init the Trainer. - - Args: - accelerator (Union[str, pl.accelerators.Accelerator, None]): Type of accelerator to use - for training. - devices: (Union[List[int], str, int, None]): Devices explicit names to use for training. - max_epochs (int): Maximum number of epochs if no early stopping logic is implemented. - """ - self._accelerator = accelerator - self._devices = devices - self._max_epochs = max_epochs - - if self._accelerator == 'cpu': - self._devices = None - - logger = pl.loggers.TensorBoardLogger(config.logs_path, name=None) - super().__init__( - default_root_dir=config.logs_path, - logger=logger, - accelerator=self._accelerator, - devices=self._devices, - max_epochs=self._max_epochs, - num_sanity_val_steps=0) - - def save(self, results, path=config.artifacts_path): - """Save the results of the training and the learned model.""" - result_file = os.path.join(config.artifacts_path, "results.json") - with open(result_file, "w") as f: - json.dump(results, f) - - torch.save(self.model, os.path.join(path, 'model.pth')) - logging.info(f"Torch model saved in {os.path.join(path, 'model.pth')}") - - def test(self, **kwargs) -> None: - """Use superclass test results, but additionally, saves raw results as a JSON file, - and stores the model weights for future use in inference mode. - - Returns: - None - """ - results = super().test(**kwargs)[0] - - self.save(results) - - -if __name__ == '__main__': - cli = LightningCLI(trainer_class=Trainer, run=False) - cli.trainer.fit(model=cli.model, datamodule=cli.datamodule) - cli.trainer.test(model=cli.model, datamodule=cli.datamodule) diff --git a/cfd/combustion/unets/.gitignore b/cfd/combustion/unets/.gitignore deleted file mode 100644 index e02e4239..00000000 --- a/cfd/combustion/unets/.gitignore +++ /dev/null @@ -1,4 +0,0 @@ -!data -data/* -!data/filenames.yaml -!data/filenames-split.yaml diff --git a/cfd/combustion/unets/README.md b/cfd/combustion/unets/README.md deleted file mode 100644 index c4a2bb03..00000000 --- a/cfd/combustion/unets/README.md +++ /dev/null @@ -1,24 +0,0 @@ -# Combustion - -## Description - - -## Dataset - -Download the dataset using ... - -## Models - -X: - -- ?? - - -Y: - -- ?? - - -One approaches was considered: - -1. A 3D Unet ... diff --git a/cfd/combustion/unets/ci/requirements_data.txt b/cfd/combustion/unets/ci/requirements_data.txt deleted file mode 100644 index 65932375..00000000 --- a/cfd/combustion/unets/ci/requirements_data.txt +++ /dev/null @@ -1,4 +0,0 @@ -randomname==0.1.5 -numpy==1.21.2 -pyyaml==6.0 -h5py==3.4.0 \ No newline at end of file diff --git a/cfd/combustion/unets/config.py b/cfd/combustion/unets/config.py deleted file mode 100755 index c370ad2b..00000000 --- a/cfd/combustion/unets/config.py +++ /dev/null @@ -1,45 +0,0 @@ -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -import os -from randomname import get_name -from os.path import dirname, join, realpath - -root_path = dirname(realpath(__file__)) - -data_path = join(root_path, 'data') - -# Create all path for the current experiment -experiments_path = os.path.join(root_path, 'experiments') -os.makedirs(experiments_path, exist_ok=True) -_existing_xps = os.listdir(experiments_path) - -# Generate experiment name -_randomize_name = True -while _randomize_name: - _experiment_name = get_name() - if _experiment_name not in _existing_xps: - break - -experiment_path = os.path.join(experiments_path, _experiment_name) - -if os.getenv("AI4SIM_EXPERIMENT_PATH") is None: - os.environ["AI4SIM_EXPERIMENT_PATH"] = experiment_path -else: - experiment_path = os.getenv("AI4SIM_EXPERIMENT_PATH") - -logs_path = join(experiment_path, 'logs') -artifacts_path = join(experiment_path, 'artifacts') -plots_path = join(experiment_path, 'plots') - -for path in [experiment_path, logs_path, artifacts_path, plots_path]: - os.makedirs(path, exist_ok=True) diff --git a/cfd/combustion/unets/requirements.txt b/cfd/combustion/unets/requirements.txt deleted file mode 100644 index 697b31b5..00000000 --- a/cfd/combustion/unets/requirements.txt +++ /dev/null @@ -1,62 +0,0 @@ -absl-py==2.1.0 -aiohttp==3.9.5 -aiosignal==1.3.1 -argcomplete==3.3.0 -async-timeout==4.0.3 -attrs==23.2.0 -cachetools==5.3.3 -certifi==2024.2.2 -charset-normalizer==3.3.2 -colorlog==6.8.2 -distlib==0.3.8 -docstring_parser==0.16 -filelock==3.14.0 -fire==0.6.0 -frozenlist==1.4.1 -fsspec==2024.5.0 -future==1.0.0 -google-auth==2.29.0 -google-auth-oauthlib==1.0.0 -grpcio==1.64.0 -h5py==3.4.0 -idna==3.7 -importlib_metadata==7.1.0 -jsonargparse==4.3.0 -kaleido==0.2.1 -Markdown==3.6 -MarkupSafe==2.1.5 -multidict==6.0.5 -nox==2024.4.15 -numpy==1.21.2 -oauthlib==3.2.2 -packaging==24.0 -pip==24.0 -platformdirs==4.2.2 -protobuf==5.27.0 -pyasn1==0.6.0 -pyasn1_modules==0.4.0 -pyDeprecate==0.3.1 -pytorch-lightning==1.5.7 -pytorch-ranger==0.1.1 -PyYAML==6.0 -randomname==0.1.5 -requests==2.32.3 -requests-oauthlib==2.0.0 -rsa==4.9 -setuptools==45.2.0 -six==1.16.0 -tensorboard==2.14.0 -tensorboard-data-server==0.7.2 -termcolor==2.4.0 -tomli==2.0.1 -torch==1.13.1+cu117 -torch-optimizer==0.1.0 -torchmetrics==0.5.1 -tqdm==4.66.4 -typing_extensions==4.12.0 -urllib3==2.2.1 -virtualenv==20.26.2 -Werkzeug==3.0.3 -wheel==0.34.2 -yarl==1.9.4 -zipp==3.19.0 \ No newline at end of file diff --git a/cfd/combustion/unets/tests/test_config.py b/cfd/combustion/unets/tests/test_config.py deleted file mode 100644 index ab15654c..00000000 --- a/cfd/combustion/unets/tests/test_config.py +++ /dev/null @@ -1,36 +0,0 @@ -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -import os -import subprocess -from unittest import TestCase, main -from os.path import exists - -import config - - -class TestConfig(TestCase): - - def test_paths(self): - self.assertTrue(exists(config.experiment_path)) - self.assertTrue(os.getenv("AI4SIM_EXPERIMENT_PATH"), config.experiment_path) - # Execute again config.py to ensure experiment_path is given by AISIM_EXPERIMENT_PATH - subprocess.run(['python3', os.path.join(os.path.dirname(os.getcwd()), "config.py")]) - self.assertTrue(config.experiment_path, os.getenv("AI4SIM_EXPERIMENT_PATH")) - - self.assertTrue(exists(config.logs_path)) - self.assertTrue(exists(config.artifacts_path)) - self.assertTrue(exists(config.plots_path)) - - -if __name__ == '__main__': - main() diff --git a/cfd/combustion/unets/tests/test_trainer.py b/cfd/combustion/unets/tests/test_trainer.py deleted file mode 100644 index 0dec88d6..00000000 --- a/cfd/combustion/unets/tests/test_trainer.py +++ /dev/null @@ -1,41 +0,0 @@ -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -from unittest import TestCase, main -from warnings import catch_warnings, simplefilter -from torch import cuda -from trainer import Trainer - - -class TestTrainer(TestCase): - - def setUp(self) -> None: - self.args_cpu = {"max_epochs": 1, - "accelerator": "cpu", - "devices": [0]} - self.args_gpu = {"max_epochs": 1, - "accelerator": "gpu", - "devices": [0]} - - def test_trainer(self) -> None: - if cuda.is_available(): - Trainer(**self.args_gpu) - - # Avoids GPU warning when testing CPU usage. - with catch_warnings(): - simplefilter("ignore") - test_trainer_cpu = Trainer(**self.args_cpu) - self.assertEqual(test_trainer_cpu._devices, None) - - -if __name__ == '__main__': - main() diff --git a/cfd/combustion/unets/trainer.py b/cfd/combustion/unets/trainer.py deleted file mode 100755 index f139d641..00000000 --- a/cfd/combustion/unets/trainer.py +++ /dev/null @@ -1,71 +0,0 @@ -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -import config -from json import dump -from os.path import join -from pytorch_lightning import Trainer -from pytorch_lightning.accelerators import Accelerator -from pytorch_lightning.loggers import TensorBoardLogger -from pytorch_lightning.callbacks.base import Callback -from pytorch_lightning.utilities.cli import LightningCLI -from torch import save -from typing import List, Union - -import data # noqa: F401 'data' imported but unused -import models # noqa: F401 'data' imported but unused - - -class Trainer(Trainer): - - def __init__(self, - accelerator: Union[str, Accelerator, None], - devices: Union[List[int], str, int, None], - max_epochs: int, - fast_dev_run: Union[int, bool] = False, - callbacks: Union[List[Callback], Callback, None] = None) -> None: - """ - Run a training session. - Args: - max_epochs (int): Maximum number of epochs if no early stopping logic is implemented. - """ - self._devices = devices - if accelerator == 'cpu': - self._devices = None - logger = TensorBoardLogger(config.logs_path, name=None) - - super().__init__( - default_root_dir=config.logs_path, - logger=logger, - accelerator=accelerator, - devices=self._devices, - max_epochs=max_epochs,) - - def test(self, **kwargs): - """ - Use superclass test results and save raw results as a JSON file. - Store the model weights for future use in inference mode. - """ - results = super().test(**kwargs)[0] - with open(join(config.artifacts_path, "results.json"), "w") as f: - dump(results, f) - save(self.model, join(config.artifacts_path, 'model.pth')) - - -def main(): - cli = LightningCLI(trainer_class=Trainer, run=False) - cli.trainer.fit(model=cli.model, datamodule=cli.datamodule) - cli.trainer.test(model=cli.model, datamodule=cli.datamodule) - - -if __name__ == '__main__': - main() diff --git a/cfd/get-started.ipynb b/cfd/get-started.ipynb deleted file mode 100644 index c077bb1f..00000000 --- a/cfd/get-started.ipynb +++ /dev/null @@ -1,67 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "5932c1b4-8875-4a8b-84e8-142adf128c85", - "metadata": {}, - "source": [ - "Licensed under the Apache License, Version 2.0 (the \"License\");\n", - "you may not use this file except in compliance with the License.\n", - "You may obtain a copy of the License at\n", - "\n", - " http://www.apache.org/licenses/LICENSE-2.0\n", - "\n", - "Unless required by applicable law or agreed to in writing, software\n", - "distributed under the License is distributed on an \"AS IS\" BASIS,\n", - "WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", - "See the License for the specific language governing permissions and\n", - "limitations under the License." - ] - }, - { - "cell_type": "markdown", - "id": "57cd1a30-78ef-4249-8d35-f97106e1a7be", - "metadata": {}, - "source": [ - "----------" - ] - }, - { - "cell_type": "markdown", - "id": "3ba62240-b4dc-4231-9ba4-c3d786126e1f", - "metadata": {}, - "source": [ - "WORK IN PROGRESS" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "49be4ff7-5d47-4ab8-b9f0-d8217992014a", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.6" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docker/Dockerfile b/docker/Dockerfile index ae79f42f..2549bdca 100644 --- a/docker/Dockerfile +++ b/docker/Dockerfile @@ -26,26 +26,29 @@ RUN apt-get update \ libffi-dev \ vim \ && apt-get clean +RUN ln -sf /usr/bin/python${PYTHON_VERS} /usr/bin/python3 # create user ai4sim ARG uid=1000 ARG gid=1000 -ARG AI4SIM_HOME=/home/ai4sim -RUN groupadd -g ${gid} ai4sim \ - && useradd -u ${uid} -g ${gid} -m -s /bin/bash ai4sim \ - && chown -R ai4sim:ai4sim ${AI4SIM_HOME} +ARG uname=ai4sim +ARG gname=ai4sim +ARG AI4SIM_HOME=/home/${uname} +RUN groupadd -g ${gid} ${gname} \ + && useradd -u ${uid} -g ${gid} -m -s /bin/bash ${uname} \ + && chown -R ${uname}:${gname} ${AI4SIM_HOME} # Retrieve use-case related files -ADD --chown=ai4sim:ai4sim ${MODEL_PROJECT_PATH} ${AI4SIM_HOME}/${MODEL_PROJECT_PATH} -ADD --chown=ai4sim:ai4sim tools ${AI4SIM_HOME}/tools +ADD --chown=${uname}:${gname} ${MODEL_PROJECT_PATH} ${AI4SIM_HOME}/${MODEL_PROJECT_PATH} +ADD --chown=${uname}:${gname} tools ${AI4SIM_HOME}/tools # change user -USER ai4sim -ENV PATH=${PATH}:/home/ai4sim/.local/bin +USER ${uname} +ENV PATH=${PATH}:${AI4SIM_HOME}/.local/bin # Install all the python dependencies in the environment WORKDIR ${AI4SIM_HOME}/${MODEL_PROJECT_PATH} -RUN pip install $(grep nox== ${AI4SIM_HOME}/${MODEL_PROJECT_PATH}/requirements.txt) \ +RUN python3 -m pip install $(grep nox== ${AI4SIM_HOME}/${MODEL_PROJECT_PATH}/requirements.txt || echo "nox") \ && python3 -m nox -s dev_dependencies --no-venv -- purge CMD ["bash"] \ No newline at end of file diff --git a/cfd/__init__.py b/reactive-flows/__init__.py similarity index 100% rename from cfd/__init__.py rename to reactive-flows/__init__.py diff --git a/reactive-flows/cnf-combustion/README.md b/reactive-flows/cnf-combustion/README.md new file mode 100644 index 00000000..bca209ab --- /dev/null +++ b/reactive-flows/cnf-combustion/README.md @@ -0,0 +1,25 @@ +# Reactive flow + +The following is an effort to improve subgrid scale Large Eddy Simulations (LES) for combustion using deep learning models. This work has been carried under the [RAISE](https://www.coe-raise.eu/) European project. + +## Description + +In the combustion community, the determination of the subgrid scale contribution to the filtered reaction rate in reacting flows Large Eddy Simulation (LES) is an example of closure problem that has been daunting for a long time. Various analitical approximations has been proposed to capture the subgrid scale phenomena associated with combustion, but none fully convincingly. A new approach is proposed for premixed turbulent combustion modeling based on neural networks by reformulating the problem of subgrid flame surface density estimation as a machine learning task. In order to train a neural network for this task, a Direct Numerical Simulation (DNS) and the equivalent LES obtained by a spatial filtering of this DNS is needed. + +The whole process then boils down to: +- generate a fully-resolved dataset (DNS) +- filter down the DNS to a reduced-order space +- train a neural network to learn the mapping between features of interest in the reduced-order space +- at inference, run a LES solver in the reduced-order space (to solve the CFD) coupled with the pretrained neural network (to solve the other phenomena, *e.g.* thermodynamics, chemistry) + +## Dataset + +The dataset can be [downloaded here](https://www.coe-raise.eu/od-combustion), which contains 113 scalar fields for a progress variable (input) and the target value of the flame surface density (output) used in for a LES combustion model. Those fields are obtained from DNS simulations and filtered to match a typical LES simulation. More details on how the dataset is generated in the preprint [Lapeyre et al. (2018)](https://arxiv.org/abs/1810.03691) + +## Models + +This problem is approached in two different ways: +- with convolutional neural networks (CNNs): a 3D U-net approach is used first to match [Lapeyre et al. (2018)](https://arxiv.org/abs/1810.03691)'s approch; +- with graph neural networks (GNNs): to directly work with structured and complexed mesh geometries. + +These neural networks differ in the way they encode as inductive bias the problem's geometry. CNNs strength lies in its ability to share weights between translated convolutional kernels, allowing to natively learn translation invariant features. However, their main limitation lies in the Euclidian geometry they assume, requirng to interpolate complex meshes to cartesian grids before using them. On the other hand, GNNs directly work on irregular meshes, with various cell sizes and topologies, allowing to seamlessly process physicals fields sampled on various mesh geometries. diff --git a/cfd/combustion/unets/__init__.py b/reactive-flows/cnf-combustion/__init__.py similarity index 100% rename from cfd/combustion/unets/__init__.py rename to reactive-flows/cnf-combustion/__init__.py diff --git a/cfd/combustion/unets/.coveragerc b/reactive-flows/cnf-combustion/gnns/.coveragerc similarity index 65% rename from cfd/combustion/unets/.coveragerc rename to reactive-flows/cnf-combustion/gnns/.coveragerc index 1e50b0f0..acb4e457 100644 --- a/cfd/combustion/unets/.coveragerc +++ b/reactive-flows/cnf-combustion/gnns/.coveragerc @@ -1,2 +1,3 @@ [run] +include = ./*.py omit = noxfile.py,tests/* diff --git a/reactive-flows/cnf-combustion/gnns/.gitignore b/reactive-flows/cnf-combustion/gnns/.gitignore new file mode 100644 index 00000000..5495c782 --- /dev/null +++ b/reactive-flows/cnf-combustion/gnns/.gitignore @@ -0,0 +1,32 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ + +# Build tool +.nox/ +.ci-reports/ + +# Unit test / coverage reports +.pytest_cache/ +.coverage +.coverage-* +.coverage.* +coverage.xml + +# Jupyter Notebook +.ipynb_checkpoints + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ +.vscode + +# Data +data/ + +# Experiments +experiments/ \ No newline at end of file diff --git a/reactive-flows/cnf-combustion/gnns/README.md b/reactive-flows/cnf-combustion/gnns/README.md new file mode 100644 index 00000000..2067ac74 --- /dev/null +++ b/reactive-flows/cnf-combustion/gnns/README.md @@ -0,0 +1,15 @@ +# Combustion + +## Description + +This use-case is a subcase of the reactive flow aiming at providing a minimum viable coupling between an LES solver and a GNN to provide an end-to-end numerical simulation of combustions on irregular geometrics (*i.e.* with industrailly plausible meshes). + +## Dataset + +The dataset can be downloaded from the Jülich Supercomputing Centre (JSC)'s open-access [JUDAC](https://uftp.fz-juelich.de:9112/UFTP_Auth/rest/access/JUDAC/dc4eef36-1929-41f6-9eb9-c11417be1dcf). + +## Models + +Graph Neural Networks (GNNs, also called *GraphNets*) provide a framework to extract convolution-like features from irregular meshes, considered as graphs. This is especially valuable for CFD as it allows for neural network inference directly on the mesh used by the solder, without resorting to often intractable interpolations to a cartesian grid. Several GNN architectures exist, such as Graph Attention Networks (GAT) from [Veličković et al. (2017)](https://arxiv.org/abs/1710.10903), GIN from [Xu et al. (2018)](https://arxiv.org/abs/1810.00826) etc. + + diff --git a/cfd/combustion/unets/tests/__init__.py b/reactive-flows/cnf-combustion/gnns/__init__.py similarity index 100% rename from cfd/combustion/unets/tests/__init__.py rename to reactive-flows/cnf-combustion/gnns/__init__.py diff --git a/cfd/combustion/gnns/ci/configs/gat_test.yaml b/reactive-flows/cnf-combustion/gnns/ci/configs/gat_test.yaml similarity index 73% rename from cfd/combustion/gnns/ci/configs/gat_test.yaml rename to reactive-flows/cnf-combustion/gnns/ci/configs/gat_test.yaml index 355ea0e6..0b34f9d1 100644 --- a/cfd/combustion/gnns/ci/configs/gat_test.yaml +++ b/reactive-flows/cnf-combustion/gnns/ci/configs/gat_test.yaml @@ -10,6 +10,8 @@ # See the License for the specific language governing permissions and # limitations under the License. +seed_everything: 0 + model: class_path: models.LitGAT init_args: @@ -28,9 +30,14 @@ data: batch_size: 1 num_workers: 0 y_normalizer: 3295.4 + splitting_ratios: [0.8, 0.1, 0.1] + data_path: ${oc.decode:${oc.env:DATADIR, ./data}} trainer: max_epochs: 1 accelerator: "cpu" - devices: - - 0 \ No newline at end of file + devices: ${oc.decode:${oc.env:SLURM_GPUS_ON_NODE, 3}} + logger: + class_path: lightning.pytorch.loggers.tensorboard.TensorBoardLogger + init_args: + save_dir: ${oc.decode:${oc.env:LOGDIR, ./logs}} \ No newline at end of file diff --git a/cfd/combustion/gnns/ci/configs/gcn_test.yaml b/reactive-flows/cnf-combustion/gnns/ci/configs/gcn_test.yaml similarity index 72% rename from cfd/combustion/gnns/ci/configs/gcn_test.yaml rename to reactive-flows/cnf-combustion/gnns/ci/configs/gcn_test.yaml index 2e9b590a..905e14fc 100644 --- a/cfd/combustion/gnns/ci/configs/gcn_test.yaml +++ b/reactive-flows/cnf-combustion/gnns/ci/configs/gcn_test.yaml @@ -10,6 +10,8 @@ # See the License for the specific language governing permissions and # limitations under the License. +seed_everything: 0 + model: class_path: models.LitGCN init_args: @@ -27,16 +29,21 @@ data: batch_size: 1 num_workers: 0 y_normalizer: 3295.4 + splitting_ratios: [0.8, 0.1, 0.1] + data_path: ${oc.decode:${oc.env:DATADIR, ./data}} trainer: max_epochs: 1 accelerator: "cpu" callbacks: - - class_path: pytorch_lightning.callbacks.EarlyStopping + - class_path: lightning.pytorch.callbacks.EarlyStopping init_args: monitor: val_loss patience: 31 mode: min min_delta: 0.0 - devices: - - 0 \ No newline at end of file + devices: ${oc.decode:${oc.env:SLURM_GPUS_ON_NODE, 1}} + logger: + class_path: lightning.pytorch.loggers.tensorboard.TensorBoardLogger + init_args: + save_dir: ${oc.decode:${oc.env:LOGDIR, ./logs}} \ No newline at end of file diff --git a/cfd/combustion/gnns/ci/configs/gin_test.yaml b/reactive-flows/cnf-combustion/gnns/ci/configs/gin_test.yaml similarity index 72% rename from cfd/combustion/gnns/ci/configs/gin_test.yaml rename to reactive-flows/cnf-combustion/gnns/ci/configs/gin_test.yaml index b78d53d6..ddbcbbbc 100644 --- a/cfd/combustion/gnns/ci/configs/gin_test.yaml +++ b/reactive-flows/cnf-combustion/gnns/ci/configs/gin_test.yaml @@ -10,6 +10,8 @@ # See the License for the specific language governing permissions and # limitations under the License. +seed_everything: 0 + model: class_path: models.LitGIN init_args: @@ -26,16 +28,21 @@ data: batch_size: 1 num_workers: 0 y_normalizer: 3295.4 + splitting_ratios: [0.8, 0.1, 0.1] + data_path: ${oc.decode:${oc.env:DATADIR, ./data}} trainer: max_epochs: 1 accelerator: "cpu" callbacks: - - class_path: pytorch_lightning.callbacks.EarlyStopping + - class_path: lightning.pytorch.callbacks.EarlyStopping init_args: monitor: val_loss patience: 30 mode: min min_delta: 0.0 - devices: - - 0 \ No newline at end of file + devices: ${oc.decode:${oc.env:SLURM_GPUS_ON_NODE, 1}} + logger: + class_path: lightning.pytorch.loggers.tensorboard.TensorBoardLogger + init_args: + save_dir: ${oc.decode:${oc.env:LOGDIR, ./logs}} \ No newline at end of file diff --git a/cfd/combustion/gnns/ci/configs/gunet_test.yaml b/reactive-flows/cnf-combustion/gnns/ci/configs/gunet_test.yaml similarity index 72% rename from cfd/combustion/gnns/ci/configs/gunet_test.yaml rename to reactive-flows/cnf-combustion/gnns/ci/configs/gunet_test.yaml index ce051873..f8339ccf 100644 --- a/cfd/combustion/gnns/ci/configs/gunet_test.yaml +++ b/reactive-flows/cnf-combustion/gnns/ci/configs/gunet_test.yaml @@ -10,6 +10,8 @@ # See the License for the specific language governing permissions and # limitations under the License. +seed_everything: 0 + model: class_path: models.LitGraphUNet init_args: @@ -26,9 +28,14 @@ data: batch_size: 1 num_workers: 0 y_normalizer: 3295.4 + splitting_ratios: [0.8, 0.1, 0.1] + data_path: ${oc.decode:${oc.env:DATADIR, ./data}} trainer: max_epochs: 1 accelerator: "cpu" - devices: - - 0 \ No newline at end of file + devices: ${oc.decode:${oc.env:SLURM_GPUS_ON_NODE, 1}} + logger: + class_path: lightning.pytorch.loggers.tensorboard.TensorBoardLogger + init_args: + save_dir: ${oc.decode:${oc.env:LOGDIR, ./logs}} \ No newline at end of file diff --git a/cfd/combustion/gnns/ci/generate_synthetic_data.py b/reactive-flows/cnf-combustion/gnns/ci/generate_synthetic_data.py similarity index 57% rename from cfd/combustion/gnns/ci/generate_synthetic_data.py rename to reactive-flows/cnf-combustion/gnns/ci/generate_synthetic_data.py index 21addd2d..0d9d88d2 100644 --- a/cfd/combustion/gnns/ci/generate_synthetic_data.py +++ b/reactive-flows/cnf-combustion/gnns/ci/generate_synthetic_data.py @@ -10,38 +10,45 @@ # See the License for the specific language governing permissions and # limitations under the License. -from os.path import join, exists +import os +import sys from os import makedirs +from os.path import exists, join + +import numpy as np from h5py import File from yaml import dump -import numpy as np -import sys -import os sys.path.insert(1, "/".join(os.path.realpath(__file__).split("/")[0:-2])) - -import config # noqa: +data_path = "./data" def create_data(): """Create data folder with fake raw data""" - filenames = ['test_1.h5', 'test_2.h5', 'test_3.h5', - 'test_4.h5', 'test_5.h5', 'test_6.h5', 'test_7.h5'] - - if (not exists(config.data_path)): - makedirs(join(config.data_path, "raw")) + filenames = [ + "test_1.h5", + "test_2.h5", + "test_3.h5", + "test_4.h5", + "test_5.h5", + "test_6.h5", + "test_7.h5", + ] + + if not exists(data_path): + makedirs(join(data_path, "raw")) for file_h5 in filenames: - with File(join(config.data_path, "raw", file_h5), 'w') as f: - f['/c_filt'] = np.random.normal(0, 1, (20, 20, 20)) - f['/c_grad_filt'] = np.random.normal(0, 1, (20, 20, 20)) + with File(join(data_path, "raw", file_h5), "w") as f: + f["/c_filt"] = np.random.normal(0, 1, (20, 20, 20)) + f["/c_grad_filt"] = np.random.normal(0, 1, (20, 20, 20)) - temp_file_path = join(config.data_path, 'filenames.yaml') - with open(temp_file_path, 'w') as tmpfile: + temp_file_path = join(data_path, "filenames.yaml") + with open(temp_file_path, "w") as tmpfile: dump(filenames, tmpfile) else: - raise Exception(f"Remove manually {config.data_path}") + raise Exception(f"Remove manually {data_path}") -if __name__ == '__main__': +if __name__ == "__main__": create_data() diff --git a/reactive-flows/cnf-combustion/gnns/ci/run.sh b/reactive-flows/cnf-combustion/gnns/ci/run.sh new file mode 100644 index 00000000..92b16092 --- /dev/null +++ b/reactive-flows/cnf-combustion/gnns/ci/run.sh @@ -0,0 +1,33 @@ +#!/usr/bin/bash +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +RUNNER="python3" +# Parse script options +while [[ $# -gt 0 ]]; do + case $1 in + -r|--runner) + RUNNER="$2" + shift # past argument + shift # past value + ;; + -*|--*) + echo "Unknown option $1" + exit 1 + ;; + esac +done + +${RUNNER} trainer.py --config ./ci/configs/gat_test.yaml || exit 1 +${RUNNER} trainer.py --config ./ci/configs/gcn_test.yaml || exit 2 +${RUNNER} trainer.py --config ./ci/configs/gin_test.yaml || exit 3 +${RUNNER} trainer.py --config ./ci/configs/gunet_test.yaml || exit 4 diff --git a/cfd/combustion/gnns/configs/gat.yaml b/reactive-flows/cnf-combustion/gnns/configs/gat.yaml similarity index 73% rename from cfd/combustion/gnns/configs/gat.yaml rename to reactive-flows/cnf-combustion/gnns/configs/gat.yaml index a09e5e91..e561da1f 100644 --- a/cfd/combustion/gnns/configs/gat.yaml +++ b/reactive-flows/cnf-combustion/gnns/configs/gat.yaml @@ -10,6 +10,8 @@ # See the License for the specific language governing permissions and # limitations under the License. +seed_everything: 0 + model: class_path: models.LitGAT init_args: @@ -28,9 +30,14 @@ data: batch_size: 1 num_workers: 0 y_normalizer: 3295.4 + splitting_ratios: [0.8, 0.1, 0.1] + data_path: ${oc.decode:${oc.env:DATADIR, ./data}} trainer: max_epochs: 100 accelerator: "gpu" - devices: - - 2 \ No newline at end of file + devices: ${oc.decode:${oc.env:SLURM_GPUS_ON_NODE, [2]}} + logger: + class_path: lightning.pytorch.loggers.tensorboard.TensorBoardLogger + init_args: + save_dir: ${oc.decode:${oc.env:LOGDIR, ./logs}} \ No newline at end of file diff --git a/cfd/combustion/gnns/configs/gcn.yaml b/reactive-flows/cnf-combustion/gnns/configs/gcn.yaml similarity index 72% rename from cfd/combustion/gnns/configs/gcn.yaml rename to reactive-flows/cnf-combustion/gnns/configs/gcn.yaml index 304f4fc2..917ebe21 100644 --- a/cfd/combustion/gnns/configs/gcn.yaml +++ b/reactive-flows/cnf-combustion/gnns/configs/gcn.yaml @@ -10,6 +10,8 @@ # See the License for the specific language governing permissions and # limitations under the License. +seed_everything: 0 + model: class_path: models.LitGCN init_args: @@ -27,16 +29,21 @@ data: batch_size: 1 num_workers: 0 y_normalizer: 3295.4 + splitting_ratios: [0.8, 0.1, 0.1] + data_path: ${oc.decode:${oc.env:DATADIR, ./data}} trainer: max_epochs: 10 accelerator: "gpu" callbacks: - - class_path: pytorch_lightning.callbacks.EarlyStopping + - class_path: lightning.pytorch.callbacks.EarlyStopping init_args: monitor: val_loss patience: 31 mode: min min_delta: 0.0 - devices: - - 3 \ No newline at end of file + devices: ${oc.decode:${oc.env:SLURM_GPUS_ON_NODE, [3]}} + logger: + class_path: lightning.pytorch.loggers.tensorboard.TensorBoardLogger + init_args: + save_dir: ${oc.decode:${oc.env:LOGDIR, ./logs}} \ No newline at end of file diff --git a/cfd/combustion/gnns/configs/gin.yaml b/reactive-flows/cnf-combustion/gnns/configs/gin.yaml similarity index 71% rename from cfd/combustion/gnns/configs/gin.yaml rename to reactive-flows/cnf-combustion/gnns/configs/gin.yaml index f0a7e455..2e55621d 100644 --- a/cfd/combustion/gnns/configs/gin.yaml +++ b/reactive-flows/cnf-combustion/gnns/configs/gin.yaml @@ -10,6 +10,8 @@ # See the License for the specific language governing permissions and # limitations under the License. +seed_everything: 0 + model: class_path: models.LitGIN init_args: @@ -26,17 +28,21 @@ data: batch_size: 1 num_workers: 0 y_normalizer: 3295.4 + splitting_ratios: [0.8, 0.1, 0.1] + data_path: ${oc.decode:${oc.env:DATADIR, ./data}} trainer: max_epochs: 1 accelerator: "gpu" callbacks: - - class_path: pytorch_lightning.callbacks.EarlyStopping + - class_path: lightning.pytorch.callbacks.EarlyStopping init_args: monitor: val_loss patience: 30 mode: min min_delta: 0.0 - devices: - - 0 - - 1 \ No newline at end of file + devices: ${oc.decode:${oc.env:SLURM_GPUS_ON_NODE, [0, 1]}} + logger: + class_path: lightning.pytorch.loggers.tensorboard.TensorBoardLogger + init_args: + save_dir: ${oc.decode:${oc.env:LOGDIR, ./logs}} \ No newline at end of file diff --git a/cfd/combustion/gnns/configs/gunet.yaml b/reactive-flows/cnf-combustion/gnns/configs/gunet.yaml similarity index 72% rename from cfd/combustion/gnns/configs/gunet.yaml rename to reactive-flows/cnf-combustion/gnns/configs/gunet.yaml index 09a6a6cf..caaa8014 100644 --- a/cfd/combustion/gnns/configs/gunet.yaml +++ b/reactive-flows/cnf-combustion/gnns/configs/gunet.yaml @@ -10,6 +10,8 @@ # See the License for the specific language governing permissions and # limitations under the License. +seed_everything: 0 + model: class_path: models.LitGraphUNet init_args: @@ -26,9 +28,14 @@ data: batch_size: 1 num_workers: 0 y_normalizer: 3295.4 + splitting_ratios: [0.8, 0.1, 0.1] + data_path: ${oc.decode:${oc.env:DATADIR, ./data}} trainer: max_epochs: 1000 accelerator: "gpu" - devices: - - 3 \ No newline at end of file + devices: ${oc.decode:${oc.env:SLURM_GPUS_ON_NODE, [3]}} + logger: + class_path: lightning.pytorch.loggers.tensorboard.TensorBoardLogger + init_args: + save_dir: ${oc.decode:${oc.env:LOGDIR, ./logs}} \ No newline at end of file diff --git a/cfd/combustion/gnns/data.py b/reactive-flows/cnf-combustion/gnns/data.py similarity index 63% rename from cfd/combustion/gnns/data.py rename to reactive-flows/cnf-combustion/gnns/data.py index a064a76e..dc0b1db0 100755 --- a/cfd/combustion/gnns/data.py +++ b/reactive-flows/cnf-combustion/gnns/data.py @@ -1,4 +1,5 @@ """This module proposes Pytorch style Dataset classes for the gnn use-case""" + # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at @@ -11,18 +12,17 @@ # See the License for the specific language governing permissions and # limitations under the License. +import os +from typing import List, Tuple + import h5py +import lightning as pl import networkx as nx import numpy as np -import os -import pytorch_lightning as pl -from pytorch_lightning.utilities.cli import DATAMODULE_REGISTRY import torch import torch_geometric as pyg -from typing import List import yaml - -import config +from torch.utils.data import random_split class CombustionDataset(pyg.data.Dataset): @@ -77,7 +77,9 @@ def get(self, idx: int) -> pyg.data.Data: Returns: (pyg.data.Data): Graph at the given index. """ - data = torch.load(os.path.join(self.processed_dir, f'data-{idx}.pt')) + data = torch.load( + os.path.join(self.processed_dir, f"data-{idx}.pt"), weights_only=False + ) return data def len(self) -> int: @@ -108,7 +110,7 @@ def process(self) -> None: """ i = 0 for raw_path in self.raw_paths: - with h5py.File(raw_path, 'r') as file: + with h5py.File(raw_path, "r") as file: feat = file["/c_filt"][:] sigma = file["/c_grad_filt"][:] @@ -129,10 +131,10 @@ def process(self) -> None: x=torch.tensor(feat.reshape(-1, 1), dtype=torch.float), edge_index=undirected_index.clone().detach().type(torch.LongTensor), pos=torch.tensor(np.stack(coordinates)), - y=torch.tensor(sigma.reshape(-1, 1), dtype=torch.float) + y=torch.tensor(sigma.reshape(-1, 1), dtype=torch.float), ) - torch.save(data, os.path.join(self.processed_dir, f'data-{i}.pt')) + torch.save(data, os.path.join(self.processed_dir, f"data-{i}.pt")) i += 1 @@ -155,7 +157,7 @@ def process(self) -> None: """ i = 0 for raw_path in self.raw_paths: - with h5py.File(raw_path, 'r') as file: + with h5py.File(raw_path, "r") as file: feat = file["/filt_8"][:] sigma = file["/filt_grad_8"][:] @@ -175,33 +177,45 @@ def process(self) -> None: x=torch.tensor(feat.reshape(-1, 1), dtype=torch.float), edge_index=undirected_index.type(torch.LongTensor), pos=torch.tensor(np.stack(coordinates)), - y=torch.tensor(sigma.reshape(-1, 1), dtype=torch.float) + y=torch.tensor(sigma.reshape(-1, 1), dtype=torch.float), ) - torch.save(data, os.path.join(self.processed_dir, f'data-{i}.pt')) + torch.save(data, os.path.join(self.processed_dir, f"data-{i}.pt")) i += 1 -@DATAMODULE_REGISTRY class LitCombustionDataModule(pl.LightningDataModule): """ Create train, val, and test splits for the CNF Combustion UC—current setup being (111, 8, 8). Training set is randomized. """ - def __init__(self, batch_size: int, num_workers: int, y_normalizer: float) -> None: + def __init__( + self, + batch_size: int, + num_workers: int, + y_normalizer: float, + data_path: str, + splitting_ratios: Tuple[float, float, float] = (0.8, 0.1, 0.1), + source_raw_data_path: str = None, + ) -> None: """Init the LitCombustionDataModule class. Args: batch_size (int): Batch size. num_workers (int): DataLoader number of workers for loading data. y_normalizer (float): Normalizing value. - data_path (str): path to raw data. + splitting_ratios (list): ratios of the full dataset for training, validation and testing + sets. + data_path (str): path to the data used by the training. + source_raw_data_path (str): path to raw data that will be symlinked in data_path. """ self.batch_size = batch_size self.num_workers = num_workers self.y_normalizer = y_normalizer - self.local_raw_data = os.path.join(config.data_path, 'raw') + self.splitting_ratios = splitting_ratios + self.data_path = data_path + self.source_raw_data_path = source_raw_data_path super().__init__() @@ -212,12 +226,12 @@ def __init__(self, batch_size: int, num_workers: int, y_normalizer: float) -> No def prepare_data(self) -> None: """Not used.""" - CombustionDataset(config.data_path, self.y_normalizer) + CombustionDataset(self.data_path, self.y_normalizer) - def setup(self, - stage: str, - data_path: str = config.data_path, - source_raw_data_path: str = config.source_raw_data_path) -> None: + def setup( + self, + stage: str, + ) -> None: """Create the main Dataset and splits the train, test and validation Datasets from the main Dataset. Currently the repartition is respectively, 80%, 10% and 10% from the main Dataset size. Creates symbolic links from origin data. @@ -228,18 +242,31 @@ def setup(self, Raises: ValueError: if the main dataset is too small and leads to have an empty dataset. """ - config.LinkRawData(source_raw_data_path, data_path) + if self.source_raw_data_path: + LinkRawData(self.source_raw_data_path, self.data_path) - dataset = R2Dataset(data_path, y_normalizer=self.y_normalizer).shuffle() - dataset_size = len(dataset) + dataset = R2Dataset(self.data_path, y_normalizer=self.y_normalizer) - self.val_dataset = dataset[int(dataset_size * 0.9):] - self.test_dataset = dataset[int(dataset_size * 0.8):int(dataset_size * 0.9)] - self.train_dataset = dataset[:int(dataset_size * 0.8)] + tr, va, te = self.splitting_ratios + if (tr + va + te) != 1: + raise RuntimeError( + f"The the splitting ratios does not cover the full dataset: {(tr + va + te)} =! 1" + ) + length = len(dataset) + idx = list(range(length)) + train_size = len(idx[: int(tr * length)]) + val_size = len(idx[int(tr * length) : int((tr + va) * length)]) + test_size = len(idx[int((tr + va) * length) :]) + + self.train_dataset, self.val_dataset, self.test_dataset = random_split( + dataset, [train_size, val_size, test_size] + ) if not (self.val_dataset and self.test_dataset and self.train_dataset): - raise ValueError("The dataset is too small to be split properly. " - f"Current length is : {dataset_size}.") + raise ValueError( + "The dataset is too small to be split properly. " + f"Current length is : {length}." + ) def train_dataloader(self) -> pyg.loader.DataLoader: """Return the train DataLoader. @@ -251,7 +278,8 @@ def train_dataloader(self) -> pyg.loader.DataLoader: self.train_dataset, batch_size=self.batch_size, shuffle=True, - num_workers=self.num_workers) + num_workers=self.num_workers, + ) def val_dataloader(self) -> pyg.loader.DataLoader: """Return the validation DataLoader. @@ -260,9 +288,8 @@ def val_dataloader(self) -> pyg.loader.DataLoader: (torch.utils.data.DataLoader): Validation DataLoader. """ return pyg.loader.DataLoader( - self.val_dataset, - batch_size=self.batch_size, - num_workers=self.num_workers) + self.val_dataset, batch_size=self.batch_size, num_workers=self.num_workers + ) def test_dataloader(self) -> pyg.loader.DataLoader: """Return the test DataLoader. @@ -271,6 +298,58 @@ def test_dataloader(self) -> pyg.loader.DataLoader: (torch.utils.data.DataLoader): Test DataLoader. """ return pyg.loader.DataLoader( - self.test_dataset, - batch_size=self.batch_size, - num_workers=self.num_workers) + self.test_dataset, batch_size=self.batch_size, num_workers=self.num_workers + ) + + +class LinkRawData: + """Link dataset to the use case.""" + + def __init__(self, source_raw_data_path, data_path): + """Link the source_raw_data_path in the data_path, if it does not already exists.""" + self.source_raw_data_path = source_raw_data_path + self.local_data_path = data_path + self.local_raw_data = os.path.join(self.local_data_path, "raw") + + if os.path.exists(self.source_raw_data_path): + if os.path.exists(self.local_raw_data): + try: + if ( + len(os.listdir(self.local_raw_data)) == 0 + or os.readlink(self.local_raw_data) != self.source_raw_data_path + ): + self.rm_old_dataset() + self.symlink_dataset() + else: + pass + except OSError: + pass + else: + self.symlink_dataset() + + def symlink_dataset(self): + """Create the filenames.yaml file from the content of the source_raw_data_path.""" + filenames = os.listdir(self.source_raw_data_path) + temp_file_path = os.path.join(self.local_data_path, "filenames.yaml") + with open(temp_file_path, "w") as file: + yaml.dump(filenames, file) + + if not os.path.exists(self.local_raw_data): + os.makedirs(self.local_raw_data, exist_ok=True) + + for filename in filenames: + os.symlink( + os.path.join(self.source_raw_data_path, filename), + os.path.join(self.local_raw_data, filename), + ) + + def rm_old_dataset(self): + """Clean the local_data_path.""" + for item in ["raw", "filenames.yaml", "processed"]: + file_location = os.path.join(self.local_data_path, item) + try: + os.remove(file_location) + except IsADirectoryError: + os.rmdir(file_location) + else: + pass diff --git a/cfd/combustion/gnns/env.yaml b/reactive-flows/cnf-combustion/gnns/env.yaml similarity index 82% rename from cfd/combustion/gnns/env.yaml rename to reactive-flows/cnf-combustion/gnns/env.yaml index 1665db61..0186867e 100644 --- a/cfd/combustion/gnns/env.yaml +++ b/reactive-flows/cnf-combustion/gnns/env.yaml @@ -1,7 +1,7 @@ # This file defines the global environment dependencies for this model project. # It is read by the CI/CD workflows in charge of the tests (ai4sim-ci-cd.yaml) # and the build of the Docker image (images-ci-cd.yaml) to set the environment. -python_version: 3.8 +python_version: 3.10 ubuntu_base_image: name: nvidia/cuda - tag: 11.7.1-cudnn8-runtime-ubuntu20.04 \ No newline at end of file + tag: 12.4.1-cudnn-runtime-ubuntu22.04 \ No newline at end of file diff --git a/cfd/combustion/gnns/inferer.py b/reactive-flows/cnf-combustion/gnns/inferer.py similarity index 86% rename from cfd/combustion/gnns/inferer.py rename to reactive-flows/cnf-combustion/gnns/inferer.py index ad5029ea..7d9215a1 100644 --- a/cfd/combustion/gnns/inferer.py +++ b/reactive-flows/cnf-combustion/gnns/inferer.py @@ -1,4 +1,5 @@ """This module proposes classes for inference in the gnn use-case""" + # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at @@ -11,16 +12,17 @@ # See the License for the specific language governing permissions and # limitations under the License. +import logging import os import pickle -import logging + import h5py import networkx as nx import numpy import torch import torch_geometric as pyg -from pytorch_lightning import LightningModule -from pytorch_lightning.utilities.cli import LightningCLI +from lightning import LightningModule +from lightning.pytorch.cli import LightningCLI CWD = os.getcwd() @@ -30,10 +32,7 @@ class Inferer: provided saved file. """ - def __init__(self, - model_path: str, - data_path: str, - wkd: str = CWD) -> None: + def __init__(self, model_path: str, data_path: str, wkd: str = CWD) -> None: """Init the Inferer class. The model is automatically loaded from the input file during the initialization. @@ -60,7 +59,7 @@ def load_nn(self) -> None: model in the same environment that the one that generated the model (all external and internal dependencies). """ - self.model = torch.load(self.model_path) + self.model = torch.load(self.model_path, weights_only=False) self.model.eval() def load_data(self) -> None: @@ -78,7 +77,7 @@ def data_processed_path(self) -> str: """Provide a path to store the preprocessed data, in order to save time between successive inference runs on the same data. """ - path_name = os.path.splitext(os.path.basename(self.data_path))[0] + '.data' + path_name = os.path.splitext(os.path.basename(self.data_path))[0] + ".data" return os.path.join(self.wkd, path_name) def preprocess(self, save: bool = False) -> None: @@ -104,11 +103,13 @@ class InferencePthGnn(Inferer): learned on R2 data and provided through a checkpoint save file. """ - def __init__(self, - model_path: str, - data_path: str, - model_class: LightningModule, - wkd: str = CWD) -> None: + def __init__( + self, + model_path: str, + data_path: str, + model_class: LightningModule, + wkd: str = CWD, + ) -> None: """Init the InferencePthGnn class with additional args required (model_class). The model is automatically loaded from the checkpoint during the initialization. @@ -134,7 +135,7 @@ def load_data(self) -> numpy.ndarray: Returns: (numpy.ndarray): the array of the data to be inferred. """ - with h5py.File(self.data_path, 'r') as file: + with h5py.File(self.data_path, "r") as file: feat = file["/c_filt"][:] logging.info("Data input R3 loaded") return feat @@ -146,7 +147,7 @@ def load_y_dns(self) -> numpy.ndarray: Returns: (numpy.ndarray): the array of the DNS data. """ - with h5py.File(self.data_path, 'r') as file: + with h5py.File(self.data_path, "r") as file: y_gt = file["/c_grad_filt"][:] logging.info("Data ground truth R3 loaded") return y_gt @@ -158,7 +159,7 @@ def load_y_les(self) -> numpy.ndarray: Returns: (numpy.ndarray): the array of the LES data. """ - with h5py.File(self.data_path, 'r') as file: + with h5py.File(self.data_path, "r") as file: y_les = file["/c_filt_grad"][:] logging.info("Data ground truth LES loaded") return y_les @@ -172,7 +173,7 @@ def _create_graph(self, feat: torch.Tensor, save: bool = False) -> None: save (bool): if the processed data are saved in a pickle file, or not. Default: False. """ try: - with open(self.data_processed_path, 'rb') as file: + with open(self.data_processed_path, "rb") as file: self.data = pickle.load(file) except FileNotFoundError: @@ -188,7 +189,7 @@ def _create_graph(self, feat: torch.Tensor, save: bool = False) -> None: ) if save: - with open(self.data_processed_path, 'wb') as file: + with open(self.data_processed_path, "wb") as file: pickle.dump(self.data, file) def preprocess(self, save: bool = False): @@ -221,14 +222,13 @@ def predict(self) -> torch.Tensor: python inferer.py --config ./configs/gin.yaml ``` """ - from data import CombustionDataset # noqa: F401 imported but unused (mandatory for CLI) cli = LightningCLI(run=False) inferer = InferencePthGnn( - model_path="/scratch/vincentl/ai4sim/gnn_r2_r3_exp/exp_save/gin_1000epoch_0.96r2/offline-burrito/logs/version_0/checkpoints/epoch=999-step=35999.ckpt", # noqa: E501 line too long - data_path='/net/172.16.118.188/data/raise/R2_flame/combustiondatabase/R2-filtered/R3-data/smaller_new_filt_15_F_4_cropped_progvar_R3.h5', # noqa: E501 line too long + model_path="./tests/test_data/test_model.ckpt", + data_path="./data/smaller_new_filt_15_F_4_cropped_progvar_R3.h5", model_class=cli.model.__class__, - wkd='/scratch/vincentl/ai4sim/gnn_r2_r3_exp/' + wkd="./", ) logging.info("Start creating data from input data ...") diff --git a/cfd/combustion/gnns/models.py b/reactive-flows/cnf-combustion/gnns/models.py similarity index 56% rename from cfd/combustion/gnns/models.py rename to reactive-flows/cnf-combustion/gnns/models.py index cfdc7cbf..f6a09073 100755 --- a/cfd/combustion/gnns/models.py +++ b/reactive-flows/cnf-combustion/gnns/models.py @@ -1,4 +1,5 @@ """This module proposes Pytorch style LightningModule classes for the gnn use-case.""" + # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at @@ -11,15 +12,17 @@ # See the License for the specific language governing permissions and # limitations under the License. + +import os +from typing import List, Tuple + +import lightning as pl import numpy as np -import pytorch_lightning as pl -from pytorch_lightning.utilities.cli import MODEL_REGISTRY import torch import torch.nn as nn import torch_geometric as pyg import torch_optimizer as optim import torchmetrics.functional as tmf -from typing import List, Tuple import plotters @@ -35,6 +38,9 @@ def __init__(self): super().__init__() self.grid_shape = None + self.ys_test = list() + self.y_hats_test = list() + def forward(self, x_val: torch.Tensor, edge_index: torch.Tensor) -> torch.Tensor: """Compute the forward pass. @@ -47,17 +53,18 @@ def forward(self, x_val: torch.Tensor, edge_index: torch.Tensor) -> torch.Tensor """ return self.model(x_val, edge_index) - def _common_step(self, - batch: torch.Tensor, - batch_idx: int, - stage: str) -> List[torch.Tensor]: + def _common_step( + self, batch: torch.Tensor, batch_idx: int, stage: str + ) -> List[torch.Tensor]: """Define the common operations performed on data.""" batch_size = batch.ptr[0] - 1 y_hat = self(batch.x, batch.edge_index) loss = tmf.mean_squared_error(y_hat, batch.y) r2 = tmf.r2_score(y_hat, batch.y) - self.log(f"{stage}_loss", loss, prog_bar=True, on_step=True, batch_size=batch_size) + self.log( + f"{stage}_loss", loss, prog_bar=True, on_step=True, batch_size=batch_size + ) self.log(f"{stage}_r2", r2, on_step=True, batch_size=batch_size) return y_hat, loss, r2 @@ -104,39 +111,39 @@ def test_step(self, batch: torch.Tensor, batch_idx: int) -> Tuple[torch.Tensor]: if not self.grid_shape: self.grid_shape = (x_max + 1, y_max + 1, z_max + 1) - return batch.y, y_hat + self.ys_test.append(batch.y) + self.y_hats_test.append(y_hat) - def test_epoch_end(self, outputs: list) -> None: - """Gather all the outputs from the test_step to plot the test Dataset. - - Args: - outputs (List[Tuple[torch.Tensor]]): all batches containing a pair of - (ground truth, prediction) - """ - ys = list() - y_hats = list() - - for out in outputs: - ys.append(out[0]) - y_hats.append(out[1]) + return batch.y, y_hat - ys = torch.stack(ys) - y_hats = torch.stack(y_hats) + def on_test_epoch_end(self) -> None: + """Gather all the outputs from the test_step to plot the test Dataset.""" + ys = torch.stack(self.ys_test) + y_hats = torch.stack(self.y_hats_test) # Inference/Test should be done on 1 GPU as data would likely be duplicated self.ys = self.all_gather(ys) self.y_hats = self.all_gather(y_hats) # Reshape the outputs to the original grid shape plus the batch dimension - self.ys = self.ys.squeeze().view((-1,) + self.grid_shape).cpu().numpy() - self.y_hats = self.y_hats.squeeze().view((-1,) + self.grid_shape).cpu().numpy() - - self.plotter = plotters.Plotter(self.model.__class__.__name__, self.grid_shape) - self.plotter.cross_section(self.plotter.zslice, self.ys, self.y_hats) - self.plotter.dispersion_plot(self.ys, self.y_hats) - self.plotter.histo(self.ys, self.y_hats) - self.plotter.histo2d(self.ys, self.y_hats) - self.plotter.boxplot(self.ys, self.y_hats) + self.ys = self.ys.squeeze().view((-1,) + self.grid_shape).detach().numpy() + self.y_hats = ( + self.y_hats.squeeze().view((-1,) + self.grid_shape).detach().numpy() + ) + + plots_path = os.path.join(self.trainer.log_dir, "plots") + if self.trainer.is_global_zero: + if not os.path.exists(plots_path): + os.makedirs(plots_path, exist_ok=True) + + self.plotter = plotters.Plotter( + self.model.__class__.__name__, plots_path, self.grid_shape + ) + self.plotter.cross_section((self.ys.shape[1] // 2), self.ys, self.y_hats) + self.plotter.dispersion_plot(self.ys, self.y_hats) + self.plotter.histo(self.ys, self.y_hats) + self.plotter.histo2d(self.ys, self.y_hats) + self.plotter.boxplot(self.ys, self.y_hats) def configure_optimizers(self) -> optim.Optimizer: """Set the model optimizer. @@ -147,105 +154,117 @@ def configure_optimizers(self) -> optim.Optimizer: return optim.AdamP(self.parameters(), lr=self.lr) -@MODEL_REGISTRY class LitGAT(CombustionModule): """Graph-ATtention net as described in the “Graph Attention Networks” paper.""" - def __init__(self, - in_channels: int, - hidden_channels: int, - out_channels: int, - num_layers: int, - dropout: float, - heads: int, - jk: str, - lr: float) -> None: + def __init__( + self, + in_channels: int, + hidden_channels: int, + out_channels: int, + num_layers: int, + dropout: float, + heads: int, + jk: str, + lr: float, + ) -> None: """Init the LitGAT class.""" super().__init__() self.save_hyperparameters() self.lr = lr - self.model = pyg.nn.GAT(in_channels=in_channels, - hidden_channels=hidden_channels, - out_channels=out_channels, - num_layers=num_layers, - dropout=dropout, - act=nn.SiLU(inplace=True), - heads=heads, - jk=jk) + self.model = pyg.nn.GAT( + in_channels=in_channels, + hidden_channels=hidden_channels, + out_channels=out_channels, + num_layers=num_layers, + dropout=dropout, + act=nn.SiLU(inplace=True), + heads=heads, + jk=jk, + ) -@MODEL_REGISTRY class LitGCN(CombustionModule): """Classic stack of GCN layers. “Semi-supervised Classification with Graph Convolutional Networks”. """ - def __init__(self, - in_channels: int, - hidden_channels: int, - out_channels: int, - num_layers: int, - dropout: float, - jk: str, - lr: float) -> None: + def __init__( + self, + in_channels: int, + hidden_channels: int, + out_channels: int, + num_layers: int, + dropout: float, + jk: str, + lr: float, + ) -> None: """Init the LitGCN.""" super().__init__() self.save_hyperparameters() self.lr = lr - self.model = pyg.nn.GCN(in_channels=in_channels, - hidden_channels=hidden_channels, - out_channels=out_channels, - num_layers=num_layers, - dropout=dropout, - jk=jk, - act=nn.SiLU(inplace=True)) + self.model = pyg.nn.GCN( + in_channels=in_channels, + hidden_channels=hidden_channels, + out_channels=out_channels, + num_layers=num_layers, + dropout=dropout, + jk=jk, + act=nn.SiLU(inplace=True), + ) -@MODEL_REGISTRY class LitGraphUNet(CombustionModule): """Graph-Unet as described in “Graph U-Nets”.""" - def __init__(self, - in_channels: int, - hidden_channels: int, - out_channels: int, - depth: int, - pool_ratios: float, - lr: float) -> None: + def __init__( + self, + in_channels: int, + hidden_channels: int, + out_channels: int, + depth: int, + pool_ratios: float, + lr: float, + ) -> None: """Init the LitGraphUNet class.""" super().__init__() self.save_hyperparameters() self.lr = lr - self.model = pyg.nn.GraphUNet(in_channels=in_channels, - hidden_channels=hidden_channels, - out_channels=out_channels, - depth=depth, - pool_ratios=pool_ratios, - act=nn.SiLU(inplace=True)) + self.model = pyg.nn.GraphUNet( + in_channels=in_channels, + hidden_channels=hidden_channels, + out_channels=out_channels, + depth=depth, + pool_ratios=pool_ratios, + act=nn.SiLU(inplace=True), + ) -@MODEL_REGISTRY class LitGIN(CombustionModule): """GNN implementation of “How Powerful are Graph Neural Networks?”.""" - def __init__(self, - in_channels: int, - hidden_channels: int, - out_channels: int, - num_layers: int, - dropout: float, - lr: float) -> None: + def __init__( + self, + in_channels: int, + hidden_channels: int, + out_channels: int, + num_layers: int, + dropout: float, + lr: float, + ) -> None: """Init the LitGIN class.""" super().__init__() self.save_hyperparameters() self.lr = lr - self.model = pyg.nn.GIN(in_channels=in_channels, - hidden_channels=hidden_channels, - out_channels=out_channels, - num_layers=num_layers, - dropout=dropout, - act=nn.SiLU(inplace=True)) + self.model = pyg.nn.GIN( + in_channels=in_channels, + hidden_channels=hidden_channels, + out_channels=out_channels, + num_layers=num_layers, + dropout=dropout, + act=nn.SiLU(inplace=True), + ) diff --git a/cfd/combustion/gnns/noxfile.py b/reactive-flows/cnf-combustion/gnns/noxfile.py similarity index 100% rename from cfd/combustion/gnns/noxfile.py rename to reactive-flows/cnf-combustion/gnns/noxfile.py index 7c247e1f..2585a153 100644 --- a/cfd/combustion/gnns/noxfile.py +++ b/reactive-flows/cnf-combustion/gnns/noxfile.py @@ -16,9 +16,9 @@ This file can be enriched by model project specific targets. """ +import inspect import os import sys -import inspect # Insert the tools/nox folder to the python path to fetch the nox_ref_file.py content current_dir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))) diff --git a/reactive-flows/cnf-combustion/gnns/plotters.py b/reactive-flows/cnf-combustion/gnns/plotters.py new file mode 100644 index 00000000..216c49f7 --- /dev/null +++ b/reactive-flows/cnf-combustion/gnns/plotters.py @@ -0,0 +1,310 @@ +"""This module proposes some utils features to plot results of the model.""" + +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os + +import matplotlib.pyplot as plt +import numpy as np +import plotly.graph_objects as go +import torch +from matplotlib.colors import LogNorm +from matplotlib.lines import Line2D +from plotly.subplots import make_subplots + +plt.style.use("bmh") +plt.rcParams.update({"font.size": 22}) + + +class Plotter: + """The Plotter class aims at providing some utils to appreciate the training results..""" + + def __init__( + self, + model_type: torch.Tensor, + plots_path: str, + grid_shape: torch.Tensor, + ) -> None: + """Init the Plotter.""" + self.model_type = model_type + self.grid_shape = grid_shape + self.plots_path = plots_path + + self.label_target = r"$\overline{\Sigma}_{target}$" + self.label_predicted = rf"$\overline{{\Sigma}}_{{{self.model_type}}}$" + + def dispersion_plot(self, y_val: np.ndarray, y_hat: np.ndarray) -> None: + """Plot the dispersion and save it in image.""" + bins = np.linspace(0, 1250, 10) + error = np.zeros((bins.shape[0], 2)) + err = np.sqrt((y_val - y_hat) ** 2) + for i in range(len(bins) - 1): + idx = np.logical_and( + y_val.flatten() >= bins[i], y_val.flatten() < bins[i + 1] + ) + if np.all(idx): + error[i, 0] = err.flatten()[idx].mean() + error[i, 1] = err.flatten()[idx].std() + + fig, ax = plt.subplots(figsize=(15, 8)) + ax.plot(bins[:-1], error[:-1, 0]) + ax.fill_between( + bins[:-1], + (error[:-1, 0] - error[:-1, 1]), + (error[:-1, 0] + error[:-1, 1]), + color="b", + alpha=0.1, + ) + ax.set_xlabel(self.label_target) + ax.set_ylabel(f"$RMSE$({self.label_predicted}, {self.label_target})") + plt.savefig( + os.path.join(self.plots_path, f"dispersion-plot-{self.model_type}.png") + ) + plt.close() + + def histo(self, y_val: np.ndarray, y_hat: np.ndarray) -> None: + """Plot the histo and save it in image.""" + fig, ax = plt.subplots(figsize=(15, 7)) + ax.hist( + y_val.flatten(), + bins=50, + density=False, + histtype="step", + lw=3, + label=self.label_target, + ) + ax.hist( + y_hat.flatten(), + bins=50, + density=False, + histtype="step", + lw=3, + label=self.label_predicted, + ) + ax.set_yscale("log") + ax.set_xlabel(r"$\overline{\Sigma}$") + # Create new legend handles but use the colors from the existing ones + handles, labels = ax.get_legend_handles_labels() + new_handles = [Line2D([], [], c=h.get_edgecolor()) for h in handles] + + plt.legend(handles=new_handles, labels=labels) + plt.savefig(os.path.join(self.plots_path, f"histogram-{self.model_type}.png")) + plt.close() + + def histo2d(self, y_val: np.ndarray, y_hat: np.ndarray) -> None: + """Plot the histo2d and save it in image.""" + fig, ax = plt.subplots(figsize=(12, 8)) + ax.plot(np.linspace(0, 1200, 100), np.linspace(0, 1200, 100), "black") + histo = ax.hist2d( + y_val.flatten(), y_hat.flatten(), bins=100, norm=LogNorm(), cmap="Blues" + ) + plt.colorbar(histo[3]) + ax.set_xlim(-50, 1200) + ax.set_ylim(-50, 1200) + ax.set_xlabel(self.label_target) + ax.set_ylabel(self.label_predicted) + plt.savefig(os.path.join(self.plots_path, f"histogram2d-{self.model_type}.png")) + plt.close() + + def boxplot(self, y_val: np.ndarray, y_hat: np.ndarray) -> None: + """Plot the boxplot and save it in image.""" + flat_err = [] + y_val = y_val.reshape((-1,) + self.grid_shape) + y_hat = y_hat.reshape((-1,) + self.grid_shape) + for i in range(y_val.shape[0]): + flat_err.append( + np.sqrt((y_val[i, :, :, :] - y_hat[i, :, :, :]) ** 2).flatten() + ) + + fig, ax = plt.subplots(figsize=(20, 10)) + ax.boxplot(flat_err, labels=np.arange(y_val.shape[0]), showmeans=True) + ax.set_xlabel("Snapshot") + ax.set_ylabel(f"$RMSE$({self.label_predicted}, {self.label_target})") + plt.savefig(os.path.join(self.plots_path, f"boxplot-{self.model_type}")) + plt.close() + + def total_flame_surface( + self, + y_target: np.ndarray, + y_hat: np.ndarray, + y_hat_2: np.ndarray = None, + y_hat_3: np.ndarray = None, + target_title: str = "Ground Truth", + pred_title: str = "Prediction GNN", + pred_2_title: str = "Prediction CNN", + pred_3_title: str = "Pred", + save: bool = False, + ) -> None: + """Plot the total_flame_surface and save it in image.""" + gt_total_flame_surface = np.stack(y_target, axis=0) + gt_total_flame_surface = np.sum(gt_total_flame_surface, axis=(2, 3)) + + pred_total_flame_surface = np.stack(y_hat, axis=0) + pred_total_flame_surface = np.sum(pred_total_flame_surface, axis=(2, 3)) + + if y_hat_2 is not None: + pred_total_flame_surface_2 = np.stack(y_hat_2, axis=0) + pred_total_flame_surface_2 = np.sum(pred_total_flame_surface_2, axis=(2, 3)) + + if y_hat_3 is not None: + pred_total_flame_surface_3 = np.stack(y_hat_3, axis=0) + pred_total_flame_surface_3 = np.sum(pred_total_flame_surface_3, axis=(2, 3)) + + for i in range(gt_total_flame_surface.shape[0]): + fig = go.Figure() + fig.add_trace( + go.Scatter( + x=np.arange(gt_total_flame_surface.shape[1]), + y=gt_total_flame_surface[i, :], + mode="lines+markers", + name=target_title, + ) + ) + fig.add_trace( + go.Scatter( + x=np.arange(gt_total_flame_surface.shape[1]), + y=pred_total_flame_surface[i, :], + mode="lines+markers", + name=pred_title, + ) + ) + if y_hat_2 is not None: + fig.add_trace( + go.Scatter( + x=np.arange(gt_total_flame_surface.shape[1]), + y=pred_total_flame_surface_2[i, :], + mode="lines+markers", + name=pred_2_title, + ) + ) + if y_hat_3 is not None: + fig.add_trace( + go.Scatter( + x=np.arange(gt_total_flame_surface.shape[1]), + y=pred_total_flame_surface_3[i, :], + mode="lines+markers", + name=pred_3_title, + ) + ) + fig.update_layout(width=1280, height=640) + fig.update_xaxes(title_text="x position") + fig.update_yaxes(title_text="Total flame surface") + + # fig.show() + if save: + fig.write_image( + os.path.join( + self.plots_path, + f"total-flame-surface-{self.model_type}-{i}.png", + ) + ) + + def cross_section( + self, + zslice: int, + y_val: np.ndarray, + y_hat: np.ndarray, + y_title: str = "Ground Truth", + y_hat_title: str = "Prediction", + norm_val: float = 1, + save: bool = False, + ) -> None: + """Plot the cross_section and save it in image.""" + for i in range(y_hat.shape[0]): + y_val = y_val.reshape((-1,) + self.grid_shape) + y_hat = y_hat.reshape((-1,) + self.grid_shape) + + sigma = y_val[i, :, :, :] + sigma = np.moveaxis(sigma, [0, -1], [-1, 0]) + + prediction = y_hat[i, :, :, :] + prediction = np.moveaxis(prediction, [0, -1], [-1, 0]) + + fig = make_subplots( + rows=1, + cols=6, + subplot_titles=[y_title, y_hat_title, "Difference"], + specs=[[{}, None, {}, None, {}, None]], + ) + fig.add_trace( + go.Contour( + z=sigma[zslice, :, :], + zmin=0, + zmax=950 / norm_val, + contours=dict( + showlines=False, + showlabels=False, + ), + line=dict(width=0), + contours_coloring="heatmap", + colorscale="IceFire", + colorbar=dict(x=0.27), + ), + row=1, + col=1, + ) + fig.add_trace( + go.Contour( + z=prediction[zslice, :, :], + zmin=0, + zmax=950 / norm_val, + contours=dict( + showlines=False, + showlabels=False, + ), + line=dict(width=0), + contours_coloring="heatmap", + colorscale="IceFire", + colorbar=dict(x=0.62), + ), + row=1, + col=3, + ) + fig.add_trace( + go.Contour( + z=sigma[zslice, :, :] - prediction[zslice, :, :], + zmin=-300 / norm_val, + zmax=300 / norm_val, + contours=dict( + showlines=False, + showlabels=False, + ), + line=dict(width=0), + contours_coloring="heatmap", + colorscale="RdBu_r", + colorbar=dict(x=0.97), + ), + row=1, + col=5, + ) + + fig.update_layout(width=1756, height=450) + fig.update_xaxes(title_text="x direction", row=1, col=1) + fig.update_xaxes(title_text="x direction", row=1, col=3) + fig.update_xaxes(title_text="x direction", row=1, col=5) + fig.update_yaxes(title_text="y direction", row=1, col=1) + fig.update_yaxes(title_text="y direction", row=1, col=3) + fig.update_yaxes(title_text="y direction", row=1, col=5) + fig.update_layout( + xaxis=dict(domain=[0, 0.27]), + xaxis2=dict(domain=[0.35, 0.62]), + xaxis3=dict(domain=[0.7, 0.97]), + ) + + # fig.show() + if save: + fig.write_image( + os.path.join( + self.plots_path, f"cross-section-{self.model_type}-{i}.png" + ) + ) diff --git a/reactive-flows/cnf-combustion/gnns/requirements.txt b/reactive-flows/cnf-combustion/gnns/requirements.txt new file mode 100644 index 00000000..5497e172 --- /dev/null +++ b/reactive-flows/cnf-combustion/gnns/requirements.txt @@ -0,0 +1,113 @@ +absl-py==2.1.0 +aiohappyeyeballs==2.4.4 +aiohttp==3.11.10 +aiosignal==1.3.1 +antlr4-python3-runtime==4.9.3 +argcomplete==3.5.2 +async-timeout==5.0.1 +attrs==24.2.0 +cachetools==5.5.0 +certifi==2024.8.30 +charset-normalizer==3.4.0 +colorlog==6.9.0 +contourpy==1.3.1 +cycler==0.12.1 +distlib==0.3.9 +docstring_parser==0.16 +filelock==3.16.1 +fire==0.7.0 +fonttools==4.55.3 +frozenlist==1.5.0 +fsspec==2024.10.0 +future==1.0.0 +google-auth==2.37.0 +google-auth-oauthlib==1.2.1 +googledrivedownloader==0.4 +grpcio==1.68.1 +h5py==3.12.1 +idna==3.10 +importlib_metadata==8.5.0 +importlib_resources==6.5.2 +isodate==0.7.2 +Jinja2==3.1.5 +joblib==1.4.2 +jsonargparse==4.34.1 +kaleido==0.2.1 +kiwisolver==1.4.7 +lightning==2.4.0 +lightning-utilities==0.11.9 +Markdown==3.7 +MarkupSafe==3.0.2 +matplotlib==3.9.4 +mpmath==1.3.0 +multidict==6.1.0 +networkx==3.4.2 +nox==2024.10.9 +numpy==2.2.0 +nvidia-cublas-cu12==12.4.5.8 +nvidia-cuda-cupti-cu12==12.4.127 +nvidia-cuda-nvrtc-cu12==12.4.127 +nvidia-cuda-runtime-cu12==12.4.127 +nvidia-cudnn-cu12==9.1.0.70 +nvidia-cufft-cu12==11.2.1.3 +nvidia-curand-cu12==10.3.5.147 +nvidia-cusolver-cu12==11.6.1.9 +nvidia-cusparse-cu12==12.3.1.170 +nvidia-nccl-cu12==2.21.5 +nvidia-nvjitlink-cu12==12.4.127 +nvidia-nvtx-cu12==12.4.127 +oauthlib==3.2.2 +omegaconf==2.3.0 +packaging==24.2 +pandas==2.2.3 +pillow==11.0.0 +pip==24.3.1 +platformdirs==4.3.6 +plotly==5.24.1 +propcache==0.2.1 +protobuf==5.29.1 +psutil==6.1.0 +pyasn1==0.6.1 +pyasn1_modules==0.4.1 +pyDeprecate==0.3.2 +pyg-lib==0.4.0+pt26cu124 +pyparsing==3.2.0 +python-dateutil==2.9.0.post0 +pytorch-lightning==2.4.0 +pytorch-ranger==0.1.1 +pytz==2024.2 +PyYAML==6.0.2 +randomname==0.2.1 +rdflib==7.1.1 +requests==2.32.3 +requests-oauthlib==2.0.0 +rsa==4.9 +scikit-learn==1.6.0 +scipy==1.14.1 +setuptools==75.1.0 +six==1.17.0 +sympy==1.13.1 +tenacity==9.0.0 +tensorboard==2.18.0 +tensorboard-data-server==0.7.2 +termcolor==2.5.0 +threadpoolctl==3.5.0 +tomli==2.2.1 +torch==2.6.0+cu124 +torch-geometric==2.6.1 +torch-optimizer==0.3.0 +torch_scatter==2.1.2+pt26cu124 +torch_sparse==0.6.18+pt26cu124 +torchmetrics==1.6.0 +tqdm==4.67.1 +triton==3.2.0 +typeshed_client==2.7.0 +typing_extensions==4.12.2 +tzdata==2024.2 +urllib3==2.2.3 +virtualenv==20.28.0 +Werkzeug==3.1.3 +wheel==0.44.0 +yacs==0.1.8 +yarl==1.18.3 +zipp==3.21.0 diff --git a/cfd/combustion/gnns/run.sh b/reactive-flows/cnf-combustion/gnns/run.sh similarity index 100% rename from cfd/combustion/gnns/run.sh rename to reactive-flows/cnf-combustion/gnns/run.sh diff --git a/cfd/combustion/unets/ci/run.sh b/reactive-flows/cnf-combustion/gnns/tests/__init__.py similarity index 87% rename from cfd/combustion/unets/ci/run.sh rename to reactive-flows/cnf-combustion/gnns/tests/__init__.py index 873e05d4..4d9a9249 100644 --- a/cfd/combustion/unets/ci/run.sh +++ b/reactive-flows/cnf-combustion/gnns/tests/__init__.py @@ -1,14 +1,11 @@ -#!/usr/bin/bash # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at -# +# # http://www.apache.org/licenses/LICENSE-2.0 -# +# # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. - -python3 trainer.py --config ./ci/configs/unets_test.yaml \ No newline at end of file diff --git a/cfd/combustion/gnns/tests/test_data.py b/reactive-flows/cnf-combustion/gnns/tests/test_data.py similarity index 55% rename from cfd/combustion/gnns/tests/test_data.py rename to reactive-flows/cnf-combustion/gnns/tests/test_data.py index 3c177a7c..e9752463 100644 --- a/cfd/combustion/gnns/tests/test_data.py +++ b/reactive-flows/cnf-combustion/gnns/tests/test_data.py @@ -1,4 +1,5 @@ """This module proposes a test suite for the data module.""" + # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at @@ -12,15 +13,17 @@ # limitations under the License. import os +import tempfile import unittest +import warnings +from copy import copy + import h5py -import yaml -import tempfile import numpy as np import torch -import warnings +import yaml -from data import CnfDataset, LitCombustionDataModule +from data import CnfDataset, LinkRawData, LitCombustionDataModule class TestData(unittest.TestCase): @@ -28,8 +31,14 @@ class TestData(unittest.TestCase): def setUp(self) -> None: """Define default parameters.""" - self.filenames = ['DNS1_00116000.h5', 'DNS1_00117000.h5', 'DNS1_00118000.h5'] - self.initParam = {'batch_size': 1, 'num_workers': 0, 'y_normalizer': 342.553} + self.filenames = ["DNS1_00116000.h5", "DNS1_00117000.h5", "DNS1_00118000.h5"] + self.init_param = { + "batch_size": 1, + "num_workers": 0, + "y_normalizer": 342.553, + "splitting_ratios": [0.8, 0.1, 0.1], + "data_path": "./data", + } def create_env(self, tempdir): """Create a test environment and data test.""" @@ -37,13 +46,13 @@ def create_env(self, tempdir): os.mkdir(os.path.join(tempdir, "data", "raw")) for file_h5 in self.filenames: - with h5py.File(os.path.join(tempdir, "data", "raw", file_h5), 'w') as file: - file['filt_8'] = np.zeros((10, 10, 10)) - file['filt_grad_8'] = np.zeros((10, 10, 10)) - file['grad_filt_8'] = np.zeros((10, 10, 10)) + with h5py.File(os.path.join(tempdir, "data", "raw", file_h5), "w") as file: + file["filt_8"] = np.zeros((10, 10, 10)) + file["filt_grad_8"] = np.zeros((10, 10, 10)) + file["grad_filt_8"] = np.zeros((10, 10, 10)) - temp_file_path = os.path.join(tempdir, 'data', 'filenames.yaml') - with open(temp_file_path, 'w') as tmpfile: + temp_file_path = os.path.join(tempdir, "data", "filenames.yaml") + with open(temp_file_path, "w") as tmpfile: _ = yaml.dump(self.filenames, tmpfile) def create_obj_rm_warning(self, path): @@ -79,7 +88,7 @@ def test_download(self): with self.assertRaises(RuntimeError) as context: _ = data_test.download() - self.assertTrue('Data not found.' in str(context.exception)) + self.assertTrue("Data not found." in str(context.exception)) def test_process(self): """Test download raise error.""" @@ -93,7 +102,7 @@ def test_process(self): # insert +2 to have transform and filter files self.assertEqual( len(os.listdir(os.path.join(tempdir, "data", "processed"))), - len(self.filenames) + 2 + len(self.filenames) + 2, ) def test_get(self): @@ -111,20 +120,20 @@ def test_setup(self): self.create_env(tempdir) _ = self.create_obj_rm_warning(os.path.join(tempdir, "data")) - dataset_test = LitCombustionDataModule(**self.initParam) + init_param = copy(self.init_param) + init_param.update({"data_path": os.path.join(tempdir, "data")}) + dataset_test = LitCombustionDataModule(**init_param) with self.assertRaises(ValueError) as context: - dataset_test.setup(stage=None, data_path=os.path.join(tempdir, "data")) + dataset_test.setup(stage=None) self.assertTrue( - 'The dataset is too small to be split properly.' in str(context.exception) + "The dataset is too small to be split properly." + in str(context.exception) ) - self.assertEqual(len(dataset_test.train_dataset), - int(len(self.filenames) * 0.8)) - self.assertEqual(len(dataset_test.val_dataset), - int(len(self.filenames)) - int(len(self.filenames) * 0.9)) - self.assertEqual(len(dataset_test.test_dataset), - int(len(self.filenames) * 0.9) - int(len(self.filenames) * 0.8)) + self.assertEqual(len(dataset_test.train_dataset), 2) + self.assertEqual(len(dataset_test.val_dataset), 0) + self.assertEqual(len(dataset_test.test_dataset), 1) def test_train_dataloader(self): """Test the "train_dataloader".""" @@ -132,10 +141,12 @@ def test_train_dataloader(self): self.create_env(tempdir) _ = self.create_obj_rm_warning(os.path.join(tempdir, "data")) - dataset_test = LitCombustionDataModule(**self.initParam) + init_param = copy(self.init_param) + init_param.update({"data_path": os.path.join(tempdir, "data")}) + dataset_test = LitCombustionDataModule(**init_param) with self.assertRaises(ValueError): - _ = dataset_test.setup(stage=None, data_path=os.path.join(tempdir, "data")) + _ = dataset_test.setup(stage=None) test_train_dl = dataset_test.train_dataloader() self.assertTrue(isinstance(test_train_dl, torch.utils.data.DataLoader)) @@ -146,10 +157,12 @@ def test_val_dataloader(self): self.create_env(tempdir) _ = self.create_obj_rm_warning(os.path.join(tempdir, "data")) - dataset_test = LitCombustionDataModule(**self.initParam) + init_param = copy(self.init_param) + init_param.update({"data_path": os.path.join(tempdir, "data")}) + dataset_test = LitCombustionDataModule(**init_param) with self.assertRaises(ValueError): - _ = dataset_test.setup(stage=None, data_path=os.path.join(tempdir, "data")) + _ = dataset_test.setup(stage=None) test_val_dl = dataset_test.val_dataloader() self.assertTrue(isinstance(test_val_dl, torch.utils.data.DataLoader)) @@ -160,14 +173,59 @@ def test_test_dataloader(self): self.create_env(tempdir) _ = self.create_obj_rm_warning(os.path.join(tempdir, "data")) - dataset_test = LitCombustionDataModule(**self.initParam) + init_param = copy(self.init_param) + init_param.update({"data_path": os.path.join(tempdir, "data")}) + dataset_test = LitCombustionDataModule(**init_param) with self.assertRaises(ValueError): - _ = dataset_test.setup(stage=None, data_path=os.path.join(tempdir, "data")) + _ = dataset_test.setup(stage=None) test_test_dl = dataset_test.test_dataloader() self.assertTrue(isinstance(test_test_dl, torch.utils.data.DataLoader)) -if __name__ == '__main__': +class TestLinkRawData(unittest.TestCase): + """LinkRawData test suite.""" + + def create_env(self, tempdir): + """Create a test environment and data test.""" + os.makedirs(os.path.join(tempdir, "raw_data"), exist_ok=True) + os.makedirs(os.path.join(tempdir, "local_data"), exist_ok=True) + os.makedirs(os.path.join(tempdir, "local_data", "raw"), exist_ok=True) + os.makedirs(os.path.join(tempdir, "local_data", "processed"), exist_ok=True) + + self.filenames = ["DNS1_00116000.h5", "DNS1_00117000.h5", "DNS1_00118000.h5"] + for file_h5 in self.filenames: + with h5py.File(os.path.join(tempdir, "raw_data", file_h5), "w") as file: + file["filt_8"] = np.zeros((10, 10, 10)) + file["filt_grad_8"] = np.zeros((10, 10, 10)) + file["grad_filt_8"] = np.zeros((10, 10, 10)) + + temp_file_path = os.path.join(tempdir, "local_data", "filenames.yaml") + with open(temp_file_path, "w") as tmpfile: + _ = yaml.dump(self.filenames, tmpfile) + + def create_obj_rm_warning(self, raw_path, local_path): + """Instantiante the CombustionDataset object with a warning filtering.""" + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + return LinkRawData(raw_path, local_path) + + def test_linkrawdata(self): + """Test the LinkRawData class.""" + with tempfile.TemporaryDirectory() as tempdir: + self.create_env(tempdir) + + self.create_obj_rm_warning( + os.path.join(tempdir, "raw_data"), os.path.join(tempdir, "local_data") + ) + num_files_raw_path = len(os.listdir(os.path.join(tempdir, "raw_data"))) + local_filenames = os.listdir(os.path.join(tempdir, "local_data", "raw")) + num_files_local_path = len(local_filenames) + + self.assertTrue(num_files_raw_path, num_files_local_path) + self.assertTrue(self.filenames, local_filenames) + + +if __name__ == "__main__": unittest.main() diff --git a/reactive-flows/cnf-combustion/gnns/tests/test_data/test_model.ckpt b/reactive-flows/cnf-combustion/gnns/tests/test_data/test_model.ckpt new file mode 100644 index 0000000000000000000000000000000000000000..0f70a491d0a45d7b51445a52e99252e175e476d4 GIT binary patch literal 84535 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ȯF>{HB}iIsFXSUVQ@Ky|m!e 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 None: self.model_pt = os.path.join(TEST_DATA_PATH, "test_model.pt") model = nn.Linear(in_features=5, out_features=2) torch.save(model, self.model_pt) - self.inferer = Inferer(model_path=self.model_pt, data_path="", wkd=TEST_DATA_PATH) + self.inferer = Inferer( + model_path=self.model_pt, data_path="", wkd=TEST_DATA_PATH + ) def test_data_processed_path(self) -> None: """Test the data_processed_path property returns the proper path of saved data.""" @@ -46,17 +50,17 @@ def test_data_processed_path(self) -> None: def test_load_data_not_implemented(self) -> None: """Test the load_data method raises a NotImplementedError.""" - self.assertRaises(NotImplementedError, - self.inferer.load_data) + self.assertRaises(NotImplementedError, self.inferer.load_data) def test_preprocess_not_implemented(self) -> None: """Test the preprocess method raises a NotImplementedError.""" - self.assertRaises(NotImplementedError, - self.inferer.preprocess) + self.assertRaises(NotImplementedError, self.inferer.preprocess) def test_predict(self) -> None: """Test the predict method returns a torch.Tensor.""" - self.inferer.data = torch.testing.make_tensor((5,), device='cpu', dtype=torch.float32) + self.inferer.data = torch.testing.make_tensor( + (5,), device="cpu", dtype=torch.float32 + ) preds = self.inferer.predict() self.assertIsInstance(preds, torch.Tensor) @@ -71,56 +75,62 @@ class TestInferencePthGnn(unittest.TestCase): @classmethod def setUpClass(cls) -> None: """Init the global data used.""" - cls.infer_data = os.path.join(TEST_DATA_PATH, 'test_infer_data.h5') - with h5py.File(cls.infer_data, 'w') as file: - file['/c_filt'] = numpy.random.rand(42, 7, 66) - file['/c_grad_filt'] = numpy.random.rand(42, 7, 66) - file['/c_filt_grad'] = numpy.random.rand(42, 7, 66) + cls.infer_data = os.path.join(TEST_DATA_PATH, "test_infer_data.h5") + with h5py.File(cls.infer_data, "w") as file: + file["/c_filt"] = numpy.random.rand(42, 7, 66) + file["/c_grad_filt"] = numpy.random.rand(42, 7, 66) + file["/c_filt_grad"] = numpy.random.rand(42, 7, 66) def setUp(self) -> None: """Init the inferer object used.""" self.model_ckpt = os.path.join(TEST_DATA_PATH, "test_model.ckpt") - self.inferer = InferencePthGnn(model_path=self.model_ckpt, - data_path=self.infer_data, - model_class=LitGIN, - wkd=TEST_DATA_PATH) + self.inferer = InferencePthGnn( + model_path=self.model_ckpt, + data_path=self.infer_data, + model_class=LitGIN, + wkd=TEST_DATA_PATH, + ) def test_load_data(self) -> None: """Test the load_data method returns an array from an hdf5 file.""" data = self.inferer.load_data() self.assertIsInstance(data, numpy.ndarray) - with h5py.File(self.infer_data, 'r') as file: - expected_array = file['/c_filt'][:] + with h5py.File(self.infer_data, "r") as file: + expected_array = file["/c_filt"][:] numpy.testing.assert_equal(data, expected_array) def test_load_y_dns(self) -> None: """Test the load_y_dns method returns an array from an hdf5 file.""" data = self.inferer.load_y_dns() self.assertIsInstance(data, numpy.ndarray) - with h5py.File(self.infer_data, 'r') as file: - expected_array = file['/c_grad_filt'][:] + with h5py.File(self.infer_data, "r") as file: + expected_array = file["/c_grad_filt"][:] numpy.testing.assert_equal(data, expected_array) def test_load_y_les(self) -> None: """Test the load_y_les method returns an array from an hdf5 file.""" data = self.inferer.load_y_les() self.assertIsInstance(data, numpy.ndarray) - with h5py.File(self.infer_data, 'r') as file: - expected_array = file['/c_filt_grad'][:] + with h5py.File(self.infer_data, "r") as file: + expected_array = file["/c_filt_grad"][:] numpy.testing.assert_equal(data, expected_array) def test_create_graph(self) -> None: """Test the _create_graph method creates a data graph from input features.""" - fake_data = torch.testing.make_tensor((2, 3, 4), device="cpu", dtype=torch.float32) + fake_data = torch.testing.make_tensor( + (2, 3, 4), device="cpu", dtype=torch.float32 + ) self.inferer._create_graph(fake_data) self.assertIsInstance(self.inferer.data, pyg.data.Data) torch.testing.assert_close(fake_data.reshape(-1, 1), self.inferer.data.x) def test_create_graph_save(self) -> None: """Test the _create_graph method creates a data graph from input features and save it.""" - patch_data_file = os.path.join(TEST_DATA_PATH, 'test_save_file.data') - self.inferer.data_path = os.path.join(TEST_DATA_PATH, 'test_save_file.h5') - fake_data = torch.testing.make_tensor((2, 3, 4), device="cpu", dtype=torch.float32) + patch_data_file = os.path.join(TEST_DATA_PATH, "test_save_file.data") + self.inferer.data_path = os.path.join(TEST_DATA_PATH, "test_save_file.h5") + fake_data = torch.testing.make_tensor( + (2, 3, 4), device="cpu", dtype=torch.float32 + ) self.inferer._create_graph(fake_data, save=True) self.assertTrue(Path(patch_data_file).resolve().is_file()) os.remove(patch_data_file) @@ -130,8 +140,10 @@ def test_create_graph_existing(self) -> None: saved file. """ # create the a false previoulsy saved data file - saved_data = torch.testing.make_tensor((1, 2, 3), device="cpu", dtype=torch.float32) - with open(self.inferer.data_processed_path, 'wb') as file: + saved_data = torch.testing.make_tensor( + (1, 2, 3), device="cpu", dtype=torch.float32 + ) + with open(self.inferer.data_processed_path, "wb") as file: pickle.dump(saved_data, file) # create graph on same data -> no re-creation, just load the file self.inferer._create_graph(saved_data) @@ -156,5 +168,5 @@ def tearDownClass(cls) -> None: os.remove(cls.infer_data) -if __name__ == '__main__': +if __name__ == "__main__": unittest.main() diff --git a/cfd/combustion/gnns/tests/test_models.py b/reactive-flows/cnf-combustion/gnns/tests/test_models.py similarity index 66% rename from cfd/combustion/gnns/tests/test_models.py rename to reactive-flows/cnf-combustion/gnns/tests/test_models.py index 36e84d23..860630f3 100644 --- a/cfd/combustion/gnns/tests/test_models.py +++ b/reactive-flows/cnf-combustion/gnns/tests/test_models.py @@ -1,4 +1,5 @@ """This module proposes a test suite for the models.py file.""" + # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at @@ -11,18 +12,20 @@ # See the License for the specific language governing permissions and # limitations under the License. -import unittest import os import tempfile +import unittest + import h5py -import numpy as np -import yaml import networkx as nx +import numpy as np import torch import torch_geometric as pyg import torch_optimizer as optim +import yaml +from lightning.pytorch.trainer import Trainer -import models +from models import LitGAT, LitGCN, LitGIN, LitGraphUNet class TestModel(unittest.TestCase): @@ -30,16 +33,16 @@ class TestModel(unittest.TestCase): def setUp(self) -> None: """Define default parameters.""" - self.filenames = ['DNS1_00116000.h5', 'DNS1_00117000.h5', 'DNS1_00118000.h5'] - - self.initParam = { - 'in_channels': 1, - 'hidden_channels': 32, - 'out_channels': 1, - 'num_layers': 4, - 'dropout': .5, - 'jk': "last", - 'lr': .0001 + self.filenames = ["DNS1_00116000.h5", "DNS1_00117000.h5", "DNS1_00118000.h5"] + + self.init_param = { + "in_channels": 1, + "hidden_channels": 32, + "out_channels": 1, + "num_layers": 4, + "dropout": 0.5, + "jk": "last", + "lr": 0.0001, } def create_env(self, tempdir): @@ -48,18 +51,18 @@ def create_env(self, tempdir): os.mkdir(os.path.join(tempdir, "data", "raw")) for file_h5 in self.filenames: - with h5py.File(os.path.join(tempdir, "data", "raw", file_h5), 'w') as file: - file['filt_8'] = np.zeros((10, 10, 10)) - file['filt_grad_8'] = np.zeros((10, 10, 10)) - file['grad_filt_8'] = np.zeros((10, 10, 10)) + with h5py.File(os.path.join(tempdir, "data", "raw", file_h5), "w") as file: + file["filt_8"] = np.zeros((10, 10, 10)) + file["filt_grad_8"] = np.zeros((10, 10, 10)) + file["grad_filt_8"] = np.zeros((10, 10, 10)) - temp_file_path = os.path.join(tempdir, 'data', 'filenames.yaml') - with open(temp_file_path, 'w') as tmpfile: + temp_file_path = os.path.join(tempdir, "data", "filenames.yaml") + with open(temp_file_path, "w") as tmpfile: _ = yaml.dump(self.filenames, tmpfile) def create_graph(self, file_path): """Create a test graph.""" - with h5py.File(file_path, 'r') as file: + with h5py.File(file_path, "r") as file: col = file["/filt_8"][:] sigma = file["/filt_grad_8"][:] @@ -76,7 +79,8 @@ def create_graph(self, file_path): x=torch.tensor(col.reshape(-1, 1), dtype=torch.float), edge_index=undirected_index.clone().detach().type(torch.LongTensor), pos=torch.tensor(np.stack(coordinates)), - y=torch.tensor(sigma.reshape(-1, 1), dtype=torch.float)) + y=torch.tensor(sigma.reshape(-1, 1), dtype=torch.float), + ) return data @@ -87,53 +91,89 @@ def test_forward(self): file_path = os.path.join(tempdir, "data", "raw", self.filenames[0]) data_test = self.create_graph(file_path) - test_gcn = models.LitGCN(**self.initParam) + test_gcn = LitGCN(**self.init_param) test_forward = test_gcn.forward(data_test.x, data_test.edge_index) self.assertTrue(isinstance(test_forward, torch.Tensor)) def test_common_step(self): """Test the "_common_step" method returns a 3 length tuple.""" + gin_init_param = { + "in_channels": 1, + "hidden_channels": 32, + "out_channels": 1, + "num_layers": 4, + "dropout": 0.5, + "lr": 0.0001, + } + with tempfile.TemporaryDirectory() as tempdir: self.create_env(tempdir) file_path = os.path.join(tempdir, "data", "raw", self.filenames[0]) data_test = self.create_graph(file_path) - test_gcn = models.LitGCN(**self.initParam) + test_gin = LitGIN(**gin_init_param) batch = pyg.data.Batch.from_data_list([data_test, data_test]) - loss = test_gcn._common_step(batch=batch, batch_idx=1, stage="train") + loss = test_gin._common_step(batch=batch, batch_idx=1, stage="train") self.assertEqual(len(loss), 3) def test_training_step(self): """Test the "training_step" method returns a Tensor.""" + gat_init_param = { + "in_channels": 1, + "hidden_channels": 32, + "out_channels": 1, + "num_layers": 4, + "dropout": 0.5, + "heads": 8, + "jk": "last", + "lr": 0.0001, + } + with tempfile.TemporaryDirectory() as tempdir: self.create_env(tempdir) file_path = os.path.join(tempdir, "data", "raw", self.filenames[0]) data_test = self.create_graph(file_path) - test_gcn = models.LitGCN(**self.initParam) + test_gat = LitGAT(**gat_init_param) batch = pyg.data.Batch.from_data_list([data_test, data_test]) - loss = test_gcn.training_step(batch=batch, batch_idx=1) + loss = test_gat.training_step(batch=batch, batch_idx=1) self.assertTrue(isinstance(loss, torch.Tensor)) def test_test_step(self): """Test the "test_step" method returns a tuple of same size Tensors.""" + gunet_init_param = { + "in_channels": 1, + "hidden_channels": 32, + "out_channels": 1, + "depth": 4, + "pool_ratios": 0.5, + "lr": 0.0001, + } + with tempfile.TemporaryDirectory() as tempdir: self.create_env(tempdir) file_path = os.path.join(tempdir, "data", "raw", self.filenames[0]) data_test = self.create_graph(file_path) - test_gcn = models.LitGCN(**self.initParam) + test_gunet = LitGraphUNet(**gunet_init_param) batch = pyg.data.Batch.from_data_list([data_test, data_test]) - out_tuple = test_gcn.test_step(batch=batch, batch_idx=1) + out_tuple = test_gunet.test_step(batch=batch, batch_idx=1) self.assertEqual(len(out_tuple), 2) self.assertEqual(out_tuple[0].size(), out_tuple[1].size()) + test_gunet._trainer = Trainer() + test_gunet.on_test_epoch_end() + + self.assertTrue( + os.path.exists(os.path.join(test_gunet.trainer.log_dir, "plots")) + ) + def test_configure_optimizers(self): """Test the "configure_optimizers" method returns an optim.Optimizer.""" with tempfile.TemporaryDirectory() as tempdir: @@ -141,11 +181,11 @@ def test_configure_optimizers(self): file_path = os.path.join(tempdir, "data", "raw", self.filenames[0]) _ = self.create_graph(file_path) - test_gcn = models.LitGCN(**self.initParam) + test_gcn = LitGCN(**self.init_param) op = test_gcn.configure_optimizers() self.assertIsInstance(op, optim.Optimizer) -if __name__ == '__main__': +if __name__ == "__main__": unittest.main() diff --git a/reactive-flows/cnf-combustion/gnns/tests/test_plotter.py b/reactive-flows/cnf-combustion/gnns/tests/test_plotter.py new file mode 100644 index 00000000..60911b4d --- /dev/null +++ b/reactive-flows/cnf-combustion/gnns/tests/test_plotter.py @@ -0,0 +1,146 @@ +"""This module provide a test suite for the plotter.py file.""" + +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +import tempfile +import unittest + +import numpy as np + +import plotters + + +class TestPlotters(unittest.TestCase): + """Plotter test file.""" + + def setUp(self) -> None: + """Define default parameters.""" + grid = 10 + self.f_num = 3 + + self.grid = (grid, grid, grid) + self.model_type = "pytorch" + self.y = np.stack( + [1 + np.random.randn(grid, grid, grid) for _ in range(self.f_num)], axis=0 + ) + self.y_hat = np.stack( + [1 + np.random.randn(grid, grid, grid) for _ in range(self.f_num)], axis=0 + ) + + def test_dispersion_plot(self): + """Test the "dispersion_plot" produces the result file.""" + with tempfile.TemporaryDirectory() as tempdir: + tt = plotters.Plotter(self.model_type, tempdir, self.grid) + tt.dispersion_plot(self.y, self.y_hat) + + self.assertTrue(len(os.listdir(tempdir)) == 1) + self.assertTrue( + os.path.exists( + os.path.join(tempdir, f"dispersion-plot-{self.model_type}.png") + ) + ) + + def test_histo(self): + """Test the "histo" produces the result file.""" + with tempfile.TemporaryDirectory() as tempdir: + tt = plotters.Plotter(self.model_type, tempdir, self.grid) + tt.histo(self.y, self.y_hat) + + self.assertTrue(len(os.listdir(tempdir)) == 1) + self.assertTrue( + os.path.exists( + os.path.join(tempdir, f"histogram-{self.model_type}.png") + ) + ) + + def test_histo2d(self): + """Test the "histo2d" produces the result file.""" + with tempfile.TemporaryDirectory() as tempdir: + + tt = plotters.Plotter(self.model_type, tempdir, self.grid) + tt.histo2d(self.y, self.y_hat) + + self.assertTrue(len(os.listdir(tempdir)) == 1) + self.assertTrue( + os.path.exists( + os.path.join(tempdir, f"histogram2d-{self.model_type}.png") + ) + ) + + def test_boxplot(self): + """Test the "boxplot" produces the result file.""" + with tempfile.TemporaryDirectory() as tempdir: + tt = plotters.Plotter(self.model_type, tempdir, self.grid) + tt.boxplot(self.y, self.y_hat) + + self.assertTrue(len(os.listdir(tempdir)) == 1) + self.assertTrue( + os.path.exists(os.path.join(tempdir, f"boxplot-{self.model_type}.png")) + ) + + def test_total_flame_surface(self): + """Test the "total_flame_surface" produces the result files.""" + with tempfile.TemporaryDirectory() as tempdir: + tt = plotters.Plotter(self.model_type, tempdir, self.grid) + tt.total_flame_surface(self.y, self.y_hat, save=True) + + self.assertEqual(len(os.listdir(tempdir)), self.f_num) + self.assertTrue( + os.path.exists( + os.path.join( + tempdir, f"total-flame-surface-{self.model_type}-0.png" + ) + ) + ) + self.assertTrue( + os.path.exists( + os.path.join( + tempdir, f"total-flame-surface-{self.model_type}-1.png" + ) + ) + ) + self.assertTrue( + os.path.exists( + os.path.join( + tempdir, f"total-flame-surface-{self.model_type}-2.png" + ) + ) + ) + + def test_cross_section(self): + """Test the "cross_section" produces the result files.""" + with tempfile.TemporaryDirectory() as tempdir: + tt = plotters.Plotter(self.model_type, tempdir, self.grid) + tt.cross_section(1, self.y, self.y_hat, save=True) + + self.assertEqual(len(os.listdir(tempdir)), self.f_num) + self.assertTrue( + os.path.exists( + os.path.join(tempdir, f"cross-section-{self.model_type}-0.png") + ) + ) + self.assertTrue( + os.path.exists( + os.path.join(tempdir, f"cross-section-{self.model_type}-1.png") + ) + ) + self.assertTrue( + os.path.exists( + os.path.join(tempdir, f"cross-section-{self.model_type}-2.png") + ) + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/reactive-flows/cnf-combustion/gnns/trainer.py b/reactive-flows/cnf-combustion/gnns/trainer.py new file mode 100755 index 00000000..08518f82 --- /dev/null +++ b/reactive-flows/cnf-combustion/gnns/trainer.py @@ -0,0 +1,20 @@ +"""This module proposes a Pytorch Lightning style Trainer class for the gnn use-case.""" + +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from lightning.pytorch.cli import LightningCLI + +if __name__ == "__main__": + cli = LightningCLI(run=False, parser_kwargs={"parser_mode": "omegaconf"}) + cli.trainer.fit(model=cli.model, datamodule=cli.datamodule) + cli.trainer.test(model=cli.model, datamodule=cli.datamodule) diff --git a/cfd/combustion/gnns/.coveragerc b/reactive-flows/cnf-combustion/unets/.coveragerc similarity index 65% rename from cfd/combustion/gnns/.coveragerc rename to reactive-flows/cnf-combustion/unets/.coveragerc index 1e50b0f0..acb4e457 100644 --- a/cfd/combustion/gnns/.coveragerc +++ b/reactive-flows/cnf-combustion/unets/.coveragerc @@ -1,2 +1,3 @@ [run] +include = ./*.py omit = noxfile.py,tests/* diff --git a/reactive-flows/cnf-combustion/unets/.gitignore b/reactive-flows/cnf-combustion/unets/.gitignore new file mode 100644 index 00000000..5495c782 --- /dev/null +++ b/reactive-flows/cnf-combustion/unets/.gitignore @@ -0,0 +1,32 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ + +# Build tool +.nox/ +.ci-reports/ + +# Unit test / coverage reports +.pytest_cache/ +.coverage +.coverage-* +.coverage.* +coverage.xml + +# Jupyter Notebook +.ipynb_checkpoints + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ +.vscode + +# Data +data/ + +# Experiments +experiments/ \ No newline at end of file diff --git a/reactive-flows/cnf-combustion/unets/README.md b/reactive-flows/cnf-combustion/unets/README.md new file mode 100644 index 00000000..d69e763b --- /dev/null +++ b/reactive-flows/cnf-combustion/unets/README.md @@ -0,0 +1,27 @@ +# CNF Use-Case + +## Description + +In this folder, a 3D U-Net is implemented and plugged on the reactive flow CNF use-case to learn subgrid scale phenomena. Once the model is trained, it can be coupled with a standard LES solver to provide a complete end-to-end simulation the reduced order space while retaining physically consistent averages of thermodynamic and chemical phenomena. + +## Dataset + +Direct Numerical Simulations (DNS) from the CNF use-case are provided by the [RAISE](https://www.coe-raise.eu/od-combustion) project. Once downloaded, it must be provided to the *CnfCombustionDataset* with the root parameter. + +In a first step, two DNS of a methane-air slot burner are run and then filtered to create the training dataset. Models are trained on this data in a supervised manner. In a second step, a new, unseen and more difficult case was used to ensure network capabilities. +This third DNS is a short-term transient started from the last field of the second DNS, where inlet velocity is doubled, going from 10 to 20 m/s for 1 ms, and then set back to its original value for 2 more ms. + +Input features: + +* ``filt_8``: filtered progress variable, c := (T - T_u) / (T_b - T_u) with T the temperature, T_u the temperature of unburnt gases and T_b the temperature of burnt gases. + +Output targets: + +* ``filt_grad_8``: filtered flame surface density (FSD), Sigma := |grad c|, the density of flame surface. Used as a proxy for the local amount of combustion. + +## Models + +The U-Net model [Ronneberger et al. (2015)](https://arxiv.org/abs/1505.04597) is a specific convolutional architecture (CNN) which allows for physical field regression with two data paths: +- a deep path, where increasingly global features are learnt by deep layers, in a autoencoder-like fashion; +- a straight through path, where data sidestep the deep path through the skip connections, allowing fine-grained details to directly path through. + diff --git a/cfd/combustion/gnns/__init__.py b/reactive-flows/cnf-combustion/unets/__init__.py similarity index 87% rename from cfd/combustion/gnns/__init__.py rename to reactive-flows/cnf-combustion/unets/__init__.py index dd4a7cdb..4d9a9249 100644 --- a/cfd/combustion/gnns/__init__.py +++ b/reactive-flows/cnf-combustion/unets/__init__.py @@ -1,5 +1,3 @@ -# Ignore "D104 Missing docstring in public package" in empty file. # noqa: D104 - # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at diff --git a/cfd/combustion/unets/ci/configs/unets_test.yaml b/reactive-flows/cnf-combustion/unets/ci/configs/unets_test.yaml similarity index 81% rename from cfd/combustion/unets/ci/configs/unets_test.yaml rename to reactive-flows/cnf-combustion/unets/ci/configs/unets_test.yaml index 78a03942..67152759 100755 --- a/cfd/combustion/unets/ci/configs/unets_test.yaml +++ b/reactive-flows/cnf-combustion/unets/ci/configs/unets_test.yaml @@ -22,6 +22,8 @@ # See the License for the specific language governing permissions and # limitations under the License. +seed_everything: 0 + model: class_path: models.LitUnet3D init_args: @@ -36,12 +38,16 @@ data: init_args: batch_size: 1 num_workers: 0 - splitting_lengths: [1, 1, 1] + splitting_ratios: [0.4, 0.4, 0.2] y_normalizer: 342.553 subblock_shape: [32, 16, 16] + data_path: ${oc.decode:${oc.env:DATADIR, ./data}} trainer: max_epochs: 1 accelerator: "cpu" - devices: - - 0 + devices: ${oc.decode:${oc.env:SLURM_GPUS_ON_NODE, 3}} + logger: + class_path: lightning.pytorch.loggers.tensorboard.TensorBoardLogger + init_args: + save_dir: ${oc.decode:${oc.env:LOGDIR, ./logs}} \ No newline at end of file diff --git a/cfd/combustion/unets/ci/generate_synthetic_data.py b/reactive-flows/cnf-combustion/unets/ci/generate_synthetic_data.py similarity index 58% rename from cfd/combustion/unets/ci/generate_synthetic_data.py rename to reactive-flows/cnf-combustion/unets/ci/generate_synthetic_data.py index 16d35bc4..1346c977 100644 --- a/cfd/combustion/unets/ci/generate_synthetic_data.py +++ b/reactive-flows/cnf-combustion/unets/ci/generate_synthetic_data.py @@ -10,38 +10,38 @@ # See the License for the specific language governing permissions and # limitations under the License. -from os.path import join, exists +import os +import sys from os import makedirs +from os.path import exists, join + +import numpy as np from h5py import File from yaml import dump -import numpy as np -import sys -import os sys.path.insert(1, "/".join(os.path.realpath(__file__).split("/")[0:-2])) - -import config # noqa: +data_path = "./data" def create_data(): """Create data folder with fake raw data""" - filenames = ['test_1.h5', 'test_2.h5', 'test_3.h5'] + filenames = ["test_1.h5", "test_2.h5", "test_3.h5"] - if (not exists(config.data_path)): - makedirs(join(config.data_path, "raw")) + if not exists(data_path): + makedirs(join(data_path, "raw")) for file_h5 in filenames: - with File(join(config.data_path, "raw", file_h5), 'w') as f: - f['filt_8'] = np.random.normal(0, 1, (320, 160, 160)) - f['filt_grad_8'] = np.random.normal(0, 1, (320, 160, 160)) - f['grad_filt_8'] = np.random.normal(0, 1, (320, 160, 160)) + with File(join(data_path, "raw", file_h5), "w") as f: + f["filt_8"] = np.random.normal(0, 1, (320, 160, 160)) + f["filt_grad_8"] = np.random.normal(0, 1, (320, 160, 160)) + f["grad_filt_8"] = np.random.normal(0, 1, (320, 160, 160)) - temp_file_path = join(config.data_path, 'filenames.yaml') - with open(temp_file_path, 'w') as tmpfile: + temp_file_path = join(data_path, "filenames.yaml") + with open(temp_file_path, "w") as tmpfile: dump(filenames, tmpfile) else: - raise Exception(f"Remove manually {config.data_path}") + raise Exception(f"Remove manually {data_path}") -if __name__ == '__main__': +if __name__ == "__main__": create_data() diff --git a/cfd/combustion/gnns/ci/run.sh b/reactive-flows/cnf-combustion/unets/ci/run.sh similarity index 63% rename from cfd/combustion/gnns/ci/run.sh rename to reactive-flows/cnf-combustion/unets/ci/run.sh index 4a8c1dad..7e3b57b8 100644 --- a/cfd/combustion/gnns/ci/run.sh +++ b/reactive-flows/cnf-combustion/unets/ci/run.sh @@ -11,7 +11,20 @@ # See the License for the specific language governing permissions and # limitations under the License. -python3 trainer.py --config ./ci/configs/gat_test.yaml -python3 trainer.py --config ./ci/configs/gcn_test.yaml -python3 trainer.py --config ./ci/configs/gin_test.yaml -python3 trainer.py --config ./ci/configs/gunet_test.yaml \ No newline at end of file +RUNNER="python3" +# Parse script options +while [[ $# -gt 0 ]]; do + case $1 in + -r|--runner) + RUNNER="$2" + shift # past argument + shift # past value + ;; + -*|--*) + echo "Unknown option $1" + exit 1 + ;; + esac +done + +${RUNNER} trainer.py --config ./ci/configs/unets_test.yaml || exit 1 \ No newline at end of file diff --git a/cfd/combustion/unets/configs/unet.yaml b/reactive-flows/cnf-combustion/unets/configs/unet.yaml similarity index 72% rename from cfd/combustion/unets/configs/unet.yaml rename to reactive-flows/cnf-combustion/unets/configs/unet.yaml index c762fccb..f7717bf6 100755 --- a/cfd/combustion/unets/configs/unet.yaml +++ b/reactive-flows/cnf-combustion/unets/configs/unet.yaml @@ -10,6 +10,8 @@ # See the License for the specific language governing permissions and # limitations under the License. +seed_everything: 0 + model: class_path: models.LitUnet3D init_args: @@ -24,12 +26,16 @@ data: init_args: batch_size: 1 num_workers: 0 - splitting_lengths: [111, 8, 8] + splitting_ratios: [0.8, 0.1, 0.1] y_normalizer: 342.553 subblock_shape: [32, 16, 16] # keeping power 2 dimensions for the U-net. + data_path: ${oc.decode:${oc.env:DATADIR, ./data}} trainer: max_epochs: 10 - accelerator: "cpu" - devices: - - 0 + accelerator: "gpu" + devices: ${oc.decode:${oc.env:SLURM_GPUS_ON_NODE, [0]}} + logger: + class_path: lightning.pytorch.loggers.tensorboard.TensorBoardLogger + init_args: + save_dir: ${oc.decode:${oc.env:LOGDIR, ./logs}} \ No newline at end of file diff --git a/cfd/combustion/unets/data.py b/reactive-flows/cnf-combustion/unets/data.py similarity index 58% rename from cfd/combustion/unets/data.py rename to reactive-flows/cnf-combustion/unets/data.py index 3de3d883..68fe338b 100755 --- a/cfd/combustion/unets/data.py +++ b/reactive-flows/cnf-combustion/unets/data.py @@ -10,29 +10,32 @@ # See the License for the specific language governing permissions and # limitations under the License. -import config -from h5py import File -from os.path import join, isfile from os import listdir, makedirs -from pytorch_lightning import LightningDataModule -from pytorch_lightning.utilities.cli import DATAMODULE_REGISTRY -from torch.utils.data import Dataset, DataLoader, random_split -from torch import load, tensor, save -from typing import Union, Optional +from os.path import isfile, join +from typing import Optional, Tuple, Union + +from h5py import File +from lightning import LightningDataModule +from torch import load, save, tensor +from torch.utils.data import DataLoader, Dataset, random_split + from utils import RandomCropper3D class CnfCombustionDataset(Dataset): - def __init__(self, - root: str, - y_normalizer: float = None, - subblock_shape: Union[int, tuple] = None): + def __init__( + self, + root: str, + y_normalizer: float = None, + subblock_shape: Union[int, tuple] = None, + ): super().__init__() self.root = root self.y_normalizer = y_normalizer - self.random_cropper = RandomCropper3D(subblock_shape) if subblock_shape is not None \ - else None + self.random_cropper = ( + RandomCropper3D(subblock_shape) if subblock_shape is not None else None + ) for i, filename in enumerate(self.raw_filenames): raw_path = join(self.raw_dir, filename) processed_path = join(self.processed_dir, self.processed_filenames[i]) @@ -65,7 +68,9 @@ def process(self, i, path) -> None: makedirs(self.processed_dir, exist_ok=True) with File(path, "r") as file: c = tensor(file["/filt_8"][:]) - sigma = tensor(file["/filt_grad_8"][:]) # Or try with surrogate 'grad_filt_8'. + sigma = tensor( + file["/filt_grad_8"][:] + ) # Or try with surrogate 'grad_filt_8'. # Crop first boundary (equal to the opposite one). c = c[1:, 1:, 1:] @@ -84,58 +89,81 @@ def process(self, i, path) -> None: save((c, sigma), join(self.processed_dir, self.processed_filenames[i])) -@DATAMODULE_REGISTRY class CnfCombustionDataModule(LightningDataModule): """ Providing 3D blocks of the CNF combustion dataset. Args: - splitting_lengths (list): lengths of training, validation and testing sets. + splitting_ratios (list): ratios of the full dataset for training, validation and testing + sets. shuffling: whether to shuffle the trainset. subblock_shape (int or tuple): data augmentation by randomly cropping sub-blocks. """ - def __init__(self, - batch_size: int, - num_workers: int, - splitting_lengths: list, - shuffling: bool = False, - y_normalizer: float = None, - subblock_shape: Union[int, tuple] = None): + def __init__( + self, + batch_size: int, + num_workers: int, + splitting_ratios: Tuple[float, float, float], + data_path: str, + shuffling: bool = False, + y_normalizer: float = None, + subblock_shape: Union[int, tuple] = None, + ): self.batch_size = batch_size self.num_workers = num_workers - self.splitting_lengths = splitting_lengths + self.splitting_ratios = splitting_ratios + self.data_path = data_path self.shuffling = shuffling self.y_normalizer = y_normalizer self.subblock_shape = subblock_shape super().__init__() - def prepare_data(self, data_path: str = config.data_path): + def prepare_data(self): """Initialize dataset.""" - self.dataset = CnfCombustionDataset(data_path, self.y_normalizer, self.subblock_shape) + CnfCombustionDataset(self.data_path, self.y_normalizer, self.subblock_shape) def setup(self, stage: Optional[str] = None): """Preprocessing: splitting and shuffling.""" + dataset = CnfCombustionDataset( + self.data_path, self.y_normalizer, self.subblock_shape + ) + + tr, va, te = self.splitting_ratios + if (tr + va + te) != 1: + raise RuntimeError( + f"The the splitting ratios does not cover the full dataset: {(tr + va + te)} =! 1" + ) + length = len(dataset) + idx = list(range(length)) + train_size = len(idx[: int(tr * length)]) + val_size = len(idx[int(tr * length) : int((tr + va) * length)]) + test_size = len(idx[int((tr + va) * length) :]) + self.train_dataset, self.val_dataset, self.test_dataset = random_split( - self.dataset, self.splitting_lengths) - if self.shuffling: - self.train_dataset = self.train_dataset.shuffle() + dataset, [train_size, val_size, test_size] + ) + + if not (self.val_dataset and self.test_dataset and self.train_dataset): + raise ValueError( + "The dataset is too small to be split properly. " + f"Current length is : {length}." + ) def train_dataloader(self): return DataLoader( self.train_dataset, batch_size=self.batch_size, shuffle=True, - num_workers=self.num_workers) + num_workers=self.num_workers, + ) def val_dataloader(self): return DataLoader( - self.val_dataset, - batch_size=self.batch_size, - num_workers=self.num_workers) + self.val_dataset, batch_size=self.batch_size, num_workers=self.num_workers + ) def test_dataloader(self): return DataLoader( - self.test_dataset, - batch_size=self.batch_size, - num_workers=self.num_workers) + self.test_dataset, batch_size=self.batch_size, num_workers=self.num_workers + ) diff --git a/cfd/combustion/unets/env.yaml b/reactive-flows/cnf-combustion/unets/env.yaml similarity index 82% rename from cfd/combustion/unets/env.yaml rename to reactive-flows/cnf-combustion/unets/env.yaml index 1665db61..0186867e 100644 --- a/cfd/combustion/unets/env.yaml +++ b/reactive-flows/cnf-combustion/unets/env.yaml @@ -1,7 +1,7 @@ # This file defines the global environment dependencies for this model project. # It is read by the CI/CD workflows in charge of the tests (ai4sim-ci-cd.yaml) # and the build of the Docker image (images-ci-cd.yaml) to set the environment. -python_version: 3.8 +python_version: 3.10 ubuntu_base_image: name: nvidia/cuda - tag: 11.7.1-cudnn8-runtime-ubuntu20.04 \ No newline at end of file + tag: 12.4.1-cudnn-runtime-ubuntu22.04 \ No newline at end of file diff --git a/cfd/combustion/unets/models.py b/reactive-flows/cnf-combustion/unets/models.py similarity index 92% rename from cfd/combustion/unets/models.py rename to reactive-flows/cnf-combustion/unets/models.py index fc0b35ba..4e399f7a 100755 --- a/cfd/combustion/unets/models.py +++ b/reactive-flows/cnf-combustion/unets/models.py @@ -10,8 +10,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -from pytorch_lightning import LightningModule -from pytorch_lightning.utilities.cli import MODEL_REGISTRY +from lightning import LightningModule from torch import flatten from torch_optimizer import AdamP from torchmetrics.functional import mean_squared_error, r2_score @@ -48,7 +47,6 @@ def test_step(self, batch, batch_idx): self._common_step(batch, "test") -@MODEL_REGISTRY class LitUnet3D(CombustionModule): """Lit wrapper to compile a 3D U-net, generic volume shapes.""" @@ -61,7 +59,8 @@ def __init__(self, in_channels, out_channels, n_levels, n_features_root, lr): inp_ch=in_channels, out_ch=out_channels, n_levels=n_levels, - n_features_root=n_features_root) + n_features_root=n_features_root, + ) def configure_optimizers(self): return AdamP(self.parameters(), lr=self.lr) diff --git a/cfd/combustion/unets/noxfile.py b/reactive-flows/cnf-combustion/unets/noxfile.py similarity index 100% rename from cfd/combustion/unets/noxfile.py rename to reactive-flows/cnf-combustion/unets/noxfile.py index 7c247e1f..2585a153 100644 --- a/cfd/combustion/unets/noxfile.py +++ b/reactive-flows/cnf-combustion/unets/noxfile.py @@ -16,9 +16,9 @@ This file can be enriched by model project specific targets. """ +import inspect import os import sys -import inspect # Insert the tools/nox folder to the python path to fetch the nox_ref_file.py content current_dir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))) diff --git a/reactive-flows/cnf-combustion/unets/requirements.txt b/reactive-flows/cnf-combustion/unets/requirements.txt new file mode 100644 index 00000000..6bf58cf3 --- /dev/null +++ b/reactive-flows/cnf-combustion/unets/requirements.txt @@ -0,0 +1,87 @@ +absl-py==2.1.0 +aiohappyeyeballs==2.4.4 +aiohttp==3.11.10 +aiosignal==1.3.2 +antlr4-python3-runtime==4.9.3 +argcomplete==3.5.2 +async-timeout==5.0.1 +attrs==24.3.0 +cachetools==5.5.0 +certifi==2024.12.14 +charset-normalizer==3.4.0 +colorlog==6.9.0 +distlib==0.3.9 +docstring_parser==0.16 +filelock==3.16.1 +fire==0.7.0 +frozenlist==1.5.0 +fsspec==2024.10.0 +future==1.0.0 +google-auth==2.37.0 +google-auth-oauthlib==1.2.1 +grpcio==1.68.1 +h5py==3.12.1 +idna==3.10 +importlib_metadata==8.5.0 +importlib_resources==6.4.5 +Jinja2==3.1.5 +jsonargparse==4.35.0 +kaleido==0.2.1 +lightning==2.4.0 +lightning-utilities==0.11.9 +Markdown==3.7 +MarkupSafe==3.0.2 +mpmath==1.3.0 +multidict==6.1.0 +networkx==3.4.2 +nox==2024.10.9 +numpy==2.2.0 +nvidia-cublas-cu12==12.4.5.8 +nvidia-cuda-cupti-cu12==12.4.127 +nvidia-cuda-nvrtc-cu12==12.4.127 +nvidia-cuda-runtime-cu12==12.4.127 +nvidia-cudnn-cu12==9.1.0.70 +nvidia-cufft-cu12==11.2.1.3 +nvidia-curand-cu12==10.3.5.147 +nvidia-cusolver-cu12==11.6.1.9 +nvidia-cusparse-cu12==12.3.1.170 +nvidia-nccl-cu12==2.21.5 +nvidia-nvjitlink-cu12==12.4.127 +nvidia-nvtx-cu12==12.4.127 +oauthlib==3.2.2 +omegaconf==2.3.0 +packaging==24.2 +pip==24.3.1 +platformdirs==4.3.6 +propcache==0.2.1 +protobuf==5.29.1 +pyasn1==0.6.1 +pyasn1_modules==0.4.1 +pyDeprecate==0.3.2 +pytorch-lightning==2.4.0 +pytorch-ranger==0.1.1 +PyYAML==6.0.2 +randomname==0.2.1 +requests==2.32.3 +requests-oauthlib==2.0.0 +rsa==4.9 +setuptools==75.1.0 +six==1.17.0 +sympy==1.13.1 +tensorboard==2.18.0 +tensorboard-data-server==0.7.2 +termcolor==2.5.0 +tomli==2.2.1 +torch==2.6.0+cu124 +torch-optimizer==0.3.0 +torchmetrics==1.6.0 +tqdm==4.67.1 +triton==3.2.0 +typeshed_client==2.7.0 +typing_extensions==4.12.2 +urllib3==2.2.3 +virtualenv==20.28.0 +Werkzeug==3.1.3 +wheel==0.44.0 +yarl==1.18.3 +zipp==3.21.0 diff --git a/cfd/combustion/gnns/tests/__init__.py b/reactive-flows/cnf-combustion/unets/tests/__init__.py similarity index 87% rename from cfd/combustion/gnns/tests/__init__.py rename to reactive-flows/cnf-combustion/unets/tests/__init__.py index dd4a7cdb..4d9a9249 100644 --- a/cfd/combustion/gnns/tests/__init__.py +++ b/reactive-flows/cnf-combustion/unets/tests/__init__.py @@ -1,5 +1,3 @@ -# Ignore "D104 Missing docstring in public package" in empty file. # noqa: D104 - # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at diff --git a/cfd/combustion/unets/tests/test_data.py b/reactive-flows/cnf-combustion/unets/tests/test_data.py similarity index 69% rename from cfd/combustion/unets/tests/test_data.py rename to reactive-flows/cnf-combustion/unets/tests/test_data.py index bed34d89..09fe3986 100644 --- a/cfd/combustion/unets/tests/test_data.py +++ b/reactive-flows/cnf-combustion/unets/tests/test_data.py @@ -10,29 +10,33 @@ # See the License for the specific language governing permissions and # limitations under the License. +from os import listdir, mkdir +from os.path import exists, join +from shutil import rmtree +from tempfile import mkdtemp from unittest import TestCase, main -from os.path import join, exists -from os import mkdir, listdir +from warnings import catch_warnings, simplefilter + from h5py import File -from data import CnfCombustionDataset, CnfCombustionDataModule -from yaml import dump -from tempfile import mkdtemp -from shutil import rmtree from numpy import zeros from torch.utils.data import DataLoader -from warnings import catch_warnings, simplefilter +from yaml import dump + +from data import CnfCombustionDataModule, CnfCombustionDataset class TestData(TestCase): def setUp(self) -> None: - self.filenames = ['DNS1_00116000.h5', 'DNS1_00117000.h5', 'DNS1_00118000.h5'] - self.data_module_params = { - 'batch_size': 1, - 'num_workers': 0, - 'y_normalizer': 342.553, - 'splitting_lengths': [1, 1, 1], - 'subblock_shape': (32, 16, 16)} + self.filenames = ["DNS1_00116000.h5", "DNS1_00117000.h5", "DNS1_00118000.h5"] + data_module_params = { + "batch_size": 1, + "num_workers": 0, + "y_normalizer": 342.553, + "data_path": "./data", + "splitting_ratios": [0.4, 0.4, 0.2], + "subblock_shape": (32, 16, 16), + } # Creates a temporary environment. self.dir = mkdtemp() @@ -43,8 +47,9 @@ def setUp(self) -> None: simplefilter("ignore") data_path = join(self.dir, "data") self.dataset = CnfCombustionDataset(data_path) - self.data_module = CnfCombustionDataModule(**self.data_module_params) - self.data_module.prepare_data(data_path) + data_module_params.update({"data_path": data_path}) + self.data_module = CnfCombustionDataModule(**data_module_params) + self.data_module.prepare_data() def tearDown(self) -> None: rmtree(self.dir) @@ -54,21 +59,21 @@ def create_env(self, tempdir): mkdir(join(tempdir, "data", "raw")) for file_h5 in self.filenames: - with File(join(tempdir, "data", "raw", file_h5), 'w') as f: - f['filt_8'] = zeros((10, 10, 10)) - f['filt_grad_8'] = zeros((10, 10, 10)) - f['grad_filt_8'] = zeros((10, 10, 10)) + with File(join(tempdir, "data", "raw", file_h5), "w") as f: + f["filt_8"] = zeros((10, 10, 10)) + f["filt_grad_8"] = zeros((10, 10, 10)) + f["grad_filt_8"] = zeros((10, 10, 10)) - temp_file_path = join(tempdir, 'data', 'filenames.yaml') - with open(temp_file_path, 'w') as tmpfile: + temp_file_path = join(tempdir, "data", "filenames.yaml") + with open(temp_file_path, "w") as tmpfile: dump(self.filenames, tmpfile) def test_process(self): self.dataset.process(0, join(self.dir, "data", "raw", "DNS1_00116000.h5")) self.assertTrue(exists(join(self.dir, "data", "processed"))) self.assertEqual( - len(listdir(join(self.dir, "data", "processed"))), - len(self.filenames)) + len(listdir(join(self.dir, "data", "processed"))), len(self.filenames) + ) def test_len(self): self.assertEqual(len(self.dataset), 3) @@ -95,5 +100,5 @@ def test_test_dataloader(self): self.assertTrue(isinstance(test_test_dl, DataLoader)) -if __name__ == '__main__': +if __name__ == "__main__": main() diff --git a/cfd/combustion/unets/tests/test_models.py b/reactive-flows/cnf-combustion/unets/tests/test_models.py similarity index 77% rename from cfd/combustion/unets/tests/test_models.py rename to reactive-flows/cnf-combustion/unets/tests/test_models.py index 58e5bbff..8ec6cc90 100644 --- a/cfd/combustion/unets/tests/test_models.py +++ b/reactive-flows/cnf-combustion/unets/tests/test_models.py @@ -11,32 +11,35 @@ # limitations under the License. from unittest import TestCase, main + from numpy import zeros from torch import Tensor, from_numpy -from models import LitUnet3D from torch_optimizer import Optimizer +from models import LitUnet3D + class TestModels(TestCase): def setUp(self) -> None: self.initParam = { - 'in_channels': 1, - 'out_channels': 2, - 'n_levels': 2, - 'n_features_root': 32, - 'lr': .0001} + "in_channels": 1, + "out_channels": 2, + "n_levels": 2, + "n_features_root": 32, + "lr": 0.0001, + } def test_forward_common_step(self): # Fake data, of dim (n_batchs, n_channels, x, y, z). - x = from_numpy(zeros((1, self.initParam['in_channels'], 10, 10, 10))) - y = from_numpy(zeros((1, self.initParam['in_channels'], 10, 10, 10))) + x = from_numpy(zeros((1, self.initParam["in_channels"], 10, 10, 10))) + y = from_numpy(zeros((1, self.initParam["in_channels"], 10, 10, 10))) # Forward. test_unet = LitUnet3D(**self.initParam) y = test_unet.forward(x) self.assertTrue(isinstance(y, Tensor)) - self.assertEqual(y.shape, (1, self.initParam['out_channels'], 10, 10, 10)) + self.assertEqual(y.shape, (1, self.initParam["out_channels"], 10, 10, 10)) # Common step. loss = test_unet._common_step(batch=(x, y), stage="train") @@ -48,5 +51,5 @@ def test_configure_optimizers(self): self.assertTrue(isinstance(op, Optimizer)) -if __name__ == '__main__': +if __name__ == "__main__": main() diff --git a/cfd/combustion/unets/tests/test_unet.py b/reactive-flows/cnf-combustion/unets/tests/test_unet.py similarity index 83% rename from cfd/combustion/unets/tests/test_unet.py rename to reactive-flows/cnf-combustion/unets/tests/test_unet.py index 1ec340b0..acaf39ec 100644 --- a/cfd/combustion/unets/tests/test_unet.py +++ b/reactive-flows/cnf-combustion/unets/tests/test_unet.py @@ -11,9 +11,11 @@ # limitations under the License. from unittest import TestCase, main + from numpy.random import rand from torch import from_numpy -from unet import UNet3D, Downsampler, Upsampler + +from unet import Downsampler, UNet3D, Upsampler class TestUnet3D(TestCase): @@ -28,11 +30,8 @@ def test_3d(self): n_levels = 1 bilinear = True net = UNet3D( - inp_ch=1, - out_ch=1, - n_levels=n_levels, - n_features_root=4, - bilinear=bilinear) + inp_ch=1, out_ch=1, n_levels=n_levels, n_features_root=4, bilinear=bilinear + ) summary = str(net) self.assertEqual(summary.count("DoubleConv"), 2 * n_levels) @@ -42,11 +41,8 @@ def test_3d(self): n_levels = 5 bilinear = True net = UNet3D( - inp_ch=1, - out_ch=1, - n_levels=n_levels, - n_features_root=4, - bilinear=bilinear) + inp_ch=1, out_ch=1, n_levels=n_levels, n_features_root=4, bilinear=bilinear + ) summary = str(net) self.assertEqual(summary.count("DoubleConv"), 2 * n_levels) @@ -71,8 +67,10 @@ def test_upsampler(self): inp = from_numpy(rand(1, 8, 16, 16, 16)) res = from_numpy(rand(1, 4, 32, 32, 32)) shp = tuple(sampler(inp, res).shape) - self.assertEqual(shp, (1, 4, 32, 32, 32)) # last DoubleConv enforces the out_ch. + self.assertEqual( + shp, (1, 4, 32, 32, 32) + ) # last DoubleConv enforces the out_ch. -if __name__ == '__main__': +if __name__ == "__main__": main() diff --git a/cfd/combustion/unets/tests/test_utils.py b/reactive-flows/cnf-combustion/unets/tests/test_utils.py similarity index 97% rename from cfd/combustion/unets/tests/test_utils.py rename to reactive-flows/cnf-combustion/unets/tests/test_utils.py index 7706af74..81d923f1 100644 --- a/cfd/combustion/unets/tests/test_utils.py +++ b/reactive-flows/cnf-combustion/unets/tests/test_utils.py @@ -11,10 +11,12 @@ # limitations under the License. from unittest import TestCase, main -from utils import RandomCropper3D + from numpy import copy from numpy.random import rand +from utils import RandomCropper3D + class TestData(TestCase): @@ -29,5 +31,5 @@ def test_random_cropper(self): self.assertEqual(x_[0, 0, 0], y_[0, 0, 0]) -if __name__ == '__main__': +if __name__ == "__main__": main() diff --git a/reactive-flows/cnf-combustion/unets/trainer.py b/reactive-flows/cnf-combustion/unets/trainer.py new file mode 100755 index 00000000..f99515ad --- /dev/null +++ b/reactive-flows/cnf-combustion/unets/trainer.py @@ -0,0 +1,23 @@ +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from lightning.pytorch.cli import LightningCLI + + +def main(): + cli = LightningCLI(run=False, parser_kwargs={"parser_mode": "omegaconf"}) + cli.trainer.fit(model=cli.model, datamodule=cli.datamodule) + cli.trainer.test(model=cli.model, datamodule=cli.datamodule) + + +if __name__ == "__main__": + main() diff --git a/cfd/combustion/unets/unet.py b/reactive-flows/cnf-combustion/unets/unet.py similarity index 79% rename from cfd/combustion/unets/unet.py rename to reactive-flows/cnf-combustion/unets/unet.py index 8db7b8bf..dfdee6cc 100644 --- a/cfd/combustion/unets/unet.py +++ b/reactive-flows/cnf-combustion/unets/unet.py @@ -10,8 +10,8 @@ # See the License for the specific language governing permissions and # limitations under the License. -from torch import cat, Tensor import torch.nn as nn +from torch import Tensor, cat class UNet3D(nn.Module): @@ -26,12 +26,14 @@ class UNet3D(nn.Module): bilinear: Whether to use bilinear interpolation or transposed convolutions for upsampling. """ - def __init__(self, - inp_ch: int, - out_ch: int, - n_levels: int, - n_features_root: int, - bilinear: bool = False): + def __init__( + self, + inp_ch: int, + out_ch: int, + n_levels: int, + n_features_root: int, + bilinear: bool = False, + ): super().__init__() self.n_levels = n_levels @@ -50,18 +52,20 @@ def __init__(self, f //= 2 layers.append(DoubleConv(f, out_ch)) - self.layers = nn.ModuleList(layers).double() # forces double precision for the whole model. + self.layers = nn.ModuleList( + layers + ).double() # forces double precision for the whole model. def forward(self, x: Tensor) -> Tensor: # xi keeps the data at each level, allowing to pass it through skip-connections. xi = [self.layers[0](x)] # Downward path. - for layer in self.layers[1:self.n_levels]: + for layer in self.layers[1 : self.n_levels]: xi.append(layer(xi[-1])) # Upward path. - for i, layer in enumerate(self.layers[self.n_levels:-1]): + for i, layer in enumerate(self.layers[self.n_levels : -1]): xi[-1] = layer(xi[-1], xi[-2 - i]) # upsamplers taking skip-connections. return self.layers[-1](xi[-1]) @@ -83,7 +87,8 @@ def __init__(self, inp_ch: int, out_ch: int, residual: bool = False): nn.ReLU(inplace=True), nn.Conv3d(out_ch, out_ch, kernel_size=3, padding=1), nn.BatchNorm3d(out_ch), - nn.ReLU(inplace=True)) + nn.ReLU(inplace=True), + ) self.res = None if residual: @@ -99,8 +104,8 @@ class Downsampler(nn.Module): def __init__(self, inp_ch: int, out_ch: int): super().__init__() self.net = nn.Sequential( - nn.MaxPool3d(kernel_size=2, stride=2), - DoubleConv(inp_ch, out_ch)) + nn.MaxPool3d(kernel_size=2, stride=2), DoubleConv(inp_ch, out_ch) + ) def forward(self, x: Tensor) -> Tensor: return self.net(x) @@ -117,13 +122,16 @@ def __init__(self, inp_ch: int, out_ch: int, bilinear: bool = False): super().__init__() self.upsample = None if inp_ch < 2: - raise ValueError(f'Input channel ({inp_ch}) too low.') + raise ValueError(f"Input channel ({inp_ch}) too low.") if bilinear: self.upsample = nn.Sequential( nn.Upsample(scale_factor=2, mode="bilinear", align_corners=True), - nn.Conv3d(inp_ch, inp_ch // 2, kernel_size=1)) + nn.Conv3d(inp_ch, inp_ch // 2, kernel_size=1), + ) else: - self.upsample = nn.ConvTranspose3d(inp_ch, inp_ch // 2, kernel_size=2, stride=2) + self.upsample = nn.ConvTranspose3d( + inp_ch, inp_ch // 2, kernel_size=2, stride=2 + ) self.conv = DoubleConv(inp_ch, out_ch) def forward(self, x1: Tensor, x2: Tensor) -> Tensor: @@ -133,9 +141,14 @@ def forward(self, x1: Tensor, x2: Tensor) -> Tensor: d2 = x2.shape[2] - x1.shape[2] d3 = x2.shape[3] - x1.shape[3] d4 = x2.shape[4] - x1.shape[4] - pad = [d4 // 2, d4 - d4 // 2, # from last to first. - d3 // 2, d3 - d3 // 2, - d2 // 2, d2 - d2 // 2] + pad = [ + d4 // 2, + d4 - d4 // 2, # from last to first. + d3 // 2, + d3 - d3 // 2, + d2 // 2, + d2 - d2 // 2, + ] x1 = nn.functional.pad(x1, pad) x = cat([x2, x1], dim=1) # concatenate along the channels axis. diff --git a/cfd/combustion/unets/utils.py b/reactive-flows/cnf-combustion/unets/utils.py similarity index 90% rename from cfd/combustion/unets/utils.py rename to reactive-flows/cnf-combustion/unets/utils.py index 08ad19ef..3c5f4337 100644 --- a/cfd/combustion/unets/utils.py +++ b/reactive-flows/cnf-combustion/unets/utils.py @@ -10,11 +10,12 @@ # See the License for the specific language governing permissions and # limitations under the License. -from numpy.random import randint from typing import Union +from numpy.random import randint + -class RandomCropper3D(): +class RandomCropper3D: """Randomly crop a sub-block out of a 3D tensor. Args: @@ -40,6 +41,6 @@ def __call__(self, x, y): tx = randint(0, h - bh) ty = randint(0, w - bw) tz = randint(0, d - bd) - x_cropped = x[tx:tx + bh, ty:ty + bw, tz:tz + bd] - y_cropped = y[tx:tx + bh, ty:ty + bw, tz:tz + bd] + x_cropped = x[tx : tx + bh, ty : ty + bw, tz : tz + bd] + y_cropped = y[tx : tx + bh, ty : ty + bw, tz : tz + bd] return x_cropped, y_cropped diff --git a/tools/flake8/flake8.cfg b/tools/flake8/flake8.cfg index 1e99dc72..a198ecc8 100644 --- a/tools/flake8/flake8.cfg +++ b/tools/flake8/flake8.cfg @@ -7,7 +7,9 @@ ignore = # Single letter variable names (eg. i, j, x, y...) VNE001, # Compulsory docstrings. - D100, D101, D102, D103, D104, D105, D106, D107 + D100, D101, D102, D103, D104, D105, D106, D107, + # To be compliant with black + E203,W503 exclude = .nox, noxfile.py, diff --git a/tools/nox/nox_ref_file.py b/tools/nox/nox_ref_file.py index 7b32b853..ad685b53 100644 --- a/tools/nox/nox_ref_file.py +++ b/tools/nox/nox_ref_file.py @@ -18,15 +18,34 @@ # limitations under the License. import os +import sys +import re +import glob import nox REPORTS_DIR = ".ci-reports/" +COV_FT_FILE = ".coverage-ft" +COV_UT_FILE = ".coverage-ut" ROOT_PATH = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) FLAKE8_CFG = os.path.join(ROOT_PATH, 'tools', 'flake8', 'flake8.cfg') # The list of the default targets executed with the simple command "nox". nox.options.sessions = ["lint", "tests"] +# Check the required python version is available +current_python = f'{sys.version_info.major}.{sys.version_info.minor}' +with open("env.yaml", 'r') as env_file: + python_req = None + for line in env_file.readlines(): + if 'python_version:' in line: + match = re.search(r'python_version: ([0-9\.]*)', line) + python_req = match.group(1) + if not python_req: + raise RuntimeError("Required python version not found in the env.yaml file.") + elif current_python != python_req: + raise RuntimeError("Current python version does not match the required version: " + f"{current_python} != {python_req}.") + def _wheel_version(wheel: str, req_file: str = 'requirements.txt') -> str: """Extract the version of a wheel from a requirement.txt, if it is present. @@ -38,11 +57,12 @@ def _wheel_version(wheel: str, req_file: str = 'requirements.txt') -> str: (str): the pip version extracted from the requirement.txt file if torch is present, an empty string otherwise. """ - version = '' + version = wheel with open(req_file, encoding='utf-8') as file: for line in file.readlines(): if f"{wheel}==" in line: version = line.rstrip() + break return version @@ -56,12 +76,9 @@ def _torch_version(req_file: str = 'requirements.txt') -> str: (str): the torch version extracted from the requirement.txt file if torch is present, an empty string otherwise. """ - version = '' - cuda = '' + cuda = 'cpu' version = _wheel_version("torch", req_file).split('==')[1] - if "+" not in version: - cuda = "cpu" - else: + if "+" in version: version, cuda = version.split('+') return version, cuda @@ -108,15 +125,31 @@ def tests(session): # Install use-case python dependencies dev_dependencies(session) session.run("python3", "-m", "pip", "install", "pytest-cov") + session.run('rm','-rf', COV_UT_FILE, external=True) session.run("python3", "-m", "pytest", "--cache-clear", "--cov=./", "-v") - session.notify("coverage_report") + session.run('mv','.coverage', COV_UT_FILE, external=True) + session.notify("coverage_report", ['data-file', f'{COV_UT_FILE}']) + + +def coverage_install(session): + session.run("python3", "-m", "pip", "install", "coverage") @nox.session def coverage_report(session): """Target to generate coverage report from test results.""" - session.run("python3", "-m", "pip", "install", "coverage") - session.run("coverage", "xml", "-o", f"{REPORTS_DIR}/pycoverage.xml") + coverage_install(session) + + cov_file=".coverage" + if "combine" in session.posargs: + session.run("coverage", "combine", "--keep", "--append", *glob.glob(".coverage-*")) + elif "data-file" in session.posargs: + # set the coverage input coverage datafile name, if provided in the command line with the "data-file" key word + # ex: nox -s coverage_report -- data-file .coverage-out + cov_file = session.posargs[session.posargs.index("data-file") + 1] + + session.run("coverage", "xml", f"--data-file={cov_file}", "-o", f"{REPORTS_DIR}/py{cov_file.lstrip('.')}.xml") + session.run("coverage", "report", "-m", f"--data-file={cov_file}") @nox.session @@ -133,6 +166,30 @@ def lint(session): session.run("flake8", "--config", FLAKE8_CFG) +@nox.session +def import_sort(session): + """Target to sort automatically the import in the code with isort.""" + # Install base python dependencies + base_dependencies(session) + session.run("python3", "-m", "pip", "install", "isort") + if "check-only" in session.posargs: + session.run("isort", "--profile", "black", "--check-only", ".") + else: + session.run("isort", "--profile", "black", ".") + + +@nox.session +def black(session): + """Target to reformat automatically the code with black.""" + # Install base python dependencies + base_dependencies(session) + session.run("python3", "-m", "pip", "install", "black") + if "check-only" in session.posargs: + session.run("black", "--check", ".") + else: + session.run("black", ".") + + @nox.session def docs(session): """Target to build the documentation (not yet implemented).""" @@ -142,8 +199,8 @@ def docs(session): @nox.session def generate_synthetic_data(session): """Target to generate synthetic data related to the use case.""" - # Install base python dependencies - base_dependencies(session) + # Install python dependencies + dev_dependencies(session) # Install requirement related to synthetic data generation req_file = "ci/requirements_data.txt" @@ -165,9 +222,11 @@ def train_test(session): """Target to launch a basic training of the use-case (not yet implemented).""" # Generate the synthetic dataset required for the functional tests generate_synthetic_data(session) - # Install all the dependencies required to run a training - dev_dependencies(session) - # Run te functional tests - session.run('bash','./ci/run.sh') + + # Run te functional tests with coverage + coverage_install(session) + session.run('rm','-rf', COV_FT_FILE, external=True) + session.run('bash', './ci/run.sh', '--runner', f'coverage run --append --data-file={COV_FT_FILE}', external=True) if "clean_data" in session.posargs: session.run('rm','-rf', './data') + session.notify("coverage_report", ['data-file', f'{COV_FT_FILE}']) diff --git a/weather-forecast/ecrad-3d-correction/unets/.coveragerc b/weather-forecast/ecrad-3d-correction/unets/.coveragerc index 1e50b0f0..acb4e457 100644 --- a/weather-forecast/ecrad-3d-correction/unets/.coveragerc +++ b/weather-forecast/ecrad-3d-correction/unets/.coveragerc @@ -1,2 +1,3 @@ [run] +include = ./*.py omit = noxfile.py,tests/* diff --git a/weather-forecast/ecrad-3d-correction/unets/.gitignore b/weather-forecast/ecrad-3d-correction/unets/.gitignore index e02e4239..5495c782 100644 --- a/weather-forecast/ecrad-3d-correction/unets/.gitignore +++ b/weather-forecast/ecrad-3d-correction/unets/.gitignore @@ -1,4 +1,32 @@ -!data -data/* -!data/filenames.yaml -!data/filenames-split.yaml +# Byte-compiled / optimized / DLL files +__pycache__/ + +# Build tool +.nox/ +.ci-reports/ + +# Unit test / coverage reports +.pytest_cache/ +.coverage +.coverage-* +.coverage.* +coverage.xml + +# Jupyter Notebook +.ipynb_checkpoints + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ +.vscode + +# Data +data/ + +# Experiments +experiments/ \ No newline at end of file diff --git a/weather-forecast/ecrad-3d-correction/unets/ci/configs/unet_test.yaml b/weather-forecast/ecrad-3d-correction/unets/ci/configs/unet_test.yaml index 6250fb7e..80015c91 100644 --- a/weather-forecast/ecrad-3d-correction/unets/ci/configs/unet_test.yaml +++ b/weather-forecast/ecrad-3d-correction/unets/ci/configs/unet_test.yaml @@ -10,10 +10,11 @@ # See the License for the specific language governing permissions and # limitations under the License. +seed_everything: 0 + model: class_path: models.LitUnet1D init_args: - data_path: data/processed/ in_channels: 47 out_channels: 6 n_levels: 3 @@ -23,7 +24,7 @@ model: data: class_path: data.LitThreeDCorrectionDataModule init_args: - data_path: data/processed/ + data_path: ${oc.decode:${oc.env:DATADIR, ./data/processed}} batch_size: 1 num_workers: 0 splitting_ratios: [0.8, 0.1, 0.1] @@ -31,5 +32,8 @@ data: trainer: max_epochs: 1 accelerator: "cpu" - devices: - - 0 \ No newline at end of file + devices: ${oc.decode:${oc.env:SLURM_GPUS_ON_NODE, 3}} + logger: + class_path: lightning.pytorch.loggers.tensorboard.TensorBoardLogger + init_args: + save_dir: ${oc.decode:${oc.env:LOGDIR, ./logs}} diff --git a/weather-forecast/ecrad-3d-correction/unets/ci/generate_synthetic_data.py b/weather-forecast/ecrad-3d-correction/unets/ci/generate_synthetic_data.py index 447e3756..dce75822 100644 --- a/weather-forecast/ecrad-3d-correction/unets/ci/generate_synthetic_data.py +++ b/weather-forecast/ecrad-3d-correction/unets/ci/generate_synthetic_data.py @@ -10,16 +10,16 @@ # See the License for the specific language governing permissions and # limitations under the License. -import dask.array as da import os.path as osp +import sys + +import dask.array as da import numpy as np import xarray as xr -import sys sys.path.insert(1, "/".join(osp.realpath(__file__).split("/")[0:-2])) -from dataproc import ThreeDCorrectionDataproc # noqa: E402 -import config # noqa: E402 +from dataproc import ThreeDCorrectionDataproc # noqa: E402 class ThreeDCorrectionDataprocSyntheticData(ThreeDCorrectionDataproc): @@ -33,44 +33,72 @@ def download(self) -> xr.DataArray: mu = 0.0 sigma = 1.0 - sca_inputs = da.from_array(np.random.normal(mu, sigma, (100, 17)).astype('float32')) - col_inputs = da.from_array(np.random.normal(mu, sigma, (100, 137, 27)).astype('float32')) - hl_inputs = da.from_array(np.random.normal(mu, sigma, (100, 138, 2)).astype('float32')) - pressure_hl = da.from_array(np.random.normal(mu, sigma, (100, 138, 1)).astype('float32')) - inter_inputs = da.from_array(np.random.normal(mu, sigma, (100, 136, 1)).astype('float32')) - lat = da.from_array(np.random.normal(mu, sigma, (100,)).astype('float32')) - lon = da.from_array(np.random.normal(mu, sigma, (100,)).astype('float32')) - flux_dn_sw = da.from_array(np.random.normal(mu, sigma, (100, 138)).astype('float32')) - flux_up_sw = da.from_array(np.random.normal(mu, sigma, (100, 138)).astype('float32')) - flux_dn_lw = da.from_array(np.random.normal(mu, sigma, (100, 138)).astype('float32')) - flux_up_lw = da.from_array(np.random.normal(mu, sigma, (100, 138)).astype('float32')) - hr_sw = da.from_array(np.random.normal(mu, sigma, (100, 137)).astype('float32')) - hr_lw = da.from_array(np.random.normal(mu, sigma, (100, 137)).astype('float32')) + sca_inputs = da.from_array( + np.random.normal(mu, sigma, (100, 17)).astype("float32") + ) + col_inputs = da.from_array( + np.random.normal(mu, sigma, (100, 137, 27)).astype("float32") + ) + hl_inputs = da.from_array( + np.random.normal(mu, sigma, (100, 138, 2)).astype("float32") + ) + pressure_hl = da.from_array( + np.random.normal(mu, sigma, (100, 138, 1)).astype("float32") + ) + inter_inputs = da.from_array( + np.random.normal(mu, sigma, (100, 136, 1)).astype("float32") + ) + lat = da.from_array(np.random.normal(mu, sigma, (100,)).astype("float32")) + lon = da.from_array(np.random.normal(mu, sigma, (100,)).astype("float32")) + flux_dn_sw = da.from_array( + np.random.normal(mu, sigma, (100, 138)).astype("float32") + ) + flux_up_sw = da.from_array( + np.random.normal(mu, sigma, (100, 138)).astype("float32") + ) + flux_dn_lw = da.from_array( + np.random.normal(mu, sigma, (100, 138)).astype("float32") + ) + flux_up_lw = da.from_array( + np.random.normal(mu, sigma, (100, 138)).astype("float32") + ) + hr_sw = da.from_array(np.random.normal(mu, sigma, (100, 137)).astype("float32")) + hr_lw = da.from_array(np.random.normal(mu, sigma, (100, 137)).astype("float32")) - xrds = xr.Dataset(data_vars=dict(sca_inputs=({"column": 100, "sca_variables": 17}, - sca_inputs), - col_inputs=({"column": 100, "level": 137, "col_variables": 17}, - col_inputs), - hl_inputs=({"column": 100, "half_level": 138, "hl_variable": 2}, - hl_inputs), - pressure_hl=({"column": 100, "half_level": 138, "p_variable": 1}, - pressure_hl), - inter_inputs=({"column": 100, "level_interface": 136, - "inter_variable": 1}, inter_inputs), - lat=({"column": 100}, lat), - lon=({"column": 100}, lon), - flux_dn_sw=({"column": 100, "half_level": 138}, flux_dn_sw), - flux_up_sw=({"column": 100, "half_level": 138}, flux_up_sw), - flux_dn_lw=({"column": 100, "half_level": 138}, flux_dn_lw), - flux_up_lw=({"column": 100, "half_level": 138}, flux_up_lw), - hr_sw=({"column": 100, "level": 137}, hr_sw), - hr_lw=({"column": 100, "level": 137}, hr_lw)), - attrs=dict(description="Weather fake data.") - ) + xrds = xr.Dataset( + data_vars=dict( + sca_inputs=({"column": 100, "sca_variables": 17}, sca_inputs), + col_inputs=( + {"column": 100, "level": 137, "col_variables": 17}, + col_inputs, + ), + hl_inputs=( + {"column": 100, "half_level": 138, "hl_variable": 2}, + hl_inputs, + ), + pressure_hl=( + {"column": 100, "half_level": 138, "p_variable": 1}, + pressure_hl, + ), + inter_inputs=( + {"column": 100, "level_interface": 136, "inter_variable": 1}, + inter_inputs, + ), + lat=({"column": 100}, lat), + lon=({"column": 100}, lon), + flux_dn_sw=({"column": 100, "half_level": 138}, flux_dn_sw), + flux_up_sw=({"column": 100, "half_level": 138}, flux_up_sw), + flux_dn_lw=({"column": 100, "half_level": 138}, flux_dn_lw), + flux_up_lw=({"column": 100, "half_level": 138}, flux_up_lw), + hr_sw=({"column": 100, "level": 137}, hr_sw), + hr_lw=({"column": 100, "level": 137}, hr_lw), + ), + attrs=dict(description="Weather fake data."), + ) return xrds -if __name__ == '__main__': +if __name__ == "__main__": - data = ThreeDCorrectionDataprocSyntheticData(config.data_path, n_shards=1) + data = ThreeDCorrectionDataprocSyntheticData("./data", n_shards=1) data.process() diff --git a/weather-forecast/ecrad-3d-correction/unets/ci/requirements_data.txt b/weather-forecast/ecrad-3d-correction/unets/ci/requirements_data.txt deleted file mode 100644 index 44feaee2..00000000 --- a/weather-forecast/ecrad-3d-correction/unets/ci/requirements_data.txt +++ /dev/null @@ -1,6 +0,0 @@ -climetlab==0.20.1 -dask==2023.5.0 -numpy==1.21.2 -randomname==0.1.5 -torch==1.13.1 -xarray==2023.1.0 \ No newline at end of file diff --git a/weather-forecast/ecrad-3d-correction/unets/ci/run.sh b/weather-forecast/ecrad-3d-correction/unets/ci/run.sh index 8e8bb667..c6a8a19f 100644 --- a/weather-forecast/ecrad-3d-correction/unets/ci/run.sh +++ b/weather-forecast/ecrad-3d-correction/unets/ci/run.sh @@ -11,4 +11,20 @@ # See the License for the specific language governing permissions and # limitations under the License. -python3 trainer.py --config ./ci/configs/unet_test.yaml +RUNNER="python3" +# Parse script options +while [[ $# -gt 0 ]]; do + case $1 in + -r|--runner) + RUNNER="$2" + shift # past argument + shift # past value + ;; + -*|--*) + echo "Unknown option $1" + exit 1 + ;; + esac +done + +${RUNNER} trainer.py --config ./ci/configs/unet_test.yaml || exit 1 diff --git a/weather-forecast/ecrad-3d-correction/unets/config.py b/weather-forecast/ecrad-3d-correction/unets/config.py deleted file mode 100644 index 430bbd78..00000000 --- a/weather-forecast/ecrad-3d-correction/unets/config.py +++ /dev/null @@ -1,32 +0,0 @@ -import os -import randomname - -root_path = os.path.dirname(os.path.realpath(__file__)) - -data_path = os.path.join(root_path, 'data') - -# Create all path for the current experiment. -experiments_path = os.path.join(root_path, 'experiments') -os.makedirs(experiments_path, exist_ok=True) -_existing_xps = os.listdir(experiments_path) - -# Generate experiment name -_randomize_name = True -while _randomize_name: - _experiment_name = randomname.get_name() - if _experiment_name not in _existing_xps: - break - -experiment_path = os.path.join(experiments_path, _experiment_name) - -if os.getenv("AI4SIM_EXPERIMENT_PATH") is None: - os.environ["AI4SIM_EXPERIMENT_PATH"] = experiment_path -else: - experiment_path = os.getenv("AI4SIM_EXPERIMENT_PATH") - -logs_path = os.path.join(experiment_path, 'logs') -artifacts_path = os.path.join(experiment_path, 'artifacts') -plots_path = os.path.join(experiment_path, 'plots') - -for path in [experiment_path, logs_path, artifacts_path, plots_path]: - os.makedirs(path, exist_ok=True) diff --git a/weather-forecast/ecrad-3d-correction/unets/configs/unet.yaml b/weather-forecast/ecrad-3d-correction/unets/configs/unet.yaml index f86ce153..6fe13984 100644 --- a/weather-forecast/ecrad-3d-correction/unets/configs/unet.yaml +++ b/weather-forecast/ecrad-3d-correction/unets/configs/unet.yaml @@ -10,10 +10,11 @@ # See the License for the specific language governing permissions and # limitations under the License. +seed_everything: 0 + model: class_path: models.LitUnet1D init_args: - data_path: data/processed/ in_channels: 47 out_channels: 6 n_levels: 3 @@ -23,13 +24,16 @@ model: data: class_path: data.LitThreeDCorrectionDataModule init_args: - data_path: data/processed/ + data_path: ${oc.decode:${oc.env:DATADIR, ./data/processed}} batch_size: 256 num_workers: 0 splitting_ratios: [0.8, 0.1, 0.1] trainer: max_epochs: 50 - accelerator: "cpu" - devices: - - 0 \ No newline at end of file + accelerator: "gpu" + devices: ${oc.decode:${oc.env:SLURM_GPUS_ON_NODE, [0]}} + logger: + class_path: lightning.pytorch.loggers.tensorboard.TensorBoardLogger + init_args: + save_dir: ${oc.decode:${oc.env:LOGDIR, ./logs}} diff --git a/weather-forecast/ecrad-3d-correction/unets/data.py b/weather-forecast/ecrad-3d-correction/unets/data.py index 3e9a4a21..0f3cf21a 100644 --- a/weather-forecast/ecrad-3d-correction/unets/data.py +++ b/weather-forecast/ecrad-3d-correction/unets/data.py @@ -11,13 +11,13 @@ # limitations under the License. import os.path as osp -import pytorch_lightning as pl -from pytorch_lightning.utilities.cli import DATAMODULE_REGISTRY -from torch.utils.data import Dataset, DataLoader, SubsetRandomSampler -from typing import Tuple, Optional -import numpy as np +from typing import Optional, Tuple + import dask.array as da +import lightning as pl +import numpy as np import torch +from torch.utils.data import DataLoader, Dataset, SubsetRandomSampler class ThreeDCorrectionDataset(Dataset): @@ -37,12 +37,12 @@ def __init__(self, data_path: str) -> None: super().__init__() # Lazily load and assemble chunks. - self.x = da.from_npy_stack(osp.join(data_path, 'x')) - self.y = da.from_npy_stack(osp.join(data_path, 'y')) + self.x = da.from_npy_stack(osp.join(data_path, "x")) + self.y = da.from_npy_stack(osp.join(data_path, "y")) # Load number of data. stats = torch.load(osp.join(data_path, "stats.pt")) - self.n_data = stats['x_nb'].item() + self.n_data = stats["x_nb"].item() def __getitem__(self, i: int) -> Tuple[np.ndarray]: """ @@ -62,15 +62,16 @@ def __len__(self) -> int: return self.n_data -@DATAMODULE_REGISTRY class LitThreeDCorrectionDataModule(pl.LightningDataModule): """DataModule for the 3dcorrection dataset.""" - def __init__(self, - data_path: str, - batch_size: int, - num_workers: int, - splitting_ratios: Tuple[float, float, float] = (0.8, 0.1, 0.1)): + def __init__( + self, + data_path: str, + batch_size: int, + num_workers: int, + splitting_ratios: Tuple[float, float, float] = (0.8, 0.1, 0.1), + ): """ Args: data_path (str): Path containing the preprocessed data (by dataproc). @@ -83,19 +84,25 @@ def __init__(self, self.batch_size = batch_size self.num_workers = num_workers self.splitting_ratios = splitting_ratios + self.dataset = None def prepare_data(self): - self.dataset = ThreeDCorrectionDataset(self.data_path) + ThreeDCorrectionDataset(self.data_path) def setup(self, stage: Optional[str] = None): # Define subsets. tr, va, te = self.splitting_ratios + if (tr + va + te) != 1: + raise RuntimeError( + f"The the splitting ratios does not cover the full dataset: {(tr + va + te)} =! 1" + ) + self.dataset = ThreeDCorrectionDataset(self.data_path) length = len(self.dataset) idx = list(range(length)) - train_idx = idx[:int(tr * length)] - val_idx = idx[int(tr * length):int((tr + va) * length)] - test_idx = idx[int((tr + va) * length):] + train_idx = idx[: int(tr * length)] + val_idx = idx[int(tr * length) : int((tr + va) * length)] + test_idx = idx[int((tr + va) * length) :] # Define samplers. self.train_sampler = SubsetRandomSampler(train_idx) @@ -107,18 +114,21 @@ def train_dataloader(self): self.dataset, batch_size=self.batch_size, sampler=self.train_sampler, - num_workers=self.num_workers) + num_workers=self.num_workers, + ) def val_dataloader(self): return DataLoader( self.dataset, batch_size=self.batch_size, sampler=self.val_sampler, - num_workers=self.num_workers) + num_workers=self.num_workers, + ) def test_dataloader(self): return DataLoader( self.dataset, batch_size=self.batch_size, sampler=self.test_sampler, - num_workers=self.num_workers) + num_workers=self.num_workers, + ) diff --git a/weather-forecast/ecrad-3d-correction/unets/dataproc.py b/weather-forecast/ecrad-3d-correction/unets/dataproc.py index be9df6c5..f9ffed55 100644 --- a/weather-forecast/ecrad-3d-correction/unets/dataproc.py +++ b/weather-forecast/ecrad-3d-correction/unets/dataproc.py @@ -10,15 +10,16 @@ # See the License for the specific language governing permissions and # limitations under the License. +import os +import os.path as osp +from typing import Dict, Tuple, Union + import climetlab as cml -from dask.config import set import dask.array as da import numpy as np -import os -import os.path as osp import torch -from typing import Dict, Tuple, Union import xarray as xr +from dask.config import set class ThreeDCorrectionDataproc: @@ -27,13 +28,15 @@ class ThreeDCorrectionDataproc: To be called once before experiments to build the dataset on the filesystem. """ - def __init__(self, - root: str, - subset: str = None, - timestep: int = 500, - patchstep: int = 1, - num_workers: int = 16, - n_shards: int = 1) -> None: + def __init__( + self, + root: str, + subset: str = None, + timestep: int = 500, + patchstep: int = 1, + num_workers: int = 16, + n_shards: int = 1, + ) -> None: """ Preprocess and shard data on disk. @@ -45,11 +48,15 @@ def __init__(self, patchstep (int): Step of the patchs (16 Earth's regions) num_workers (int): Number of workers. """ - self.cached_data_path = osp.join(root, 'cached') - self.raw_data_path = osp.join(root, 'raw') - self.processed_data_path = osp.join(root, 'processed') - - for path in [self.cached_data_path, self.raw_data_path, self.processed_data_path]: + self.cached_data_path = osp.join(root, "cached") + self.raw_data_path = osp.join(root, "raw") + self.processed_data_path = osp.join(root, "processed") + + for path in [ + self.cached_data_path, + self.raw_data_path, + self.processed_data_path, + ]: os.makedirs(path, exist_ok=True) self.subset = subset @@ -75,14 +82,15 @@ def download(self) -> xr.DataArray: """Download the data for 3D Correction UC and return an xr.Array.""" cml.settings.set("cache-directory", self.cached_data_path) cml_ds = cml.load_dataset( - 'maelstrom-radiation', + "maelstrom-radiation", subset=self.subset, - dataset='3dcorrection', + dataset="3dcorrection", raw_inputs=False, minimal_outputs=False, timestep=list(range(0, 3501, self.timestep)), patch=list(range(0, 16, self.patchstep)), - hr_units='K d-1') + hr_units="K d-1", + ) return cml_ds.to_xarray() @@ -93,6 +101,7 @@ def build_features(self, xr_array) -> Tuple[da.Array]: * Rechunk on row dimension; * Finally lazily build (x, y). """ + def broadcast_features(arr: da.Array, sz: int) -> da.Array: """Repeat a scalar in a vector.""" a = da.repeat(arr, sz, axis=-1) @@ -103,34 +112,49 @@ def pad_tensor(arr: da.Array, pads: Tuple) -> da.Array: return da.pad(arr, ((0, 0), pads, (0, 0))) features = [ - 'sca_inputs', 'col_inputs', 'hl_inputs', 'inter_inputs', - 'flux_dn_sw', 'flux_up_sw', 'flux_dn_lw', 'flux_up_lw', 'hr_sw', 'hr_lw'] - dataset_len = xr_array.dims['column'] + "sca_inputs", + "col_inputs", + "hl_inputs", + "inter_inputs", + "flux_dn_sw", + "flux_up_sw", + "flux_dn_lw", + "flux_up_lw", + "hr_sw", + "hr_lw", + ] + dataset_len = xr_array.dims["column"] self.shard_size = dataset_len // self.n_shards - set(scheduler='threads') + set(scheduler="threads") data = {} for f in features: arr = xr_array[f].data arr = da.rechunk(arr, chunks=(self.shard_size, *arr.shape[1:])) data.update({f: arr}) - x = da.concatenate([ - data['hl_inputs'], - pad_tensor(data['inter_inputs'], (1, 1)), - pad_tensor(data['col_inputs'], (1, 0)), - broadcast_features(data['sca_inputs'][..., np.newaxis], 138) - ], axis=-1) - - y = da.concatenate([ - data['flux_dn_sw'][..., np.newaxis], - data['flux_up_sw'][..., np.newaxis], - data['flux_dn_lw'][..., np.newaxis], - data['flux_up_lw'][..., np.newaxis], - pad_tensor(data['hr_sw'][..., np.newaxis], (1, 0)), - pad_tensor(data['hr_lw'][..., np.newaxis], (1, 0)), - ], axis=-1) + x = da.concatenate( + [ + data["hl_inputs"], + pad_tensor(data["inter_inputs"], (1, 1)), + pad_tensor(data["col_inputs"], (1, 0)), + broadcast_features(data["sca_inputs"][..., np.newaxis], 138), + ], + axis=-1, + ) + + y = da.concatenate( + [ + data["flux_dn_sw"][..., np.newaxis], + data["flux_up_sw"][..., np.newaxis], + data["flux_dn_lw"][..., np.newaxis], + data["flux_up_lw"][..., np.newaxis], + pad_tensor(data["hr_sw"][..., np.newaxis], (1, 0)), + pad_tensor(data["hr_lw"][..., np.newaxis], (1, 0)), + ], + axis=-1, + ) return x, y @@ -142,6 +166,7 @@ def purgedirs(self, paths: Union[str, list]) -> Union[str, list]: for p in paths: if osp.isdir(p): from shutil import rmtree + rmtree(p) os.makedirs(p, exist_ok=True) @@ -156,9 +181,12 @@ def reshard(self, x: da.Array, y: da.Array) -> Tuple[str]: x_chunked = da.rechunk(x, chunks=(self.shard_size, *x.shape[1:])) y_chunked = da.rechunk(y, chunks=(self.shard_size, *y.shape[1:])) - x_path, y_path = self.purgedirs([ - osp.join(self.processed_data_path, 'x'), - osp.join(self.processed_data_path, 'y')]) + x_path, y_path = self.purgedirs( + [ + osp.join(self.processed_data_path, "x"), + osp.join(self.processed_data_path, "y"), + ] + ) da.to_npy_stack(x_path, x_chunked, axis=0) da.to_npy_stack(y_path, y_chunked, axis=0) @@ -172,15 +200,17 @@ def compute_stats(self, x_path: str, y_path: str) -> Dict[str, np.array]: s = da.std(a, axis=0).compute(num_workers=self.num_workers) name = a.name.split("/")[-1] - stats.update({ - f'{name}_mean': torch.tensor(m), - f'{name}_std': torch.tensor(s), - f'{name}_nb': torch.tensor(a.shape[0])}) + stats.update( + { + f"{name}_mean": torch.tensor(m), + f"{name}_std": torch.tensor(s), + f"{name}_nb": torch.tensor(a.shape[0]), + } + ) torch.save(stats, osp.join(self.processed_data_path, "stats.pt")) -if __name__ == '__main__': - import config # noqa: F401 'config' imported but unused - dataproc = ThreeDCorrectionDataproc("/tmp", n_shards=(53 * 2 ** 6)) +if __name__ == "__main__": + dataproc = ThreeDCorrectionDataproc("/tmp", n_shards=(53 * 2**6)) dataproc.process() diff --git a/weather-forecast/ecrad-3d-correction/unets/env.yaml b/weather-forecast/ecrad-3d-correction/unets/env.yaml index 1665db61..0186867e 100644 --- a/weather-forecast/ecrad-3d-correction/unets/env.yaml +++ b/weather-forecast/ecrad-3d-correction/unets/env.yaml @@ -1,7 +1,7 @@ # This file defines the global environment dependencies for this model project. # It is read by the CI/CD workflows in charge of the tests (ai4sim-ci-cd.yaml) # and the build of the Docker image (images-ci-cd.yaml) to set the environment. -python_version: 3.8 +python_version: 3.10 ubuntu_base_image: name: nvidia/cuda - tag: 11.7.1-cudnn8-runtime-ubuntu20.04 \ No newline at end of file + tag: 12.4.1-cudnn-runtime-ubuntu22.04 \ No newline at end of file diff --git a/weather-forecast/ecrad-3d-correction/unets/models.py b/weather-forecast/ecrad-3d-correction/unets/models.py index ca65a360..7b48d62e 100644 --- a/weather-forecast/ecrad-3d-correction/unets/models.py +++ b/weather-forecast/ecrad-3d-correction/unets/models.py @@ -10,14 +10,14 @@ # See the License for the specific language governing permissions and # limitations under the License. -import pytorch_lightning as pl -from pytorch_lightning.utilities.cli import MODEL_REGISTRY -import torch -from torchmetrics.functional import mean_squared_error -from typing import Tuple, Union import os.path as osp -from torch_optimizer import AdamP +from typing import Tuple, Union + +import lightning as pl import numpy as np +import torch +from torch_optimizer import AdamP +from torchmetrics.functional import mean_squared_error from unet import UNet1D @@ -67,15 +67,16 @@ def gradient_histograms_adder(self): if global_step % 50 == 0: for name, param in self.named_parameters(): if param.requires_grad: - self.logger.experiment.add_histogram(f"{name}_grad", param.grad, global_step) + self.logger.experiment.add_histogram( + f"{name}_grad", param.grad, global_step + ) - def normalize(self, - x: torch.Tensor) -> Tuple[torch.Tensor]: + def normalize(self, x: torch.Tensor) -> Tuple[torch.Tensor]: """ - Normalize nside the network. + Normalize inside the network. If y is None, then only process x (e.g. forward mode). """ - eps = torch.tensor(1.e-8) + eps = torch.tensor(1.0e-8) x = (x - self.x_mean) / (self.x_std + eps) return x @@ -85,39 +86,40 @@ def _common_step(self, batch, stage): x, y = batch y_hat = self(x) - loss = mean_squared_error(y_hat, y) + loss = mean_squared_error(y_hat.contiguous(), y.contiguous()) self.log(f"{stage}_loss", loss, prog_bar=True, on_step=True, batch_size=len(x)) return y_hat, loss - def training_step(self, batch, batch_idx): + def training_step(self, batch): _, loss = self._common_step(batch, "train") return loss def on_after_backward(self): self.gradient_histograms_adder() - def training_epoch_end(self, outputs): + def on_train_epoch_end(self): self.weight_histograms_adder() - def validation_step(self, batch, batch_idx): + def validation_step(self, batch): self._common_step(batch, "val") - def test_step(self, batch, batch_idx): + def test_step(self, batch): self._common_step(batch, "test") -@MODEL_REGISTRY class LitUnet1D(ThreeDCorrectionModule): """Compile a 1D U-Net, which needs a stats.pt (in the folder of data_path).""" - def __init__(self, - data_path: str, - in_channels: int, - out_channels: int, - n_levels: int, - n_features_root: int, - lr: float): + def __init__( + self, + data_path: str, + in_channels: int, + out_channels: int, + n_levels: int, + n_features_root: int, + lr: float, + ): super(LitUnet1D, self).__init__(data_path) self.save_hyperparameters() @@ -126,7 +128,8 @@ def __init__(self, inp_ch=in_channels, out_ch=out_channels, n_levels=n_levels, - n_features_root=n_features_root) + n_features_root=n_features_root, + ) def configure_optimizers(self): return AdamP(self.parameters(), lr=self.lr) diff --git a/weather-forecast/ecrad-3d-correction/unets/noxfile.py b/weather-forecast/ecrad-3d-correction/unets/noxfile.py index 7c247e1f..2585a153 100644 --- a/weather-forecast/ecrad-3d-correction/unets/noxfile.py +++ b/weather-forecast/ecrad-3d-correction/unets/noxfile.py @@ -16,9 +16,9 @@ This file can be enriched by model project specific targets. """ +import inspect import os import sys -import inspect # Insert the tools/nox folder to the python path to fetch the nox_ref_file.py content current_dir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))) diff --git a/weather-forecast/ecrad-3d-correction/unets/requirements.txt b/weather-forecast/ecrad-3d-correction/unets/requirements.txt index b0e00fa3..35f89aac 100644 --- a/weather-forecast/ecrad-3d-correction/unets/requirements.txt +++ b/weather-forecast/ecrad-3d-correction/unets/requirements.txt @@ -1,109 +1,142 @@ absl-py==2.1.0 -aiohttp==3.9.5 -aiosignal==1.3.1 -argcomplete==3.3.0 +aiohappyeyeballs==2.4.4 +aiohttp==3.11.10 +aiosignal==1.3.2 +antlr4-python3-runtime==4.9.3 +argcomplete==3.5.2 astunparse==1.6.3 -async-timeout==4.0.3 -attrs==23.2.0 -branca==0.7.2 -cachetools==5.3.3 -cads-api-client==1.0.3 -cdsapi==0.7.0 -certifi==2024.2.2 -cffi==1.16.0 -cfgrib==0.9.12.0 -cftime==1.6.3 -charset-normalizer==3.3.2 +async-timeout==5.0.1 +attrs==24.3.0 +branca==0.8.1 +cachetools==5.5.0 +cads-api-client==1.5.4 +cdsapi==0.7.5 +certifi==2024.12.14 +cffi==1.17.1 +cfgrib==0.9.14.1 +cftime==1.6.4.post1 +charset-normalizer==3.4.0 click==8.1.7 -climetlab==0.20.1 +climetlab==0.24.0 climetlab-maelstrom-radiation==0.7.5 -cloudpickle==3.0.0 -colorlog==6.8.2 -dask==2023.5.0 -distlib==0.3.8 +cloudpickle==3.1.0 +colorlog==6.9.0 +dask==2024.12.0 +datapi==0.1.1 +distlib==0.3.9 docstring_parser==0.16 -eccodes==1.7.0 +earthkit-meteo==0.3.0 +eccodes==2.39.1 ecmwf-api-client==1.6.3 -ecmwf-opendata==0.3.8 +ecmwf-opendata==0.3.14 ecmwflibs==0.6.3 entrypoints==0.4 -filelock==3.14.0 +filelock==3.16.1 findlibs==0.0.5 -fire==0.6.0 +fire==0.7.0 flatbuffers==24.3.25 -frozenlist==1.4.1 -fsspec==2024.5.0 +frozenlist==1.5.0 +fsspec==2024.10.0 future==1.0.0 -gast==0.4.0 -google-auth==2.29.0 -google-auth-oauthlib==0.4.6 +gast==0.6.0 +google-auth==2.37.0 +google-auth-oauthlib==1.2.1 google-pasta==0.2.0 -grpcio==1.64.0 -h5py==3.11.0 -idna==3.7 -imageio==2.34.1 -importlib_metadata==7.1.0 -Jinja2==3.1.4 -jsonargparse==4.3.0 -keras==2.11.0 +grpcio==1.68.1 +h5py==3.12.1 +idna==3.10 +imageio==2.36.1 +importlib_metadata==8.5.0 +importlib_resources==6.4.5 +Jinja2==3.1.5 +jsonargparse==4.35.0 +keras==3.9.0 libclang==18.1.1 +lightning==2.4.0 +lightning-utilities==0.11.9 locket==1.0.0 lru-dict==1.3.0 Magics==1.5.8 -Markdown==3.6 -MarkupSafe==2.1.5 -multidict==6.0.5 -multiurl==0.3.1 -netCDF4==1.6.5 -nox==2024.4.15 -numpngw==0.1.3 -numpy==1.21.2 +Markdown==3.7 +markdown-it-py==3.0.0 +MarkupSafe==3.0.2 +mdurl==0.1.2 +ml-dtypes==0.4.1 +mpmath==1.3.0 +multidict==6.1.0 +multiurl==0.3.3 +namex==0.0.8 +netCDF4==1.7.2 +networkx==3.4.2 +nox==2024.10.9 +numpngw==0.1.4 +numpy==2.0.2 +nvidia-cublas-cu12==12.4.5.8 +nvidia-cuda-cupti-cu12==12.4.127 +nvidia-cuda-nvrtc-cu12==12.4.127 +nvidia-cuda-runtime-cu12==12.4.127 +nvidia-cudnn-cu12==9.1.0.70 +nvidia-cufft-cu12==11.2.1.3 +nvidia-curand-cu12==10.3.5.147 +nvidia-cusolver-cu12==11.6.1.9 +nvidia-cusparse-cu12==12.3.1.170 +nvidia-nccl-cu12==2.21.5 +nvidia-nvjitlink-cu12==12.4.127 +nvidia-nvtx-cu12==12.4.127 oauthlib==3.2.2 -opt-einsum==3.3.0 -packaging==24.0 -pandas==2.0.3 -partd==1.4.1 +omegaconf==2.3.0 +opt_einsum==3.4.0 +optree==0.13.1 +packaging==24.2 +pandas==2.2.3 +partd==1.4.2 pdbufr==0.11.0 -pillow==10.3.0 -pip==24.0 -platformdirs==4.2.2 -protobuf==3.19.6 -pyasn1==0.6.0 -pyasn1_modules==0.4.0 +pillow==11.0.0 +pip==24.3.1 +platformdirs==4.3.6 +propcache==0.2.1 +protobuf==5.29.1 +pyasn1==0.6.1 +pyasn1_modules==0.4.1 pycparser==2.22 -pyDeprecate==0.3.1 +pyDeprecate==0.3.2 +Pygments==2.18.0 pyodc==1.4.1 python-dateutil==2.9.0.post0 -pytorch-lightning==1.5.7 +pytorch-lightning==2.4.0 pytorch-ranger==0.1.1 -pytz==2024.1 -PyYAML==6.0 -randomname==0.1.5 +pytz==2024.2 +PyYAML==6.0.2 +randomname==0.2.1 requests==2.32.3 requests-oauthlib==2.0.0 +rich==13.9.4 rsa==4.9 -setuptools==45.2.0 -six==1.16.0 -tensorboard==2.11.2 -tensorboard-data-server==0.6.1 +setuptools==75.1.0 +six==1.17.0 +sympy==1.13.1 +tensorboard==2.18.0 +tensorboard-data-server==0.7.2 tensorboard-plugin-wit==1.8.1 -tensorflow==2.11.1 -tensorflow-estimator==2.11.0 -tensorflow-io-gcs-filesystem==0.34.0 -termcolor==2.4.0 -tomli==2.0.1 -toolz==0.12.1 -torch==1.13.1+cu117 -torch-optimizer==0.1.0 -torchmetrics==0.5.1 -tqdm==4.66.4 -typing_extensions==4.12.0 -tzdata==2024.1 -urllib3==2.2.1 -virtualenv==20.26.2 -Werkzeug==3.0.3 -wheel==0.34.2 -wrapt==1.16.0 -xarray==2023.1.0 -yarl==1.9.4 -zipp==3.19.0 \ No newline at end of file +tensorflow==2.18.0 +tensorflow-estimator==2.15.0 +tensorflow-io-gcs-filesystem==0.37.1 +termcolor==2.5.0 +tomli==2.2.1 +toolz==1.0.0 +torch==2.6.0+cu124 +torch-optimizer==0.3.0 +torchmetrics==1.6.0 +tqdm==4.67.1 +triton==3.2.0 +typeshed_client==2.7.0 +typing_extensions==4.12.2 +tzdata==2024.2 +urllib3==2.2.3 +virtualenv==20.28.0 +Werkzeug==3.1.3 +wheel==0.44.0 +wrapt==1.17.0 +xarray==2024.11.0 +yarl==1.18.3 +zipp==3.21.0 diff --git a/weather-forecast/ecrad-3d-correction/unets/tests/test_config.py b/weather-forecast/ecrad-3d-correction/unets/tests/test_config.py deleted file mode 100644 index ab15654c..00000000 --- a/weather-forecast/ecrad-3d-correction/unets/tests/test_config.py +++ /dev/null @@ -1,36 +0,0 @@ -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -import os -import subprocess -from unittest import TestCase, main -from os.path import exists - -import config - - -class TestConfig(TestCase): - - def test_paths(self): - self.assertTrue(exists(config.experiment_path)) - self.assertTrue(os.getenv("AI4SIM_EXPERIMENT_PATH"), config.experiment_path) - # Execute again config.py to ensure experiment_path is given by AISIM_EXPERIMENT_PATH - subprocess.run(['python3', os.path.join(os.path.dirname(os.getcwd()), "config.py")]) - self.assertTrue(config.experiment_path, os.getenv("AI4SIM_EXPERIMENT_PATH")) - - self.assertTrue(exists(config.logs_path)) - self.assertTrue(exists(config.artifacts_path)) - self.assertTrue(exists(config.plots_path)) - - -if __name__ == '__main__': - main() diff --git a/weather-forecast/ecrad-3d-correction/unets/tests/test_data.py b/weather-forecast/ecrad-3d-correction/unets/tests/test_data.py index 1c5bde2c..1fb54d0e 100644 --- a/weather-forecast/ecrad-3d-correction/unets/tests/test_data.py +++ b/weather-forecast/ecrad-3d-correction/unets/tests/test_data.py @@ -10,17 +10,19 @@ # See the License for the specific language governing permissions and # limitations under the License. -from unittest import TestCase, main import os import os.path as osp -from data import ThreeDCorrectionDataset, LitThreeDCorrectionDataModule -from tempfile import mkdtemp from shutil import rmtree -from torch.utils.data import DataLoader +from tempfile import mkdtemp +from unittest import TestCase, main from warnings import catch_warnings, simplefilter -import numpy as np + import dask.array as da +import numpy as np import torch +from torch.utils.data import DataLoader + +from data import LitThreeDCorrectionDataModule, ThreeDCorrectionDataset class TestData(TestCase): @@ -39,7 +41,8 @@ def setUp(self) -> None: data_path=data_path, batch_size=1, num_workers=0, - splitting_ratios=(0.5, 0.25, 0.25)) + splitting_ratios=(0.5, 0.25, 0.25), + ) self.data_module.prepare_data() def tearDown(self) -> None: @@ -63,17 +66,20 @@ def create_env(self, root) -> None: # Save to shards. x_chunked = da.from_array(x, chunks=shard_size) y_chunked = da.from_array(y, chunks=shard_size) - da.to_npy_stack(osp.join(data_path, 'x'), x_chunked, axis=0) - da.to_npy_stack(osp.join(data_path, 'y'), y_chunked, axis=0) - - torch.save({ - 'x_mean': torch.tensor(np.random.rand(4, 138)), - 'x_std': torch.tensor(np.random.rand(4, 138)), - 'x_nb': torch.tensor(self.n_data), - 'y_mean': torch.tensor(np.random.rand(4, 138)), - 'y_std': torch.tensor(np.random.rand(4, 138)), - 'y_nb': torch.tensor(self.n_data) - }, osp.join(data_path, "stats.pt")) + da.to_npy_stack(osp.join(data_path, "x"), x_chunked, axis=0) + da.to_npy_stack(osp.join(data_path, "y"), y_chunked, axis=0) + + torch.save( + { + "x_mean": torch.tensor(np.random.rand(4, 138)), + "x_std": torch.tensor(np.random.rand(4, 138)), + "x_nb": torch.tensor(self.n_data), + "y_mean": torch.tensor(np.random.rand(4, 138)), + "y_std": torch.tensor(np.random.rand(4, 138)), + "y_nb": torch.tensor(self.n_data), + }, + osp.join(data_path, "stats.pt"), + ) def test_get(self) -> None: x, y = self.dataset[1] @@ -90,5 +96,5 @@ def test_setup(self) -> None: self.assertTrue(isinstance(self.data_module.test_dataloader(), DataLoader)) -if __name__ == '__main__': +if __name__ == "__main__": main() diff --git a/weather-forecast/ecrad-3d-correction/unets/tests/test_dataproc.py b/weather-forecast/ecrad-3d-correction/unets/tests/test_dataproc.py index 01da42d8..4d7b4eed 100644 --- a/weather-forecast/ecrad-3d-correction/unets/tests/test_dataproc.py +++ b/weather-forecast/ecrad-3d-correction/unets/tests/test_dataproc.py @@ -10,11 +10,12 @@ # See the License for the specific language governing permissions and # limitations under the License. -from unittest import TestCase, main import os.path as osp -from dataproc import ThreeDCorrectionDataproc -from tempfile import mkdtemp from shutil import rmtree +from tempfile import mkdtemp +from unittest import TestCase, main + +from dataproc import ThreeDCorrectionDataproc class TestDataproc(TestCase): @@ -23,10 +24,8 @@ def setUp(self) -> None: """Create a temporary environment.""" self.data_path = mkdtemp() self.dataproc = ThreeDCorrectionDataproc( - self.data_path, - timestep=3500, - patchstep=16, - num_workers=1) + self.data_path, timestep=3500, patchstep=16, num_workers=1 + ) def tearDown(self) -> None: rmtree(self.data_path) @@ -38,5 +37,5 @@ def test_process(self) -> None: self.assertTrue(osp.exists(osp.join(self.data_path, "processed", "y"))) -if __name__ == '__main__': +if __name__ == "__main__": main() diff --git a/weather-forecast/ecrad-3d-correction/unets/tests/test_models.py b/weather-forecast/ecrad-3d-correction/unets/tests/test_models.py index ea97ec47..bfa63a4f 100644 --- a/weather-forecast/ecrad-3d-correction/unets/tests/test_models.py +++ b/weather-forecast/ecrad-3d-correction/unets/tests/test_models.py @@ -10,14 +10,16 @@ # See the License for the specific language governing permissions and # limitations under the License. -from unittest import TestCase, main -from torch import Tensor, zeros, rand -from tempfile import mkdtemp +import os.path as osp from shutil import rmtree -from models import LitUnet1D -from torch_optimizer import Optimizer +from tempfile import mkdtemp +from unittest import TestCase, main + import torch -import os.path as osp +from torch import Tensor, rand, zeros +from torch_optimizer import Optimizer + +from models import LitUnet1D class TestModels(TestCase): @@ -32,26 +34,30 @@ def setUp(self) -> None: self.create_env(self.root) self.initParam = { - 'data_path': self.root, - 'in_channels': self.in_ch, - 'out_channels': self.out_ch, - 'n_levels': 3, - 'n_features_root': 32, - 'lr': .0001} + "data_path": self.root, + "in_channels": self.in_ch, + "out_channels": self.out_ch, + "n_levels": 3, + "n_features_root": 32, + "lr": 0.0001, + } def tearDown(self) -> None: rmtree(self.root) def create_env(self, root) -> None: """Build an environment with stats.pt.""" - torch.save({ - 'x_mean': rand(self.height, self.in_ch), - 'x_std': rand(self.height, self.in_ch), - 'x_nb': torch.tensor(10), - 'y_mean': rand(self.height, self.out_ch), - 'y_std': rand(self.height, self.out_ch), - 'y_nb': torch.tensor(10) - }, osp.join(root, "stats.pt")) + torch.save( + { + "x_mean": rand(self.height, self.in_ch), + "x_std": rand(self.height, self.in_ch), + "x_nb": torch.tensor(10), + "y_mean": rand(self.height, self.out_ch), + "y_std": rand(self.height, self.out_ch), + "y_nb": torch.tensor(10), + }, + osp.join(root, "stats.pt"), + ) def test_forward_common_step(self): # Fake data, of dim (n_batchs, height, n_channels). @@ -74,5 +80,5 @@ def test_configure_optimizers(self): self.assertTrue(isinstance(op, Optimizer)) -if __name__ == '__main__': +if __name__ == "__main__": main() diff --git a/weather-forecast/ecrad-3d-correction/unets/tests/test_trainer.py b/weather-forecast/ecrad-3d-correction/unets/tests/test_trainer.py deleted file mode 100644 index 0dec88d6..00000000 --- a/weather-forecast/ecrad-3d-correction/unets/tests/test_trainer.py +++ /dev/null @@ -1,41 +0,0 @@ -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -from unittest import TestCase, main -from warnings import catch_warnings, simplefilter -from torch import cuda -from trainer import Trainer - - -class TestTrainer(TestCase): - - def setUp(self) -> None: - self.args_cpu = {"max_epochs": 1, - "accelerator": "cpu", - "devices": [0]} - self.args_gpu = {"max_epochs": 1, - "accelerator": "gpu", - "devices": [0]} - - def test_trainer(self) -> None: - if cuda.is_available(): - Trainer(**self.args_gpu) - - # Avoids GPU warning when testing CPU usage. - with catch_warnings(): - simplefilter("ignore") - test_trainer_cpu = Trainer(**self.args_cpu) - self.assertEqual(test_trainer_cpu._devices, None) - - -if __name__ == '__main__': - main() diff --git a/weather-forecast/ecrad-3d-correction/unets/tests/test_unet.py b/weather-forecast/ecrad-3d-correction/unets/tests/test_unet.py index b1c2524a..a5f86fb0 100644 --- a/weather-forecast/ecrad-3d-correction/unets/tests/test_unet.py +++ b/weather-forecast/ecrad-3d-correction/unets/tests/test_unet.py @@ -11,8 +11,10 @@ # limitations under the License. from unittest import TestCase, main + from torch import rand -from unet import UNet1D, Downsampler, Upsampler + +from unet import Downsampler, UNet1D, Upsampler class TestUnet1D(TestCase): @@ -60,5 +62,5 @@ def test_upsampler(self): self.assertEqual(shp, (1, 4, 32)) # last DoubleConv enforces the out_ch. -if __name__ == '__main__': +if __name__ == "__main__": main() diff --git a/weather-forecast/ecrad-3d-correction/unets/trainer.py b/weather-forecast/ecrad-3d-correction/unets/trainer.py index c7e0eeeb..9983a888 100644 --- a/weather-forecast/ecrad-3d-correction/unets/trainer.py +++ b/weather-forecast/ecrad-3d-correction/unets/trainer.py @@ -10,69 +10,21 @@ # See the License for the specific language governing permissions and # limitations under the License. -import json -import os -import pytorch_lightning as pl -from pytorch_lightning.callbacks.base import Callback -from pytorch_lightning.loggers import TensorBoardLogger -from pytorch_lightning.utilities.cli import LightningCLI -import torch -from typing import List, Union +from lightning.pytorch.cli import LightningCLI -import config -import data # noqa: F401 'data' imported but unused -import models # noqa: F401 'data' imported but unused - -class Trainer(pl.Trainer): - """ - Modified PyTorch Lightning Trainer that automatically tests, - logs, and writes artifacts by the end of training. - """ - - def __init__(self, - accelerator: Union[str, pl.accelerators.Accelerator, None], - devices: Union[List[int], str, int, None], - max_epochs: int, - fast_dev_run: Union[int, bool] = False, - callbacks: Union[List[Callback], Callback, None] = None) -> None: - """ - Args: - accelerator (Union[str, Accelerator, None]): Type of accelerator to use for training. - devices: (Union[List[int], str, int, None]): Devices to use for training. - max_epochs (int): Maximum number of epochs if no early stopping logic is implemented. - """ - self._devices = devices - if accelerator == 'cpu': - self._devices = None - logger = TensorBoardLogger(config.logs_path, name=None) - - super().__init__( - default_root_dir=config.logs_path, - logger=logger, - accelerator=accelerator, - devices=self._devices, - max_epochs=max_epochs, - # for some reason, a forward pass happens in the model before datamodule creation. - # TODO: learn normalizers (mean, std) in a layer - num_sanity_val_steps=0) - - def test(self, **kwargs) -> None: - """ - Uses superclass test results, saves raw results as a JSON file, - stores the model weights for future use in inference mode. - """ - results = super().test(**kwargs)[0] - with open(os.path.join(config.artifacts_path, "results.json"), "w") as f: - json.dump(results, f) - torch.save(self.model, os.path.join(config.artifacts_path, 'model.pth')) +class MyLightningCLI(LightningCLI): + def add_arguments_to_parser(self, parser): + parser.link_arguments( + "data.data_path", "model.init_args.data_path", apply_on="instantiate" + ) def main(): - cli = LightningCLI(trainer_class=Trainer, run=False) + cli = MyLightningCLI(run=False, parser_kwargs={"parser_mode": "omegaconf"}) cli.trainer.fit(model=cli.model, datamodule=cli.datamodule) cli.trainer.test(model=cli.model, datamodule=cli.datamodule) -if __name__ == '__main__': +if __name__ == "__main__": main() diff --git a/weather-forecast/ecrad-3d-correction/unets/unet.py b/weather-forecast/ecrad-3d-correction/unets/unet.py index 02eb457b..263cf703 100644 --- a/weather-forecast/ecrad-3d-correction/unets/unet.py +++ b/weather-forecast/ecrad-3d-correction/unets/unet.py @@ -10,8 +10,8 @@ # See the License for the specific language governing permissions and # limitations under the License. -from torch import cat, Tensor import torch.nn as nn +from torch import Tensor, cat class UNet1D(nn.Module): @@ -25,12 +25,14 @@ class UNet1D(nn.Module): bilinear: Whether to use bilinear interpolation or transposed convolutions for upsampling. """ - def __init__(self, - inp_ch: int, - out_ch: int, - n_levels: int, - n_features_root: int, - bilinear: bool = False): + def __init__( + self, + inp_ch: int, + out_ch: int, + n_levels: int, + n_features_root: int, + bilinear: bool = False, + ): super().__init__() self.n_levels = n_levels @@ -56,11 +58,11 @@ def forward(self, x: Tensor) -> Tensor: xi = [self.layers[0](x)] # Downward path. - for layer in self.layers[1:self.n_levels]: + for layer in self.layers[1 : self.n_levels]: xi.append(layer(xi[-1])) # Upward path. - for i, layer in enumerate(self.layers[self.n_levels:-1]): + for i, layer in enumerate(self.layers[self.n_levels : -1]): xi[-1] = layer(xi[-1], xi[-2 - i]) # upsamplers taking skip-connections. return self.layers[-1](xi[-1]) @@ -82,7 +84,8 @@ def __init__(self, inp_ch: int, out_ch: int, residual: bool = False): nn.ReLU(inplace=True), nn.Conv1d(out_ch, out_ch, kernel_size=3, padding=1), nn.BatchNorm1d(out_ch), - nn.ReLU(inplace=True)) + nn.ReLU(inplace=True), + ) self.res = None if residual: @@ -98,8 +101,8 @@ class Downsampler(nn.Module): def __init__(self, inp_ch: int, out_ch: int): super().__init__() self.net = nn.Sequential( - nn.MaxPool1d(kernel_size=2, stride=2), - DoubleConv(inp_ch, out_ch)) + nn.MaxPool1d(kernel_size=2, stride=2), DoubleConv(inp_ch, out_ch) + ) def forward(self, x: Tensor) -> Tensor: return self.net(x) @@ -116,14 +119,17 @@ def __init__(self, inp_ch: int, out_ch: int, bilinear: bool = False): super().__init__() self.upsample = None if inp_ch < 2: - raise ValueError(f'Input channel ({inp_ch}) too low.') + raise ValueError(f"Input channel ({inp_ch}) too low.") if bilinear: self.upsample = nn.Sequential( nn.Upsample(scale_factor=2, mode="bilinear", align_corners=True), - nn.Conv1d(inp_ch, inp_ch // 2, kernel_size=1)) + nn.Conv1d(inp_ch, inp_ch // 2, kernel_size=1), + ) else: - self.upsample = nn.ConvTranspose1d(inp_ch, inp_ch // 2, kernel_size=2, stride=2) + self.upsample = nn.ConvTranspose1d( + inp_ch, inp_ch // 2, kernel_size=2, stride=2 + ) self.conv = DoubleConv(inp_ch, out_ch) def forward(self, x1: Tensor, x2: Tensor) -> Tensor: diff --git a/weather-forecast/gravity-wave-drag/cnns/.coveragerc b/weather-forecast/gravity-wave-drag/cnns/.coveragerc index 1e50b0f0..acb4e457 100644 --- a/weather-forecast/gravity-wave-drag/cnns/.coveragerc +++ b/weather-forecast/gravity-wave-drag/cnns/.coveragerc @@ -1,2 +1,3 @@ [run] +include = ./*.py omit = noxfile.py,tests/* diff --git a/weather-forecast/gravity-wave-drag/cnns/.gitignore b/weather-forecast/gravity-wave-drag/cnns/.gitignore index 107361e6..5495c782 100755 --- a/weather-forecast/gravity-wave-drag/cnns/.gitignore +++ b/weather-forecast/gravity-wave-drag/cnns/.gitignore @@ -1,9 +1,3 @@ -!data -data/* -!data/filenames.yaml -!data/filenames-split.yaml -experiments - # Byte-compiled / optimized / DLL files __pycache__/ @@ -14,6 +8,7 @@ __pycache__/ # Unit test / coverage reports .pytest_cache/ .coverage +.coverage-* .coverage.* coverage.xml @@ -28,3 +23,10 @@ venv/ ENV/ env.bak/ venv.bak/ +.vscode + +# Data +data/ + +# Experiments +experiments/ \ No newline at end of file diff --git a/weather-forecast/gravity-wave-drag/cnns/__init__.py b/weather-forecast/gravity-wave-drag/cnns/__init__.py index dd4a7cdb..4d9a9249 100644 --- a/weather-forecast/gravity-wave-drag/cnns/__init__.py +++ b/weather-forecast/gravity-wave-drag/cnns/__init__.py @@ -1,5 +1,3 @@ -# Ignore "D104 Missing docstring in public package" in empty file. # noqa: D104 - # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at diff --git a/weather-forecast/gravity-wave-drag/cnns/ci/configs/cnn_test.yaml b/weather-forecast/gravity-wave-drag/cnns/ci/configs/cnn_test.yaml index 92c2ba5c..316ce672 100644 --- a/weather-forecast/gravity-wave-drag/cnns/ci/configs/cnn_test.yaml +++ b/weather-forecast/gravity-wave-drag/cnns/ci/configs/cnn_test.yaml @@ -10,27 +10,32 @@ # See the License for the specific language governing permissions and # limitations under the License. -fit: - model: - class_path: models.LitCNN - init_args: - in_channels: 5 - init_feat: 16 - out_channels: 126 - conv_size: 1 - pool_size: 2 - lr: .0001 +seed_everything: 0 + +model: + class_path: models.LitCNN + init_args: + in_channels: 5 + init_feat: 16 + out_channels: 126 + conv_size: 1 + pool_size: 2 + lr: .0001 + +data: + class_path: data.NOGWDDataModule + init_args: + batch_size: 10 + num_workers: 1 + shard_len: 10 + data_path: ${oc.decode:${oc.env:DATADIR, ./data}} + splitting_file: ${oc.decode:${oc.env:DATADIR, ./data}}/filenames-split.yaml - data: - class_path: data.NOGWDDataModule +trainer: + max_epochs: 1 + accelerator: "cpu" + devices: ${oc.decode:${oc.env:SLURM_GPUS_ON_NODE, 3}} + logger: + class_path: lightning.pytorch.loggers.tensorboard.TensorBoardLogger init_args: - batch_size: 10 - num_workers: - splitting_ratios: [0.6, 0.2] - shard_len: 100 - - trainer: - max_epochs: 1 - accelerator: "cpu" - devices: - - 0 \ No newline at end of file + save_dir: ${oc.decode:${oc.env:LOGDIR, ./logs}} diff --git a/weather-forecast/gravity-wave-drag/cnns/ci/configs/mlp_test.yaml b/weather-forecast/gravity-wave-drag/cnns/ci/configs/mlp_test.yaml index 36706a14..c832571b 100644 --- a/weather-forecast/gravity-wave-drag/cnns/ci/configs/mlp_test.yaml +++ b/weather-forecast/gravity-wave-drag/cnns/ci/configs/mlp_test.yaml @@ -10,25 +10,30 @@ # See the License for the specific language governing permissions and # limitations under the License. -fit: - model: - class_path: models.LitMLP - init_args: - in_channels: 191 - hidden_channels: 256 - out_channels: 126 - lr: .0001 +seed_everything: 0 + +model: + class_path: models.LitMLP + init_args: + in_channels: 191 + hidden_channels: 256 + out_channels: 126 + lr: .0001 + +data: + class_path: data.NOGWDDataModule + init_args: + batch_size: 10 + num_workers: 1 + shard_len: 10 + data_path: ${oc.decode:${oc.env:DATADIR, ./data}} + splitting_file: ${oc.decode:${oc.env:DATADIR, ./data}}/filenames-split.yaml - data: - class_path: data.NOGWDDataModule +trainer: + max_epochs: 1 + accelerator: "cpu" + devices: ${oc.decode:${oc.env:SLURM_GPUS_ON_NODE, 1}} + logger: + class_path: lightning.pytorch.loggers.tensorboard.TensorBoardLogger init_args: - batch_size: 10 - num_workers: 1 - splitting_ratios: [0.6, 0.2] - shard_len: 100 - - trainer: - max_epochs: 1 - accelerator: "cpu" - devices: - - 0 \ No newline at end of file + save_dir: ${oc.decode:${oc.env:LOGDIR, ./logs}} diff --git a/weather-forecast/gravity-wave-drag/cnns/ci/generate_synthetic_data.py b/weather-forecast/gravity-wave-drag/cnns/ci/generate_synthetic_data.py index 732672ad..a628093b 100644 --- a/weather-forecast/gravity-wave-drag/cnns/ci/generate_synthetic_data.py +++ b/weather-forecast/gravity-wave-drag/cnns/ci/generate_synthetic_data.py @@ -10,56 +10,42 @@ # See the License for the specific language governing permissions and # limitations under the License. -from os.path import join, exists +import os +import sys from os import makedirs -from h5py import File -from yaml import dump, safe_load +from os.path import exists, join + import numpy as np -import sys -import os +from h5py import File +from yaml import dump sys.path.insert(1, "/".join(os.path.realpath(__file__).split("/")[0:-2])) - -import config # noqa: +data_path = "./data" def create_data(): """Create data folder with fake raw data""" - filepath = join(config.root_path, 'ci/configs', 'mlp_test.yaml') - filenames = ['test_1.h5', 'test_2.h5', 'test_3.h5', 'test_4.h5', 'test_5.h5', 'test_6.h5'] - file_split = {} - - with open(filepath, 'r') as file: - params = safe_load(file) - - row_feats = params['fit']['data']['init_args']['shard_len'] - if (not exists(config.data_path)): - makedirs(join(config.data_path, "raw")) - for file_h5 in filenames: - with File(join(config.data_path, "raw", file_h5), 'w') as f: - f['/x'] = np.random.normal(0, 1, (row_feats, 191)).astype('float32') - f['/y'] = np.random.normal(0, 1, (row_feats, 126)).astype('float32') - - temp_file_path = join(config.data_path, 'filenames.yaml') - with open(temp_file_path, 'w') as tmpfile: - dump(filenames, tmpfile) - - tr, va = params['fit']['data']['init_args']['splitting_ratios'] - length = len(filenames) - - for element in filenames: - file_split['train'] = filenames[:int(tr * length)] - file_split['val'] = filenames[int(tr * length):int((tr + va) * length)] - file_split['test'] = filenames[int((tr + va) * length):] - - temp_file_path = join(config.data_path, 'filenames-split.yaml') - with open(temp_file_path, 'w') as tmpfile: + file_split = { + "train": ["test_1.h5", "test_2.h5", "test_3.h5"], + "val": ["test_4.h5", "test_5.h5"], + "test": ["test_6.h5"], + } + + if not exists(data_path): + makedirs(join(data_path, "raw")) + for file_list in file_split.values(): + for file_h5 in file_list: + with File(join(data_path, "raw", file_h5), "w") as f: + f["/x"] = np.random.normal(0, 1, (10, 191)).astype("float32") + f["/y"] = np.random.normal(0, 1, (10, 126)).astype("float32") + + temp_file_path = join(data_path, "filenames-split.yaml") + with open(temp_file_path, "w") as tmpfile: dump(file_split, tmpfile) - else: - raise Exception(f"Remove manually {config.data_path}") + raise Exception(f"Remove manually {data_path}") -if __name__ == '__main__': +if __name__ == "__main__": create_data() diff --git a/weather-forecast/gravity-wave-drag/cnns/ci/requirements_data.txt b/weather-forecast/gravity-wave-drag/cnns/ci/requirements_data.txt deleted file mode 100644 index 65932375..00000000 --- a/weather-forecast/gravity-wave-drag/cnns/ci/requirements_data.txt +++ /dev/null @@ -1,4 +0,0 @@ -randomname==0.1.5 -numpy==1.21.2 -pyyaml==6.0 -h5py==3.4.0 \ No newline at end of file diff --git a/weather-forecast/gravity-wave-drag/cnns/ci/run.sh b/weather-forecast/gravity-wave-drag/cnns/ci/run.sh index 33c3441c..a9ba44d7 100644 --- a/weather-forecast/gravity-wave-drag/cnns/ci/run.sh +++ b/weather-forecast/gravity-wave-drag/cnns/ci/run.sh @@ -11,5 +11,21 @@ # See the License for the specific language governing permissions and # limitations under the License. -python3 trainer.py --config ./ci/configs/cnn_test.yaml -python3 trainer.py --config ./ci/configs/mlp_test.yaml +RUNNER="python3" +# Parse script options +while [[ $# -gt 0 ]]; do + case $1 in + -r|--runner) + RUNNER="$2" + shift # past argument + shift # past value + ;; + -*|--*) + echo "Unknown option $1" + exit 1 + ;; + esac +done + +${RUNNER} trainer.py --config ./ci/configs/cnn_test.yaml || exit 1 +${RUNNER} trainer.py --config ./ci/configs/mlp_test.yaml || exit 2 diff --git a/weather-forecast/gravity-wave-drag/cnns/config.py b/weather-forecast/gravity-wave-drag/cnns/config.py deleted file mode 100644 index c5265775..00000000 --- a/weather-forecast/gravity-wave-drag/cnns/config.py +++ /dev/null @@ -1,50 +0,0 @@ -"""This module configure the experiment environment.""" -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -import os -import randomname - -root_path = os.path.dirname(os.path.realpath(__file__)) - -data_path = os.path.join(root_path, 'data') - -# Create all path for the current experiment -experiments_path = os.path.join(root_path, 'experiments') -os.makedirs(experiments_path, exist_ok=True) -_existing_xps = os.listdir(experiments_path) - -# Generate experiment name -_randomize_name = True -while _randomize_name: - _experiment_name = randomname.get_name() - if _experiment_name not in _existing_xps: - break -experiment_path = os.path.join(experiments_path, _experiment_name) - -if os.getenv("AI4SIM_EXPERIMENT_PATH") is None: - os.environ["AI4SIM_EXPERIMENT_PATH"] = experiment_path -else: - experiment_path = os.getenv("AI4SIM_EXPERIMENT_PATH") - -logs_path = os.path.join(experiment_path, 'logs') -artifacts_path = os.path.join(experiment_path, 'artifacts') -plots_path = os.path.join(experiment_path, 'plots') - -_paths = [ - experiment_path, - logs_path, - artifacts_path, - plots_path -] -for path in _paths: - os.makedirs(path, exist_ok=True) diff --git a/weather-forecast/gravity-wave-drag/cnns/configs/cnn.yaml b/weather-forecast/gravity-wave-drag/cnns/configs/cnn.yaml index 0107d57d..57a7013e 100644 --- a/weather-forecast/gravity-wave-drag/cnns/configs/cnn.yaml +++ b/weather-forecast/gravity-wave-drag/cnns/configs/cnn.yaml @@ -10,25 +10,31 @@ # See the License for the specific language governing permissions and # limitations under the License. -fit: - model: - class_path: models.LitCNN - init_args: - in_channels: 5 - init_feat: 16 - out_channels: 126 - conv_size: 1 - pool_size: 2 - lr: .0001 +seed_everything: 0 + +model: + class_path: models.LitCNN + init_args: + in_channels: 5 + init_feat: 16 + out_channels: 126 + conv_size: 1 + pool_size: 2 + lr: .0001 + +data: + class_path: data.NOGWDDataModule + init_args: + batch_size: 256 + num_workers: 0 + data_path: ${oc.decode:${oc.env:DATADIR, ./data}} + splitting_file: ${oc.decode:${oc.env:DATADIR, ./data}}/filenames-split.yaml - data: - class_path: data.NOGWDDataModule +trainer: + max_epochs: 10 + accelerator: "gpu" + devices: ${oc.decode:${oc.env:SLURM_GPUS_ON_NODE, [0]}} + logger: + class_path: lightning.pytorch.loggers.tensorboard.TensorBoardLogger init_args: - batch_size: 256 - num_workers: 0 - - trainer: - max_epochs: 10 - accelerator: "cpu" - devices: - - 0 \ No newline at end of file + save_dir: ${oc.decode:${oc.env:LOGDIR, ./logs}} diff --git a/weather-forecast/gravity-wave-drag/cnns/configs/default.yaml b/weather-forecast/gravity-wave-drag/cnns/configs/default.yaml index 99b405bf..48d2bd9c 100644 --- a/weather-forecast/gravity-wave-drag/cnns/configs/default.yaml +++ b/weather-forecast/gravity-wave-drag/cnns/configs/default.yaml @@ -10,23 +10,29 @@ # See the License for the specific language governing permissions and # limitations under the License. -fit: - model: - class_path: models.LitMLP - init_args: - in_channels: 191 - hidden_channels: 256 - out_channels: 126 - lr: .0001 +seed_everything: 0 + +model: + class_path: models.LitMLP + init_args: + in_channels: 191 + hidden_channels: 256 + out_channels: 126 + lr: .0001 + +data: + class_path: data.NOGWDDataModule + init_args: + batch_size: 256 + num_workers: 0 + data_path: ${oc.decode:${oc.env:DATADIR, ./data}} + splitting_file: ${oc.decode:${oc.env:DATADIR, ./data}}/filenames-split.yaml - data: - class_path: data.NOGWDDataModule +trainer: + max_epochs: 1 + accelerator: "gpu" + devices: ${oc.decode:${oc.env:SLURM_GPUS_ON_NODE, [0]}} + logger: + class_path: lightning.pytorch.loggers.tensorboard.TensorBoardLogger init_args: - batch_size: 256 - num_workers: 0 - - trainer: - max_epochs: 1 - accelerator: "gpu" - devices: - - 0 \ No newline at end of file + save_dir: ${oc.decode:${oc.env:LOGDIR, ./logs}} diff --git a/weather-forecast/gravity-wave-drag/cnns/configs/mlp.yaml b/weather-forecast/gravity-wave-drag/cnns/configs/mlp.yaml index 7c154fc5..b546edc9 100644 --- a/weather-forecast/gravity-wave-drag/cnns/configs/mlp.yaml +++ b/weather-forecast/gravity-wave-drag/cnns/configs/mlp.yaml @@ -10,23 +10,29 @@ # See the License for the specific language governing permissions and # limitations under the License. -fit: - model: - class_path: models.LitMLP - init_args: - in_channels: 191 - hidden_channels: 256 - out_channels: 126 - lr: .0001 +seed_everything: 0 + +model: + class_path: models.LitMLP + init_args: + in_channels: 191 + hidden_channels: 256 + out_channels: 126 + lr: .0001 + +data: + class_path: data.NOGWDDataModule + init_args: + batch_size: 256 + num_workers: 0 + data_path: ${oc.decode:${oc.env:DATADIR, ./data}} + splitting_file: ${oc.decode:${oc.env:DATADIR, ./data}}/filenames-split.yaml - data: - class_path: data.NOGWDDataModule +trainer: + max_epochs: 5 + accelerator: "gpu" + devices: ${oc.decode:${oc.env:SLURM_GPUS_ON_NODE, [0]}} + logger: + class_path: lightning.pytorch.loggers.tensorboard.TensorBoardLogger init_args: - batch_size: 256 - num_workers: 0 - - trainer: - max_epochs: 5 - accelerator: "gpu" - devices: - - 0 \ No newline at end of file + save_dir: ${oc.decode:${oc.env:LOGDIR, ./logs}} diff --git a/weather-forecast/gravity-wave-drag/cnns/data.py b/weather-forecast/gravity-wave-drag/cnns/data.py index 661c6ed4..5539f9f7 100644 --- a/weather-forecast/gravity-wave-drag/cnns/data.py +++ b/weather-forecast/gravity-wave-drag/cnns/data.py @@ -1,4 +1,5 @@ """This module proposes Pytorch style Dataset classes for the gwd use-case.""" + # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at @@ -11,17 +12,15 @@ # See the License for the specific language governing permissions and # limitations under the License. +import os +from typing import List, Optional, Tuple + import h5py +import lightning as pl import numpy as np -import os -import pytorch_lightning as pl -from pytorch_lightning.utilities.cli import DATAMODULE_REGISTRY import torch -from typing import List, Tuple, Optional import yaml -import config - class NOGWDDataset(torch.utils.data.Dataset): """ @@ -29,24 +28,28 @@ class NOGWDDataset(torch.utils.data.Dataset): Each raw HDF5 input file contains two datasets—x and y—of 2355840 rows each. Input features: Output features: . - Refer to the UC get-started.ipynb notebook for more details on the inputs. """ x_feat = 191 y_feat = 126 - def __init__(self, root: str, mode: str, shard_len: int) -> None: + def __init__( + self, root: str, mode: str, shard_len: int, splitting_file: str + ) -> None: """Create the Dataset. Args: root (str): Path to the root data folder. mode (str): Data processing mode. If 'train', it will compute the stats used by the model in the normalization layer. + splitting_file (str): Path to the file that contains the set of filenames used for + each dataset (train, val, test). """ super().__init__() self.root = root self.mode = mode self.shard_len = shard_len + self.splitting_file = splitting_file self.x, self.y = self.load() @@ -56,11 +59,11 @@ def __init__(self, root: str, mode: str, shard_len: int) -> None: def _compute_stats(self) -> None: """Compute some x and y statistics and store them in a file.""" stats = { - 'x_mean': torch.mean(self.x, dim=0, dtype=torch.float32), - 'x_std': torch.std(self.x, dim=0), - 'y_std': torch.std(self.y, dim=0) + "x_mean": torch.mean(self.x, dim=0, dtype=torch.float32), + "x_std": torch.std(self.x, dim=0), + "y_std": torch.std(self.y, dim=0), } - torch.save(stats, os.path.join(self.root, 'stats.pt')) + torch.save(stats, os.path.join(self.root, "stats.pt")) # TODO: Implement a method to download the data with Climetlab def download(self) -> None: @@ -80,9 +83,9 @@ def load(self) -> Tuple[torch.Tensor, torch.Tensor]: print(self.raw_filenames) for filename in self.raw_filenames: - with h5py.File(os.path.join(self.raw_dir, filename), 'r') as file: - x_raw = file['/x'][:] - y_raw = file['/y'][:] + with h5py.File(os.path.join(self.raw_dir, filename), "r") as file: + x_raw = file["/x"][:] + y_raw = file["/y"][:] x_temp.append(np.reshape(x_raw, (191, -1)).T) y_temp.append(np.reshape(y_raw, (126, -1)).T) @@ -108,7 +111,7 @@ def raw_filenames(self) -> List[str]: Returns: (List[str]): Raw data file names list. """ - with open(os.path.join(self.root, "filenames-split.yaml"), "r") as stream: + with open(self.splitting_file, "r") as stream: filenames = yaml.safe_load(stream) filenames = filenames[self.mode] return filenames @@ -130,18 +133,20 @@ def __getitem__(self, idx: int) -> Tuple[torch.Tensor]: return self.x[idx, :], self.y[idx, :] -@DATAMODULE_REGISTRY class NOGWDDataModule(pl.LightningDataModule): """Create a datamodule structure for use in a PyTorch Lightning Trainer. Basically a wrapper around the Dataset. Train, val, test split is given by data/filenames-split.yaml. Training set is randomized. """ - def __init__(self, - batch_size: int, - num_workers: int, - splitting_ratios: Tuple[float, float] = (0.8, 0.1), - shard_len: int = 2355840) -> None: + def __init__( + self, + batch_size: int, + num_workers: int, + data_path: str, + splitting_file: str, + shard_len: int = 2355840, + ) -> None: """Init the NOGWDDataModule class. Args: @@ -150,8 +155,9 @@ def __init__(self, """ self.batch_size = batch_size self.num_workers = num_workers - self.splitting_ratios = splitting_ratios + self.splitting_file = splitting_file self.shard_len = shard_len + self.data_path = data_path super().__init__() self.train = None self.val = None @@ -167,12 +173,18 @@ def setup(self, stage: Optional[str] = None) -> None: stage (str): Stage for which to setup the DataLoader. If 'fit', it will prepare the train and val DataLoaders. If 'test', it will prepare the test DataLoader. """ - if stage == 'fit': - self.train = NOGWDDataset(config.data_path, 'train', self.shard_len) - self.val = NOGWDDataset(config.data_path, 'val', self.shard_len) - - if stage == 'test': - self.test = NOGWDDataset(config.data_path, 'test', self.shard_len) + if stage == "fit": + self.train = NOGWDDataset( + self.data_path, "train", self.shard_len, self.splitting_file + ) + self.val = NOGWDDataset( + self.data_path, "val", self.shard_len, self.splitting_file + ) + + if stage == "test": + self.test = NOGWDDataset( + self.data_path, "test", self.shard_len, self.splitting_file + ) def train_dataloader(self) -> torch.utils.data.DataLoader: """Return the train DataLoader. @@ -185,7 +197,8 @@ def train_dataloader(self) -> torch.utils.data.DataLoader: batch_size=self.batch_size, shuffle=True, drop_last=True, - num_workers=self.num_workers) + num_workers=self.num_workers, + ) def val_dataloader(self) -> torch.utils.data.DataLoader: """Return the val DataLoader. @@ -197,7 +210,8 @@ def val_dataloader(self) -> torch.utils.data.DataLoader: self.val, batch_size=self.batch_size, drop_last=True, - num_workers=self.num_workers) + num_workers=self.num_workers, + ) def test_dataloader(self) -> torch.utils.data.DataLoader: """Return the test DataLoader. @@ -206,6 +220,5 @@ def test_dataloader(self) -> torch.utils.data.DataLoader: (torch.utils.data.DataLoader): Test DataLoader. """ return torch.utils.data.DataLoader( - self.test, - batch_size=self.batch_size, - num_workers=self.num_workers) + self.test, batch_size=self.batch_size, num_workers=self.num_workers + ) diff --git a/weather-forecast/gravity-wave-drag/cnns/env.yaml b/weather-forecast/gravity-wave-drag/cnns/env.yaml index 1665db61..0186867e 100644 --- a/weather-forecast/gravity-wave-drag/cnns/env.yaml +++ b/weather-forecast/gravity-wave-drag/cnns/env.yaml @@ -1,7 +1,7 @@ # This file defines the global environment dependencies for this model project. # It is read by the CI/CD workflows in charge of the tests (ai4sim-ci-cd.yaml) # and the build of the Docker image (images-ci-cd.yaml) to set the environment. -python_version: 3.8 +python_version: 3.10 ubuntu_base_image: name: nvidia/cuda - tag: 11.7.1-cudnn8-runtime-ubuntu20.04 \ No newline at end of file + tag: 12.4.1-cudnn-runtime-ubuntu22.04 \ No newline at end of file diff --git a/weather-forecast/gravity-wave-drag/cnns/models.py b/weather-forecast/gravity-wave-drag/cnns/models.py index ed72521c..994ebf5a 100644 --- a/weather-forecast/gravity-wave-drag/cnns/models.py +++ b/weather-forecast/gravity-wave-drag/cnns/models.py @@ -1,4 +1,5 @@ """This module proposes Pytorch style LightningModule classes for the gwd use-case.""" + # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at @@ -11,21 +12,20 @@ # See the License for the specific language governing permissions and # limitations under the License. -import config import os -import pytorch_lightning as pl -from pytorch_lightning.utilities.cli import MODEL_REGISTRY +from typing import Tuple + +import lightning as pl import torch import torch.nn as nn import torch_optimizer as optim import torchmetrics.functional as tmf -from typing import Tuple class NOGWDModule(pl.LightningModule): """Contains the mutualizable model logic for the NO-GWD UC.""" - def __init__(self): + def __init__(self, data_path: str): """Load previously computed stats for model-level normalization purposes.""" super().__init__() # Init attributes to fake data @@ -33,11 +33,11 @@ def __init__(self): self.x_std = torch.tensor(1) self.y_std = torch.tensor(1) - if os.path.exists(os.path.join(config.data_path, 'stats.pt')): - stats = torch.load(os.path.join(config.data_path, 'stats.pt')) - self.x_mean = stats['x_mean'] - self.x_std = stats['x_std'] - self.y_std = stats['y_std'].max() + if os.path.exists(os.path.join(data_path, "stats.pt")): + stats = torch.load(os.path.join(data_path, "stats.pt")) + self.x_mean = stats["x_mean"] + self.x_std = stats["x_std"] + self.y_std = stats["y_std"].max() def forward(self, features: torch.Tensor): """Compute the forward pass. @@ -50,14 +50,16 @@ def forward(self, features: torch.Tensor): """ return self.net(features) - def _common_step(self, batch: Tuple[torch.Tensor, torch.Tensor], batch_idx: int, stage: str): + def _common_step( + self, batch: Tuple[torch.Tensor, torch.Tensor], batch_idx: int, stage: str + ): """Define the common operations performed on data.""" x_val, y_val = batch x_val = (x_val - self.x_mean.to(self.device)) / self.x_std.to(self.device) y_val = y_val / self.y_std.to(self.device) y_hat = self(x_val) - loss = tmf.mean_squared_error(y_hat, y_val) + loss = tmf.mean_squared_error(y_hat.contiguous(), y_val.contiguous()) # TODO: Add epsilon in TSS for R2 score computation. # Currently returns NaN sometimes. r2 = tmf.r2_score(y_hat, y_val) @@ -107,17 +109,20 @@ def configure_optimizers(self): return optim.AdamP(self.parameters(), lr=self.lr) -@MODEL_REGISTRY class LitMLP(NOGWDModule): """Create a good old MLP.""" - def __init__(self, - in_channels: int, - hidden_channels: int, - out_channels: int, - lr: float): + def __init__( + self, + in_channels: int, + hidden_channels: int, + out_channels: int, + lr: float, + *args, + **kwargs, + ): """Define the network LitMLP architecture.""" - super().__init__() + super().__init__(*args, **kwargs) self.lr = lr self.net = nn.Sequential( @@ -131,7 +136,6 @@ def __init__(self, ) -@MODEL_REGISTRY class LitCNN(NOGWDModule): """Create a simple 1D ConvNet working on columnar data. Input layer reshapes the data to broadcast surface parameters at every Atmospheric level. @@ -151,20 +155,24 @@ def forward(self, tensor: torch.Tensor): Returns: (torch.Tensor): the reshaped tensor. """ - t0 = torch.reshape(tensor[:, :3 * 63], [-1, 3, 63]) - t1 = torch.tile(tensor[:, 3 * 63:].unsqueeze(2), (1, 1, 63)) + t0 = torch.reshape(tensor[:, : 3 * 63], [-1, 3, 63]) + t1 = torch.tile(tensor[:, 3 * 63 :].unsqueeze(2), (1, 1, 63)) return torch.cat((t0, t1), dim=1) - def __init__(self, - in_channels: int, - init_feat: int, - conv_size: int, - pool_size: int, - out_channels: int, - lr: float): + def __init__( + self, + in_channels: int, + init_feat: int, + conv_size: int, + pool_size: int, + out_channels: int, + lr: float, + *args, + **kwargs, + ): """Define the network LitCNN architecture.""" - super().__init__() + super().__init__(*args, **kwargs) self.lr = lr self.net = nn.Sequential( @@ -177,5 +185,5 @@ def __init__(self, nn.MaxPool1d(pool_size), nn.Flatten(), nn.Linear(480, out_channels), - nn.Linear(out_channels, out_channels) + nn.Linear(out_channels, out_channels), ) diff --git a/weather-forecast/gravity-wave-drag/cnns/notebooks/get-started.ipynb b/weather-forecast/gravity-wave-drag/cnns/notebooks/get-started.ipynb deleted file mode 100644 index c077bb1f..00000000 --- a/weather-forecast/gravity-wave-drag/cnns/notebooks/get-started.ipynb +++ /dev/null @@ -1,67 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "5932c1b4-8875-4a8b-84e8-142adf128c85", - "metadata": {}, - "source": [ - "Licensed under the Apache License, Version 2.0 (the \"License\");\n", - "you may not use this file except in compliance with the License.\n", - "You may obtain a copy of the License at\n", - "\n", - " http://www.apache.org/licenses/LICENSE-2.0\n", - "\n", - "Unless required by applicable law or agreed to in writing, software\n", - "distributed under the License is distributed on an \"AS IS\" BASIS,\n", - "WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", - "See the License for the specific language governing permissions and\n", - "limitations under the License." - ] - }, - { - "cell_type": "markdown", - "id": "57cd1a30-78ef-4249-8d35-f97106e1a7be", - "metadata": {}, - "source": [ - "----------" - ] - }, - { - "cell_type": "markdown", - "id": "3ba62240-b4dc-4231-9ba4-c3d786126e1f", - "metadata": {}, - "source": [ - "WORK IN PROGRESS" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "49be4ff7-5d47-4ab8-b9f0-d8217992014a", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.6" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/weather-forecast/gravity-wave-drag/cnns/noxfile.py b/weather-forecast/gravity-wave-drag/cnns/noxfile.py index 813eaad1..2585a153 100644 --- a/weather-forecast/gravity-wave-drag/cnns/noxfile.py +++ b/weather-forecast/gravity-wave-drag/cnns/noxfile.py @@ -16,9 +16,9 @@ This file can be enriched by model project specific targets. """ +import inspect import os import sys -import inspect # Insert the tools/nox folder to the python path to fetch the nox_ref_file.py content current_dir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))) @@ -30,4 +30,3 @@ from nox_ref_file import * # Insert below the model project specific targets - diff --git a/weather-forecast/gravity-wave-drag/cnns/requirements.txt b/weather-forecast/gravity-wave-drag/cnns/requirements.txt index 15a3c5bf..c0ee87b4 100644 --- a/weather-forecast/gravity-wave-drag/cnns/requirements.txt +++ b/weather-forecast/gravity-wave-drag/cnns/requirements.txt @@ -1,61 +1,86 @@ absl-py==2.1.0 -aiohttp==3.9.5 -aiosignal==1.3.1 -argcomplete==3.3.0 -async-timeout==4.0.3 -attrs==23.2.0 -cachetools==5.3.3 -certifi==2024.2.2 -charset-normalizer==3.3.2 -colorlog==6.8.2 -distlib==0.3.8 +aiohappyeyeballs==2.4.4 +aiohttp==3.11.10 +aiosignal==1.3.2 +antlr4-python3-runtime==4.9.3 +argcomplete==3.5.2 +async-timeout==5.0.1 +attrs==24.3.0 +cachetools==5.5.0 +certifi==2024.12.14 +charset-normalizer==3.4.0 +colorlog==6.9.0 +distlib==0.3.9 docstring_parser==0.16 -filelock==3.14.0 -fire==0.6.0 -frozenlist==1.4.1 -fsspec==2024.5.0 +filelock==3.16.1 +fire==0.7.0 +frozenlist==1.5.0 +fsspec==2024.10.0 future==1.0.0 -google-auth==2.29.0 -google-auth-oauthlib==1.0.0 -grpcio==1.64.0 -h5py==3.4.0 -idna==3.7 -importlib_metadata==7.1.0 -jsonargparse==4.3.0 -Markdown==3.6 -MarkupSafe==2.1.5 -multidict==6.0.5 -nox==2024.4.15 -numpy==1.21.2 +google-auth==2.37.0 +google-auth-oauthlib==1.2.1 +grpcio==1.68.1 +h5py==3.12.1 +idna==3.10 +importlib_metadata==8.5.0 +importlib_resources==6.4.5 +Jinja2==3.1.5 +jsonargparse==4.35.0 +lightning==2.4.0 +lightning-utilities==0.11.9 +Markdown==3.7 +MarkupSafe==3.0.2 +mpmath==1.3.0 +multidict==6.1.0 +networkx==3.4.2 +nox==2024.10.9 +numpy==2.2.0 +nvidia-cublas-cu12==12.4.5.8 +nvidia-cuda-cupti-cu12==12.4.127 +nvidia-cuda-nvrtc-cu12==12.4.127 +nvidia-cuda-runtime-cu12==12.4.127 +nvidia-cudnn-cu12==9.1.0.70 +nvidia-cufft-cu12==11.2.1.3 +nvidia-curand-cu12==10.3.5.147 +nvidia-cusolver-cu12==11.6.1.9 +nvidia-cusparse-cu12==12.3.1.170 +nvidia-nccl-cu12==2.21.5 +nvidia-nvjitlink-cu12==12.4.127 +nvidia-nvtx-cu12==12.4.127 oauthlib==3.2.2 -packaging==24.0 -pip==24.0 -platformdirs==4.2.2 -protobuf==5.27.0 -pyasn1==0.6.0 -pyasn1_modules==0.4.0 -pyDeprecate==0.3.1 -pytorch-lightning==1.5.7 +omegaconf==2.3.0 +packaging==24.2 +pip==24.3.1 +platformdirs==4.3.6 +propcache==0.2.1 +protobuf==5.29.1 +pyasn1==0.6.1 +pyasn1_modules==0.4.1 +pyDeprecate==0.3.2 +pytorch-lightning==2.4.0 pytorch-ranger==0.1.1 -PyYAML==6.0 -randomname==0.1.5 +PyYAML==6.0.2 +randomname==0.2.1 requests==2.32.3 requests-oauthlib==2.0.0 rsa==4.9 -setuptools==45.2.0 -six==1.16.0 -tensorboard==2.14.0 +setuptools==75.1.0 +six==1.17.0 +sympy==1.13.1 +tensorboard==2.18.0 tensorboard-data-server==0.7.2 -termcolor==2.4.0 -tomli==2.0.1 -torch==1.13.1+cu117 -torch-optimizer==0.1.0 -torchmetrics==0.5.1 -tqdm==4.66.4 -typing_extensions==4.12.0 -urllib3==2.2.1 -virtualenv==20.26.2 -Werkzeug==3.0.3 -wheel==0.34.2 -yarl==1.9.4 -zipp==3.19.0 \ No newline at end of file +termcolor==2.5.0 +tomli==2.2.1 +torch==2.6.0+cu124 +torch-optimizer==0.3.0 +torchmetrics==1.6.0 +tqdm==4.67.1 +triton==3.2.0 +typeshed_client==2.7.0 +typing_extensions==4.12.2 +urllib3==2.2.3 +virtualenv==20.28.0 +Werkzeug==3.1.3 +wheel==0.44.0 +yarl==1.18.3 +zipp==3.21.0 diff --git a/weather-forecast/gravity-wave-drag/cnns/tests/test_config.py b/weather-forecast/gravity-wave-drag/cnns/tests/test_config.py deleted file mode 100644 index 5206b440..00000000 --- a/weather-forecast/gravity-wave-drag/cnns/tests/test_config.py +++ /dev/null @@ -1,46 +0,0 @@ -"""This module provides a unit tests suite for the config.py module.""" -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -import os -import subprocess -import unittest - -import config - - -class TestConfigPath(unittest.TestCase): - """Test the config.py folders creation.""" - - def test_experiment_path(self): - """Test if config creates the correct experiment paths.""" - self.assertTrue(os.path.exists(config.experiment_path)) - self.assertTrue(os.getenv("AI4SIM_EXPERIMENT_PATH"), config.experiment_path) - # Execute again config.py to ensure experiment_path is given by AISIM_EXPERIMENT_PATH - subprocess.run(['python3', os.path.join(os.path.dirname(os.getcwd()), "config.py")]) - self.assertTrue(config.experiment_path, os.getenv("AI4SIM_EXPERIMENT_PATH")) - - def test_logs_path(self): - """Test if config creates the correct log paths and file.""" - self.assertTrue(os.path.exists(config.logs_path)) - - def test_artifacts_path(self): - """Test if config creates the correct artifacts paths.""" - self.assertTrue(os.path.exists(config.artifacts_path)) - - def test_plots_path(self): - """Test if config creats the correct paths.""" - self.assertTrue(os.path.exists(config.plots_path)) - - -if __name__ == '__main__': - unittest.main() diff --git a/weather-forecast/gravity-wave-drag/cnns/tests/test_data.py b/weather-forecast/gravity-wave-drag/cnns/tests/test_data.py index d3b19f4e..2babf74d 100644 --- a/weather-forecast/gravity-wave-drag/cnns/tests/test_data.py +++ b/weather-forecast/gravity-wave-drag/cnns/tests/test_data.py @@ -1,4 +1,5 @@ """This module provides a unit tests suite for the data.py module.""" + # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at @@ -13,14 +14,14 @@ import os import shutil -from pathlib import Path import unittest -from unittest.mock import patch +from pathlib import Path + import numpy as np import torch - from test_utils import get_filenames, populate_test_data -from data import NOGWDDataset, NOGWDDataModule + +from data import NOGWDDataModule, NOGWDDataset CURRENT_DIR = Path(__file__).parent.absolute() TEST_DATA_PATH = os.path.join(CURRENT_DIR, "test_data", "data") @@ -44,22 +45,29 @@ def setUpClass(cls) -> None: def setUp(self) -> None: """Instantiate the NOGWDDataset class in train mode.""" - self.data_test = NOGWDDataset(root=TEST_DATA_PATH, mode='train', shard_len=1) + self.data_test = NOGWDDataset( + root=TEST_DATA_PATH, + mode="train", + shard_len=1, + splitting_file=REF_FILENAMES_FILE, + ) def test__compute_stats(self): """Test the instantiated NOGWDDataset class in train mode, has created the stat file.""" - self.assertTrue(os.path.isfile(os.path.join(TEST_DATA_PATH, 'stats.pt'))) + self.assertTrue(os.path.isfile(os.path.join(TEST_DATA_PATH, "stats.pt"))) def test_raw_filenames_property(self): """Test the 'raw_filenames' property is properly set with the train dataset files.""" - expected_file_list = ['2015-01-01.h5', '2016-01-01.h5', '2017-01-01.h5'] + expected_file_list = ["2015-01-01.h5", "2016-01-01.h5", "2017-01-01.h5"] self.assertListEqual(self.data_test.raw_filenames, expected_file_list) def test_download(self): """Test 'download' method is not yet implemented.""" - self.assertRaisesRegex(NotImplementedError, - "The 'download' method is not yet available", - self.data_test.download) + self.assertRaisesRegex( + NotImplementedError, + "The 'download' method is not yet available", + self.data_test.download, + ) def test_load(self): """Test the 'load' method returns tensors with good shapes.""" @@ -77,8 +85,12 @@ def test_load(self): def test_get(self): """Test the '__getitem__' method returns the proper (x, y) tuple of tensors.""" data_get = self.data_test[1] - np.testing.assert_array_equal(data_get[0].numpy(), self.data_test.x[1, :].numpy()) - np.testing.assert_array_equal(data_get[1].numpy(), self.data_test.y[1, :].numpy()) + np.testing.assert_array_equal( + data_get[0].numpy(), self.data_test.x[1, :].numpy() + ) + np.testing.assert_array_equal( + data_get[1].numpy(), self.data_test.y[1, :].numpy() + ) def test_len(self): """Test the '__len__' method returns the proper value. @@ -111,15 +123,20 @@ def setUpClass(cls) -> None: def setUp(self) -> None: """Instantiate the NOGWDDataset class in test mode.""" - self.data_test = NOGWDDataset(root=TEST_DATA_PATH, mode='test', shard_len=1) + self.data_test = NOGWDDataset( + root=TEST_DATA_PATH, + mode="test", + shard_len=1, + splitting_file=REF_FILENAMES_FILE, + ) def test__compute_stats(self): """Test the instantiated NOGWDDataset class in train mode, has NOT created the stat file.""" - self.assertFalse(os.path.isfile(os.path.join(TEST_DATA_PATH, 'stats.pt'))) + self.assertFalse(os.path.isfile(os.path.join(TEST_DATA_PATH, "stats.pt"))) def test_raw_filenames_property(self): """Test the 'raw_filenames' property is properly set with the train dataset files.""" - expected_file_list = ['2017-02-19.h5'] + expected_file_list = ["2017-02-19.h5"] self.assertListEqual(self.data_test.raw_filenames, expected_file_list) @classmethod @@ -145,15 +162,20 @@ def setUpClass(cls) -> None: def setUp(self) -> None: """Instantiate the NOGWDDataset class in val mode.""" - self.data_test = NOGWDDataset(root=TEST_DATA_PATH, mode='val', shard_len=1) + self.data_test = NOGWDDataset( + root=TEST_DATA_PATH, + mode="val", + shard_len=1, + splitting_file=REF_FILENAMES_FILE, + ) def test__compute_stats(self): """Test the instantiated NOGWDDataset class in train mode, has NOT created the stat file.""" - self.assertFalse(os.path.isfile(os.path.join(TEST_DATA_PATH, 'stats.pt'))) + self.assertFalse(os.path.isfile(os.path.join(TEST_DATA_PATH, "stats.pt"))) def test_raw_filenames_property(self): """Test the 'raw_filenames' property is properly set with the train dataset files.""" - expected_file_list = ['2016-02-25.h5'] + expected_file_list = ["2016-02-25.h5"] self.assertListEqual(self.data_test.raw_filenames, expected_file_list) @classmethod @@ -180,9 +202,13 @@ def setUpClass(cls) -> None: def setUp(self) -> None: """Instantiate the NOGWDDataset class in val mode.""" - self.data_module = NOGWDDataModule(batch_size=1, num_workers=0) + self.data_module = NOGWDDataModule( + batch_size=1, + num_workers=0, + data_path=TEST_DATA_PATH, + splitting_file=REF_FILENAMES_FILE, + ) - @patch("config.data_path", TEST_DATA_PATH) def test_setup_fit(self): """Test the 'setup' method set properly the train and val attributes in 'fit' mode.""" self.data_module.setup("fit") @@ -190,7 +216,6 @@ def test_setup_fit(self): self.assertIsInstance(self.data_module.val, NOGWDDataset) self.assertIsNone(self.data_module.test) - @patch("config.data_path", TEST_DATA_PATH) def test_setup_test(self): """Test the 'setup' method set properly the test attribute in 'test' mode.""" self.data_module.setup("test") @@ -198,21 +223,18 @@ def test_setup_test(self): self.assertIsNone(self.data_module.val) self.assertIsInstance(self.data_module.test, NOGWDDataset) - @patch("config.data_path", TEST_DATA_PATH) def test_train_dataloader(self): """Test the 'train_dataloader' method properly instantiate a DataLoader.""" self.data_module.setup("fit") dataloader = self.data_module.train_dataloader() self.assertIsInstance(dataloader, torch.utils.data.DataLoader) - @patch("config.data_path", TEST_DATA_PATH) def test_val_dataloader(self): """Test the 'val_dataloader' method properly instantiate a DataLoader.""" self.data_module.setup("fit") dataloader = self.data_module.val_dataloader() self.assertIsInstance(dataloader, torch.utils.data.DataLoader) - @patch("config.data_path", TEST_DATA_PATH) def test_test_dataloader(self): """Test the 'test_dataloader' method properly instantiate a DataLoader.""" self.data_module.setup("fit") @@ -226,5 +248,5 @@ def tearDownClass(cls) -> None: shutil.rmtree(TEST_DATA_PATH, ignore_errors=True) -if __name__ == '__main__': +if __name__ == "__main__": unittest.main() diff --git a/weather-forecast/gravity-wave-drag/cnns/tests/test_models.py b/weather-forecast/gravity-wave-drag/cnns/tests/test_models.py index 78bc8133..84a317ba 100644 --- a/weather-forecast/gravity-wave-drag/cnns/tests/test_models.py +++ b/weather-forecast/gravity-wave-drag/cnns/tests/test_models.py @@ -1,4 +1,5 @@ """This module provides a unit tests suite for the models.py module.""" + # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at @@ -13,14 +14,15 @@ import os import shutil -from pathlib import Path import unittest +from pathlib import Path + import torch import torch_optimizer as optim - from test_utils import get_filenames, populate_test_data + from data import NOGWDDataset -from models import LitMLP, LitCNN +from models import LitCNN, LitMLP CURRENT_DIR = Path(__file__).parent.absolute() TEST_DATA_PATH = os.path.join(CURRENT_DIR, "test_data", "data") @@ -43,13 +45,21 @@ def setUpClass(cls) -> None: def setUp(self) -> None: """Instantiate the LitMLP class and produce input dataset.""" # Generate data fir test purpose - data_test = NOGWDDataset(root=TEST_DATA_PATH, mode='train', shard_len=1) + data_test = NOGWDDataset( + root=TEST_DATA_PATH, + mode="train", + shard_len=1, + splitting_file=REF_FILENAMES_FILE, + ) self.data = data_test.load() # Instantiate a LitMLP - self.model_test = LitMLP(in_channels=191, - hidden_channels=10, - out_channels=126, - lr=0.001) + self.model_test = LitMLP( + in_channels=191, + hidden_channels=10, + out_channels=126, + lr=0.001, + data_path=TEST_DATA_PATH, + ) def test_forward(self): """Test the 'forward' method returns a properly formatted tensor.""" @@ -100,15 +110,23 @@ def setUpClass(cls) -> None: def setUp(self) -> None: """Instantiate the LitMLP class and produce input dataset.""" # Generate data fir test purpose - data_test = NOGWDDataset(root=TEST_DATA_PATH, mode='train', shard_len=1) + data_test = NOGWDDataset( + root=TEST_DATA_PATH, + mode="train", + shard_len=1, + splitting_file=REF_FILENAMES_FILE, + ) self.data = data_test.load() # Instantiate a LitCNN - self.model_test = LitCNN(in_channels=5, - init_feat=16, - out_channels=126, - conv_size=1, - pool_size=2, - lr=0.001) + self.model_test = LitCNN( + in_channels=5, + init_feat=16, + out_channels=126, + conv_size=1, + pool_size=2, + lr=0.001, + data_path=TEST_DATA_PATH, + ) def test_forward(self): """Test the 'forward' method returns a properly formatted tensor.""" @@ -141,5 +159,5 @@ def tearDownClass(cls) -> None: shutil.rmtree(TEST_DATA_PATH, ignore_errors=True) -if __name__ == '__main__': +if __name__ == "__main__": unittest.main() diff --git a/weather-forecast/gravity-wave-drag/cnns/tests/test_trainer.py b/weather-forecast/gravity-wave-drag/cnns/tests/test_trainer.py deleted file mode 100644 index c1b88767..00000000 --- a/weather-forecast/gravity-wave-drag/cnns/tests/test_trainer.py +++ /dev/null @@ -1,76 +0,0 @@ -"""This module provides a unit tests suite for the trainer.py module.""" -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -import os -import unittest -from unittest import skipIf -from unittest.mock import patch -import torch - -import config -from trainer import Trainer - - -@skipIf(not torch.cuda.is_available(), "Cuda not available.") -class TestTrainerGpu(unittest.TestCase): - """Test the Trainer class with GPUs.""" - - def setUp(self) -> None: - """Prepare config file parameters-like settings.""" - args_gpu = {"max_epochs": 1, - "accelerator": "gpu", - "devices": [0]} - self.test_trainer_gpu = Trainer(**args_gpu) - - def test_trainer_gpu_init(self): - """Tests the 'devices' mother attribute is properly set if gpu mode is activated.""" - self.assertEqual(self.test_trainer_gpu.devices, [0]) - - @patch('pytorch_lightning.Trainer.test') - def test_trainer_cpu_test(self, mock_test): - """Tests the 'test' method properly save the result file and model, running on GPUs.""" - # patch the super().test() returned value - mock_test.return_value = [{'a': 1, 'b': 2}] - self.test_trainer_gpu.test() - self.assertTrue(os.path.exists(os.path.join(config.artifacts_path, 'model.pth'))) - self.assertTrue(os.path.exists(os.path.join(config.artifacts_path, 'results.json'))) - - -class TestTrainerCPU(unittest.TestCase): - """Test the Trainer class with CPUs.""" - - def setUp(self) -> None: - """Prepare config file parameters-like settings.""" - args_cpu = {"max_epochs": 1, - "accelerator": "cpu", - "devices": [0]} - self.test_trainer_cpu = Trainer(**args_cpu) - - def test_trainer_cpu_init(self): - """Tests the 'devices' mother attribute is set to the default value (1) if the cpu mode is - activated. - """ - self.assertEqual(self.test_trainer_cpu.devices, 1) - - @patch('pytorch_lightning.Trainer.test') - def test_trainer_cpu_test(self, mock_test): - """Tests the 'test' method properly save the result file and model, running on CPUs.""" - # patch the super().test() returned value - mock_test.return_value = [{'a': 1, 'b': 2}] - self.test_trainer_cpu.test() - self.assertTrue(os.path.exists(os.path.join(config.artifacts_path, 'model.pth'))) - self.assertTrue(os.path.exists(os.path.join(config.artifacts_path, 'results.json'))) - - -if __name__ == '__main__': - unittest.main() diff --git a/weather-forecast/gravity-wave-drag/cnns/tests/test_utils.py b/weather-forecast/gravity-wave-drag/cnns/tests/test_utils.py index 297a9f28..bfcf9da8 100644 --- a/weather-forecast/gravity-wave-drag/cnns/tests/test_utils.py +++ b/weather-forecast/gravity-wave-drag/cnns/tests/test_utils.py @@ -1,4 +1,5 @@ """This module provides utils functions to be used in test modules.""" + # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at @@ -13,8 +14,9 @@ import os from pathlib import Path -import numpy as np + import h5py +import numpy as np import yaml @@ -27,7 +29,7 @@ def get_filenames(filenames_file): Returns: filenames (list): the filenames extracted from the input file. """ - with open(filenames_file, 'r') as file: + with open(filenames_file, "r") as file: yaml_content = yaml.safe_load(file) filenames = [] for files in yaml_content.values(): @@ -46,6 +48,6 @@ def populate_test_data(root_data_path, filenames) -> None: Path(data_path).mkdir(parents=True, exist_ok=True) for file_h5 in filenames: - with h5py.File(os.path.join(data_path, file_h5), 'w') as file: - file['/x'] = np.random.rand(191, 36, 10) - file['/y'] = np.random.rand(126, 36, 10) + with h5py.File(os.path.join(data_path, file_h5), "w") as file: + file["/x"] = np.random.rand(191, 36, 10) + file["/y"] = np.random.rand(126, 36, 10) diff --git a/weather-forecast/gravity-wave-drag/cnns/trainer.py b/weather-forecast/gravity-wave-drag/cnns/trainer.py index 620ca17f..12f79a21 100644 --- a/weather-forecast/gravity-wave-drag/cnns/trainer.py +++ b/weather-forecast/gravity-wave-drag/cnns/trainer.py @@ -1,4 +1,5 @@ """This module proposes Pytorch style a Trainer class for the gwd use-case.""" + # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at @@ -11,71 +12,22 @@ # See the License for the specific language governing permissions and # limitations under the License. -import json -import os -import pytorch_lightning as pl -from pytorch_lightning.callbacks.base import Callback -from pytorch_lightning.utilities.cli import LightningCLI -import torch -from typing import List, Union - -import config -import data # noqa: F401 'data' imported but unused - - -class Trainer(pl.Trainer): - """Modified PyTorch Lightning Trainer. It automatically tests, logs, and writes artifacts by the - end of training. - """ - - def __init__(self, - accelerator: Union[str, pl.accelerators.Accelerator, None], - devices: Union[List[int], str, int, None], - max_epochs: int, - # TODO: delete. - # For some reason, those two are mandatory in current version of Lightning. - fast_dev_run: Union[int, bool] = False, - callbacks: Union[List[Callback], Callback, None] = None) -> None: - """Init the Trainer. - - Args: - accelerator (Union[str, pl.accelerators.Accelerator, None]): Type of accelerator to use - for training. - devices: (Union[List[int], str, int, None]): Devices explicit names to use for training. - max_epochs (int): Maximum number of epochs if no early stopping logic is implemented. - """ - if accelerator == 'cpu': - devices = None - - logger = pl.loggers.TensorBoardLogger(config.logs_path, name=None) - super().__init__( - default_root_dir=config.logs_path, - logger=logger, - accelerator=accelerator, - devices=devices, - max_epochs=max_epochs, - # TODO: for some reason, a forward pass happens in the model before datamodule creation. - num_sanity_val_steps=0) - - def test(self, **kwargs) -> None: - """ - Uses superclass test results, but additionally, saves raw results as a JSON file, and stores - the model weights for future use in inference mode. - """ - results = super().test(**kwargs)[0] +from lightning.pytorch.cli import LightningCLI - with open(os.path.join(config.artifacts_path, "results.json"), "w") as file: - json.dump(results, file) - torch.save(self.model, os.path.join(config.artifacts_path, 'model.pth')) +class MyLightningCLI(LightningCLI): + def add_arguments_to_parser(self, parser): + parser.link_arguments( + "data.data_path", "model.init_args.data_path", apply_on="instantiate" + ) def main(): """Instantiate the CLI and launch the trainer.""" - cli = LightningCLI(trainer_class=Trainer) + cli = MyLightningCLI(run=False, parser_kwargs={"parser_mode": "omegaconf"}) cli.trainer.fit(model=cli.model, datamodule=cli.datamodule) cli.trainer.test(model=cli.model, datamodule=cli.datamodule) -if __name__ == '__main__': +if __name__ == "__main__": main()