1015 Restructure folders and combine examples

mednist_tutorial.ipynb → 2d_classification/mednist_tutorial.ipynb

@@ -15,7 +15,7 @@
     "* Train the model with a PyTorch program\n",
     "* Evaluate on test dataset\n",
     "\n",
-    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Project-MONAI/Tutorials/blob/master/mednist_tutorial.ipynb)"
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Project-MONAI/tutorials/blob/master/2d_classification/mednist_tutorial.ipynb)"
    ]
   },
   {
@@ -683,7 +683,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.9"
+   "version": "3.6.10"
   }
  },
  "nbformat": 4,

2d_segmentation/torch/unet_evaluation_array.py

@@ -0,0 +1,84 @@
+# Copyright 2020 MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+import os
+import sys
+import tempfile
+from glob import glob
+
+import torch
+from PIL import Image
+from torch.utils.data import DataLoader
+
+from monai import config
+from monai.data import ArrayDataset, PNGSaver, create_test_image_2d
+from monai.inferers import sliding_window_inference
+from monai.metrics import DiceMetric
+from monai.networks.nets import UNet
+from monai.transforms import AddChannel, Compose, LoadImage, ScaleIntensity, ToTensor
+
+
+def main(tempdir):
+    config.print_config()
+    logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+
+    print(f"generating synthetic data to {tempdir} (this may take a while)")
+    for i in range(5):
+        im, seg = create_test_image_2d(128, 128, num_seg_classes=1)
+        Image.fromarray(im.astype("uint8")).save(os.path.join(tempdir, f"img{i:d}.png"))
+        Image.fromarray(seg.astype("uint8")).save(os.path.join(tempdir, f"seg{i:d}.png"))
+
+    images = sorted(glob(os.path.join(tempdir, "img*.png")))
+    segs = sorted(glob(os.path.join(tempdir, "seg*.png")))
+
+    # define transforms for image and segmentation
+    imtrans = Compose([LoadImage(image_only=True), ScaleIntensity(), AddChannel(), ToTensor()])
+    segtrans = Compose([LoadImage(image_only=True), AddChannel(), ToTensor()])
+    val_ds = ArrayDataset(images, imtrans, segs, segtrans)
+    # sliding window inference for one image at every iteration
+    val_loader = DataLoader(val_ds, batch_size=1, num_workers=1, pin_memory=torch.cuda.is_available())
+    dice_metric = DiceMetric(include_background=True, to_onehot_y=False, sigmoid=True, reduction="mean")
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = UNet(
+        dimensions=2,
+        in_channels=1,
+        out_channels=1,
+        channels=(16, 32, 64, 128, 256),
+        strides=(2, 2, 2, 2),
+        num_res_units=2,
+    ).to(device)
+
+    model.load_state_dict(torch.load("best_metric_model_segmentation2d_array.pth"))
+    model.eval()
+    with torch.no_grad():
+        metric_sum = 0.0
+        metric_count = 0
+        saver = PNGSaver(output_dir="./output")
+        for val_data in val_loader:
+            val_images, val_labels = val_data[0].to(device), val_data[1].to(device)
+            # define sliding window size and batch size for windows inference
+            roi_size = (96, 96)
+            sw_batch_size = 4
+            val_outputs = sliding_window_inference(val_images, roi_size, sw_batch_size, model)
+            value = dice_metric(y_pred=val_outputs, y=val_labels)
+            metric_count += len(value)
+            metric_sum += value.item() * len(value)
+            val_outputs = val_outputs.sigmoid() >= 0.5
+            saver.save_batch(val_outputs)
+        metric = metric_sum / metric_count
+        print("evaluation metric:", metric)
+
+
+if __name__ == "__main__":
+    with tempfile.TemporaryDirectory() as tempdir:
+        main(tempdir)

2d_segmentation/torch/unet_evaluation_dict.py

