Add files using upload-large-folder tool

testbed/Project-MONAI__MONAI/.gitattributes

@@ -0,0 +1 @@
+monai/_version.py export-subst

testbed/Project-MONAI__MONAI/.gitignore

@@ -0,0 +1,126 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# pytype cache
+.pytype/
+
+# mypy
+.mypy_cache/
+examples/scd_lvsegs.npz
+temp/
+.idea/
+
+*~
+
+# Remove .pyre temporary config files
+.pyre
+.pyre_configuration
+
+# temporary editor files that should not be in git
+*.orig
+*.bak
+*.swp
+.DS_Store
+
+# temporary testing data MedNIST
+tests/testing_data/MedNIST*
+tests/testing_data/*Hippocampus*

testbed/Project-MONAI__MONAI/.readthedocs.yml

@@ -0,0 +1,28 @@
+# .readthedocs.yml
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
+version: 2
+
+# Build documentation in the docs/ directory with Sphinx
+sphinx:
+  configuration: docs/source/conf.py
+
+# Build documentation with MkDocs
+#mkdocs:
+#  configuration: mkdocs.yml
+
+# Optionally build your docs in additional formats such as PDF and ePub
+# formats: all
+
+# Optionally set the version of Python and requirements required to build your docs
+python:
+  version: 3.7
+  install:
+    - requirements: docs/requirements.txt
+#  system_packages: true
+
+
+build:
+  image: stable

testbed/Project-MONAI__MONAI/CHANGELOG.md

@@ -0,0 +1,61 @@
+# Changelog
+All notable changes to MONAI are documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+## [0.2.0] - 2020-07-02
+### Added
+* Overview document for [feature highlights in v0.2.0](https://github.com/Project-MONAI/MONAI/blob/master/docs/source/highlights.md)
+* Type hints and static type analysis support
+* `MONAI/research` folder
+* `monai.engine.workflow` APIs for supervised training
+* `monai.inferers` APIs for validation and inference
+* 7 new tutorials and examples
+* 3 new loss functions
+* 4 new event handlers
+* 8 new layers, blocks, and networks
+* 12 new transforms, including post-processing transforms
+* `monai.apps.datasets` APIs, including `MedNISTDataset` and `DecathlonDataset`
+* Persistent caching, `ZipDataset`, and `ArrayDataset` in `monai.data`
+* Cross-platform CI tests supporting multiple Python versions
+* Optional import mechanism
+* Experimental features for third-party transforms integration
+### Changed
+> For more details please visit [the project wiki](https://github.com/Project-MONAI/MONAI/wiki/Notable-changes-between-0.1.0-and-0.2.0)
+* Core modules now require numpy >= 1.17
+* Categorized `monai.transforms` modules into crop and pad, intensity, IO, post-processing, spatial, and utility.
+* Most transforms are now implemented with PyTorch native APIs
+* Code style enforcement and automated formatting workflows now use autopep8 and black
+* Base Docker image upgraded to `nvcr.io/nvidia/pytorch:20.03-py3` from `nvcr.io/nvidia/pytorch:19.10-py3`
+* Enhanced local testing tools
+* Documentation website domain changed to https://docs.monai.io
+### Removed
+* Support of Python < 3.6
+* Automatic installation of optional dependencies including pytorch-ignite, nibabel, tensorboard, pillow, scipy, scikit-image
+### Fixed
+* Various issues in type and argument names consistency
+* Various issues in docstring and documentation site
+* Various issues in unit and integration tests
+* Various issues in examples and notebooks
+
+## [0.1.0] - 2020-04-17
+### Added
+* Public alpha source code release under the Apache 2.0 license ([highlights](https://github.com/Project-MONAI/MONAI/blob/0.1.0/docs/source/highlights.md))
+* Various tutorials and examples
+  - Medical image classification and segmentation workflows
+  - Spacing/orientation-aware preprocessing with CPU/GPU and caching
+  - Flexible workflows with PyTorch Ignite and Lightning
+* Various GitHub Actions
+  - CI/CD pipelines via self-hosted runners
+  - Documentation publishing via readthedocs.org
+  - PyPI package publishing
+* Contributing guidelines
+* A project logo and badges
+
+[highlights]: https://github.com/Project-MONAI/MONAI/blob/master/docs/source/highlights.md
+
+[Unreleased]: https://github.com/Project-MONAI/MONAI/compare/0.2.0...HEAD
+[0.2.0]: https://github.com/Project-MONAI/MONAI/compare/0.1.0...0.2.0
+[0.1.0]: https://github.com/Project-MONAI/MONAI/commits/0.1.0

testbed/Project-MONAI__MONAI/CONTRIBUTING.md

@@ -0,0 +1,212 @@
+- [Introduction](#introduction)
+- [The contribution process](#the-contribution-process)
+  * [Submitting pull requests](#submitting-pull-requests)
+  * [Ensuring code quality](#ensuring-code-quality)
+    1. [Coding style](#coding-style)
+    1. [Code analysis and unit testing](#code-analysis-and-unit-testing)
+    1. [Building the documentation](#building-the-documentation)
+    1. [Automatic code formatting](#automatic-code-formatting)
+    1. [Utility functions](#utility-functions)
+- [The code reviewing process (for the maintainers)](#the-code-reviewing-process)
+  * [Reviewing pull requests](#reviewing-pull-requests)
+- [Admin tasks (for the maintainers)](#admin-tasks)
+  * [Releasing a new version](#release-a-new-version)
+
+## Introduction
+
+
+This documentation is intended for individuals and institutions interested in contributing to MONAI. MONAI is an open-source project and, as such, its success relies on its community of contributors willing to keep improving it. Your contribution will be a valued addition to the code base; we simply ask that you read this page and understand our contribution process, whether you are a seasoned open-source contributor or whether you are a first-time contributor.
+
+### Communicate with us
+
+We are happy to talk with you about your needs for MONAI and your ideas for contributing to the project. One way to do this is to create an issue discussing your thoughts. It might be that a very similar feature is under development or already exists, so an issue is a great starting point.
+
+### Does it belong in PyTorch instead of MONAI?
+
+MONAI is based on the PyTorch and Numpy libraries. These libraries implement what we consider to be best practice for general scientific computing and deep learning functionality. MONAI builds on these with a strong focus on medical applications. As such, it is a good idea to consider whether your functionality is medical-application specific or not. General deep learning functionality may be better off in PyTorch; you can find their contribution guidelines [here](https://pytorch.org/docs/stable/community/contribution_guide.html).
+
+## The contribution process
+
+_Pull request early_
+
+We encourage you to create pull requests early. It helps us track the contributions under development, whether they are ready to be merged or not. Change your pull request's title to begin with `[WIP]` until it is ready for formal review.
+
+
+### Submitting pull requests
+All code changes to the master branch must be done via [pull requests](https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/proposing-changes-to-your-work-with-pull-requests).
+1. Create a new ticket or take a known ticket from [the issue list][monai issue list].
+1. Check if there's already a branch dedicated to the task.
+1. If the task has not been taken, [create a new branch in your fork](https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/creating-a-pull-request-from-a-fork)
+of the codebase named `[ticket_id]-[task_name]`.
+For example, branch name `19-ci-pipeline-setup` corresponds to [issue #19](https://github.com/Project-MONAI/MONAI/issues/19).
+Ideally, the new branch should be based on the latest `master` branch.
+1. Make changes to the branch ([use detailed commit messages if possible](https://chris.beams.io/posts/git-commit/)).
+1. Make sure that new tests cover the changes and the changed codebase [passes all tests locally](#ensuring-code-quality).
+1. [Create a new pull request](https://help.github.com/en/desktop/contributing-to-projects/creating-a-pull-request) from the task branch to the master branch, with detailed descriptions of the purpose of this pull request.
+1. Check [the CI/CD status of the pull request][github ci], make sure all CI/CD tests passed.
+1. Wait for reviews; if there are reviews, make point-to-point responses, make further code changes if needed.
+1. If there're conflicts between the pull request branch and the master branch, pull the changes from the master and resolve the conflicts locally.
+1. Reviewer and contributor may have discussions back and forth until all comments addressed.
+1. Wait for the pull request to be merged.
+
+### Ensuring code quality
+To ensure the code quality, MONAI relies on several linting tools ([flake8 and its plugins](https://gitlab.com/pycqa/flake8), [black](https://github.com/psf/black), [isort](https://github.com/timothycrosley/isort)),
+static type analysis tools ([mypy](https://github.com/python/mypy), [pytype](https://github.com/google/pytype)), as well as a set of unit/integration tests.
+
+This section highlights all the necessary steps required before sending a pull request.
+To collaborate efficiently, please read through this section and follow them.
+
+* [Coding style](#coding-style)
+* [Code analysis and unit testing](#code-analysis-and-unit-testing)
+* [Building documentation](#building-the-documentation)
+
+#### Coding style
+Coding style is checked and enforced by flake8, black, and isort, using [a flake8 configuration](./setup.cfg) similar to [PyTorch's](https://github.com/pytorch/pytorch/blob/master/.flake8).
+The next section provides [a few commands to run the relevant tools](#code-analysis-and-unit-testing).
+
+For string definition, [f-string](https://www.python.org/dev/peps/pep-0498/) is recommended to use over `%-print` and `format-print` from python 3.6. So please try to use `f-string` if you need to define any string object.
+
+License information: all source code files should start with this paragraph:
+```
+# Copyright 2020 MONAI Consortium
+# 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.
+
+```
+
+#### Code analysis and unit testing
+MONAI tests are located under `tests/`.
+
+- The unit test's file name follows `test_[module_name].py`.
+- The integration test's file name follows `test_integration_[workflow_name].py`.
+
+A bash script (`runtests.sh`) is provided to run all tests locally
+Please run ``./runtests.sh -h`` to see all options.
+
+To run a particular test, for example `tests/test_dice_loss.py`:
+```
+python -m tests.test_dice_loss
+```
+
+Before submitting a pull request, we recommend that all linting and unit tests
+should pass, by running the following command locally:
+
+```bash
+./runtests.sh --codeformat --coverage
+```
+
+It is recommended that the new test `test_[module_name].py` is constructed by using only
+python 3.6+ build-in functions, `torch`, `numpy`, and `parameterized` packages.
+If it requires any other external packages, please make sure:
+- the packages are listed in [`requirements-dev.txt`](requirements-dev.txt)
+- the new test `test_[module_name].py` is added to the `exclude_cases` in [`./tests/min_tests.py`](./tests/min_tests.py) so that
+the minimal CI runner will not execute it.
+
+_If it's not tested, it's broken_
+
+All new functionality should be accompanied by an appropriate set of tests.
+MONAI functionality has plenty of unit tests from which you can draw inspiration,
+and you can reach out to us if you are unsure of how to proceed with testing.
+
+MONAI's code coverage report is available at [CodeCov](https://codecov.io/gh/Project-MONAI/MONAI).
+
+#### Building the documentation
+MONAI's documentation is located at `docs/`.
+
+```bash
+# install the doc-related dependencies
+pip install --upgrade pip
+pip install -r docs/requirements.txt
+
+# build the docs
+cd docs/
+make html
+```
+The above commands build html documentation, they are used to automatically generate [https://docs.monai.io](https://docs.monai.io).
+
+Before submitting a pull request, it is recommended to:
+- edit the relevant `.rst` files in [`docs/source`](./docs/source) accordingly.
+- build html documentation locally
+- check the auto-generated documentation (by browsing `./docs/build/html/index.html` with a web browser)
+- type `make clean` in `docs/` folder to remove the current build files.
+
+Please type `make help` for all supported format options.
+
+#### Automatic code formatting
+MONAI provides support of automatic Python code formatting via [a customised GitHub action](https://github.com/Project-MONAI/monai-code-formatter).
+This makes the project's Python coding style consistent and reduces maintenance burdens.
+Commenting a pull request with `/black` triggers the formatting action based on [`psf/Black`](https://github.com/psf/black) (this is implemented with [`slash command dispatch`](https://github.com/marketplace/actions/slash-command-dispatch)).
+
+Steps for the formatting process:
+- After submitting a pull request or push to an existing pull request,
+make a comment to the pull request to trigger the formatting action.
+The first line of the comment must be `/black` so that it will be interpreted by [the comment parser](https://github.com/marketplace/actions/slash-command-dispatch#how-are-comments-parsed-for-slash-commands).
+- [Auto] The GitHub action tries to format all Python files (using [`psf/Black`](https://github.com/psf/black)) in the branch and makes a commit under the name "MONAI bot" if there's code change. The actual formatting action is deployed at [project-monai/monai-code-formatter](https://github.com/Project-MONAI/monai-code-formatter).
+- [Auto] After the formatting commit, the GitHub action adds an emoji to the comment that triggered the process.
+- Repeat the above steps if necessary.
+
+#### Utility functions
+MONAI provides a set of generic utility functions and frequently used routines.
+These are located in [``monai/utils``](./monai/utils/) and in the module folders such as [``networks/utils.py``](./monai/networks/).
+Users are encouraged to use these common routines to improve code readability and reduce the code maintenance burdens.
+
+Notably,
+- ``monai.module.export`` decorator can make the module name shorter when importing,
+for example, ``import monai.transforms.Spacing`` is the equivalent of ``monai.transforms.spatial.array.Spacing`` if
+``class Spacing`` defined in file `monai/transforms/spatial/array.py` is decorated with ``@export("monai.transforms")``.
+
+
+## The code reviewing process
+
+
+### Reviewing pull requests
+All code review comments should be specific, constructive, and actionable.
+1. Check [the CI/CD status of the pull request][github ci], make sure all CI/CD tests passed before reviewing (contact the branch owner if needed).
+1. Read carefully the descriptions of the pull request and the files changed, write comments if needed.
+1. Make in-line comments to specific code segments, [request for changes](https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/about-pull-request-reviews) if needed.
+1. Review any further code changes until all comments addressed by the contributors.
+1. Merge the pull request to the master branch.
+1. Close the corresponding task ticket on [the issue list][monai issue list].
+
+[github ci]: https://github.com/Project-MONAI/MONAI/actions
+[monai issue list]: https://github.com/Project-MONAI/MONAI/issues
+
+
+## Admin tasks
+
+### Release a new version
+- Prepare [a release note](https://github.com/Project-MONAI/MONAI/releases).
+- Checkout a new branch `releases/[version number]` locally from the master branch and push to the codebase.
+- Create a tag, for example `git tag -a 0.1a -m "version 0.1a"`.
+- Push the tag to the codebase, for example `git push origin 0.1a`.
+  This step will trigger package building and testing.
+  The resultant packages are automatically uploaded to
+  [TestPyPI](https://test.pypi.org/project/monai/).  The packages are also available for downloading as
+  repository's artifacts (e.g. the file at https://github.com/Project-MONAI/MONAI/actions/runs/66570977).
+- Check the release test at [TestPyPI](https://test.pypi.org/project/monai/), download the artifacts when the CI finishes.
+- Upload the packages to [PyPI](https://pypi.org/project/monai/).
+  This could be done manually by ``twine upload dist/*``, given the artifacts are unzipped to the folder ``dist/``.
+- Publish the release note.
+
+Note that the release should be tagged with a [PEP440](https://www.python.org/dev/peps/pep-0440/) compliant
+[semantic versioning](https://semver.org/spec/v2.0.0.html) number.
+
+If any error occurs during the release process, first checkout a new branch from the master, make PRs to the master
+to fix the bugs via the regular contribution procedure.
+Then rollback the release branch and tag:
+ - remove any artifacts (website UI) and tag (`git tag -d` and `git push origin -d`).
+ - reset the `releases/[version number]` branch to the latest master:
+ ```bash
+git checkout master
+git pull origin master
+git checkout releases/[version number]
+git reset --hard master
+```
+Finally, repeat the tagging and TestPyPI uploading process.

testbed/Project-MONAI__MONAI/Dockerfile

@@ -0,0 +1,30 @@
+# Copyright 2020 MONAI Consortium
+# 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.
+
+ARG PYTORCH_IMAGE=nvcr.io/nvidia/pytorch:20.08-py3
+
+FROM ${PYTORCH_IMAGE} as base
+
+WORKDIR /opt/monai
+COPY . .
+
+ENV PYTHONPATH=$PYTHONPATH:/opt/monai
+ENV PATH=/opt/tools:$PATH
+
+RUN python -m pip install --no-cache-dir -U pip wheel \
+  && python -m pip install --no-cache-dir -r requirements-dev.txt
+
+# NGC Client
+WORKDIR /opt/tools
+RUN wget -q https://ngc.nvidia.com/downloads/ngccli_cat_linux.zip && \
+    unzip ngccli_cat_linux.zip && chmod u+x ngc && \
+    rm -rf ngccli_cat_linux.zip ngc.md5
+WORKDIR /opt/monai

testbed/Project-MONAI__MONAI/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

testbed/Project-MONAI__MONAI/MANIFEST.in

@@ -0,0 +1,2 @@
+include versioneer.py
+include monai/_version.py

testbed/Project-MONAI__MONAI/README.md

@@ -0,0 +1,68 @@
+<p align="center">
+  <img src="https://github.com/Project-MONAI/MONAI/raw/master/docs/images/MONAI-logo-color.png" width="50%" alt='project-monai'>
+</p>
+
+**M**edical **O**pen **N**etwork for **AI**
+
+[![License](https://img.shields.io/badge/license-Apache%202.0-green.svg)](https://opensource.org/licenses/Apache-2.0)
+[![CI Build](https://github.com/Project-MONAI/MONAI/workflows/build/badge.svg?branch=master)](https://github.com/Project-MONAI/MONAI/commits/master)
+[![Documentation Status](https://readthedocs.org/projects/monai/badge/?version=latest)](https://docs.monai.io/en/latest/?badge=latest)
+[![codecov](https://codecov.io/gh/Project-MONAI/MONAI/branch/master/graph/badge.svg)](https://codecov.io/gh/Project-MONAI/MONAI)
+[![PyPI version](https://badge.fury.io/py/monai.svg)](https://badge.fury.io/py/monai)
+
+MONAI is a [PyTorch](https://pytorch.org/)-based, [open-source](https://github.com/Project-MONAI/MONAI/blob/master/LICENSE) framework for deep learning in healthcare imaging, part of [PyTorch Ecosystem](https://pytorch.org/ecosystem/).
+Its ambitions are:
+- developing a community of academic, industrial and clinical researchers collaborating on a common foundation;
+- creating state-of-the-art, end-to-end training workflows for healthcare imaging;
+- providing researchers with the optimized and standardized way to create and evaluate deep learning models.
+
+
+## Features
+> _The codebase is currently under active development._
+> _Please see [the technical highlights](https://docs.monai.io/en/latest/highlights.html) of the current milestone release._
+
+- flexible pre-processing for multi-dimensional medical imaging data;
+- compositional & portable APIs for ease of integration in existing workflows;
+- domain-specific implementations for networks, losses, evaluation metrics and more;
+- customizable design for varying user expertise;
+- multi-GPU data parallelism support.
+
+
+## Installation
+To install [the current release](https://pypi.org/project/monai/):
+```bash
+pip install monai
+```
+
+To install from the source code repository:
+```bash
+pip install git+https://github.com/Project-MONAI/MONAI#egg=MONAI
+```
+
+Alternatively, pre-built Docker image is available via [DockerHub](https://hub.docker.com/r/projectmonai/monai):
+  ```bash
+  # with docker v19.03+
+  docker run --gpus all --rm -ti --ipc=host projectmonai/monai:latest
+  ```
+
+For more details, please refer to [the installation guide](https://docs.monai.io/en/latest/installation.html).
+
+## Getting Started
+
+[MedNIST demo](https://colab.research.google.com/drive/1wy8XUSnNWlhDNazFdvGBHLfdkGvOHBKe) and [MONAI for PyTorch Users](https://colab.research.google.com/drive/1boqy7ENpKrqaJoxFlbHIBnIODAs1Ih1T) are available on Colab.
+
+Tutorials & examples are located at [monai/examples](https://github.com/Project-MONAI/MONAI/tree/master/examples).
+
+Technical documentation is available at [docs.monai.io](https://docs.monai.io).
+
+## Contributing
+For guidance on making a contribution to MONAI, see the [contributing guidelines](https://github.com/Project-MONAI/MONAI/blob/master/CONTRIBUTING.md).
+
+## Links
+- Website: https://monai.io/
+- API documentation: https://docs.monai.io
+- Code: https://github.com/Project-MONAI/MONAI
+- Project tracker: https://github.com/Project-MONAI/MONAI/projects
+- Issue tracker: https://github.com/Project-MONAI/MONAI/issues
+- Wiki: https://github.com/Project-MONAI/MONAI/wiki
+- Test status: https://github.com/Project-MONAI/MONAI/actions

testbed/Project-MONAI__MONAI/examples/README.md

@@ -0,0 +1,36 @@
+### 1. Requirements
+Some of the examples may require optional dependencies. In case of any optional import errors,
+please install the relevant packages according to the error message.
+Or install all optional requirements by:
+```
+pip install -r https://raw.githubusercontent.com/Project-MONAI/MONAI/master/requirements-dev.txt
+```
+
+### 2. List of examples
+#### [classification_3d](./classification_3d)
+Training and evaluation examples of 3D classification based on DenseNet3D and [IXI dataset](https://brain-development.org/ixi-dataset).
+The examples are standard PyTorch programs and have both dictionary-based and array-based transformation versions.
+#### [classification_3d_ignite](./classification_3d_ignite)
+Training and evaluation examples of 3D classification based on DenseNet3D and [IXI dataset](https://brain-development.org/ixi-dataset).
+The examples are PyTorch Ignite programs and have both dictionary-based and array-based transformation versions.
+#### [distributed_training](./distributed_training)
+The examples show how to execute distributed training and evaluation based on 3 different frameworks:
+- PyTorch native `DistributedDataParallel` module with `torch.distributed.launch`.
+- Horovod APIs with `horovodrun`.
+- PyTorch ignite and MONAI workflows.
+
+They can run on several distributed nodes with multiple GPU devices on every node.
+#### [segmentation_3d](./segmentation_3d)
+Training and evaluation examples of 3D segmentation based on UNet3D and synthetic dataset.
+The examples are standard PyTorch programs and have both dictionary-based and array-based versions.
+#### [segmentation_3d_ignite](./segmentation_3d_ignite)
+Training and evaluation examples of 3D segmentation based on UNet3D and synthetic dataset.
+The examples are PyTorch Ignite programs and have both dictionary-base and array-based transformations.
+#### [workflows](./workflows)
+Training and evaluation examples of 3D segmentation based on UNet3D and synthetic dataset.
+The examples are built with MONAI workflows, mainly contain: trainer/evaluator, handlers, post_transforms, etc.
+#### [synthesis](./synthesis)
+A GAN training and evaluation example for a medical image generative adversarial network. Easy run training script uses `GanTrainer` to train a 2D CT scan reconstruction network. Evaluation script generates random samples from a trained network.
+
+### 3. List of tutorials
+Please check out https://github.com/Project-MONAI/Tutorials

testbed/Project-MONAI__MONAI/examples/classification_3d/densenet_evaluation_array.py

@@ -0,0 +1,77 @@
+# Copyright 2020 MONAI Consortium
+# 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 logging
+import os
+import sys
+
+import numpy as np
+import torch
+from torch.utils.data import DataLoader
+
+import monai
+from monai.data import CSVSaver, NiftiDataset
+from monai.transforms import AddChannel, Compose, Resize, ScaleIntensity, ToTensor
+
+
+def main():
+    monai.config.print_config()
+    logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+
+    # IXI dataset as a demo, downloadable from https://brain-development.org/ixi-dataset/
+    images = [
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI607-Guys-1097-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI175-HH-1570-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI385-HH-2078-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI344-Guys-0905-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI409-Guys-0960-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI584-Guys-1129-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI253-HH-1694-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI092-HH-1436-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI574-IOP-1156-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI585-Guys-1130-T1.nii.gz"]),
+    ]
+
+    # 2 binary labels for gender classification: man and woman
+    labels = np.array([0, 0, 1, 0, 1, 0, 1, 0, 1, 0], dtype=np.int64)
+
+    # Define transforms for image
+    val_transforms = Compose([ScaleIntensity(), AddChannel(), Resize((96, 96, 96)), ToTensor()])
+
+    # Define nifti dataset
+    val_ds = NiftiDataset(image_files=images, labels=labels, transform=val_transforms, image_only=False)
+    # create a validation data loader
+    val_loader = DataLoader(val_ds, batch_size=2, num_workers=4, pin_memory=torch.cuda.is_available())
+
+    # Create DenseNet121
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = monai.networks.nets.densenet.densenet121(spatial_dims=3, in_channels=1, out_channels=2).to(device)
+
+    model.load_state_dict(torch.load("best_metric_model_classification3d_array.pth"))
+    model.eval()
+    with torch.no_grad():
+        num_correct = 0.0
+        metric_count = 0
+        saver = CSVSaver(output_dir="./output")
+        for val_data in val_loader:
+            val_images, val_labels = val_data[0].to(device), val_data[1].to(device)
+            val_outputs = model(val_images).argmax(dim=1)
+            value = torch.eq(val_outputs, val_labels)
+            metric_count += len(value)
+            num_correct += value.sum().item()
+            saver.save_batch(val_outputs, val_data[2])
+        metric = num_correct / metric_count
+        print("evaluation metric:", metric)
+        saver.finalize()
+
+
+if __name__ == "__main__":
+    main()

testbed/Project-MONAI__MONAI/examples/classification_3d/densenet_evaluation_dict.py

@@ -0,0 +1,85 @@
+# Copyright 2020 MONAI Consortium
+# 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 logging
+import os
+import sys
+
+import numpy as np
+import torch
+from torch.utils.data import DataLoader
+
+import monai
+from monai.data import CSVSaver
+from monai.transforms import AddChanneld, Compose, LoadNiftid, Resized, ScaleIntensityd, ToTensord
+
+
+def main():
+    monai.config.print_config()
+    logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+
+    # IXI dataset as a demo, downloadable from https://brain-development.org/ixi-dataset/
+    images = [
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI607-Guys-1097-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI175-HH-1570-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI385-HH-2078-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI344-Guys-0905-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI409-Guys-0960-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI584-Guys-1129-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI253-HH-1694-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI092-HH-1436-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI574-IOP-1156-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI585-Guys-1130-T1.nii.gz"]),
+    ]
+
+    # 2 binary labels for gender classification: man and woman
+    labels = np.array([0, 0, 1, 0, 1, 0, 1, 0, 1, 0], dtype=np.int64)
+    val_files = [{"img": img, "label": label} for img, label in zip(images, labels)]
+
+    # Define transforms for image
+    val_transforms = Compose(
+        [
+            LoadNiftid(keys=["img"]),
+            AddChanneld(keys=["img"]),
+            ScaleIntensityd(keys=["img"]),
+            Resized(keys=["img"], spatial_size=(96, 96, 96)),
+            ToTensord(keys=["img"]),
+        ]
+    )
+
+    # create a validation data loader
+    val_ds = monai.data.Dataset(data=val_files, transform=val_transforms)
+    val_loader = DataLoader(val_ds, batch_size=2, num_workers=4, pin_memory=torch.cuda.is_available())
+
+    # Create DenseNet121
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = monai.networks.nets.densenet.densenet121(spatial_dims=3, in_channels=1, out_channels=2).to(device)
+
+    model.load_state_dict(torch.load("best_metric_model_classification3d_dict.pth"))
+    model.eval()
+    with torch.no_grad():
+        num_correct = 0.0
+        metric_count = 0
+        saver = CSVSaver(output_dir="./output")
+        for val_data in val_loader:
+            val_images, val_labels = val_data["img"].to(device), val_data["label"].to(device)
+            val_outputs = model(val_images).argmax(dim=1)
+            value = torch.eq(val_outputs, val_labels)
+            metric_count += len(value)
+            num_correct += value.sum().item()
+            saver.save_batch(val_outputs, val_data["img_meta_dict"])
+        metric = num_correct / metric_count
+        print("evaluation metric:", metric)
+        saver.finalize()
+
+
+if __name__ == "__main__":
+    main()

testbed/Project-MONAI__MONAI/examples/classification_3d/densenet_training_array.py

@@ -0,0 +1,139 @@
+# Copyright 2020 MONAI Consortium
+# 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 logging
+import os
+import sys
+
+import numpy as np
+import torch
+from torch.utils.data import DataLoader
+from torch.utils.tensorboard import SummaryWriter
+
+import monai
+from monai.data import NiftiDataset
+from monai.transforms import AddChannel, Compose, RandRotate90, Resize, ScaleIntensity, ToTensor
+
+
+def main():
+    monai.config.print_config()
+    logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+
+    # IXI dataset as a demo, downloadable from https://brain-development.org/ixi-dataset/
+    images = [
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI314-IOP-0889-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI249-Guys-1072-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI609-HH-2600-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI173-HH-1590-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI020-Guys-0700-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI342-Guys-0909-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI134-Guys-0780-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI577-HH-2661-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI066-Guys-0731-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI130-HH-1528-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI607-Guys-1097-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI175-HH-1570-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI385-HH-2078-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI344-Guys-0905-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI409-Guys-0960-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI584-Guys-1129-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI253-HH-1694-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI092-HH-1436-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI574-IOP-1156-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI585-Guys-1130-T1.nii.gz"]),
+    ]
+
+    # 2 binary labels for gender classification: man and woman
+    labels = np.array([0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0], dtype=np.int64)
+
+    # Define transforms
+    train_transforms = Compose([ScaleIntensity(), AddChannel(), Resize((96, 96, 96)), RandRotate90(), ToTensor()])
+    val_transforms = Compose([ScaleIntensity(), AddChannel(), Resize((96, 96, 96)), ToTensor()])
+
+    # Define nifti dataset, data loader
+    check_ds = NiftiDataset(image_files=images, labels=labels, transform=train_transforms)
+    check_loader = DataLoader(check_ds, batch_size=2, num_workers=2, pin_memory=torch.cuda.is_available())
+    im, label = monai.utils.misc.first(check_loader)
+    print(type(im), im.shape, label)
+
+    # create a training data loader
+    train_ds = NiftiDataset(image_files=images[:10], labels=labels[:10], transform=train_transforms)
+    train_loader = DataLoader(train_ds, batch_size=2, shuffle=True, num_workers=2, pin_memory=torch.cuda.is_available())
+
+    # create a validation data loader
+    val_ds = NiftiDataset(image_files=images[-10:], labels=labels[-10:], transform=val_transforms)
+    val_loader = DataLoader(val_ds, batch_size=2, num_workers=2, pin_memory=torch.cuda.is_available())
+
+    # Create DenseNet121, CrossEntropyLoss and Adam optimizer
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = monai.networks.nets.densenet.densenet121(spatial_dims=3, in_channels=1, out_channels=2).to(device)
+    loss_function = torch.nn.CrossEntropyLoss()
+    optimizer = torch.optim.Adam(model.parameters(), 1e-5)
+
+    # start a typical PyTorch training
+    val_interval = 2
+    best_metric = -1
+    best_metric_epoch = -1
+    epoch_loss_values = list()
+    metric_values = list()
+    writer = SummaryWriter()
+    for epoch in range(5):
+        print("-" * 10)
+        print(f"epoch {epoch + 1}/{5}")
+        model.train()
+        epoch_loss = 0
+        step = 0
+        for batch_data in train_loader:
+            step += 1
+            inputs, labels = batch_data[0].to(device), batch_data[1].to(device)
+            optimizer.zero_grad()
+            outputs = model(inputs)
+            loss = loss_function(outputs, labels)
+            loss.backward()
+            optimizer.step()
+            epoch_loss += loss.item()
+            epoch_len = len(train_ds) // train_loader.batch_size
+            print(f"{step}/{epoch_len}, train_loss: {loss.item():.4f}")
+            writer.add_scalar("train_loss", loss.item(), epoch_len * epoch + step)
+        epoch_loss /= step
+        epoch_loss_values.append(epoch_loss)
+        print(f"epoch {epoch + 1} average loss: {epoch_loss:.4f}")
+
+        if (epoch + 1) % val_interval == 0:
+            model.eval()
+            with torch.no_grad():
+                num_correct = 0.0
+                metric_count = 0
+                for val_data in val_loader:
+                    val_images, val_labels = val_data[0].to(device), val_data[1].to(device)
+                    val_outputs = model(val_images)
+                    value = torch.eq(val_outputs.argmax(dim=1), val_labels)
+                    metric_count += len(value)
+                    num_correct += value.sum().item()
+                metric = num_correct / metric_count
+                metric_values.append(metric)
+                if metric > best_metric:
+                    best_metric = metric
+                    best_metric_epoch = epoch + 1
+                    torch.save(model.state_dict(), "best_metric_model_classification3d_array.pth")
+                    print("saved new best metric model")
+                print(
+                    "current epoch: {} current accuracy: {:.4f} best accuracy: {:.4f} at epoch {}".format(
+                        epoch + 1, metric, best_metric, best_metric_epoch
+                    )
+                )
+                writer.add_scalar("val_accuracy", metric, epoch + 1)
+    print(f"train completed, best_metric: {best_metric:.4f} at epoch: {best_metric_epoch}")
+    writer.close()
+
+
+if __name__ == "__main__":
+    main()

testbed/Project-MONAI__MONAI/examples/classification_3d/densenet_training_dict.py

@@ -0,0 +1,155 @@
+# Copyright 2020 MONAI Consortium
+# 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 logging
+import os
+import sys
+
+import numpy as np
+import torch
+from torch.utils.data import DataLoader
+from torch.utils.tensorboard import SummaryWriter
+
+import monai
+from monai.metrics import compute_roc_auc
+from monai.transforms import AddChanneld, Compose, LoadNiftid, RandRotate90d, Resized, ScaleIntensityd, ToTensord
+
+
+def main():
+    monai.config.print_config()
+    logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+
+    # IXI dataset as a demo, downloadable from https://brain-development.org/ixi-dataset/
+    images = [
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI314-IOP-0889-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI249-Guys-1072-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI609-HH-2600-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI173-HH-1590-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI020-Guys-0700-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI342-Guys-0909-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI134-Guys-0780-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI577-HH-2661-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI066-Guys-0731-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI130-HH-1528-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI607-Guys-1097-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI175-HH-1570-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI385-HH-2078-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI344-Guys-0905-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI409-Guys-0960-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI584-Guys-1129-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI253-HH-1694-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI092-HH-1436-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI574-IOP-1156-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI585-Guys-1130-T1.nii.gz"]),
+    ]
+
+    # 2 binary labels for gender classification: man and woman
+    labels = np.array([0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0], dtype=np.int64)
+    train_files = [{"img": img, "label": label} for img, label in zip(images[:10], labels[:10])]
+    val_files = [{"img": img, "label": label} for img, label in zip(images[-10:], labels[-10:])]
+
+    # Define transforms for image
+    train_transforms = Compose(
+        [
+            LoadNiftid(keys=["img"]),
+            AddChanneld(keys=["img"]),
+            ScaleIntensityd(keys=["img"]),
+            Resized(keys=["img"], spatial_size=(96, 96, 96)),
+            RandRotate90d(keys=["img"], prob=0.8, spatial_axes=[0, 2]),
+            ToTensord(keys=["img"]),
+        ]
+    )
+    val_transforms = Compose(
+        [
+            LoadNiftid(keys=["img"]),
+            AddChanneld(keys=["img"]),
+            ScaleIntensityd(keys=["img"]),
+            Resized(keys=["img"], spatial_size=(96, 96, 96)),
+            ToTensord(keys=["img"]),
+        ]
+    )
+
+    # Define dataset, data loader
+    check_ds = monai.data.Dataset(data=train_files, transform=train_transforms)
+    check_loader = DataLoader(check_ds, batch_size=2, num_workers=4, pin_memory=torch.cuda.is_available())
+    check_data = monai.utils.misc.first(check_loader)
+    print(check_data["img"].shape, check_data["label"])
+
+    # create a training data loader
+    train_ds = monai.data.Dataset(data=train_files, transform=train_transforms)
+    train_loader = DataLoader(train_ds, batch_size=2, shuffle=True, num_workers=4, pin_memory=torch.cuda.is_available())
+
+    # create a validation data loader
+    val_ds = monai.data.Dataset(data=val_files, transform=val_transforms)
+    val_loader = DataLoader(val_ds, batch_size=2, num_workers=4, pin_memory=torch.cuda.is_available())
+
+    # Create DenseNet121, CrossEntropyLoss and Adam optimizer
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = monai.networks.nets.densenet.densenet121(spatial_dims=3, in_channels=1, out_channels=2).to(device)
+    loss_function = torch.nn.CrossEntropyLoss()
+    optimizer = torch.optim.Adam(model.parameters(), 1e-5)
+
+    # start a typical PyTorch training
+    val_interval = 2
+    best_metric = -1
+    best_metric_epoch = -1
+    writer = SummaryWriter()
+    for epoch in range(5):
+        print("-" * 10)
+        print(f"epoch {epoch + 1}/{5}")
+        model.train()
+        epoch_loss = 0
+        step = 0
+        for batch_data in train_loader:
+            step += 1
+            inputs, labels = batch_data["img"].to(device), batch_data["label"].to(device)
+            optimizer.zero_grad()
+            outputs = model(inputs)
+            loss = loss_function(outputs, labels)
+            loss.backward()
+            optimizer.step()
+            epoch_loss += loss.item()
+            epoch_len = len(train_ds) // train_loader.batch_size
+            print(f"{step}/{epoch_len}, train_loss: {loss.item():.4f}")
+            writer.add_scalar("train_loss", loss.item(), epoch_len * epoch + step)
+        epoch_loss /= step
+        print(f"epoch {epoch + 1} average loss: {epoch_loss:.4f}")
+
+        if (epoch + 1) % val_interval == 0:
+            model.eval()
+            with torch.no_grad():
+                y_pred = torch.tensor([], dtype=torch.float32, device=device)
+                y = torch.tensor([], dtype=torch.long, device=device)
+                for val_data in val_loader:
+                    val_images, val_labels = val_data["img"].to(device), val_data["label"].to(device)
+                    y_pred = torch.cat([y_pred, model(val_images)], dim=0)
+                    y = torch.cat([y, val_labels], dim=0)
+
+                acc_value = torch.eq(y_pred.argmax(dim=1), y)
+                acc_metric = acc_value.sum().item() / len(acc_value)
+                auc_metric = compute_roc_auc(y_pred, y, to_onehot_y=True, softmax=True)
+                if acc_metric > best_metric:
+                    best_metric = acc_metric
+                    best_metric_epoch = epoch + 1
+                    torch.save(model.state_dict(), "best_metric_model_classification3d_dict.pth")
+                    print("saved new best metric model")
+                print(
+                    "current epoch: {} current accuracy: {:.4f} current AUC: {:.4f} best accuracy: {:.4f} at epoch {}".format(
+                        epoch + 1, acc_metric, auc_metric, best_metric, best_metric_epoch
+                    )
+                )
+                writer.add_scalar("val_accuracy", acc_metric, epoch + 1)
+    print(f"train completed, best_metric: {best_metric:.4f} at epoch: {best_metric_epoch}")
+    writer.close()
+
+
+if __name__ == "__main__":
+    main()

testbed/Project-MONAI__MONAI/examples/classification_3d_ignite/densenet_evaluation_array.py

@@ -0,0 +1,94 @@
+# Copyright 2020 MONAI Consortium
+# 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 logging
+import os
+import sys
+
+import numpy as np
+import torch
+from ignite.engine import _prepare_batch, create_supervised_evaluator
+from ignite.metrics import Accuracy
+from torch.utils.data import DataLoader
+
+import monai
+from monai.data import NiftiDataset
+from monai.handlers import CheckpointLoader, ClassificationSaver, StatsHandler
+from monai.transforms import AddChannel, Compose, Resize, ScaleIntensity, ToTensor
+
+
+def main():
+    monai.config.print_config()
+    logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+
+    # IXI dataset as a demo, downloadable from https://brain-development.org/ixi-dataset/
+    images = [
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI607-Guys-1097-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI175-HH-1570-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI385-HH-2078-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI344-Guys-0905-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI409-Guys-0960-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI584-Guys-1129-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI253-HH-1694-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI092-HH-1436-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI574-IOP-1156-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI585-Guys-1130-T1.nii.gz"]),
+    ]
+
+    # 2 binary labels for gender classification: man and woman
+    labels = np.array([0, 0, 1, 0, 1, 0, 1, 0, 1, 0], dtype=np.int64)
+
+    # define transforms for image
+    val_transforms = Compose([ScaleIntensity(), AddChannel(), Resize((96, 96, 96)), ToTensor()])
+    # define nifti dataset
+    val_ds = NiftiDataset(image_files=images, labels=labels, transform=val_transforms, image_only=False)
+    # create DenseNet121
+    net = monai.networks.nets.densenet.densenet121(spatial_dims=3, in_channels=1, out_channels=2)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    metric_name = "Accuracy"
+    # add evaluation metric to the evaluator engine
+    val_metrics = {metric_name: Accuracy()}
+
+    def prepare_batch(batch, device=None, non_blocking=False):
+        return _prepare_batch((batch[0], batch[1]), device, non_blocking)
+
+    # Ignite evaluator expects batch=(img, label) and returns output=(y_pred, y) at every iteration,
+    # user can add output_transform to return other values
+    evaluator = create_supervised_evaluator(net, val_metrics, device, True, prepare_batch=prepare_batch)
+
+    # add stats event handler to print validation stats via evaluator
+    val_stats_handler = StatsHandler(
+        name="evaluator",
+        output_transform=lambda x: None,  # no need to print loss value, so disable per iteration output
+    )
+    val_stats_handler.attach(evaluator)
+
+    # for the array data format, assume the 3rd item of batch data is the meta_data
+    prediction_saver = ClassificationSaver(
+        output_dir="tempdir",
+        batch_transform=lambda batch: batch[2],
+        output_transform=lambda output: output[0].argmax(1),
+    )
+    prediction_saver.attach(evaluator)
+
+    # the model was trained by "densenet_training_array" example
+    CheckpointLoader(load_path="./runs_array/net_checkpoint_20.pth", load_dict={"net": net}).attach(evaluator)
+
+    # create a validation data loader
+    val_loader = DataLoader(val_ds, batch_size=2, num_workers=4, pin_memory=torch.cuda.is_available())
+
+    state = evaluator.run(val_loader)
+    print(state)
+
+
+if __name__ == "__main__":
+    main()

testbed/Project-MONAI__MONAI/examples/classification_3d_ignite/densenet_evaluation_dict.py

@@ -0,0 +1,102 @@
+# Copyright 2020 MONAI Consortium
+# 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 logging
+import os
+import sys
+
+import numpy as np
+import torch
+from ignite.engine import _prepare_batch, create_supervised_evaluator
+from ignite.metrics import Accuracy
+from torch.utils.data import DataLoader
+
+import monai
+from monai.handlers import CheckpointLoader, ClassificationSaver, StatsHandler
+from monai.transforms import AddChanneld, Compose, LoadNiftid, Resized, ScaleIntensityd, ToTensord
+
+
+def main():
+    monai.config.print_config()
+    logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+
+    # IXI dataset as a demo, downloadable from https://brain-development.org/ixi-dataset/
+    images = [
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI607-Guys-1097-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI175-HH-1570-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI385-HH-2078-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI344-Guys-0905-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI409-Guys-0960-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI584-Guys-1129-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI253-HH-1694-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI092-HH-1436-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI574-IOP-1156-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI585-Guys-1130-T1.nii.gz"]),
+    ]
+
+    # 2 binary labels for gender classification: man and woman
+    labels = np.array([0, 0, 1, 0, 1, 0, 1, 0, 1, 0], dtype=np.int64)
+    val_files = [{"img": img, "label": label} for img, label in zip(images, labels)]
+
+    # define transforms for image
+    val_transforms = Compose(
+        [
+            LoadNiftid(keys=["img"]),
+            AddChanneld(keys=["img"]),
+            ScaleIntensityd(keys=["img"]),
+            Resized(keys=["img"], spatial_size=(96, 96, 96)),
+            ToTensord(keys=["img"]),
+        ]
+    )
+
+    # create DenseNet121
+    net = monai.networks.nets.densenet.densenet121(spatial_dims=3, in_channels=1, out_channels=2)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    def prepare_batch(batch, device=None, non_blocking=False):
+        return _prepare_batch((batch["img"], batch["label"]), device, non_blocking)
+
+    metric_name = "Accuracy"
+    # add evaluation metric to the evaluator engine
+    val_metrics = {metric_name: Accuracy()}
+    # Ignite evaluator expects batch=(img, label) and returns output=(y_pred, y) at every iteration,
+    # user can add output_transform to return other values
+    evaluator = create_supervised_evaluator(net, val_metrics, device, True, prepare_batch=prepare_batch)
+
+    # add stats event handler to print validation stats via evaluator
+    val_stats_handler = StatsHandler(
+        name="evaluator",
+        output_transform=lambda x: None,  # no need to print loss value, so disable per iteration output
+    )
+    val_stats_handler.attach(evaluator)
+
+    # for the array data format, assume the 3rd item of batch data is the meta_data
+    prediction_saver = ClassificationSaver(
+        output_dir="tempdir",
+        name="evaluator",
+        batch_transform=lambda batch: batch["img_meta_dict"],
+        output_transform=lambda output: output[0].argmax(1),
+    )
+    prediction_saver.attach(evaluator)
+
+    # the model was trained by "densenet_training_dict" example
+    CheckpointLoader(load_path="./runs_dict/net_checkpoint_20.pth", load_dict={"net": net}).attach(evaluator)
+
+    # create a validation data loader
+    val_ds = monai.data.Dataset(data=val_files, transform=val_transforms)
+    val_loader = DataLoader(val_ds, batch_size=2, num_workers=4, pin_memory=torch.cuda.is_available())
+
+    state = evaluator.run(val_loader)
+    print(state)
+
+
+if __name__ == "__main__":
+    main()

testbed/Project-MONAI__MONAI/examples/classification_3d_ignite/densenet_training_array.py

@@ -0,0 +1,144 @@
+# Copyright 2020 MONAI Consortium
+# 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 logging
+import os
+import sys
+
+import numpy as np
+import torch
+from ignite.engine import Events, create_supervised_evaluator, create_supervised_trainer
+from ignite.handlers import EarlyStopping, ModelCheckpoint
+from ignite.metrics import Accuracy
+from torch.utils.data import DataLoader
+
+import monai
+from monai.data import NiftiDataset
+from monai.handlers import StatsHandler, TensorBoardStatsHandler, stopping_fn_from_metric
+from monai.transforms import AddChannel, Compose, RandRotate90, Resize, ScaleIntensity, ToTensor
+
+
+def main():
+    monai.config.print_config()
+    logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+
+    # IXI dataset as a demo, downloadable from https://brain-development.org/ixi-dataset/
+    images = [
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI314-IOP-0889-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI249-Guys-1072-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI609-HH-2600-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI173-HH-1590-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI020-Guys-0700-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI342-Guys-0909-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI134-Guys-0780-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI577-HH-2661-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI066-Guys-0731-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI130-HH-1528-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI607-Guys-1097-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI175-HH-1570-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI385-HH-2078-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI344-Guys-0905-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI409-Guys-0960-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI584-Guys-1129-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI253-HH-1694-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI092-HH-1436-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI574-IOP-1156-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI585-Guys-1130-T1.nii.gz"]),
+    ]
+
+    # 2 binary labels for gender classification: man and woman
+    labels = np.array([0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0], dtype=np.int64)
+
+    # define transforms
+    train_transforms = Compose([ScaleIntensity(), AddChannel(), Resize((96, 96, 96)), RandRotate90(), ToTensor()])
+    val_transforms = Compose([ScaleIntensity(), AddChannel(), Resize((96, 96, 96)), ToTensor()])
+
+    # define nifti dataset, data loader
+    check_ds = NiftiDataset(image_files=images, labels=labels, transform=train_transforms)
+    check_loader = DataLoader(check_ds, batch_size=2, num_workers=2, pin_memory=torch.cuda.is_available())
+    im, label = monai.utils.misc.first(check_loader)
+    print(type(im), im.shape, label)
+
+    # create DenseNet121, CrossEntropyLoss and Adam optimizer
+    net = monai.networks.nets.densenet.densenet121(spatial_dims=3, in_channels=1, out_channels=2)
+    loss = torch.nn.CrossEntropyLoss()
+    lr = 1e-5
+    opt = torch.optim.Adam(net.parameters(), lr)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    # Ignite trainer expects batch=(img, label) and returns output=loss at every iteration,
+    # user can add output_transform to return other values, like: y_pred, y, etc.
+    trainer = create_supervised_trainer(net, opt, loss, device, False)
+
+    # adding checkpoint handler to save models (network params and optimizer stats) during training
+    checkpoint_handler = ModelCheckpoint("./runs_array/", "net", n_saved=10, require_empty=False)
+    trainer.add_event_handler(
+        event_name=Events.EPOCH_COMPLETED, handler=checkpoint_handler, to_save={"net": net, "opt": opt}
+    )
+
+    # StatsHandler prints loss at every iteration and print metrics at every epoch,
+    # we don't set metrics for trainer here, so just print loss, user can also customize print functions
+    # and can use output_transform to convert engine.state.output if it's not loss value
+    train_stats_handler = StatsHandler(name="trainer")
+    train_stats_handler.attach(trainer)
+
+    # TensorBoardStatsHandler plots loss at every iteration and plots metrics at every epoch, same as StatsHandler
+    train_tensorboard_stats_handler = TensorBoardStatsHandler()
+    train_tensorboard_stats_handler.attach(trainer)
+
+    # set parameters for validation
+    validation_every_n_epochs = 1
+
+    metric_name = "Accuracy"
+    # add evaluation metric to the evaluator engine
+    val_metrics = {metric_name: Accuracy()}
+    # Ignite evaluator expects batch=(img, label) and returns output=(y_pred, y) at every iteration,
+    # user can add output_transform to return other values
+    evaluator = create_supervised_evaluator(net, val_metrics, device, True)
+
+    # add stats event handler to print validation stats via evaluator
+    val_stats_handler = StatsHandler(
+        name="evaluator",
+        output_transform=lambda x: None,  # no need to print loss value, so disable per iteration output
+        global_epoch_transform=lambda x: trainer.state.epoch,
+    )  # fetch global epoch number from trainer
+    val_stats_handler.attach(evaluator)
+
+    # add handler to record metrics to TensorBoard at every epoch
+    val_tensorboard_stats_handler = TensorBoardStatsHandler(
+        output_transform=lambda x: None,  # no need to plot loss value, so disable per iteration output
+        global_epoch_transform=lambda x: trainer.state.epoch,
+    )  # fetch global epoch number from trainer
+    val_tensorboard_stats_handler.attach(evaluator)
+
+    # add early stopping handler to evaluator
+    early_stopper = EarlyStopping(patience=4, score_function=stopping_fn_from_metric(metric_name), trainer=trainer)
+    evaluator.add_event_handler(event_name=Events.EPOCH_COMPLETED, handler=early_stopper)
+
+    # create a validation data loader
+    val_ds = NiftiDataset(image_files=images[-10:], labels=labels[-10:], transform=val_transforms)
+    val_loader = DataLoader(val_ds, batch_size=2, num_workers=2, pin_memory=torch.cuda.is_available())
+
+    @trainer.on(Events.EPOCH_COMPLETED(every=validation_every_n_epochs))
+    def run_validation(engine):
+        evaluator.run(val_loader)
+
+    # create a training data loader
+    train_ds = NiftiDataset(image_files=images[:10], labels=labels[:10], transform=train_transforms)
+    train_loader = DataLoader(train_ds, batch_size=2, shuffle=True, num_workers=2, pin_memory=torch.cuda.is_available())
+
+    train_epochs = 30
+    state = trainer.run(train_loader, train_epochs)
+    print(state)
+
+
+if __name__ == "__main__":
+    main()

testbed/Project-MONAI__MONAI/examples/classification_3d_ignite/densenet_training_dict.py

@@ -0,0 +1,166 @@
+# Copyright 2020 MONAI Consortium
+# 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 logging
+import os
+import sys
+
+import numpy as np
+import torch
+from ignite.engine import Events, _prepare_batch, create_supervised_evaluator, create_supervised_trainer
+from ignite.handlers import EarlyStopping, ModelCheckpoint
+from ignite.metrics import Accuracy
+from torch.utils.data import DataLoader
+
+import monai
+from monai.handlers import ROCAUC, StatsHandler, TensorBoardStatsHandler, stopping_fn_from_metric
+from monai.transforms import AddChanneld, Compose, LoadNiftid, RandRotate90d, Resized, ScaleIntensityd, ToTensord
+
+
+def main():
+    monai.config.print_config()
+    logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+
+    # IXI dataset as a demo, downloadable from https://brain-development.org/ixi-dataset/
+    images = [
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI314-IOP-0889-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI249-Guys-1072-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI609-HH-2600-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI173-HH-1590-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI020-Guys-0700-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI342-Guys-0909-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI134-Guys-0780-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI577-HH-2661-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI066-Guys-0731-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI130-HH-1528-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI607-Guys-1097-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI175-HH-1570-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI385-HH-2078-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI344-Guys-0905-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI409-Guys-0960-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI584-Guys-1129-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI253-HH-1694-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI092-HH-1436-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI574-IOP-1156-T1.nii.gz"]),
+        os.sep.join(["workspace", "data", "medical", "ixi", "IXI-T1", "IXI585-Guys-1130-T1.nii.gz"]),
+    ]
+
+    # 2 binary labels for gender classification: man and woman
+    labels = np.array([0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0], dtype=np.int64)
+    train_files = [{"img": img, "label": label} for img, label in zip(images[:10], labels[:10])]
+    val_files = [{"img": img, "label": label} for img, label in zip(images[-10:], labels[-10:])]
+
+    # define transforms for image
+    train_transforms = Compose(
+        [
+            LoadNiftid(keys=["img"]),
+            AddChanneld(keys=["img"]),
+            ScaleIntensityd(keys=["img"]),
+            Resized(keys=["img"], spatial_size=(96, 96, 96)),
+            RandRotate90d(keys=["img"], prob=0.8, spatial_axes=[0, 2]),
+            ToTensord(keys=["img"]),
+        ]
+    )
+    val_transforms = Compose(
+        [
+            LoadNiftid(keys=["img"]),
+            AddChanneld(keys=["img"]),
+            ScaleIntensityd(keys=["img"]),
+            Resized(keys=["img"], spatial_size=(96, 96, 96)),
+            ToTensord(keys=["img"]),
+        ]
+    )
+
+    # define dataset, data loader
+    check_ds = monai.data.Dataset(data=train_files, transform=train_transforms)
+    check_loader = DataLoader(check_ds, batch_size=2, num_workers=4, pin_memory=torch.cuda.is_available())
+    check_data = monai.utils.misc.first(check_loader)
+    print(check_data["img"].shape, check_data["label"])
+
+    # create DenseNet121, CrossEntropyLoss and Adam optimizer
+    net = monai.networks.nets.densenet.densenet121(spatial_dims=3, in_channels=1, out_channels=2)
+    loss = torch.nn.CrossEntropyLoss()
+    lr = 1e-5
+    opt = torch.optim.Adam(net.parameters(), lr)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    # Ignite trainer expects batch=(img, label) and returns output=loss at every iteration,
+    # user can add output_transform to return other values, like: y_pred, y, etc.
+    def prepare_batch(batch, device=None, non_blocking=False):
+
+        return _prepare_batch((batch["img"], batch["label"]), device, non_blocking)
+
+    trainer = create_supervised_trainer(net, opt, loss, device, False, prepare_batch=prepare_batch)
+
+    # adding checkpoint handler to save models (network params and optimizer stats) during training
+    checkpoint_handler = ModelCheckpoint("./runs_dict/", "net", n_saved=10, require_empty=False)
+    trainer.add_event_handler(
+        event_name=Events.EPOCH_COMPLETED, handler=checkpoint_handler, to_save={"net": net, "opt": opt}
+    )
+
+    # StatsHandler prints loss at every iteration and print metrics at every epoch,
+    # we don't set metrics for trainer here, so just print loss, user can also customize print functions
+    # and can use output_transform to convert engine.state.output if it's not loss value
+    train_stats_handler = StatsHandler(name="trainer")
+    train_stats_handler.attach(trainer)
+
+    # TensorBoardStatsHandler plots loss at every iteration and plots metrics at every epoch, same as StatsHandler
+    train_tensorboard_stats_handler = TensorBoardStatsHandler()
+    train_tensorboard_stats_handler.attach(trainer)
+
+    # set parameters for validation
+    validation_every_n_epochs = 1
+
+    metric_name = "Accuracy"
+    # add evaluation metric to the evaluator engine
+    val_metrics = {metric_name: Accuracy(), "AUC": ROCAUC(to_onehot_y=True, softmax=True)}
+    # Ignite evaluator expects batch=(img, label) and returns output=(y_pred, y) at every iteration,
+    # user can add output_transform to return other values
+    evaluator = create_supervised_evaluator(net, val_metrics, device, True, prepare_batch=prepare_batch)
+
+    # add stats event handler to print validation stats via evaluator
+    val_stats_handler = StatsHandler(
+        name="evaluator",
+        output_transform=lambda x: None,  # no need to print loss value, so disable per iteration output
+        global_epoch_transform=lambda x: trainer.state.epoch,
+    )  # fetch global epoch number from trainer
+    val_stats_handler.attach(evaluator)
+
+    # add handler to record metrics to TensorBoard at every epoch
+    val_tensorboard_stats_handler = TensorBoardStatsHandler(
+        output_transform=lambda x: None,  # no need to plot loss value, so disable per iteration output
+        global_epoch_transform=lambda x: trainer.state.epoch,
+    )  # fetch global epoch number from trainer
+    val_tensorboard_stats_handler.attach(evaluator)
+
+    # add early stopping handler to evaluator
+    early_stopper = EarlyStopping(patience=4, score_function=stopping_fn_from_metric(metric_name), trainer=trainer)
+    evaluator.add_event_handler(event_name=Events.EPOCH_COMPLETED, handler=early_stopper)
+
+    # create a validation data loader
+    val_ds = monai.data.Dataset(data=val_files, transform=val_transforms)
+    val_loader = DataLoader(val_ds, batch_size=2, num_workers=4, pin_memory=torch.cuda.is_available())
+
+    @trainer.on(Events.EPOCH_COMPLETED(every=validation_every_n_epochs))
+    def run_validation(engine):
+        evaluator.run(val_loader)
+
+    # create a training data loader
+    train_ds = monai.data.Dataset(data=train_files, transform=train_transforms)
+    train_loader = DataLoader(train_ds, batch_size=2, shuffle=True, num_workers=4, pin_memory=torch.cuda.is_available())
+
+    train_epochs = 30
+    state = trainer.run(train_loader, train_epochs)
+    print(state)
+
+
+if __name__ == "__main__":
+    main()

testbed/Project-MONAI__MONAI/examples/distributed_training/unet_evaluation_ddp.py

@@ -0,0 +1,166 @@
+# Copyright 2020 MONAI Consortium
+# 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.
+
+"""
+This example shows how to execute distributed evaluation based on PyTorch native `DistributedDataParallel` module.
+It can run on several nodes with multiple GPU devices on every node.
+Main steps to set up the distributed evaluation:
+
+- Execute `torch.distributed.launch` to create processes on every node for every GPU.
+  It receives parameters as below:
+  `--nproc_per_node=NUM_GPUS_PER_NODE`
+  `--nnodes=NUM_NODES`
+  `--node_rank=INDEX_CURRENT_NODE`
+  `--master_addr="192.168.1.1"`
+  `--master_port=1234`
+  For more details, refer to https://github.com/pytorch/pytorch/blob/master/torch/distributed/launch.py.
+  Alternatively, we can also use `torch.multiprocessing.spawn` to start program, but it that case, need to handle
+  all the above parameters and compute `rank` manually, then set to `init_process_group`, etc.
+  `torch.distributed.launch` is even more efficient than `torch.multiprocessing.spawn`.
+- Use `init_process_group` to initialize every process, every GPU runs in a separate process with unique rank.
+  Here we use `NVIDIA NCCL` as the backend and must set `init_method="env://"` if use `torch.distributed.launch`.
+- Wrap the model with `DistributedDataParallel` after moving to expected device.
+- Put model file on every node, then load and map to expected GPU device in every process.
+- Wrap Dataset with `DistributedSampler`, disable the `shuffle` in sampler and DataLoader.
+- Compute `Dice Metric` on every process, reduce the results after synchronization.
+
+Note:
+    `torch.distributed.launch` will launch `nnodes * nproc_per_node = world_size` processes in total.
+    Suggest setting exactly the same software environment for every node, especially `PyTorch`, `nccl`, etc.
+    A good practice is to use the same MONAI docker image for all nodes directly.
+    Example script to execute this program on every node:
+    python -m torch.distributed.launch --nproc_per_node=NUM_GPUS_PER_NODE
+           --nnodes=NUM_NODES --node_rank=INDEX_CURRENT_NODE
+           --master_addr="192.168.1.1" --master_port=1234
+           unet_evaluation_ddp.py -d DIR_OF_TESTDATA
+
+    This example was tested with [Ubuntu 16.04/20.04], [NCCL 2.6.3].
+
+Referring to: https://pytorch.org/tutorials/intermediate/ddp_tutorial.html
+
+"""
+
+import argparse
+import os
+from glob import glob
+
+import nibabel as nib
+import numpy as np
+import torch
+import torch.distributed as dist
+from torch.nn.parallel import DistributedDataParallel
+from torch.utils.data.distributed import DistributedSampler
+
+import monai
+from monai.data import DataLoader, Dataset, create_test_image_3d
+from monai.inferers import sliding_window_inference
+from monai.metrics import DiceMetric
+from monai.transforms import AsChannelFirstd, Compose, LoadNiftid, ScaleIntensityd, ToTensord
+
+
+def evaluate(args):
+    if args.local_rank == 0 and not os.path.exists(args.dir):
+        # create 16 random image, mask paris for evaluation
+        print(f"generating synthetic data to {args.dir} (this may take a while)")
+        os.makedirs(args.dir)
+        # set random seed to generate same random data for every node
+        np.random.seed(seed=0)
+        for i in range(16):
+            im, seg = create_test_image_3d(128, 128, 128, num_seg_classes=1, channel_dim=-1)
+            n = nib.Nifti1Image(im, np.eye(4))
+            nib.save(n, os.path.join(args.dir, f"img{i:d}.nii.gz"))
+            n = nib.Nifti1Image(seg, np.eye(4))
+            nib.save(n, os.path.join(args.dir, f"seg{i:d}.nii.gz"))
+
+    # initialize the distributed evaluation process, every GPU runs in a process
+    dist.init_process_group(backend="nccl", init_method="env://")
+
+    images = sorted(glob(os.path.join(args.dir, "img*.nii.gz")))
+    segs = sorted(glob(os.path.join(args.dir, "seg*.nii.gz")))
+    val_files = [{"img": img, "seg": seg} for img, seg in zip(images, segs)]
+
+    # define transforms for image and segmentation
+    val_transforms = Compose(
+        [
+            LoadNiftid(keys=["img", "seg"]),
+            AsChannelFirstd(keys=["img", "seg"], channel_dim=-1),
+            ScaleIntensityd(keys="img"),
+            ToTensord(keys=["img", "seg"]),
+        ]
+    )
+
+    # create a evaluation data loader
+    val_ds = Dataset(data=val_files, transform=val_transforms)
+    # create a evaluation data sampler
+    val_sampler = DistributedSampler(val_ds, shuffle=False)
+    # sliding window inference need to input 1 image in every iteration
+    val_loader = DataLoader(val_ds, batch_size=1, shuffle=False, num_workers=2, pin_memory=True, sampler=val_sampler)
+    dice_metric = DiceMetric(include_background=True, to_onehot_y=False, sigmoid=True, reduction="mean")
+
+    # create UNet, DiceLoss and Adam optimizer
+    device = torch.device(f"cuda:{args.local_rank}")
+    model = monai.networks.nets.UNet(
+        dimensions=3,
+        in_channels=1,
+        out_channels=1,
+        channels=(16, 32, 64, 128, 256),
+        strides=(2, 2, 2, 2),
+        num_res_units=2,
+    ).to(device)
+    # wrap the model with DistributedDataParallel module
+    model = DistributedDataParallel(model, device_ids=[args.local_rank])
+    # config mapping to expected GPU device
+    map_location = {"cuda:0": f"cuda:{args.local_rank}"}
+    # load model parameters to GPU device
+    model.load_state_dict(torch.load("final_model.pth", map_location=map_location))
+
+    model.eval()
+    with torch.no_grad():
+        # define PyTorch Tensor to record metrics result at each GPU
+        # the first value is `sum` of all dice metric, the second value is `count` of not_nan items
+        metric = torch.zeros(2, dtype=torch.float, device=device)
+        for val_data in val_loader:
+            val_images, val_labels = val_data["img"].to(device), val_data["seg"].to(device)
+            # define sliding window size and batch size for windows inference
+            roi_size = (96, 96, 96)
+            sw_batch_size = 4
+            val_outputs = sliding_window_inference(val_images, roi_size, sw_batch_size, model)
+            value = dice_metric(y_pred=val_outputs, y=val_labels).squeeze()
+            metric[0] += value * dice_metric.not_nans
+            metric[1] += dice_metric.not_nans
+        # synchronizes all processes and reduce results
+        dist.barrier()
+        dist.all_reduce(metric, op=torch.distributed.ReduceOp.SUM)
+        metric = metric.tolist()
+        if dist.get_rank() == 0:
+            print("evaluation metric:", metric[0] / metric[1])
+        dist.destroy_process_group()
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-d", "--dir", default="./testdata", type=str, help="directory to create random data")
+    # must parse the command-line argument: ``--local_rank=LOCAL_PROCESS_RANK``, which will be provided by DDP
+    parser.add_argument("--local_rank", type=int)
+    args = parser.parse_args()
+
+    evaluate(args=args)
+
+
+# usage example(refer to https://github.com/pytorch/pytorch/blob/master/torch/distributed/launch.py):
+
+# python -m torch.distributed.launch --nproc_per_node=NUM_GPUS_PER_NODE
+#        --nnodes=NUM_NODES --node_rank=INDEX_CURRENT_NODE
+#        --master_addr="192.168.1.1" --master_port=1234
+#        unet_evaluation_ddp.py -d DIR_OF_TESTDATA
+
+if __name__ == "__main__":
+    main()

testbed/Project-MONAI__MONAI/examples/distributed_training/unet_evaluation_horovod.py

@@ -0,0 +1,165 @@
+# Copyright 2020 MONAI Consortium
+# 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.
+
+"""
+This example shows how to execute distributed evaluation based on Horovod APIs.
+It can run on several nodes with multiple GPU devices on every node.
+Main steps to set up the distributed evaluation:
+
+- Install Horovod referring to the guide: https://github.com/horovod/horovod/blob/master/docs/gpus.rst
+  If using MONAI docker, which already has NCCL and MPI, can quickly install Horovod with command:
+  `HOROVOD_NCCL_INCLUDE=/usr/include HOROVOD_NCCL_LIB=/usr/lib/x86_64-linux-gnu HOROVOD_GPU_OPERATIONS=NCCL \
+  pip install --no-cache-dir horovod`
+- Set SSH permissions for root login without password at all nodes except master, referring to:
+  http://www.linuxproblem.org/art_9.html
+- Run `hvd.init()` to initialize Horovod.
+- Pin each GPU to a single process to avoid resource contention, use `hvd.local_rank()` to get GPU index.
+  And use `hvd.rank()` to get the overall rank index.
+- Wrap Dataset with `DistributedSampler`, disable `shuffle` for sampler and DataLoader.
+- Broadcast the model parameters from rank 0 to all other processes.
+
+Note:
+    Suggest setting exactly the same software environment for every node, especially `mpi`, `nccl`, etc.
+    A good practice is to use the same MONAI docker image for all nodes directly, if using docker, need
+    to set SSH permissions both at the node and in docker, referring to Horovod guide for more details:
+    https://github.com/horovod/horovod/blob/master/docs/docker.rst
+
+    Example script to execute this program, only need to run on the master node:
+    `horovodrun -np 16 -H server1:4,server2:4,server3:4,server4:4 python unet_evaluation_horovod.py -d "./testdata"`
+
+    This example was tested with [Ubuntu 16.04/20.04], [NCCL 2.6.3], [horovod 0.19.5].
+
+Referring to: https://github.com/horovod/horovod/blob/master/examples/pytorch_mnist.py
+
+"""
+
+import argparse
+import os
+from glob import glob
+
+import horovod.torch as hvd
+import nibabel as nib
+import numpy as np
+import torch
+import torch.multiprocessing as mp
+from torch.utils.data.distributed import DistributedSampler
+
+import monai
+from monai.data import DataLoader, Dataset, create_test_image_3d
+from monai.inferers import sliding_window_inference
+from monai.metrics import DiceMetric
+from monai.transforms import AsChannelFirstd, Compose, LoadNiftid, ScaleIntensityd, ToTensord
+
+
+def evaluate(args):
+    # initialize Horovod library
+    hvd.init()
+    # Horovod limits CPU threads to be used per worker
+    torch.set_num_threads(1)
+
+    if hvd.local_rank() == 0 and not os.path.exists(args.dir):
+        # create 16 random image, mask paris for evaluation
+        print(f"generating synthetic data to {args.dir} (this may take a while)")
+        os.makedirs(args.dir)
+        # set random seed to generate same random data for every node
+        np.random.seed(seed=0)
+        for i in range(16):
+            im, seg = create_test_image_3d(128, 128, 128, num_seg_classes=1, channel_dim=-1)
+            n = nib.Nifti1Image(im, np.eye(4))
+            nib.save(n, os.path.join(args.dir, f"img{i:d}.nii.gz"))
+            n = nib.Nifti1Image(seg, np.eye(4))
+            nib.save(n, os.path.join(args.dir, f"seg{i:d}.nii.gz"))
+
+    images = sorted(glob(os.path.join(args.dir, "img*.nii.gz")))
+    segs = sorted(glob(os.path.join(args.dir, "seg*.nii.gz")))
+    val_files = [{"img": img, "seg": seg} for img, seg in zip(images, segs)]
+
+    # define transforms for image and segmentation
+    val_transforms = Compose(
+        [
+            LoadNiftid(keys=["img", "seg"]),
+            AsChannelFirstd(keys=["img", "seg"], channel_dim=-1),
+            ScaleIntensityd(keys="img"),
+            ToTensord(keys=["img", "seg"]),
+        ]
+    )
+
+    # create a evaluation data loader
+    val_ds = Dataset(data=val_files, transform=val_transforms)
+    # create a evaluation data sampler
+    val_sampler = DistributedSampler(val_ds, shuffle=False, num_replicas=hvd.size(), rank=hvd.rank())
+    # when supported, use "forkserver" to spawn dataloader workers instead of "fork" to prevent
+    # issues with Infiniband implementations that are not fork-safe
+    multiprocessing_context = None
+    if hasattr(mp, "_supports_context") and mp._supports_context and "forkserver" in mp.get_all_start_methods():
+        multiprocessing_context = "forkserver"
+    # sliding window inference need to input 1 image in every iteration
+    val_loader = DataLoader(
+        val_ds,
+        batch_size=1,
+        shuffle=False,
+        num_workers=2,
+        pin_memory=True,
+        sampler=val_sampler,
+        multiprocessing_context=multiprocessing_context,
+    )
+    dice_metric = DiceMetric(include_background=True, to_onehot_y=False, sigmoid=True, reduction="mean")
+
+    # create UNet, DiceLoss and Adam optimizer
+    device = torch.device(f"cuda:{hvd.local_rank()}")
+    model = monai.networks.nets.UNet(
+        dimensions=3,
+        in_channels=1,
+        out_channels=1,
+        channels=(16, 32, 64, 128, 256),
+        strides=(2, 2, 2, 2),
+        num_res_units=2,
+    ).to(device)
+    if hvd.rank() == 0:
+        # load model parameters for evaluation
+        model.load_state_dict(torch.load("final_model.pth"))
+    # Horovod broadcasts parameters
+    hvd.broadcast_parameters(model.state_dict(), root_rank=0)
+
+    model.eval()
+    with torch.no_grad():
+        # define PyTorch Tensor to record metrics result at each GPU
+        # the first value is `sum` of all dice metric, the second value is `count` of not_nan items
+        metric = torch.zeros(2, dtype=torch.float, device=device)
+        for val_data in val_loader:
+            val_images, val_labels = val_data["img"].to(device), val_data["seg"].to(device)
+            # define sliding window size and batch size for windows inference
+            roi_size = (96, 96, 96)
+            sw_batch_size = 4
+            val_outputs = sliding_window_inference(val_images, roi_size, sw_batch_size, model)
+            value = dice_metric(y_pred=val_outputs, y=val_labels).squeeze()
+            metric[0] += value * dice_metric.not_nans
+            metric[1] += dice_metric.not_nans
+        # synchronizes all processes and reduce results
+        print(f"metric in rank {hvd.rank()}: sum={metric[0].item()}, count={metric[1].item()}")
+        avg_metric = hvd.allreduce(metric, name="mean_dice")
+        if hvd.rank() == 0:
+            print(f"average metric: sum={avg_metric[0].item()}, count={avg_metric[1].item()}")
+            print("evaluation metric:", (avg_metric[0] / avg_metric[1]).item())
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-d", "--dir", default="./testdata", type=str, help="directory to create random data")
+    args = parser.parse_args()
+
+    evaluate(args=args)
+
+
+# Example script to execute this program only on the master node:
+# horovodrun -np 16 -H server1:4,server2:4,server3:4,server4:4 python unet_evaluation_horovod.py -d "./testdata"
+if __name__ == "__main__":
+    main()

testbed/Project-MONAI__MONAI/examples/distributed_training/unet_evaluation_workflows.py

@@ -0,0 +1,203 @@
+# Copyright 2020 MONAI Consortium
+# 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.
+
+"""
+This example shows how to execute distributed evaluation based on PyTorch native `DistributedDataParallel` module
+and MONAI workflows. It can run on several nodes with multiple GPU devices on every node.
+Main steps to set up the distributed evaluation:
+
+- Execute `torch.distributed.launch` to create processes on every node for every GPU.
+  It receives parameters as below:
+  `--nproc_per_node=NUM_GPUS_PER_NODE`
+  `--nnodes=NUM_NODES`
+  `--node_rank=INDEX_CURRENT_NODE`
+  `--master_addr="192.168.1.1"`
+  `--master_port=1234`
+  For more details, refer to https://github.com/pytorch/pytorch/blob/master/torch/distributed/launch.py.
+  Alternatively, we can also use `torch.multiprocessing.spawn` to start program, but it that case, need to handle
+  all the above parameters and compute `rank` manually, then set to `init_process_group`, etc.
+  `torch.distributed.launch` is even more efficient than `torch.multiprocessing.spawn`.
+- Use `init_process_group` to initialize every process, every GPU runs in a separate process with unique rank.
+  Here we use `NVIDIA NCCL` as the backend and must set `init_method="env://"` if use `torch.distributed.launch`.
+- Wrap the model with `DistributedDataParallel` after moving to expected device.
+- Put model file on every node, then load and map to expected GPU device in every process.
+- Wrap Dataset with `DistributedSampler`, disable the `shuffle` in sampler and DataLoader.
+- Add `StatsHandler` and `SegmentationSaver` to the master process which is `dist.get_rank() == 0`.
+- ignite can automatically reduce metrics for distributed evaluation, refer to:
+  https://github.com/pytorch/ignite/blob/v0.3.0/ignite/metrics/metric.py#L85
+
+Note:
+    `torch.distributed.launch` will launch `nnodes * nproc_per_node = world_size` processes in total.
+    Suggest setting exactly the same software environment for every node, especially `PyTorch`, `nccl`, etc.
+    A good practice is to use the same MONAI docker image for all nodes directly.
+    Example script to execute this program on every node:
+    python -m torch.distributed.launch --nproc_per_node=NUM_GPUS_PER_NODE
+           --nnodes=NUM_NODES --node_rank=INDEX_CURRENT_NODE
+           --master_addr="192.168.1.1" --master_port=1234
+           unet_evaluation_workflows.py -d DIR_OF_TESTDATA
+
+    This example was tested with [Ubuntu 16.04/20.04], [NCCL 2.6.3].
+
+Referring to: https://pytorch.org/tutorials/intermediate/ddp_tutorial.html
+
+"""
+
+import argparse
+import logging
+import os
+import sys
+from glob import glob
+
+import nibabel as nib
+import numpy as np
+import torch
+import torch.distributed as dist
+from ignite.metrics import Accuracy
+from torch.nn.parallel import DistributedDataParallel
+from torch.utils.data.distributed import DistributedSampler
+
+import monai
+from monai.data import DataLoader, Dataset, create_test_image_3d
+from monai.engines import SupervisedEvaluator
+from monai.handlers import CheckpointLoader, MeanDice, SegmentationSaver, StatsHandler
+from monai.inferers import SlidingWindowInferer
+from monai.transforms import (
+    Activationsd,
+    AsChannelFirstd,
+    AsDiscreted,
+    Compose,
+    KeepLargestConnectedComponentd,
+    LoadNiftid,
+    ScaleIntensityd,
+    ToTensord,
+)
+
+
+def evaluate(args):
+    if args.local_rank == 0 and not os.path.exists(args.dir):
+        # create 16 random image, mask paris for evaluation
+        print(f"generating synthetic data to {args.dir} (this may take a while)")
+        os.makedirs(args.dir)
+        # set random seed to generate same random data for every node
+        np.random.seed(seed=0)
+        for i in range(16):
+            im, seg = create_test_image_3d(128, 128, 128, num_seg_classes=1, channel_dim=-1)
+            n = nib.Nifti1Image(im, np.eye(4))
+            nib.save(n, os.path.join(args.dir, f"img{i:d}.nii.gz"))
+            n = nib.Nifti1Image(seg, np.eye(4))
+            nib.save(n, os.path.join(args.dir, f"seg{i:d}.nii.gz"))
+
+    # initialize the distributed evaluation process, every GPU runs in a process
+    dist.init_process_group(backend="nccl", init_method="env://")
+
+    images = sorted(glob(os.path.join(args.dir, "img*.nii.gz")))
+    segs = sorted(glob(os.path.join(args.dir, "seg*.nii.gz")))
+    val_files = [{"image": img, "label": seg} for img, seg in zip(images, segs)]
+
+    # define transforms for image and segmentation
+    val_transforms = Compose(
+        [
+            LoadNiftid(keys=["image", "label"]),
+            AsChannelFirstd(keys=["image", "label"], channel_dim=-1),
+            ScaleIntensityd(keys="image"),
+            ToTensord(keys=["image", "label"]),
+        ]
+    )
+
+    # create a evaluation data loader
+    val_ds = Dataset(data=val_files, transform=val_transforms)
+    # create a evaluation data sampler
+    val_sampler = DistributedSampler(val_ds, shuffle=False)
+    # sliding window inference need to input 1 image in every iteration
+    val_loader = DataLoader(val_ds, batch_size=1, shuffle=False, num_workers=2, pin_memory=True, sampler=val_sampler)
+
+    # create UNet, DiceLoss and Adam optimizer
+    device = torch.device(f"cuda:{args.local_rank}")
+    net = monai.networks.nets.UNet(
+        dimensions=3,
+        in_channels=1,
+        out_channels=1,
+        channels=(16, 32, 64, 128, 256),
+        strides=(2, 2, 2, 2),
+        num_res_units=2,
+    ).to(device)
+    # wrap the model with DistributedDataParallel module
+    net = DistributedDataParallel(net, device_ids=[args.local_rank])
+
+    val_post_transforms = Compose(
+        [
+            Activationsd(keys="pred", sigmoid=True),
+            AsDiscreted(keys="pred", threshold_values=True),
+            KeepLargestConnectedComponentd(keys="pred", applied_labels=[1]),
+        ]
+    )
+    val_handlers = [
+        CheckpointLoader(
+            load_path="./runs/checkpoint_epoch=4.pth",
+            load_dict={"net": net},
+            # config mapping to expected GPU device
+            map_location={"cuda:0": f"cuda:{args.local_rank}"},
+        ),
+    ]
+    if dist.get_rank() == 0:
+        logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+        val_handlers.extend(
+            [
+                StatsHandler(output_transform=lambda x: None),
+                SegmentationSaver(
+                    output_dir="./runs/",
+                    batch_transform=lambda batch: batch["image_meta_dict"],
+                    output_transform=lambda output: output["pred"],
+                ),
+            ]
+        )
+
+    evaluator = SupervisedEvaluator(
+        device=device,
+        val_data_loader=val_loader,
+        network=net,
+        inferer=SlidingWindowInferer(roi_size=(96, 96, 96), sw_batch_size=4, overlap=0.5),
+        post_transform=val_post_transforms,
+        key_val_metric={
+            "val_mean_dice": MeanDice(
+                include_background=True,
+                output_transform=lambda x: (x["pred"], x["label"]),
+                device=device,
+            )
+        },
+        additional_metrics={"val_acc": Accuracy(output_transform=lambda x: (x["pred"], x["label"]), device=device)},
+        val_handlers=val_handlers,
+        # if no FP16 support in GPU or PyTorch version < 1.6, will not enable AMP evaluation
+        amp=True if monai.config.get_torch_version_tuple() >= (1, 6) else False,
+    )
+    evaluator.run()
+    dist.destroy_process_group()
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-d", "--dir", default="./testdata", type=str, help="directory to create random data")
+    # must parse the command-line argument: ``--local_rank=LOCAL_PROCESS_RANK``, which will be provided by DDP
+    parser.add_argument("--local_rank", type=int)
+    args = parser.parse_args()
+
+    evaluate(args=args)
+
+
+# usage example(refer to https://github.com/pytorch/pytorch/blob/master/torch/distributed/launch.py):
+
+# python -m torch.distributed.launch --nproc_per_node=NUM_GPUS_PER_NODE
+#        --nnodes=NUM_NODES --node_rank=INDEX_CURRENT_NODE
+#        --master_addr="192.168.1.1" --master_port=1234
+#        unet_evaluation_workflows.py -d DIR_OF_TESTDATA
+
+if __name__ == "__main__":
+    main()

testbed/Project-MONAI__MONAI/examples/distributed_training/unet_training_ddp.py

@@ -0,0 +1,193 @@
+# Copyright 2020 MONAI Consortium
+# 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.
+
+"""
+This example shows how to execute distributed training based on PyTorch native `DistributedDataParallel` module.
+It can run on several nodes with multiple GPU devices on every node.
+Main steps to set up the distributed training:
+
+- Execute `torch.distributed.launch` to create processes on every node for every GPU.
+  It receives parameters as below:
+  `--nproc_per_node=NUM_GPUS_PER_NODE`
+  `--nnodes=NUM_NODES`
+  `--node_rank=INDEX_CURRENT_NODE`
+  `--master_addr="192.168.1.1"`
+  `--master_port=1234`
+  For more details, refer to https://github.com/pytorch/pytorch/blob/master/torch/distributed/launch.py.
+  Alternatively, we can also use `torch.multiprocessing.spawn` to start program, but it that case, need to handle
+  all the above parameters and compute `rank` manually, then set to `init_process_group`, etc.
+  `torch.distributed.launch` is even more efficient than `torch.multiprocessing.spawn` during training.
+- Use `init_process_group` to initialize every process, every GPU runs in a separate process with unique rank.
+  Here we use `NVIDIA NCCL` as the backend and must set `init_method="env://"` if use `torch.distributed.launch`.
+- Wrap the model with `DistributedDataParallel` after moving to expected device.
+- Wrap Dataset with `DistributedSampler`, and disable the `shuffle` in DataLoader.
+  Instead, shuffle data by `train_sampler.set_epoch(epoch)` before every epoch.
+
+Note:
+    `torch.distributed.launch` will launch `nnodes * nproc_per_node = world_size` processes in total.
+    Suggest setting exactly the same software environment for every node, especially `PyTorch`, `nccl`, etc.
+    A good practice is to use the same MONAI docker image for all nodes directly.
+    Example script to execute this program on every node:
+    python -m torch.distributed.launch --nproc_per_node=NUM_GPUS_PER_NODE
+           --nnodes=NUM_NODES --node_rank=INDEX_CURRENT_NODE
+           --master_addr="192.168.1.1" --master_port=1234
+           unet_training_ddp.py -d DIR_OF_TESTDATA
+
+    This example was tested with [Ubuntu 16.04/20.04], [NCCL 2.6.3].
+
+Referring to: https://pytorch.org/tutorials/intermediate/ddp_tutorial.html
+
+"""
+
+import argparse
+import os
+import sys
+from glob import glob
+
+import nibabel as nib
+import numpy as np
+import torch
+import torch.distributed as dist
+from torch.nn.parallel import DistributedDataParallel
+from torch.utils.data.distributed import DistributedSampler
+
+import monai
+from monai.data import DataLoader, Dataset, create_test_image_3d
+from monai.transforms import (
+    AsChannelFirstd,
+    Compose,
+    LoadNiftid,
+    RandCropByPosNegLabeld,
+    RandRotate90d,
+    ScaleIntensityd,
+    ToTensord,
+)
+
+
+def train(args):
+    # disable logging for processes execpt 0 on every node
+    if args.local_rank != 0:
+        f = open(os.devnull, "w")
+        sys.stdout = sys.stderr = f
+    elif not os.path.exists(args.dir):
+        # create 40 random image, mask paris for training
+        print(f"generating synthetic data to {args.dir} (this may take a while)")
+        os.makedirs(args.dir)
+        # set random seed to generate same random data for every node
+        np.random.seed(seed=0)
+        for i in range(40):
+            im, seg = create_test_image_3d(128, 128, 128, num_seg_classes=1, channel_dim=-1)
+            n = nib.Nifti1Image(im, np.eye(4))
+            nib.save(n, os.path.join(args.dir, f"img{i:d}.nii.gz"))
+            n = nib.Nifti1Image(seg, np.eye(4))
+            nib.save(n, os.path.join(args.dir, f"seg{i:d}.nii.gz"))
+
+    # initialize the distributed training process, every GPU runs in a process
+    dist.init_process_group(backend="nccl", init_method="env://")
+
+    images = sorted(glob(os.path.join(args.dir, "img*.nii.gz")))
+    segs = sorted(glob(os.path.join(args.dir, "seg*.nii.gz")))
+    train_files = [{"img": img, "seg": seg} for img, seg in zip(images, segs)]
+
+    # define transforms for image and segmentation
+    train_transforms = Compose(
+        [
+            LoadNiftid(keys=["img", "seg"]),
+            AsChannelFirstd(keys=["img", "seg"], channel_dim=-1),
+            ScaleIntensityd(keys="img"),
+            RandCropByPosNegLabeld(
+                keys=["img", "seg"], label_key="seg", spatial_size=[96, 96, 96], pos=1, neg=1, num_samples=4
+            ),
+            RandRotate90d(keys=["img", "seg"], prob=0.5, spatial_axes=[0, 2]),
+            ToTensord(keys=["img", "seg"]),
+        ]
+    )
+
+    # create a training data loader
+    train_ds = Dataset(data=train_files, transform=train_transforms)
+    # create a training data sampler
+    train_sampler = DistributedSampler(train_ds)
+    # use batch_size=2 to load images and use RandCropByPosNegLabeld to generate 2 x 4 images for network training
+    train_loader = DataLoader(
+        train_ds,
+        batch_size=2,
+        shuffle=False,
+        num_workers=2,
+        pin_memory=True,
+        sampler=train_sampler,
+    )
+
+    # create UNet, DiceLoss and Adam optimizer
+    device = torch.device(f"cuda:{args.local_rank}")
+    model = monai.networks.nets.UNet(
+        dimensions=3,
+        in_channels=1,
+        out_channels=1,
+        channels=(16, 32, 64, 128, 256),
+        strides=(2, 2, 2, 2),
+        num_res_units=2,
+    ).to(device)
+    loss_function = monai.losses.DiceLoss(sigmoid=True).to(device)
+    optimizer = torch.optim.Adam(model.parameters(), 1e-3)
+    # wrap the model with DistributedDataParallel module
+    model = DistributedDataParallel(model, device_ids=[args.local_rank])
+
+    # start a typical PyTorch training
+    epoch_loss_values = list()
+    for epoch in range(5):
+        print("-" * 10)
+        print(f"epoch {epoch + 1}/{5}")
+        model.train()
+        epoch_loss = 0
+        step = 0
+        train_sampler.set_epoch(epoch)
+        for batch_data in train_loader:
+            step += 1
+            inputs, labels = batch_data["img"].to(device), batch_data["seg"].to(device)
+            optimizer.zero_grad()
+            outputs = model(inputs)
+            loss = loss_function(outputs, labels)
+            loss.backward()
+            optimizer.step()
+            epoch_loss += loss.item()
+            epoch_len = len(train_ds) // train_loader.batch_size
+            print(f"{step}/{epoch_len}, train_loss: {loss.item():.4f}")
+        epoch_loss /= step
+        epoch_loss_values.append(epoch_loss)
+        print(f"epoch {epoch + 1} average loss: {epoch_loss:.4f}")
+    print(f"train completed, epoch losses: {epoch_loss_values}")
+    if dist.get_rank() == 0:
+        # all processes should see same parameters as they all start from same
+        # random parameters and gradients are synchronized in backward passes,
+        # therefore, saving it in one process is sufficient
+        torch.save(model.state_dict(), "final_model.pth")
+    dist.destroy_process_group()
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-d", "--dir", default="./testdata", type=str, help="directory to create random data")
+    # must parse the command-line argument: ``--local_rank=LOCAL_PROCESS_RANK``, which will be provided by DDP
+    parser.add_argument("--local_rank", type=int)
+    args = parser.parse_args()
+
+    train(args=args)
+
+
+# usage example(refer to https://github.com/pytorch/pytorch/blob/master/torch/distributed/launch.py):
+
+# python -m torch.distributed.launch --nproc_per_node=NUM_GPUS_PER_NODE
+#        --nnodes=NUM_NODES --node_rank=INDEX_CURRENT_NODE
+#        --master_addr="192.168.1.1" --master_port=1234
+#        unet_training_ddp.py -d DIR_OF_TESTDATA
+
+if __name__ == "__main__":
+    main()

testbed/Project-MONAI__MONAI/examples/distributed_training/unet_training_horovod.py

@@ -0,0 +1,193 @@
+# Copyright 2020 MONAI Consortium
+# 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.
+
+"""
+This example shows how to execute distributed training based on Horovod APIs.
+It can run on several nodes with multiple GPU devices on every node.
+Main steps to set up the distributed training:
+
+- Install Horovod referring to the guide: https://github.com/horovod/horovod/blob/master/docs/gpus.rst
+  If using MONAI docker, which already has NCCL and MPI, can quickly install Horovod with command:
+  `HOROVOD_NCCL_INCLUDE=/usr/include HOROVOD_NCCL_LIB=/usr/lib/x86_64-linux-gnu HOROVOD_GPU_OPERATIONS=NCCL \
+  pip install --no-cache-dir horovod`
+- Set SSH permissions for root login without password at all nodes except master, referring to:
+  http://www.linuxproblem.org/art_9.html
+- Run `hvd.init()` to initialize Horovod.
+- Pin each GPU to a single process to avoid resource contention, use `hvd.local_rank()` to get GPU index.
+  And use `hvd.rank()` to get the overall rank index.
+- Wrap Dataset with `DistributedSampler`, and disable the `shuffle` in DataLoader.
+  Instead, shuffle data by `train_sampler.set_epoch(epoch)` before every epoch.
+- Wrap the optimizer in hvd.DistributedOptimizer. The distributed optimizer delegates gradient
+  computation to the original optimizer, averages gradients using allreduce or allgather,
+  and then applies those averaged gradients.
+- Broadcast the initial variable states from rank 0 to all other processes.
+
+Note:
+    Suggest setting exactly the same software environment for every node, especially `mpi`, `nccl`, etc.
+    A good practice is to use the same MONAI docker image for all nodes directly, if using docker, need
+    to set SSH permissions both at the node and in docker, referring to Horovod guide for more details:
+    https://github.com/horovod/horovod/blob/master/docs/docker.rst
+
+    Example script to execute this program, only need to run on the master node:
+    `horovodrun -np 16 -H server1:4,server2:4,server3:4,server4:4 python unet_training_horovod.py -d "./testdata"`
+
+    This example was tested with [Ubuntu 16.04/20.04], [NCCL 2.6.3], [horovod 0.19.5].
+
+Referring to: https://github.com/horovod/horovod/blob/master/examples/pytorch_mnist.py
+
+"""
+
+import argparse
+import os
+import sys
+from glob import glob
+
+import horovod.torch as hvd
+import nibabel as nib
+import numpy as np
+import torch
+import torch.multiprocessing as mp
+from torch.utils.data.distributed import DistributedSampler
+
+import monai
+from monai.data import DataLoader, Dataset, create_test_image_3d
+from monai.transforms import (
+    AsChannelFirstd,
+    Compose,
+    LoadNiftid,
+    RandCropByPosNegLabeld,
+    RandRotate90d,
+    ScaleIntensityd,
+    ToTensord,
+)
+
+
+def train(args):
+    # initialize Horovod library
+    hvd.init()
+    # Horovod limits CPU threads to be used per worker
+    torch.set_num_threads(1)
+    # disable logging for processes execpt 0 on every node
+    if hvd.local_rank() != 0:
+        f = open(os.devnull, "w")
+        sys.stdout = sys.stderr = f
+    elif not os.path.exists(args.dir):
+        # create 40 random image, mask paris on master node for training
+        print(f"generating synthetic data to {args.dir} (this may take a while)")
+        os.makedirs(args.dir)
+        # set random seed to generate same random data for every node
+        np.random.seed(seed=0)
+        for i in range(40):
+            im, seg = create_test_image_3d(128, 128, 128, num_seg_classes=1, channel_dim=-1)
+            n = nib.Nifti1Image(im, np.eye(4))
+            nib.save(n, os.path.join(args.dir, f"img{i:d}.nii.gz"))
+            n = nib.Nifti1Image(seg, np.eye(4))
+            nib.save(n, os.path.join(args.dir, f"seg{i:d}.nii.gz"))
+
+    images = sorted(glob(os.path.join(args.dir, "img*.nii.gz")))
+    segs = sorted(glob(os.path.join(args.dir, "seg*.nii.gz")))
+    train_files = [{"img": img, "seg": seg} for img, seg in zip(images, segs)]
+
+    # define transforms for image and segmentation
+    train_transforms = Compose(
+        [
+            LoadNiftid(keys=["img", "seg"]),
+            AsChannelFirstd(keys=["img", "seg"], channel_dim=-1),
+            ScaleIntensityd(keys="img"),
+            RandCropByPosNegLabeld(
+                keys=["img", "seg"], label_key="seg", spatial_size=[96, 96, 96], pos=1, neg=1, num_samples=4
+            ),
+            RandRotate90d(keys=["img", "seg"], prob=0.5, spatial_axes=[0, 2]),
+            ToTensord(keys=["img", "seg"]),
+        ]
+    )
+
+    # create a training data loader
+    train_ds = Dataset(data=train_files, transform=train_transforms)
+    # create a training data sampler
+    train_sampler = DistributedSampler(train_ds, num_replicas=hvd.size(), rank=hvd.rank())
+    # when supported, use "forkserver" to spawn dataloader workers instead of "fork" to prevent
+    # issues with Infiniband implementations that are not fork-safe
+    multiprocessing_context = None
+    if hasattr(mp, "_supports_context") and mp._supports_context and "forkserver" in mp.get_all_start_methods():
+        multiprocessing_context = "forkserver"
+    # use batch_size=2 to load images and use RandCropByPosNegLabeld to generate 2 x 4 images for network training
+    train_loader = DataLoader(
+        train_ds,
+        batch_size=2,
+        shuffle=False,
+        num_workers=2,
+        pin_memory=True,
+        sampler=train_sampler,
+        multiprocessing_context=multiprocessing_context,
+    )
+
+    # create UNet, DiceLoss and Adam optimizer
+    device = torch.device(f"cuda:{hvd.local_rank()}")
+    model = monai.networks.nets.UNet(
+        dimensions=3,
+        in_channels=1,
+        out_channels=1,
+        channels=(16, 32, 64, 128, 256),
+        strides=(2, 2, 2, 2),
+        num_res_units=2,
+    ).to(device)
+    loss_function = monai.losses.DiceLoss(sigmoid=True).to(device)
+    optimizer = torch.optim.Adam(model.parameters(), 1e-3)
+    # Horovod broadcasts parameters & optimizer state
+    hvd.broadcast_parameters(model.state_dict(), root_rank=0)
+    hvd.broadcast_optimizer_state(optimizer, root_rank=0)
+    # Horovod wraps optimizer with DistributedOptimizer
+    optimizer = hvd.DistributedOptimizer(optimizer, named_parameters=model.named_parameters())
+
+    # start a typical PyTorch training
+    epoch_loss_values = list()
+    for epoch in range(5):
+        print("-" * 10)
+        print(f"epoch {epoch + 1}/{5}")
+        model.train()
+        epoch_loss = 0
+        step = 0
+        train_sampler.set_epoch(epoch)
+        for batch_data in train_loader:
+            step += 1
+            inputs, labels = batch_data["img"].to(device), batch_data["seg"].to(device)
+            optimizer.zero_grad()
+            outputs = model(inputs)
+            loss = loss_function(outputs, labels)
+            loss.backward()
+            optimizer.step()
+            epoch_loss += loss.item()
+            epoch_len = len(train_ds) // train_loader.batch_size
+            print(f"{step}/{epoch_len}, train_loss: {loss.item():.4f}")
+        epoch_loss /= step
+        epoch_loss_values.append(epoch_loss)
+        print(f"epoch {epoch + 1} average loss: {epoch_loss:.4f}")
+    print(f"train completed, epoch losses: {epoch_loss_values}")
+    if hvd.rank() == 0:
+        # all processes should see same parameters as they all start from same
+        # random parameters and gradients are synchronized in backward passes,
+        # therefore, saving it in one process is sufficient
+        torch.save(model.state_dict(), "final_model.pth")
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-d", "--dir", default="./testdata", type=str, help="directory to create random data")
+    args = parser.parse_args()
+
+    train(args=args)
+
+
+# Example script to execute this program only on the master node:
+# horovodrun -np 16 -H server1:4,server2:4,server3:4,server4:4 python unet_training_horovod.py -d "./testdata"
+if __name__ == "__main__":
+    main()

testbed/Project-MONAI__MONAI/examples/distributed_training/unet_training_workflows.py

@@ -0,0 +1,206 @@
+# Copyright 2020 MONAI Consortium
+# 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.
+
+"""
+This example shows how to execute distributed training based on PyTorch native `DistributedDataParallel` module
+and MONAI workflows. It can run on several nodes with multiple GPU devices on every node.
+Main steps to set up the distributed training:
+
+- Execute `torch.distributed.launch` to create processes on every node for every GPU.
+  It receives parameters as below:
+  `--nproc_per_node=NUM_GPUS_PER_NODE`
+  `--nnodes=NUM_NODES`
+  `--node_rank=INDEX_CURRENT_NODE`
+  `--master_addr="192.168.1.1"`
+  `--master_port=1234`
+  For more details, refer to https://github.com/pytorch/pytorch/blob/master/torch/distributed/launch.py.
+  Alternatively, we can also use `torch.multiprocessing.spawn` to start program, but it that case, need to handle
+  all the above parameters and compute `rank` manually, then set to `init_process_group`, etc.
+  `torch.distributed.launch` is even more efficient than `torch.multiprocessing.spawn` during training.
+- Use `init_process_group` to initialize every process, every GPU runs in a separate process with unique rank.
+  Here we use `NVIDIA NCCL` as the backend and must set `init_method="env://"` if use `torch.distributed.launch`.
+- Wrap the model with `DistributedDataParallel` after moving to expected device.
+- Wrap Dataset with `DistributedSampler`, and disable the `shuffle` in DataLoader.
+  Instead, `SupervisedTrainer` shuffles data by `train_sampler.set_epoch(epoch)` before every epoch.
+- Add `StatsHandler` and `CheckpointHandler` to the master process which is `dist.get_rank() == 0`.
+- ignite can automatically reduce metrics for distributed training, refer to:
+  https://github.com/pytorch/ignite/blob/v0.3.0/ignite/metrics/metric.py#L85
+
+Note:
+    `torch.distributed.launch` will launch `nnodes * nproc_per_node = world_size` processes in total.
+    Suggest setting exactly the same software environment for every node, especially `PyTorch`, `nccl`, etc.
+    A good practice is to use the same MONAI docker image for all nodes directly.
+    Example script to execute this program on every node:
+    python -m torch.distributed.launch --nproc_per_node=NUM_GPUS_PER_NODE
+           --nnodes=NUM_NODES --node_rank=INDEX_CURRENT_NODE
+           --master_addr="192.168.1.1" --master_port=1234
+           unet_training_workflows.py -d DIR_OF_TESTDATA
+
+    This example was tested with [Ubuntu 16.04/20.04], [NCCL 2.6.3].
+
+Referring to: https://pytorch.org/tutorials/intermediate/ddp_tutorial.html
+
+"""
+
+import argparse
+import logging
+import os
+import sys
+from glob import glob
+
+import nibabel as nib
+import numpy as np
+import torch
+import torch.distributed as dist
+from ignite.metrics import Accuracy
+from torch.nn.parallel import DistributedDataParallel
+from torch.utils.data.distributed import DistributedSampler
+
+import monai
+from monai.data import DataLoader, Dataset, create_test_image_3d
+from monai.engines import SupervisedTrainer
+from monai.handlers import CheckpointSaver, LrScheduleHandler, StatsHandler
+from monai.inferers import SimpleInferer
+from monai.transforms import (
+    Activationsd,
+    AsChannelFirstd,
+    AsDiscreted,
+    Compose,
+    KeepLargestConnectedComponentd,
+    LoadNiftid,
+    RandCropByPosNegLabeld,
+    RandRotate90d,
+    ScaleIntensityd,
+    ToTensord,
+)
+
+
+def train(args):
+    if args.local_rank == 0 and not os.path.exists(args.dir):
+        # create 40 random image, mask paris for training
+        print(f"generating synthetic data to {args.dir} (this may take a while)")
+        os.makedirs(args.dir)
+        # set random seed to generate same random data for every node
+        np.random.seed(seed=0)
+        for i in range(40):
+            im, seg = create_test_image_3d(128, 128, 128, num_seg_classes=1, channel_dim=-1)
+            n = nib.Nifti1Image(im, np.eye(4))
+            nib.save(n, os.path.join(args.dir, f"img{i:d}.nii.gz"))
+            n = nib.Nifti1Image(seg, np.eye(4))
+            nib.save(n, os.path.join(args.dir, f"seg{i:d}.nii.gz"))
+
+    # initialize the distributed training process, every GPU runs in a process
+    dist.init_process_group(backend="nccl", init_method="env://")
+
+    images = sorted(glob(os.path.join(args.dir, "img*.nii.gz")))
+    segs = sorted(glob(os.path.join(args.dir, "seg*.nii.gz")))
+    train_files = [{"image": img, "label": seg} for img, seg in zip(images, segs)]
+
+    # define transforms for image and segmentation
+    train_transforms = Compose(
+        [
+            LoadNiftid(keys=["image", "label"]),
+            AsChannelFirstd(keys=["image", "label"], channel_dim=-1),
+            ScaleIntensityd(keys="image"),
+            RandCropByPosNegLabeld(
+                keys=["image", "label"], label_key="label", spatial_size=[96, 96, 96], pos=1, neg=1, num_samples=4
+            ),
+            RandRotate90d(keys=["image", "label"], prob=0.5, spatial_axes=[0, 2]),
+            ToTensord(keys=["image", "label"]),
+        ]
+    )
+
+    # create a training data loader
+    train_ds = Dataset(data=train_files, transform=train_transforms)
+    # create a training data sampler
+    train_sampler = DistributedSampler(train_ds)
+    # use batch_size=2 to load images and use RandCropByPosNegLabeld to generate 2 x 4 images for network training
+    train_loader = DataLoader(
+        train_ds,
+        batch_size=2,
+        shuffle=False,
+        num_workers=2,
+        pin_memory=True,
+        sampler=train_sampler,
+    )
+
+    # create UNet, DiceLoss and Adam optimizer
+    device = torch.device(f"cuda:{args.local_rank}")
+    net = monai.networks.nets.UNet(
+        dimensions=3,
+        in_channels=1,
+        out_channels=1,
+        channels=(16, 32, 64, 128, 256),
+        strides=(2, 2, 2, 2),
+        num_res_units=2,
+    ).to(device)
+    loss = monai.losses.DiceLoss(sigmoid=True).to(device)
+    opt = torch.optim.Adam(net.parameters(), 1e-3)
+    lr_scheduler = torch.optim.lr_scheduler.StepLR(opt, step_size=2, gamma=0.1)
+    # wrap the model with DistributedDataParallel module
+    net = DistributedDataParallel(net, device_ids=[args.local_rank])
+
+    train_post_transforms = Compose(
+        [
+            Activationsd(keys="pred", sigmoid=True),
+            AsDiscreted(keys="pred", threshold_values=True),
+            KeepLargestConnectedComponentd(keys="pred", applied_labels=[1]),
+        ]
+    )
+    train_handlers = [
+        LrScheduleHandler(lr_scheduler=lr_scheduler, print_lr=True),
+    ]
+    if dist.get_rank() == 0:
+        logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+        train_handlers.extend(
+            [
+                StatsHandler(tag_name="train_loss", output_transform=lambda x: x["loss"]),
+                CheckpointSaver(save_dir="./runs/", save_dict={"net": net, "opt": opt}, save_interval=2),
+            ]
+        )
+
+    trainer = SupervisedTrainer(
+        device=device,
+        max_epochs=5,
+        train_data_loader=train_loader,
+        network=net,
+        optimizer=opt,
+        loss_function=loss,
+        inferer=SimpleInferer(),
+        # if no FP16 support in GPU or PyTorch version < 1.6, will not enable AMP evaluation
+        amp=True if monai.config.get_torch_version_tuple() >= (1, 6) else False,
+        post_transform=train_post_transforms,
+        key_train_metric={"train_acc": Accuracy(output_transform=lambda x: (x["pred"], x["label"]), device=device)},
+        train_handlers=train_handlers,
+    )
+    trainer.run()
+    dist.destroy_process_group()
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-d", "--dir", default="./testdata", type=str, help="directory to create random data")
+    # must parse the command-line argument: ``--local_rank=LOCAL_PROCESS_RANK``, which will be provided by DDP
+    parser.add_argument("--local_rank", type=int)
+    args = parser.parse_args()
+
+    train(args=args)
+
+
+# usage example(refer to https://github.com/pytorch/pytorch/blob/master/torch/distributed/launch.py):
+
+# python -m torch.distributed.launch --nproc_per_node=NUM_GPUS_PER_NODE
+#        --nnodes=NUM_NODES --node_rank=INDEX_CURRENT_NODE
+#        --master_addr="192.168.1.1" --master_port=1234
+#        unet_training_workflows.py -d DIR_OF_TESTDATA
+
+if __name__ == "__main__":
+    main()

testbed/Project-MONAI__MONAI/examples/segmentation_3d/unet_evaluation_array.py

@@ -0,0 +1,89 @@
+# Copyright 2020 MONAI Consortium
+# 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 logging
+import os
+import sys
+import tempfile
+from glob import glob
+
+import nibabel as nib
+import numpy as np
+import torch
+from torch.utils.data import DataLoader
+
+from monai import config
+from monai.data import NiftiDataset, NiftiSaver, create_test_image_3d
+from monai.inferers import sliding_window_inference
+from monai.metrics import DiceMetric
+from monai.networks.nets import UNet
+from monai.transforms import AddChannel, Compose, ScaleIntensity, ToTensor
+
+
+def main(tempdir):
+    config.print_config()
+    logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+
+    print(f"generating synthetic data to {tempdir} (this may take a while)")
+    for i in range(5):
+        im, seg = create_test_image_3d(128, 128, 128, num_seg_classes=1)
+
+        n = nib.Nifti1Image(im, np.eye(4))
+        nib.save(n, os.path.join(tempdir, f"im{i:d}.nii.gz"))
+
+        n = nib.Nifti1Image(seg, np.eye(4))
+        nib.save(n, os.path.join(tempdir, f"seg{i:d}.nii.gz"))
+
+    images = sorted(glob(os.path.join(tempdir, "im*.nii.gz")))
+    segs = sorted(glob(os.path.join(tempdir, "seg*.nii.gz")))
+
+    # define transforms for image and segmentation
+    imtrans = Compose([ScaleIntensity(), AddChannel(), ToTensor()])
+    segtrans = Compose([AddChannel(), ToTensor()])
+    val_ds = NiftiDataset(images, segs, transform=imtrans, seg_transform=segtrans, image_only=False)
+    # sliding window inference for one image at every iteration
+    val_loader = DataLoader(val_ds, batch_size=1, num_workers=1, pin_memory=torch.cuda.is_available())
+    dice_metric = DiceMetric(include_background=True, to_onehot_y=False, sigmoid=True, reduction="mean")
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = UNet(
+        dimensions=3,
+        in_channels=1,
+        out_channels=1,
+        channels=(16, 32, 64, 128, 256),
+        strides=(2, 2, 2, 2),
+        num_res_units=2,
+    ).to(device)
+
+    model.load_state_dict(torch.load("best_metric_model_segmentation3d_array.pth"))
+    model.eval()
+    with torch.no_grad():
+        metric_sum = 0.0
+        metric_count = 0
+        saver = NiftiSaver(output_dir="./output")
+        for val_data in val_loader:
+            val_images, val_labels = val_data[0].to(device), val_data[1].to(device)
+            # define sliding window size and batch size for windows inference
+            roi_size = (96, 96, 96)
+            sw_batch_size = 4
+            val_outputs = sliding_window_inference(val_images, roi_size, sw_batch_size, model)
+            value = dice_metric(y_pred=val_outputs, y=val_labels)
+            metric_count += len(value)
+            metric_sum += value.item() * len(value)
+            val_outputs = (val_outputs.sigmoid() >= 0.5).float()
+            saver.save_batch(val_outputs, val_data[2])
+        metric = metric_sum / metric_count
+        print("evaluation metric:", metric)
+
+
+if __name__ == "__main__":
+    with tempfile.TemporaryDirectory() as tempdir:
+        main(tempdir)

testbed/Project-MONAI__MONAI/examples/segmentation_3d/unet_evaluation_dict.py

@@ -0,0 +1,103 @@
+# Copyright 2020 MONAI Consortium
+# 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 logging
+import os
+import sys
+import tempfile
+from glob import glob
+
+import nibabel as nib
+import numpy as np
+import torch
+from torch.utils.data import DataLoader
+
+import monai
+from monai.data import NiftiSaver, create_test_image_3d, list_data_collate
+from monai.engines import get_devices_spec
+from monai.inferers import sliding_window_inference
+from monai.metrics import DiceMetric
+from monai.networks.nets import UNet
+from monai.transforms import AsChannelFirstd, Compose, LoadNiftid, ScaleIntensityd, ToTensord
+
+
+def main(tempdir):
+    monai.config.print_config()
+    logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+
+    print(f"generating synthetic data to {tempdir} (this may take a while)")
+    for i in range(5):
+        im, seg = create_test_image_3d(128, 128, 128, num_seg_classes=1, channel_dim=-1)
+
+        n = nib.Nifti1Image(im, np.eye(4))
+        nib.save(n, os.path.join(tempdir, f"im{i:d}.nii.gz"))
+
+        n = nib.Nifti1Image(seg, np.eye(4))
+        nib.save(n, os.path.join(tempdir, f"seg{i:d}.nii.gz"))
+
+    images = sorted(glob(os.path.join(tempdir, "im*.nii.gz")))
+    segs = sorted(glob(os.path.join(tempdir, "seg*.nii.gz")))
+    val_files = [{"img": img, "seg": seg} for img, seg in zip(images, segs)]
+
+    # define transforms for image and segmentation
+    val_transforms = Compose(
+        [
+            LoadNiftid(keys=["img", "seg"]),
+            AsChannelFirstd(keys=["img", "seg"], channel_dim=-1),
+            ScaleIntensityd(keys="img"),
+            ToTensord(keys=["img", "seg"]),
+        ]
+    )
+    val_ds = monai.data.Dataset(data=val_files, transform=val_transforms)
+    # sliding window inference need to input 1 image in every iteration
+    val_loader = DataLoader(val_ds, batch_size=1, num_workers=4, collate_fn=list_data_collate)
+    dice_metric = DiceMetric(include_background=True, to_onehot_y=False, sigmoid=True, reduction="mean")
+
+    # try to use all the available GPUs
+    devices = get_devices_spec(None)
+    model = UNet(
+        dimensions=3,
+        in_channels=1,
+        out_channels=1,
+        channels=(16, 32, 64, 128, 256),
+        strides=(2, 2, 2, 2),
+        num_res_units=2,
+    ).to(devices[0])
+
+    model.load_state_dict(torch.load("best_metric_model_segmentation3d_dict.pth"))
+
+    # if we have multiple GPUs, set data parallel to execute sliding window inference
+    if len(devices) > 1:
+        model = torch.nn.DataParallel(model, device_ids=devices)
+
+    model.eval()
+    with torch.no_grad():
+        metric_sum = 0.0
+        metric_count = 0
+        saver = NiftiSaver(output_dir="./output")
+        for val_data in val_loader:
+            val_images, val_labels = val_data["img"].to(devices[0]), val_data["seg"].to(devices[0])
+            # define sliding window size and batch size for windows inference
+            roi_size = (96, 96, 96)
+            sw_batch_size = 4
+            val_outputs = sliding_window_inference(val_images, roi_size, sw_batch_size, model)
+            value = dice_metric(y_pred=val_outputs, y=val_labels)
+            metric_count += len(value)
+            metric_sum += value.item() * len(value)
+            val_outputs = (val_outputs.sigmoid() >= 0.5).float()
+            saver.save_batch(val_outputs, val_data["img_meta_dict"])
+        metric = metric_sum / metric_count
+        print("evaluation metric:", metric)
+
+
+if __name__ == "__main__":
+    with tempfile.TemporaryDirectory() as tempdir:
+        main(tempdir)

testbed/Project-MONAI__MONAI/examples/segmentation_3d/unet_training_array.py

@@ -0,0 +1,167 @@
+# Copyright 2020 MONAI Consortium
+# 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 logging
+import os
+import sys
+import tempfile
+from glob import glob
+
+import nibabel as nib
+import numpy as np
+import torch
+from torch.utils.data import DataLoader
+from torch.utils.tensorboard import SummaryWriter
+
+import monai
+from monai.data import NiftiDataset, create_test_image_3d
+from monai.inferers import sliding_window_inference
+from monai.metrics import DiceMetric
+from monai.transforms import AddChannel, Compose, RandRotate90, RandSpatialCrop, ScaleIntensity, ToTensor
+from monai.visualize import plot_2d_or_3d_image
+
+
+def main(tempdir):
+    monai.config.print_config()
+    logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+
+    # create a temporary directory and 40 random image, mask pairs
+    print(f"generating synthetic data to {tempdir} (this may take a while)")
+    for i in range(40):
+        im, seg = create_test_image_3d(128, 128, 128, num_seg_classes=1)
+
+        n = nib.Nifti1Image(im, np.eye(4))
+        nib.save(n, os.path.join(tempdir, f"im{i:d}.nii.gz"))
+
+        n = nib.Nifti1Image(seg, np.eye(4))
+        nib.save(n, os.path.join(tempdir, f"seg{i:d}.nii.gz"))
+
+    images = sorted(glob(os.path.join(tempdir, "im*.nii.gz")))
+    segs = sorted(glob(os.path.join(tempdir, "seg*.nii.gz")))
+
+    # define transforms for image and segmentation
+    train_imtrans = Compose(
+        [
+            ScaleIntensity(),
+            AddChannel(),
+            RandSpatialCrop((96, 96, 96), random_size=False),
+            RandRotate90(prob=0.5, spatial_axes=(0, 2)),
+            ToTensor(),
+        ]
+    )
+    train_segtrans = Compose(
+        [
+            AddChannel(),
+            RandSpatialCrop((96, 96, 96), random_size=False),
+            RandRotate90(prob=0.5, spatial_axes=(0, 2)),
+            ToTensor(),
+        ]
+    )
+    val_imtrans = Compose([ScaleIntensity(), AddChannel(), ToTensor()])
+    val_segtrans = Compose([AddChannel(), ToTensor()])
+
+    # define nifti dataset, data loader
+    check_ds = NiftiDataset(images, segs, transform=train_imtrans, seg_transform=train_segtrans)
+    check_loader = DataLoader(check_ds, batch_size=10, num_workers=2, pin_memory=torch.cuda.is_available())
+    im, seg = monai.utils.misc.first(check_loader)
+    print(im.shape, seg.shape)
+
+    # create a training data loader
+    train_ds = NiftiDataset(images[:20], segs[:20], transform=train_imtrans, seg_transform=train_segtrans)
+    train_loader = DataLoader(train_ds, batch_size=4, shuffle=True, num_workers=8, pin_memory=torch.cuda.is_available())
+    # create a validation data loader
+    val_ds = NiftiDataset(images[-20:], segs[-20:], transform=val_imtrans, seg_transform=val_segtrans)
+    val_loader = DataLoader(val_ds, batch_size=1, num_workers=4, pin_memory=torch.cuda.is_available())
+    dice_metric = DiceMetric(include_background=True, to_onehot_y=False, sigmoid=True, reduction="mean")
+
+    # create UNet, DiceLoss and Adam optimizer
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = monai.networks.nets.UNet(
+        dimensions=3,
+        in_channels=1,
+        out_channels=1,
+        channels=(16, 32, 64, 128, 256),
+        strides=(2, 2, 2, 2),
+        num_res_units=2,
+    ).to(device)
+    loss_function = monai.losses.DiceLoss(sigmoid=True)
+    optimizer = torch.optim.Adam(model.parameters(), 1e-3)
+
+    # start a typical PyTorch training
+    val_interval = 2
+    best_metric = -1
+    best_metric_epoch = -1
+    epoch_loss_values = list()
+    metric_values = list()
+    writer = SummaryWriter()
+    for epoch in range(5):
+        print("-" * 10)
+        print(f"epoch {epoch + 1}/{5}")
+        model.train()
+        epoch_loss = 0
+        step = 0
+        for batch_data in train_loader:
+            step += 1
+            inputs, labels = batch_data[0].to(device), batch_data[1].to(device)
+            optimizer.zero_grad()
+            outputs = model(inputs)
+            loss = loss_function(outputs, labels)
+            loss.backward()
+            optimizer.step()
+            epoch_loss += loss.item()
+            epoch_len = len(train_ds) // train_loader.batch_size
+            print(f"{step}/{epoch_len}, train_loss: {loss.item():.4f}")
+            writer.add_scalar("train_loss", loss.item(), epoch_len * epoch + step)
+        epoch_loss /= step
+        epoch_loss_values.append(epoch_loss)
+        print(f"epoch {epoch + 1} average loss: {epoch_loss:.4f}")
+
+        if (epoch + 1) % val_interval == 0:
+            model.eval()
+            with torch.no_grad():
+                metric_sum = 0.0
+                metric_count = 0
+                val_images = None
+                val_labels = None
+                val_outputs = None
+                for val_data in val_loader:
+                    val_images, val_labels = val_data[0].to(device), val_data[1].to(device)
+                    roi_size = (96, 96, 96)
+                    sw_batch_size = 4
+                    val_outputs = sliding_window_inference(val_images, roi_size, sw_batch_size, model)
+                    value = dice_metric(y_pred=val_outputs, y=val_labels)
+                    metric_count += len(value)
+                    metric_sum += value.item() * len(value)
+                metric = metric_sum / metric_count
+                metric_values.append(metric)
+                if metric > best_metric:
+                    best_metric = metric
+                    best_metric_epoch = epoch + 1
+                    torch.save(model.state_dict(), "best_metric_model_segmentation3d_array.pth")
+                    print("saved new best metric model")
+                print(
+                    "current epoch: {} current mean dice: {:.4f} best mean dice: {:.4f} at epoch {}".format(
+                        epoch + 1, metric, best_metric, best_metric_epoch
+                    )
+                )
+                writer.add_scalar("val_mean_dice", metric, epoch + 1)
+                # plot the last model output as GIF image in TensorBoard with the corresponding image and label
+                plot_2d_or_3d_image(val_images, epoch + 1, writer, index=0, tag="image")
+                plot_2d_or_3d_image(val_labels, epoch + 1, writer, index=0, tag="label")
+                plot_2d_or_3d_image(val_outputs, epoch + 1, writer, index=0, tag="output")
+
+    print(f"train completed, best_metric: {best_metric:.4f} at epoch: {best_metric_epoch}")
+    writer.close()
+
+
+if __name__ == "__main__":
+    with tempfile.TemporaryDirectory() as tempdir:
+        main(tempdir)

testbed/Project-MONAI__MONAI/examples/segmentation_3d/unet_training_dict.py

@@ -0,0 +1,187 @@
+# Copyright 2020 MONAI Consortium
+# 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 logging
+import os
+import sys
+import tempfile
+from glob import glob
+
+import nibabel as nib
+import numpy as np
+import torch
+from torch.utils.data import DataLoader
+from torch.utils.tensorboard import SummaryWriter
+
+import monai
+from monai.data import create_test_image_3d, list_data_collate
+from monai.inferers import sliding_window_inference
+from monai.metrics import DiceMetric
+from monai.transforms import (
+    AsChannelFirstd,
+    Compose,
+    LoadNiftid,
+    RandCropByPosNegLabeld,
+    RandRotate90d,
+    ScaleIntensityd,
+    ToTensord,
+)
+from monai.visualize import plot_2d_or_3d_image
+
+
+def main(tempdir):
+    monai.config.print_config()
+    logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+
+    # create a temporary directory and 40 random image, mask pairs
+    print(f"generating synthetic data to {tempdir} (this may take a while)")
+    for i in range(40):
+        im, seg = create_test_image_3d(128, 128, 128, num_seg_classes=1, channel_dim=-1)
+
+        n = nib.Nifti1Image(im, np.eye(4))
+        nib.save(n, os.path.join(tempdir, f"img{i:d}.nii.gz"))
+
+        n = nib.Nifti1Image(seg, np.eye(4))
+        nib.save(n, os.path.join(tempdir, f"seg{i:d}.nii.gz"))
+
+    images = sorted(glob(os.path.join(tempdir, "img*.nii.gz")))
+    segs = sorted(glob(os.path.join(tempdir, "seg*.nii.gz")))
+    train_files = [{"img": img, "seg": seg} for img, seg in zip(images[:20], segs[:20])]
+    val_files = [{"img": img, "seg": seg} for img, seg in zip(images[-20:], segs[-20:])]
+
+    # define transforms for image and segmentation
+    train_transforms = Compose(
+        [
+            LoadNiftid(keys=["img", "seg"]),
+            AsChannelFirstd(keys=["img", "seg"], channel_dim=-1),
+            ScaleIntensityd(keys="img"),
+            RandCropByPosNegLabeld(
+                keys=["img", "seg"], label_key="seg", spatial_size=[96, 96, 96], pos=1, neg=1, num_samples=4
+            ),
+            RandRotate90d(keys=["img", "seg"], prob=0.5, spatial_axes=[0, 2]),
+            ToTensord(keys=["img", "seg"]),
+        ]
+    )
+    val_transforms = Compose(
+        [
+            LoadNiftid(keys=["img", "seg"]),
+            AsChannelFirstd(keys=["img", "seg"], channel_dim=-1),
+            ScaleIntensityd(keys="img"),
+            ToTensord(keys=["img", "seg"]),
+        ]
+    )
+
+    # define dataset, data loader
+    check_ds = monai.data.Dataset(data=train_files, transform=train_transforms)
+    # use batch_size=2 to load images and use RandCropByPosNegLabeld to generate 2 x 4 images for network training
+    check_loader = DataLoader(check_ds, batch_size=2, num_workers=4, collate_fn=list_data_collate)
+    check_data = monai.utils.misc.first(check_loader)
+    print(check_data["img"].shape, check_data["seg"].shape)
+
+    # create a training data loader
+    train_ds = monai.data.Dataset(data=train_files, transform=train_transforms)
+    # use batch_size=2 to load images and use RandCropByPosNegLabeld to generate 2 x 4 images for network training
+    train_loader = DataLoader(
+        train_ds,
+        batch_size=2,
+        shuffle=True,
+        num_workers=4,
+        collate_fn=list_data_collate,
+        pin_memory=torch.cuda.is_available(),
+    )
+    # create a validation data loader
+    val_ds = monai.data.Dataset(data=val_files, transform=val_transforms)
+    val_loader = DataLoader(val_ds, batch_size=1, num_workers=4, collate_fn=list_data_collate)
+    dice_metric = DiceMetric(include_background=True, to_onehot_y=False, sigmoid=True, reduction="mean")
+
+    # create UNet, DiceLoss and Adam optimizer
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = monai.networks.nets.UNet(
+        dimensions=3,
+        in_channels=1,
+        out_channels=1,
+        channels=(16, 32, 64, 128, 256),
+        strides=(2, 2, 2, 2),
+        num_res_units=2,
+    ).to(device)
+    loss_function = monai.losses.DiceLoss(sigmoid=True)
+    optimizer = torch.optim.Adam(model.parameters(), 1e-3)
+
+    # start a typical PyTorch training
+    val_interval = 2
+    best_metric = -1
+    best_metric_epoch = -1
+    epoch_loss_values = list()
+    metric_values = list()
+    writer = SummaryWriter()
+    for epoch in range(5):
+        print("-" * 10)
+        print(f"epoch {epoch + 1}/{5}")
+        model.train()
+        epoch_loss = 0
+        step = 0
+        for batch_data in train_loader:
+            step += 1
+            inputs, labels = batch_data["img"].to(device), batch_data["seg"].to(device)
+            optimizer.zero_grad()
+            outputs = model(inputs)
+            loss = loss_function(outputs, labels)
+            loss.backward()
+            optimizer.step()
+            epoch_loss += loss.item()
+            epoch_len = len(train_ds) // train_loader.batch_size
+            print(f"{step}/{epoch_len}, train_loss: {loss.item():.4f}")
+            writer.add_scalar("train_loss", loss.item(), epoch_len * epoch + step)
+        epoch_loss /= step
+        epoch_loss_values.append(epoch_loss)
+        print(f"epoch {epoch + 1} average loss: {epoch_loss:.4f}")
+
+        if (epoch + 1) % val_interval == 0:
+            model.eval()
+            with torch.no_grad():
+                metric_sum = 0.0
+                metric_count = 0
+                val_images = None
+                val_labels = None
+                val_outputs = None
+                for val_data in val_loader:
+                    val_images, val_labels = val_data["img"].to(device), val_data["seg"].to(device)
+                    roi_size = (96, 96, 96)
+                    sw_batch_size = 4
+                    val_outputs = sliding_window_inference(val_images, roi_size, sw_batch_size, model)
+                    value = dice_metric(y_pred=val_outputs, y=val_labels)
+                    metric_count += len(value)
+                    metric_sum += value.item() * len(value)
+                metric = metric_sum / metric_count
+                metric_values.append(metric)
+                if metric > best_metric:
+                    best_metric = metric
+                    best_metric_epoch = epoch + 1
+                    torch.save(model.state_dict(), "best_metric_model_segmentation3d_dict.pth")
+                    print("saved new best metric model")
+                print(
+                    "current epoch: {} current mean dice: {:.4f} best mean dice: {:.4f} at epoch {}".format(
+                        epoch + 1, metric, best_metric, best_metric_epoch
+                    )
+                )
+                writer.add_scalar("val_mean_dice", metric, epoch + 1)
+                # plot the last model output as GIF image in TensorBoard with the corresponding image and label
+                plot_2d_or_3d_image(val_images, epoch + 1, writer, index=0, tag="image")
+                plot_2d_or_3d_image(val_labels, epoch + 1, writer, index=0, tag="label")
+                plot_2d_or_3d_image(val_outputs, epoch + 1, writer, index=0, tag="output")
+
+    print(f"train completed, best_metric: {best_metric:.4f} at epoch: {best_metric_epoch}")
+    writer.close()
+
+
+if __name__ == "__main__":
+    with tempfile.TemporaryDirectory() as tempdir:
+        main(tempdir)

testbed/Project-MONAI__MONAI/examples/segmentation_3d_ignite/unet_evaluation_array.py

@@ -0,0 +1,113 @@
+# Copyright 2020 MONAI Consortium
+# 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 logging
+import os
+import sys
+import tempfile
+from glob import glob
+
+import nibabel as nib
+import numpy as np
+import torch
+from ignite.engine import Engine
+from torch.utils.data import DataLoader
+
+from monai import config
+from monai.data import NiftiDataset, create_test_image_3d
+from monai.handlers import CheckpointLoader, MeanDice, SegmentationSaver, StatsHandler
+from monai.inferers import sliding_window_inference
+from monai.networks import predict_segmentation
+from monai.networks.nets import UNet
+from monai.transforms import AddChannel, Compose, ScaleIntensity, ToTensor
+
+
+def main(tempdir):
+    config.print_config()
+    logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+
+    print(f"generating synthetic data to {tempdir} (this may take a while)")
+    for i in range(5):
+        im, seg = create_test_image_3d(128, 128, 128, num_seg_classes=1)
+
+        n = nib.Nifti1Image(im, np.eye(4))
+        nib.save(n, os.path.join(tempdir, f"im{i:d}.nii.gz"))
+
+        n = nib.Nifti1Image(seg, np.eye(4))
+        nib.save(n, os.path.join(tempdir, f"seg{i:d}.nii.gz"))
+
+    images = sorted(glob(os.path.join(tempdir, "im*.nii.gz")))
+    segs = sorted(glob(os.path.join(tempdir, "seg*.nii.gz")))
+
+    # define transforms for image and segmentation
+    imtrans = Compose([ScaleIntensity(), AddChannel(), ToTensor()])
+    segtrans = Compose([AddChannel(), ToTensor()])
+    ds = NiftiDataset(images, segs, transform=imtrans, seg_transform=segtrans, image_only=False)
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    net = UNet(
+        dimensions=3,
+        in_channels=1,
+        out_channels=1,
+        channels=(16, 32, 64, 128, 256),
+        strides=(2, 2, 2, 2),
+        num_res_units=2,
+    )
+    net.to(device)
+
+    # define sliding window size and batch size for windows inference
+    roi_size = (96, 96, 96)
+    sw_batch_size = 4
+
+    def _sliding_window_processor(engine, batch):
+        net.eval()
+        with torch.no_grad():
+            val_images, val_labels = batch[0].to(device), batch[1].to(device)
+            seg_probs = sliding_window_inference(val_images, roi_size, sw_batch_size, net)
+            return seg_probs, val_labels
+
+    evaluator = Engine(_sliding_window_processor)
+
+    # add evaluation metric to the evaluator engine
+    MeanDice(sigmoid=True, to_onehot_y=False).attach(evaluator, "Mean_Dice")
+
+    # StatsHandler prints loss at every iteration and print metrics at every epoch,
+    # we don't need to print loss for evaluator, so just print metrics, user can also customize print functions
+    val_stats_handler = StatsHandler(
+        name="evaluator",
+        output_transform=lambda x: None,  # no need to print loss value, so disable per iteration output
+    )
+    val_stats_handler.attach(evaluator)
+
+    # for the array data format, assume the 3rd item of batch data is the meta_data
+    file_saver = SegmentationSaver(
+        output_dir="tempdir",
+        output_ext=".nii.gz",
+        output_postfix="seg",
+        name="evaluator",
+        batch_transform=lambda x: x[2],
+        output_transform=lambda output: predict_segmentation(output[0]),
+    )
+    file_saver.attach(evaluator)
+
+    # the model was trained by "unet_training_array" example
+    ckpt_saver = CheckpointLoader(load_path="./runs_array/net_checkpoint_100.pth", load_dict={"net": net})
+    ckpt_saver.attach(evaluator)
+
+    # sliding window inference for one image at every iteration
+    loader = DataLoader(ds, batch_size=1, num_workers=1, pin_memory=torch.cuda.is_available())
+    state = evaluator.run(loader)
+    print(state)
+
+
+if __name__ == "__main__":
+    with tempfile.TemporaryDirectory() as tempdir:
+        main(tempdir)

testbed/Project-MONAI__MONAI/examples/segmentation_3d_ignite/unet_evaluation_dict.py

@@ -0,0 +1,119 @@
+# Copyright 2020 MONAI Consortium
+# 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 logging
+import os
+import sys
+import tempfile
+from glob import glob
+
+import nibabel as nib
+import numpy as np
+import torch
+from ignite.engine import Engine
+from torch.utils.data import DataLoader
+
+import monai
+from monai.data import create_test_image_3d, list_data_collate
+from monai.handlers import CheckpointLoader, MeanDice, SegmentationSaver, StatsHandler
+from monai.inferers import sliding_window_inference
+from monai.networks import predict_segmentation
+from monai.networks.nets import UNet
+from monai.transforms import AsChannelFirstd, Compose, LoadNiftid, ScaleIntensityd, ToTensord
+
+
+def main(tempdir):
+    monai.config.print_config()
+    logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+
+    print(f"generating synthetic data to {tempdir} (this may take a while)")
+    for i in range(5):
+        im, seg = create_test_image_3d(128, 128, 128, num_seg_classes=1, channel_dim=-1)
+
+        n = nib.Nifti1Image(im, np.eye(4))
+        nib.save(n, os.path.join(tempdir, f"im{i:d}.nii.gz"))
+
+        n = nib.Nifti1Image(seg, np.eye(4))
+        nib.save(n, os.path.join(tempdir, f"seg{i:d}.nii.gz"))
+
+    images = sorted(glob(os.path.join(tempdir, "im*.nii.gz")))
+    segs = sorted(glob(os.path.join(tempdir, "seg*.nii.gz")))
+    val_files = [{"img": img, "seg": seg} for img, seg in zip(images, segs)]
+
+    # define transforms for image and segmentation
+    val_transforms = Compose(
+        [
+            LoadNiftid(keys=["img", "seg"]),
+            AsChannelFirstd(keys=["img", "seg"], channel_dim=-1),
+            ScaleIntensityd(keys="img"),
+            ToTensord(keys=["img", "seg"]),
+        ]
+    )
+    val_ds = monai.data.Dataset(data=val_files, transform=val_transforms)
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    net = UNet(
+        dimensions=3,
+        in_channels=1,
+        out_channels=1,
+        channels=(16, 32, 64, 128, 256),
+        strides=(2, 2, 2, 2),
+        num_res_units=2,
+    )
+    net.to(device)
+
+    # define sliding window size and batch size for windows inference
+    roi_size = (96, 96, 96)
+    sw_batch_size = 4
+
+    def _sliding_window_processor(engine, batch):
+        net.eval()
+        with torch.no_grad():
+            val_images, val_labels = batch["img"].to(device), batch["seg"].to(device)
+            seg_probs = sliding_window_inference(val_images, roi_size, sw_batch_size, net)
+            return seg_probs, val_labels
+
+    evaluator = Engine(_sliding_window_processor)
+
+    # add evaluation metric to the evaluator engine
+    MeanDice(sigmoid=True, to_onehot_y=False).attach(evaluator, "Mean_Dice")
+
+    # StatsHandler prints loss at every iteration and print metrics at every epoch,
+    # we don't need to print loss for evaluator, so just print metrics, user can also customize print functions
+    val_stats_handler = StatsHandler(
+        name="evaluator",
+        output_transform=lambda x: None,  # no need to print loss value, so disable per iteration output
+    )
+    val_stats_handler.attach(evaluator)
+
+    # convert the necessary metadata from batch data
+    SegmentationSaver(
+        output_dir="tempdir",
+        output_ext=".nii.gz",
+        output_postfix="seg",
+        name="evaluator",
+        batch_transform=lambda batch: batch["img_meta_dict"],
+        output_transform=lambda output: predict_segmentation(output[0]),
+    ).attach(evaluator)
+    # the model was trained by "unet_training_dict" example
+    CheckpointLoader(load_path="./runs_dict/net_checkpoint_50.pth", load_dict={"net": net}).attach(evaluator)
+
+    # sliding window inference for one image at every iteration
+    val_loader = DataLoader(
+        val_ds, batch_size=1, num_workers=4, collate_fn=list_data_collate, pin_memory=torch.cuda.is_available()
+    )
+    state = evaluator.run(val_loader)
+    print(state)
+
+
+if __name__ == "__main__":
+    with tempfile.TemporaryDirectory() as tempdir:
+        main(tempdir)

testbed/Project-MONAI__MONAI/examples/segmentation_3d_ignite/unet_training_array.py

@@ -0,0 +1,160 @@
+# Copyright 2020 MONAI Consortium
+# 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 logging
+import os
+import sys
+import tempfile
+from glob import glob
+
+import nibabel as nib
+import numpy as np
+import torch
+from ignite.engine import Events, create_supervised_evaluator, create_supervised_trainer
+from ignite.handlers import EarlyStopping, ModelCheckpoint
+from torch.utils.data import DataLoader
+
+import monai
+from monai.data import NiftiDataset, create_test_image_3d
+from monai.handlers import (
+    MeanDice,
+    StatsHandler,
+    TensorBoardImageHandler,
+    TensorBoardStatsHandler,
+    stopping_fn_from_metric,
+)
+from monai.networks import predict_segmentation
+from monai.transforms import AddChannel, Compose, RandSpatialCrop, Resize, ScaleIntensity, ToTensor
+
+
+def main(tempdir):
+    monai.config.print_config()
+    logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+
+    # create a temporary directory and 40 random image, mask pairs
+    print(f"generating synthetic data to {tempdir} (this may take a while)")
+    for i in range(40):
+        im, seg = create_test_image_3d(128, 128, 128, num_seg_classes=1)
+
+        n = nib.Nifti1Image(im, np.eye(4))
+        nib.save(n, os.path.join(tempdir, f"im{i:d}.nii.gz"))
+
+        n = nib.Nifti1Image(seg, np.eye(4))
+        nib.save(n, os.path.join(tempdir, f"seg{i:d}.nii.gz"))
+
+    images = sorted(glob(os.path.join(tempdir, "im*.nii.gz")))
+    segs = sorted(glob(os.path.join(tempdir, "seg*.nii.gz")))
+
+    # define transforms for image and segmentation
+    train_imtrans = Compose(
+        [ScaleIntensity(), AddChannel(), RandSpatialCrop((96, 96, 96), random_size=False), ToTensor()]
+    )
+    train_segtrans = Compose([AddChannel(), RandSpatialCrop((96, 96, 96), random_size=False), ToTensor()])
+    val_imtrans = Compose([ScaleIntensity(), AddChannel(), Resize((96, 96, 96)), ToTensor()])
+    val_segtrans = Compose([AddChannel(), Resize((96, 96, 96)), ToTensor()])
+
+    # define nifti dataset, data loader
+    check_ds = NiftiDataset(images, segs, transform=train_imtrans, seg_transform=train_segtrans)
+    check_loader = DataLoader(check_ds, batch_size=10, num_workers=2, pin_memory=torch.cuda.is_available())
+    im, seg = monai.utils.misc.first(check_loader)
+    print(im.shape, seg.shape)
+
+    # create a training data loader
+    train_ds = NiftiDataset(images[:20], segs[:20], transform=train_imtrans, seg_transform=train_segtrans)
+    train_loader = DataLoader(train_ds, batch_size=5, shuffle=True, num_workers=8, pin_memory=torch.cuda.is_available())
+    # create a validation data loader
+    val_ds = NiftiDataset(images[-20:], segs[-20:], transform=val_imtrans, seg_transform=val_segtrans)
+    val_loader = DataLoader(val_ds, batch_size=5, num_workers=8, pin_memory=torch.cuda.is_available())
+
+    # create UNet, DiceLoss and Adam optimizer
+    net = monai.networks.nets.UNet(
+        dimensions=3,
+        in_channels=1,
+        out_channels=1,
+        channels=(16, 32, 64, 128, 256),
+        strides=(2, 2, 2, 2),
+        num_res_units=2,
+    )
+    loss = monai.losses.DiceLoss(sigmoid=True)
+    lr = 1e-3
+    opt = torch.optim.Adam(net.parameters(), lr)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    # Ignite trainer expects batch=(img, seg) and returns output=loss at every iteration,
+    # user can add output_transform to return other values, like: y_pred, y, etc.
+    trainer = create_supervised_trainer(net, opt, loss, device, False)
+
+    # adding checkpoint handler to save models (network params and optimizer stats) during training
+    checkpoint_handler = ModelCheckpoint("./runs_array/", "net", n_saved=10, require_empty=False)
+    trainer.add_event_handler(
+        event_name=Events.EPOCH_COMPLETED, handler=checkpoint_handler, to_save={"net": net, "opt": opt}
+    )
+
+    # StatsHandler prints loss at every iteration and print metrics at every epoch,
+    # we don't set metrics for trainer here, so just print loss, user can also customize print functions
+    # and can use output_transform to convert engine.state.output if it's not a loss value
+    train_stats_handler = StatsHandler(name="trainer")
+    train_stats_handler.attach(trainer)
+
+    # TensorBoardStatsHandler plots loss at every iteration and plots metrics at every epoch, same as StatsHandler
+    train_tensorboard_stats_handler = TensorBoardStatsHandler()
+    train_tensorboard_stats_handler.attach(trainer)
+
+    validation_every_n_epochs = 1
+    # Set parameters for validation
+    metric_name = "Mean_Dice"
+    # add evaluation metric to the evaluator engine
+    val_metrics = {metric_name: MeanDice(sigmoid=True, to_onehot_y=False)}
+
+    # Ignite evaluator expects batch=(img, seg) and returns output=(y_pred, y) at every iteration,
+    # user can add output_transform to return other values
+    evaluator = create_supervised_evaluator(net, val_metrics, device, True)
+
+    @trainer.on(Events.EPOCH_COMPLETED(every=validation_every_n_epochs))
+    def run_validation(engine):
+        evaluator.run(val_loader)
+
+    # add early stopping handler to evaluator
+    early_stopper = EarlyStopping(patience=4, score_function=stopping_fn_from_metric(metric_name), trainer=trainer)
+    evaluator.add_event_handler(event_name=Events.EPOCH_COMPLETED, handler=early_stopper)
+
+    # add stats event handler to print validation stats via evaluator
+    val_stats_handler = StatsHandler(
+        name="evaluator",
+        output_transform=lambda x: None,  # no need to print loss value, so disable per iteration output
+        global_epoch_transform=lambda x: trainer.state.epoch,
+    )  # fetch global epoch number from trainer
+    val_stats_handler.attach(evaluator)
+
+    # add handler to record metrics to TensorBoard at every validation epoch
+    val_tensorboard_stats_handler = TensorBoardStatsHandler(
+        output_transform=lambda x: None,  # no need to plot loss value, so disable per iteration output
+        global_epoch_transform=lambda x: trainer.state.epoch,
+    )  # fetch global epoch number from trainer
+    val_tensorboard_stats_handler.attach(evaluator)
+
+    # add handler to draw the first image and the corresponding label and model output in the last batch
+    # here we draw the 3D output as GIF format along Depth axis, at every validation epoch
+    val_tensorboard_image_handler = TensorBoardImageHandler(
+        batch_transform=lambda batch: (batch[0], batch[1]),
+        output_transform=lambda output: predict_segmentation(output[0]),
+        global_iter_transform=lambda x: trainer.state.epoch,
+    )
+    evaluator.add_event_handler(event_name=Events.EPOCH_COMPLETED, handler=val_tensorboard_image_handler)
+
+    train_epochs = 30
+    state = trainer.run(train_loader, train_epochs)
+    print(state)
+
+
+if __name__ == "__main__":
+    with tempfile.TemporaryDirectory() as tempdir:
+        main(tempdir)

testbed/Project-MONAI__MONAI/examples/segmentation_3d_ignite/unet_training_dict.py

@@ -0,0 +1,200 @@
+# Copyright 2020 MONAI Consortium
+# 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 logging
+import os
+import sys
+import tempfile
+from glob import glob
+
+import nibabel as nib
+import numpy as np
+import torch
+from ignite.engine import Events, _prepare_batch, create_supervised_evaluator, create_supervised_trainer
+from ignite.handlers import EarlyStopping, ModelCheckpoint
+from torch.utils.data import DataLoader
+
+import monai
+from monai.data import create_test_image_3d, list_data_collate
+from monai.handlers import (
+    MeanDice,
+    StatsHandler,
+    TensorBoardImageHandler,
+    TensorBoardStatsHandler,
+    stopping_fn_from_metric,
+)
+from monai.networks import predict_segmentation
+from monai.transforms import (
+    AsChannelFirstd,
+    Compose,
+    LoadNiftid,
+    RandCropByPosNegLabeld,
+    RandRotate90d,
+    ScaleIntensityd,
+    ToTensord,
+)
+
+
+def main(tempdir):
+    monai.config.print_config()
+    logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+
+    # create a temporary directory and 40 random image, mask pairs
+    print(f"generating synthetic data to {tempdir} (this may take a while)")
+    for i in range(40):
+        im, seg = create_test_image_3d(128, 128, 128, num_seg_classes=1, channel_dim=-1)
+
+        n = nib.Nifti1Image(im, np.eye(4))
+        nib.save(n, os.path.join(tempdir, f"img{i:d}.nii.gz"))
+
+        n = nib.Nifti1Image(seg, np.eye(4))
+        nib.save(n, os.path.join(tempdir, f"seg{i:d}.nii.gz"))
+
+    images = sorted(glob(os.path.join(tempdir, "img*.nii.gz")))
+    segs = sorted(glob(os.path.join(tempdir, "seg*.nii.gz")))
+    train_files = [{"img": img, "seg": seg} for img, seg in zip(images[:20], segs[:20])]
+    val_files = [{"img": img, "seg": seg} for img, seg in zip(images[-20:], segs[-20:])]
+
+    # define transforms for image and segmentation
+    train_transforms = Compose(
+        [
+            LoadNiftid(keys=["img", "seg"]),
+            AsChannelFirstd(keys=["img", "seg"], channel_dim=-1),
+            ScaleIntensityd(keys="img"),
+            RandCropByPosNegLabeld(
+                keys=["img", "seg"], label_key="seg", spatial_size=[96, 96, 96], pos=1, neg=1, num_samples=4
+            ),
+            RandRotate90d(keys=["img", "seg"], prob=0.5, spatial_axes=[0, 2]),
+            ToTensord(keys=["img", "seg"]),
+        ]
+    )
+    val_transforms = Compose(
+        [
+            LoadNiftid(keys=["img", "seg"]),
+            AsChannelFirstd(keys=["img", "seg"], channel_dim=-1),
+            ScaleIntensityd(keys="img"),
+            ToTensord(keys=["img", "seg"]),
+        ]
+    )
+
+    # define dataset, data loader
+    check_ds = monai.data.Dataset(data=train_files, transform=train_transforms)
+    # use batch_size=2 to load images and use RandCropByPosNegLabeld to generate 2 x 4 images for network training
+    check_loader = DataLoader(
+        check_ds, batch_size=2, num_workers=4, collate_fn=list_data_collate, pin_memory=torch.cuda.is_available()
+    )
+    check_data = monai.utils.misc.first(check_loader)
+    print(check_data["img"].shape, check_data["seg"].shape)
+
+    # create a training data loader
+    train_ds = monai.data.Dataset(data=train_files, transform=train_transforms)
+    # use batch_size=2 to load images and use RandCropByPosNegLabeld to generate 2 x 4 images for network training
+    train_loader = DataLoader(
+        train_ds,
+        batch_size=2,
+        shuffle=True,
+        num_workers=4,
+        collate_fn=list_data_collate,
+        pin_memory=torch.cuda.is_available(),
+    )
+    # create a validation data loader
+    val_ds = monai.data.Dataset(data=val_files, transform=val_transforms)
+    val_loader = DataLoader(
+        val_ds, batch_size=5, num_workers=8, collate_fn=list_data_collate, pin_memory=torch.cuda.is_available()
+    )
+
+    # create UNet, DiceLoss and Adam optimizer
+    net = monai.networks.nets.UNet(
+        dimensions=3,
+        in_channels=1,
+        out_channels=1,
+        channels=(16, 32, 64, 128, 256),
+        strides=(2, 2, 2, 2),
+        num_res_units=2,
+    )
+    loss = monai.losses.DiceLoss(sigmoid=True)
+    lr = 1e-3
+    opt = torch.optim.Adam(net.parameters(), lr)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    # Ignite trainer expects batch=(img, seg) and returns output=loss at every iteration,
+    # user can add output_transform to return other values, like: y_pred, y, etc.
+    def prepare_batch(batch, device=None, non_blocking=False):
+        return _prepare_batch((batch["img"], batch["seg"]), device, non_blocking)
+
+    trainer = create_supervised_trainer(net, opt, loss, device, False, prepare_batch=prepare_batch)
+
+    # adding checkpoint handler to save models (network params and optimizer stats) during training
+    checkpoint_handler = ModelCheckpoint("./runs_dict/", "net", n_saved=10, require_empty=False)
+    trainer.add_event_handler(
+        event_name=Events.EPOCH_COMPLETED, handler=checkpoint_handler, to_save={"net": net, "opt": opt}
+    )
+
+    # StatsHandler prints loss at every iteration and print metrics at every epoch,
+    # we don't set metrics for trainer here, so just print loss, user can also customize print functions
+    # and can use output_transform to convert engine.state.output if it's not loss value
+    train_stats_handler = StatsHandler(name="trainer")
+    train_stats_handler.attach(trainer)
+
+    # TensorBoardStatsHandler plots loss at every iteration and plots metrics at every epoch, same as StatsHandler
+    train_tensorboard_stats_handler = TensorBoardStatsHandler()
+    train_tensorboard_stats_handler.attach(trainer)
+
+    validation_every_n_iters = 5
+    # set parameters for validation
+    metric_name = "Mean_Dice"
+    # add evaluation metric to the evaluator engine
+    val_metrics = {metric_name: MeanDice(sigmoid=True, to_onehot_y=False)}
+
+    # Ignite evaluator expects batch=(img, seg) and returns output=(y_pred, y) at every iteration,
+    # user can add output_transform to return other values
+    evaluator = create_supervised_evaluator(net, val_metrics, device, True, prepare_batch=prepare_batch)
+
+    @trainer.on(Events.ITERATION_COMPLETED(every=validation_every_n_iters))
+    def run_validation(engine):
+        evaluator.run(val_loader)
+
+    # add early stopping handler to evaluator
+    early_stopper = EarlyStopping(patience=4, score_function=stopping_fn_from_metric(metric_name), trainer=trainer)
+    evaluator.add_event_handler(event_name=Events.EPOCH_COMPLETED, handler=early_stopper)
+
+    # add stats event handler to print validation stats via evaluator
+    val_stats_handler = StatsHandler(
+        name="evaluator",
+        output_transform=lambda x: None,  # no need to print loss value, so disable per iteration output
+        global_epoch_transform=lambda x: trainer.state.epoch,
+    )  # fetch global epoch number from trainer
+    val_stats_handler.attach(evaluator)
+
+    # add handler to record metrics to TensorBoard at every validation epoch
+    val_tensorboard_stats_handler = TensorBoardStatsHandler(
+        output_transform=lambda x: None,  # no need to plot loss value, so disable per iteration output
+        global_epoch_transform=lambda x: trainer.state.iteration,
+    )  # fetch global iteration number from trainer
+    val_tensorboard_stats_handler.attach(evaluator)
+
+    # add handler to draw the first image and the corresponding label and model output in the last batch
+    # here we draw the 3D output as GIF format along the depth axis, every 2 validation iterations.
+    val_tensorboard_image_handler = TensorBoardImageHandler(
+        batch_transform=lambda batch: (batch["img"], batch["seg"]),
+        output_transform=lambda output: predict_segmentation(output[0]),
+        global_iter_transform=lambda x: trainer.state.epoch,
+    )
+    evaluator.add_event_handler(event_name=Events.ITERATION_COMPLETED(every=2), handler=val_tensorboard_image_handler)
+
+    train_epochs = 5
+    state = trainer.run(train_loader, train_epochs)
+    print(state)
+
+
+if __name__ == "__main__":
+    with tempfile.TemporaryDirectory() as tempdir:
+        main(tempdir)

testbed/Project-MONAI__MONAI/examples/synthesis/gan_evaluation.py

@@ -0,0 +1,67 @@
+# Copyright 2020 MONAI Consortium
+# 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.
+"""
+MONAI GAN Evaluation Example
+    Generate fake images from trained generator file.
+
+"""
+
+import logging
+import os
+import sys
+from glob import glob
+
+import torch
+
+import monai
+from monai.data import png_writer
+from monai.engines.utils import default_make_latent as make_latent
+from monai.networks.nets import Generator
+from monai.utils.misc import set_determinism
+
+
+def save_generator_fakes(run_folder, g_output_tensor):
+    for i, image in enumerate(g_output_tensor):
+        filename = "gen-fake-%d.png" % (i)
+        save_path = os.path.join(run_folder, filename)
+        img_array = image[0].cpu().data.numpy()
+        png_writer.write_png(img_array, save_path, scale=255)
+
+
+def main():
+    monai.config.print_config()
+    logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+    set_determinism(12345)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    # load generator
+    network_filepath = glob("./model_out/*.pth")[0]
+    data = torch.load(network_filepath)
+    latent_size = 64
+    gen_net = Generator(
+        latent_shape=latent_size, start_shape=(latent_size, 8, 8), channels=[32, 16, 8, 1], strides=[2, 2, 2, 1]
+    )
+    gen_net.conv.add_module("activation", torch.nn.Sigmoid())
+    gen_net.load_state_dict(data["g_net"])
+    gen_net = gen_net.to(device)
+
+    # create fakes
+    output_dir = "./generated_images"
+    if not os.path.isdir(output_dir):
+        os.mkdir(output_dir)
+    num_fakes = 10
+    print("Generating %d fakes and saving in %s" % (num_fakes, output_dir))
+    fake_latents = make_latent(num_fakes, latent_size).to(device)
+    save_generator_fakes(output_dir, gen_net(fake_latents))
+
+
+if __name__ == "__main__":
+    main()

testbed/Project-MONAI__MONAI/examples/synthesis/gan_training.py

@@ -0,0 +1,203 @@
+# Copyright 2020 MONAI Consortium
+# 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.
+"""
+MONAI Generative Adversarial Networks Workflow Example
+    Sample script using MONAI to train a GAN to synthesize images from a latent code.
+
+## Get the dataset
+    MedNIST.tar.gz link: https://www.dropbox.com/s/5wwskxctvcxiuea/MedNIST.tar.gz
+    Extract tarball and set input_dir variable. GAN script trains using hand CT scan jpg images.
+
+    Dataset information available in MedNIST Tutorial
+    https://github.com/Project-MONAI/Tutorials/blob/master/mednist_tutorial.ipynb
+"""
+
+import logging
+import os
+import sys
+
+import torch
+
+import monai
+from monai.apps.utils import download_and_extract
+from monai.data import CacheDataset, DataLoader, png_writer
+from monai.engines import GanTrainer
+from monai.engines.utils import GanKeys as Keys
+from monai.engines.utils import default_make_latent as make_latent
+from monai.handlers import CheckpointSaver, StatsHandler
+from monai.networks import normal_init
+from monai.networks.nets import Discriminator, Generator
+from monai.transforms import (
+    AddChannelD,
+    Compose,
+    LoadPNGD,
+    RandFlipD,
+    RandRotateD,
+    RandZoomD,
+    ScaleIntensityD,
+    ToTensorD,
+)
+from monai.utils.misc import set_determinism
+
+
+def main():
+    monai.config.print_config()
+    logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+    set_determinism(12345)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    # load real data
+    mednist_url = "https://www.dropbox.com/s/5wwskxctvcxiuea/MedNIST.tar.gz?dl=1"
+    md5_value = "0bc7306e7427e00ad1c5526a6677552d"
+    extract_dir = "data"
+    tar_save_path = os.path.join(extract_dir, "MedNIST.tar.gz")
+    download_and_extract(mednist_url, tar_save_path, extract_dir, md5_value)
+    hand_dir = os.path.join(extract_dir, "MedNIST", "Hand")
+    real_data = [{"hand": os.path.join(hand_dir, filename)} for filename in os.listdir(hand_dir)]
+
+    # define real data transforms
+    train_transforms = Compose(
+        [
+            LoadPNGD(keys=["hand"]),
+            AddChannelD(keys=["hand"]),
+            ScaleIntensityD(keys=["hand"]),
+            RandRotateD(keys=["hand"], range_x=15, prob=0.5, keep_size=True),
+            RandFlipD(keys=["hand"], spatial_axis=0, prob=0.5),
+            RandZoomD(keys=["hand"], min_zoom=0.9, max_zoom=1.1, prob=0.5),
+            ToTensorD(keys=["hand"]),
+        ]
+    )
+
+    # create dataset and dataloader
+    real_dataset = CacheDataset(real_data, train_transforms)
+    batch_size = 300
+    real_dataloader = DataLoader(real_dataset, batch_size=batch_size, shuffle=True, num_workers=10)
+
+    # define function to process batchdata for input into discriminator
+    def prepare_batch(batchdata):
+        """
+        Process Dataloader batchdata dict object and return image tensors for D Inferer
+        """
+        return batchdata["hand"]
+
+    # define networks
+    disc_net = Discriminator(
+        in_shape=(1, 64, 64), channels=(8, 16, 32, 64, 1), strides=(2, 2, 2, 2, 1), num_res_units=1, kernel_size=5
+    ).to(device)
+
+    latent_size = 64
+    gen_net = Generator(
+        latent_shape=latent_size, start_shape=(latent_size, 8, 8), channels=[32, 16, 8, 1], strides=[2, 2, 2, 1]
+    )
+
+    # initialize both networks
+    disc_net.apply(normal_init)
+    gen_net.apply(normal_init)
+
+    # input images are scaled to [0,1] so enforce the same of generated outputs
+    gen_net.conv.add_module("activation", torch.nn.Sigmoid())
+    gen_net = gen_net.to(device)
+
+    # create optimizers and loss functions
+    learning_rate = 2e-4
+    betas = (0.5, 0.999)
+    disc_opt = torch.optim.Adam(disc_net.parameters(), learning_rate, betas=betas)
+    gen_opt = torch.optim.Adam(gen_net.parameters(), learning_rate, betas=betas)
+
+    disc_loss_criterion = torch.nn.BCELoss()
+    gen_loss_criterion = torch.nn.BCELoss()
+    real_label = 1
+    fake_label = 0
+
+    def discriminator_loss(gen_images, real_images):
+        """
+        The discriminator loss is calculated by comparing D
+        prediction for real and generated images.
+
+        """
+        real = real_images.new_full((real_images.shape[0], 1), real_label)
+        gen = gen_images.new_full((gen_images.shape[0], 1), fake_label)
+
+        realloss = disc_loss_criterion(disc_net(real_images), real)
+        genloss = disc_loss_criterion(disc_net(gen_images.detach()), gen)
+
+        return (genloss + realloss) / 2
+
+    def generator_loss(gen_images):
+        """
+        The generator loss is calculated by determining how realistic
+        the discriminator classifies the generated images.
+
+        """
+        output = disc_net(gen_images)
+        cats = output.new_full(output.shape, real_label)
+        return gen_loss_criterion(output, cats)
+
+    # initialize current run dir
+    run_dir = "model_out"
+    print("Saving model output to: %s " % run_dir)
+
+    # create workflow handlers
+    handlers = [
+        StatsHandler(
+            name="batch_training_loss",
+            output_transform=lambda x: {Keys.GLOSS: x[Keys.GLOSS], Keys.DLOSS: x[Keys.DLOSS]},
+        ),
+        CheckpointSaver(
+            save_dir=run_dir,
+            save_dict={"g_net": gen_net, "d_net": disc_net},
+            save_interval=10,
+            save_final=True,
+            epoch_level=True,
+        ),
+    ]
+
+    # define key metric
+    key_train_metric = None
+
+    # create adversarial trainer
+    disc_train_steps = 5
+    num_epochs = 50
+
+    trainer = GanTrainer(
+        device,
+        num_epochs,
+        real_dataloader,
+        gen_net,
+        gen_opt,
+        generator_loss,
+        disc_net,
+        disc_opt,
+        discriminator_loss,
+        d_prepare_batch=prepare_batch,
+        d_train_steps=disc_train_steps,
+        latent_shape=latent_size,
+        key_train_metric=key_train_metric,
+        train_handlers=handlers,
+    )
+
+    # run GAN training
+    trainer.run()
+
+    # Training completed, save a few random generated images.
+    print("Saving trained generator sample output.")
+    test_img_count = 10
+    test_latents = make_latent(test_img_count, latent_size).to(device)
+    fakes = gen_net(test_latents)
+    for i, image in enumerate(fakes):
+        filename = "gen-fake-final-%d.png" % (i)
+        save_path = os.path.join(run_dir, filename)
+        img_array = image[0].cpu().data.numpy()
+        png_writer.write_png(img_array, save_path, scale=255)
+
+
+if __name__ == "__main__":
+    main()

testbed/Project-MONAI__MONAI/examples/workflows/unet_evaluation_dict.py

@@ -0,0 +1,121 @@
+# Copyright 2020 MONAI Consortium
+# 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 logging
+import os
+import sys
+import tempfile
+from glob import glob
+
+import nibabel as nib
+import numpy as np
+import torch
+from ignite.metrics import Accuracy
+
+import monai
+from monai.data import create_test_image_3d
+from monai.engines import SupervisedEvaluator
+from monai.handlers import CheckpointLoader, MeanDice, SegmentationSaver, StatsHandler
+from monai.inferers import SlidingWindowInferer
+from monai.transforms import (
+    Activationsd,
+    AsChannelFirstd,
+    AsDiscreted,
+    Compose,
+    KeepLargestConnectedComponentd,
+    LoadNiftid,
+    ScaleIntensityd,
+    ToTensord,
+)
+
+
+def main(tempdir):
+    monai.config.print_config()
+    logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+
+    # create a temporary directory and 40 random image, mask pairs
+    print(f"generating synthetic data to {tempdir} (this may take a while)")
+    for i in range(5):
+        im, seg = create_test_image_3d(128, 128, 128, num_seg_classes=1, channel_dim=-1)
+        n = nib.Nifti1Image(im, np.eye(4))
+        nib.save(n, os.path.join(tempdir, f"im{i:d}.nii.gz"))
+        n = nib.Nifti1Image(seg, np.eye(4))
+        nib.save(n, os.path.join(tempdir, f"seg{i:d}.nii.gz"))
+
+    images = sorted(glob(os.path.join(tempdir, "im*.nii.gz")))
+    segs = sorted(glob(os.path.join(tempdir, "seg*.nii.gz")))
+    val_files = [{"image": img, "label": seg} for img, seg in zip(images, segs)]
+
+    # model file path
+    model_file = glob("./runs/net_key_metric*")[0]
+
+    # define transforms for image and segmentation
+    val_transforms = Compose(
+        [
+            LoadNiftid(keys=["image", "label"]),
+            AsChannelFirstd(keys=["image", "label"], channel_dim=-1),
+            ScaleIntensityd(keys="image"),
+            ToTensord(keys=["image", "label"]),
+        ]
+    )
+
+    # create a validation data loader
+    val_ds = monai.data.Dataset(data=val_files, transform=val_transforms)
+    val_loader = monai.data.DataLoader(val_ds, batch_size=1, num_workers=4)
+
+    # create UNet, DiceLoss and Adam optimizer
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    net = monai.networks.nets.UNet(
+        dimensions=3,
+        in_channels=1,
+        out_channels=1,
+        channels=(16, 32, 64, 128, 256),
+        strides=(2, 2, 2, 2),
+        num_res_units=2,
+    ).to(device)
+
+    val_post_transforms = Compose(
+        [
+            Activationsd(keys="pred", sigmoid=True),
+            AsDiscreted(keys="pred", threshold_values=True),
+            KeepLargestConnectedComponentd(keys="pred", applied_labels=[1]),
+        ]
+    )
+    val_handlers = [
+        StatsHandler(output_transform=lambda x: None),
+        CheckpointLoader(load_path=model_file, load_dict={"net": net}),
+        SegmentationSaver(
+            output_dir="./runs/",
+            batch_transform=lambda batch: batch["image_meta_dict"],
+            output_transform=lambda output: output["pred"],
+        ),
+    ]
+
+    evaluator = SupervisedEvaluator(
+        device=device,
+        val_data_loader=val_loader,
+        network=net,
+        inferer=SlidingWindowInferer(roi_size=(96, 96, 96), sw_batch_size=4, overlap=0.5),
+        post_transform=val_post_transforms,
+        key_val_metric={
+            "val_mean_dice": MeanDice(include_background=True, output_transform=lambda x: (x["pred"], x["label"]))
+        },
+        additional_metrics={"val_acc": Accuracy(output_transform=lambda x: (x["pred"], x["label"]))},
+        val_handlers=val_handlers,
+        # if no FP16 support in GPU or PyTorch version < 1.6, will not enable AMP evaluation
+        amp=True if monai.config.get_torch_version_tuple() >= (1, 6) else False,
+    )
+    evaluator.run()
+
+
+if __name__ == "__main__":
+    with tempfile.TemporaryDirectory() as tempdir:
+        main(tempdir)

testbed/Project-MONAI__MONAI/examples/workflows/unet_training_dict.py

@@ -0,0 +1,179 @@
+# Copyright 2020 MONAI Consortium
+# 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 logging
+import os
+import sys
+import tempfile
+from glob import glob
+
+import nibabel as nib
+import numpy as np
+import torch
+from ignite.metrics import Accuracy
+
+import monai
+from monai.data import create_test_image_3d
+from monai.engines import SupervisedEvaluator, SupervisedTrainer
+from monai.handlers import (
+    CheckpointSaver,
+    LrScheduleHandler,
+    MeanDice,
+    StatsHandler,
+    TensorBoardImageHandler,
+    TensorBoardStatsHandler,
+    ValidationHandler,
+)
+from monai.inferers import SimpleInferer, SlidingWindowInferer
+from monai.transforms import (
+    Activationsd,
+    AsChannelFirstd,
+    AsDiscreted,
+    Compose,
+    KeepLargestConnectedComponentd,
+    LoadNiftid,
+    RandCropByPosNegLabeld,
+    RandRotate90d,
+    ScaleIntensityd,
+    ToTensord,
+)
+
+
+def main(tempdir):
+    monai.config.print_config()
+    logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+
+    # create a temporary directory and 40 random image, mask pairs
+    print(f"generating synthetic data to {tempdir} (this may take a while)")
+    for i in range(40):
+        im, seg = create_test_image_3d(128, 128, 128, num_seg_classes=1, channel_dim=-1)
+        n = nib.Nifti1Image(im, np.eye(4))
+        nib.save(n, os.path.join(tempdir, f"img{i:d}.nii.gz"))
+        n = nib.Nifti1Image(seg, np.eye(4))
+        nib.save(n, os.path.join(tempdir, f"seg{i:d}.nii.gz"))
+
+    images = sorted(glob(os.path.join(tempdir, "img*.nii.gz")))
+    segs = sorted(glob(os.path.join(tempdir, "seg*.nii.gz")))
+    train_files = [{"image": img, "label": seg} for img, seg in zip(images[:20], segs[:20])]
+    val_files = [{"image": img, "label": seg} for img, seg in zip(images[-20:], segs[-20:])]
+
+    # define transforms for image and segmentation
+    train_transforms = Compose(
+        [
+            LoadNiftid(keys=["image", "label"]),
+            AsChannelFirstd(keys=["image", "label"], channel_dim=-1),
+            ScaleIntensityd(keys="image"),
+            RandCropByPosNegLabeld(
+                keys=["image", "label"], label_key="label", spatial_size=[96, 96, 96], pos=1, neg=1, num_samples=4
+            ),
+            RandRotate90d(keys=["image", "label"], prob=0.5, spatial_axes=[0, 2]),
+            ToTensord(keys=["image", "label"]),
+        ]
+    )
+    val_transforms = Compose(
+        [
+            LoadNiftid(keys=["image", "label"]),
+            AsChannelFirstd(keys=["image", "label"], channel_dim=-1),
+            ScaleIntensityd(keys="image"),
+            ToTensord(keys=["image", "label"]),
+        ]
+    )
+
+    # create a training data loader
+    train_ds = monai.data.CacheDataset(data=train_files, transform=train_transforms, cache_rate=0.5)
+    # use batch_size=2 to load images and use RandCropByPosNegLabeld to generate 2 x 4 images for network training
+    train_loader = monai.data.DataLoader(train_ds, batch_size=2, shuffle=True, num_workers=4)
+    # create a validation data loader
+    val_ds = monai.data.CacheDataset(data=val_files, transform=val_transforms, cache_rate=1.0)
+    val_loader = monai.data.DataLoader(val_ds, batch_size=1, num_workers=4)
+
+    # create UNet, DiceLoss and Adam optimizer
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    net = monai.networks.nets.UNet(
+        dimensions=3,
+        in_channels=1,
+        out_channels=1,
+        channels=(16, 32, 64, 128, 256),
+        strides=(2, 2, 2, 2),
+        num_res_units=2,
+    ).to(device)
+    loss = monai.losses.DiceLoss(sigmoid=True)
+    opt = torch.optim.Adam(net.parameters(), 1e-3)
+    lr_scheduler = torch.optim.lr_scheduler.StepLR(opt, step_size=2, gamma=0.1)
+
+    val_post_transforms = Compose(
+        [
+            Activationsd(keys="pred", sigmoid=True),
+            AsDiscreted(keys="pred", threshold_values=True),
+            KeepLargestConnectedComponentd(keys="pred", applied_labels=[1]),
+        ]
+    )
+    val_handlers = [
+        StatsHandler(output_transform=lambda x: None),
+        TensorBoardStatsHandler(log_dir="./runs/", output_transform=lambda x: None),
+        TensorBoardImageHandler(
+            log_dir="./runs/",
+            batch_transform=lambda x: (x["image"], x["label"]),
+            output_transform=lambda x: x["pred"],
+        ),
+        CheckpointSaver(save_dir="./runs/", save_dict={"net": net}, save_key_metric=True),
+    ]
+
+    evaluator = SupervisedEvaluator(
+        device=device,
+        val_data_loader=val_loader,
+        network=net,
+        inferer=SlidingWindowInferer(roi_size=(96, 96, 96), sw_batch_size=4, overlap=0.5),
+        post_transform=val_post_transforms,
+        key_val_metric={
+            "val_mean_dice": MeanDice(include_background=True, output_transform=lambda x: (x["pred"], x["label"]))
+        },
+        additional_metrics={"val_acc": Accuracy(output_transform=lambda x: (x["pred"], x["label"]))},
+        val_handlers=val_handlers,
+        # if no FP16 support in GPU or PyTorch version < 1.6, will not enable AMP evaluation
+        amp=True if monai.config.get_torch_version_tuple() >= (1, 6) else False,
+    )
+
+    train_post_transforms = Compose(
+        [
+            Activationsd(keys="pred", sigmoid=True),
+            AsDiscreted(keys="pred", threshold_values=True),
+            KeepLargestConnectedComponentd(keys="pred", applied_labels=[1]),
+        ]
+    )
+    train_handlers = [
+        LrScheduleHandler(lr_scheduler=lr_scheduler, print_lr=True),
+        ValidationHandler(validator=evaluator, interval=2, epoch_level=True),
+        StatsHandler(tag_name="train_loss", output_transform=lambda x: x["loss"]),
+        TensorBoardStatsHandler(log_dir="./runs/", tag_name="train_loss", output_transform=lambda x: x["loss"]),
+        CheckpointSaver(save_dir="./runs/", save_dict={"net": net, "opt": opt}, save_interval=2, epoch_level=True),
+    ]
+
+    trainer = SupervisedTrainer(
+        device=device,
+        max_epochs=5,
+        train_data_loader=train_loader,
+        network=net,
+        optimizer=opt,
+        loss_function=loss,
+        inferer=SimpleInferer(),
+        post_transform=train_post_transforms,
+        key_train_metric={"train_acc": Accuracy(output_transform=lambda x: (x["pred"], x["label"]))},
+        train_handlers=train_handlers,
+        # if no FP16 support in GPU or PyTorch version < 1.6, will not enable AMP training
+        amp=True if monai.config.get_torch_version_tuple() >= (1, 6) else False,
+    )
+    trainer.run()
+
+
+if __name__ == "__main__":
+    with tempfile.TemporaryDirectory() as tempdir:
+        main(tempdir)

testbed/Project-MONAI__MONAI/monai/README.md

@@ -0,0 +1,26 @@
+# MONAI
+
+* **apps**: high level medical domain specific deep learning applications.
+
+* **config**: for system configuration and diagnostic output.
+
+* **data**: for the datasets, readers/writers, and synthetic data
+
+* **engines**: engine-derived classes for extending Ignite behaviour.
+
+* **handlers**: defines handlers for implementing functionality at various stages in the training process.
+
+* **inferers**: defines model inference methods. 
+
+* **losses**: classes defining loss functions.
+
+* **metrics**: defines metric tracking types.
+
+* **networks**: contains network definitions, component definitions, and Pytorch specific utilities.
+
+* **transforms**: defines data transforms for preprocessing and postprocessing.
+
+* **utils**: generic utilities intended to be implemented in pure Python or using Numpy,
+and not with Pytorch, such as namespace aliasing, auto module loading.
+
+* **visualize**: utilities for data visualization.

testbed/Project-MONAI__MONAI/monai/__init__.py

@@ -0,0 +1,33 @@
+# Copyright 2020 MONAI Consortium
+# 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 sys
+
+from ._version import get_versions
+from .utils.module import load_submodules
+
+__version__ = get_versions()["version"]
+del get_versions
+
+__copyright__ = "(c) 2020 MONAI Consortium"
+
+__basedir__ = os.path.dirname(__file__)
+
+# handlers_* have some external decorators the users may not have installed
+# *.so files and folder "_C" may not exist when the cpp extensions are not compiled
+excludes = "(^(handlers))|((\\.so)$)|(_C)"
+
+# load directory modules only, skip loading individual files
+load_submodules(sys.modules[__name__], False, exclude_pattern=excludes)
+
+# load all modules, this will trigger all export decorations
+load_submodules(sys.modules[__name__], True, exclude_pattern=excludes)

testbed/Project-MONAI__MONAI/monai/_version.py

@@ -0,0 +1,519 @@
+# This file helps to compute a version number in source trees obtained from
+# git-archive tarball (such as those provided by githubs download-from-tag
+# feature). Distribution tarballs (built by setup.py sdist) and build
+# directories (produced by setup.py build) will contain a much shorter file
+# that just contains the computed version number.
+
+# This file is released into the public domain. Generated by
+# versioneer-0.18 (https://github.com/warner/python-versioneer)
+
+"""Git implementation of _version.py."""
+
+import errno
+import os
+import re
+import subprocess
+import sys
+
+
+def get_keywords():
+    """Get the keywords needed to look up the version information."""
+    # these strings will be replaced by git during git-archive.
+    # setup.py/versioneer.py will grep for the variable names, so they must
+    # each be defined on a line of their own. _version.py will just call
+    # get_keywords().
+    git_refnames = "$Format:%d$"
+    git_full = "$Format:%H$"
+    git_date = "$Format:%ci$"
+    keywords = {"refnames": git_refnames, "full": git_full, "date": git_date}
+    return keywords
+
+
+class VersioneerConfig:
+    """Container for Versioneer configuration parameters."""
+
+
+def get_config():
+    """Create, populate and return the VersioneerConfig() object."""
+    # these strings are filled in when 'setup.py versioneer' creates
+    # _version.py
+    cfg = VersioneerConfig()
+    cfg.VCS = "git"
+    cfg.style = "pep440"
+    cfg.tag_prefix = ""
+    cfg.parentdir_prefix = ""
+    cfg.versionfile_source = "monai/_version.py"
+    cfg.verbose = False
+    return cfg
+
+
+class NotThisMethod(Exception):
+    """Exception raised if a method is not valid for the current scenario."""
+
+
+LONG_VERSION_PY = {}
+HANDLERS = {}
+
+
+def register_vcs_handler(vcs, method):  # decorator
+    """Decorator to mark a method as the handler for a particular VCS."""
+    def decorate(f):
+        """Store f in HANDLERS[vcs][method]."""
+        if vcs not in HANDLERS:
+            HANDLERS[vcs] = {}
+        HANDLERS[vcs][method] = f
+        return f
+    return decorate
+
+
+def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,
+                env=None):
+    """Call the given command(s)."""
+    assert isinstance(commands, list)
+    p = None
+    for c in commands:
+        try:
+            dispcmd = str([c] + args)
+            # remember shell=False, so use git.cmd on windows, not just git
+            p = subprocess.Popen([c] + args, cwd=cwd, env=env,
+                                 stdout=subprocess.PIPE,
+                                 stderr=(subprocess.PIPE if hide_stderr
+                                         else None))
+            break
+        except EnvironmentError:
+            e = sys.exc_info()[1]
+            if e.errno == errno.ENOENT:
+                continue
+            if verbose:
+                print("unable to run %s" % dispcmd)
+                print(e)
+            return None, None
+    else:
+        if verbose:
+            print("unable to find command, tried %s" % (commands,))
+        return None, None
+    stdout = p.communicate()[0].strip()
+    if sys.version_info[0] >= 3:
+        stdout = stdout.decode()
+    if p.returncode != 0:
+        if verbose:
+            print("unable to run %s (error)" % dispcmd)
+            print("stdout was %s" % stdout)
+        return None, p.returncode
+    return stdout, p.returncode
+
+
+def versions_from_parentdir(parentdir_prefix, root, verbose):
+    """Try to determine the version from the parent directory name.
+
+    Source tarballs conventionally unpack into a directory that includes both
+    the project name and a version string. We will also support searching up
+    two directory levels for an appropriately named parent directory
+    """
+    rootdirs = []
+
+    for i in range(3):
+        dirname = os.path.basename(root)
+        if dirname.startswith(parentdir_prefix):
+            return {"version": dirname[len(parentdir_prefix):],
+                    "full-revisionid": None,
+                    "dirty": False, "error": None, "date": None}
+        else:
+            rootdirs.append(root)
+            root = os.path.dirname(root)  # up a level
+
+    if verbose:
+        print("Tried directories %s but none started with prefix %s" %
+              (str(rootdirs), parentdir_prefix))
+    raise NotThisMethod("rootdir doesn't start with parentdir_prefix")
+
+
+@register_vcs_handler("git", "get_keywords")
+def git_get_keywords(versionfile_abs):
+    """Extract version information from the given file."""
+    # the code embedded in _version.py can just fetch the value of these
+    # keywords. When used from setup.py, we don't want to import _version.py,
+    # so we do it with a regexp instead. This function is not used from
+    # _version.py.
+    keywords = {}
+    try:
+        f = open(versionfile_abs, "r")
+        for line in f.readlines():
+            if line.strip().startswith("git_refnames ="):
+                mo = re.search(r'=\s*"(.*)"', line)
+                if mo:
+                    keywords["refnames"] = mo.group(1)
+            if line.strip().startswith("git_full ="):
+                mo = re.search(r'=\s*"(.*)"', line)
+                if mo:
+                    keywords["full"] = mo.group(1)
+            if line.strip().startswith("git_date ="):
+                mo = re.search(r'=\s*"(.*)"', line)
+                if mo:
+                    keywords["date"] = mo.group(1)
+        f.close()
+    except EnvironmentError:
+        pass
+    return keywords
+
+
+@register_vcs_handler("git", "keywords")
+def git_versions_from_keywords(keywords, tag_prefix, verbose):
+    """Get version information from git keywords."""
+    if not keywords:
+        raise NotThisMethod("no keywords at all, weird")
+    date = keywords.get("date")
+    if date is not None:
+        # git-2.2.0 added "%cI", which expands to an ISO-8601 -compliant
+        # datestamp. However we prefer "%ci" (which expands to an "ISO-8601
+        # -like" string, which we must then edit to make compliant), because
+        # it's been around since git-1.5.3, and it's too difficult to
+        # discover which version we're using, or to work around using an
+        # older one.
+        date = date.strip().replace(" ", "T", 1).replace(" ", "", 1)
+    refnames = keywords["refnames"].strip()
+    if refnames.startswith("$Format"):
+        if verbose:
+            print("keywords are unexpanded, not using")
+        raise NotThisMethod("unexpanded keywords, not a git-archive tarball")
+    refs = set([r.strip() for r in refnames.strip("()").split(",")])
+    # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of
+    # just "foo-1.0". If we see a "tag: " prefix, prefer those.
+    TAG = "tag: "
+    tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)])
+    if not tags:
+        # Either we're using git < 1.8.3, or there really are no tags. We use
+        # a heuristic: assume all version tags have a digit. The old git %d
+        # expansion behaves like git log --decorate=short and strips out the
+        # refs/heads/ and refs/tags/ prefixes that would let us distinguish
+        # between branches and tags. By ignoring refnames without digits, we
+        # filter out many common branch names like "release" and
+        # "stabilization", as well as "HEAD" and "master".
+        tags = set([r for r in refs if re.search(r'\d', r)])
+        if verbose:
+            print("discarding '%s', no digits" % ",".join(refs - tags))
+    if verbose:
+        print("likely tags: %s" % ",".join(sorted(tags)))
+    for ref in sorted(tags):
+        # sorting will prefer e.g. "2.0" over "2.0rc1"
+        if ref.startswith(tag_prefix):
+            r = ref[len(tag_prefix):]
+            if verbose:
+                print("picking %s" % r)
+            return {"version": r,
+                    "full-revisionid": keywords["full"].strip(),
+                    "dirty": False, "error": None,
+                    "date": date}
+    # no suitable tags, so version is "0+unknown", but full hex is still there
+    if verbose:
+        print("no suitable tags, using unknown + full revision id")
+    return {"version": "0+unknown",
+            "full-revisionid": keywords["full"].strip(),
+            "dirty": False, "error": "no suitable tags", "date": None}
+
+
+@register_vcs_handler("git", "pieces_from_vcs")
+def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
+    """Get version from 'git describe' in the root of the source tree.
+
+    This only gets called if the git-archive 'subst' keywords were *not*
+    expanded, and _version.py hasn't already been rewritten with a short
+    version string, meaning we're inside a checked out source tree.
+    """
+    GITS = ["git"]
+    if sys.platform == "win32":
+        GITS = ["git.cmd", "git.exe"]
+
+    out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root,
+                          hide_stderr=True)
+    if rc != 0:
+        if verbose:
+            print("Directory %s not under git control" % root)
+        raise NotThisMethod("'git rev-parse --git-dir' returned error")
+
+    # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty]
+    # if there isn't one, this yields HEX[-dirty] (no NUM)
+    describe_out, rc = run_command(GITS, ["describe", "--tags", "--dirty",
+                                          "--always", "--long",
+                                          "--match", "%s*" % tag_prefix],
+                                   cwd=root)
+    # --long was added in git-1.5.5
+    if describe_out is None:
+        raise NotThisMethod("'git describe' failed")
+    describe_out = describe_out.strip()
+    full_out, rc = run_command(GITS, ["rev-parse", "HEAD"], cwd=root)
+    if full_out is None:
+        raise NotThisMethod("'git rev-parse' failed")
+    full_out = full_out.strip()
+
+    pieces = {}
+    pieces["long"] = full_out
+    pieces["short"] = full_out[:7]  # maybe improved later
+    pieces["error"] = None
+
+    # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty]
+    # TAG might have hyphens.
+    git_describe = describe_out
+
+    # look for -dirty suffix
+    dirty = git_describe.endswith("-dirty")
+    pieces["dirty"] = dirty
+    if dirty:
+        git_describe = git_describe[:git_describe.rindex("-dirty")]
+
+    # now we have TAG-NUM-gHEX or HEX
+
+    if "-" in git_describe:
+        # TAG-NUM-gHEX
+        mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe)
+        if not mo:
+            # unparseable. Maybe git-describe is misbehaving?
+            pieces["error"] = ("unable to parse git-describe output: '%s'"
+                               % describe_out)
+            return pieces
+
+        # tag
+        full_tag = mo.group(1)
+        if not full_tag.startswith(tag_prefix):
+            if verbose:
+                fmt = "tag '%s' doesn't start with prefix '%s'"
+                print(fmt % (full_tag, tag_prefix))
+            pieces["error"] = ("tag '%s' doesn't start with prefix '%s'"
+                               % (full_tag, tag_prefix))
+            return pieces
+        pieces["closest-tag"] = full_tag[len(tag_prefix):]
+
+        # distance: number of commits since tag
+        pieces["distance"] = int(mo.group(2))
+
+        # commit: short hex revision ID
+        pieces["short"] = mo.group(3)
+
+    else:
+        # HEX: no tags
+        pieces["closest-tag"] = None
+        count_out, rc = run_command(GITS, ["rev-list", "HEAD", "--count"],
+                                    cwd=root)
+        pieces["distance"] = int(count_out)  # total number of commits
+
+    # commit date: see ISO-8601 comment in git_versions_from_keywords()
+    date = run_command(GITS, ["show", "-s", "--format=%ci", "HEAD"],
+                       cwd=root)[0].strip()
+    pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1)
+
+    return pieces
+
+
+def plus_or_dot(pieces):
+    """Return a + if we don't already have one, else return a ."""
+    if "+" in pieces.get("closest-tag", ""):
+        return "."
+    return "+"
+
+
+def render_pep440(pieces):
+    """Build up version string, with post-release "local version identifier".
+
+    Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you
+    get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty
+
+    Exceptions:
+    1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty]
+    """
+    if pieces["closest-tag"]:
+        rendered = pieces["closest-tag"]
+        if pieces["distance"] or pieces["dirty"]:
+            rendered += plus_or_dot(pieces)
+            rendered += "%d.g%s" % (pieces["distance"], pieces["short"])
+            if pieces["dirty"]:
+                rendered += ".dirty"
+    else:
+        # exception #1
+        rendered = "0+untagged.%d.g%s" % (pieces["distance"],
+                                          pieces["short"])
+        if pieces["dirty"]:
+            rendered += ".dirty"
+    return rendered
+
+
+def render_pep440_pre(pieces):
+    """TAG[.post.devDISTANCE] -- No -dirty.
+
+    Exceptions:
+    1: no tags. 0.post.devDISTANCE
+    """
+    if pieces["closest-tag"]:
+        rendered = pieces["closest-tag"]
+        if pieces["distance"]:
+            rendered += ".post.dev%d" % pieces["distance"]
+    else:
+        # exception #1
+        rendered = "0.post.dev%d" % pieces["distance"]
+    return rendered
+
+
+def render_pep440_post(pieces):
+    """TAG[.postDISTANCE[.dev0]+gHEX] .
+
+    The ".dev0" means dirty. Note that .dev0 sorts backwards
+    (a dirty tree will appear "older" than the corresponding clean one),
+    but you shouldn't be releasing software with -dirty anyways.
+
+    Exceptions:
+    1: no tags. 0.postDISTANCE[.dev0]
+    """
+    if pieces["closest-tag"]:
+        rendered = pieces["closest-tag"]
+        if pieces["distance"] or pieces["dirty"]:
+            rendered += ".post%d" % pieces["distance"]
+            if pieces["dirty"]:
+                rendered += ".dev0"
+            rendered += plus_or_dot(pieces)
+            rendered += "g%s" % pieces["short"]
+    else:
+        # exception #1
+        rendered = "0.post%d" % pieces["distance"]
+        if pieces["dirty"]:
+            rendered += ".dev0"
+        rendered += "+g%s" % pieces["short"]
+    return rendered
+
+
+def render_pep440_old(pieces):
+    """TAG[.postDISTANCE[.dev0]] .
+
+    The ".dev0" means dirty.
+
+    Exceptions:
+    1: no tags. 0.postDISTANCE[.dev0]
+    """
+    if pieces["closest-tag"]:
+        rendered = pieces["closest-tag"]
+        if pieces["distance"] or pieces["dirty"]:
+            rendered += ".post%d" % pieces["distance"]
+            if pieces["dirty"]:
+                rendered += ".dev0"
+    else:
+        # exception #1
+        rendered = "0.post%d" % pieces["distance"]
+        if pieces["dirty"]:
+            rendered += ".dev0"
+    return rendered
+
+
+def render_git_describe(pieces):
+    """TAG[-DISTANCE-gHEX][-dirty].
+
+    Like 'git describe --tags --dirty --always'.
+
+    Exceptions:
+    1: no tags. HEX[-dirty]  (note: no 'g' prefix)
+    """
+    if pieces["closest-tag"]:
+        rendered = pieces["closest-tag"]
+        if pieces["distance"]:
+            rendered += "-%d-g%s" % (pieces["distance"], pieces["short"])
+    else:
+        # exception #1
+        rendered = pieces["short"]
+    if pieces["dirty"]:
+        rendered += "-dirty"
+    return rendered
+
+
+def render_git_describe_long(pieces):
+    """TAG-DISTANCE-gHEX[-dirty].
+
+    Like 'git describe --tags --dirty --always -long'.
+    The distance/hash is unconditional.
+
+    Exceptions:
+    1: no tags. HEX[-dirty]  (note: no 'g' prefix)
+    """
+    if pieces["closest-tag"]:
+        rendered = pieces["closest-tag"]
+        rendered += "-%d-g%s" % (pieces["distance"], pieces["short"])
+    else:
+        # exception #1
+        rendered = pieces["short"]
+    if pieces["dirty"]:
+        rendered += "-dirty"
+    return rendered
+
+
+def render(pieces, style):
+    """Render the given version pieces into the requested style."""
+    if pieces["error"]:
+        return {"version": "unknown",
+                "full-revisionid": pieces.get("long"),
+                "dirty": None,
+                "error": pieces["error"],
+                "date": None}
+
+    if not style or style == "default":
+        style = "pep440"  # the default
+
+    if style == "pep440":
+        rendered = render_pep440(pieces)
+    elif style == "pep440-pre":
+        rendered = render_pep440_pre(pieces)
+    elif style == "pep440-post":
+        rendered = render_pep440_post(pieces)
+    elif style == "pep440-old":
+        rendered = render_pep440_old(pieces)
+    elif style == "git-describe":
+        rendered = render_git_describe(pieces)
+    elif style == "git-describe-long":
+        rendered = render_git_describe_long(pieces)
+    else:
+        raise ValueError("unknown style '%s'" % style)
+
+    return {"version": rendered, "full-revisionid": pieces["long"],
+            "dirty": pieces["dirty"], "error": None,
+            "date": pieces.get("date")}
+
+
+def get_versions():
+    """Get version information or return default if unable to do so."""
+    # I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have
+    # __file__, we can work backwards from there to the root. Some
+    # py2exe/bbfreeze/non-CPython implementations don't do __file__, in which
+    # case we can only use expanded keywords.
+
+    cfg = get_config()
+    verbose = cfg.verbose
+
+    try:
+        return git_versions_from_keywords(get_keywords(), cfg.tag_prefix,
+                                          verbose)
+    except NotThisMethod:
+        pass
+
+    try:
+        root = os.path.realpath(__file__)
+        # versionfile_source is the relative path from the top of the source
+        # tree (where the .git directory might live) to this file. Invert
+        # this to find the root from __file__.
+        for i in cfg.versionfile_source.split('/'):  # lgtm[py/unused-loop-variable]
+            root = os.path.dirname(root)
+    except NameError:
+        return {"version": "0+unknown", "full-revisionid": None,
+                "dirty": None,
+                "error": "unable to find root of source tree",
+                "date": None}
+
+    try:
+        pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose)
+        return render(pieces, cfg.style)
+    except NotThisMethod:
+        pass
+
+    try:
+        if cfg.parentdir_prefix:
+            return versions_from_parentdir(cfg.parentdir_prefix, root, verbose)
+    except NotThisMethod:
+        pass
+
+    return {"version": "0+unknown", "full-revisionid": None,
+            "dirty": None,
+            "error": "unable to compute version", "date": None}

testbed/Project-MONAI__MONAI/monai/apps/__init__.py

@@ -0,0 +1,13 @@
+# Copyright 2020 MONAI Consortium
+# 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 .datasets import *
+from .utils import *

testbed/Project-MONAI__MONAI/monai/apps/datasets.py

@@ -0,0 +1,265 @@
+# Copyright 2020 MONAI Consortium
+# 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 sys
+from typing import Any, Callable, Dict, List, Optional, Sequence, Union
+
+from monai.apps.utils import download_and_extract
+from monai.data import CacheDataset, load_decathalon_datalist
+from monai.transforms import LoadNiftid, LoadPNGd, Randomizable
+
+
+class MedNISTDataset(Randomizable, CacheDataset):
+    """
+    The Dataset to automatically download MedNIST data and generate items for training, validation or test.
+    It's based on `CacheDataset` to accelerate the training process.
+
+    Args:
+        root_dir: target directory to download and load MedNIST dataset.
+        section: expected data section, can be: `training`, `validation` or `test`.
+        transform: transforms to execute operations on input data. the default transform is `LoadPNGd`,
+            which can load data into numpy array with [H, W] shape. for further usage, use `AddChanneld`
+            to convert the shape to [C, H, W, D].
+        download: whether to download and extract the MedNIST from resource link, default is False.
+            if expected file already exists, skip downloading even set it to True.
+            user can manually copy `MedNIST.tar.gz` file or `MedNIST` folder to root directory.
+        seed: random seed to randomly split training, validation and test datasets, defaut is 0.
+        val_frac: percentage of of validation fraction in the whole dataset, default is 0.1.
+        test_frac: percentage of of test fraction in the whole dataset, default is 0.1.
+        cache_num: number of items to be cached. Default is `sys.maxsize`.
+            will take the minimum of (cache_num, data_length x cache_rate, data_length).
+        cache_rate: percentage of cached data in total, default is 1.0 (cache all).
+            will take the minimum of (cache_num, data_length x cache_rate, data_length).
+        num_workers: the number of worker threads to use.
+            if 0 a single thread will be used. Default is 0.
+
+    Raises:
+        ValueError: When ``root_dir`` is not a directory.
+        RuntimeError: When ``dataset_dir`` doesn't exist and downloading is not selected (``download=False``).
+
+    """
+
+    resource = "https://www.dropbox.com/s/5wwskxctvcxiuea/MedNIST.tar.gz?dl=1"
+    md5 = "0bc7306e7427e00ad1c5526a6677552d"
+    compressed_file_name = "MedNIST.tar.gz"
+    dataset_folder_name = "MedNIST"
+
+    def __init__(
+        self,
+        root_dir: str,
+        section: str,
+        transform: Union[Sequence[Callable], Callable] = LoadPNGd("image"),
+        download: bool = False,
+        seed: int = 0,
+        val_frac: float = 0.1,
+        test_frac: float = 0.1,
+        cache_num: int = sys.maxsize,
+        cache_rate: float = 1.0,
+        num_workers: int = 0,
+    ) -> None:
+        if not os.path.isdir(root_dir):
+            raise ValueError("Root directory root_dir must be a directory.")
+        self.section = section
+        self.val_frac = val_frac
+        self.test_frac = test_frac
+        self.set_random_state(seed=seed)
+        tarfile_name = os.path.join(root_dir, self.compressed_file_name)
+        dataset_dir = os.path.join(root_dir, self.dataset_folder_name)
+        if download:
+            download_and_extract(self.resource, tarfile_name, root_dir, self.md5)
+
+        if not os.path.exists(dataset_dir):
+            raise RuntimeError(
+                f"Cannot find dataset directory: {dataset_dir}, please use download=True to download it."
+            )
+        data = self._generate_data_list(dataset_dir)
+        super().__init__(data, transform, cache_num=cache_num, cache_rate=cache_rate, num_workers=num_workers)
+
+    def randomize(self, data: Optional[Any] = None) -> None:
+        self.rann = self.R.random()
+
+    def _generate_data_list(self, dataset_dir: str) -> List[Dict]:
+        """
+        Raises:
+            ValueError: When ``section`` is not one of ["training", "validation", "test"].
+
+        """
+        class_names = sorted((x for x in os.listdir(dataset_dir) if os.path.isdir(os.path.join(dataset_dir, x))))
+        num_class = len(class_names)
+        image_files = [
+            [
+                os.path.join(dataset_dir, class_names[i], x)
+                for x in os.listdir(os.path.join(dataset_dir, class_names[i]))
+            ]
+            for i in range(num_class)
+        ]
+        num_each = [len(image_files[i]) for i in range(num_class)]
+        image_files_list = []
+        image_class = []
+        for i in range(num_class):
+            image_files_list.extend(image_files[i])
+            image_class.extend([i] * num_each[i])
+        num_total = len(image_class)
+
+        data = list()
+
+        for i in range(num_total):
+            self.randomize()
+            if self.section == "training":
+                if self.rann < self.val_frac + self.test_frac:
+                    continue
+            elif self.section == "validation":
+                if self.rann >= self.val_frac:
+                    continue
+            elif self.section == "test":
+                if self.rann < self.val_frac or self.rann >= self.val_frac + self.test_frac:
+                    continue
+            else:
+                raise ValueError(
+                    f'Unsupported section: {self.section}, available options are ["training", "validation", "test"].'
+                )
+            data.append({"image": image_files_list[i], "label": image_class[i]})
+        return data
+
+
+class DecathlonDataset(Randomizable, CacheDataset):
+    """
+    The Dataset to automatically download the data of Medical Segmentation Decathlon challenge
+    (http://medicaldecathlon.com/) and generate items for training, validation or test.
+    It's based on :py:class:`monai.data.CacheDataset` to accelerate the training process.
+
+    Args:
+        root_dir: user's local directory for caching and loading the MSD datasets.
+        task: which task to download and execute: one of list ("Task01_BrainTumour", "Task02_Heart",
+            "Task03_Liver", "Task04_Hippocampus", "Task05_Prostate", "Task06_Lung", "Task07_Pancreas",
+            "Task08_HepaticVessel", "Task09_Spleen", "Task10_Colon").
+        section: expected data section, can be: `training`, `validation` or `test`.
+        transform: transforms to execute operations on input data. the default transform is `LoadNiftid`,
+            which can load Nifit format data into numpy array with [H, W, D] or [H, W, D, C] shape.
+            for further usage, use `AddChanneld` or `AsChannelFirstd` to convert the shape to [C, H, W, D].
+        download: whether to download and extract the Decathlon from resource link, default is False.
+            if expected file already exists, skip downloading even set it to True.
+            user can manually copy tar file or dataset folder to the root directory.
+        seed: random seed to randomly split `training`, `validation` and `test` datasets, defaut is 0.
+        val_frac: percentage of of validation fraction from the `training` section, default is 0.2.
+            Decathlon data only contains `training` section with labels and `test` section without labels,
+            so randomly select fraction from the `training` section as the `validation` section.
+        cache_num: number of items to be cached. Default is `sys.maxsize`.
+            will take the minimum of (cache_num, data_length x cache_rate, data_length).
+        cache_rate: percentage of cached data in total, default is 1.0 (cache all).
+            will take the minimum of (cache_num, data_length x cache_rate, data_length).
+        num_workers: the number of worker threads to use.
+            if 0 a single thread will be used. Default is 0.
+
+    Raises:
+        ValueError: When ``root_dir`` is not a directory.
+        ValueError: When ``task`` is not one of ["Task01_BrainTumour", "Task02_Heart",
+            "Task03_Liver", "Task04_Hippocampus", "Task05_Prostate", "Task06_Lung", "Task07_Pancreas",
+            "Task08_HepaticVessel", "Task09_Spleen", "Task10_Colon"].
+        RuntimeError: When ``dataset_dir`` doesn't exist and downloading is not selected (``download=False``).
+
+    Example::
+
+        transform = Compose(
+            [
+                LoadNiftid(keys=["image", "label"]),
+                AddChanneld(keys=["image", "label"]),
+                ScaleIntensityd(keys="image"),
+                ToTensord(keys=["image", "label"]),
+            ]
+        )
+
+        data = DecathlonDataset(
+            root_dir="./", task="Task09_Spleen", transform=transform, section="validation", download=True
+        )
+
+        print(data[0]["image"], data[0]["label"])
+
+    """
+
+    resource = {
+        "Task01_BrainTumour": "https://msd-for-monai.s3-us-west-2.amazonaws.com/Task01_BrainTumour.tar",
+        "Task02_Heart": "https://msd-for-monai.s3-us-west-2.amazonaws.com/Task02_Heart.tar",
+        "Task03_Liver": "https://msd-for-monai.s3-us-west-2.amazonaws.com/Task03_Liver.tar",
+        "Task04_Hippocampus": "https://msd-for-monai.s3-us-west-2.amazonaws.com/Task04_Hippocampus.tar",
+        "Task05_Prostate": "https://msd-for-monai.s3-us-west-2.amazonaws.com/Task05_Prostate.tar",
+        "Task06_Lung": "https://msd-for-monai.s3-us-west-2.amazonaws.com/Task06_Lung.tar",
+        "Task07_Pancreas": "https://msd-for-monai.s3-us-west-2.amazonaws.com/Task07_Pancreas.tar",
+        "Task08_HepaticVessel": "https://msd-for-monai.s3-us-west-2.amazonaws.com/Task08_HepaticVessel.tar",
+        "Task09_Spleen": "https://msd-for-monai.s3-us-west-2.amazonaws.com/Task09_Spleen.tar",
+        "Task10_Colon": "https://msd-for-monai.s3-us-west-2.amazonaws.com/Task10_Colon.tar",
+    }
+    md5 = {
+        "Task01_BrainTumour": "240a19d752f0d9e9101544901065d872",
+        "Task02_Heart": "06ee59366e1e5124267b774dbd654057",
+        "Task03_Liver": "a90ec6c4aa7f6a3d087205e23d4e6397",
+        "Task04_Hippocampus": "9d24dba78a72977dbd1d2e110310f31b",
+        "Task05_Prostate": "35138f08b1efaef89d7424d2bcc928db",
+        "Task06_Lung": "8afd997733c7fc0432f71255ba4e52dc",
+        "Task07_Pancreas": "4f7080cfca169fa8066d17ce6eb061e4",
+        "Task08_HepaticVessel": "641d79e80ec66453921d997fbf12a29c",
+        "Task09_Spleen": "410d4a301da4e5b2f6f86ec3ddba524e",
+        "Task10_Colon": "bad7a188931dc2f6acf72b08eb6202d0",
+    }
+
+    def __init__(
+        self,
+        root_dir: str,
+        task: str,
+        section: str,
+        transform: Union[Sequence[Callable], Callable] = LoadNiftid(["image", "label"]),
+        download: bool = False,
+        seed: int = 0,
+        val_frac: float = 0.2,
+        cache_num: int = sys.maxsize,
+        cache_rate: float = 1.0,
+        num_workers: int = 0,
+    ) -> None:
+        if not os.path.isdir(root_dir):
+            raise ValueError("Root directory root_dir must be a directory.")
+        self.section = section
+        self.val_frac = val_frac
+        self.set_random_state(seed=seed)
+        if task not in self.resource:
+            raise ValueError(f"Unsupported task: {task}, available options are: {list(self.resource.keys())}.")
+        dataset_dir = os.path.join(root_dir, task)
+        tarfile_name = f"{dataset_dir}.tar"
+        if download:
+            download_and_extract(self.resource[task], tarfile_name, root_dir, self.md5[task])
+
+        if not os.path.exists(dataset_dir):
+            raise RuntimeError(
+                f"Cannot find dataset directory: {dataset_dir}, please use download=True to download it."
+            )
+        data = self._generate_data_list(dataset_dir)
+        super().__init__(data, transform, cache_num=cache_num, cache_rate=cache_rate, num_workers=num_workers)
+
+    def randomize(self, data: Optional[Any] = None) -> None:
+        self.rann = self.R.random()
+
+    def _generate_data_list(self, dataset_dir: str) -> List[Dict]:
+        section = "training" if self.section in ["training", "validation"] else "test"
+        datalist = load_decathalon_datalist(os.path.join(dataset_dir, "dataset.json"), True, section)
+        if section == "test":
+            return datalist
+        else:
+            data = list()
+            for i in datalist:
+                self.randomize()
+                if self.section == "training":
+                    if self.rann < self.val_frac:
+                        continue
+                else:
+                    if self.rann >= self.val_frac:
+                        continue
+                data.append(i)
+            return data

testbed/Project-MONAI__MONAI/monai/apps/utils.py

@@ -0,0 +1,186 @@
+# Copyright 2020 MONAI Consortium
+# 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 hashlib
+import logging
+import os
+import shutil
+import tarfile
+import zipfile
+from typing import Optional
+from urllib.error import ContentTooShortError, HTTPError, URLError
+from urllib.request import Request, urlopen, urlretrieve
+
+from monai.utils import optional_import, progress_bar
+
+gdown, has_gdown = optional_import("gdown", "3.6")
+
+
+def check_md5(filepath: str, md5_value: Optional[str] = None) -> bool:
+    """
+    check MD5 signature of specified file.
+
+    Args:
+        filepath: path of source file to verify MD5.
+        md5_value: expected MD5 value of the file.
+
+    """
+    if md5_value is not None:
+        md5 = hashlib.md5()
+        try:
+            with open(filepath, "rb") as f:
+                for chunk in iter(lambda: f.read(1024 * 1024), b""):
+                    md5.update(chunk)
+        except Exception as e:
+            print(f"Exception in check_md5: {e}")
+            return False
+        if md5_value != md5.hexdigest():
+            return False
+    else:
+        print(f"expected MD5 is None, skip MD5 check for file {filepath}.")
+
+    return True
+
+
+def download_url(url: str, filepath: str, md5_value: Optional[str] = None) -> None:
+    """
+    Download file from specified URL link, support process bar and MD5 check.
+
+    Args:
+        url: source URL link to download file.
+        filepath: target filepath to save the downloaded file.
+        md5_value: expected MD5 value to validate the downloaded file.
+            if None, skip MD5 validation.
+
+    Raises:
+        RuntimeError: When the MD5 validation of the ``filepath`` existing file fails.
+        RuntimeError: When a network issue or denied permission prevents the
+            file download from ``url`` to ``filepath``.
+        URLError: See urllib.request.urlretrieve.
+        HTTPError: See urllib.request.urlretrieve.
+        ContentTooShortError: See urllib.request.urlretrieve.
+        IOError: See urllib.request.urlretrieve.
+        RuntimeError: When the MD5 validation of the ``url`` downloaded file fails.
+
+    """
+    if os.path.exists(filepath):
+        if not check_md5(filepath, md5_value):
+            raise RuntimeError(f"MD5 check of existing file failed: filepath={filepath}, expected MD5={md5_value}.")
+        print(f"file {filepath} exists, skip downloading.")
+        return
+
+    if url.startswith("https://drive.google.com"):
+        if not has_gdown:
+            raise RuntimeError("To download files from Google Drive, please install the gdown dependency.")
+        os.makedirs(os.path.dirname(filepath), exist_ok=True)
+        gdown.download(url, filepath, quiet=False)
+        if not os.path.exists(filepath):
+            raise RuntimeError(
+                f"Download of file from {url} to {filepath} failed due to network issue or denied permission."
+            )
+    elif url.startswith("https://msd-for-monai.s3-us-west-2.amazonaws.com"):
+        block_size = 1024 * 1024
+        tmp_file_path = filepath + ".part"
+        first_byte = os.path.getsize(tmp_file_path) if os.path.exists(tmp_file_path) else 0
+        file_size = -1
+
+        try:
+            file_size = int(urlopen(url).info().get("Content-Length", -1))
+            progress_bar(index=first_byte, count=file_size)
+
+            while first_byte < file_size:
+                last_byte = first_byte + block_size if first_byte + block_size < file_size else file_size - 1
+
+                req = Request(url)
+                req.headers["Range"] = "bytes=%s-%s" % (first_byte, last_byte)
+                data_chunk = urlopen(req, timeout=10).read()
+                with open(tmp_file_path, "ab") as f:
+                    f.write(data_chunk)
+                progress_bar(index=last_byte, count=file_size)
+                first_byte = last_byte + 1
+        except IOError as e:
+            logging.debug("IO Error - %s" % e)
+        finally:
+            if file_size == os.path.getsize(tmp_file_path):
+                if md5_value and not check_md5(tmp_file_path, md5_value):
+                    raise Exception("Error validating the file against its MD5 hash")
+                shutil.move(tmp_file_path, filepath)
+            elif file_size == -1:
+                raise Exception("Error getting Content-Length from server: %s" % url)
+    else:
+        os.makedirs(os.path.dirname(filepath), exist_ok=True)
+
+        def _process_hook(blocknum: int, blocksize: int, totalsize: int):
+            progress_bar(blocknum * blocksize, totalsize, f"Downloading {filepath.split('/')[-1]}:")
+
+        try:
+            urlretrieve(url, filepath, reporthook=_process_hook)
+            print(f"\ndownloaded file: {filepath}.")
+        except (URLError, HTTPError, ContentTooShortError, IOError) as e:
+            print(f"download failed from {url} to {filepath}.")
+            raise e
+
+    if not check_md5(filepath, md5_value):
+        raise RuntimeError(
+            f"MD5 check of downloaded file failed: URL={url}, filepath={filepath}, expected MD5={md5_value}."
+        )
+
+
+def extractall(filepath: str, output_dir: str, md5_value: Optional[str] = None) -> None:
+    """
+    Extract file to the output directory.
+    Expected file types are: `zip`, `tar.gz` and `tar`.
+
+    Args:
+        filepath: the file path of compressed file.
+        output_dir: target directory to save extracted files.
+        md5_value: expected MD5 value to validate the compressed file.
+            if None, skip MD5 validation.
+
+    Raises:
+        RuntimeError: When the MD5 validation of the ``filepath`` compressed file fails.
+        ValueError: When the ``filepath`` file extension is not one of [zip", "tar.gz", "tar"].
+
+    """
+    target_file = os.path.join(output_dir, os.path.basename(filepath).split(".")[0])
+    if os.path.exists(target_file):
+        print(f"extracted file {target_file} exists, skip extracting.")
+        return
+    if not check_md5(filepath, md5_value):
+        raise RuntimeError(f"MD5 check of compressed file failed: filepath={filepath}, expected MD5={md5_value}.")
+
+    if filepath.endswith("zip"):
+        zip_file = zipfile.ZipFile(filepath)
+        zip_file.extractall(output_dir)
+        zip_file.close()
+    elif filepath.endswith("tar") or filepath.endswith("tar.gz"):
+        tar_file = tarfile.open(filepath)
+        tar_file.extractall(output_dir)
+        tar_file.close()
+    else:
+        raise ValueError('Unsupported file extension, available options are: ["zip", "tar.gz", "tar"].')
+
+
+def download_and_extract(url: str, filepath: str, output_dir: str, md5_value: Optional[str] = None) -> None:
+    """
+    Download file from URL and extract it to the output directory.
+
+    Args:
+        url: source URL link to download file.
+        filepath: the file path of compressed file.
+        output_dir: target directory to save extracted files.
+            defaut is None to save in current directory.
+        md5_value: expected MD5 value to validate the downloaded file.
+            if None, skip MD5 validation.
+
+    """
+    download_url(url=url, filepath=filepath, md5_value=md5_value)
+    extractall(filepath=filepath, output_dir=output_dir, md5_value=md5_value)

testbed/Project-MONAI__MONAI/monai/engines/__init__.py

@@ -0,0 +1,14 @@
+# Copyright 2020 MONAI Consortium
+# 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 .evaluator import *
+from .multi_gpu_supervised_trainer import *
+from .trainer import *

testbed/Project-MONAI__MONAI/monai/engines/evaluator.py

@@ -0,0 +1,280 @@
+# Copyright 2020 MONAI Consortium
+# 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 typing import TYPE_CHECKING, Callable, Dict, Optional, Sequence
+
+import torch
+from torch.utils.data import DataLoader
+
+from monai.engines.utils import CommonKeys as Keys
+from monai.engines.utils import default_prepare_batch
+from monai.engines.workflow import Workflow
+from monai.inferers import Inferer, SimpleInferer
+from monai.transforms import Transform
+from monai.utils import ensure_tuple, exact_version, optional_import
+
+if TYPE_CHECKING:
+    from ignite.engine import Engine
+    from ignite.metrics import Metric
+else:
+    Engine, _ = optional_import("ignite.engine", "0.3.0", exact_version, "Engine")
+    Metric, _ = optional_import("ignite.metrics", "0.3.0", exact_version, "Metric")
+
+
+class Evaluator(Workflow):
+    """
+    Base class for all kinds of evaluators, inherits from Workflow.
+
+    Args:
+        device: an object representing the device on which to run.
+        val_data_loader: Ignite engine use data_loader to run, must be torch.DataLoader.
+        prepare_batch: function to parse image and label for current iteration.
+        iteration_update: the callable function for every iteration, expect to accept `engine`
+            and `batchdata` as input parameters. if not provided, use `self._iteration()` instead.
+        post_transform: execute additional transformation for the model output data.
+            Typically, several Tensor based transforms composed by `Compose`.
+        key_val_metric: compute metric when every iteration completed, and save average value to
+            engine.state.metrics when epoch completed. key_val_metric is the main metric to compare and save the
+            checkpoint into files.
+        additional_metrics: more Ignite metrics that also attach to Ignite Engine.
+        val_handlers: every handler is a set of Ignite Event-Handlers, must have `attach` function, like:
+            CheckpointHandler, StatsHandler, SegmentationSaver, etc.
+        amp: whether to enable auto-mixed-precision evaluation, default is False.
+
+    """
+
+    def __init__(
+        self,
+        device: torch.device,
+        val_data_loader: DataLoader,
+        prepare_batch: Callable = default_prepare_batch,
+        iteration_update: Optional[Callable] = None,
+        post_transform: Optional[Transform] = None,
+        key_val_metric: Optional[Dict[str, Metric]] = None,
+        additional_metrics: Optional[Dict[str, Metric]] = None,
+        val_handlers: Optional[Sequence] = None,
+        amp: bool = False,
+    ) -> None:
+        super().__init__(
+            device=device,
+            max_epochs=1,
+            data_loader=val_data_loader,
+            prepare_batch=prepare_batch,
+            iteration_update=iteration_update,
+            post_transform=post_transform,
+            key_metric=key_val_metric,
+            additional_metrics=additional_metrics,
+            handlers=val_handlers,
+            amp=amp,
+        )
+
+    def run(self, global_epoch: int = 1) -> None:
+        """
+        Execute validation/evaluation based on Ignite Engine.
+
+        Args:
+            global_epoch: the overall epoch if during a training. evaluator engine can get it from trainer.
+
+        """
+        # init env value for current validation process
+        self.state.max_epochs = global_epoch
+        self.state.epoch = global_epoch - 1
+        self.state.iteration = 0
+        super().run()
+
+    def get_validation_stats(self) -> Dict[str, float]:
+        return {"best_validation_metric": self.state.best_metric, "best_validation_epoch": self.state.best_metric_epoch}
+
+
+class SupervisedEvaluator(Evaluator):
+    """
+    Standard supervised evaluation method with image and label(optional), inherits from evaluator and Workflow.
+
+    Args:
+        device: an object representing the device on which to run.
+        val_data_loader: Ignite engine use data_loader to run, must be torch.DataLoader.
+        network: use the network to run model forward.
+        prepare_batch: function to parse image and label for current iteration.
+        iteration_update: the callable function for every iteration, expect to accept `engine`
+            and `batchdata` as input parameters. if not provided, use `self._iteration()` instead.
+        inferer: inference method that execute model forward on input data, like: SlidingWindow, etc.
+        post_transform: execute additional transformation for the model output data.
+            Typically, several Tensor based transforms composed by `Compose`.
+        key_val_metric: compute metric when every iteration completed, and save average value to
+            engine.state.metrics when epoch completed. key_val_metric is the main metric to compare and save the
+            checkpoint into files.
+        additional_metrics: more Ignite metrics that also attach to Ignite Engine.
+        val_handlers: every handler is a set of Ignite Event-Handlers, must have `attach` function, like:
+            CheckpointHandler, StatsHandler, SegmentationSaver, etc.
+        amp: whether to enable auto-mixed-precision evaluation, default is False.
+
+    """
+
+    def __init__(
+        self,
+        device: torch.device,
+        val_data_loader: DataLoader,
+        network: torch.nn.Module,
+        prepare_batch: Callable = default_prepare_batch,
+        iteration_update: Optional[Callable] = None,
+        inferer: Inferer = SimpleInferer(),
+        post_transform: Optional[Transform] = None,
+        key_val_metric: Optional[Dict[str, Metric]] = None,
+        additional_metrics: Optional[Dict[str, Metric]] = None,
+        val_handlers: Optional[Sequence] = None,
+        amp: bool = False,
+    ) -> None:
+        super().__init__(
+            device=device,
+            val_data_loader=val_data_loader,
+            prepare_batch=prepare_batch,
+            iteration_update=iteration_update,
+            post_transform=post_transform,
+            key_val_metric=key_val_metric,
+            additional_metrics=additional_metrics,
+            val_handlers=val_handlers,
+            amp=amp,
+        )
+
+        self.network = network
+        self.inferer = inferer
+
+    def _iteration(self, engine: Engine, batchdata: Dict[str, torch.Tensor]) -> Dict[str, torch.Tensor]:
+        """
+        callback function for the Supervised Evaluation processing logic of 1 iteration in Ignite Engine.
+        Return below items in a dictionary:
+            - IMAGE: image Tensor data for model input, already moved to device.
+            - LABEL: label Tensor data corresponding to the image, already moved to device.
+            - PRED: prediction result of model.
+
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+            batchdata: input data for this iteration, usually can be dictionary or tuple of Tensor data.
+
+        Raises:
+            ValueError: When ``batchdata`` is None.
+
+        """
+        if batchdata is None:
+            raise ValueError("Must provide batch data for current iteration.")
+        inputs, targets = self.prepare_batch(batchdata)
+        inputs = inputs.to(engine.state.device)
+        if targets is not None:
+            targets = targets.to(engine.state.device)
+
+        # execute forward computation
+        self.network.eval()
+        with torch.no_grad():
+            if self.amp:
+                with torch.cuda.amp.autocast():
+                    predictions = self.inferer(inputs, self.network)
+            else:
+                predictions = self.inferer(inputs, self.network)
+
+        return {Keys.IMAGE: inputs, Keys.LABEL: targets, Keys.PRED: predictions}
+
+
+class EnsembleEvaluator(Evaluator):
+    """
+    Ensemble evaluation for multiple models, inherits from evaluator and Workflow.
+    It accepts a list of models for inference and outputs a list of predictions for further operations.
+
+    Args:
+        device: an object representing the device on which to run.
+        val_data_loader: Ignite engine use data_loader to run, must be torch.DataLoader.
+        networks: use the networks to run model forward in order.
+        pred_keys: the keys to store every prediction data.
+            the length must exactly match the number of networks.
+        prepare_batch: function to parse image and label for current iteration.
+        iteration_update: the callable function for every iteration, expect to accept `engine`
+            and `batchdata` as input parameters. if not provided, use `self._iteration()` instead.
+        inferer: inference method that execute model forward on input data, like: SlidingWindow, etc.
+        post_transform: execute additional transformation for the model output data.
+            Typically, several Tensor based transforms composed by `Compose`.
+        key_val_metric: compute metric when every iteration completed, and save average value to
+            engine.state.metrics when epoch completed. key_val_metric is the main metric to compare and save the
+            checkpoint into files.
+        additional_metrics: more Ignite metrics that also attach to Ignite Engine.
+        val_handlers: every handler is a set of Ignite Event-Handlers, must have `attach` function, like:
+            CheckpointHandler, StatsHandler, SegmentationSaver, etc.
+        amp: whether to enable auto-mixed-precision evaluation, default is False.
+
+    """
+
+    def __init__(
+        self,
+        device: torch.device,
+        val_data_loader: DataLoader,
+        networks: Sequence[torch.nn.Module],
+        pred_keys: Sequence[str],
+        prepare_batch: Callable = default_prepare_batch,
+        iteration_update: Optional[Callable] = None,
+        inferer: Inferer = SimpleInferer(),
+        post_transform: Optional[Transform] = None,
+        key_val_metric: Optional[Dict[str, Metric]] = None,
+        additional_metrics: Optional[Dict[str, Metric]] = None,
+        val_handlers: Optional[Sequence] = None,
+        amp: bool = False,
+    ) -> None:
+        super().__init__(
+            device=device,
+            val_data_loader=val_data_loader,
+            prepare_batch=prepare_batch,
+            iteration_update=iteration_update,
+            post_transform=post_transform,
+            key_val_metric=key_val_metric,
+            additional_metrics=additional_metrics,
+            val_handlers=val_handlers,
+            amp=amp,
+        )
+
+        self.networks = ensure_tuple(networks)
+        self.pred_keys = ensure_tuple(pred_keys)
+        self.inferer = inferer
+
+    def _iteration(self, engine: Engine, batchdata: Dict[str, torch.Tensor]) -> Dict[str, torch.Tensor]:
+        """
+        callback function for the Supervised Evaluation processing logic of 1 iteration in Ignite Engine.
+        Return below items in a dictionary:
+            - IMAGE: image Tensor data for model input, already moved to device.
+            - LABEL: label Tensor data corresponding to the image, already moved to device.
+            - pred_keys[0]: prediction result of network 0.
+            - pred_keys[1]: prediction result of network 1.
+            - ... ...
+            - pred_keys[N]: prediction result of network N.
+
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+            batchdata: input data for this iteration, usually can be dictionary or tuple of Tensor data.
+
+        Raises:
+            ValueError: When ``batchdata`` is None.
+
+        """
+        if batchdata is None:
+            raise ValueError("Must provide batch data for current iteration.")
+        inputs, targets = self.prepare_batch(batchdata)
+        inputs = inputs.to(engine.state.device)
+        if targets is not None:
+            targets = targets.to(engine.state.device)
+
+        # execute forward computation
+        predictions = {Keys.IMAGE: inputs, Keys.LABEL: targets}
+        for idx, network in enumerate(self.networks):
+            network.eval()
+            with torch.no_grad():
+                if self.amp:
+                    with torch.cuda.amp.autocast():
+                        predictions.update({self.pred_keys[idx]: self.inferer(inputs, network)})
+                else:
+                    predictions.update({self.pred_keys[idx]: self.inferer(inputs, network)})
+
+        return predictions

testbed/Project-MONAI__MONAI/monai/engines/multi_gpu_supervised_trainer.py

@@ -0,0 +1,136 @@
+# Copyright 2020 MONAI Consortium
+# 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 typing import TYPE_CHECKING, Callable, Dict, Optional, Sequence, Tuple
+
+import torch
+import torch.nn
+from torch.nn.parallel import DataParallel, DistributedDataParallel
+from torch.optim.optimizer import Optimizer
+
+from monai.engines.utils import get_devices_spec
+from monai.utils import exact_version, optional_import
+
+create_supervised_trainer, _ = optional_import("ignite.engine", "0.3.0", exact_version, "create_supervised_trainer")
+create_supervised_evaluator, _ = optional_import("ignite.engine", "0.3.0", exact_version, "create_supervised_evaluator")
+_prepare_batch, _ = optional_import("ignite.engine", "0.3.0", exact_version, "_prepare_batch")
+if TYPE_CHECKING:
+    from ignite.engine import Engine
+    from ignite.metrics import Metric
+else:
+    Engine, _ = optional_import("ignite.engine", "0.3.0", exact_version, "Engine")
+    Metric, _ = optional_import("ignite.metrics", "0.3.0", exact_version, "Metric")
+
+
+def _default_transform(_x: torch.Tensor, _y: torch.Tensor, _y_pred: torch.Tensor, loss: torch.Tensor) -> float:
+    return loss.item()
+
+
+def _default_eval_transform(
+    x: torch.Tensor, y: torch.Tensor, y_pred: torch.Tensor
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    return y_pred, y
+
+
+def create_multigpu_supervised_trainer(
+    net: torch.nn.Module,
+    optimizer: Optimizer,
+    loss_fn: Callable,
+    devices: Optional[Sequence[torch.device]] = None,
+    non_blocking: bool = False,
+    prepare_batch: Callable = _prepare_batch,
+    output_transform: Callable = _default_transform,
+    distributed: bool = False,
+) -> Engine:
+    """
+    Derived from `create_supervised_trainer` in Ignite.
+
+    Factory function for creating a trainer for supervised models.
+
+    Args:
+        net: the network to train.
+        optimizer: the optimizer to use.
+        loss_fn: the loss function to use.
+        devices: device(s) type specification (default: None).
+            Applies to both model and batches. None is all devices used, empty list is CPU only.
+        non_blocking: if True and this copy is between CPU and GPU, the copy may occur asynchronously
+            with respect to the host. For other cases, this argument has no effect.
+        prepare_batch: function that receives `batch`, `device`, `non_blocking` and outputs
+            tuple of tensors `(batch_x, batch_y)`.
+        output_transform: function that receives 'x', 'y', 'y_pred', 'loss' and returns value
+            to be assigned to engine's state.output after each iteration. Default is returning `loss.item()`.
+        distributed: whether convert model to `DistributedDataParallel`, if have multiple devices, use
+            the first device as output device.
+
+    Returns:
+        Engine: a trainer engine with supervised update function.
+
+    Note:
+        `engine.state.output` for this engine is defined by `output_transform` parameter and is the loss
+        of the processed batch by default.
+    """
+
+    devices_ = get_devices_spec(devices)
+    if distributed:
+        net = DistributedDataParallel(net, device_ids=devices_)
+    elif len(devices_) > 1:
+        net = DataParallel(net)
+
+    return create_supervised_trainer(
+        net, optimizer, loss_fn, devices_[0], non_blocking, prepare_batch, output_transform
+    )
+
+
+def create_multigpu_supervised_evaluator(
+    net: torch.nn.Module,
+    metrics: Optional[Dict[str, Metric]] = None,
+    devices: Optional[Sequence[torch.device]] = None,
+    non_blocking: bool = False,
+    prepare_batch: Callable = _prepare_batch,
+    output_transform: Callable = _default_eval_transform,
+    distributed: bool = False,
+) -> Engine:
+    """
+    Derived from `create_supervised_evaluator` in Ignite.
+
+    Factory function for creating an evaluator for supervised models.
+
+    Args:
+        net: the model to train.
+        metrics: a map of metric names to Metrics.
+        devices: device(s) type specification (default: None).
+            Applies to both model and batches. None is all devices used, empty list is CPU only.
+        non_blocking: if True and this copy is between CPU and GPU, the copy may occur asynchronously
+            with respect to the host. For other cases, this argument has no effect.
+        prepare_batch: function that receives `batch`, `device`, `non_blocking` and outputs
+            tuple of tensors `(batch_x, batch_y)`.
+        output_transform: function that receives 'x', 'y', 'y_pred' and returns value
+            to be assigned to engine's state.output after each iteration. Default is returning `(y_pred, y,)`
+            which fits output expected by metrics. If you change it you should use `output_transform` in metrics.
+        distributed: whether convert model to `DistributedDataParallel`, if have multiple devices, use
+            the first device as output device.
+
+    Note:
+        `engine.state.output` for this engine is defined by `output_transform` parameter and is
+        a tuple of `(batch_pred, batch_y)` by default.
+
+    Returns:
+        Engine: an evaluator engine with supervised inference function.
+    """
+
+    devices_ = get_devices_spec(devices)
+
+    if distributed:
+        net = DistributedDataParallel(net, device_ids=devices_)
+    elif len(devices_) > 1:
+        net = DataParallel(net)
+
+    return create_supervised_evaluator(net, metrics, devices_[0], non_blocking, prepare_batch, output_transform)

testbed/Project-MONAI__MONAI/monai/engines/trainer.py

@@ -0,0 +1,297 @@
+# Copyright 2020 MONAI Consortium
+# 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 typing import TYPE_CHECKING, Callable, Dict, Optional, Sequence, Union
+
+import torch
+from torch.optim.optimizer import Optimizer
+from torch.utils.data import DataLoader
+
+from monai.engines.utils import CommonKeys as Keys
+from monai.engines.utils import GanKeys, default_make_latent, default_prepare_batch
+from monai.engines.workflow import Workflow
+from monai.inferers import Inferer, SimpleInferer
+from monai.transforms import Transform
+from monai.utils import exact_version, optional_import
+
+if TYPE_CHECKING:
+    from ignite.engine import Engine
+    from ignite.metrics import Metric
+else:
+    Engine, _ = optional_import("ignite.engine", "0.3.0", exact_version, "Engine")
+    Metric, _ = optional_import("ignite.metrics", "0.3.0", exact_version, "Metric")
+
+
+class Trainer(Workflow):
+    """
+    Base class for all kinds of trainers, inherits from Workflow.
+
+    """
+
+    def run(self) -> None:
+        """
+        Execute training based on Ignite Engine.
+        If call this function multiple times, it will continuously run from the previous state.
+
+        """
+        if self._is_done(self.state):
+            self.state.iteration = 0  # to avoid creating new State instance in ignite Engine.run
+        self.scaler = torch.cuda.amp.GradScaler() if self.amp else None
+        super().run()
+
+    def get_train_stats(self) -> Dict[str, float]:
+        return {"total_epochs": self.state.max_epochs, "total_iterations": self.state.epoch_length}
+
+
+class SupervisedTrainer(Trainer):
+    """
+    Standard supervised training method with image and label, inherits from ``Trainer`` and ``Workflow``.
+
+    Args:
+        device: an object representing the device on which to run.
+        max_epochs: the total epoch number for trainer to run.
+        train_data_loader: Ignite engine use data_loader to run, must be torch.DataLoader.
+        network: to train with this network.
+        optimizer: the optimizer associated to the network.
+        loss_function: the loss function associated to the optimizer.
+        prepare_batch: function to parse image and label for current iteration.
+        iteration_update: the callable function for every iteration, expect to accept `engine`
+            and `batchdata` as input parameters. if not provided, use `self._iteration()` instead.
+        inferer: inference method that execute model forward on input data, like: SlidingWindow, etc.
+        post_transform: execute additional transformation for the model output data.
+            Typically, several Tensor based transforms composed by `Compose`.
+        key_train_metric: compute metric when every iteration completed, and save average value to
+            engine.state.metrics when epoch completed. key_train_metric is the main metric to compare and save the
+            checkpoint into files.
+        additional_metrics: more Ignite metrics that also attach to Ignite Engine.
+        train_handlers: every handler is a set of Ignite Event-Handlers, must have `attach` function, like:
+            CheckpointHandler, StatsHandler, SegmentationSaver, etc.
+        amp: whether to enable auto-mixed-precision training, default is False.
+
+    """
+
+    def __init__(
+        self,
+        device: torch.device,
+        max_epochs: int,
+        train_data_loader: DataLoader,
+        network: torch.nn.Module,
+        optimizer: Optimizer,
+        loss_function: Callable,
+        prepare_batch: Callable = default_prepare_batch,
+        iteration_update: Optional[Callable] = None,
+        inferer: Inferer = SimpleInferer(),
+        post_transform: Optional[Transform] = None,
+        key_train_metric: Optional[Dict[str, Metric]] = None,
+        additional_metrics: Optional[Dict[str, Metric]] = None,
+        train_handlers: Optional[Sequence] = None,
+        amp: bool = False,
+    ) -> None:
+        # set up Ignite engine and environments
+        super().__init__(
+            device=device,
+            max_epochs=max_epochs,
+            data_loader=train_data_loader,
+            prepare_batch=prepare_batch,
+            iteration_update=iteration_update,
+            post_transform=post_transform,
+            key_metric=key_train_metric,
+            additional_metrics=additional_metrics,
+            handlers=train_handlers,
+            amp=amp,
+        )
+
+        self.network = network
+        self.optimizer = optimizer
+        self.loss_function = loss_function
+        self.inferer = inferer
+
+    def _iteration(self, engine: Engine, batchdata: Dict[str, torch.Tensor]):
+        """
+        Callback function for the Supervised Training processing logic of 1 iteration in Ignite Engine.
+        Return below items in a dictionary:
+            - IMAGE: image Tensor data for model input, already moved to device.
+            - LABEL: label Tensor data corresponding to the image, already moved to device.
+            - PRED: prediction result of model.
+            - LOSS: loss value computed by loss function.
+
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+            batchdata: input data for this iteration, usually can be dictionary or tuple of Tensor data.
+
+        Raises:
+            ValueError: When ``batchdata`` is None.
+
+        """
+        if batchdata is None:
+            raise ValueError("Must provide batch data for current iteration.")
+        inputs, targets = self.prepare_batch(batchdata)
+        inputs, targets = inputs.to(engine.state.device), targets.to(engine.state.device)
+
+        self.network.train()
+        self.optimizer.zero_grad()
+        if self.amp and self.scaler is not None:
+            with torch.cuda.amp.autocast():
+                predictions = self.inferer(inputs, self.network)
+                loss = self.loss_function(predictions, targets).mean()
+            self.scaler.scale(loss).backward()
+            self.scaler.step(self.optimizer)
+            self.scaler.update()
+        else:
+            predictions = self.inferer(inputs, self.network)
+            loss = self.loss_function(predictions, targets).mean()
+            loss.backward()
+            self.optimizer.step()
+
+        return {Keys.IMAGE: inputs, Keys.LABEL: targets, Keys.PRED: predictions, Keys.LOSS: loss.item()}
+
+
+class GanTrainer(Trainer):
+    """
+    Generative adversarial network training based on Goodfellow et al. 2014 https://arxiv.org/abs/1406.266,
+    inherits from ``Trainer`` and ``Workflow``.
+
+    Training Loop: for each batch of data size `m`
+        1. Generate `m` fakes from random latent codes.
+        2. Update discriminator with these fakes and current batch reals, repeated d_train_steps times.
+        3. If g_update_latents, generate `m` fakes from new random latent codes.
+        4. Update generator with these fakes using discriminator feedback.
+
+    Args:
+        device: an object representing the device on which to run.
+        max_epochs: the total epoch number for engine to run.
+        train_data_loader: Core ignite engines uses `DataLoader` for training loop batchdata.
+        g_network: generator (G) network architecture.
+        g_optimizer: G optimizer function.
+        g_loss_function: G loss function for optimizer.
+        d_network: discriminator (D) network architecture.
+        d_optimizer: D optimizer function.
+        d_loss_function: D loss function for optimizer.
+        g_inferer: inference method to execute G model forward. Defaults to ``SimpleInferer()``.
+        d_inferer: inference method to execute D model forward. Defaults to ``SimpleInferer()``.
+        d_train_steps: number of times to update D with real data minibatch. Defaults to ``1``.
+        latent_shape: size of G input latent code. Defaults to ``64``.
+        d_prepare_batch: callback function to prepare batchdata for D inferer.
+            Defaults to return ``GanKeys.REALS`` in batchdata dict.
+        g_prepare_batch: callback function to create batch of latent input for G inferer.
+            Defaults to return random latents.
+        g_update_latents: Calculate G loss with new latent codes. Defaults to ``True``.
+        iteration_update: the callable function for every iteration, expect to accept `engine`
+            and `batchdata` as input parameters. if not provided, use `self._iteration()` instead.
+        post_transform: execute additional transformation for the model output data.
+            Typically, several Tensor based transforms composed by `Compose`.
+        key_train_metric: compute metric when every iteration completed, and save average value to
+            engine.state.metrics when epoch completed. key_train_metric is the main metric to compare and save the
+            checkpoint into files.
+        additional_metrics: more Ignite metrics that also attach to Ignite Engine.
+        train_handlers: every handler is a set of Ignite Event-Handlers, must have `attach` function, like:
+            CheckpointHandler, StatsHandler, SegmentationSaver, etc.
+
+    """
+
+    def __init__(
+        self,
+        device: torch.device,
+        max_epochs: int,
+        train_data_loader: DataLoader,
+        g_network: torch.nn.Module,
+        g_optimizer: Optimizer,
+        g_loss_function: Callable,
+        d_network: torch.nn.Module,
+        d_optimizer: Optimizer,
+        d_loss_function: Callable,
+        g_inferer: Inferer = SimpleInferer(),
+        d_inferer: Inferer = SimpleInferer(),
+        d_train_steps: int = 1,
+        latent_shape: int = 64,
+        d_prepare_batch: Callable = default_prepare_batch,
+        g_prepare_batch: Callable = default_make_latent,
+        g_update_latents: bool = True,
+        iteration_update: Optional[Callable] = None,
+        post_transform: Optional[Transform] = None,
+        key_train_metric: Optional[Dict[str, Metric]] = None,
+        additional_metrics: Optional[Dict[str, Metric]] = None,
+        train_handlers: Optional[Sequence] = None,
+    ):
+        # set up Ignite engine and environments
+        super().__init__(
+            device=device,
+            max_epochs=max_epochs,
+            data_loader=train_data_loader,
+            prepare_batch=d_prepare_batch,
+            iteration_update=iteration_update,
+            key_metric=key_train_metric,
+            additional_metrics=additional_metrics,
+            handlers=train_handlers,
+            post_transform=post_transform,
+        )
+        self.g_network = g_network
+        self.g_optimizer = g_optimizer
+        self.g_loss_function = g_loss_function
+        self.g_inferer = g_inferer
+        self.d_network = d_network
+        self.d_optimizer = d_optimizer
+        self.d_loss_function = d_loss_function
+        self.d_inferer = d_inferer
+        self.d_train_steps = d_train_steps
+        self.latent_shape = latent_shape
+        self.g_prepare_batch = g_prepare_batch
+        self.g_update_latents = g_update_latents
+
+    def _iteration(
+        self, engine: Engine, batchdata: Union[Dict, Sequence]
+    ) -> Dict[str, Union[torch.Tensor, int, float, bool]]:
+        """
+        Callback function for Adversarial Training processing logic of 1 iteration in Ignite Engine.
+
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+            batchdata: input data for this iteration, usually can be dictionary or tuple of Tensor data.
+
+        Raises:
+            ValueError: must provide batch data for current iteration.
+
+        """
+        if batchdata is None:
+            raise ValueError("must provide batch data for current iteration.")
+
+        d_input = self.prepare_batch(batchdata).to(engine.state.device)
+        batch_size = self.data_loader.batch_size
+        g_input = self.g_prepare_batch(batch_size, self.latent_shape, batchdata).to(engine.state.device)
+        g_output = self.g_inferer(g_input, self.g_network)
+
+        # Train Discriminator
+        d_total_loss = torch.zeros(
+            1,
+        )
+        for _ in range(self.d_train_steps):
+            self.d_optimizer.zero_grad()
+            dloss = self.d_loss_function(g_output, d_input)
+            dloss.backward()
+            self.d_optimizer.step()
+            d_total_loss += dloss.item()
+
+        # Train Generator
+        if self.g_update_latents:
+            g_input = self.g_prepare_batch(batch_size, self.latent_shape, batchdata).to(engine.state.device)
+        g_output = self.g_inferer(g_input, self.g_network)
+        self.g_optimizer.zero_grad()
+        g_loss = self.g_loss_function(g_output)
+        g_loss.backward()
+        self.g_optimizer.step()
+
+        return {
+            GanKeys.REALS: d_input,
+            GanKeys.FAKES: g_output,
+            GanKeys.LATENTS: g_input,
+            GanKeys.GLOSS: g_loss.item(),
+            GanKeys.DLOSS: d_total_loss.item(),
+        }

testbed/Project-MONAI__MONAI/monai/engines/utils.py

@@ -0,0 +1,90 @@
+# Copyright 2020 MONAI Consortium
+# 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 typing import Dict, List, Optional, Sequence, Tuple, Union
+
+import torch
+
+
+class CommonKeys:
+    """
+    A set of common keys for dictionary based supervised training process.
+    `IMAGE` is the input image data.
+    `LABEL` is the training or evaluation label of segmentation or classification task.
+    `PRED` is the prediction data of model output.
+    `LOSS` is the loss value of current iteration.
+    `INFO` is some useful information during training or evaluation, like loss value, etc.
+
+    """
+
+    IMAGE = "image"
+    LABEL = "label"
+    PRED = "pred"
+    LOSS = "loss"
+
+
+class GanKeys:
+    """
+    A set of common keys for generative adversarial networks.
+    """
+
+    REALS = "reals"
+    FAKES = "fakes"
+    LATENTS = "latents"
+    GLOSS = "g_loss"
+    DLOSS = "d_loss"
+
+
+def get_devices_spec(devices: Optional[Sequence[torch.device]] = None) -> List[torch.device]:
+    """
+    Get a valid specification for one or more devices. If `devices` is None get devices for all CUDA devices available.
+    If `devices` is and zero-length structure a single CPU compute device is returned. In any other cases `devices` is
+    returned unchanged.
+
+    Args:
+        devices: list of devices to request, None for all GPU devices, [] for CPU.
+
+    Raises:
+        RuntimeError: When all GPUs are selected (``devices=None``) but no GPUs are available.
+
+    Returns:
+        list of torch.device: list of devices.
+
+    """
+    if devices is None:
+        devices = [torch.device(f"cuda:{d:d}") for d in range(torch.cuda.device_count())]
+
+        if len(devices) == 0:
+            raise RuntimeError("No GPU devices available.")
+
+    elif len(devices) == 0:
+        devices = [torch.device("cpu")]
+
+    else:
+        devices = list(devices)
+
+    return devices
+
+
+def default_prepare_batch(
+    batchdata: Dict[str, torch.Tensor]
+) -> Union[Tuple[torch.Tensor, Optional[torch.Tensor]], torch.Tensor]:
+    assert isinstance(batchdata, dict), "default prepare_batch expects dictionary input data."
+    if CommonKeys.LABEL in batchdata:
+        return (batchdata[CommonKeys.IMAGE], batchdata[CommonKeys.LABEL])
+    elif GanKeys.REALS in batchdata:
+        return batchdata[GanKeys.REALS]
+    else:
+        return (batchdata[CommonKeys.IMAGE], None)
+
+
+def default_make_latent(num_latents: int, latent_size: int, real_data: Optional[torch.Tensor] = None) -> torch.Tensor:
+    return torch.randn(num_latents, latent_size)

testbed/Project-MONAI__MONAI/monai/engines/workflow.py

@@ -0,0 +1,172 @@
+# Copyright 2020 MONAI Consortium
+# 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 typing import TYPE_CHECKING, Callable, Dict, Optional, Sequence
+
+import torch
+from torch.utils.data import DataLoader
+from torch.utils.data.distributed import DistributedSampler
+
+from monai.engines.utils import default_prepare_batch
+from monai.transforms import apply_transform
+from monai.utils import ensure_tuple, exact_version, optional_import
+
+IgniteEngine, _ = optional_import("ignite.engine", "0.3.0", exact_version, "Engine")
+State, _ = optional_import("ignite.engine", "0.3.0", exact_version, "State")
+Events, _ = optional_import("ignite.engine", "0.3.0", exact_version, "Events")
+if TYPE_CHECKING:
+    from ignite.engine import Engine
+    from ignite.metrics import Metric
+else:
+    Engine, _ = optional_import("ignite.engine", "0.3.0", exact_version, "Engine")
+    Metric, _ = optional_import("ignite.metrics", "0.3.0", exact_version, "Metric")
+
+
+class Workflow(IgniteEngine):  # type: ignore[valid-type, misc] # due to optional_import
+    """
+    Workflow defines the core work process inheriting from Ignite engine.
+    All trainer, validator and evaluator share this same workflow as base class,
+    because they all can be treated as same Ignite engine loops.
+    It initializes all the sharable data in Ignite engine.state.
+    And attach additional processing logics to Ignite engine based on Event-Handler mechanism.
+
+    Users should consider to inherit from `trainer` or `evaluator` to develop more trainers or evaluators.
+
+    Args:
+        device: an object representing the device on which to run.
+        max_epochs: the total epoch number for engine to run, validator and evaluator have only 1 epoch.
+        data_loader: Ignite engine use data_loader to run, must be torch.DataLoader.
+        prepare_batch: function to parse image and label for every iteration.
+        iteration_update: the callable function for every iteration, expect to accept `engine`
+            and `batchdata` as input parameters. if not provided, use `self._iteration()` instead.
+        post_transform: execute additional transformation for the model output data.
+            Typically, several Tensor based transforms composed by `Compose`.
+        key_metric: compute metric when every iteration completed, and save average value to
+            engine.state.metrics when epoch completed. key_metric is the main metric to compare and save the
+            checkpoint into files.
+        additional_metrics: more Ignite metrics that also attach to Ignite Engine.
+        handlers: every handler is a set of Ignite Event-Handlers, must have `attach` function, like:
+            CheckpointHandler, StatsHandler, SegmentationSaver, etc.
+        amp: whether to enable auto-mixed-precision training or inference, default is False.
+
+    Raises:
+        TypeError: When ``device`` is not a ``torch.Device``.
+        TypeError: When ``data_loader`` is not a ``torch.utils.data.DataLoader``.
+        TypeError: When ``key_metric`` is not a ``Optional[dict]``.
+        TypeError: When ``additional_metrics`` is not a ``Optional[dict]``.
+
+    """
+
+    def __init__(
+        self,
+        device: torch.device,
+        max_epochs: int,
+        data_loader: DataLoader,
+        prepare_batch: Callable = default_prepare_batch,
+        iteration_update: Optional[Callable] = None,
+        post_transform: Optional[Callable] = None,
+        key_metric: Optional[Dict[str, Metric]] = None,
+        additional_metrics: Optional[Dict[str, Metric]] = None,
+        handlers: Optional[Sequence] = None,
+        amp: bool = False,
+    ) -> None:
+        if iteration_update is not None:
+            super().__init__(iteration_update)
+        else:
+            super().__init__(self._iteration)
+        if not isinstance(device, torch.device):
+            raise TypeError(f"device must be a torch.device but is {type(device).__name__}.")
+        if not isinstance(data_loader, DataLoader):
+            raise TypeError(f"data_loader must be a torch.utils.data.DataLoader but is {type(data_loader).__name__}.")
+        sampler = data_loader.__dict__["sampler"]
+        if isinstance(sampler, DistributedSampler):
+
+            @self.on(Events.EPOCH_STARTED)
+            def set_sampler_epoch(engine: Engine):
+                sampler.set_epoch(engine.state.epoch)
+
+        # set all sharable data for the workflow based on Ignite engine.state
+        self.state = State(
+            seed=0,
+            iteration=0,
+            epoch=0,
+            max_epochs=max_epochs,
+            epoch_length=-1,
+            output=None,
+            batch=None,
+            metrics={},
+            dataloader=None,
+            device=device,
+            key_metric_name=None,  # we can set many metrics, only use key_metric to compare and save the best model
+            best_metric=-1,
+            best_metric_epoch=-1,
+        )
+        self.data_loader = data_loader
+        self.prepare_batch = prepare_batch
+
+        if post_transform is not None:
+
+            @self.on(Events.ITERATION_COMPLETED)
+            def run_post_transform(engine: Engine) -> None:
+                assert post_transform is not None
+                engine.state.output = apply_transform(post_transform, engine.state.output)
+
+        if key_metric is not None:
+
+            if not isinstance(key_metric, dict):
+                raise TypeError(f"key_metric must be None or a dict but is {type(key_metric).__name__}.")
+            self.state.key_metric_name = list(key_metric.keys())[0]
+            metrics = key_metric
+            if additional_metrics is not None and len(additional_metrics) > 0:
+                if not isinstance(additional_metrics, dict):
+                    raise TypeError(
+                        f"additional_metrics must be None or a dict but is {type(additional_metrics).__name__}."
+                    )
+                metrics.update(additional_metrics)
+            for name, metric in metrics.items():
+                metric.attach(self, name)
+
+            @self.on(Events.EPOCH_COMPLETED)
+            def _compare_metrics(engine: Engine) -> None:
+                if engine.state.key_metric_name is not None:
+                    current_val_metric = engine.state.metrics[engine.state.key_metric_name]
+                    if current_val_metric > engine.state.best_metric:
+                        self.logger.info(f"Got new best metric of {engine.state.key_metric_name}: {current_val_metric}")
+                        engine.state.best_metric = current_val_metric
+                        engine.state.best_metric_epoch = engine.state.epoch
+
+        if handlers is not None:
+            handlers_ = ensure_tuple(handlers)
+            for handler in handlers_:
+                handler.attach(self)
+        self.amp = amp
+
+    def run(self) -> None:
+        """
+        Execute training, validation or evaluation based on Ignite Engine.
+
+        """
+        super().run(data=self.data_loader, epoch_length=len(self.data_loader))
+
+    def _iteration(self, engine: Engine, batchdata: Dict[str, torch.Tensor]):
+        """
+        Abstract callback function for the processing logic of 1 iteration in Ignite Engine.
+        Need subclass to implement different logics, like SupervisedTrainer/Evaluator, GANTrainer, etc.
+
+        Args:
+            engine: Ignite Engine, it can be a trainer, validator or evaluator.
+            batchdata: input data for this iteration, usually can be dictionary or tuple of Tensor data.
+
+        Raises:
+            NotImplementedError: When the subclass does not override this method.
+
+        """
+        raise NotImplementedError(f"Subclass {self.__class__.__name__} must implement this method.")

testbed/Project-MONAI__MONAI/monai/inferers/__init__.py

@@ -0,0 +1,13 @@
+# Copyright 2020 MONAI Consortium
+# 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 .inferer import *
+from .utils import sliding_window_inference

testbed/Project-MONAI__MONAI/monai/inferers/inferer.py

@@ -0,0 +1,110 @@
+# Copyright 2020 MONAI Consortium
+# 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 abc import ABC, abstractmethod
+from typing import Sequence, Union
+
+import torch
+
+from monai.inferers.utils import sliding_window_inference
+from monai.utils import BlendMode
+
+
+class Inferer(ABC):
+    """
+    A base class for model inference.
+    Extend this class to support operations during inference, e.g. a sliding window method.
+    """
+
+    @abstractmethod
+    def __call__(self, inputs: torch.Tensor, network: torch.nn.Module):
+        """
+        Run inference on `inputs` with the `network` model.
+
+        Args:
+            inputs: input of the model inference.
+            network: model for inference.
+
+        Raises:
+            NotImplementedError: When the subclass does not override this method.
+
+        """
+        raise NotImplementedError(f"Subclass {self.__class__.__name__} must implement this method.")
+
+
+class SimpleInferer(Inferer):
+    """
+    SimpleInferer is the normal inference method that run model forward() directly.
+
+    """
+
+    def __init__(self) -> None:
+        Inferer.__init__(self)
+
+    def __call__(self, inputs: torch.Tensor, network: torch.nn.Module):
+        """Unified callable function API of Inferers.
+
+        Args:
+            inputs: model input data for inference.
+            network: target model to execute inference.
+
+        """
+        return network(inputs)
+
+
+class SlidingWindowInferer(Inferer):
+    """
+    Sliding window method for model inference,
+    with `sw_batch_size` windows for every model.forward().
+
+    Args:
+        roi_size: the window size to execute SlidingWindow evaluation.
+            If it has non-positive components, the corresponding `inputs` size will be used.
+            if the components of the `roi_size` are non-positive values, the transform will use the
+            corresponding components of img size. For example, `roi_size=(32, -1)` will be adapted
+            to `(32, 64)` if the second spatial dimension size of img is `64`.
+        sw_batch_size: the batch size to run window slices.
+        overlap: Amount of overlap between scans.
+        mode: {``"constant"``, ``"gaussian"``}
+            How to blend output of overlapping windows. Defaults to ``"constant"``.
+
+            - ``"constant``": gives equal weight to all predictions.
+            - ``"gaussian``": gives less weight to predictions on edges of windows.
+
+    Note:
+        the "sw_batch_size" here is to run a batch of window slices of 1 input image,
+        not batch size of input images.
+
+    """
+
+    def __init__(
+        self,
+        roi_size: Union[Sequence[int], int],
+        sw_batch_size: int = 1,
+        overlap: float = 0.25,
+        mode: Union[BlendMode, str] = BlendMode.CONSTANT,
+    ) -> None:
+        Inferer.__init__(self)
+        self.roi_size = roi_size
+        self.sw_batch_size = sw_batch_size
+        self.overlap = overlap
+        self.mode: BlendMode = BlendMode(mode)
+
+    def __call__(self, inputs: torch.Tensor, network: torch.nn.Module) -> torch.Tensor:
+        """
+        Unified callable function API of Inferers.
+
+        Args:
+            inputs: model input data for inference.
+            network: target model to execute inference.
+
+        """
+        return sliding_window_inference(inputs, self.roi_size, self.sw_batch_size, network, self.overlap, self.mode)