From e255b70c2551d70c42ececbb71d7979788d39f69 Mon Sep 17 00:00:00 2001
From: Hamid <hamidriasat@gmail.com>
Date: Mon, 20 Feb 2023 17:51:39 +0500
Subject: [PATCH 1/3] adding UNet3+ support for Tensorflow 2.0
---
TensorFlow2/Segmentation/UNet3P/.gitignore | 18 +
TensorFlow2/Segmentation/UNet3P/Dockerfile | 15 +
TensorFlow2/Segmentation/UNet3P/LICENSE | 21 ++
TensorFlow2/Segmentation/UNet3P/README.md | 318 ++++++++++++++++++
.../UNet3P/benchmark_inference.py | 101 ++++++
.../UNet3P/callbacks/timing_callback.py | 30 ++
.../UNet3P/checkpoint/tb_logs/.gitkeep | 0
.../Segmentation/UNet3P/configs/README.md | 86 +++++
.../Segmentation/UNet3P/configs/config.yaml | 118 +++++++
.../UNet3P/data/Training Batch 1/.gitkeep | 0
.../UNet3P/data/Training Batch 2/.gitkeep | 0
.../Segmentation/UNet3P/data/train/.gitkeep | 0
.../Segmentation/UNet3P/data/val/.gitkeep | 0
.../UNet3P/data_generators/README.md | 44 +++
.../data_generators/dali_data_generator.py | 264 +++++++++++++++
.../UNet3P/data_generators/data_generator.py | 88 +++++
.../data_generators/tf_data_generator.py | 179 ++++++++++
.../UNet3P/data_preparation/README.md | 102 ++++++
.../delete_extracted_scans_data.sh | 2 +
.../data_preparation/delete_zip_data.sh | 2 +
.../UNet3P/data_preparation/extract_data.sh | 9 +
.../data_preparation/preprocess_data.py | 242 +++++++++++++
.../UNet3P/data_preparation/verify_data.py | 56 +++
TensorFlow2/Segmentation/UNet3P/evaluate.py | 125 +++++++
.../UNet3P/figures/unet3p_architecture.png | Bin 0 -> 87012 bytes
.../Segmentation/UNet3P/losses/loss.py | 114 +++++++
.../Segmentation/UNet3P/losses/unet_loss.py | 19 ++
.../Segmentation/UNet3P/models/backbones.py | 73 ++++
.../Segmentation/UNet3P/models/model.py | 100 ++++++
.../Segmentation/UNet3P/models/unet3plus.py | 104 ++++++
.../models/unet3plus_deep_supervision.py | 132 ++++++++
.../models/unet3plus_deep_supervision_cgm.py | 138 ++++++++
.../UNet3P/models/unet3plus_utils.py | 31 ++
TensorFlow2/Segmentation/UNet3P/predict.ipynb | 247 ++++++++++++++
TensorFlow2/Segmentation/UNet3P/predict.py | 101 ++++++
.../Segmentation/UNet3P/requirements.txt | 7 +
TensorFlow2/Segmentation/UNet3P/train.py | 215 ++++++++++++
.../UNet3P/utils/general_utils.py | 123 +++++++
.../Segmentation/UNet3P/utils/images_utils.py | 118 +++++++
39 files changed, 3342 insertions(+)
create mode 100644 TensorFlow2/Segmentation/UNet3P/.gitignore
create mode 100644 TensorFlow2/Segmentation/UNet3P/Dockerfile
create mode 100644 TensorFlow2/Segmentation/UNet3P/LICENSE
create mode 100644 TensorFlow2/Segmentation/UNet3P/README.md
create mode 100644 TensorFlow2/Segmentation/UNet3P/benchmark_inference.py
create mode 100644 TensorFlow2/Segmentation/UNet3P/callbacks/timing_callback.py
create mode 100644 TensorFlow2/Segmentation/UNet3P/checkpoint/tb_logs/.gitkeep
create mode 100644 TensorFlow2/Segmentation/UNet3P/configs/README.md
create mode 100644 TensorFlow2/Segmentation/UNet3P/configs/config.yaml
create mode 100644 TensorFlow2/Segmentation/UNet3P/data/Training Batch 1/.gitkeep
create mode 100644 TensorFlow2/Segmentation/UNet3P/data/Training Batch 2/.gitkeep
create mode 100644 TensorFlow2/Segmentation/UNet3P/data/train/.gitkeep
create mode 100644 TensorFlow2/Segmentation/UNet3P/data/val/.gitkeep
create mode 100644 TensorFlow2/Segmentation/UNet3P/data_generators/README.md
create mode 100644 TensorFlow2/Segmentation/UNet3P/data_generators/dali_data_generator.py
create mode 100644 TensorFlow2/Segmentation/UNet3P/data_generators/data_generator.py
create mode 100644 TensorFlow2/Segmentation/UNet3P/data_generators/tf_data_generator.py
create mode 100644 TensorFlow2/Segmentation/UNet3P/data_preparation/README.md
create mode 100644 TensorFlow2/Segmentation/UNet3P/data_preparation/delete_extracted_scans_data.sh
create mode 100644 TensorFlow2/Segmentation/UNet3P/data_preparation/delete_zip_data.sh
create mode 100644 TensorFlow2/Segmentation/UNet3P/data_preparation/extract_data.sh
create mode 100644 TensorFlow2/Segmentation/UNet3P/data_preparation/preprocess_data.py
create mode 100644 TensorFlow2/Segmentation/UNet3P/data_preparation/verify_data.py
create mode 100644 TensorFlow2/Segmentation/UNet3P/evaluate.py
create mode 100644 TensorFlow2/Segmentation/UNet3P/figures/unet3p_architecture.png
create mode 100644 TensorFlow2/Segmentation/UNet3P/losses/loss.py
create mode 100644 TensorFlow2/Segmentation/UNet3P/losses/unet_loss.py
create mode 100644 TensorFlow2/Segmentation/UNet3P/models/backbones.py
create mode 100644 TensorFlow2/Segmentation/UNet3P/models/model.py
create mode 100644 TensorFlow2/Segmentation/UNet3P/models/unet3plus.py
create mode 100644 TensorFlow2/Segmentation/UNet3P/models/unet3plus_deep_supervision.py
create mode 100644 TensorFlow2/Segmentation/UNet3P/models/unet3plus_deep_supervision_cgm.py
create mode 100644 TensorFlow2/Segmentation/UNet3P/models/unet3plus_utils.py
create mode 100644 TensorFlow2/Segmentation/UNet3P/predict.ipynb
create mode 100644 TensorFlow2/Segmentation/UNet3P/predict.py
create mode 100644 TensorFlow2/Segmentation/UNet3P/requirements.txt
create mode 100644 TensorFlow2/Segmentation/UNet3P/train.py
create mode 100644 TensorFlow2/Segmentation/UNet3P/utils/general_utils.py
create mode 100644 TensorFlow2/Segmentation/UNet3P/utils/images_utils.py
diff --git a/TensorFlow2/Segmentation/UNet3P/.gitignore b/TensorFlow2/Segmentation/UNet3P/.gitignore
new file mode 100644
index 000000000..60d8f9716
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/.gitignore
@@ -0,0 +1,18 @@
+.idea
+__pycache__
+
+checkpoint/tb_logs/*
+checkpoint/*.hdf5
+checkpoint/*.csv
+!checkpoint/tb_logs/.gitkeep
+
+#data/*
+/data/**/*.png
+/data/**/*.jpg
+/data/**/*.nii
+!data/**/.gitkeep
+
+data_preparation/verify_preprocess_data.ipynb
+old_data_preperation/
+others/
+**/outputs
\ No newline at end of file
diff --git a/TensorFlow2/Segmentation/UNet3P/Dockerfile b/TensorFlow2/Segmentation/UNet3P/Dockerfile
new file mode 100644
index 000000000..498695855
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/Dockerfile
@@ -0,0 +1,15 @@
+ARG FROM_IMAGE_NAME=nvcr.io/nvidia/tensorflow:22.12-tf2-py3
+FROM ${FROM_IMAGE_NAME}
+
+ADD . /workspace/unet3p
+WORKDIR /workspace/unet3p
+
+RUN pip install -r requirements.txt
+
+#For opencv, inside docker run these commands
+RUN apt-get update
+RUN apt-get install ffmpeg libsm6 libxext6 -y
+
+# reinstall jupyterlab
+RUN pip uninstall jupyterlab -y
+RUN pip install jupyterlab
diff --git a/TensorFlow2/Segmentation/UNet3P/LICENSE b/TensorFlow2/Segmentation/UNet3P/LICENSE
new file mode 100644
index 000000000..45f5ea544
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Hamid Ali
+
+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.
diff --git a/TensorFlow2/Segmentation/UNet3P/README.md b/TensorFlow2/Segmentation/UNet3P/README.md
new file mode 100644
index 000000000..988770ca3
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/README.md
@@ -0,0 +1,318 @@
+# UNet 3+: A Full-Scale Connected UNet for Medical Image Segmentation
+
+[](https://paperswithcode.com/sota/medical-image-segmentation-on-lits2017?p=unet-3-a-full-scale-connected-unet-for)
+
+This repository provides a script and recipe to train UNet3+ to achieve state of the art accuracy.
+
+[//]: # (, and is tested and maintained by NVIDIA.)
+
+## Table of Contents
+
+- [UNet 3+](https://arxiv.org/abs/2004.08790) for Image Segmentation in Tensorflow 2.0.
+ - [Table of Contents](#table-of-contents)
+ - [Feature Support Matrix](#feature-support-matrix)
+ - [Installation](#installation)
+ - [Code Structure](#code-structure)
+ - [Config](#config)
+ - [Data Preparation](#data-preparation)
+ - [Models](#models)
+ - [Performance](#performance)
+ - [Inference Demo](#inference-demo)
+ - [Known issues](#known-issues)
+ - [Release notes](#release-notes)
+
+## Feature Support Matrix
+
+The following features are supported by our code base:
+
+| Feature | UNet3+ Supports |
+|:------------------------------------------:|:---------------:|
+| DALI | ✓ |
+| TensorFlow Multi-GPU Training | ✓ |
+| TensorFlow Automatic Mixed Precision(AMP) | ✓ |
+| TensorFlow Accelerated Linear Algebra(XLA) | ✓ |
+
+#### [NVIDIA DALI](https://docs.nvidia.com/deeplearning/dali/user-guide/docs/index.html)
+
+The NVIDIA Data Loading Library (DALI) is a library for data loading and
+pre-processing to accelerate deep learning applications. It provides a
+collection of highly optimized building blocks for loading and processing
+image, video and audio data. It can be used as a portable drop-in
+replacement for built in data loaders and data iterators in popular deep
+learning frameworks.
+
+#### [TensorFlow Multi-GPU Training](https://www.tensorflow.org/guide/distributed_training)
+
+Distribute training across multiple GPUs, multiple machines, or TPUs.
+
+#### [TensorFlow Automatic Mixed Precision(AMP)](https://www.tensorflow.org/guide/mixed_precision)
+
+Mixed precision is the use of both 16-bit and 32-bit floating-point types in a model during training to make it run
+faster and use less memory. By keeping certain parts of the model in the 32-bit types for numeric stability, the model
+will have a lower step time and train equally as well in terms of the evaluation metrics such as accuracy.
+
+#### [TensorFlow Accelerated Linear Algebra(XLA)](https://www.tensorflow.org/xla)
+
+In a TensorFlow program, all of the operations are executed individually by the TensorFlow executor. Each TensorFlow
+operation has a precompiled GPU kernel implementation that the executor dispatches to.
+XLA provides an alternative mode of running models: it compiles the TensorFlow graph into a sequence of computation
+kernels generated specifically for the given model. Because these kernels are unique to the model, they can exploit
+model-specific information for optimization.
+
+For details on how to enable these features while training and evaluation see [Benchmarking](#benchmarking) section.
+
+## Installation
+
+* Clone code
+
+```
+git clone https://github.com/hamidriasat/NVIDIA-DeepLearningExamples.git
+cd NVIDIA-DeepLearningExamples/TensorFlow2/Segmentation/UNet3P/
+```
+
+* Build the UNet3P TensorFlow NGC container
+ From `Dockerfile` this will create a docker image with name `unet3p`. This image will contain all the components
+ required to successfully run the UNet3+ code.
+
+```
+docker build -t unet3p .
+```
+
+The NGC container contains all the components optimized for usage on NVIDIA hardware.
+
+* Start an interactive session in the NGC container
+
+To run preprocessing/training/inference, following command will launch the container and mount the current directory
+to `/workspace/unet3p` as a volume in the container
+
+```
+docker run --rm -it --shm-size=1g --ulimit memlock=-1 --pids-limit=8192 --gpus all -p 5012:8888 -v $PWD/:/workspace/unet3p --name unet3p unet3p:latest /bin/bash
+```
+
+Here we are mapping external port `5012` to `8888` inside docker. This will be used for visualization purpose.
+
+## Code Structure
+
+- **callbacks**: Custom callbacks to monitor training time, latency and throughput
+- **checkpoint**: Model checkpoint and logs directory
+- **configs**: Configuration file (see [Config](#config) for more details)
+- **data**: Dataset files (see [Data Preparation](#data-preparation) for more details)
+- **data_generators**: Data loaders for UNet3+ (see [Data Generators](#data-generators) for more details)
+- **data_preparation**: For LiTS data preparation and data verification
+- **figures**: Model architecture image
+- **losses**: Implementations of UNet3+ hybrid loss function and dice coefficient
+- **models**: Unet3+ model files (see [Models](#models) for more details)
+- **utils**: Generic utility functions
+- **benchmark_inference.py**: Benchmark script to output model throughput and latency while inference
+- **evaluate.py**: Evaluation script to validate accuracy on trained model
+- **predict.ipynb**: Prediction file used to visualize model output inside notebook(helpful for remote server
+ visualization)
+- **predict.py**: Prediction script used to visualize model output
+- **train.py**: Training script
+
+## Data Preparation
+
+- This code can be used to reproduce UNet3+ paper results
+ on [LiTS - Liver Tumor Segmentation Challenge](https://competitions.codalab.org/competitions/15595).
+- You can also use it to train UNet3+ on custom dataset.
+
+For dataset preparation read [here](data_preparation/README.md).
+
+## Config
+
+Configurations are passed through `yaml` file. For more details on config file read [here](configs/).
+
+## Data Generators
+
+We support two types of data loaders. `NVIDIA DALI` and `TensorFlow Sequence`
+generators. For more details on supported generator types read [here](data_generators/).
+
+## Models
+
+UNet 3+ is latest from Unet family, proposed for semantic image segmentation. it takes advantage of full-scale skip
+connections and deep supervisions.The full-scale skip connections incorporate low-level details with high-level
+semantics from feature maps in different scales; while the deep supervision learns hierarchical representations from the
+full-scale aggregated feature maps.
+
+
+
+Figure 1. UNet3+ architecture diagram from [original paper](https://arxiv.org/abs/2004.08790).
+
+This repo contains all three versions of UNet3+.
+
+| # | Description | Model Name | Training Supported |
+|:----|:-------------------------------------------------------------:|:-----------------------------------------------------------------:|:------------------:|
+| 1 | UNet3+ Base model | [unet3plus](models/unet3plus.py) | ✓ |
+| 2 | UNet3+ with Deep Supervision | [unet3plus_deepsup](models/unet3plus_deep_supervision.py) | ✓ |
+| 3 | UNet3+ with Deep Supervision and Classification Guided Module | [unet3plus_deepsup_cgm](models/unet3plus_deep_supervision_cgm.py) | ✗ |
+
+Available backbones are `unet3plus`, `vgg16` and `vgg19`. All backbones are untrained networks.
+
+In our case all results are reported using `vgg19` backbone and `unet3plus` variant.
+
+[Here](losses/unet_loss.py) you can find UNet3+ hybrid loss.
+
+## Performance
+
+### Benchmarking
+
+The following section shows how to run benchmarks to measure the model performance in training and inference modes.
+
+#### Training performance benchmark
+
+Run the `python train.py` script with the required model configurations to print training benchmark results for each
+model
+configuration. At the end of the training, a line reporting the training throughput and latency will be printed.
+
+To calculate dice score on trained model call `python evaluate.py` with required parameters.
+
+##### Example 1
+
+To train base model `unet3plus` with `vgg19` backbone on `single GPU`
+using `TensorFlow Sequence Generator` without `Automatic Mixed Precision(AMP)` and `Accelerated Linear Algebra(XLA)` run
+
+```
+python train.py MODEL.TYPE=unet3plus MODEL.BACKBONE.TYPE=vgg19 \
+USE_MULTI_GPUS.VALUE=False \
+DATA_GENERATOR_TYPE=TF_GENERATOR \
+OPTIMIZATION.AMP=False OPTIMIZATION.XLA=False
+```
+
+##### Example 2
+
+To train base model `unet3plus` with `vgg19` backbone on `multiple GPUs`
+using `TensorFlow Sequence Generator` without `Automatic Mixed Precision(AMP)` and `Accelerated Linear Algebra(XLA)` run
+
+```
+python train.py MODEL.TYPE=unet3plus MODEL.BACKBONE.TYPE=vgg19 \
+USE_MULTI_GPUS.VALUE=True USE_MULTI_GPUS.GPU_IDS=-1 \
+DATA_GENERATOR_TYPE=TF_GENERATOR \
+OPTIMIZATION.AMP=False OPTIMIZATION.XLA=False
+```
+
+##### Example 3
+
+To train base model `unet3plus` with `vgg19` backbone on `multiple GPUs`
+using `NVIDIA DALI Generator` with `Automatic Mixed Precision(AMP)` and `Accelerated Linear Algebra(XLA)` run
+
+```
+python train.py MODEL.TYPE=unet3plus MODEL.BACKBONE.TYPE=vgg19 \
+USE_MULTI_GPUS.VALUE=True USE_MULTI_GPUS.GPU_IDS=-1 \
+DATA_GENERATOR_TYPE=DALI_GENERATOR \
+OPTIMIZATION.AMP=True OPTIMIZATION.XLA=True
+```
+
+To evaluate/calculate dice accuracy of model pass same parameters to `evaluate.py` file. See [Config](#config) for
+complete hyper parameter details.
+
+Please check [Config](configs/config.yaml) file for more details about default training parameters.
+
+#### Inference performance benchmark
+
+To benchmark inference time, run the `python benchmark_inference.py` script with the required model configurations to
+print
+inference benchmark results for each model configuration. At the end, a line reporting the inference throughput and
+latency will be printed.
+
+For inference run without `data generator` and `GPUs` details but with `batch size`, `warmup_steps`
+and `bench_steps`
+parameters.
+
+```
+python benchmark_inference.py MODEL.TYPE=unet3plus MODEL.BACKBONE.TYPE=vgg19 \
+HYPER_PARAMETERS.BATCH_SIZE=16 \
+OPTIMIZATION.AMP=False OPTIMIZATION.XLA=False \
++warmup_steps=50 +bench_steps=100
+```
+
+Each of these scripts will by default run a warm-up for 50 iterations and then start benchmarking for another 100
+steps.
+You can adjust these settings with `+warmup_steps` and `+bench_steps` parameters.
+
+### Results
+
+The following section provide details of results that are achieved in different settings of model training and
+inference.
+
+#### Training accuracy results
+
+###### Training accuracy: NVIDIA DGX A100 (8xA100 80G)
+
+| #GPU | Generator | XLA | AMP | Training Time<br/>HH:MM:SS ↓ | Latency Avg [ms] ↓ | Throughput Avg [img/s] ↑ | Speed Up | Dice Score |
+|:----:|:---------:|:-------:|:-------:|:---------------------------------:|:-----------------------:|:-----------------------------:|:---------:|:----------:|
+| 1 | TF | ✗ | ✗ | 51:38:24.24 | 616.14 | 25.97 | --- | 0.96032 |
+| 8 | TF | ✗ | ✗ | 11:30:45 | 999.39 | 128.08 | 1x (base) | 0.95224 |
+| 8 | DALI | ✗ | ✗ | 6:23:43 | 614.26 | 208.38 | 1.8x | 0.94566 |
+| 8 | DALI | ✓ | ✗ | 7:33:15 | 692.71 | 184.78 | 1.5x | 0.94806 |
+| 8 | DALI | ✗ | ✓ | 3:49:55 | 357.34 | 358.2 | 3x | 0.94786 |
+| 8 | DALI | ✓ | ✓ | 3:14:24 | 302.83 | 422.68 | 3.5x | 0.9474 |
+
+Latency is reported in milliseconds per batch whereas throughput is reported in images per second.
+Speed Up comparison is efficiency achieved in terms of training time between different runs.
+
+Note: Training time includes time to load cuDNN in first iteration and the first epoch which take little longer as
+compared to later epochs because in first epoch tensorflow optimizes the training graph. In terms of latency and
+throughput it does not matter much because we have trained networks for 100 epochs which normalizes this during
+averaging.
+
+#### Inference performance results
+
+###### Inference performance: NVIDIA DGX A100 (1xA100 80G)
+
+| Batch Size | XLA | AMP | Latency Avg [ms] ↓ | Throughput Avg [img/s] ↑ |
+|:----------:|:-------:|:-------:|:-----------------------:|:-----------------------------:|
+| 1 | ✗ | ✗ | 59.54 | 16.79 |
+| 1 | ✓ | ✗ | 70.59 | 14.17 |
+| 1 | ✗ | ✓ | 56.17 | 17.80 |
+| 1 | ✓ | ✓ | 55.54 | 18.16 |
+| 16 | ✗ | ✗ | 225.59 | 70.93 |
+| 16 | ✓ | ✗ | 379.93 | 43.15 |
+| 16 | ✗ | ✓ | 184.98 | 87.02 |
+| 16 | ✓ | ✓ | 153.65 | 103.6 |
+
+Inference results are tested on single gpu. Here data generator type does not matter because only prediction time
+is calculated and averaged between 5 runs.
+
+## Inference Demo
+
+Model output can be visualized from Jupyter Notebook. Use below command to start Jupyter Lab on port `8888`.
+
+```
+jupyter lab --no-browser --allow-root --ip=0.0.0.0 --port=8888
+```
+
+While starting container we mapped system port `5012` to `8888` inside docker.
+> Note: Make sure you have server network ip and port access in case you are working with remote sever.
+
+Now in browser go to link `http://<server ip here>:5012/` to access Jupyter Lab.
+Open [predict.ipynb](predict.ipynb) notebook and rerun the whole notebook to visualize model output.
+
+There are two options for visualization, you can
+
+1. Visualize from directory
+
+It's going to make prediction and show all images from given directory. Useful for detailed evaluation.
+
+2. Visualize from list
+
+It's going to make prediction on elements of given list. Use for testing on specific cases.
+
+For custom data visualization set `SHOW_CENTER_CHANNEL_IMAGE=False`. This should set True for only UNet3+ LiTS data.
+
+For further details on visualization options see [predict.ipynb](predict.ipynb) notebook.
+
+## Known issues
+
+There are no known issues in this release.
+
+## Release notes
+
+### Changelog
+
+Feb 2023
+
+- Initial release
+
+We appreciate any feedback so reporting problems, and asking questions are welcomed here.
+
+Licensed under [MIT License](LICENSE)
diff --git a/TensorFlow2/Segmentation/UNet3P/benchmark_inference.py b/TensorFlow2/Segmentation/UNet3P/benchmark_inference.py
new file mode 100644
index 000000000..468607674
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/benchmark_inference.py
@@ -0,0 +1,101 @@
+"""
+Script to benchmark model throughput and latency
+"""
+import os
+import numpy as np
+from tqdm import tqdm
+from timeit import default_timer as timer
+import hydra
+from omegaconf import DictConfig
+import tensorflow as tf
+from tensorflow.keras import mixed_precision
+
+from data_generators import tf_data_generator
+from utils.general_utils import join_paths, suppress_warnings
+from utils.images_utils import postprocess_mask
+from models.model import prepare_model
+
+
+def benchmark_time(cfg: DictConfig):
+ """
+ Output throughput and latency
+ """
+
+ # suppress TensorFlow and DALI warnings
+ suppress_warnings()
+
+ if cfg.OPTIMIZATION.AMP:
+ print("Enabling Automatic Mixed Precision(AMP)")
+ policy = mixed_precision.Policy('mixed_float16')
+ mixed_precision.set_global_policy(policy)
+
+ if cfg.OPTIMIZATION.XLA:
+ print("Enabling Accelerated Linear Algebra(XLA)")
+ tf.config.optimizer.set_jit(True)
+
+ # data generator
+ val_generator = tf_data_generator.DataGenerator(cfg, mode="VAL")
+ validation_steps = val_generator.__len__()
+
+ warmup_steps, bench_steps = 50, 100
+ if "warmup_steps" in cfg.keys():
+ warmup_steps = cfg.warmup_steps
+ if "bench_steps" in cfg.keys():
+ bench_steps = cfg.bench_steps
+ validation_steps = min(validation_steps, (warmup_steps + bench_steps))
+
+ progress_bar = tqdm(total=validation_steps)
+
+ # create model
+ model = prepare_model(cfg)
+
+ # weights model path
+ checkpoint_path = join_paths(
+ cfg.WORK_DIR,
+ cfg.CALLBACKS.MODEL_CHECKPOINT.PATH,
+ f"{cfg.MODEL.WEIGHTS_FILE_NAME}.hdf5"
+ )
+
+ assert os.path.exists(checkpoint_path), \
+ f"Model weight's file does not exist at \n{checkpoint_path}"
+
+ # load model weights
+ model.load_weights(checkpoint_path, by_name=True, skip_mismatch=True)
+ # model.summary()
+
+ time_taken = []
+ # for each batch
+ for i, (batch_images, batch_mask) in enumerate(val_generator):
+
+ start_time = timer()
+ # make prediction on batch
+ batch_predictions = model.predict_on_batch(batch_images)
+ if len(model.outputs) > 1:
+ batch_predictions = batch_predictions[0]
+
+ # do postprocessing on predicted mask
+ batch_predictions = postprocess_mask(batch_predictions, cfg.OUTPUT.CLASSES)
+
+ time_taken.append(timer() - start_time)
+
+ progress_bar.update(1)
+ if i >= validation_steps:
+ break
+ progress_bar.close()
+
+ mean_time = np.mean(time_taken[warmup_steps:]) # skipping warmup_steps
+ throughput = (cfg.HYPER_PARAMETERS.BATCH_SIZE / mean_time)
+ print(f"Latency: {round(mean_time * 1e3, 2)} msec")
+ print(f"Throughput/FPS: {round(throughput, 2)} samples/sec")
+
+
+@hydra.main(version_base=None, config_path="configs", config_name="config")
+def main(cfg: DictConfig):
+ """
+ Read config file and pass to benchmark_time method
+ """
+ benchmark_time(cfg)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/TensorFlow2/Segmentation/UNet3P/callbacks/timing_callback.py b/TensorFlow2/Segmentation/UNet3P/callbacks/timing_callback.py
new file mode 100644
index 000000000..093fabce0
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/callbacks/timing_callback.py
@@ -0,0 +1,30 @@
+import sys
+from timeit import default_timer as timer
+import tensorflow as tf
+
+
+class TimingCallback(tf.keras.callbacks.Callback):
+ """
+ Custom callback to note training time, latency and throughput
+ """
+
+ def __init__(self, ):
+ super(TimingCallback, self).__init__()
+ self.train_start_time = None
+ self.train_end_time = None
+ self.batch_time = []
+ self.batch_start_time = None
+
+ def on_train_begin(self, logs: dict):
+ tf.print("Training starting time noted.", output_stream=sys.stdout)
+ self.train_start_time = timer()
+
+ def on_train_end(self, logs: dict):
+ tf.print("Training ending time noted.", output_stream=sys.stdout)
+ self.train_end_time = timer()
+
+ def on_train_batch_begin(self, batch: int, logs: dict):
+ self.batch_start_time = timer()
+
+ def on_train_batch_end(self, batch: int, logs: dict):
+ self.batch_time.append(timer() - self.batch_start_time)
diff --git a/TensorFlow2/Segmentation/UNet3P/checkpoint/tb_logs/.gitkeep b/TensorFlow2/Segmentation/UNet3P/checkpoint/tb_logs/.gitkeep
new file mode 100644
index 000000000..e69de29bb
diff --git a/TensorFlow2/Segmentation/UNet3P/configs/README.md b/TensorFlow2/Segmentation/UNet3P/configs/README.md
new file mode 100644
index 000000000..80d091d3d
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/configs/README.md
@@ -0,0 +1,86 @@
+Here we provide **overview** of our config file and how you can use your own custom settings's for training and
+evaluation.
+
+We are using [Hydra](https://hydra.cc/) for passing configurations. Hydra is a framework for elegantly configuring
+complex applications. In Hydra you can easily [extend](https://hydra.cc/docs/patterns/extending_configs/)
+and [interpolate](https://hydra.cc/docs/advanced/override_grammar/basic/#primitives) `yaml` config files.
+
+#### Override Hydra config from command line
+
+[Here](https://hydra.cc/docs/1.0/advanced/override_grammar/basic/) you can read how to pass or override configurations
+through command line. Overall to
+
+###### Override higher level attribute
+
+Directly access the key and override its value
+
+- For instance to override Data generator pass `DATA_GENERATOR_TYPE=DALI_GENERATOR`
+
+###### Override nested attribute
+
+Use `.` to access nested keys
+
+- For instance to override model type `MODEL.TYPE=unet3plus`
+- To override model backbone `MODEL.BACKBONE.TYPE=vgg19`
+
+To add new element from command line add `+` before attribute name. E.g. `+warmup_steps=50` because warm steps is not
+added in config file.
+
+> Note: Don't add space between list elements, it will create problem with Hydra.
+
+Most of the configurations attributes in our [config](./../configs/config.yaml) are self-explanatory. However, for some
+attributes additional comments are added.
+
+You can override configurations from command line too, but it's **advisable to override them from config file** because
+it's
+easy.
+
+By default, hydra stores a log file of each run in a separate directory. We have disabled it in our case,
+if you want to enable them to keep record of each run configuration's then comment out the settings at the end of config
+file.
+
+```yaml
+# project root working directory, automatically read by hydra (.../UNet3P)
+WORK_DIR: ${hydra:runtime.cwd}
+DATA_PREPARATION:
+ # unprocessed LiTS scan data paths, for custom data training skip this section details
+ SCANS_TRAIN_DATA_PATH: "/data/Training Batch 2/"
+ ...
+DATASET:
+ # training data paths, should be relative from project root path
+ TRAIN:
+ IMAGES_PATH: "/data/train/images"
+ ...
+MODEL:
+ # available variants are unet3plus, unet3plus_deepsup, unet3plus_deepsup_cgm
+ TYPE: "unet3plus"
+ BACKBONE:
+ ...
+...
+DATA_GENERATOR_TYPE: "DALI_GENERATOR" # options are TF_GENERATOR or DALI_GENERATOR
+SHOW_CENTER_CHANNEL_IMAGE: True # only true for UNet3+. for custom dataset it should be False
+# Model input shape
+INPUT:
+ HEIGHT: 320
+ ...
+# Model output classes
+OUTPUT:
+ CLASSES: 2
+HYPER_PARAMETERS:
+ EPOCHS: 5
+ BATCH_SIZE: 2 # specify per gpu batch size
+ ...
+CALLBACKS:
+ TENSORBOARD:
+ ...
+PREPROCESS_DATA:
+ RESIZE:
+ VALUE: False # if True, resize to input height and width
+ ...
+USE_MULTI_GPUS:
+ ...
+# to stop hydra from storing logs files
+defaults:
+ ...
+
+```
diff --git a/TensorFlow2/Segmentation/UNet3P/configs/config.yaml b/TensorFlow2/Segmentation/UNet3P/configs/config.yaml
new file mode 100644
index 000000000..6496ac019
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/configs/config.yaml
@@ -0,0 +1,118 @@
+# project root working directory, automatically read by hydra (.../UNet3P)
+WORK_DIR: ${hydra:runtime.cwd}
+
+DATA_PREPARATION:
+ # unprocessed LiTS scan data paths, for custom data training skip this section details
+ SCANS_TRAIN_DATA_PATH: "/data/Training Batch 2/"
+ SCANS_VAL_DATA_PATH: "/data/Training Batch 1/"
+
+ # Resize scans to model input size
+ RESIZED_HEIGHT: ${INPUT.HEIGHT}
+ RESIZED_WIDTH: ${INPUT.WIDTH}
+
+ # Clip scans value in given range
+ SCAN_MIN_VALUE: -200
+ SCAN_MAX_VALUE: 250
+
+DATASET:
+ # paths should be relative from project root path
+ TRAIN:
+ IMAGES_PATH: "/data/train/images"
+ MASK_PATH: "/data/train/mask"
+ VAL:
+ IMAGES_PATH: "/data/val/images"
+ MASK_PATH: "/data/val/mask"
+
+
+MODEL:
+ # available variants are unet3plus, unet3plus_deepsup, unet3plus_deepsup_cgm
+ TYPE: "unet3plus"
+ WEIGHTS_FILE_NAME: model_${MODEL.TYPE}
+ BACKBONE:
+ # available variants are unet3plus, vgg16, vgg19
+ TYPE: "vgg19"
+
+DATA_GENERATOR_TYPE: "DALI_GENERATOR" # options are TF_GENERATOR or DALI_GENERATOR
+SEED: 5 # for result's reproducibility
+VERBOSE: 1 # For logs printing details, available options are 0, 1, 2
+DATALOADER_WORKERS: 3 # number of workers used for data loading
+SHOW_CENTER_CHANNEL_IMAGE: True # only true for UNet3+ for custom dataset it should be False
+
+# Model input shape
+INPUT:
+ HEIGHT: 320
+ WIDTH: 320
+ CHANNELS: 3
+
+# Model output classes
+OUTPUT:
+ CLASSES: 2
+
+
+HYPER_PARAMETERS:
+ EPOCHS: 100
+ BATCH_SIZE: 16 # specify per gpu batch size
+ LEARNING_RATE: 5e-5 # 0.1, 1e-3, 3e-4, 5e-5
+
+
+CALLBACKS:
+ # paths should be relative from project root path
+ TENSORBOARD:
+ PATH: "/checkpoint/tb_logs"
+
+ EARLY_STOPPING:
+ PATIENCE: 100
+
+ MODEL_CHECKPOINT:
+ PATH: "/checkpoint"
+ SAVE_WEIGHTS_ONLY: True
+ SAVE_BEST_ONLY: True
+
+ CSV_LOGGER:
+ PATH: "/checkpoint"
+ APPEND_LOGS: False
+
+
+PREPROCESS_DATA:
+ RESIZE:
+ VALUE: False # if True, resize to input height and width
+ HEIGHT: ${INPUT.HEIGHT}
+ WIDTH: ${INPUT.WIDTH}
+
+ IMAGE_PREPROCESSING_TYPE: "normalize"
+
+ NORMALIZE_MASK:
+ VALUE: False # if True, divide mask by given value
+ NORMALIZE_VALUE: 255
+
+ SHUFFLE:
+ TRAIN:
+ VALUE: True
+ VAL:
+ VALUE: False
+
+
+USE_MULTI_GPUS:
+ VALUE: True # If True use multiple gpus for training
+ # GPU_IDS: Could be integer or list of integers.
+ # In case Integer: if integer value is -1 then it uses all available gpus.
+ # otherwise if positive number, then use given number of gpus.
+ # In case list of Integers: each integer will be considered as gpu id
+ # e.g. [4, 5, 7] means use gpu 5,6 and 8 for training/evaluation
+ GPU_IDS: -1
+
+
+OPTIMIZATION:
+ AMP: True # Automatic Mixed Precision(AMP)
+ XLA: True # Accelerated Linear Algebra(XLA)
+
+
+# to stop hydra from storing logs files
+# logs will be stored in outputs directory
+defaults:
+ - _self_
+ - override hydra/hydra_logging: disabled
+ - override hydra/job_logging: disabled
+
+hydra:
+ output_subdir: null
diff --git a/TensorFlow2/Segmentation/UNet3P/data/Training Batch 1/.gitkeep b/TensorFlow2/Segmentation/UNet3P/data/Training Batch 1/.gitkeep
new file mode 100644
index 000000000..e69de29bb
diff --git a/TensorFlow2/Segmentation/UNet3P/data/Training Batch 2/.gitkeep b/TensorFlow2/Segmentation/UNet3P/data/Training Batch 2/.gitkeep
new file mode 100644
index 000000000..e69de29bb
diff --git a/TensorFlow2/Segmentation/UNet3P/data/train/.gitkeep b/TensorFlow2/Segmentation/UNet3P/data/train/.gitkeep
new file mode 100644
index 000000000..e69de29bb
diff --git a/TensorFlow2/Segmentation/UNet3P/data/val/.gitkeep b/TensorFlow2/Segmentation/UNet3P/data/val/.gitkeep
new file mode 100644
index 000000000..e69de29bb
diff --git a/TensorFlow2/Segmentation/UNet3P/data_generators/README.md b/TensorFlow2/Segmentation/UNet3P/data_generators/README.md
new file mode 100644
index 000000000..d65de3a72
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/data_generators/README.md
@@ -0,0 +1,44 @@
+Our code base support two types of data loaders.
+
+- [Tensorflow Sequence Generator](#tensorflow-sequence-generator)
+- [NVIDIA DALI Generator](#nvidia-dali-generator)
+
+## [Tensorflow Sequence Generator](https://www.tensorflow.org/api_docs/python/tf/keras/utils/Sequence)
+
+Sequence data generator is best suited for situations where we need
+advanced control over sample generation or when simple data does not
+fit into memory and must be loaded dynamically.
+
+Our [sequence generator](./../data_generators/tf_data_generator.py) generates
+dataset on multiple cores in real time and feed it right away to deep
+learning model.
+
+## [NVIDIA DALI Generator](https://docs.nvidia.com/deeplearning/dali/user-guide/docs/index.html)
+
+The NVIDIA Data Loading Library (DALI) is a library for data loading and
+pre-processing to accelerate deep learning applications. It provides a
+collection of highly optimized building blocks for loading and processing
+image, video and audio data. It can be used as a portable drop-in
+replacement for built in data loaders and data iterators in popular deep
+learning frameworks.
+
+We've used [DALI Pipeline](./../data_generators/dali_data_generator.py) to directly load
+data on `GPU`, which resulted in reduced latency and training time,
+mitigating bottlenecks, by overlapping training and pre-processing. Our code
+base also support's multi GPU data loading for DALI.
+
+## Use Cases
+
+For training and evaluation you can use both `TF Sequence` and `DALI` generator with multiple gpus, but for prediction
+and inference benchmark we only support `TF Sequence` generator with single gpu support.
+
+> Reminder: DALI is only supported on Linux platforms. For Windows, you can
+> train using Sequence Generator. The code base will work without DALI
+> installation too.
+
+It's advised to use DALI only when you have large gpu memory to load both model
+and training data at the same time.
+
+Override `DATA_GENERATOR_TYPE` in config to change default generator type. Possible
+options are `TF_GENERATOR` for Sequence generator and `DALI_GENERATOR` for DALI generator.
+
diff --git a/TensorFlow2/Segmentation/UNet3P/data_generators/dali_data_generator.py b/TensorFlow2/Segmentation/UNet3P/data_generators/dali_data_generator.py
new file mode 100644
index 000000000..085c321de
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/data_generators/dali_data_generator.py
@@ -0,0 +1,264 @@
+"""
+NVIDIA DALI data generator object.
+"""
+import nvidia.dali.fn as fn
+from nvidia.dali import pipeline_def
+import nvidia.dali.types as types
+import nvidia.dali.plugin.tf as dali_tf
+import tensorflow as tf
+from omegaconf import DictConfig
+
+from utils.general_utils import get_data_paths, get_gpus_count
+
+
+def data_generator_pipeline(cfg: DictConfig, mode: str, mask_available: bool):
+ """
+ Returns DALI data pipeline object.
+ """
+ data_paths = get_data_paths(cfg, mode, mask_available) # get data paths
+ images_paths = data_paths[0]
+ if mask_available:
+ mask_paths = data_paths[1]
+
+ @pipeline_def(batch_size=cfg.HYPER_PARAMETERS.BATCH_SIZE)
+ def single_gpu_pipeline(device):
+ """
+ Returns DALI data pipeline object for single GPU training.
+ """
+ device = 'mixed' if 'gpu' in device.lower() else 'cpu'
+
+ pngs, _ = fn.readers.file(
+ files=images_paths,
+ random_shuffle=cfg.PREPROCESS_DATA.SHUFFLE[mode].VALUE,
+ seed=cfg.SEED
+ )
+ images = fn.decoders.image(pngs, device=device, output_type=types.RGB)
+ if cfg.PREPROCESS_DATA.RESIZE.VALUE:
+ # TODO verify image resizing method
+ images = fn.resize(
+ images,
+ size=[
+ cfg.PREPROCESS_DATA.RESIZE.HEIGHT,
+ cfg.PREPROCESS_DATA.RESIZE.WIDTH
+ ]
+ )
+ if cfg.PREPROCESS_DATA.IMAGE_PREPROCESSING_TYPE == "normalize":
+ images = fn.normalize(images, mean=0, stddev=255, ) # axes=(2,)
+
+ if mask_available:
+ labels, _ = fn.readers.file(
+ files=mask_paths,
+ random_shuffle=cfg.PREPROCESS_DATA.SHUFFLE[mode].VALUE,
+ seed=cfg.SEED
+ )
+ labels = fn.decoders.image(
+ labels,
+ device=device,
+ output_type=types.GRAY
+ )
+ if cfg.PREPROCESS_DATA.RESIZE.VALUE:
+ # TODO verify image resizing method
+ labels = fn.resize(
+ labels,
+ size=[
+ cfg.PREPROCESS_DATA.RESIZE.HEIGHT,
+ cfg.PREPROCESS_DATA.RESIZE.WIDTH
+ ]
+ )
+ if cfg.PREPROCESS_DATA.NORMALIZE_MASK.VALUE:
+ labels = fn.normalize(
+ labels,
+ mean=0,
+ stddev=cfg.PREPROCESS_DATA.NORMALIZE_MASK.NORMALIZE_VALUE,
+ )
+ if cfg.OUTPUT.CLASSES == 1:
+ labels = fn.cast(labels, dtype=types.FLOAT)
+ else:
+ labels = fn.squeeze(labels, axes=[2])
+ labels = fn.one_hot(labels, num_classes=cfg.OUTPUT.CLASSES)
+
+ if mask_available:
+ return images, labels
+ else:
+ return images,
+
+ @pipeline_def(batch_size=cfg.HYPER_PARAMETERS.BATCH_SIZE)
+ def multi_gpu_pipeline(device, shard_id):
+ """
+ Returns DALI data pipeline object for multi GPU'S training.
+ """
+ device = 'mixed' if 'gpu' in device.lower() else 'cpu'
+ shard_id = 1 if 'cpu' in device else shard_id
+ num_shards = get_gpus_count()
+ # num_shards should be <= #images
+ num_shards = len(images_paths) if num_shards > len(images_paths) else num_shards
+
+ pngs, _ = fn.readers.file(
+ files=images_paths,
+ random_shuffle=cfg.PREPROCESS_DATA.SHUFFLE[mode].VALUE,
+ shard_id=shard_id,
+ num_shards=num_shards,
+ seed=cfg.SEED
+ )
+ images = fn.decoders.image(pngs, device=device, output_type=types.RGB)
+ if cfg.PREPROCESS_DATA.RESIZE.VALUE:
+ # TODO verify image resizing method
+ images = fn.resize(
+ images,
+ size=[
+ cfg.PREPROCESS_DATA.RESIZE.HEIGHT,
+ cfg.PREPROCESS_DATA.RESIZE.WIDTH
+ ]
+ )
+ if cfg.PREPROCESS_DATA.IMAGE_PREPROCESSING_TYPE == "normalize":
+ images = fn.normalize(images, mean=0, stddev=255, ) # axes=(2,)
+
+ if mask_available:
+ labels, _ = fn.readers.file(
+ files=mask_paths,
+ random_shuffle=cfg.PREPROCESS_DATA.SHUFFLE[mode].VALUE,
+ shard_id=shard_id,
+ num_shards=num_shards,
+ seed=cfg.SEED
+ )
+ labels = fn.decoders.image(
+ labels,
+ device=device,
+ output_type=types.GRAY
+ )
+ if cfg.PREPROCESS_DATA.RESIZE.VALUE:
+ # TODO verify image resizing method
+ labels = fn.resize(
+ labels,
+ size=[
+ cfg.PREPROCESS_DATA.RESIZE.HEIGHT,
+ cfg.PREPROCESS_DATA.RESIZE.WIDTH
+ ]
+ )
+ if cfg.PREPROCESS_DATA.NORMALIZE_MASK.VALUE:
+ labels = fn.normalize(
+ labels,
+ mean=0,
+ stddev=cfg.PREPROCESS_DATA.NORMALIZE_MASK.NORMALIZE_VALUE,
+ )
+ if cfg.OUTPUT.CLASSES == 1:
+ labels = fn.cast(labels, dtype=types.FLOAT)
+ else:
+ labels = fn.squeeze(labels, axes=[2])
+ labels = fn.one_hot(labels, num_classes=cfg.OUTPUT.CLASSES)
+
+ if mask_available:
+ return images, labels
+ else:
+ return images,
+
+ if cfg.USE_MULTI_GPUS.VALUE:
+ return multi_gpu_pipeline
+ else:
+ return single_gpu_pipeline
+
+
+def get_data_shapes(cfg: DictConfig, mask_available: bool):
+ """
+ Returns shapes and dtypes of the outputs.
+ """
+ if mask_available:
+ shapes = (
+ (cfg.HYPER_PARAMETERS.BATCH_SIZE,
+ cfg.INPUT.HEIGHT,
+ cfg.INPUT.WIDTH,
+ cfg.INPUT.CHANNELS),
+ (cfg.HYPER_PARAMETERS.BATCH_SIZE,
+ cfg.INPUT.HEIGHT,
+ cfg.INPUT.WIDTH,
+ cfg.OUTPUT.CLASSES)
+ )
+ dtypes = (
+ tf.float32,
+ tf.float32)
+ else:
+ shapes = (
+ (cfg.HYPER_PARAMETERS.BATCH_SIZE,
+ cfg.INPUT.HEIGHT,
+ cfg.INPUT.WIDTH,
+ cfg.INPUT.CHANNELS),
+ )
+ dtypes = (
+ tf.float32,
+ )
+ return shapes, dtypes
+
+
+def data_generator(cfg: DictConfig,
+ mode: str,
+ strategy: tf.distribute.Strategy = None):
+ """
+ Generate batches of data for model by reading images and their
+ corresponding masks using NVIDIA DALI.
+ Works for both single and mult GPU's. In case of multi gpu pass
+ the strategy object too.
+ There are two options you can either pass directory path or list.
+ In case of directory, it should contain relative path of images/mask
+ folder from project root path.
+ In case of list of images, every element should contain absolute path
+ for each image and mask.
+ """
+
+ # check mask are available or not
+ mask_available = False if cfg.DATASET[mode].MASK_PATH is None or str(
+ cfg.DATASET[mode].MASK_PATH).lower() == "none" else True
+
+ # create dali data pipeline
+ data_pipeline = data_generator_pipeline(cfg, mode, mask_available)
+
+ shapes, dtypes = get_data_shapes(cfg, mask_available)
+
+ if cfg.USE_MULTI_GPUS.VALUE:
+ def bound_dataset(input_context):
+ """
+ In case of multi gpu training bound dataset to a device for distributed training.
+ """
+ with tf.device("/gpu:{}".format(input_context.input_pipeline_id)):
+ device_id = input_context.input_pipeline_id
+ return dali_tf.DALIDataset(
+ pipeline=data_pipeline(
+ device="gpu",
+ device_id=device_id,
+ shard_id=device_id,
+ num_threads=cfg.DATALOADER_WORKERS
+ ),
+ batch_size=cfg.HYPER_PARAMETERS.BATCH_SIZE,
+ output_shapes=shapes,
+ output_dtypes=dtypes,
+ device_id=device_id,
+ )
+
+ # distribute dataset
+ input_options = tf.distribute.InputOptions(
+ experimental_place_dataset_on_device=True,
+ # for older dali versions use experimental_prefetch_to_device
+ # for new dali versions use experimental_fetch_to_device
+ experimental_fetch_to_device=False, # experimental_fetch_to_device
+ experimental_replication_mode=tf.distribute.InputReplicationMode.PER_REPLICA)
+
+ # map dataset to given strategy and return it
+ return strategy.distribute_datasets_from_function(bound_dataset, input_options)
+ else:
+ # single gpu pipeline
+ pipeline = data_pipeline(
+ batch_size=cfg.HYPER_PARAMETERS.BATCH_SIZE,
+ num_threads=cfg.DATALOADER_WORKERS,
+ device="gpu",
+ device_id=0
+ )
+
+ # create dataset
+ with tf.device('/gpu:0'):
+ data_generator = dali_tf.DALIDataset(
+ pipeline=pipeline,
+ batch_size=cfg.HYPER_PARAMETERS.BATCH_SIZE,
+ output_shapes=shapes,
+ output_dtypes=dtypes,
+ device_id=0)
+
+ return data_generator
diff --git a/TensorFlow2/Segmentation/UNet3P/data_generators/data_generator.py b/TensorFlow2/Segmentation/UNet3P/data_generators/data_generator.py
new file mode 100644
index 000000000..ab19123e2
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/data_generators/data_generator.py
@@ -0,0 +1,88 @@
+"""
+Data generator
+"""
+import os
+import tensorflow as tf
+from omegaconf import DictConfig
+
+from utils.general_utils import join_paths, get_gpus_count
+from .tf_data_generator import DataGenerator as tf_data_generator
+
+try:
+ from .dali_data_generator import data_generator as dali_data_generator
+except ModuleNotFoundError:
+ print("NVIDIA DALI not installed, please install it."
+ "\nNote: DALI is only available on Linux platform. For Window "
+ "you can use TensorFlow generator for training.")
+
+
+def get_data_generator(cfg: DictConfig,
+ mode: str,
+ strategy: tf.distribute.Strategy = None):
+ """
+ Creates and return data generator object based on given type.
+ """
+ if cfg.DATA_GENERATOR_TYPE == "TF_GENERATOR":
+ print(f"Using TensorFlow generator for {mode} data")
+ generator = tf_data_generator(cfg, mode)
+ elif cfg.DATA_GENERATOR_TYPE == "DALI_GENERATOR":
+ print(f"Using NVIDIA DALI generator for {mode} data")
+ if cfg.USE_MULTI_GPUS.VALUE:
+ generator = dali_data_generator(cfg, mode, strategy)
+ else:
+ generator = dali_data_generator(cfg, mode)
+ else:
+ raise ValueError(
+ "Wrong generator type passed."
+ "\nPossible options are TF_GENERATOR and DALI_GENERATOR"
+ )
+ return generator
+
+
+def update_batch_size(cfg: DictConfig):
+ """
+ Scale up batch size to multi gpus in case of TensorFlow generator.
+ """
+ if cfg.DATA_GENERATOR_TYPE == "TF_GENERATOR" and cfg.USE_MULTI_GPUS.VALUE:
+ # change batch size according to available gpus
+ cfg.HYPER_PARAMETERS.BATCH_SIZE = \
+ cfg.HYPER_PARAMETERS.BATCH_SIZE * get_gpus_count()
+
+
+def get_batch_size(cfg: DictConfig):
+ """
+ Return batch size.
+ In case of DALI generator scale up batch size to multi gpus.
+ """
+ if cfg.DATA_GENERATOR_TYPE == "DALI_GENERATOR" and cfg.USE_MULTI_GPUS.VALUE:
+ # change batch size according to available gpus
+ return cfg.HYPER_PARAMETERS.BATCH_SIZE * get_gpus_count()
+ else:
+ return cfg.HYPER_PARAMETERS.BATCH_SIZE
+
+
+def get_iterations(cfg: DictConfig, mode: str):
+ """
+ Return steps per epoch
+ """
+ images_length = len(
+ os.listdir(
+ join_paths(
+ cfg.WORK_DIR,
+ cfg.DATASET[mode].IMAGES_PATH
+ )
+ )
+ )
+
+ if cfg.DATA_GENERATOR_TYPE == "TF_GENERATOR":
+ training_steps = images_length // cfg.HYPER_PARAMETERS.BATCH_SIZE
+ elif cfg.DATA_GENERATOR_TYPE == "DALI_GENERATOR":
+ if cfg.USE_MULTI_GPUS.VALUE:
+ training_steps = images_length // (
+ cfg.HYPER_PARAMETERS.BATCH_SIZE * get_gpus_count())
+ else:
+ training_steps = images_length // cfg.HYPER_PARAMETERS.BATCH_SIZE
+ else:
+ raise ValueError("Wrong generator type passed.")
+
+ return training_steps
diff --git a/TensorFlow2/Segmentation/UNet3P/data_generators/tf_data_generator.py b/TensorFlow2/Segmentation/UNet3P/data_generators/tf_data_generator.py
new file mode 100644
index 000000000..8f35a1b84
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/data_generators/tf_data_generator.py
@@ -0,0 +1,179 @@
+"""
+Tensorflow data generator class.
+"""
+import tensorflow as tf
+import numpy as np
+from omegaconf import DictConfig
+
+from utils.general_utils import get_data_paths
+from utils.images_utils import prepare_image, prepare_mask
+
+
+class DataGenerator(tf.keras.utils.Sequence):
+ """
+ Generate batches of data for model by reading images and their
+ corresponding masks using TensorFlow Sequence Generator.
+ There are two options you can either pass directory path or list.
+ In case of directory, it should contain relative path of images/mask
+ folder from project root path.
+ In case of list of images, every element should contain absolute path
+ for each image and mask.
+ Because this generator is also used for prediction, so during testing you can
+ set mask path to None if mask are not available for visualization.
+ """
+
+ def __init__(self, cfg: DictConfig, mode: str):
+ """
+ Initialization
+ """
+ self.cfg = cfg
+ self.mode = mode
+ self.batch_size = self.cfg.HYPER_PARAMETERS.BATCH_SIZE
+ # set seed for reproducibility
+ np.random.seed(cfg.SEED)
+
+ # check mask are available or not
+ self.mask_available = False if cfg.DATASET[mode].MASK_PATH is None or str(
+ cfg.DATASET[mode].MASK_PATH).lower() == "none" else True
+
+ data_paths = get_data_paths(cfg, mode, self.mask_available)
+
+ self.images_paths = data_paths[0]
+ if self.mask_available:
+ self.mask_paths = data_paths[1]
+
+ # self.images_paths.sort() # no need for sorting
+
+ self.on_epoch_end()
+
+ def __len__(self):
+ """
+ Denotes the number of batches per epoch
+ """
+ # Tensorflow problem: on_epoch_end is not being called at the end
+ # of each epoch, so forcing on_epoch_end call
+ self.on_epoch_end()
+ return int(
+ np.floor(
+ len(self.images_paths) / self.batch_size
+ )
+ )
+
+ def on_epoch_end(self):
+ """
+ Updates indexes after each epoch
+ """
+ self.indexes = np.arange(len(self.images_paths))
+ if self.cfg.PREPROCESS_DATA.SHUFFLE[self.mode].VALUE:
+ np.random.shuffle(self.indexes)
+
+ def __getitem__(self, index):
+ """
+ Generate one batch of data
+ """
+ # Generate indexes of the batch
+ indexes = self.indexes[
+ index * self.batch_size:(index + 1) * self.batch_size
+ ]
+
+ # Generate data
+ return self.__data_generation(indexes)
+
+ def __data_generation(self, indexes):
+ """
+ Generates batch data
+ """
+
+ # create empty array to store batch data
+ batch_images = np.zeros(
+ (
+ self.cfg.HYPER_PARAMETERS.BATCH_SIZE,
+ self.cfg.INPUT.HEIGHT,
+ self.cfg.INPUT.WIDTH,
+ self.cfg.INPUT.CHANNELS
+ )
+ ).astype(np.float32)
+
+ if self.mask_available:
+ batch_masks = np.zeros(
+ (
+ self.cfg.HYPER_PARAMETERS.BATCH_SIZE,
+ self.cfg.INPUT.HEIGHT,
+ self.cfg.INPUT.WIDTH,
+ self.cfg.OUTPUT.CLASSES
+ )
+ ).astype(np.float32)
+
+ for i, index in enumerate(indexes):
+ # extract path from list
+ img_path = self.images_paths[int(index)]
+ if self.mask_available:
+ mask_path = self.mask_paths[int(index)]
+
+ # prepare image for model by resizing and preprocessing it
+ image = prepare_image(
+ img_path,
+ self.cfg.PREPROCESS_DATA.RESIZE,
+ self.cfg.PREPROCESS_DATA.IMAGE_PREPROCESSING_TYPE,
+ )
+
+ if self.mask_available:
+ # prepare image for model by resizing and preprocessing it
+ mask = prepare_mask(
+ mask_path,
+ self.cfg.PREPROCESS_DATA.RESIZE,
+ self.cfg.PREPROCESS_DATA.NORMALIZE_MASK,
+ )
+
+ # numpy to tensorflow conversion
+ if self.mask_available:
+ image, mask = tf.numpy_function(
+ self.tf_func,
+ [image, mask],
+ [tf.float32, tf.int32]
+ )
+ else:
+ image = tf.numpy_function(
+ self.tf_func,
+ [image, ],
+ [tf.float32, ]
+ )
+
+ # set shape attributes which was lost during Tf conversion
+ image.set_shape(
+ [
+ self.cfg.INPUT.HEIGHT,
+ self.cfg.INPUT.WIDTH,
+ self.cfg.INPUT.CHANNELS
+ ]
+ )
+ batch_images[i] = image
+
+ if self.mask_available:
+ # height x width --> height x width x output classes
+ if self.cfg.OUTPUT.CLASSES == 1:
+ mask = tf.expand_dims(mask, axis=-1)
+ else:
+ # convert mask into one hot vectors
+ mask = tf.one_hot(
+ mask,
+ self.cfg.OUTPUT.CLASSES,
+ dtype=tf.int32
+ )
+ mask.set_shape(
+ [
+ self.cfg.INPUT.HEIGHT,
+ self.cfg.INPUT.WIDTH,
+ self.cfg.OUTPUT.CLASSES
+ ]
+ )
+ batch_masks[i] = mask
+
+ if self.mask_available:
+ return batch_images, batch_masks
+ else:
+ return batch_images,
+
+ @staticmethod
+ def tf_func(*args):
+ return args
diff --git a/TensorFlow2/Segmentation/UNet3P/data_preparation/README.md b/TensorFlow2/Segmentation/UNet3P/data_preparation/README.md
new file mode 100644
index 000000000..9acd5b172
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/data_preparation/README.md
@@ -0,0 +1,102 @@
+For data two options are available
+
+- [Train on LiTS Data](#lits-liver-tumor-segmentation-challenge)
+- [Train on custom data](#train-on-custom-data)
+
+## LiTS Liver Tumor Segmentation challenge
+
+This dataset consist of 131 Liver CT Scans.
+
+Register [here](https://competitions.codalab.org/competitions/17094) to get dataset access.
+Go to participate → Training Data to get dataset link.
+Download Training Batch 1 and Training Batch 2 zip files and past them under data folder.
+
+`Training Batch 1` size is 3.97GB and `Training Batch 2` zip file size is 11.5GB.
+
+Inside main directory `/workspace/unet3p` run below command to extract zip files
+
+```shell
+bash data_preparation/extract_data.sh
+```
+
+After extraction `Training Batch 1` folder size will be 11.4GB and `Training Batch 2` folder size will be 38.5GB.
+
+- `Training Batch 1` consist of 28 scans which are used for testing
+- `Training Batch 2` consist of 103 scans which are used for training
+
+Default directory structure looks like this
+
+ ├── data/
+ │ ├── Training Batch 1/
+ ├── segmentation-0.nii
+ ├── volume-0.nii
+ ├── ...
+ ├── volume-27.nii
+ │ ├── Training Batch 2/
+ ├── segmentation-28.nii
+ ├── volume-28.nii
+ ├── ...
+ ├── volume-130.nii
+
+For testing, you can have any number of files in Training Batch 1 and Training Batch 2. But make sure the naming
+convention is similar.
+
+To prepare LiTS dataset for training run
+
+```
+python data_preparation/preprocess_data.py
+```
+
+> Note: Because of the extensive preprocessing, it will take some time, so relax and wait.
+
+#### Final directory
+
+After completion, you will have a directories like this
+
+ ├── data/
+ │ ├── train/
+ ├── images
+ ├── image_28_0.png
+ ├── ...
+ ├── mask
+ ├── mask_28_0.png
+ ├── ...
+ │ ├── val/
+ ├── images
+ ├── image_0_0.png
+ ├── ...
+ ├── mask
+ ├── mask_0_0.png
+ ├── ...
+
+After processing the `train` folder size will be 5GB and `val` folder size will be 1.7GB.
+
+#### Free space (Optional)
+
+At this stage you can delete the intermediate scans files to free space, run below command
+
+```shell
+bash data_preparation/delete_extracted_scans_data.sh
+```
+
+You can also delete the data zip files using below command, but remember you cannot retrieve them back
+
+```shell
+bash data_preparation/delete_zip_data.sh
+```
+
+> Note: It is recommended to delete scan files but not zip data because you may need it again.
+
+## Train on custom data
+
+To train on custom dateset it's advised that you follow the same train and val directory structure like
+mentioned [above](#final-directory).
+
+In our case image file name can be mapped to it's corresponding mask file name by replacing `image` text with `mask`. If
+your data has different mapping then you need to update [image_to_mask_name](./../utils/images_utils.py#L63) function which
+is responsible for converting image name to it's corresponding file name.
+
+Each image should be a color image with 3 channels and `RGB` color format. Each mask is considered as a gray scale
+image, where each pixel value is the class on which each pixel belongs.
+
+Congratulations, now you can start training and testing on your new dataset!
\ No newline at end of file
diff --git a/TensorFlow2/Segmentation/UNet3P/data_preparation/delete_extracted_scans_data.sh b/TensorFlow2/Segmentation/UNet3P/data_preparation/delete_extracted_scans_data.sh
new file mode 100644
index 000000000..72683297b
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/data_preparation/delete_extracted_scans_data.sh
@@ -0,0 +1,2 @@
+rm -r 'data/Training Batch 1/'
+rm -r 'data/Training Batch 2/'
\ No newline at end of file
diff --git a/TensorFlow2/Segmentation/UNet3P/data_preparation/delete_zip_data.sh b/TensorFlow2/Segmentation/UNet3P/data_preparation/delete_zip_data.sh
new file mode 100644
index 000000000..14437b63f
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/data_preparation/delete_zip_data.sh
@@ -0,0 +1,2 @@
+rm data/Training_Batch1.zip
+rm data/Training_Batch2.zip
\ No newline at end of file
diff --git a/TensorFlow2/Segmentation/UNet3P/data_preparation/extract_data.sh b/TensorFlow2/Segmentation/UNet3P/data_preparation/extract_data.sh
new file mode 100644
index 000000000..b284a3e7f
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/data_preparation/extract_data.sh
@@ -0,0 +1,9 @@
+# extract testing data
+unzip data/Training_Batch1.zip -d data/
+mv "data/media/nas/01_Datasets/CT/LITS/Training Batch 1/" "data/Training Batch 1/"
+rm -r data/media
+
+# extract training data
+unzip data/Training_Batch2.zip -d data/
+mv "data/media/nas/01_Datasets/CT/LITS/Training Batch 2/" "data/Training Batch 2/"
+rm -r data/media
diff --git a/TensorFlow2/Segmentation/UNet3P/data_preparation/preprocess_data.py b/TensorFlow2/Segmentation/UNet3P/data_preparation/preprocess_data.py
new file mode 100644
index 000000000..9fb475015
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/data_preparation/preprocess_data.py
@@ -0,0 +1,242 @@
+"""
+Convert LiTS 2017 (Liver Tumor Segmentation) data into UNet3+ data format
+LiTS: https://competitions.codalab.org/competitions/17094
+"""
+import os
+import sys
+from glob import glob
+from pathlib import Path
+from tqdm import tqdm
+import numpy as np
+import multiprocessing as mp
+import cv2
+import nibabel as nib
+import hydra
+from omegaconf import DictConfig
+
+sys.path.append(os.path.abspath("./"))
+from utils.general_utils import create_directory, join_paths
+from utils.images_utils import resize_image
+
+
+def read_nii(filepath):
+ """
+ Reads .nii file and returns pixel array
+ """
+ ct_scan = nib.load(filepath).get_fdata()
+ # TODO: Verify images orientation
+ # in both train and test set, especially on train scan 130
+ ct_scan = np.rot90(np.array(ct_scan))
+ return ct_scan
+
+
+def crop_center(img, croph, cropw):
+ """
+ Center crop on given height and width
+ """
+ height, width = img.shape[:2]
+ starth = height // 2 - (croph // 2)
+ startw = width // 2 - (cropw // 2)
+ return img[starth:starth + croph, startw:startw + cropw, :]
+
+
+def linear_scale(img):
+ """
+ First convert image to range of 0-1 and them scale to 255
+ """
+ img = (img - img.min(axis=(0, 1))) / (img.max(axis=(0, 1)) - img.min(axis=(0, 1)))
+ return img * 255
+
+
+def clip_scan(img, min_value, max_value):
+ """
+ Clip scan to given range
+ """
+ return np.clip(img, min_value, max_value)
+
+
+def resize_scan(scan, new_height, new_width, scan_type):
+ """
+ Resize CT scan to given size
+ """
+ scan_shape = scan.shape
+ resized_scan = np.zeros((new_height, new_width, scan_shape[2]), dtype=scan.dtype)
+ resize_method = cv2.INTER_CUBIC if scan_type == "image" else cv2.INTER_NEAREST
+ for start in range(0, scan_shape[2], scan_shape[1]):
+ end = start + scan_shape[1]
+ if end >= scan_shape[2]: end = scan_shape[2]
+ resized_scan[:, :, start:end] = resize_image(
+ scan[:, :, start:end],
+ new_height, new_width,
+ resize_method
+ )
+
+ return resized_scan
+
+
+def save_images(scan, save_path, img_index):
+ """
+ Based on UNet3+ requirement "input image had three channels, including
+ the slice to be segmented and the upper and lower slices, which was
+ cropped to 320×320" save each scan as separate image with previous and
+ next scan concatenated.
+ """
+ scan_shape = scan.shape
+ for index in range(scan_shape[-1]):
+ before_index = index - 1 if (index - 1) > 0 else 0
+ after_index = index + 1 if (index + 1) < scan_shape[-1] else scan_shape[-1] - 1
+
+ new_img_path = join_paths(save_path, f"image_{img_index}_{index}.png")
+ new_image = np.stack(
+ (
+ scan[:, :, before_index],
+ scan[:, :, index],
+ scan[:, :, after_index]
+ )
+ , axis=-1)
+ new_image = cv2.cvtColor(new_image, cv2.COLOR_RGB2BGR) # RGB to BGR
+ cv2.imwrite(new_img_path, new_image) # save the images as .png
+
+
+def save_mask(scan, save_path, mask_index):
+ """
+ Save each scan as separate mask
+ """
+ for index in range(scan.shape[-1]):
+ new_mask_path = join_paths(save_path, f"mask_{mask_index}_{index}.png")
+ cv2.imwrite(new_mask_path, scan[:, :, index]) # save grey scale image
+
+
+def extract_image(cfg, image_path, save_path, scan_type="image", ):
+ """
+ Extract image from given scan path
+ """
+ _, index = str(Path(image_path).stem).split("-")
+
+ scan = read_nii(image_path)
+ scan = resize_scan(
+ scan,
+ cfg.DATA_PREPARATION.RESIZED_HEIGHT,
+ cfg.DATA_PREPARATION.RESIZED_WIDTH,
+ scan_type
+ )
+ if scan_type == "image":
+ scan = clip_scan(
+ scan,
+ cfg.DATA_PREPARATION.SCAN_MIN_VALUE,
+ cfg.DATA_PREPARATION.SCAN_MAX_VALUE
+ )
+ scan = linear_scale(scan)
+ scan = np.uint8(scan)
+ save_images(scan, save_path, index)
+ else:
+ # 0 for background/non-lesion, 1 for liver, 2 for lesion/tumor
+ # merging label 2 into label 1, because lesion/tumor is part of liver
+ scan = np.where(scan != 0, 1, scan)
+ # scan = np.where(scan==2, 1, scan)
+ scan = np.uint8(scan)
+ save_mask(scan, save_path, index)
+
+
+def extract_images(cfg, images_path, save_path, scan_type="image", ):
+ """
+ Extract images paths using multiprocessing and pass to
+ extract_image function for further processing .
+ """
+ # create pool
+ process_count = np.clip(mp.cpu_count() - 2, 1, 20) # less than 20 workers
+ pool = mp.Pool(process_count)
+ for image_path in tqdm(images_path):
+ pool.apply_async(extract_image,
+ args=(cfg, image_path, save_path, scan_type),
+ )
+
+ # close pool
+ pool.close()
+ pool.join()
+
+
+@hydra.main(version_base=None, config_path="../configs", config_name="config")
+def preprocess_lits_data(cfg: DictConfig):
+ """
+ Preprocess LiTS 2017 (Liver Tumor Segmentation) data by extractions
+ images and mask into UNet3+ data format
+ """
+ train_images_names = glob(
+ join_paths(
+ cfg.WORK_DIR,
+ cfg.DATA_PREPARATION.SCANS_TRAIN_DATA_PATH,
+ "volume-*.nii"
+ )
+ )
+ train_mask_names = glob(
+ join_paths(
+ cfg.WORK_DIR,
+ cfg.DATA_PREPARATION.SCANS_TRAIN_DATA_PATH,
+ "segmentation-*.nii"
+ )
+ )
+
+ assert len(train_images_names) == len(train_mask_names), \
+ "Train volumes and segmentations are not same in length"
+
+ val_images_names = glob(
+ join_paths(
+ cfg.WORK_DIR,
+ cfg.DATA_PREPARATION.SCANS_VAL_DATA_PATH,
+ "volume-*.nii"
+ )
+ )
+ val_mask_names = glob(
+ join_paths(
+ cfg.WORK_DIR,
+ cfg.DATA_PREPARATION.SCANS_VAL_DATA_PATH,
+ "segmentation-*.nii"
+ )
+ )
+ assert len(val_images_names) == len(val_mask_names), \
+ "Validation volumes and segmentations are not same in length"
+
+ train_images_names = sorted(train_images_names)
+ train_mask_names = sorted(train_mask_names)
+ val_images_names = sorted(val_images_names)
+ val_mask_names = sorted(val_mask_names)
+
+ train_images_path = join_paths(
+ cfg.WORK_DIR, cfg.DATASET.TRAIN.IMAGES_PATH
+ )
+ train_mask_path = join_paths(
+ cfg.WORK_DIR, cfg.DATASET.TRAIN.MASK_PATH
+ )
+ val_images_path = join_paths(
+ cfg.WORK_DIR, cfg.DATASET.VAL.IMAGES_PATH
+ )
+ val_mask_path = join_paths(
+ cfg.WORK_DIR, cfg.DATASET.VAL.MASK_PATH
+ )
+
+ create_directory(train_images_path)
+ create_directory(train_mask_path)
+ create_directory(val_images_path)
+ create_directory(val_mask_path)
+
+ print("\nExtracting train images")
+ extract_images(
+ cfg, train_images_names, train_images_path, scan_type="image"
+ )
+ print("\nExtracting train mask")
+ extract_images(
+ cfg, train_mask_names, train_mask_path, scan_type="mask"
+ )
+ print("\nExtracting val images")
+ extract_images(
+ cfg, val_images_names, val_images_path, scan_type="image"
+ )
+ print("\nExtracting val mask")
+ extract_images(
+ cfg, val_mask_names, val_mask_path, scan_type="mask"
+ )
+
+
+if __name__ == '__main__':
+ preprocess_lits_data()
diff --git a/TensorFlow2/Segmentation/UNet3P/data_preparation/verify_data.py b/TensorFlow2/Segmentation/UNet3P/data_preparation/verify_data.py
new file mode 100644
index 000000000..0eb0d77bf
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/data_preparation/verify_data.py
@@ -0,0 +1,56 @@
+"""
+Verify for each image corresponding mask exist or not.
+Check against both train and val data
+"""
+import os
+import sys
+from omegaconf import DictConfig
+from tqdm import tqdm
+
+sys.path.append(os.path.abspath("./"))
+from utils.general_utils import join_paths
+from utils.images_utils import image_to_mask_name
+
+
+def check_image_and_mask(cfg, mode):
+ """
+ Check and print names of those images whose mask are not found.
+ """
+ images_path = join_paths(
+ cfg.WORK_DIR,
+ cfg.DATASET[mode].IMAGES_PATH
+ )
+ mask_path = join_paths(
+ cfg.WORK_DIR,
+ cfg.DATASET[mode].MASK_PATH
+ )
+
+ all_images = os.listdir(images_path)
+
+ both_found = True
+ for image in tqdm(all_images):
+ mask_name = image_to_mask_name(image)
+ if not (
+ os.path.exists(
+ join_paths(images_path, image)
+ ) and
+ os.path.exists(
+ join_paths(mask_path, mask_name)
+ )
+ ):
+ print(f"{mask_name} did not found against {image}")
+ both_found = False
+
+ return both_found
+
+
+def verify_data(cfg: DictConfig):
+ """
+ For both train and val data, check for each image its
+ corresponding mask exist or not. If not then stop the program.
+ """
+ assert check_image_and_mask(cfg, "TRAIN"), \
+ "Train images and mask should be same in length"
+
+ assert check_image_and_mask(cfg, "VAL"), \
+ "Validation images and mask should be same in length"
diff --git a/TensorFlow2/Segmentation/UNet3P/evaluate.py b/TensorFlow2/Segmentation/UNet3P/evaluate.py
new file mode 100644
index 000000000..555381e6b
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/evaluate.py
@@ -0,0 +1,125 @@
+"""
+Evaluation script used to calculate accuracy of trained model
+"""
+import os
+import hydra
+from omegaconf import DictConfig
+import tensorflow as tf
+from tensorflow.keras import mixed_precision
+
+from data_generators import data_generator
+from utils.general_utils import join_paths, set_gpus, suppress_warnings
+from models.model import prepare_model
+from losses.loss import DiceCoefficient
+from losses.unet_loss import unet3p_hybrid_loss
+
+
+def evaluate(cfg: DictConfig):
+ """
+ Evaluate or calculate accuracy of given model
+ """
+
+ # suppress TensorFlow and DALI warnings
+ suppress_warnings()
+
+ if cfg.USE_MULTI_GPUS.VALUE:
+ # change number of visible gpus for evaluation
+ set_gpus(cfg.USE_MULTI_GPUS.GPU_IDS)
+ # update batch size according to available gpus
+ data_generator.update_batch_size(cfg)
+
+ if cfg.OPTIMIZATION.AMP:
+ print("Enabling Automatic Mixed Precision(AMP) training")
+ policy = mixed_precision.Policy('mixed_float16')
+ mixed_precision.set_global_policy(policy)
+
+ if cfg.OPTIMIZATION.XLA:
+ print("Enabling Automatic Mixed Precision(XLA) training")
+ tf.config.optimizer.set_jit(True)
+
+ # create model
+ strategy = None
+ if cfg.USE_MULTI_GPUS.VALUE:
+ # multi gpu training using tensorflow mirrored strategy
+ strategy = tf.distribute.MirroredStrategy(
+ cross_device_ops=tf.distribute.HierarchicalCopyAllReduce()
+ )
+ print('Number of visible gpu devices: {}'.format(strategy.num_replicas_in_sync))
+ with strategy.scope():
+ optimizer = tf.keras.optimizers.Adam(
+ learning_rate=cfg.HYPER_PARAMETERS.LEARNING_RATE
+ ) # optimizer
+ if cfg.OPTIMIZATION.AMP:
+ optimizer = mixed_precision.LossScaleOptimizer(
+ optimizer,
+ dynamic=True
+ )
+ dice_coef = DiceCoefficient(post_processed=True, classes=cfg.OUTPUT.CLASSES)
+ dice_coef = tf.keras.metrics.MeanMetricWrapper(name="dice_coef", fn=dice_coef)
+ model = prepare_model(cfg, training=True)
+ else:
+ optimizer = tf.keras.optimizers.Adam(
+ learning_rate=cfg.HYPER_PARAMETERS.LEARNING_RATE
+ ) # optimizer
+ if cfg.OPTIMIZATION.AMP:
+ optimizer = mixed_precision.LossScaleOptimizer(
+ optimizer,
+ dynamic=True
+ )
+ dice_coef = DiceCoefficient(post_processed=True, classes=cfg.OUTPUT.CLASSES)
+ dice_coef = tf.keras.metrics.MeanMetricWrapper(name="dice_coef", fn=dice_coef)
+ model = prepare_model(cfg, training=True)
+
+ model.compile(
+ optimizer=optimizer,
+ loss=unet3p_hybrid_loss,
+ metrics=[dice_coef],
+ )
+
+ # weights model path
+ checkpoint_path = join_paths(
+ cfg.WORK_DIR,
+ cfg.CALLBACKS.MODEL_CHECKPOINT.PATH,
+ f"{cfg.MODEL.WEIGHTS_FILE_NAME}.hdf5"
+ )
+
+ assert os.path.exists(checkpoint_path), \
+ f"Model weight's file does not exist at \n{checkpoint_path}"
+
+ # TODO: verify without augment it produces same results
+ # load model weights
+ model.load_weights(checkpoint_path, by_name=True, skip_mismatch=True)
+ model.summary()
+
+ # data generators
+ val_generator = data_generator.get_data_generator(cfg, "VAL", strategy)
+ validation_steps = data_generator.get_iterations(cfg, mode="VAL")
+
+ # evaluation metric
+ evaluation_metric = "dice_coef"
+ if len(model.outputs) > 1:
+ evaluation_metric = f"{model.output_names[0]}_dice_coef"
+
+ result = model.evaluate(
+ x=val_generator,
+ steps=validation_steps,
+ workers=cfg.DATALOADER_WORKERS,
+ return_dict=True,
+ )
+
+ # return computed loss, validation accuracy, and it's metric name
+ return result, evaluation_metric
+
+
+@hydra.main(version_base=None, config_path="configs", config_name="config")
+def main(cfg: DictConfig):
+ """
+ Read config file and pass to evaluate method
+ """
+ result, evaluation_metric = evaluate(cfg)
+ print(result)
+ print(f"Validation dice coefficient: {result[evaluation_metric]}")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/TensorFlow2/Segmentation/UNet3P/figures/unet3p_architecture.png b/TensorFlow2/Segmentation/UNet3P/figures/unet3p_architecture.png
new file mode 100644
index 0000000000000000000000000000000000000000..77a892f11262cb746f33ebbed6c68e9f5ff58741
GIT binary patch
literal 87012
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
literal 0
HcmV?d00001
diff --git a/TensorFlow2/Segmentation/UNet3P/losses/loss.py b/TensorFlow2/Segmentation/UNet3P/losses/loss.py
new file mode 100644
index 000000000..652c7434e
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/losses/loss.py
@@ -0,0 +1,114 @@
+"""
+Implementation of different loss functions
+"""
+import tensorflow as tf
+import tensorflow.keras.backend as K
+
+
+def iou(y_true, y_pred, smooth=1.e-9):
+ """
+ Calculate intersection over union (IoU) between images.
+ Input shape should be Batch x Height x Width x #Classes (BxHxWxN).
+ Using Mean as reduction type for batch values.
+ """
+ intersection = K.sum(K.abs(y_true * y_pred), axis=[1, 2, 3])
+ union = K.sum(y_true, [1, 2, 3]) + K.sum(y_pred, [1, 2, 3])
+ union = union - intersection
+ iou = K.mean((intersection + smooth) / (union + smooth), axis=0)
+ return iou
+
+
+def iou_loss(y_true, y_pred):
+ """
+ Jaccard / IoU loss
+ """
+ return 1 - iou(y_true, y_pred)
+
+
+def focal_loss(y_true, y_pred):
+ """
+ Focal loss
+ """
+ gamma = 2.
+ alpha = 4.
+ epsilon = 1.e-9
+
+ y_true_c = tf.convert_to_tensor(y_true, tf.float32)
+ y_pred_c = tf.convert_to_tensor(y_pred, tf.float32)
+
+ model_out = tf.add(y_pred_c, epsilon)
+ ce = tf.multiply(y_true_c, -tf.math.log(model_out))
+ weight = tf.multiply(y_true_c, tf.pow(
+ tf.subtract(1., model_out), gamma)
+ )
+ fl = tf.multiply(alpha, tf.multiply(weight, ce))
+ reduced_fl = tf.reduce_max(fl, axis=-1)
+ return tf.reduce_mean(reduced_fl)
+
+
+def ssim_loss(y_true, y_pred, smooth=1.e-9):
+ """
+ Structural Similarity Index loss.
+ Input shape should be Batch x Height x Width x #Classes (BxHxWxN).
+ Using Mean as reduction type for batch values.
+ """
+ ssim_value = tf.image.ssim(y_true, y_pred, max_val=1)
+ return K.mean(1 - ssim_value + smooth, axis=0)
+
+
+class DiceCoefficient(tf.keras.metrics.Metric):
+ """
+ Dice coefficient metric. Can be used to calculate dice on probabilities
+ or on their respective classes
+ """
+
+ def __init__(self, post_processed: bool,
+ classes: int,
+ name='dice_coef',
+ **kwargs):
+ """
+ Set post_processed=False if dice coefficient needs to be calculated
+ on probabilities. Set post_processed=True if probabilities needs to
+ be first converted/mapped into their respective class.
+ """
+ super(DiceCoefficient, self).__init__(name=name, **kwargs)
+ self.dice_value = self.add_weight(name='dice_value', initializer='zeros',
+ aggregation=tf.VariableAggregation.MEAN) # SUM
+ self.post_processed = post_processed
+ self.classes = classes
+ if self.classes == 1:
+ self.axis = [1, 2, 3]
+ else:
+ self.axis = [1, 2, ]
+
+ def update_state(self, y_true, y_pred, sample_weight=None):
+ if self.post_processed:
+ if self.classes == 1:
+ y_true_ = y_true
+ y_pred_ = tf.where(y_pred > .5, 1.0, 0.0)
+ else:
+ y_true_ = tf.math.argmax(y_true, axis=-1, output_type=tf.int32)
+ y_pred_ = tf.math.argmax(y_pred, axis=-1, output_type=tf.int32)
+ y_true_ = tf.cast(y_true_, dtype=tf.float32)
+ y_pred_ = tf.cast(y_pred_, dtype=tf.float32)
+ else:
+ y_true_, y_pred_ = y_true, y_pred
+
+ self.dice_value.assign(self.dice_coef(y_true_, y_pred_))
+
+ def result(self):
+ return self.dice_value
+
+ def reset_state(self):
+ self.dice_value.assign(0.0) # reset metric state
+
+ def dice_coef(self, y_true, y_pred, smooth=1.e-9):
+ """
+ Calculate dice coefficient.
+ Input shape could be either Batch x Height x Width x #Classes (BxHxWxN)
+ or Batch x Height x Width (BxHxW).
+ Using Mean as reduction type for batch values.
+ """
+ intersection = K.sum(y_true * y_pred, axis=self.axis)
+ union = K.sum(y_true, axis=self.axis) + K.sum(y_pred, axis=self.axis)
+ return K.mean((2. * intersection + smooth) / (union + smooth), axis=0)
diff --git a/TensorFlow2/Segmentation/UNet3P/losses/unet_loss.py b/TensorFlow2/Segmentation/UNet3P/losses/unet_loss.py
new file mode 100644
index 000000000..24f3c1063
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/losses/unet_loss.py
@@ -0,0 +1,19 @@
+"""
+UNet 3+ Loss
+"""
+from .loss import focal_loss, ssim_loss, iou_loss
+
+
+def unet3p_hybrid_loss(y_true, y_pred):
+ """
+ Hybrid loss proposed in
+ UNET 3+ (https://arxiv.org/ftp/arxiv/papers/2004/2004.08790.pdf)
+ Hybrid loss for segmentation in three-level hierarchy – pixel,
+ patch and map-level, which is able to capture both large-scale
+ and fine structures with clear boundaries.
+ """
+ f_loss = focal_loss(y_true, y_pred)
+ ms_ssim_loss = ssim_loss(y_true, y_pred)
+ jacard_loss = iou_loss(y_true, y_pred)
+
+ return f_loss + ms_ssim_loss + jacard_loss
diff --git a/TensorFlow2/Segmentation/UNet3P/models/backbones.py b/TensorFlow2/Segmentation/UNet3P/models/backbones.py
new file mode 100644
index 000000000..22fd65e84
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/models/backbones.py
@@ -0,0 +1,73 @@
+"""
+Unet3+ backbones
+"""
+import tensorflow as tf
+import tensorflow.keras as k
+from .unet3plus_utils import conv_block
+
+
+def vgg16_backbone(input_layer, ):
+ """ VGG-16 backbone as encoder for UNet3P """
+
+ base_model = tf.keras.applications.VGG16(
+ input_tensor=input_layer,
+ weights=None,
+ include_top=False
+ )
+
+ # block 1
+ e1 = base_model.get_layer("block1_conv2").output # 320, 320, 64
+ # block 2
+ e2 = base_model.get_layer("block2_conv2").output # 160, 160, 128
+ # block 3
+ e3 = base_model.get_layer("block3_conv3").output # 80, 80, 256
+ # block 4
+ e4 = base_model.get_layer("block4_conv3").output # 40, 40, 512
+ # block 5
+ e5 = base_model.get_layer("block5_conv3").output # 20, 20, 512
+
+ return [e1, e2, e3, e4, e5]
+
+
+def vgg19_backbone(input_layer, ):
+ """ VGG-19 backbone as encoder for UNet3P """
+
+ base_model = tf.keras.applications.VGG19(
+ input_tensor=input_layer,
+ weights=None,
+ include_top=False
+ )
+
+ # block 1
+ e1 = base_model.get_layer("block1_conv2").output # 320, 320, 64
+ # block 2
+ e2 = base_model.get_layer("block2_conv2").output # 160, 160, 128
+ # block 3
+ e3 = base_model.get_layer("block3_conv4").output # 80, 80, 256
+ # block 4
+ e4 = base_model.get_layer("block4_conv4").output # 40, 40, 512
+ # block 5
+ e5 = base_model.get_layer("block5_conv4").output # 20, 20, 512
+
+ return [e1, e2, e3, e4, e5]
+
+
+def unet3plus_backbone(input_layer, filters):
+ """ UNet3+ own backbone """
+ """ Encoder"""
+ # block 1
+ e1 = conv_block(input_layer, filters[0]) # 320*320*64
+ # block 2
+ e2 = k.layers.MaxPool2D(pool_size=(2, 2))(e1) # 160*160*64
+ e2 = conv_block(e2, filters[1]) # 160*160*128
+ # block 3
+ e3 = k.layers.MaxPool2D(pool_size=(2, 2))(e2) # 80*80*128
+ e3 = conv_block(e3, filters[2]) # 80*80*256
+ # block 4
+ e4 = k.layers.MaxPool2D(pool_size=(2, 2))(e3) # 40*40*256
+ e4 = conv_block(e4, filters[3]) # 40*40*512
+ # block 5, bottleneck layer
+ e5 = k.layers.MaxPool2D(pool_size=(2, 2))(e4) # 20*20*512
+ e5 = conv_block(e5, filters[4]) # 20*20*1024
+
+ return [e1, e2, e3, e4, e5]
diff --git a/TensorFlow2/Segmentation/UNet3P/models/model.py b/TensorFlow2/Segmentation/UNet3P/models/model.py
new file mode 100644
index 000000000..1b2e5a6bd
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/models/model.py
@@ -0,0 +1,100 @@
+"""
+Returns Unet3+ model
+"""
+import tensorflow as tf
+from omegaconf import DictConfig
+
+from .backbones import vgg16_backbone, vgg19_backbone, unet3plus_backbone
+from .unet3plus import unet3plus
+from .unet3plus_deep_supervision import unet3plus_deepsup
+from .unet3plus_deep_supervision_cgm import unet3plus_deepsup_cgm
+
+
+def prepare_model(cfg: DictConfig, training=False):
+ """
+ Creates and return model object based on given model type.
+ """
+
+ input_shape = [cfg.INPUT.HEIGHT, cfg.INPUT.WIDTH, cfg.INPUT.CHANNELS]
+ input_layer = tf.keras.layers.Input(
+ shape=input_shape,
+ name="input_layer"
+ ) # 320*320*3
+ filters = [64, 128, 256, 512, 1024]
+
+ # create backbone
+ if cfg.MODEL.BACKBONE.TYPE == "unet3plus":
+ backbone_layers = unet3plus_backbone(
+ input_layer,
+ filters
+ )
+ elif cfg.MODEL.BACKBONE.TYPE == "vgg16":
+ backbone_layers = vgg16_backbone(input_layer, )
+ elif cfg.MODEL.BACKBONE.TYPE == "vgg19":
+ backbone_layers = vgg19_backbone(input_layer, )
+ else:
+ raise ValueError(
+ "Wrong backbone type passed."
+ "\nPlease check config file for possible options."
+ )
+ print(f"Using {cfg.MODEL.BACKBONE.TYPE} as a backbone.")
+
+ if cfg.MODEL.TYPE == "unet3plus":
+ # training parameter does not matter in this case
+ outputs, model_name = unet3plus(
+ backbone_layers,
+ cfg.OUTPUT.CLASSES,
+ filters
+ )
+ elif cfg.MODEL.TYPE == "unet3plus_deepsup":
+ outputs, model_name = unet3plus_deepsup(
+ backbone_layers,
+ cfg.OUTPUT.CLASSES,
+ filters,
+ training
+ )
+ elif cfg.MODEL.TYPE == "unet3plus_deepsup_cgm":
+ if cfg.OUTPUT.CLASSES != 1:
+ raise ValueError(
+ "UNet3+ with Deep Supervision and Classification Guided Module"
+ "\nOnly works when model output classes are equal to 1"
+ )
+ outputs, model_name = unet3plus_deepsup_cgm(
+ backbone_layers,
+ cfg.OUTPUT.CLASSES,
+ filters,
+ training
+ )
+ else:
+ raise ValueError(
+ "Wrong model type passed."
+ "\nPlease check config file for possible options."
+ )
+
+ return tf.keras.Model(
+ inputs=input_layer,
+ outputs=outputs,
+ name=model_name
+ )
+
+
+if __name__ == "__main__":
+ """## Test model Compilation,"""
+ from omegaconf import OmegaConf
+
+ cfg = {
+ "WORK_DIR": "H:\\Projects\\UNet3P",
+ "INPUT": {"HEIGHT": 320, "WIDTH": 320, "CHANNELS": 3},
+ "OUTPUT": {"CLASSES": 1},
+ # available variants are unet3plus, unet3plus_deepsup, unet3plus_deepsup_cgm
+ "MODEL": {"TYPE": "unet3plus",
+ # available variants are unet3plus, vgg16, vgg19
+ "BACKBONE": {"TYPE": "vgg19", }
+ }
+ }
+ unet_3P = prepare_model(OmegaConf.create(cfg), True)
+ unet_3P.summary()
+
+ # tf.keras.utils.plot_model(unet_3P, show_layer_names=True, show_shapes=True)
+
+ # unet_3P.save("unet_3P.hdf5")
diff --git a/TensorFlow2/Segmentation/UNet3P/models/unet3plus.py b/TensorFlow2/Segmentation/UNet3P/models/unet3plus.py
new file mode 100644
index 000000000..a1036196e
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/models/unet3plus.py
@@ -0,0 +1,104 @@
+"""
+UNet3+ base model
+"""
+import tensorflow as tf
+import tensorflow.keras as k
+from .unet3plus_utils import conv_block
+
+
+def unet3plus(encoder_layer, output_channels, filters):
+ """ UNet3+ base model """
+
+ """ Encoder """
+ e1 = encoder_layer[0]
+ e2 = encoder_layer[1]
+ e3 = encoder_layer[2]
+ e4 = encoder_layer[3]
+ e5 = encoder_layer[4]
+
+ """ Decoder """
+ cat_channels = filters[0]
+ cat_blocks = len(filters)
+ upsample_channels = cat_blocks * cat_channels
+
+ """ d4 """
+ e1_d4 = k.layers.MaxPool2D(pool_size=(8, 8))(e1) # 320*320*64 --> 40*40*64
+ e1_d4 = conv_block(e1_d4, cat_channels, n=1) # 320*320*64 --> 40*40*64
+
+ e2_d4 = k.layers.MaxPool2D(pool_size=(4, 4))(e2) # 160*160*128 --> 40*40*128
+ e2_d4 = conv_block(e2_d4, cat_channels, n=1) # 160*160*128 --> 40*40*64
+
+ e3_d4 = k.layers.MaxPool2D(pool_size=(2, 2))(e3) # 80*80*256 --> 40*40*256
+ e3_d4 = conv_block(e3_d4, cat_channels, n=1) # 80*80*256 --> 40*40*64
+
+ e4_d4 = conv_block(e4, cat_channels, n=1) # 40*40*512 --> 40*40*64
+
+ e5_d4 = k.layers.UpSampling2D(size=(2, 2), interpolation='bilinear')(e5) # 80*80*256 --> 40*40*256
+ e5_d4 = conv_block(e5_d4, cat_channels, n=1) # 20*20*1024 --> 20*20*64
+
+ d4 = k.layers.concatenate([e1_d4, e2_d4, e3_d4, e4_d4, e5_d4])
+ d4 = conv_block(d4, upsample_channels, n=1) # 40*40*320 --> 40*40*320
+
+ """ d3 """
+ e1_d3 = k.layers.MaxPool2D(pool_size=(4, 4))(e1) # 320*320*64 --> 80*80*64
+ e1_d3 = conv_block(e1_d3, cat_channels, n=1) # 80*80*64 --> 80*80*64
+
+ e2_d3 = k.layers.MaxPool2D(pool_size=(2, 2))(e2) # 160*160*256 --> 80*80*256
+ e2_d3 = conv_block(e2_d3, cat_channels, n=1) # 80*80*256 --> 80*80*64
+
+ e3_d3 = conv_block(e3, cat_channels, n=1) # 80*80*512 --> 80*80*64
+
+ e4_d3 = k.layers.UpSampling2D(size=(2, 2), interpolation='bilinear')(d4) # 40*40*320 --> 80*80*320
+ e4_d3 = conv_block(e4_d3, cat_channels, n=1) # 80*80*320 --> 80*80*64
+
+ e5_d3 = k.layers.UpSampling2D(size=(4, 4), interpolation='bilinear')(e5) # 20*20*320 --> 80*80*320
+ e5_d3 = conv_block(e5_d3, cat_channels, n=1) # 80*80*320 --> 80*80*64
+
+ d3 = k.layers.concatenate([e1_d3, e2_d3, e3_d3, e4_d3, e5_d3])
+ d3 = conv_block(d3, upsample_channels, n=1) # 80*80*320 --> 80*80*320
+
+ """ d2 """
+ e1_d2 = k.layers.MaxPool2D(pool_size=(2, 2))(e1) # 320*320*64 --> 160*160*64
+ e1_d2 = conv_block(e1_d2, cat_channels, n=1) # 160*160*64 --> 160*160*64
+
+ e2_d2 = conv_block(e2, cat_channels, n=1) # 160*160*256 --> 160*160*64
+
+ d3_d2 = k.layers.UpSampling2D(size=(2, 2), interpolation='bilinear')(d3) # 80*80*320 --> 160*160*320
+ d3_d2 = conv_block(d3_d2, cat_channels, n=1) # 160*160*320 --> 160*160*64
+
+ d4_d2 = k.layers.UpSampling2D(size=(4, 4), interpolation='bilinear')(d4) # 40*40*320 --> 160*160*320
+ d4_d2 = conv_block(d4_d2, cat_channels, n=1) # 160*160*320 --> 160*160*64
+
+ e5_d2 = k.layers.UpSampling2D(size=(8, 8), interpolation='bilinear')(e5) # 20*20*320 --> 160*160*320
+ e5_d2 = conv_block(e5_d2, cat_channels, n=1) # 160*160*320 --> 160*160*64
+
+ d2 = k.layers.concatenate([e1_d2, e2_d2, d3_d2, d4_d2, e5_d2])
+ d2 = conv_block(d2, upsample_channels, n=1) # 160*160*320 --> 160*160*320
+
+ """ d1 """
+ e1_d1 = conv_block(e1, cat_channels, n=1) # 320*320*64 --> 320*320*64
+
+ d2_d1 = k.layers.UpSampling2D(size=(2, 2), interpolation='bilinear')(d2) # 160*160*320 --> 320*320*320
+ d2_d1 = conv_block(d2_d1, cat_channels, n=1) # 160*160*320 --> 160*160*64
+
+ d3_d1 = k.layers.UpSampling2D(size=(4, 4), interpolation='bilinear')(d3) # 80*80*320 --> 320*320*320
+ d3_d1 = conv_block(d3_d1, cat_channels, n=1) # 320*320*320 --> 320*320*64
+
+ d4_d1 = k.layers.UpSampling2D(size=(8, 8), interpolation='bilinear')(d4) # 40*40*320 --> 320*320*320
+ d4_d1 = conv_block(d4_d1, cat_channels, n=1) # 320*320*320 --> 320*320*64
+
+ e5_d1 = k.layers.UpSampling2D(size=(16, 16), interpolation='bilinear')(e5) # 20*20*320 --> 320*320*320
+ e5_d1 = conv_block(e5_d1, cat_channels, n=1) # 320*320*320 --> 320*320*64
+
+ d1 = k.layers.concatenate([e1_d1, d2_d1, d3_d1, d4_d1, e5_d1, ])
+ d1 = conv_block(d1, upsample_channels, n=1) # 320*320*320 --> 320*320*320
+
+ # last layer does not have batchnorm and relu
+ d = conv_block(d1, output_channels, n=1, is_bn=False, is_relu=False)
+
+ if output_channels == 1:
+ output = k.layers.Activation('sigmoid', dtype='float32')(d)
+ else:
+ output = k.layers.Activation('softmax', dtype='float32')(d)
+
+ return output, 'UNet_3Plus'
diff --git a/TensorFlow2/Segmentation/UNet3P/models/unet3plus_deep_supervision.py b/TensorFlow2/Segmentation/UNet3P/models/unet3plus_deep_supervision.py
new file mode 100644
index 000000000..0766ed820
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/models/unet3plus_deep_supervision.py
@@ -0,0 +1,132 @@
+"""
+UNet3+ with Deep Supervision
+"""
+import tensorflow as tf
+import tensorflow.keras as k
+from .unet3plus_utils import conv_block
+
+
+def unet3plus_deepsup(encoder_layer, output_channels, filters, training=False):
+ """ UNet_3Plus with Deep Supervision """
+
+ """ Encoder """
+ e1 = encoder_layer[0]
+ e2 = encoder_layer[1]
+ e3 = encoder_layer[2]
+ e4 = encoder_layer[3]
+ e5 = encoder_layer[4]
+
+ """ Decoder """
+ cat_channels = filters[0]
+ cat_blocks = len(filters)
+ upsample_channels = cat_blocks * cat_channels
+
+ """ d4 """
+ e1_d4 = k.layers.MaxPool2D(pool_size=(8, 8))(e1) # 320*320*64 --> 40*40*64
+ e1_d4 = conv_block(e1_d4, cat_channels, n=1) # 320*320*64 --> 40*40*64
+
+ e2_d4 = k.layers.MaxPool2D(pool_size=(4, 4))(e2) # 160*160*128 --> 40*40*128
+ e2_d4 = conv_block(e2_d4, cat_channels, n=1) # 160*160*128 --> 40*40*64
+
+ e3_d4 = k.layers.MaxPool2D(pool_size=(2, 2))(e3) # 80*80*256 --> 40*40*256
+ e3_d4 = conv_block(e3_d4, cat_channels, n=1) # 80*80*256 --> 40*40*64
+
+ e4_d4 = conv_block(e4, cat_channels, n=1) # 40*40*512 --> 40*40*64
+
+ e5_d4 = k.layers.UpSampling2D(size=(2, 2), interpolation='bilinear')(e5) # 80*80*256 --> 40*40*256
+ e5_d4 = conv_block(e5_d4, cat_channels, n=1) # 20*20*1024 --> 20*20*64
+
+ d4 = k.layers.concatenate([e1_d4, e2_d4, e3_d4, e4_d4, e5_d4])
+ d4 = conv_block(d4, upsample_channels, n=1) # 40*40*320 --> 40*40*320
+
+ """ d3 """
+ e1_d3 = k.layers.MaxPool2D(pool_size=(4, 4))(e1) # 320*320*64 --> 80*80*64
+ e1_d3 = conv_block(e1_d3, cat_channels, n=1) # 80*80*64 --> 80*80*64
+
+ e2_d3 = k.layers.MaxPool2D(pool_size=(2, 2))(e2) # 160*160*256 --> 80*80*256
+ e2_d3 = conv_block(e2_d3, cat_channels, n=1) # 80*80*256 --> 80*80*64
+
+ e3_d3 = conv_block(e3, cat_channels, n=1) # 80*80*512 --> 80*80*64
+
+ e4_d3 = k.layers.UpSampling2D(size=(2, 2), interpolation='bilinear')(d4) # 40*40*320 --> 80*80*320
+ e4_d3 = conv_block(e4_d3, cat_channels, n=1) # 80*80*320 --> 80*80*64
+
+ e5_d3 = k.layers.UpSampling2D(size=(4, 4), interpolation='bilinear')(e5) # 20*20*320 --> 80*80*320
+ e5_d3 = conv_block(e5_d3, cat_channels, n=1) # 80*80*320 --> 80*80*64
+
+ d3 = k.layers.concatenate([e1_d3, e2_d3, e3_d3, e4_d3, e5_d3])
+ d3 = conv_block(d3, upsample_channels, n=1) # 80*80*320 --> 80*80*320
+
+ """ d2 """
+ e1_d2 = k.layers.MaxPool2D(pool_size=(2, 2))(e1) # 320*320*64 --> 160*160*64
+ e1_d2 = conv_block(e1_d2, cat_channels, n=1) # 160*160*64 --> 160*160*64
+
+ e2_d2 = conv_block(e2, cat_channels, n=1) # 160*160*256 --> 160*160*64
+
+ d3_d2 = k.layers.UpSampling2D(size=(2, 2), interpolation='bilinear')(d3) # 80*80*320 --> 160*160*320
+ d3_d2 = conv_block(d3_d2, cat_channels, n=1) # 160*160*320 --> 160*160*64
+
+ d4_d2 = k.layers.UpSampling2D(size=(4, 4), interpolation='bilinear')(d4) # 40*40*320 --> 160*160*320
+ d4_d2 = conv_block(d4_d2, cat_channels, n=1) # 160*160*320 --> 160*160*64
+
+ e5_d2 = k.layers.UpSampling2D(size=(8, 8), interpolation='bilinear')(e5) # 20*20*320 --> 160*160*320
+ e5_d2 = conv_block(e5_d2, cat_channels, n=1) # 160*160*320 --> 160*160*64
+
+ d2 = k.layers.concatenate([e1_d2, e2_d2, d3_d2, d4_d2, e5_d2])
+ d2 = conv_block(d2, upsample_channels, n=1) # 160*160*320 --> 160*160*320
+
+ """ d1 """
+ e1_d1 = conv_block(e1, cat_channels, n=1) # 320*320*64 --> 320*320*64
+
+ d2_d1 = k.layers.UpSampling2D(size=(2, 2), interpolation='bilinear')(d2) # 160*160*320 --> 320*320*320
+ d2_d1 = conv_block(d2_d1, cat_channels, n=1) # 160*160*320 --> 160*160*64
+
+ d3_d1 = k.layers.UpSampling2D(size=(4, 4), interpolation='bilinear')(d3) # 80*80*320 --> 320*320*320
+ d3_d1 = conv_block(d3_d1, cat_channels, n=1) # 320*320*320 --> 320*320*64
+
+ d4_d1 = k.layers.UpSampling2D(size=(8, 8), interpolation='bilinear')(d4) # 40*40*320 --> 320*320*320
+ d4_d1 = conv_block(d4_d1, cat_channels, n=1) # 320*320*320 --> 320*320*64
+
+ e5_d1 = k.layers.UpSampling2D(size=(16, 16), interpolation='bilinear')(e5) # 20*20*320 --> 320*320*320
+ e5_d1 = conv_block(e5_d1, cat_channels, n=1) # 320*320*320 --> 320*320*64
+
+ d1 = k.layers.concatenate([e1_d1, d2_d1, d3_d1, d4_d1, e5_d1, ])
+ d1 = conv_block(d1, upsample_channels, n=1) # 320*320*320 --> 320*320*320
+
+ # last layer does not have batch norm and relu
+ d1 = conv_block(d1, output_channels, n=1, is_bn=False, is_relu=False)
+
+ if output_channels == 1:
+ d1 = k.layers.Activation('sigmoid', dtype='float32')(d1)
+ else:
+ # d1 = k.activations.softmax(d1)
+ d1 = k.layers.Activation('softmax', dtype='float32')(d1)
+
+ """ Deep Supervision Part"""
+ if training:
+ d2 = conv_block(d2, output_channels, n=1, is_bn=False, is_relu=False)
+ d3 = conv_block(d3, output_channels, n=1, is_bn=False, is_relu=False)
+ d4 = conv_block(d4, output_channels, n=1, is_bn=False, is_relu=False)
+ e5 = conv_block(e5, output_channels, n=1, is_bn=False, is_relu=False)
+
+ # d1 = no need for up sampling
+ d2 = k.layers.UpSampling2D(size=(2, 2), interpolation='bilinear')(d2)
+ d3 = k.layers.UpSampling2D(size=(4, 4), interpolation='bilinear')(d3)
+ d4 = k.layers.UpSampling2D(size=(8, 8), interpolation='bilinear')(d4)
+ e5 = k.layers.UpSampling2D(size=(16, 16), interpolation='bilinear')(e5)
+
+ if output_channels == 1:
+ d2 = k.layers.Activation('sigmoid', dtype='float32')(d2)
+ d3 = k.layers.Activation('sigmoid', dtype='float32')(d3)
+ d4 = k.layers.Activation('sigmoid', dtype='float32')(d4)
+ e5 = k.layers.Activation('sigmoid', dtype='float32')(e5)
+ else:
+ d2 = k.layers.Activation('softmax', dtype='float32')(d2)
+ d3 = k.layers.Activation('softmax', dtype='float32')(d3)
+ d4 = k.layers.Activation('softmax', dtype='float32')(d4)
+ e5 = k.layers.Activation('softmax', dtype='float32')(e5)
+
+ if training:
+ return [d1, d2, d3, d4, e5], 'UNet3Plus_DeepSup'
+ else:
+ return [d1, ], 'UNet3Plus_DeepSup'
diff --git a/TensorFlow2/Segmentation/UNet3P/models/unet3plus_deep_supervision_cgm.py b/TensorFlow2/Segmentation/UNet3P/models/unet3plus_deep_supervision_cgm.py
new file mode 100644
index 000000000..110dd81d8
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/models/unet3plus_deep_supervision_cgm.py
@@ -0,0 +1,138 @@
+"""
+UNet_3Plus with Deep Supervision and Classification Guided Module
+"""
+import tensorflow as tf
+import tensorflow.keras as k
+from .unet3plus_utils import conv_block, dot_product
+
+
+def unet3plus_deepsup_cgm(encoder_layer, output_channels, filters, training=False):
+ """ UNet_3Plus with Deep Supervision and Classification Guided Module """
+
+ """ Encoder """
+ e1 = encoder_layer[0]
+ e2 = encoder_layer[1]
+ e3 = encoder_layer[2]
+ e4 = encoder_layer[3]
+ e5 = encoder_layer[4]
+
+ """ Classification Guided Module. Part 1"""
+ cls = k.layers.Dropout(rate=0.5)(e5)
+ cls = k.layers.Conv2D(2, kernel_size=(1, 1), padding="same", strides=(1, 1))(cls)
+ cls = k.layers.GlobalMaxPooling2D()(cls)
+ cls = k.layers.Activation('sigmoid', dtype='float32')(cls)
+ cls = tf.argmax(cls, axis=-1)
+ cls = cls[..., tf.newaxis]
+ cls = tf.cast(cls, dtype=tf.float32, )
+
+ """ Decoder """
+ cat_channels = filters[0]
+ cat_blocks = len(filters)
+ upsample_channels = cat_blocks * cat_channels
+
+ """ d4 """
+ e1_d4 = k.layers.MaxPool2D(pool_size=(8, 8))(e1) # 320*320*64 --> 40*40*64
+ e1_d4 = conv_block(e1_d4, cat_channels, n=1) # 320*320*64 --> 40*40*64
+
+ e2_d4 = k.layers.MaxPool2D(pool_size=(4, 4))(e2) # 160*160*128 --> 40*40*128
+ e2_d4 = conv_block(e2_d4, cat_channels, n=1) # 160*160*128 --> 40*40*64
+
+ e3_d4 = k.layers.MaxPool2D(pool_size=(2, 2))(e3) # 80*80*256 --> 40*40*256
+ e3_d4 = conv_block(e3_d4, cat_channels, n=1) # 80*80*256 --> 40*40*64
+
+ e4_d4 = conv_block(e4, cat_channels, n=1) # 40*40*512 --> 40*40*64
+
+ e5_d4 = k.layers.UpSampling2D(size=(2, 2), interpolation='bilinear')(e5) # 80*80*256 --> 40*40*256
+ e5_d4 = conv_block(e5_d4, cat_channels, n=1) # 20*20*1024 --> 20*20*64
+
+ d4 = k.layers.concatenate([e1_d4, e2_d4, e3_d4, e4_d4, e5_d4])
+ d4 = conv_block(d4, upsample_channels, n=1) # 40*40*320 --> 40*40*320
+
+ """ d3 """
+ e1_d3 = k.layers.MaxPool2D(pool_size=(4, 4))(e1) # 320*320*64 --> 80*80*64
+ e1_d3 = conv_block(e1_d3, cat_channels, n=1) # 80*80*64 --> 80*80*64
+
+ e2_d3 = k.layers.MaxPool2D(pool_size=(2, 2))(e2) # 160*160*256 --> 80*80*256
+ e2_d3 = conv_block(e2_d3, cat_channels, n=1) # 80*80*256 --> 80*80*64
+
+ e3_d3 = conv_block(e3, cat_channels, n=1) # 80*80*512 --> 80*80*64
+
+ e4_d3 = k.layers.UpSampling2D(size=(2, 2), interpolation='bilinear')(d4) # 40*40*320 --> 80*80*320
+ e4_d3 = conv_block(e4_d3, cat_channels, n=1) # 80*80*320 --> 80*80*64
+
+ e5_d3 = k.layers.UpSampling2D(size=(4, 4), interpolation='bilinear')(e5) # 20*20*320 --> 80*80*320
+ e5_d3 = conv_block(e5_d3, cat_channels, n=1) # 80*80*320 --> 80*80*64
+
+ d3 = k.layers.concatenate([e1_d3, e2_d3, e3_d3, e4_d3, e5_d3])
+ d3 = conv_block(d3, upsample_channels, n=1) # 80*80*320 --> 80*80*320
+
+ """ d2 """
+ e1_d2 = k.layers.MaxPool2D(pool_size=(2, 2))(e1) # 320*320*64 --> 160*160*64
+ e1_d2 = conv_block(e1_d2, cat_channels, n=1) # 160*160*64 --> 160*160*64
+
+ e2_d2 = conv_block(e2, cat_channels, n=1) # 160*160*256 --> 160*160*64
+
+ d3_d2 = k.layers.UpSampling2D(size=(2, 2), interpolation='bilinear')(d3) # 80*80*320 --> 160*160*320
+ d3_d2 = conv_block(d3_d2, cat_channels, n=1) # 160*160*320 --> 160*160*64
+
+ d4_d2 = k.layers.UpSampling2D(size=(4, 4), interpolation='bilinear')(d4) # 40*40*320 --> 160*160*320
+ d4_d2 = conv_block(d4_d2, cat_channels, n=1) # 160*160*320 --> 160*160*64
+
+ e5_d2 = k.layers.UpSampling2D(size=(8, 8), interpolation='bilinear')(e5) # 20*20*320 --> 160*160*320
+ e5_d2 = conv_block(e5_d2, cat_channels, n=1) # 160*160*320 --> 160*160*64
+
+ d2 = k.layers.concatenate([e1_d2, e2_d2, d3_d2, d4_d2, e5_d2])
+ d2 = conv_block(d2, upsample_channels, n=1) # 160*160*320 --> 160*160*320
+
+ """ d1 """
+ e1_d1 = conv_block(e1, cat_channels, n=1) # 320*320*64 --> 320*320*64
+
+ d2_d1 = k.layers.UpSampling2D(size=(2, 2), interpolation='bilinear')(d2) # 160*160*320 --> 320*320*320
+ d2_d1 = conv_block(d2_d1, cat_channels, n=1) # 160*160*320 --> 160*160*64
+
+ d3_d1 = k.layers.UpSampling2D(size=(4, 4), interpolation='bilinear')(d3) # 80*80*320 --> 320*320*320
+ d3_d1 = conv_block(d3_d1, cat_channels, n=1) # 320*320*320 --> 320*320*64
+
+ d4_d1 = k.layers.UpSampling2D(size=(8, 8), interpolation='bilinear')(d4) # 40*40*320 --> 320*320*320
+ d4_d1 = conv_block(d4_d1, cat_channels, n=1) # 320*320*320 --> 320*320*64
+
+ e5_d1 = k.layers.UpSampling2D(size=(16, 16), interpolation='bilinear')(e5) # 20*20*320 --> 320*320*320
+ e5_d1 = conv_block(e5_d1, cat_channels, n=1) # 320*320*320 --> 320*320*64
+
+ d1 = k.layers.concatenate([e1_d1, d2_d1, d3_d1, d4_d1, e5_d1, ])
+ d1 = conv_block(d1, upsample_channels, n=1) # 320*320*320 --> 320*320*320
+
+ """ Deep Supervision Part"""
+ # last layer does not have batch norm and relu
+ d1 = conv_block(d1, output_channels, n=1, is_bn=False, is_relu=False)
+ if training:
+ d2 = conv_block(d2, output_channels, n=1, is_bn=False, is_relu=False)
+ d3 = conv_block(d3, output_channels, n=1, is_bn=False, is_relu=False)
+ d4 = conv_block(d4, output_channels, n=1, is_bn=False, is_relu=False)
+ e5 = conv_block(e5, output_channels, n=1, is_bn=False, is_relu=False)
+
+ # d1 = no need for up sampling
+ d2 = k.layers.UpSampling2D(size=(2, 2), interpolation='bilinear')(d2)
+ d3 = k.layers.UpSampling2D(size=(4, 4), interpolation='bilinear')(d3)
+ d4 = k.layers.UpSampling2D(size=(8, 8), interpolation='bilinear')(d4)
+ e5 = k.layers.UpSampling2D(size=(16, 16), interpolation='bilinear')(e5)
+
+ """ Classification Guided Module. Part 2"""
+ d1 = dot_product(d1, cls)
+ d1 = k.layers.Activation('sigmoid', dtype='float32')(d1)
+
+ if training:
+ d2 = dot_product(d2, cls)
+ d3 = dot_product(d3, cls)
+ d4 = dot_product(d4, cls)
+ e5 = dot_product(e5, cls)
+
+ d2 = k.layers.Activation('sigmoid', dtype='float32')(d2)
+ d3 = k.layers.Activation('sigmoid', dtype='float32')(d3)
+ d4 = k.layers.Activation('sigmoid', dtype='float32')(d4)
+ e5 = k.layers.Activation('sigmoid', dtype='float32')(e5)
+
+ if training:
+ return [d1, d2, d3, d4, e5, cls], 'UNet3Plus_DeepSup_CGM'
+ else:
+ return [d1, ], 'UNet3Plus_DeepSup_CGM'
diff --git a/TensorFlow2/Segmentation/UNet3P/models/unet3plus_utils.py b/TensorFlow2/Segmentation/UNet3P/models/unet3plus_utils.py
new file mode 100644
index 000000000..e002a3c89
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/models/unet3plus_utils.py
@@ -0,0 +1,31 @@
+"""
+Utility functions for Unet3+ models
+"""
+import tensorflow as tf
+import tensorflow.keras as k
+
+
+def conv_block(x, kernels, kernel_size=(3, 3), strides=(1, 1), padding='same',
+ is_bn=True, is_relu=True, n=2):
+ """ Custom function for conv2d:
+ Apply 3*3 convolutions with BN and relu.
+ """
+ for i in range(1, n + 1):
+ x = k.layers.Conv2D(filters=kernels, kernel_size=kernel_size,
+ padding=padding, strides=strides,
+ kernel_regularizer=tf.keras.regularizers.l2(1e-4),
+ kernel_initializer=k.initializers.he_normal(seed=5))(x)
+ if is_bn:
+ x = k.layers.BatchNormalization()(x)
+ if is_relu:
+ x = k.activations.relu(x)
+
+ return x
+
+
+def dot_product(seg, cls):
+ b, h, w, n = k.backend.int_shape(seg)
+ seg = tf.reshape(seg, [-1, h * w, n])
+ final = tf.einsum("ijk,ik->ijk", seg, cls)
+ final = tf.reshape(final, [-1, h, w, n])
+ return final
diff --git a/TensorFlow2/Segmentation/UNet3P/predict.ipynb b/TensorFlow2/Segmentation/UNet3P/predict.ipynb
new file mode 100644
index 000000000..599ff0f89
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/predict.ipynb
@@ -0,0 +1,247 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "570c0575",
+ "metadata": {},
+ "source": [
+ "# Visualization Script"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "fc14ebac",
+ "metadata": {
+ "collapsed": false,
+ "jupyter": {
+ "outputs_hidden": false
+ }
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "2023-02-20 07:22:21.247783: I tensorflow/core/platform/cpu_feature_guard.cc:194] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations: SSE3 SSE4.1 SSE4.2 AVX\n",
+ "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Imports\n",
+ "%load_ext autoreload\n",
+ "%autoreload 2\n",
+ "%matplotlib inline\n",
+ "\n",
+ "import hydra\n",
+ "from hydra import initialize, compose\n",
+ "from hydra.core.hydra_config import HydraConfig\n",
+ "\n",
+ "from predict import predict"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2115b6b7",
+ "metadata": {},
+ "source": [
+ "## Read Config File"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "065dc666-417f-4cd9-b70c-52d8907696b8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# clear previous hydra instances\n",
+ "hydra.core.global_hydra.GlobalHydra.instance().clear()\n",
+ "\n",
+ "# configs/config.yaml\n",
+ "initialize(version_base=None, config_path=\"configs\")\n",
+ "cfg = compose(config_name=\"config\", return_hydra_config=True)\n",
+ "HydraConfig().cfg = cfg"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3f51818e",
+ "metadata": {},
+ "source": [
+ "For visualization two options are available\n",
+ "1: Visualize from directory\n",
+ "2: Visualize from list\n",
+ "In both cases mask is optional\n",
+ "You can also override these settings through command line and call predict.py"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ce64141b",
+ "metadata": {},
+ "source": [
+ "## 1: Visualize from directory\n",
+ "In case of visualization from directory, it's going to make prediction and show all images from given directory.\n",
+ "Override the validation data paths and make sure the directory paths are relative to the project base/root path"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "210cdc87",
+ "metadata": {
+ "collapsed": false,
+ "jupyter": {
+ "outputs_hidden": false
+ }
+ },
+ "outputs": [],
+ "source": [
+ "# e.g. to visualize validation data\n",
+ "# images_paths = \"/data/val/images\"\n",
+ "# mask_paths = \"/data/val/mask\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5f846db6",
+ "metadata": {},
+ "source": [
+ "## 2: Visualize from list\n",
+ "In case of visualization from list, each list element should contain absolute path of image/mask."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "b88515e2-620e-4269-9e4c-4b1ddb9b48df",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# e.g. to visualize two images with their corresponding mask\n",
+ "images_paths = [\n",
+ " \"/workspace/unet3p/data/val/images/image_0_48.png\",\n",
+ " \"/workspace/unet3p/data/val/images/image_0_21.png\",\n",
+ "]\n",
+ "mask_paths = [\n",
+ " \"/workspace/unet3p/data/val/mask/mask_0_48.png\",\n",
+ " \"/workspace/unet3p/data/val/mask/mask_0_21.png\",\n",
+ "]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "ad2e8191-c1d1-4994-bef8-cc8a36062150",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# override given settings\n",
+ "cfg.DATASET.VAL.IMAGES_PATH = images_paths\n",
+ "cfg.DATASET.VAL.MASK_PATH = mask_paths"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "6a77869e",
+ "metadata": {
+ "collapsed": false,
+ "jupyter": {
+ "outputs_hidden": false
+ }
+ },
+ "outputs": [],
+ "source": [
+ "# In both cases if mask is not available just set the mask path to None\n",
+ "# cfg.DATASET.VAL.MASK_PATH = None"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "28e38f6d-6eee-4c7c-b209-f700598723fa",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# For custom data visualization set SHOW_CENTER_CHANNEL_IMAGE=False. This should set True for only UNet3+ LiTS data.\n",
+ "cfg.SHOW_CENTER_CHANNEL_IMAGE=True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "ffb762af-e67b-41e5-92ff-0983a1396762",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Using vgg19 as a backbone.\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 1200x400 with 3 Axes>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 1200x400 with 3 Axes>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# make predictions\n",
+ "predict(cfg)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "52b7abaa",
+ "metadata": {
+ "collapsed": false,
+ "jupyter": {
+ "outputs_hidden": false
+ }
+ },
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.10"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/TensorFlow2/Segmentation/UNet3P/predict.py b/TensorFlow2/Segmentation/UNet3P/predict.py
new file mode 100644
index 000000000..e838feded
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/predict.py
@@ -0,0 +1,101 @@
+"""
+Prediction script used to visualize model output
+"""
+import os
+import hydra
+from omegaconf import DictConfig
+
+from data_generators import tf_data_generator
+from utils.general_utils import join_paths, suppress_warnings
+from utils.images_utils import display
+from utils.images_utils import postprocess_mask, denormalize_mask
+from models.model import prepare_model
+
+
+def predict(cfg: DictConfig):
+ """
+ Predict and visualize given data
+ """
+
+ # suppress TensorFlow and DALI warnings
+ suppress_warnings()
+
+ # set batch size to one
+ cfg.HYPER_PARAMETERS.BATCH_SIZE = 1
+
+ # data generator
+ val_generator = tf_data_generator.DataGenerator(cfg, mode="VAL")
+
+ # create model
+ model = prepare_model(cfg)
+
+ # weights model path
+ checkpoint_path = join_paths(
+ cfg.WORK_DIR,
+ cfg.CALLBACKS.MODEL_CHECKPOINT.PATH,
+ f"{cfg.MODEL.WEIGHTS_FILE_NAME}.hdf5"
+ )
+
+ assert os.path.exists(checkpoint_path), \
+ f"Model weight's file does not exist at \n{checkpoint_path}"
+
+ # load model weights
+ model.load_weights(checkpoint_path, by_name=True, skip_mismatch=True)
+ # model.summary()
+
+ # check mask are available or not
+ mask_available = True
+ if cfg.DATASET.VAL.MASK_PATH is None or \
+ str(cfg.DATASET.VAL.MASK_PATH).lower() == "none":
+ mask_available = False
+
+ showed_images = 0
+ for batch_data in val_generator: # for each batch
+ batch_images = batch_data[0]
+ if mask_available:
+ batch_mask = batch_data[1]
+
+ # make prediction on batch
+ batch_predictions = model.predict_on_batch(batch_images)
+ if len(model.outputs) > 1:
+ batch_predictions = batch_predictions[0]
+
+ for index in range(len(batch_images)):
+
+ image = batch_images[index] # for each image
+ if cfg.SHOW_CENTER_CHANNEL_IMAGE:
+ # for UNet3+ show only center channel as image
+ image = image[:, :, 1]
+
+ # do postprocessing on predicted mask
+ prediction = batch_predictions[index]
+ prediction = postprocess_mask(prediction, cfg.OUTPUT.CLASSES)
+ # denormalize mask for better visualization
+ prediction = denormalize_mask(prediction, cfg.OUTPUT.CLASSES)
+
+ if mask_available:
+ mask = batch_mask[index]
+ mask = postprocess_mask(mask, cfg.OUTPUT.CLASSES)
+ mask = denormalize_mask(mask, cfg.OUTPUT.CLASSES)
+
+ # if np.unique(mask).shape[0] == 2:
+ if mask_available:
+ display([image, mask, prediction], show_true_mask=True)
+ else:
+ display([image, prediction], show_true_mask=False)
+
+ showed_images += 1
+ # stop after displaying below number of images
+ # if showed_images >= 10: break
+
+
+@hydra.main(version_base=None, config_path="configs", config_name="config")
+def main(cfg: DictConfig):
+ """
+ Read config file and pass to prediction method
+ """
+ predict(cfg)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/TensorFlow2/Segmentation/UNet3P/requirements.txt b/TensorFlow2/Segmentation/UNet3P/requirements.txt
new file mode 100644
index 000000000..bdb49797f
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/requirements.txt
@@ -0,0 +1,7 @@
+hydra-core
+opencv-python
+jupyter
+matplotlib
+tqdm
+nibabel
+numba
\ No newline at end of file
diff --git a/TensorFlow2/Segmentation/UNet3P/train.py b/TensorFlow2/Segmentation/UNet3P/train.py
new file mode 100644
index 000000000..a6e27f7da
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/train.py
@@ -0,0 +1,215 @@
+"""
+Training script
+"""
+import numpy as np
+from datetime import datetime, timedelta
+import hydra
+from omegaconf import DictConfig
+import tensorflow as tf
+from tensorflow.keras import mixed_precision
+from tensorflow.keras.callbacks import (
+ EarlyStopping,
+ ModelCheckpoint,
+ TensorBoard,
+ CSVLogger
+)
+
+from data_generators import data_generator
+from data_preparation.verify_data import verify_data
+from utils.general_utils import create_directory, join_paths, set_gpus, \
+ suppress_warnings
+from models.model import prepare_model
+from losses.loss import DiceCoefficient
+from losses.unet_loss import unet3p_hybrid_loss
+from callbacks.timing_callback import TimingCallback
+
+
+def create_training_folders(cfg: DictConfig):
+ """
+ Create directories to store Model CheckPoint and TensorBoard logs.
+ """
+ create_directory(
+ join_paths(
+ cfg.WORK_DIR,
+ cfg.CALLBACKS.MODEL_CHECKPOINT.PATH
+ )
+ )
+ create_directory(
+ join_paths(
+ cfg.WORK_DIR,
+ cfg.CALLBACKS.TENSORBOARD.PATH
+ )
+ )
+
+
+def train(cfg: DictConfig):
+ """
+ Training method
+ """
+
+ # suppress TensorFlow and DALI warnings
+ suppress_warnings()
+
+ print("Verifying data ...")
+ verify_data(cfg)
+
+ if cfg.MODEL.TYPE == "unet3plus_deepsup_cgm":
+ raise ValueError(
+ "UNet3+ with Deep Supervision and Classification Guided Module"
+ "\nModel exist but training script is not supported for this variant"
+ "please choose other variants from config file"
+ )
+
+ if cfg.USE_MULTI_GPUS.VALUE:
+ # change number of visible gpus for training
+ set_gpus(cfg.USE_MULTI_GPUS.GPU_IDS)
+ # update batch size according to available gpus
+ data_generator.update_batch_size(cfg)
+
+ # create folders to store training checkpoints and logs
+ create_training_folders(cfg)
+
+ if cfg.OPTIMIZATION.AMP:
+ print("Enabling Automatic Mixed Precision(AMP) training")
+ policy = mixed_precision.Policy('mixed_float16')
+ mixed_precision.set_global_policy(policy)
+
+ if cfg.OPTIMIZATION.XLA:
+ print("Enabling Accelerated Linear Algebra(XLA) training")
+ tf.config.optimizer.set_jit(True)
+
+ # create model
+ strategy = None
+ if cfg.USE_MULTI_GPUS.VALUE:
+ # multi gpu training using tensorflow mirrored strategy
+ strategy = tf.distribute.MirroredStrategy(
+ cross_device_ops=tf.distribute.HierarchicalCopyAllReduce()
+ )
+ print('Number of visible gpu devices: {}'.format(strategy.num_replicas_in_sync))
+ with strategy.scope():
+ optimizer = tf.keras.optimizers.Adam(
+ learning_rate=cfg.HYPER_PARAMETERS.LEARNING_RATE
+ ) # optimizer
+ if cfg.OPTIMIZATION.AMP:
+ optimizer = mixed_precision.LossScaleOptimizer(
+ optimizer,
+ dynamic=True
+ )
+ dice_coef = DiceCoefficient(post_processed=True, classes=cfg.OUTPUT.CLASSES)
+ dice_coef = tf.keras.metrics.MeanMetricWrapper(name="dice_coef", fn=dice_coef)
+ model = prepare_model(cfg, training=True)
+ else:
+ optimizer = tf.keras.optimizers.Adam(
+ learning_rate=cfg.HYPER_PARAMETERS.LEARNING_RATE
+ ) # optimizer
+ if cfg.OPTIMIZATION.AMP:
+ optimizer = mixed_precision.LossScaleOptimizer(
+ optimizer,
+ dynamic=True
+ )
+ dice_coef = DiceCoefficient(post_processed=True, classes=cfg.OUTPUT.CLASSES)
+ dice_coef = tf.keras.metrics.MeanMetricWrapper(name="dice_coef", fn=dice_coef)
+ model = prepare_model(cfg, training=True)
+
+ model.compile(
+ optimizer=optimizer,
+ loss=unet3p_hybrid_loss,
+ metrics=[dice_coef],
+ )
+ model.summary()
+
+ # data generators
+ train_generator = data_generator.get_data_generator(cfg, "TRAIN", strategy)
+ val_generator = data_generator.get_data_generator(cfg, "VAL", strategy)
+
+ # verify generator
+ # for i, (batch_images, batch_mask) in enumerate(val_generator):
+ # print(len(batch_images))
+ # if i >= 3: break
+
+ # the tensorboard log directory will be a unique subdirectory
+ # based on the start time for the run
+ tb_log_dir = join_paths(
+ cfg.WORK_DIR,
+ cfg.CALLBACKS.TENSORBOARD.PATH,
+ "{}".format(datetime.now().strftime("%Y.%m.%d.%H.%M.%S"))
+ )
+ print("TensorBoard directory\n" + tb_log_dir)
+
+ checkpoint_path = join_paths(
+ cfg.WORK_DIR,
+ cfg.CALLBACKS.MODEL_CHECKPOINT.PATH,
+ f"{cfg.MODEL.WEIGHTS_FILE_NAME}.hdf5"
+ )
+ print("Weights path\n" + checkpoint_path)
+
+ csv_log_path = join_paths(
+ cfg.WORK_DIR,
+ cfg.CALLBACKS.CSV_LOGGER.PATH,
+ f"training_logs_{cfg.MODEL.TYPE}.csv"
+ )
+ print("Logs path\n" + csv_log_path)
+
+ # evaluation metric
+ evaluation_metric = "val_dice_coef"
+ if len(model.outputs) > 1:
+ evaluation_metric = f"val_{model.output_names[0]}_dice_coef"
+
+ # Timing, TensorBoard, EarlyStopping, ModelCheckpoint, CSVLogger callbacks
+ timing_callback = TimingCallback()
+ callbacks = [
+ TensorBoard(log_dir=tb_log_dir, write_graph=False, profile_batch=0),
+ EarlyStopping(
+ patience=cfg.CALLBACKS.EARLY_STOPPING.PATIENCE,
+ verbose=cfg.VERBOSE
+ ),
+ ModelCheckpoint(
+ checkpoint_path,
+ verbose=cfg.VERBOSE,
+ save_weights_only=cfg.CALLBACKS.MODEL_CHECKPOINT.SAVE_WEIGHTS_ONLY,
+ save_best_only=cfg.CALLBACKS.MODEL_CHECKPOINT.SAVE_BEST_ONLY,
+ monitor=evaluation_metric,
+ mode="max"
+
+ ),
+ CSVLogger(
+ csv_log_path,
+ append=cfg.CALLBACKS.CSV_LOGGER.APPEND_LOGS
+ ),
+ timing_callback
+ ]
+
+ training_steps = data_generator.get_iterations(cfg, mode="TRAIN")
+ validation_steps = data_generator.get_iterations(cfg, mode="VAL")
+
+ # start training
+ model.fit(
+ x=train_generator,
+ steps_per_epoch=training_steps,
+ validation_data=val_generator,
+ validation_steps=validation_steps,
+ epochs=cfg.HYPER_PARAMETERS.EPOCHS,
+ callbacks=callbacks,
+ workers=cfg.DATALOADER_WORKERS,
+ )
+
+ training_time = timing_callback.train_end_time - timing_callback.train_start_time
+ training_time = timedelta(seconds=training_time)
+ print(f"Total training time {training_time}")
+
+ mean_time = np.mean(timing_callback.batch_time)
+ throughput = data_generator.get_batch_size(cfg) / mean_time
+ print(f"Training latency: {round(mean_time * 1e3, 2)} msec")
+ print(f"Training throughput/FPS: {round(throughput, 2)} samples/sec")
+
+
+@hydra.main(version_base=None, config_path="configs", config_name="config")
+def main(cfg: DictConfig):
+ """
+ Read config file and pass to train method for training
+ """
+ train(cfg)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/TensorFlow2/Segmentation/UNet3P/utils/general_utils.py b/TensorFlow2/Segmentation/UNet3P/utils/general_utils.py
new file mode 100644
index 000000000..9eea67b8d
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/utils/general_utils.py
@@ -0,0 +1,123 @@
+"""
+General Utility functions
+"""
+import os
+import tensorflow as tf
+from omegaconf import DictConfig
+from .images_utils import image_to_mask_name
+
+
+def create_directory(path):
+ """
+ Create Directory if it already does not exist.
+ """
+ if not os.path.exists(path):
+ os.makedirs(path)
+
+
+def join_paths(*paths):
+ """
+ Concatenate multiple paths.
+ """
+ return os.path.normpath(os.path.sep.join(path.rstrip(r"\/") for path in paths))
+
+
+def set_gpus(gpu_ids):
+ """
+ Change number of visible gpus for tensorflow.
+ gpu_ids: Could be integer or list of integers.
+ In case Integer: if integer value is -1 then use all available gpus.
+ otherwise if positive number, then use given number of gpus.
+ In case list of Integer: each integer will be considered as gpu id
+ """
+ all_gpus = tf.config.experimental.list_physical_devices('GPU')
+ all_gpus_length = len(all_gpus)
+ if isinstance(gpu_ids, int):
+ if gpu_ids == -1:
+ gpu_ids = range(all_gpus_length)
+ else:
+ gpu_ids = min(gpu_ids, all_gpus_length)
+ gpu_ids = range(gpu_ids)
+
+ selected_gpus = [all_gpus[gpu_id] for gpu_id in gpu_ids if gpu_id < all_gpus_length]
+
+ try:
+ tf.config.experimental.set_visible_devices(selected_gpus, 'GPU')
+ except RuntimeError as e:
+ # Visible devices must be set at program startup
+ print(e)
+
+
+def get_gpus_count():
+ """
+ Return length of available gpus.
+ """
+ return len(tf.config.experimental.list_logical_devices('GPU'))
+
+
+def get_data_paths(cfg: DictConfig, mode: str, mask_available: bool):
+ """
+ Return list of absolute images/mask paths.
+ There are two options you can either pass directory path or list.
+ In case of directory, it should contain relative path of images/mask
+ folder from project root path.
+ In case of list of images, every element should contain absolute path
+ for each image and mask.
+ For prediction, you can set mask path to None if mask are not
+ available for visualization.
+ """
+
+ # read images from directory
+ if isinstance(cfg.DATASET[mode].IMAGES_PATH, str):
+ # has only images name not full path
+ images_paths = os.listdir(
+ join_paths(
+ cfg.WORK_DIR,
+ cfg.DATASET[mode].IMAGES_PATH
+ )
+ )
+
+ if mask_available:
+ mask_paths = [
+ image_to_mask_name(image_name) for image_name in images_paths
+ ]
+ # create full mask paths from folder
+ mask_paths = [
+ join_paths(
+ cfg.WORK_DIR,
+ cfg.DATASET[mode].MASK_PATH,
+ mask_name
+ ) for mask_name in mask_paths
+ ]
+
+ # create full images paths from folder
+ images_paths = [
+ join_paths(
+ cfg.WORK_DIR,
+ cfg.DATASET[mode].IMAGES_PATH,
+ image_name
+ ) for image_name in images_paths
+ ]
+ else:
+ # read images and mask from absolute paths given in list
+ images_paths = list(cfg.DATASET[mode].IMAGES_PATH)
+ if mask_available:
+ mask_paths = list(cfg.DATASET[mode].MASK_PATH)
+
+ if mask_available:
+ return images_paths, mask_paths
+ else:
+ return images_paths,
+
+
+def suppress_warnings():
+ """
+ Suppress TensorFlow warnings.
+ """
+ import logging
+ logging.getLogger('tensorflow').setLevel(logging.ERROR)
+ logging.getLogger('dali').setLevel(logging.ERROR)
+ os.environ["KMP_AFFINITY"] = "noverbose"
+ os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
+ import tensorflow as tf
+ tf.autograph.set_verbosity(3)
diff --git a/TensorFlow2/Segmentation/UNet3P/utils/images_utils.py b/TensorFlow2/Segmentation/UNet3P/utils/images_utils.py
new file mode 100644
index 000000000..d97e482af
--- /dev/null
+++ b/TensorFlow2/Segmentation/UNet3P/utils/images_utils.py
@@ -0,0 +1,118 @@
+"""
+Utility functions for image processing
+"""
+import numpy as np
+import cv2
+from omegaconf import DictConfig
+import matplotlib.pyplot as plt
+
+
+def read_image(img_path, color_mode):
+ """
+ Read and return image as np array from given path.
+ In case of color image, it returns image in BGR mode.
+ """
+ return cv2.imread(img_path, color_mode)
+
+
+def resize_image(img, height, width, resize_method=cv2.INTER_CUBIC):
+ """
+ Resize image
+ """
+ return cv2.resize(img, dsize=(width, height), interpolation=resize_method)
+
+
+def prepare_image(path: str, resize: DictConfig, normalize_type: str):
+ """
+ Prepare image for model.
+ read image --> resize --> normalize --> return as float32
+ """
+ image = read_image(path, cv2.IMREAD_COLOR)
+ image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+
+ if resize.VALUE:
+ # TODO verify image resizing method
+ image = resize_image(image, resize.HEIGHT, resize.WIDTH, cv2.INTER_AREA)
+
+ if normalize_type == "normalize":
+ image = image / 255.0
+
+ image = image.astype(np.float32)
+
+ return image
+
+
+def prepare_mask(path: str, resize: dict, normalize_mask: dict):
+ """
+ Prepare mask for model.
+ read mask --> resize --> normalize --> return as int32
+ """
+ mask = read_image(path, cv2.IMREAD_GRAYSCALE)
+
+ if resize.VALUE:
+ mask = resize_image(mask, resize.HEIGHT, resize.WIDTH, cv2.INTER_NEAREST)
+
+ if normalize_mask.VALUE:
+ mask = mask / normalize_mask.NORMALIZE_VALUE
+
+ mask = mask.astype(np.int32)
+
+ return mask
+
+
+def image_to_mask_name(image_name: str):
+ """
+ Convert image file name to it's corresponding mask file name e.g.
+ image name --> mask name
+ image_28_0.png mask_28_0.png
+ replace image with mask
+ """
+
+ return image_name.replace('image', 'mask')
+
+
+def postprocess_mask(mask, classes, output_type=np.int32):
+ """
+ Post process model output.
+ Covert probabilities into indexes based on maximum value.
+ """
+ if classes == 1:
+ mask = np.where(mask > .5, 1.0, 0.0)
+ else:
+ mask = np.argmax(mask, axis=-1)
+ return mask.astype(output_type)
+
+
+def denormalize_mask(mask, classes):
+ """
+ Denormalize mask by multiplying each class with higher
+ integer (255 / classes) for better visualization.
+ """
+ mask = mask * (255 / classes)
+ return mask.astype(np.int32)
+
+
+def display(display_list, show_true_mask=False):
+ """
+ Show list of images. it could be
+ either [image, true_mask, predicted_mask] or [image, predicted_mask].
+ Set show_true_mask to True if true mask is available or vice versa
+ """
+ if show_true_mask:
+ title_list = ('Input Image', 'True Mask', 'Predicted Mask')
+ plt.figure(figsize=(12, 4))
+ else:
+ title_list = ('Input Image', 'Predicted Mask')
+ plt.figure(figsize=(8, 4))
+
+ for i in range(len(display_list)):
+ plt.subplot(1, len(display_list), i + 1)
+ if title_list is not None:
+ plt.title(title_list[i])
+ if len(np.squeeze(display_list[i]).shape) == 2:
+ plt.imshow(np.squeeze(display_list[i]), cmap='gray')
+ plt.axis('on')
+ else:
+ plt.imshow(np.squeeze(display_list[i]))
+ plt.axis('on')
+ plt.show()
From 4feeb18a950f03bb8d6d2ff3148d354812814d67 Mon Sep 17 00:00:00 2001
From: Hamid <hamidriasat@gmail.com>
Date: Wed, 19 Apr 2023 02:52:53 +0500
Subject: [PATCH 2/3] Updating License and README file
---
.../{ => Contrib}/UNet3P/.gitignore | 0
.../{ => Contrib}/UNet3P/Dockerfile | 0
.../Segmentation/Contrib/UNet3P/LICENSE | 201 ++++++++++++++++++
.../{ => Contrib}/UNet3P/README.md | 9 +-
.../UNet3P/benchmark_inference.py | 0
.../UNet3P/callbacks/timing_callback.py | 0
.../UNet3P/checkpoint/tb_logs/.gitkeep | 0
.../{ => Contrib}/UNet3P/configs/README.md | 0
.../{ => Contrib}/UNet3P/configs/config.yaml | 0
.../UNet3P/data/Training Batch 1/.gitkeep | 0
.../UNet3P/data/Training Batch 2/.gitkeep | 0
.../{ => Contrib}/UNet3P/data/train/.gitkeep | 0
.../{ => Contrib}/UNet3P/data/val/.gitkeep | 0
.../UNet3P/data_generators/README.md | 0
.../data_generators/dali_data_generator.py | 0
.../UNet3P/data_generators/data_generator.py | 0
.../data_generators/tf_data_generator.py | 0
.../UNet3P/data_preparation/README.md | 0
.../delete_extracted_scans_data.sh | 0
.../data_preparation/delete_zip_data.sh | 0
.../UNet3P/data_preparation/extract_data.sh | 0
.../data_preparation/preprocess_data.py | 0
.../UNet3P/data_preparation/verify_data.py | 0
.../{ => Contrib}/UNet3P/evaluate.py | 0
.../UNet3P/figures/unet3p_architecture.png | Bin
.../{ => Contrib}/UNet3P/losses/loss.py | 0
.../{ => Contrib}/UNet3P/losses/unet_loss.py | 0
.../{ => Contrib}/UNet3P/models/backbones.py | 0
.../{ => Contrib}/UNet3P/models/model.py | 0
.../{ => Contrib}/UNet3P/models/unet3plus.py | 0
.../models/unet3plus_deep_supervision.py | 0
.../models/unet3plus_deep_supervision_cgm.py | 0
.../UNet3P/models/unet3plus_utils.py | 0
.../{ => Contrib}/UNet3P/predict.ipynb | 0
.../{ => Contrib}/UNet3P/predict.py | 0
.../{ => Contrib}/UNet3P/requirements.txt | 0
.../{ => Contrib}/UNet3P/train.py | 0
.../UNet3P/utils/general_utils.py | 0
.../UNet3P/utils/images_utils.py | 0
TensorFlow2/Segmentation/UNet3P/LICENSE | 21 --
40 files changed, 206 insertions(+), 25 deletions(-)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/.gitignore (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/Dockerfile (100%)
create mode 100644 TensorFlow2/Segmentation/Contrib/UNet3P/LICENSE
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/README.md (98%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/benchmark_inference.py (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/callbacks/timing_callback.py (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/checkpoint/tb_logs/.gitkeep (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/configs/README.md (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/configs/config.yaml (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/data/Training Batch 1/.gitkeep (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/data/Training Batch 2/.gitkeep (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/data/train/.gitkeep (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/data/val/.gitkeep (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/data_generators/README.md (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/data_generators/dali_data_generator.py (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/data_generators/data_generator.py (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/data_generators/tf_data_generator.py (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/data_preparation/README.md (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/data_preparation/delete_extracted_scans_data.sh (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/data_preparation/delete_zip_data.sh (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/data_preparation/extract_data.sh (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/data_preparation/preprocess_data.py (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/data_preparation/verify_data.py (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/evaluate.py (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/figures/unet3p_architecture.png (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/losses/loss.py (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/losses/unet_loss.py (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/models/backbones.py (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/models/model.py (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/models/unet3plus.py (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/models/unet3plus_deep_supervision.py (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/models/unet3plus_deep_supervision_cgm.py (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/models/unet3plus_utils.py (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/predict.ipynb (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/predict.py (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/requirements.txt (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/train.py (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/utils/general_utils.py (100%)
rename TensorFlow2/Segmentation/{ => Contrib}/UNet3P/utils/images_utils.py (100%)
delete mode 100644 TensorFlow2/Segmentation/UNet3P/LICENSE
diff --git a/TensorFlow2/Segmentation/UNet3P/.gitignore b/TensorFlow2/Segmentation/Contrib/UNet3P/.gitignore
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/.gitignore
rename to TensorFlow2/Segmentation/Contrib/UNet3P/.gitignore
diff --git a/TensorFlow2/Segmentation/UNet3P/Dockerfile b/TensorFlow2/Segmentation/Contrib/UNet3P/Dockerfile
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/Dockerfile
rename to TensorFlow2/Segmentation/Contrib/UNet3P/Dockerfile
diff --git a/TensorFlow2/Segmentation/Contrib/UNet3P/LICENSE b/TensorFlow2/Segmentation/Contrib/UNet3P/LICENSE
new file mode 100644
index 000000000..a1deb94c2
--- /dev/null
+++ b/TensorFlow2/Segmentation/Contrib/UNet3P/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 2023 Hamid Ali
+
+ 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.
\ No newline at end of file
diff --git a/TensorFlow2/Segmentation/UNet3P/README.md b/TensorFlow2/Segmentation/Contrib/UNet3P/README.md
similarity index 98%
rename from TensorFlow2/Segmentation/UNet3P/README.md
rename to TensorFlow2/Segmentation/Contrib/UNet3P/README.md
index 988770ca3..183f816bb 100644
--- a/TensorFlow2/Segmentation/UNet3P/README.md
+++ b/TensorFlow2/Segmentation/Contrib/UNet3P/README.md
@@ -4,7 +4,7 @@
This repository provides a script and recipe to train UNet3+ to achieve state of the art accuracy.
-[//]: # (, and is tested and maintained by NVIDIA.)
+**The code and associated performance metrics were contributed by the community and are not maintained by NVIDIA.**
## Table of Contents
@@ -202,8 +202,7 @@ DATA_GENERATOR_TYPE=DALI_GENERATOR \
OPTIMIZATION.AMP=True OPTIMIZATION.XLA=True
```
-To evaluate/calculate dice accuracy of model pass same parameters to `evaluate.py` file. See [Config](#config) for
-complete hyper parameter details.
+To evaluate/calculate dice accuracy of model pass same parameters to `evaluate.py` file.
Please check [Config](configs/config.yaml) file for more details about default training parameters.
@@ -234,6 +233,8 @@ You can adjust these settings with `+warmup_steps` and `+bench_steps` parameters
The following section provide details of results that are achieved in different settings of model training and
inference.
+**These results were contributed by the community and are not maintained by NVIDIA.**
+
#### Training accuracy results
###### Training accuracy: NVIDIA DGX A100 (8xA100 80G)
@@ -315,4 +316,4 @@ Feb 2023
We appreciate any feedback so reporting problems, and asking questions are welcomed here.
-Licensed under [MIT License](LICENSE)
+Licensed under [Apache-2.0 License](LICENSE)
diff --git a/TensorFlow2/Segmentation/UNet3P/benchmark_inference.py b/TensorFlow2/Segmentation/Contrib/UNet3P/benchmark_inference.py
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/benchmark_inference.py
rename to TensorFlow2/Segmentation/Contrib/UNet3P/benchmark_inference.py
diff --git a/TensorFlow2/Segmentation/UNet3P/callbacks/timing_callback.py b/TensorFlow2/Segmentation/Contrib/UNet3P/callbacks/timing_callback.py
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/callbacks/timing_callback.py
rename to TensorFlow2/Segmentation/Contrib/UNet3P/callbacks/timing_callback.py
diff --git a/TensorFlow2/Segmentation/UNet3P/checkpoint/tb_logs/.gitkeep b/TensorFlow2/Segmentation/Contrib/UNet3P/checkpoint/tb_logs/.gitkeep
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/checkpoint/tb_logs/.gitkeep
rename to TensorFlow2/Segmentation/Contrib/UNet3P/checkpoint/tb_logs/.gitkeep
diff --git a/TensorFlow2/Segmentation/UNet3P/configs/README.md b/TensorFlow2/Segmentation/Contrib/UNet3P/configs/README.md
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/configs/README.md
rename to TensorFlow2/Segmentation/Contrib/UNet3P/configs/README.md
diff --git a/TensorFlow2/Segmentation/UNet3P/configs/config.yaml b/TensorFlow2/Segmentation/Contrib/UNet3P/configs/config.yaml
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/configs/config.yaml
rename to TensorFlow2/Segmentation/Contrib/UNet3P/configs/config.yaml
diff --git a/TensorFlow2/Segmentation/UNet3P/data/Training Batch 1/.gitkeep b/TensorFlow2/Segmentation/Contrib/UNet3P/data/Training Batch 1/.gitkeep
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/data/Training Batch 1/.gitkeep
rename to TensorFlow2/Segmentation/Contrib/UNet3P/data/Training Batch 1/.gitkeep
diff --git a/TensorFlow2/Segmentation/UNet3P/data/Training Batch 2/.gitkeep b/TensorFlow2/Segmentation/Contrib/UNet3P/data/Training Batch 2/.gitkeep
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/data/Training Batch 2/.gitkeep
rename to TensorFlow2/Segmentation/Contrib/UNet3P/data/Training Batch 2/.gitkeep
diff --git a/TensorFlow2/Segmentation/UNet3P/data/train/.gitkeep b/TensorFlow2/Segmentation/Contrib/UNet3P/data/train/.gitkeep
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/data/train/.gitkeep
rename to TensorFlow2/Segmentation/Contrib/UNet3P/data/train/.gitkeep
diff --git a/TensorFlow2/Segmentation/UNet3P/data/val/.gitkeep b/TensorFlow2/Segmentation/Contrib/UNet3P/data/val/.gitkeep
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/data/val/.gitkeep
rename to TensorFlow2/Segmentation/Contrib/UNet3P/data/val/.gitkeep
diff --git a/TensorFlow2/Segmentation/UNet3P/data_generators/README.md b/TensorFlow2/Segmentation/Contrib/UNet3P/data_generators/README.md
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/data_generators/README.md
rename to TensorFlow2/Segmentation/Contrib/UNet3P/data_generators/README.md
diff --git a/TensorFlow2/Segmentation/UNet3P/data_generators/dali_data_generator.py b/TensorFlow2/Segmentation/Contrib/UNet3P/data_generators/dali_data_generator.py
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/data_generators/dali_data_generator.py
rename to TensorFlow2/Segmentation/Contrib/UNet3P/data_generators/dali_data_generator.py
diff --git a/TensorFlow2/Segmentation/UNet3P/data_generators/data_generator.py b/TensorFlow2/Segmentation/Contrib/UNet3P/data_generators/data_generator.py
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/data_generators/data_generator.py
rename to TensorFlow2/Segmentation/Contrib/UNet3P/data_generators/data_generator.py
diff --git a/TensorFlow2/Segmentation/UNet3P/data_generators/tf_data_generator.py b/TensorFlow2/Segmentation/Contrib/UNet3P/data_generators/tf_data_generator.py
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/data_generators/tf_data_generator.py
rename to TensorFlow2/Segmentation/Contrib/UNet3P/data_generators/tf_data_generator.py
diff --git a/TensorFlow2/Segmentation/UNet3P/data_preparation/README.md b/TensorFlow2/Segmentation/Contrib/UNet3P/data_preparation/README.md
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/data_preparation/README.md
rename to TensorFlow2/Segmentation/Contrib/UNet3P/data_preparation/README.md
diff --git a/TensorFlow2/Segmentation/UNet3P/data_preparation/delete_extracted_scans_data.sh b/TensorFlow2/Segmentation/Contrib/UNet3P/data_preparation/delete_extracted_scans_data.sh
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/data_preparation/delete_extracted_scans_data.sh
rename to TensorFlow2/Segmentation/Contrib/UNet3P/data_preparation/delete_extracted_scans_data.sh
diff --git a/TensorFlow2/Segmentation/UNet3P/data_preparation/delete_zip_data.sh b/TensorFlow2/Segmentation/Contrib/UNet3P/data_preparation/delete_zip_data.sh
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/data_preparation/delete_zip_data.sh
rename to TensorFlow2/Segmentation/Contrib/UNet3P/data_preparation/delete_zip_data.sh
diff --git a/TensorFlow2/Segmentation/UNet3P/data_preparation/extract_data.sh b/TensorFlow2/Segmentation/Contrib/UNet3P/data_preparation/extract_data.sh
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/data_preparation/extract_data.sh
rename to TensorFlow2/Segmentation/Contrib/UNet3P/data_preparation/extract_data.sh
diff --git a/TensorFlow2/Segmentation/UNet3P/data_preparation/preprocess_data.py b/TensorFlow2/Segmentation/Contrib/UNet3P/data_preparation/preprocess_data.py
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/data_preparation/preprocess_data.py
rename to TensorFlow2/Segmentation/Contrib/UNet3P/data_preparation/preprocess_data.py
diff --git a/TensorFlow2/Segmentation/UNet3P/data_preparation/verify_data.py b/TensorFlow2/Segmentation/Contrib/UNet3P/data_preparation/verify_data.py
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/data_preparation/verify_data.py
rename to TensorFlow2/Segmentation/Contrib/UNet3P/data_preparation/verify_data.py
diff --git a/TensorFlow2/Segmentation/UNet3P/evaluate.py b/TensorFlow2/Segmentation/Contrib/UNet3P/evaluate.py
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/evaluate.py
rename to TensorFlow2/Segmentation/Contrib/UNet3P/evaluate.py
diff --git a/TensorFlow2/Segmentation/UNet3P/figures/unet3p_architecture.png b/TensorFlow2/Segmentation/Contrib/UNet3P/figures/unet3p_architecture.png
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/figures/unet3p_architecture.png
rename to TensorFlow2/Segmentation/Contrib/UNet3P/figures/unet3p_architecture.png
diff --git a/TensorFlow2/Segmentation/UNet3P/losses/loss.py b/TensorFlow2/Segmentation/Contrib/UNet3P/losses/loss.py
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/losses/loss.py
rename to TensorFlow2/Segmentation/Contrib/UNet3P/losses/loss.py
diff --git a/TensorFlow2/Segmentation/UNet3P/losses/unet_loss.py b/TensorFlow2/Segmentation/Contrib/UNet3P/losses/unet_loss.py
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/losses/unet_loss.py
rename to TensorFlow2/Segmentation/Contrib/UNet3P/losses/unet_loss.py
diff --git a/TensorFlow2/Segmentation/UNet3P/models/backbones.py b/TensorFlow2/Segmentation/Contrib/UNet3P/models/backbones.py
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/models/backbones.py
rename to TensorFlow2/Segmentation/Contrib/UNet3P/models/backbones.py
diff --git a/TensorFlow2/Segmentation/UNet3P/models/model.py b/TensorFlow2/Segmentation/Contrib/UNet3P/models/model.py
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/models/model.py
rename to TensorFlow2/Segmentation/Contrib/UNet3P/models/model.py
diff --git a/TensorFlow2/Segmentation/UNet3P/models/unet3plus.py b/TensorFlow2/Segmentation/Contrib/UNet3P/models/unet3plus.py
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/models/unet3plus.py
rename to TensorFlow2/Segmentation/Contrib/UNet3P/models/unet3plus.py
diff --git a/TensorFlow2/Segmentation/UNet3P/models/unet3plus_deep_supervision.py b/TensorFlow2/Segmentation/Contrib/UNet3P/models/unet3plus_deep_supervision.py
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/models/unet3plus_deep_supervision.py
rename to TensorFlow2/Segmentation/Contrib/UNet3P/models/unet3plus_deep_supervision.py
diff --git a/TensorFlow2/Segmentation/UNet3P/models/unet3plus_deep_supervision_cgm.py b/TensorFlow2/Segmentation/Contrib/UNet3P/models/unet3plus_deep_supervision_cgm.py
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/models/unet3plus_deep_supervision_cgm.py
rename to TensorFlow2/Segmentation/Contrib/UNet3P/models/unet3plus_deep_supervision_cgm.py
diff --git a/TensorFlow2/Segmentation/UNet3P/models/unet3plus_utils.py b/TensorFlow2/Segmentation/Contrib/UNet3P/models/unet3plus_utils.py
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/models/unet3plus_utils.py
rename to TensorFlow2/Segmentation/Contrib/UNet3P/models/unet3plus_utils.py
diff --git a/TensorFlow2/Segmentation/UNet3P/predict.ipynb b/TensorFlow2/Segmentation/Contrib/UNet3P/predict.ipynb
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/predict.ipynb
rename to TensorFlow2/Segmentation/Contrib/UNet3P/predict.ipynb
diff --git a/TensorFlow2/Segmentation/UNet3P/predict.py b/TensorFlow2/Segmentation/Contrib/UNet3P/predict.py
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/predict.py
rename to TensorFlow2/Segmentation/Contrib/UNet3P/predict.py
diff --git a/TensorFlow2/Segmentation/UNet3P/requirements.txt b/TensorFlow2/Segmentation/Contrib/UNet3P/requirements.txt
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/requirements.txt
rename to TensorFlow2/Segmentation/Contrib/UNet3P/requirements.txt
diff --git a/TensorFlow2/Segmentation/UNet3P/train.py b/TensorFlow2/Segmentation/Contrib/UNet3P/train.py
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/train.py
rename to TensorFlow2/Segmentation/Contrib/UNet3P/train.py
diff --git a/TensorFlow2/Segmentation/UNet3P/utils/general_utils.py b/TensorFlow2/Segmentation/Contrib/UNet3P/utils/general_utils.py
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/utils/general_utils.py
rename to TensorFlow2/Segmentation/Contrib/UNet3P/utils/general_utils.py
diff --git a/TensorFlow2/Segmentation/UNet3P/utils/images_utils.py b/TensorFlow2/Segmentation/Contrib/UNet3P/utils/images_utils.py
similarity index 100%
rename from TensorFlow2/Segmentation/UNet3P/utils/images_utils.py
rename to TensorFlow2/Segmentation/Contrib/UNet3P/utils/images_utils.py
diff --git a/TensorFlow2/Segmentation/UNet3P/LICENSE b/TensorFlow2/Segmentation/UNet3P/LICENSE
deleted file mode 100644
index 45f5ea544..000000000
--- a/TensorFlow2/Segmentation/UNet3P/LICENSE
+++ /dev/null
@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022 Hamid Ali
-
-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.
From 6a751a8025db200d60e552e7705396332c3f1944 Mon Sep 17 00:00:00 2001
From: Hamid <hamidriasat@gmail.com>
Date: Thu, 11 May 2023 21:46:14 +0500
Subject: [PATCH 3/3] Updating clone path
---
TensorFlow2/Segmentation/Contrib/UNet3P/README.md | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/TensorFlow2/Segmentation/Contrib/UNet3P/README.md b/TensorFlow2/Segmentation/Contrib/UNet3P/README.md
index 183f816bb..095918f38 100644
--- a/TensorFlow2/Segmentation/Contrib/UNet3P/README.md
+++ b/TensorFlow2/Segmentation/Contrib/UNet3P/README.md
@@ -66,8 +66,8 @@ For details on how to enable these features while training and evaluation see [B
* Clone code
```
-git clone https://github.com/hamidriasat/NVIDIA-DeepLearningExamples.git
-cd NVIDIA-DeepLearningExamples/TensorFlow2/Segmentation/UNet3P/
+git clone https://github.com/NVIDIA/DeepLearningExamples.git
+cd DeepLearningExamples/TensorFlow2/Segmentation/Contrib/UNet3P/
```
* Build the UNet3P TensorFlow NGC container