@@ -0,0 +1,92 @@
+# Copyright 2020 MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+import os
+import sys
+import tempfile
+from glob import glob
+
+import torch
+from PIL import Image
+from torch.utils.data import DataLoader
+
+import monai
+from monai.data import PNGSaver, create_test_image_2d, list_data_collate
+from monai.inferers import sliding_window_inference
+from monai.metrics import DiceMetric
+from monai.networks.nets import UNet
+from monai.transforms import AddChanneld, Compose, LoadImaged, ScaleIntensityd, ToTensord
+
+
+def main(tempdir):
+    monai.config.print_config()
+    logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+
+    print(f"generating synthetic data to {tempdir} (this may take a while)")
+    for i in range(5):
+        im, seg = create_test_image_2d(128, 128, num_seg_classes=1)
+        Image.fromarray(im.astype("uint8")).save(os.path.join(tempdir, f"img{i:d}.png"))
+        Image.fromarray(seg.astype("uint8")).save(os.path.join(tempdir, f"seg{i:d}.png"))
+
+    images = sorted(glob(os.path.join(tempdir, "img*.png")))
+    segs = sorted(glob(os.path.join(tempdir, "seg*.png")))
+    val_files = [{"img": img, "seg": seg} for img, seg in zip(images, segs)]
+
+    # define transforms for image and segmentation
+    val_transforms = Compose(
+        [
+            LoadImaged(keys=["img", "seg"]),
+            AddChanneld(keys=["img", "seg"]),
+            ScaleIntensityd(keys="img"),
+            ToTensord(keys=["img", "seg"]),
+        ]
+    )
+    val_ds = monai.data.Dataset(data=val_files, transform=val_transforms)
+    # sliding window inference need to input 1 image in every iteration
+    val_loader = DataLoader(val_ds, batch_size=1, num_workers=4, collate_fn=list_data_collate)
+    dice_metric = DiceMetric(include_background=True, to_onehot_y=False, sigmoid=True, reduction="mean")
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = UNet(
+        dimensions=2,
+        in_channels=1,
+        out_channels=1,
+        channels=(16, 32, 64, 128, 256),
+        strides=(2, 2, 2, 2),
+        num_res_units=2,
+    ).to(device)
+
+    model.load_state_dict(torch.load("best_metric_model_segmentation2d_dict.pth"))
+
+    model.eval()
+    with torch.no_grad():
+        metric_sum = 0.0
+        metric_count = 0
+        saver = PNGSaver(output_dir="./output")
+        for val_data in val_loader:
+            val_images, val_labels = val_data["img"].to(device), val_data["seg"].to(device)
+            # define sliding window size and batch size for windows inference
+            roi_size = (96, 96)
+            sw_batch_size = 4
+            val_outputs = sliding_window_inference(val_images, roi_size, sw_batch_size, model)
+            value = dice_metric(y_pred=val_outputs, y=val_labels)
+            metric_count += len(value)
+            metric_sum += value.item() * len(value)
+            val_outputs = val_outputs.sigmoid() >= 0.5
+            saver.save_batch(val_outputs)
+        metric = metric_sum / metric_count
+        print("evaluation metric:", metric)
+
+
+if __name__ == "__main__":
+    with tempfile.TemporaryDirectory() as tempdir:
+        main(tempdir)

2d_segmentation/torch/unet_training_array.py

