Add files using upload-large-folder tool

kits21/kits21/.gitignore

@@ -0,0 +1,19 @@
+kits21/data/*/imaging.nii.gz
+*__pycache__*
+
+.idea
+
+kits21/data/*/segmentation_samples*
+regenerates.sh
+kits21/data/*/*segmentation_samples*
+
+*.egg-info
+*.vscode*
+
+*inter_rater_disagreement.json
+*inter_rater_variability.json
+*tolerances.json
+
+*temp.tmp
+
+examples/submission/dummy_submission/**.tar.gz

kits21/kits21/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Nicholas Heller
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

kits21/kits21/README.md

@@ -0,0 +1,131 @@
+## NEW: The KiTS23 Challenge is Underway!
+
+See the [KiTS23 Homepage](https://kits-challenge.org/kits23/) for more details, including:
+
+- A larger dataset
+- Additional contrast phases
+
+# KiTS21
+
+The official repository of the 2021 Kidney and Kidney Tumor Segmentation Challenge
+
+**Current dataset version: `2.2.3` -- Official Frozen Training Set** (see [changelog](changelog.md))
+
+<img src="https://kits-challenge.org/public/site_media/figures/rendering_dimmed.png" width="400" />
+
+[Challenge Homepage](https://kits-challenge.org/kits21/)
+
+## Timeline
+
+- **Mar 1 - Jul 1**: Annotation, Release, and Refinement of Training Data (*now published!*)
+- **July 15**: Further refinement of training set will be complete
+- **Aug 23**: Deadline for Intention to Submit & Required Paper (formerly Aug 9)
+- **Aug 30 - Sep 13**: Submissions Accepted (formerly Aug 16 - 30)
+- **Sep 15**: Results Announced (formerly Sep 1)
+- **Sep 27**: Satellite Event at MICCAI 2021
+
+## News
+
+- **July 15, 2021**: The training set has been frozen!
+- **July 1, 2021**: The training set has been released! Also we are adding a two-week buffer for final edits to be made based on community feedback, and we are pushing the challenge timeline by two weeks (see above).
+- **June 17, 2021**: We've changed the set of classes for the challenge. See [this forum post](https://discourse.kits-challenge.org/t/kits21-challenge-update/354) for details
+- **Apr 7, 2021**: We've started using tags and a changelog to keep track of the dataset version
+- **Mar 23, 2021**: A draft of the postprocessing code and some preliminary data has been merged into the master branch.
+- **Mar 9, 2021**: A preliminary challenge homepage has been published at [kits-challenge.org](https://kits-challenge.org). You can keep tabs on the data annotation process there.
+- **Mar 29, 2020**: A second edition of KiTS was accepted to be held in conjunction with MICCAI 2021 in Strasbourg! More information will be posted here and on the [discussion forum](https://discourse.kits-challenge.org/) when it becomes available.
+
+## Usage
+
+### Installation
+
+1) Install dependency for surface dice:\
+`pip install git+https://github.com/JoHof/surface-distance.git` (the original [DeepMind repository](https://github.com/deepmind/surface-distance) is currently not working due to a [missing line comment](https://github.com/deepmind/surface-distance/blob/4315531eb2d449310d47c0850f334cc6a6580543/surface_distance/metrics.py#L102))
+2) Clone this repository
+3) Install this repository by running `pip install -e .` in the folder where the setup.py file is located
+
+### Download
+
+Start by cloning this repository, but note that **the imaging is not stored here**, it must be downloaded using one of the `get_imaging` scripts in the `starter_code` directory. Currently there are implementations in:
+
+- **python3**: `python3 kits21/starter_code/get_imaging.py`
+- **MATLAB**: `matlab kits21/starter_code/get_imaging.m`
+- **bash**: `bash kits21/starter_code/get_imaging.sh`
+- **julia**: `julia kits21/starter_code/get_imaging.jl`
+
+If you would like to request another implementation of `get_imaging`, please [submit an issue](https://github.com/neheller/kits21/issues/new).
+
+## Folder Structure
+
+### `data/`
+
+```text
+kits21
+├──data/
+|   ├── case_00000/
+|   |   ├── raw/
+|   |   ├── segmentations/
+|   |   ├── imaging.nii.gz
+|   |   ├── aggregated_OR_seg.nii.gz
+|   |   ├── aggregated_AND_seg.nii.gz
+|   |   └── aggregated_MAJ_seg.nii.gz
+|   ├── case_00001/
+|   |   ├── raw/
+|   |   ├── segmentations/
+|   |   ├── imaging.nii.gz
+|   |   ├── aggregated_OR_seg.nii.gz
+|   |   ├── aggregated_AND_seg.nii.gz
+|   |   └── aggregated_MAJ_seg.nii.gz
+...
+|   ├── case_00299/
+|   |   ├── raw/
+|   |   ├── segmentations/
+|   |   ├── imaging.nii.gz
+|   |   ├── aggregated_OR_seg.nii.gz
+|   |   ├── aggregated_AND_seg.nii.gz
+|   |   └── aggregated_MAJ_seg.nii.gz
+└── ├── kits.json
+```
+
+This is different from [KiTS19](https://github.com/neheller/kits19) because unlike 2019, we now have multiple annotations per "instance" and multiple instances per region.
+
+Consider the "kidney" label in a scan: most patients have two kidneys (i.e., two "instances" of kidney), and each instance was annotated by three independent people. That case's `segmentations/` we would thus have
+
+- `kidney_instance-1_annotation-1.nii.gz`
+- `kidney_instance-1_annotation-2.nii.gz`
+- `kidney_instance-1_annotation-3.nii.gz`
+- `kidney_instance-2_annotation-1.nii.gz`
+- `kidney_instance-2_annotation-2.nii.gz`
+- `kidney_instance-2_annotation-3.nii.gz`
+
+along with similar collections for `cyst`, and `tumor` regions. The `aggregated_<X>_seg.nii.gz` file is a result of aggregating all of these files by various methods indicated by \<X\>:
+
+- **OR**: A voxel-wise "or" or "union" operator
+- **AND**: A voxel-wise "and" or "intersection" operator
+- **MAJ**: Voxel-wise majority voting
+
+### `starter_code/`
+
+This folder holds code snippets for viewing and manipulating the data. See [Usage](#Usage) for more information.
+
+### `annotation/`
+
+This folder contains code used to process and import data from the annotation platform. As a participant, there's no reason you should need to run this code, it's only meant to serve as a reference.
+
+## Challenge Information
+
+This challenge will feature significantly more data, several annotations per case, and a number of additional annotated regions. The accepted proposal can be found [on Zenodo](https://doi.org/10.5281/zenodo.3714971), but the most up-to-date information about the challenge can be found on [the KiTS21 homepage](https://kits-challenge.org/kits21/).
+
+## Previous KiTS Challenges
+
+KiTS was first held in conjunction with MICCAI 2019 in Shenzhen. A paper describing that challenge was published in Medical Image Analysis \[[html](https://www.sciencedirect.com/science/article/abs/pii/S1361841520301857)\] \[[pdf](https://arxiv.org/pdf/1912.01054.pdf)\].
+
+```bibtex
+@article{heller2020state,
+  title={The state of the art in kidney and kidney tumor segmentation in contrast-enhanced CT imaging: Results of the KiTS19 Challenge},
+  author={Heller, Nicholas and Isensee, Fabian and Maier-Hein, Klaus H and Hou, Xiaoshuai and Xie, Chunmei and Li, Fengyi and Nan, Yang and Mu, Guangrui and Lin, Zhiyong and Han, Miofei and others},
+  journal={Medical Image Analysis},
+  pages={101821},
+  year={2020},
+  publisher={Elsevier}
+}
+```

kits21/kits21/examples/README.md

@@ -0,0 +1,11 @@
+# Examples
+
+This folder contains instructions for training a baseline nnUNet model, and examples for making official docker submissions.
+
+- `nnUNet_baseline` contains instructions on how to train nnUNet. This is merely intended as inspiration.
+  **We by no means require participants to use nnUnet!** However, we encourage participants to compare their model 
+  performance to the performance achieved by the nnUNet baseline, and participants are welcome to extend this 
+  implementation if they so desire
+
+- `submission` contains guidelines for successful submission of your trained model to the test set. We 
+  have prepared examples for creating the needed docker containers.

kits21/kits21/examples/nnUNet_baseline/README.md

@@ -0,0 +1,175 @@
+# nnUNet baseline model
+
+We chose [nnUNet](https://www.nature.com/articles/s41592-020-01008-z) as a model baseline for KiTS 2021 Challenge since 
+it is well known as a framework for fast and effective
+development of segmentation methods. Users with various backgrounds and expertise can use nnUNet out-of-the-box for
+their custom 3D segmentation problem without much need for manual intervention. It's publicly available and can be
+accessed via [MIC-DKFZ/nnUNet](https://github.com/MIC-DKFZ/nnUNet).
+
+We do not expect the participants to use nnUNet for model development but strongly encourage to compare the performance of
+their developed model to the nnUNet baseline.
+
+A documentation on how to run nnUNet on a new dataset is
+given [here](https://github.com/MIC-DKFZ/nnUNet#how-to-run-nnu-net-on-a-new-dataset). To simplify a number of the steps
+for the participants of KiTS 2021 Challenge, here we highlight the steps needed to train nnUNet on the KiTS 2021 dataset.
+
+**IMPORTANT: nnU-Net only works on Linux-based operating systems!**
+
+Note that our nnU-Net baseline uses the majority voted segmentations as ground truth for training and does not make
+use of the sampled segmentations. 
+
+### nnUNet setup
+
+Please follow the installation instructions [here](https://github.com/MIC-DKFZ/nnUNet#installation). Please install 
+nnU-Net as an integrative framework (not via `pip install nnunet`).
+
+Remember that all nnU-Net commands support the `-h` argument for displaying usage instructions!
+
+### Dataset preparation
+
+This section requires you to have downloaded the KiTS2021 dataset.
+
+As nnUNet expects datasets in a structured format, you need to convert the dataset to be compatible with nnUNet. We
+provide a script to do this as part of the nnU-Net repository: [Task135_KiTS2021.py](https://github.com/MIC-DKFZ/nnUNet/blob/master/nnunet/dataset_conversion/Task135_KiTS2021.py)
+
+Please adapt this script to your system and simply execute it with python. This will convert the KiTS dataset into 
+nnU-Net's data format.
+
+
+### Experiment planning and preprocessing
+In order to train the nnU-Net models all you need to do is run the standard nnU-Net steps:
+
+The following command will extract the dataset fingerprint and based on that configure nnU-Net.
+```console
+nnUNet_plan_and_preprocess -t 135 -pl2d None -tl 4 -tf 2
+```
+
+`-pl2d None` makes nnU-Net ignore the 2D configuration which is unlikely to perform well on the KiTS task. You can 
+remove this part if you would like to use the 2D model.
+
+Setting `-tf 2` and `-tl 4` is necessary to keep RAM utilization low during preprocessing. The provided numbers work 
+well with 64GB RAM. If you find yourself running out of memory or if the preprocessing gets stuck, consider setting 
+these lower. If you have more RAM (and CPU cores), set them higher.
+
+Running preprocessing will take a while - so sit back and relax!
+
+### Model training
+Once preprocessing is completed you can run the nnU-net configurations you would like to use as baselines. Note that 
+we will be providing pretrained model weights shortly after the dataset freeze so that you don't have to train nnU-Net 
+yourself! (TODO)
+
+In nnU-Net, the default is to train each configuration via cross-validation. This is the setting we recommend you use 
+as well, regardless of whether you use nnU-Net for your submission or not. Running cross-validation gives you the most 
+stable estimate of model performance on the training set. To run training with nnU-Net, use the following command:
+
+```console
+nnUNet_train CONFIGURATION nnUNetTrainerV2 135 FOLD
+```
+
+`CONFIGURATION` is hereby the nnU-Net configuration you would like to use (`2d`, `3d_lowres`, `3d_fullres`, 
+`3d_cascade_fullres`; remember that we do not have preprocessed data for `2d` because we used `-pl2d None` in 
+`nnUNet_plan_and_preprocess`). Run this command 5 times for `FOLD` 0, 1, 2, 3 and 4. If have multiple GPUs you can run 
+these simultaneously BUT you need to start one of the folds first and wait till it utilizes the GPU before starting 
+the others (this has to do with unpacking the data for training).
+
+The trained models will be writen to the RESULTS_FOLDER/nnUNet folder. Each training obtains an automatically generated
+output folder name. Here we give an example of output folder for 3d_fullres:
+
+    RESULTS_FOLDER/nnUNet/
+    ├── 3d_cascade_fullres
+    ├── 3d_fullres
+    │   └── Task135_KiTS2021
+    │       └── nnUNetTrainerV2__nnUNetPlansv2.1
+    │           ├── fold_0
+    │           │   ├── debug.json
+    │           │   ├── model_best.model
+    │           │   ├── model_best.model.pkl
+    │           │   ├── model_final_checkpoint.model
+    │           │   ├── model_final_checkpoint.model.pkl
+    │           │   ├── progress.png
+    │           │   └── validation_raw
+    │           │       ├── case_00002.nii.gz
+    │           │       ├���─ case_00008.nii.gz
+    │           │       ├── case_00012.nii.gz
+    │           │       ├── case_00021.nii.gz
+    │           │       ├── case_00022.nii.gz
+    │           │       ├── case_00031.nii.gz
+    │           │       ├── case_00034.nii.gz
+    │           │       ├── case_00036.nii.gz
+    │           │       ├── summary.json
+    │           │       └── validation_args.json
+    │           ├── fold_1
+    │           ├── fold_2
+    │           ├── fold_3
+    │           └── fold_4
+    └── 3d_lowres
+
+Exactly this structure of those three folders (3d_fullres, 3d_lowres and 3d_cascade_fullres) is required for running 
+inference script presented in the example
+of [nnUNet docker submission](../submission/nnUNet_submission).
+
+### Choosing the best configuration
+
+Once the models are trained, you can either choose manually which one you would like to use, or use the 
+`nnUNet_find_best_configuration` command to automatically determine the best configuration. Since this command does not 
+understand the KiTS2021 HECs, we recommend evaluating the different configurations manually with the 
+evaluation scripts provided in the kits21 repository and selecting the best performing model based on that.
+
+In order to evaluate a nnU-Net model with the kits21 repository you first need to gather the validation set 
+predictions from the five folds into a single folder. These are located here:
+`${RESULTS_FOLDER}/nnUNet/CONFIGURATION/Task135_KiTS21/TRAINERCLASS__PLANSIDENTIFIER/fold_X/validation_raw`
+Note that we are using the `validation_raw` and not the `validation_raw_postprocessed` folder. That is because 
+a) nnU-Net prostprocessing needs to be executed for the entire cross validation using `nnUNet_determine_postprocessing` 
+(`validation_raw_postprocessed` is for development purposes only) and b) the nnU-Net postprocessing is not useful for 
+KiTS2021 anyways so it can safely be omitted.
+
+Once you have all validation set predictions of the desired nnU-Net run in one folder, double check that all 300 KiTS21 
+training cases are present. Then run 
+
+`python kits21/evaluation/evaluate_predictions.py FOLDER -num_processes XX`
+
+(note that you need to have generated the sampled segmentations first, see [here](../../kits21/evaluation))
+
+Once that is completed there will be a file in `FOLDER` with the kits metrics. 
+
+### Inference
+
+For running inference on all images in a specific folder you can either make use of the scripts
+prepared for docker submission or run `nnUNet_predict` command: 
+```console
+nnUNet_predict -i INPUT_FOLDER -o OUTPUT_FOLDER -t 135 -m 3d_fullres 
+```
+
+IMPORTANT: When using `nnUNet_predict`, nnU-Net expects the filenames in the input folder to end with _XXXX.nii.gz 
+where _XXXX is a modality 
+identifier. For KiTS there is just one modality (CT) so the files need to end with _0000.nii.gz 
+(example: case_00036_0000.nii.gz). This is not needed when using the scripts in the nnU-Net docker examples!
+
+## Updating the KiTS21 dataset within nnU-Net
+
+The datset will be finalized by July 15th 2021. In order to update the dataset within nnU-Net you HAVE TO delete not 
+only the content of `${nnUNet_raw_data_base}/nnUNet_raw_data` but also `${nnUNet_raw_data_base}/nnUNet_cropped_data` 
+and `${nnUNet_preprocessed}/Task135_KiTS2021`. Then rerun the conversion script again, followed by
+[experiment planning and preprocessing](#experiment-planning-and-preprocessing).
+
+# nnU-Net baseline results
+Pretrained model weights and predicted segmentation masks from the training set are provided here: https://zenodo.org/record/5126443
+If you would like to use the pretrained weights, download the [Task135_KiTS21.zip](https://zenodo.org/record/5126443/files/Task135_KiTS2021.zip?download=1) 
+file and import it with `nnUNet_install_pretrained_model_from_zip Task135_KiTS21.zip`.
+
+
+Here are the results obtained with our nnU-Net baseline on the 300 training cases (5-fold cross-validation):
+
+|                    | Dice_kidney | Dice_masses | Dice_tumor | Dice_average |   | SurfDice_kidney | SurfDice_masses | SurfDice_tumor | SurfDice_average |
+|--------------------|-------------|-------------|------------|--------------|---|-----------------|-----------------|----------------|------------------|
+| 3d_fullres         | 0.9666      | 0.8618      | 0.8493     | 0.8926       |   | 0.9336          | 0.7532          | 0.7371         | 0.8080           |
+| 3d_lowres          | 0.9683      | 0.8702      | 0.8508     | 0.8964       |   | 0.9272          | 0.7507          | 0.7347         | 0.8042           |
+| 3d_cascade_fullres | 0.9747      | 0.8799      | 0.8491     | 0.9012       |   | 0.9453          | 0.7714          | 0.7393         | 0.8187           |
+
+As you can see, the `3d_cascade_fullres` configuration performed best, both in thers of average Dice score and average Surface Dice.
+
+# Extending nnU-Net for KiTS2021
+
+[Here](https://github.com/MIC-DKFZ/nnUNet/blob/master/documentation/extending_nnunet.md) are instructions on how to 
+change and adapt nnU-Net. In order to keep things fair between participants **WE WILL NOT PROVIDE SUPPORT FOR IMPROVING 
+nnU-Net FOR KITS2021**. You are on your own! 

kits21/kits21/examples/submission/README.md

@@ -0,0 +1,152 @@
+# Submission examples
+Please direct any questions or concerns about these instructions or the submission process generally to [the KiTS21 Discourse Forum](https://discourse.kits-challenge.org/).
+
+## Submission guidelines
+
+Instead of getting access to the test images and being requested to upload the segmentations (as is was the case in 
+KiTS2019), you will be asked to upload the inference portion of your algorithm in the form of a 
+[docker](https://www.docker.com/) container. The submission takes place by uploading a saved docker image 
+(single file) containing your inference code to [our grand-challenge.org site](https://kits21.grand-challenge.org/). 
+This image will be loaded on the evaluation system and executed on private servers to run inference on the test images.
+Naturally, these docker images **will NOT have access to the internet**,
+so please make sure everything you need it included in the image you upload.
+The primary reason for that is to eliminate 
+any possibility of cheating e.g. designing the model specifically for test dataset or manually correcting test set 
+predictions.
+
+On our servers, the containers will be mounted such that two specific folders are available, `/input/images/ct/` and `/output/images/kidney-tumor-and-cyst/` (see also [Step 4](#step-4-run-a-container-from-a-created-docker-image)).
+The `/input/images/ct/` folder contains the test set. There are no subfolders - 
+  merely a bunch of `*.mha` files containing the test images. Your docker is expected to produce equivalently 
+  named segmentation files (also ending with .mha) in the /output/images/kidney-tumor-and-cyst/ folder. The structure of those folders is shown 
+  below with the example of two cases: 
+  
+      ├── input
+      │   └── case00000.mha
+      │   └── case00001.mha
+      ├── output
+      │   └── case00000.mha
+      │   └── case00001.mha
+
+In reality, the cases will not be named with this predictable numbering system. They can have arbitrary file names.
+
+NOTE: The dataset was released in .nii.gz format but grand-challenge.org is only able to work with .mha files, so our .nii.gz collection has been converted to .mha files on the backend, and these are the files that your docker container must know how to read and write. Please see the dummy submission's updated "run_inference.py" for an example of how you can do this.
+
+In order to run the inference, your trained model has to be part of the docker image and needs to have been added to 
+the docker at the stage of building the image. Transferring parameter files is simply done by copying them to a 
+specified folder within the container using the `ADD` command in the dockerfile.
+For more information see the examples of the dockerfiles we prepared.
+
+Your docker image needs to expose the inference functionality via an inference script which must be named 
+`run_inference.py` and take no additional arguments (must be executable with `python run_inference.py`). 
+This script needs to use the images
+provided in `/input/images/ct/` and write your segmentation predictions into the `/output/images/kidney-tumor-and-cyst/` folder (using the same name as the 
+corresponding input file). **IMPORTANT: Following best practices, your predictions must have the same geometry 
+(same shape + same affine) as the corresponding raw image!**
+
+## Docker examples
+
+This folder consists of 2 examples that can be used as a base for docker submission of the KiTS challenge 2021.
+
+- The `dummy_submission` folder includes
+  a simple [dockerfile](dummy_submission/Dockerfile)
+  and simplistic inference
+  script [run_inference.py](dummy_submission/run_inference.py)
+  for computing dummy output segmentation (this just creates random noise as segmentation).
+
+- The `nnUNet_submission` folder has
+  a [dockerfile](nnU-Net_baseline/Dockerfile) for
+  running nnUNet baseline model along with 2 options: single model
+  submission ([run_inference.py](nnUNet_submission/run_inference.py))
+  and ensemble of the
+  models ([run_inference_ensemble.py](nnUNet_submission/run_inference_ensembling.py))
+  . Please note here, that to run the ensemble script locally, you need to change the naming of the parameters folder as
+  well as the script to run (as outlines in the comments of
+  the [dockerfile](nnUNet_submission/Dockerfile)).
+  Your docker run command has to be adapted accordingly. For final submission, your inference script should be
+  always called `run_inference.py`.
+
+## Installation and running guidelines
+
+We recognize that not all participants will have had experience with Docker, so we've prepared quick guidelines for
+setting up a docker and using the submission examples. Here are the steps to follow to:
+
+- Install docker
+- Build a docker image
+- Run a container
+- Save and load a docker image created
+
+### Step 1. Install Docker
+
+To install docker use following instructions [https://docs.docker.com/engine/install/](https://docs.docker.com/engine/install/) depending on your OS.
+
+### Step 2. Creating Dockerfile
+
+A good practice when using docker is to create a dockerfile with all needed requirements and needed operations. You can
+find a simple example of the dockerfile in
+the [`dummy_submission/`](dummy_submission) folder.
+More complicated example of a dockerfile can be found
+in [`nnUNet_submission/`](nnUNet_submission) folder,
+where we specified additional requirements needed for running the nnUNet baseline model. Please make sure that your
+dockerfile is placed in the same folder as your python script to run inference on the test data
+(*run_inference.py*) and directory that contains your training weights (`model/` folder for dummy example and `parameters/`
+folder for nnUNet baseline example).
+
+Please double check that the naming of your folder with a trained model is correctly specified in a dockerfile as well
+as in the inference script.
+
+### Step 3. Build a docker image from a dockerfile
+
+Navigate to the directory with the dockerfile and run following command:
+
+```console
+docker build -t YOUR_DOCKER_IMAGE_NAME .
+```
+
+Note that the nnU-Net docker requires the parameters to build. The pretrained parameters are not available yet, but will be provided soon :-)
+
+### Step 4. Run a container from a created docker image
+
+To run a container the `docker run` command is used:
+
+```console
+docker run --rm --runtime=nvidia --ipc=host -v LOCAL_PATH_INPUT:/input/images/ct/:ro -v LOCAL_PATH_OUTPUT:/output/images/kidney-tumor-and-cyst/ YOUR_DOCKER_IMAGE_NAME
+```
+
+`-v` flag mounts the directories between your local host and the container. `:ro` specifies that the folder mounted
+with `-v` has read-only permissions. Make sure that `LOCAL_PATH_INPUT` contains your test samples,
+and `LOCAL_PATH_OUTPUT` is an output folder for saving the predictions. During test set submission this command will
+be run on a private server managed by the organizers with mounting to the folders with final test data. Please test
+the docker on your local computer using the command above before uploading!
+
+<!---
+### (Optional) Step 5. Running script within the container
+To run any additional scripts, you can execute the following line **within the container**:
+```console
+python run_inference.py
+```
+"""
+-->
+
+### Step 5. Save docker image container
+
+To save your docker image to a file on your local machine, you can run the following command in a terminal:
+
+```console
+docker save YOUR_DOCKER_IMAGE_NAME | gzip -c > test_docker.tar.gz
+```
+
+This will create a file named `test_docker.tar.gz` containing your image.
+
+### Step 6. Load the image
+
+To double check your saved image, you can load it with:
+
+```console
+docker load -i test_docker.tar.gz
+```
+
+and run the loaded docker as outlined above with the following command (see Step 4):
+
+```console
+docker run --rm --runtime=nvidia --ipc=host -v LOCAL_PATH_INPUT:/input/images/ct/:ro -v LOCAL_PATH_OUTPUT:/output/images/kidney-tumor-and-cyst/ YOUR_DOCKER_IMAGE_NAME
+```

kits21/kits21/examples/submission/dummy_submission/Dockerfile

@@ -0,0 +1,26 @@
+# Here is an example of a Dockerfile to use. Please make sure this file is placed to the same folder as run_inference.py file and directory model/ that contains your training weights.
+
+FROM ubuntu:latest
+
+# Install some basic utilities and python
+RUN apt-get update \
+  && apt-get install -y python3-pip python3-dev \
+  && cd /usr/local/bin \
+  && ln -s /usr/bin/python3 python \
+  && pip3 install --upgrade pip
+
+RUN pip3 install numpy simpleitk nibabel
+
+# Copy the folder with your pretrained model here to /model folder within the container. This part is skipped here due to simplicity reasons
+# ADD model /model/
+
+ADD run_inference.py ./
+
+RUN groupadd -r myuser -g 433 && \
+    useradd -u 431 -r -g myuser -s /sbin/nologin -c "Docker image user" myuser
+
+RUN mkdir /input_nifti && mkdir /output_nifti && chown -R myuser /input_nifti && chown -R myuser /output_nifti
+
+USER myuser
+
+CMD python3 ./run_inference.py

kits21/kits21/examples/submission/dummy_submission/run_inference.py

@@ -0,0 +1,121 @@
+"""
+This python script is a dummy example of the inference script that populates output/ folder. For this example, the
+loading of the model from the directory /model is not taking place and the output/ folder is populated with arrays
+filled with zeros of the same size as the images in the input/ folder.
+"""
+
+import os
+import numpy as np
+from pathlib import Path
+
+import SimpleITK as sitk
+import nibabel as nib
+
+INPUT_NIFTI = '/input_nifti'
+OUTPUT_NIFTI = '/output_nifti'
+if not os.path.exists(INPUT_NIFTI):
+    os.mkdir(INPUT_NIFTI)
+if not os.path.exists(OUTPUT_NIFTI):
+    os.mkdir(OUTPUT_NIFTI)
+
+
+def _load_mha_as_nifti(filepath):
+    reader = sitk.ImageFileReader()
+    reader.SetImageIO("MetaImageIO")
+    reader.SetFileName(str(filepath))
+    image = reader.Execute()
+    nda = np.moveaxis(sitk.GetArrayFromImage(image), -1, 0)
+    mha_meta = {
+        "origin": image.GetOrigin(),
+        "spacing": image.GetSpacing(),
+        "direction": image.GetDirection(),
+        "filename": filepath.name
+    }
+
+    affine = np.array(
+       [[0.0, 0.0, -1*mha_meta["spacing"][2], 0.0],
+        [0.0, -1*mha_meta["spacing"][1], 0.0, 0.0],
+        [-1*mha_meta["spacing"][0], 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 1.0]]
+    )
+
+    return nib.Nifti1Image(nda, affine), mha_meta
+
+
+def _save_mha(segmentation_nib, mha_meta):
+    output_mha = '/output/images/kidney-tumor-and-cyst/'
+    if not Path(output_mha).exists():
+        Path(output_mha).mkdir(parents=True)
+
+    channels_last = np.moveaxis(np.asanyarray(segmentation_nib.dataobj), 0, -1)
+
+    dummy_segmentation = sitk.GetImageFromArray(channels_last)
+    dummy_segmentation.SetOrigin(mha_meta["origin"])
+    dummy_segmentation.SetSpacing(mha_meta["spacing"])
+    dummy_segmentation.SetDirection(mha_meta["direction"])
+
+    writer = sitk.ImageFileWriter()
+    writer.SetFileName(os.path.join(output_mha, mha_meta["filename"]))
+    writer.Execute(dummy_segmentation)
+
+
+def convert_imaging_to_nifti():
+    input_mha = Path('/input/images/ct/')
+    meta = {}
+    for x in input_mha.glob("*.mha"):
+        x_nii, x_meta = _load_mha_as_nifti(x)
+        meta[x.stem] = x_meta
+        nib.save(x_nii, str(Path(INPUT_NIFTI) / "{}.nii.gz".format(x.stem)))
+
+    return meta
+
+
+def convert_predictions_to_mha(conversion_meta):
+    for uid in conversion_meta:
+        pred_nii_pth = Path(OUTPUT_NIFTI) / "{}.nii.gz".format(uid)
+        if not pred_nii_pth.exists():
+            raise ValueError("No prediction found for file {}.mha".format(uid))
+        pred_nii = nib.load(str(pred_nii_pth))
+        _save_mha(pred_nii, conversion_meta[uid])
+
+
+
+# =========================================================================
+# Replace this function with your inference code!
+def predict(image_nib, model):
+    # As a dummy submission, just predict random voxels
+    width, height, queue = image_nib.shape
+    data = np.round(np.random.uniform(low=-0.49, high=2.49, size=(width, height, queue))).astype(np.uint8)
+
+    # Must return a Nifti1Image object
+    return nib.Nifti1Image(data, image_nib.affine)
+# =========================================================================
+
+
+def main():
+    # This converts the mha files to nifti just like the official GitHub
+    conversion_meta = convert_imaging_to_nifti()
+
+    # =========================================================================
+    # Load model from /model folder!
+    # This part is skipped for simplicity reasons
+    model = None
+    # =========================================================================
+
+    for filename in os.listdir(INPUT_NIFTI):
+        if filename.endswith(".nii.gz"):
+            # Load mha as nifti using provided function
+            image_nib = nib.load(os.path.join(INPUT_NIFTI, filename))
+
+            # Run your prediction function
+            segmentation_nib = predict(image_nib, model)
+
+            # Save nifti just as you otherwise would
+            nib.save(segmentation_nib, Path(OUTPUT_NIFTI) / "{}".format(filename))
+
+    # This converts the nifti predictions to the expected output
+    convert_predictions_to_mha(conversion_meta)
+
+
+if __name__ == '__main__':
+    main()

kits21/kits21/examples/submission/nnUNet_submission/Dockerfile

@@ -0,0 +1,29 @@
+FROM nvcr.io/nvidia/pytorch:20.08-py3
+
+# Install some basic utilities and python
+RUN apt-get update \
+  && apt-get install -y python3-pip python3-dev \
+  && cd /usr/local/bin \
+  && ln -s /usr/bin/python3 python \
+  && pip3 install --upgrade pip
+
+# install nnunet
+RUN pip install nnunet
+
+# for single model inference
+ADD parameters /parameters/
+ADD run_inference.py ./
+
+# for ensemble model inference
+# ADD parameters_ensembling /parameters_ensembling/
+# ADD run_inference_ensembling.py ./
+
+RUN groupadd -r myuser -g 433 && \
+    useradd -u 431 -r -g myuser -s /sbin/nologin -c "Docker image user" myuser
+
+RUN mkdir /input_nifti && mkdir /output_nifti && chown -R myuser /input_nifti && chown -R myuser /output_nifti
+
+USER myuser
+
+CMD python3 ./run_inference.py
+# or CMD python3 ./run_inference_ensembling.py

kits21/kits21/examples/submission/nnUNet_submission/run_inference.py

@@ -0,0 +1,144 @@
+from pathlib import Path
+import os
+
+import numpy as np
+import nibabel as nib
+import SimpleITK as sitk
+
+
+INPUT_NIFTI = '/input_nifti'
+OUTPUT_NIFTI = '/output_nifti'
+if not os.path.exists(INPUT_NIFTI):
+    os.mkdir(INPUT_NIFTI)
+if not os.path.exists(OUTPUT_NIFTI):
+    os.mkdir(OUTPUT_NIFTI)
+
+
+def _load_mha_as_nifti(filepath):
+    reader = sitk.ImageFileReader()
+    reader.SetImageIO("MetaImageIO")
+    reader.SetFileName(str(filepath))
+    image = reader.Execute()
+    nda = np.moveaxis(sitk.GetArrayFromImage(image), -1, 0)
+    mha_meta = {
+        "origin": image.GetOrigin(),
+        "spacing": image.GetSpacing(),
+        "direction": image.GetDirection(),
+        "filename": filepath.name
+    }
+
+    affine = np.array(
+       [[0.0, 0.0, -1*mha_meta["spacing"][2], 0.0],
+        [0.0, -1*mha_meta["spacing"][1], 0.0, 0.0],
+        [-1*mha_meta["spacing"][0], 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 1.0]]
+    )
+
+    return nib.Nifti1Image(nda, affine), mha_meta
+
+
+def _save_mha(segmentation_nib, mha_meta):
+    output_mha = '/output/images/kidney-tumor-and-cyst/'
+    if not Path(output_mha).exists():
+        Path(output_mha).mkdir(parents=True)
+
+    channels_last = np.moveaxis(np.asanyarray(segmentation_nib.dataobj), 0, -1)
+
+    dummy_segmentation = sitk.GetImageFromArray(channels_last)
+    dummy_segmentation.SetOrigin(mha_meta["origin"])
+    dummy_segmentation.SetSpacing(mha_meta["spacing"])
+    dummy_segmentation.SetDirection(mha_meta["direction"])
+
+    writer = sitk.ImageFileWriter()
+    writer.SetFileName(os.path.join(output_mha, mha_meta["filename"]))
+    writer.Execute(dummy_segmentation)
+
+
+def convert_imaging_to_nifti():
+    input_mha = Path('/input/images/ct/')
+    meta = {}
+    for x in input_mha.glob("*.mha"):
+        x_nii, x_meta = _load_mha_as_nifti(x)
+        meta[x.stem] = x_meta
+        nib.save(x_nii, str(Path(INPUT_NIFTI) / "{}.nii.gz".format(x.stem)))
+
+    return meta
+
+
+def convert_predictions_to_mha(conversion_meta):
+    for uid in conversion_meta:
+        pred_nii_pth = Path(OUTPUT_NIFTI) / "{}.nii.gz".format(uid)
+        if not pred_nii_pth.exists():
+            raise ValueError("No prediction found for file {}.mha".format(uid))
+        pred_nii = nib.load(str(pred_nii_pth))
+        _save_mha(pred_nii, conversion_meta[uid])
+
+
+if __name__ == '__main__':
+    """
+    This inference script is intended to be used within a Docker container as part of the KiTS Test set submission. It
+    expects to find input files (.nii.gz) in /input and will write the segmentation output to /output
+    
+    For testing purposes we set the paths to something local, but once we pack it in a docker we need to adapt them of 
+    course
+    
+    IMPORTANT: This script performs inference using one nnU-net configuration (3d_lowres, 3d_fullres, 2d OR 
+    3d_cascade_fullres). Within the /parameter folder, nnU-Net expects to find fold_X subfolders where X is the fold ID 
+    (typically [0-4]). These folds CANNOT originate from different configurations. There also needs to be the plans.pkl 
+    file that you find along with these fold_X folders in the 
+    corresponding nnunet training output directory.
+    
+    /parameters/
+    ├── fold_0
+    │    ├── model_final_checkpoint.model
+    │    └── model_final_checkpoint.model.pkl
+    ├── fold_1
+    ├── ...
+    ├── plans.pkl
+    
+    Note: nnU-Net will read the correct nnU-Net trainer class from the plans.pkl file. Thus there is no need to 
+    specify it here.
+    """
+
+    # This converts the mha files to nifti just like the official GitHub
+    conversion_meta = convert_imaging_to_nifti()
+
+    # this will be changed to /input for the docker
+    input_folder = INPUT_NIFTI
+
+    # this will be changed to /output for the docker
+    output_folder = OUTPUT_NIFTI
+    outpth = Path(output_folder)
+    outpth.mkdir(parents=True, exist_ok=True)
+
+    # this will be changed to /parameters for the docker
+    parameter_folder = '/parameters'
+
+    from nnunet.inference.predict import predict_cases
+    from batchgenerators.utilities.file_and_folder_operations import subfiles, join
+
+    input_files = subfiles(input_folder, suffix='.mha', join=False)
+
+    output_files = [join(output_folder, i) for i in input_files]
+    input_files = [join(input_folder, i) for i in input_files]
+
+    # in the parameters folder are five models (fold_X) traines as a cross-validation. We use them as an ensemble for
+    # prediction
+    folds = (0, 1, 2, 3, 4)
+
+    # setting this to True will make nnU-Net use test time augmentation in the form of mirroring along all axes. This
+    # will increase inference time a lot at small gain, so you can turn that off
+    do_tta = True
+
+    # does inference with mixed precision. Same output, twice the speed on Turing and newer. It's free lunch!
+    mixed_precision = True
+
+    predict_cases(parameter_folder, [[i] for i in input_files], output_files, folds, save_npz=False,
+                  num_threads_preprocessing=2, num_threads_nifti_save=2, segs_from_prev_stage=None, do_tta=do_tta,
+                  mixed_precision=mixed_precision, overwrite_existing=True, all_in_gpu=False, step_size=0.5)
+
+    # This converts the nifti predictions to the expected output
+    convert_predictions_to_mha(conversion_meta)
+
+    # done!
+    # (ignore the postprocessing warning!)

kits21/kits21/examples/submission/nnUNet_submission/run_inference_ensembling.py

@@ -0,0 +1,181 @@
+import shutil
+from pathlib import Path
+import os
+
+import numpy as np
+import nibabel as nib
+import SimpleITK as sitk
+
+
+INPUT_NIFTI = '/input_nifti'
+OUTPUT_NIFTI = '/output_nifti'
+if not os.path.exists(INPUT_NIFTI):
+    os.mkdir(INPUT_NIFTI)
+if not os.path.exists(OUTPUT_NIFTI):
+    os.mkdir(OUTPUT_NIFTI)
+
+
+def _load_mha_as_nifti(filepath):
+    reader = sitk.ImageFileReader()
+    reader.SetImageIO("MetaImageIO")
+    reader.SetFileName(str(filepath))
+    image = reader.Execute()
+    nda = np.moveaxis(sitk.GetArrayFromImage(image), -1, 0)
+    mha_meta = {
+        "origin": image.GetOrigin(),
+        "spacing": image.GetSpacing(),
+        "direction": image.GetDirection(),
+        "filename": filepath.name
+    }
+
+    affine = np.array(
+       [[0.0, 0.0, -1*mha_meta["spacing"][2], 0.0],
+        [0.0, -1*mha_meta["spacing"][1], 0.0, 0.0],
+        [-1*mha_meta["spacing"][0], 0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0, 1.0]]
+    )
+
+    return nib.Nifti1Image(nda, affine), mha_meta
+
+
+def _save_mha(segmentation_nib, mha_meta):
+    output_mha = '/output/images/kidney-tumor-and-cyst/'
+    if not Path(output_mha).exists():
+        Path(output_mha).mkdir(parents=True)
+
+    channels_last = np.moveaxis(np.asanyarray(segmentation_nib.dataobj), 0, -1)
+
+    dummy_segmentation = sitk.GetImageFromArray(channels_last)
+    dummy_segmentation.SetOrigin(mha_meta["origin"])
+    dummy_segmentation.SetSpacing(mha_meta["spacing"])
+    dummy_segmentation.SetDirection(mha_meta["direction"])
+
+    writer = sitk.ImageFileWriter()
+    writer.SetFileName(os.path.join(output_mha, mha_meta["filename"]))
+    writer.Execute(dummy_segmentation)
+
+
+def convert_imaging_to_nifti():
+    input_mha = Path('/input/images/ct/')
+    meta = {}
+    for x in input_mha.glob("*.mha"):
+        x_nii, x_meta = _load_mha_as_nifti(x)
+        meta[x.stem] = x_meta
+        nib.save(x_nii, str(Path(INPUT_NIFTI) / "{}.nii.gz".format(x.stem)))
+
+    return meta
+
+
+def convert_predictions_to_mha(conversion_meta):
+    for uid in conversion_meta:
+        pred_nii_pth = Path(OUTPUT_NIFTI) / "{}.nii.gz".format(uid)
+        if not pred_nii_pth.exists():
+            raise ValueError("No prediction found for file {}.mha".format(uid))
+        pred_nii = nib.load(str(pred_nii_pth))
+        _save_mha(pred_nii, conversion_meta[uid])
+
+
+
+if __name__ == '__main__':
+    """
+    This inference script is intended to be used within a Docker container as part of the KiTS Test set submission. It
+    expects to find input files (.nii.gz) in /input and will write the segmentation output to /output
+    
+    For testing purposes we set the paths to something local, but once we pack it in a docker we need to adapt them of 
+    course
+    
+    IMPORTANT: This script performs inference using two nnU-net configurations, 3d_lowres and 3d_fullres. Within the 
+    /parameter folder, this script expects to find a 3d_fullres and a 3d_lowres subfolder. Within each of these there 
+    should be fold_X subfolders where X is the fold ID (typically [0-4]). These fold folder CANNOT originate from 
+    different configurations (the fullres folds go into the 3d_fullres subfolder, the lowres folds go into the 
+    3d_lowres folder!). There also needs to be the plans.pkl file that you find along with these fold_X folders in the 
+    corresponding nnunet training output directory.
+    
+    /parameters/
+        3d_fullres/
+        ├── fold_0
+        │    ├── model_final_checkpoint.model
+        │    └── model_final_checkpoint.model.pkl
+        ├── fold_1
+        ├── ...
+        └── plans.pkl
+        3d_lowres/
+        ├── fold_0
+        ├── fold_1
+        ├── ...
+        └── plans.pkl
+    
+    Note: nnU-Net will read the correct nnU-Net trainer class from the plans.pkl file. Thus there is no need to 
+    specify it here.
+    """
+
+    # This converts the mha files to nifti just like the official GitHub
+    conversion_meta = convert_imaging_to_nifti()
+
+    # this will be changed to /input for the docker
+    input_folder = INPUT_NIFTI
+
+    # this will be changed to /output for the docker
+    output_folder = OUTPUT_NIFTI
+    outpth = Path(output_folder)
+    outpth.mkdir(parents=True, exist_ok=True)
+
+    # this will be changed to /parameters/X for the docker
+    parameter_folder_fullres = '/parameters_ensembling/3d_fullres'
+    parameter_folder_lowres = '/parameters_ensembling/3d_lowres'
+
+    from nnunet.inference.predict import predict_cases
+    from batchgenerators.utilities.file_and_folder_operations import subfiles, join, maybe_mkdir_p
+
+    input_files = subfiles(input_folder, suffix='.mha', join=False)
+
+    # in the parameters folder are five models (fold_X) traines as a cross-validation. We use them as an ensemble for
+    # prediction
+    folds_fullres = (0, 1, 2, 3, 4)
+    folds_lowres = (0, 1, 2, 3, 4)
+
+    # setting this to True will make nnU-Net use test time augmentation in the form of mirroring along all axes. This
+    # will increase inference time a lot at small gain, so we turn that off here (you do whatever you want)
+    do_tta = False
+
+    # does inference with mixed precision. Same output, twice the speed on Turing and newer. It's free lunch!
+    mixed_precision = True
+
+    # This will make nnU-Net save the softmax probabilities. We need them for ensembling the configurations. Note
+    # that ensembling the 5 folds of each configurationis done BEFORE saving the softmax probabilities
+    save_npz = True
+
+    # predict with 3d_lowres
+    output_folder_lowres = join(output_folder, '3d_lowres')
+    maybe_mkdir_p(output_folder_lowres)
+    output_files_lowres = [join(output_folder_lowres, i) for i in input_files]
+
+    predict_cases(parameter_folder_lowres, [[join(input_folder, i)] for i in input_files], output_files_lowres, folds_lowres,
+                  save_npz=save_npz, num_threads_preprocessing=2, num_threads_nifti_save=2, segs_from_prev_stage=None,
+                  do_tta=do_tta, mixed_precision=mixed_precision, overwrite_existing=True, all_in_gpu=False,
+                  step_size=0.5)
+
+    # predict with 3d_fullres
+    output_folder_fullres = join(output_folder, '3d_fullres')
+    maybe_mkdir_p(output_folder_fullres)
+    output_files_fullres = [join(output_folder_fullres, i) for i in input_files]
+
+    predict_cases(parameter_folder_fullres, [[join(input_folder, i)] for i in input_files], output_files_fullres, folds_fullres,
+                  save_npz=save_npz, num_threads_preprocessing=2, num_threads_nifti_save=2, segs_from_prev_stage=None,
+                  do_tta=do_tta, mixed_precision=mixed_precision, overwrite_existing=True, all_in_gpu=False,
+                  step_size=0.5)
+
+    # ensemble
+    from nnunet.inference.ensemble_predictions import merge
+    merge((output_folder_fullres, output_folder_lowres), output_folder, 4, override=True, postprocessing_file=None,
+          store_npz=False)
+
+    # cleanup
+    shutil.rmtree(output_folder_fullres)
+    shutil.rmtree(output_folder_lowres)
+
+    # This converts the nifti predictions to the expected output
+    convert_predictions_to_mha(conversion_meta)
+
+    # done!
+

kits21/kits21/examples/submission/sanity_check_guide.md

@@ -0,0 +1,107 @@
+# Tutorial For Sanity-Checking Your Submission
+
+This document is meant to walk you through the steps of creating an algorithm on grand-challenge.org and requesting that it be run on the three "sanity check" cases in order to make sure that everything is working properly for the final test set.
+
+## Make Sure Your Docker Is Expecting The **UPDATED** I/O Format
+
+This had to be changed on August 30th due to a misunderstanding by the organizers. The important changes are:
+
+- Grand Challenge can only support .mha files, not .nii.gz
+- Rather than `/input`, the input files are mounted at `/input/images/ct`
+- Rather than `/output`, the output files are expected at `/output/images/kidney-tumor-and-cyst`
+
+The [example dummy submission](https://github.com/neheller/kits21/blob/master/examples/submission/dummy_submission/run_inference.py) has been updated to fit this format. You might find it helpful.
+
+## Make Sure Your Dockerfile Doesn't Run As Root
+
+This can typically be resolved by simply adding the following to the end of your Dockerfile
+
+```Dockerfile
+RUN groupadd -r myuser -g 433 && \
+    useradd -u 431 -r -g myuser -s /sbin/nologin -c "Docker image user" myuser
+
+USER myuser
+
+CMD python3 ./run_inference.py
+```
+
+## Make Sure to GZip Your Saved Container
+
+You can do this with the following command (assuming you have built the container with the tag `-t my_submission`):
+
+```bash
+docker save my_submission | gzip -c > test_docker.tar.gz
+```
+
+## "Create an Algorithm" On Grand Challenge
+
+Log-in to grand-challenge.org and click "Algorithms" at the top of the page.
+
+![](figures/go_to_algorithms.png)
+
+Then click "Add New Algorithm" in the middle of the page. 
+
+![](figures/click_add_new_algorithm.png)
+
+**If this option is not shown, make sure you are registered for the KiTS21 challenge [here](https://kits21.grand-challenge.org/participants/registration/create/).**
+
+This button will take you to a form where you will need to provide some metadata about your approach. You can use any name and image that you like, but make sure to fill out the rest of the marked fields as shown below.
+
+Your algorithm will be created only once, and you can update it with new containers later, so don't worry about describing different versions here.
+
+![](figures/fill_out_form0.png)
+
+![](figures/fill_out_form1.png)
+
+**It's especially important to mimic the above for the "Inputs" and "Outputs" fields.**
+
+## Make `helle246` a User of Your Algorithm
+
+In order for us to run the algorithm on your behalf on the sanity check cases, you must make `helle246` a user of your algorithm. Do this by first going to "Users" on the left hand side.
+
+![](figures/go_to_users.png)
+
+Then clicking on "Add Users"
+
+![](figures/add_users.png)
+
+Then typing in "helle246" and clicking "Save".
+
+![](figures/add_helle246.png)
+
+
+## Upload Your `.tar.gz` Docker Container
+
+Now go back to your algorithm and click "Containers" on the left hand side.
+
+![](figures/go_to_containers.png)
+
+Once there, click on "Upload a Container"
+
+![](figures/upload_a_container.png)
+
+That will bring you to a form which will ask you how much RAM you need (max 24GB) and ask if GPU is needed, and then ask you to upload your `.tar.gz` file.
+
+![](figures/add_your_container.png)
+
+
+After your docker container is uploaded, it will be screened for errors. Please address any issues that are raised and **only proceed to the next step after your algorithm shows "Ready: `True`"**
+
+![](figures/make_sure_is_ready.png)
+
+
+## Initiate Your Inference Job
+
+Once your algorithm is created with the correct configuration and you have uploaded a container which was error checked without issue, you are ready to initiate your inference job. You can do this by filling out [this form](https://kits21.kits-challenge.org/inference-request) which asks for
+
+- Your Grand Challenge Username
+- Your Team's "Secret"
+  - You should have received this via email. Please contact Nicholas Heller at [email protected] if you have not received one
+- Your Algorithm's URL
+  - e.g., `https://grand-challenge.org/algorithms/kits21-demo-algorithm/`
+
+![](figures/kits21_sc_request_form.png)
+
+Once the form is submitted, the page will either show an error message or it will provide a link to a page back on grand-challenge.org where you can monitor the progress of your inference jobs.
+
+Once they have finished, you will be able to download the predicted segmentations in order to check them against your expected output.

kits21/kits21/kits21.egg-info/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: kits21
+Version: 2.2.3
+License-File: LICENSE
+Requires-Dist: batchgenerators
+Requires-Dist: numpy
+Requires-Dist: SimpleITK
+Requires-Dist: medpy
+Requires-Dist: nibabel
+Requires-Dist: pillow
+Requires-Dist: opencv-python
+Requires-Dist: torch
+Requires-Dist: scipy
+Requires-Dist: scikit-image
+Requires-Dist: requests
+Requires-Dist: argparse
+Dynamic: license-file
+Dynamic: requires-dist

kits21/kits21/kits21.egg-info/SOURCES.txt

@@ -0,0 +1,27 @@
+LICENSE
+README.md
+setup.py
+examples/submission/dummy_submission/run_inference.py
+examples/submission/nnUNet_submission/run_inference.py
+examples/submission/nnUNet_submission/run_inference_ensembling.py
+kits21.egg-info/PKG-INFO
+kits21.egg-info/SOURCES.txt
+kits21.egg-info/dependency_links.txt
+kits21.egg-info/not-zip-safe
+kits21.egg-info/requires.txt
+kits21.egg-info/top_level.txt
+kits21/annotation/__init__.py
+kits21/annotation/import.py
+kits21/annotation/postprocessing.py
+kits21/annotation/sample_segmentations.py
+kits21/configuration/__init__.py
+kits21/configuration/labels.py
+kits21/configuration/paths.py
+kits21/evaluation/__init__.py
+kits21/evaluation/compute_tolerances.py
+kits21/evaluation/evaluate_predictions.py
+kits21/evaluation/inter_rater_disagreement.py
+kits21/evaluation/metrics.py
+kits21/starter_code/__init__.py
+kits21/starter_code/get_imaging.py
+kits21/starter_code/get_imaging_v2.py

kits21/kits21/kits21.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

kits21/kits21/kits21.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

kits21/kits21/kits21.egg-info/requires.txt

@@ -0,0 +1,12 @@
+batchgenerators
+numpy
+SimpleITK
+medpy
+nibabel
+pillow
+opencv-python
+torch
+scipy
+scikit-image
+requests
+argparse

kits21/kits21/pull_request_template.md

@@ -0,0 +1,16 @@
+# <Title_Here>
+
+## Description
+
+<description_here>
+
+## Checklist
+
+- [ ] Merged latest `master`
+- [ ] Updated version number in `README.md`
+- [ ] Added changes to `changelog.md`
+- [ ] Updated version number in `setup.py`
+- [ ] (only when updating dataset) Ran `annotation.import` to completion
+- [ ] (only when updating dataset) Updated Surface Dice tolerances in `labels.py` (execute `sample_segmentations.py`, and 
+  after that `compute_tolerances.py`. Then put the new values in. Do not re-use sampled segmentations from prior dataset versions!)
+

kits21/kits21/setup.py

@@ -0,0 +1,21 @@
+from setuptools import setup, find_namespace_packages
+
+setup(name='kits21',
+      packages=find_namespace_packages(),
+      version='2.2.3',
+      description='',
+      zip_safe=False,
+      install_requires=[
+            'batchgenerators',
+            'numpy',
+            'SimpleITK',
+            'medpy',
+            'nibabel',
+            'pillow',
+            'opencv-python',
+            'torch',
+            'scipy',
+            'scikit-image',
+            'requests',
+            'argparse'
+      ])