@@ -0,0 +1,166 @@
+# Copyright 2020 MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+import os
+import sys
+import tempfile
+from glob import glob
+
+import torch
+from PIL import Image
+from torch.utils.data import DataLoader
+from torch.utils.tensorboard import SummaryWriter
+
+import monai
+from monai.data import ArrayDataset, create_test_image_2d
+from monai.inferers import sliding_window_inference
+from monai.metrics import DiceMetric
+from monai.transforms import AddChannel, Compose, LoadImage, RandRotate90, RandSpatialCrop, ScaleIntensity, ToTensor
+from monai.visualize import plot_2d_or_3d_image
+
+
+def main(tempdir):
+    monai.config.print_config()
+    logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+
+    # create a temporary directory and 40 random image, mask pairs
+    print(f"generating synthetic data to {tempdir} (this may take a while)")
+    for i in range(40):
+        im, seg = create_test_image_2d(128, 128, num_seg_classes=1)
+        Image.fromarray(im.astype("uint8")).save(os.path.join(tempdir, f"img{i:d}.png"))
+        Image.fromarray(seg.astype("uint8")).save(os.path.join(tempdir, f"seg{i:d}.png"))
+
+    images = sorted(glob(os.path.join(tempdir, "img*.png")))
+    segs = sorted(glob(os.path.join(tempdir, "seg*.png")))
+    train_files = [{"img": img, "seg": seg} for img, seg in zip(images[:20], segs[:20])]
+    val_files = [{"img": img, "seg": seg} for img, seg in zip(images[-20:], segs[-20:])]
+
+    # define transforms for image and segmentation
+    train_imtrans = Compose(
+        [
+            LoadImage(image_only=True),
+            ScaleIntensity(),
+            AddChannel(),
+            RandSpatialCrop((96, 96), random_size=False),
+            RandRotate90(prob=0.5, spatial_axes=(0, 1)),
+            ToTensor(),
+        ]
+    )
+    train_segtrans = Compose(
+        [
+            LoadImage(image_only=True),
+            AddChannel(),
+            RandSpatialCrop((96, 96), random_size=False),
+            RandRotate90(prob=0.5, spatial_axes=(0, 1)),
+            ToTensor(),
+        ]
+    )
+    val_imtrans = Compose([LoadImage(image_only=True), ScaleIntensity(), AddChannel(), ToTensor()])
+    val_segtrans = Compose([LoadImage(image_only=True), AddChannel(), ToTensor()])
+
+    # define array dataset, data loader
+    check_ds = ArrayDataset(images, train_imtrans, segs, train_segtrans)
+    check_loader = DataLoader(check_ds, batch_size=10, num_workers=2, pin_memory=torch.cuda.is_available())
+    im, seg = monai.utils.misc.first(check_loader)
+    print(im.shape, seg.shape)
+
+    # create a training data loader
+    train_ds = ArrayDataset(images[:20], train_imtrans, segs[:20], train_segtrans)
+    train_loader = DataLoader(train_ds, batch_size=4, shuffle=True, num_workers=8, pin_memory=torch.cuda.is_available())
+    # create a validation data loader
+    val_ds = ArrayDataset(images[-20:], val_imtrans, segs[-20:], val_segtrans)
+    val_loader = DataLoader(val_ds, batch_size=1, num_workers=4, pin_memory=torch.cuda.is_available())
+    dice_metric = DiceMetric(include_background=True, to_onehot_y=False, sigmoid=True, reduction="mean")
+
+    # create UNet, DiceLoss and Adam optimizer
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = monai.networks.nets.UNet(
+        dimensions=2,
+        in_channels=1,
+        out_channels=1,
+        channels=(16, 32, 64, 128, 256),
+        strides=(2, 2, 2, 2),
+        num_res_units=2,
+    ).to(device)
+    loss_function = monai.losses.DiceLoss(sigmoid=True)
+    optimizer = torch.optim.Adam(model.parameters(), 1e-3)
+
+    # start a typical PyTorch training
+    val_interval = 2
+    best_metric = -1
+    best_metric_epoch = -1
+    epoch_loss_values = list()
+    metric_values = list()
+    writer = SummaryWriter()
+    for epoch in range(10):
+        print("-" * 10)
+        print(f"epoch {epoch + 1}/{10}")
+        model.train()
+        epoch_loss = 0
+        step = 0
+        for batch_data in train_loader:
+            step += 1
+            inputs, labels = batch_data[0].to(device), batch_data[1].to(device)
+            optimizer.zero_grad()
+            outputs = model(inputs)
+            loss = loss_function(outputs, labels)
+            loss.backward()
+            optimizer.step()
+            epoch_loss += loss.item()
+            epoch_len = len(train_ds) // train_loader.batch_size
+            print(f"{step}/{epoch_len}, train_loss: {loss.item():.4f}")
+            writer.add_scalar("train_loss", loss.item(), epoch_len * epoch + step)
+        epoch_loss /= step
+        epoch_loss_values.append(epoch_loss)
+        print(f"epoch {epoch + 1} average loss: {epoch_loss:.4f}")
+
+        if (epoch + 1) % val_interval == 0:
+            model.eval()
+            with torch.no_grad():
+                metric_sum = 0.0
+                metric_count = 0
+                val_images = None
+                val_labels = None
+                val_outputs = None
+                for val_data in val_loader:
+                    val_images, val_labels = val_data[0].to(device), val_data[1].to(device)
+                    roi_size = (96, 96)
+                    sw_batch_size = 4
+                    val_outputs = sliding_window_inference(val_images, roi_size, sw_batch_size, model)
+                    value = dice_metric(y_pred=val_outputs, y=val_labels)
+                    metric_count += len(value)
+                    metric_sum += value.item() * len(value)
+                metric = metric_sum / metric_count
+                metric_values.append(metric)
+                if metric > best_metric:
+                    best_metric = metric
+                    best_metric_epoch = epoch + 1
+                    torch.save(model.state_dict(), "best_metric_model_segmentation2d_array.pth")
+                    print("saved new best metric model")
+                print(
+                    "current epoch: {} current mean dice: {:.4f} best mean dice: {:.4f} at epoch {}".format(
+                        epoch + 1, metric, best_metric, best_metric_epoch
+                    )
+                )
+                writer.add_scalar("val_mean_dice", metric, epoch + 1)
+                # plot the last model output as GIF image in TensorBoard with the corresponding image and label
+                plot_2d_or_3d_image(val_images, epoch + 1, writer, index=0, tag="image")
+                plot_2d_or_3d_image(val_labels, epoch + 1, writer, index=0, tag="label")
+                plot_2d_or_3d_image(val_outputs, epoch + 1, writer, index=0, tag="output")
+
+    print(f"train completed, best_metric: {best_metric:.4f} at epoch: {best_metric_epoch}")
+    writer.close()
+
+
+if __name__ == "__main__":
+    with tempfile.TemporaryDirectory() as tempdir:
+        main(tempdir)