SVLS_Interactive_Demo.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "SVLS_Interactive_Demo.ipynb",
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/mobarakol/SVLS/blob/main/SVLS_Interactive_Demo.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AQ5MCVytMBzZ"
      },
      "source": [
        "# Spatially Varying Label Smoothing: Capturing Uncertainty from Expert Annotations\n",
        "[Preprint](https://arxiv.org/pdf/2104.05788.pdf)\n",
        "[Code](https://github.com/mobarakol/SVLS)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DiSbpb1EwjnY"
      },
      "source": [
        "Downloading SVLS and Surface Dice codes"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xFNfvBfdKsT7",
        "outputId": "37b775d0-b1a9-4de1-f2ad-65c4493f2974"
      },
      "source": [
        "!rm -rf SVLS\n",
        "!git clone https://github.com/mobarakol/SVLS.git\n",
        "%cd SVLS\n",
        "!git clone https://github.com/deepmind/surface-distance.git\n",
        "!mv surface-distance surface_distance"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cloning into 'SVLS'...\n",
            "remote: Enumerating objects: 394, done.\u001b[K\n",
            "remote: Counting objects: 100% (394/394), done.\u001b[K\n",
            "remote: Compressing objects: 100% (56/56), done.\u001b[K\n",
            "remote: Total 394 (delta 348), reused 372 (delta 336), pack-reused 0\u001b[K\n",
            "Receiving objects: 100% (394/394), 66.33 KiB | 2.76 MiB/s, done.\n",
            "Resolving deltas: 100% (348/348), done.\n",
            "/content/SVLS\n",
            "Cloning into 'surface-distance'...\n",
            "remote: Enumerating objects: 50, done.\u001b[K\n",
            "remote: Counting objects: 100% (17/17), done.\u001b[K\n",
            "remote: Compressing objects: 100% (10/10), done.\u001b[K\n",
            "remote: Total 50 (delta 11), reused 8 (delta 7), pack-reused 33\u001b[K\n",
            "Unpacking objects: 100% (50/50), 36.65 KiB | 1.18 MiB/s, done.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QZNhk4-Od3FR"
      },
      "source": [
        "Install require packages:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JdbUhZNUd6kl",
        "outputId": "b39cf47a-8663-42ac-d11c-0fd98a04596a"
      },
      "source": [
        "!pip install -U -q SimpleITK"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m52.7/52.7 MB\u001b[0m \u001b[31m14.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FBq96oSpM7Da"
      },
      "source": [
        "### Download Dataset and Trained Models"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "keDB9x0yNH4J"
      },
      "source": [
        "!pip install -U -q PyDrive\n",
        "from pydrive.auth import GoogleAuth\n",
        "from pydrive.drive import GoogleDrive\n",
        "from google.colab import auth\n",
        "from oauth2client.client import GoogleCredentials\n",
        "\n",
        "# Authenticate and create the PyDrive client.\n",
        "auth.authenticate_user()\n",
        "gauth = GoogleAuth()\n",
        "gauth.credentials = GoogleCredentials.get_application_default()\n",
        "drive = GoogleDrive(gauth)"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zgGSo3tNNwaF"
      },
      "source": [
        "Trained Models: https://drive.google.com/file/d/1evE2VqBGdY-0VPB8OeArHMPdRXhWuxFm/view?usp=sharing <br>\n",
        "Validation Data: https://drive.google.com/file/d/1oZ9z-l9lBjKGNZCCTK819Z1ufwe90mg3/view?usp=sharing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lhX7jTGxNxEr"
      },
      "source": [
        "ids = ['1evE2VqBGdY-0VPB8OeArHMPdRXhWuxFm', '1oZ9z-l9lBjKGNZCCTK819Z1ufwe90mg3']\n",
        "zip_files = ['ckpt_brats19.zip','train_valid.zip']\n",
        "for id, zip_file in zip(ids, zip_files):\n",
        "    downloaded = drive.CreateFile({'id':id})\n",
        "    downloaded.GetContentFile(zip_file)\n",
        "    !unzip -q $zip_file"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m0PdKAYPWBx8"
      },
      "source": [
        "Demo"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 640
        },
        "id": "ZkknSZEls29B",
        "outputId": "12cc9fff-56e0-42dc-fd65-97925ac855e1"
      },
      "source": [
        "import argparse\n",
        "import os\n",
        "import numpy as np\n",
        "import pathlib\n",
        "import torch\n",
        "from torch.nn import functional as F\n",
        "from model import UNet3D\n",
        "from datasets import get_datasets_brats\n",
        "from utils import seed_everything, EDiceLoss\n",
        "from calibration_metrics import ece_eval, tace_eval, reliability_diagram\n",
        "import warnings\n",
        "warnings.filterwarnings(\"ignore\")\n",
        "\n",
        "def step_valid(data_loader, model, metric):\n",
        "    ece_all, acc_all, conf_all, tace_all = [], [], [], []\n",
        "    losses, metrics, metrics_sd = [], [], []\n",
        "    model.eval()\n",
        "    for i, batch in enumerate(data_loader):\n",
        "        targets = batch[\"label\"].squeeze(1).cuda(non_blocking=True)\n",
        "        inputs = batch[\"image\"].float().cuda()\n",
        "        segs = model(inputs)\n",
        "        outputs = F.softmax(segs, dim=1).detach().cpu().numpy()\n",
        "        if len(targets.shape) < 4:#if batch size=1\n",
        "            targets = targets.unsqueeze(0)\n",
        "        labels = targets.detach().cpu().numpy()\n",
        "\n",
        "        ece, acc, conf, _ = ece_eval(outputs,labels)\n",
        "        tace, _, _, _ = tace_eval(outputs,labels)\n",
        "        ece_all.append(ece)\n",
        "        acc_all.append(acc)\n",
        "        conf_all.append(conf)\n",
        "        tace_all.append(tace)\n",
        "        segs = segs.data.max(1)[1].squeeze_(1)\n",
        "        metric_ = metric.metric_brats(segs, targets)\n",
        "        metrics_sd.extend(metric.get_surface_dice(segs.detach().cpu().numpy(), targets.detach().cpu().numpy()))\n",
        "        metrics.extend(metric_)\n",
        "\n",
        "    ece_avg = np.stack(ece_all).mean(0)\n",
        "    acc_avg = np.stack(acc_all).mean(0)\n",
        "    conf_avg = np.stack(conf_all).mean(0)\n",
        "    tace_avg = np.stack(tace_all).mean(0)\n",
        "    return metrics, metrics_sd, ece_avg, acc_avg, conf_avg, tace_avg\n",
        "\n",
        "def main():\n",
        "    parser = argparse.ArgumentParser(description='SVLS Brats Training')\n",
        "    parser.add_argument('--batch_size', default=2, type=int,help='mini-batch size')\n",
        "    parser.add_argument('--num_classes', default=4, type=int, help=\"num of classes\")\n",
        "    parser.add_argument('--in_channels', default=4, type=int, help=\"num of input channels\")\n",
        "    parser.add_argument('--train_option', default='SVLS', help=\"options:[SVLS, LS, OH]\")\n",
        "    parser.add_argument('--epochs', default=200, type=int, help='number of total epochs to run')\n",
        "    parser.add_argument('--data_root', default='train_valid', help='data directory')\n",
        "    parser.add_argument('--ckpt_dir', default='ckpt_brats19', help='ckpt directory')\n",
        "    args = parser.parse_args(args=[])\n",
        "\n",
        "    _, val_dataset = get_datasets_brats(data_root=args.data_root)\n",
        "    val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=args.batch_size, shuffle=False,\n",
        "        pin_memory=False, num_workers=2)\n",
        "\n",
        "    print('valid sample:',len(val_dataset), 'valid minibatch:',len(val_loader))\n",
        "\n",
        "    model = UNet3D(inplanes=args.in_channels, num_classes=args.num_classes).cuda()\n",
        "\n",
        "    model = torch.nn.DataParallel(model)\n",
        "    criterion_dice = EDiceLoss().cuda()\n",
        "\n",
        "    legends = ['OH', 'LS(0.1)', 'LS(0.2)', 'LS(0.3)', 'SVLS']\n",
        "    model_list = ['best_oh.pth.tar', 'best_ls0.1.pth.tar', 'best_ls0.2.pth.tar', 'best_ls0.3.pth.tar', 'best_svls.pth.tar']\n",
        "    for model_name, legend in zip(model_list, legends):\n",
        "        model.load_state_dict(torch.load(os.path.join(args.ckpt_dir, model_name)))\n",
        "        model.eval()\n",
        "        with torch.no_grad():\n",
        "            dice_metrics, metrics_sd, ece_avg, acc_avg, conf_avg, tace_avg = step_valid(val_loader, model, criterion_dice)\n",
        "        if legend != 'LS(0.3)':\n",
        "            reliability_diagram(conf_avg, acc_avg, legend=legend)\n",
        "        dice_metrics = list(zip(*dice_metrics))\n",
        "        dice_metrics = [torch.tensor(dice, device=\"cpu\").numpy() for dice in dice_metrics]\n",
        "        avg_dices = np.mean(dice_metrics,1)\n",
        "        avg_std = np.std(dice_metrics,1)\n",
        "\n",
        "        metrics_sd = list(zip(*metrics_sd))\n",
        "        metrics_sd = [torch.tensor(dice, device=\"cpu\").numpy() for dice in metrics_sd]\n",
        "        avg_sd = np.mean(metrics_sd,1)\n",
        "        avg_std_sd = np.std(metrics_sd,1)\n",
        "\n",
        "        print('model:%s , dice[ET:%.3f ± %.3f, TC:%.3f ± %.3f, WT:%.3f ± %.3f], ECE:%.4f, TACE:%.4f'%(\n",
        "            model_name, avg_dices[0],avg_std[0], avg_dices[1],avg_std[1], avg_dices[2],avg_std[2], ece_avg, tace_avg))\n",
        "\n",
        "        print('model:%s , Surface dice[ET:%.3f ± %.3f, TC:%.3f ± %.3f, WT:%.3f ± %.3f]'%(\n",
        "            model_name, avg_sd[0],avg_std_sd[0], avg_sd[1],avg_std_sd[1], avg_sd[2],avg_std_sd[2]))\n",
        "\n",
        "if __name__ == '__main__':\n",
        "    seed_everything()\n",
        "    main()\n"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "valid sample: 66 valid minibatch: 33\n",
            "model:best_oh.pth.tar , dice[ET:0.802 ± 0.179, TC:0.861 ± 0.128, WT:0.892 ± 0.074], ECE:0.0768, TACE:0.0041\n",
            "model:best_oh.pth.tar , Surface dice[ET:0.916 ± 0.196, TC:0.862 ± 0.181, WT:0.894 ± 0.147]\n",
            "model:best_ls0.1.pth.tar , dice[ET:0.825 ± 0.152, TC:0.873 ± 0.131, WT:0.892 ± 0.071], ECE:0.0659, TACE:0.0025\n",
            "model:best_ls0.1.pth.tar , Surface dice[ET:0.933 ± 0.169, TC:0.888 ± 0.175, WT:0.911 ± 0.121]\n",
            "model:best_ls0.2.pth.tar , dice[ET:0.819 ± 0.148, TC:0.861 ± 0.135, WT:0.892 ± 0.070], ECE:0.0931, TACE:0.0049\n",
            "model:best_ls0.2.pth.tar , Surface dice[ET:0.929 ± 0.185, TC:0.879 ± 0.183, WT:0.906 ± 0.127]\n",
            "model:best_ls0.3.pth.tar , dice[ET:0.788 ± 0.209, TC:0.858 ± 0.161, WT:0.891 ± 0.072], ECE:0.1467, TACE:0.0073\n",
            "model:best_ls0.3.pth.tar , Surface dice[ET:0.914 ± 0.195, TC:0.873 ± 0.188, WT:0.919 ± 0.113]\n",
            "model:best_svls.pth.tar , dice[ET:0.817 ± 0.138, TC:0.864 ± 0.118, WT:0.895 ± 0.064], ECE:0.0614, TACE:0.0040\n",
            "model:best_svls.pth.tar , Surface dice[ET:0.937 ± 0.161, TC:0.884 ± 0.160, WT:0.941 ± 0.082]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Method-1: Saving the prediction: same size as training"
      ],
      "metadata": {
        "id": "PX_ri7M1KBrs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import argparse\n",
        "import os\n",
        "import numpy as np\n",
        "import pathlib\n",
        "import torch\n",
        "from torch.nn import functional as F\n",
        "from model import UNet3D\n",
        "from datasets import get_datasets_brats\n",
        "from utils import seed_everything, EDiceLoss\n",
        "import nibabel as nib\n",
        "import numpy as np\n",
        "import SimpleITK as sitk\n",
        "import random\n",
        "from glob import glob\n",
        "from torch.utils.data.dataset import Dataset\n",
        "import torch.nn.functional as F\n",
        "from torch.utils.data._utils.collate import default_collate\n",
        "from datasets import custom_collate, determinist_collate, pad_batch_to_max_shape, \\\n",
        "pad_batch1_to_compatible_size, irm_min_max_preprocess, pad_or_crop_image\n",
        "\n",
        "import warnings\n",
        "warnings.filterwarnings(\"ignore\")\n",
        "\n",
        "\n",
        "parser = argparse.ArgumentParser(description='SVLS Brats Training')\n",
        "parser.add_argument('--batch_size', default=2, type=int,help='mini-batch size')\n",
        "parser.add_argument('--num_classes', default=4, type=int, help=\"num of classes\")\n",
        "parser.add_argument('--in_channels', default=4, type=int, help=\"num of input channels\")\n",
        "parser.add_argument('--train_option', default='SVLS', help=\"options:[SVLS, LS, OH]\")\n",
        "parser.add_argument('--epochs', default=200, type=int, help='number of total epochs to run')\n",
        "parser.add_argument('--data_root', default='train_valid', help='data directory')\n",
        "parser.add_argument('--ckpt_dir', default='ckpt_brats19', help='ckpt directory')\n",
        "args = parser.parse_args(args=[])\n",
        "\n",
        "def get_datasets_brats(data_root=None, normalisation=\"zscore\"):\n",
        "\n",
        "    data_root = pathlib.Path(data_root)\n",
        "    base_folder_train = pathlib.Path('data/BraTS19/train_train/').resolve()\n",
        "    base_folder_valid = pathlib.Path('data/BraTS19/train_valid/').resolve()\n",
        "    patients_dir_train = sorted([data_root/x.name for x in base_folder_train.iterdir() if (data_root/x.name).is_dir()])\n",
        "    patients_dir_valid = sorted([data_root/x.name for x in base_folder_valid.iterdir() if (data_root/x.name).is_dir()])\n",
        "    train_dataset = brats19(patients_dir_train, training=True, normalisation=normalisation)\n",
        "    val_dataset = brats19(patients_dir_valid, training=False, normalisation=normalisation)\n",
        "    return train_dataset, val_dataset\n",
        "\n",
        "\n",
        "class brats19(Dataset):\n",
        "    def __init__(self, patients_dir, training=True, no_seg=False, normalisation=\"minmax\"):\n",
        "        super(brats19, self).__init__()\n",
        "        self.normalisation = normalisation\n",
        "        self.training = training\n",
        "        self.datas = []\n",
        "        self.validation = no_seg\n",
        "        self.patterns = [ \"_flair\", \"_t1\", \"_t1ce\", \"_t2\"]\n",
        "        self.mean = dict(flair=0.0860377, t1=0.1216296, t1ce=0.07420689, t2=0.09033176)\n",
        "        if not no_seg:\n",
        "            self.patterns += [\"_seg\"]\n",
        "        for patient_dir in patients_dir:\n",
        "            patient_id = patient_dir.name\n",
        "            paths = [patient_dir / f\"{patient_id}{value}.nii.gz\" for value in self.patterns]\n",
        "            patient = dict(\n",
        "                id=patient_id, flair=paths[0], t1=paths[1], t1ce=paths[2],\n",
        "                t2=paths[3], seg=paths[4] if not no_seg else None\n",
        "            )\n",
        "            self.datas.append(patient)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        _patient = self.datas[idx]\n",
        "        patient_image = {key: self.load_nii(_patient[key]) for key in _patient if key not in [\"id\", \"seg\"]}\n",
        "        if _patient[\"seg\"] is not None:\n",
        "            patient_label = self.load_nii(_patient[\"seg\"])\n",
        "\n",
        "        patient_image = {key: (irm_min_max_preprocess(patient_image[key]) - self.mean[key]) for key in patient_image}\n",
        "        patient_image = np.stack([patient_image[key] for key in patient_image])\n",
        "        patient_label[patient_label==4] = 3\n",
        "        patient_label = patient_label[None,:,:,:]\n",
        "\n",
        "        # Remove maximum extent of the zero-background to make future crop more useful\n",
        "        z_indexes, y_indexes, x_indexes = np.nonzero(np.sum(patient_image, axis=0) != 0)\n",
        "\n",
        "        # Add 1 pixel in each side\n",
        "        zmin, ymin, xmin = [max(0, int(np.min(arr) - 1)) for arr in (z_indexes, y_indexes, x_indexes)]\n",
        "        zmax, ymax, xmax = [int(np.max(arr) + 1) for arr in (z_indexes, y_indexes, x_indexes)]\n",
        "        patient_image = patient_image[:, 13:141, 24:216, 24:216]\n",
        "        patient_image, patient_label = patient_image.astype(\"float16\"), patient_label.astype(\"long\")\n",
        "        patient_image, patient_label = [torch.from_numpy(x) for x in [patient_image, patient_label]]\n",
        "        return dict(patient_id=_patient[\"id\"],\n",
        "                    image=patient_image, label=patient_label,\n",
        "                    seg_path=str(_patient[\"seg\"]),\n",
        "                    crop_indexes=((zmin, zmax), (ymin, ymax), (xmin, xmax)),\n",
        "                    )\n",
        "\n",
        "    @staticmethod\n",
        "    def load_nii(path_folder):\n",
        "        return sitk.GetArrayFromImage(sitk.ReadImage(str(path_folder)))\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.datas)\n",
        "\n",
        "\n",
        "def save_prediction_to_mri(args, predictions, patient_ids):\n",
        "    os.makedirs('predicted_segs', exist_ok=True)\n",
        "    for idx, patient_id in enumerate(patient_ids):\n",
        "        path = os.path.join(args.data_root, patient_id, patient_id+'_t1.nii.gz')\n",
        "        img_original = nib.load(path)\n",
        "        img_nifti = nib.Nifti1Image(predictions[idx], img_original.affine, header=img_original.header)\n",
        "        nib.save(img_nifti,'predicted_segs/'+patient_id+'_pred.nii.gz') #not as expected\n",
        "\n",
        "_, val_dataset = get_datasets_brats(data_root=args.data_root)\n",
        "val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=args.batch_size, shuffle=False,\n",
        "    pin_memory=False, num_workers=2)\n",
        "\n",
        "print('valid sample:',len(val_dataset), 'valid minibatch:',len(val_loader))\n",
        "model = UNet3D(inplanes=args.in_channels, num_classes=args.num_classes).cuda()\n",
        "model = torch.nn.DataParallel(model)\n",
        "criterion_dice = EDiceLoss().cuda()\n",
        "model.load_state_dict(torch.load(os.path.join(args.ckpt_dir, 'best_oh.pth.tar')))\n",
        "model.eval()\n",
        "with torch.no_grad():\n",
        "    metrics = []\n",
        "    for i, batch in enumerate(val_loader):\n",
        "        targets = batch[\"label\"].squeeze(1).cuda(non_blocking=True)\n",
        "        inputs = batch[\"image\"].float().cuda()\n",
        "        preds = model(inputs)\n",
        "        pred_full = torch.zeros(targets.shape)\n",
        "        preds = preds.data.max(1)[1].squeeze_(1)\n",
        "        pred_full[:,13:141, 24:216, 24:216] = preds.cpu()\n",
        "        if len(targets.shape) < 4:#if batch size=1\n",
        "            targets = targets.unsqueeze(0)\n",
        "        metric_ = criterion_dice.metric_brats(pred_full, targets.cpu())\n",
        "        metrics.extend(metric_)\n",
        "        pred_full = pred_full.permute(0,3,2,1).detach().cpu().numpy()\n",
        "        save_prediction_to_mri(args, pred_full, batch['patient_id'])\n",
        "\n",
        "    metrics = list(zip(*metrics))\n",
        "    metrics = [torch.tensor(dice, device=\"cpu\").numpy() for dice in metrics]\n",
        "    avg_dices = np.mean(metrics,1)\n",
        "\n",
        "print('dice[ET:%.3f, TC:%.3f, WT:%.3f]'%(avg_dices[0], avg_dices[1], avg_dices[2]))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rHjwGbL3KIJ9",
        "outputId": "8c756709-cc76-49e7-b2d9-395171f98480"
      },
      "execution_count": 74,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "valid sample: 66 valid minibatch: 33\n",
            "dice[ET:0.801, TC:0.861, WT:0.892]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Method-2: Saving the prediction: including padding(default volume 155 244 244)"
      ],
      "metadata": {
        "id": "W0Tt6RRorSlA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import argparse\n",
        "import os\n",
        "import numpy as np\n",
        "import pathlib\n",
        "import torch\n",
        "from torch.nn import functional as F\n",
        "from model import UNet3D\n",
        "from datasets import get_datasets_brats\n",
        "from utils import seed_everything, EDiceLoss\n",
        "import nibabel as nib\n",
        "import numpy as np\n",
        "import SimpleITK as sitk\n",
        "import random\n",
        "from glob import glob\n",
        "from torch.utils.data.dataset import Dataset\n",
        "import torch.nn.functional as F\n",
        "from torch.utils.data._utils.collate import default_collate\n",
        "from datasets import custom_collate, determinist_collate, pad_batch_to_max_shape, \\\n",
        "pad_batch1_to_compatible_size, irm_min_max_preprocess, pad_or_crop_image\n",
        "\n",
        "import warnings\n",
        "warnings.filterwarnings(\"ignore\")\n",
        "\n",
        "\n",
        "parser = argparse.ArgumentParser(description='SVLS Brats Training')\n",
        "parser.add_argument('--batch_size', default=2, type=int,help='mini-batch size')\n",
        "parser.add_argument('--num_classes', default=4, type=int, help=\"num of classes\")\n",
        "parser.add_argument('--in_channels', default=4, type=int, help=\"num of input channels\")\n",
        "parser.add_argument('--train_option', default='SVLS', help=\"options:[SVLS, LS, OH]\")\n",
        "parser.add_argument('--epochs', default=200, type=int, help='number of total epochs to run')\n",
        "parser.add_argument('--data_root', default='train_valid', help='data directory')\n",
        "parser.add_argument('--ckpt_dir', default='ckpt_brats19', help='ckpt directory')\n",
        "args = parser.parse_args(args=[])\n",
        "\n",
        "def get_datasets_brats(data_root=None, normalisation=\"zscore\"):\n",
        "\n",
        "    data_root = pathlib.Path(data_root)\n",
        "    base_folder_train = pathlib.Path('data/BraTS19/train_train/').resolve()\n",
        "    base_folder_valid = pathlib.Path('data/BraTS19/train_valid/').resolve()\n",
        "    patients_dir_train = sorted([data_root/x.name for x in base_folder_train.iterdir() if (data_root/x.name).is_dir()])\n",
        "    patients_dir_valid = sorted([data_root/x.name for x in base_folder_valid.iterdir() if (data_root/x.name).is_dir()])\n",
        "    train_dataset = brats19(patients_dir_train, training=True, normalisation=normalisation)\n",
        "    val_dataset = brats19(patients_dir_valid, training=False, normalisation=normalisation)\n",
        "    return train_dataset, val_dataset\n",
        "\n",
        "\n",
        "class brats19(Dataset):\n",
        "    def __init__(self, patients_dir, training=True, no_seg=False, normalisation=\"minmax\"):\n",
        "        super(brats19, self).__init__()\n",
        "        self.normalisation = normalisation\n",
        "        self.training = training\n",
        "        self.datas = []\n",
        "        self.validation = no_seg\n",
        "        self.patterns = [ \"_flair\", \"_t1\", \"_t1ce\", \"_t2\"]\n",
        "        self.mean = dict(flair=0.0860377, t1=0.1216296, t1ce=0.07420689, t2=0.09033176)\n",
        "        if not no_seg:\n",
        "            self.patterns += [\"_seg\"]\n",
        "        for patient_dir in patients_dir:\n",
        "            patient_id = patient_dir.name\n",
        "            paths = [patient_dir / f\"{patient_id}{value}.nii.gz\" for value in self.patterns]\n",
        "            patient = dict(\n",
        "                id=patient_id, flair=paths[0], t1=paths[1], t1ce=paths[2],\n",
        "                t2=paths[3], seg=paths[4] if not no_seg else None\n",
        "            )\n",
        "            self.datas.append(patient)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        _patient = self.datas[idx]\n",
        "        patient_image = {key: self.load_nii(_patient[key]) for key in _patient if key not in [\"id\", \"seg\"]}\n",
        "        if _patient[\"seg\"] is not None:\n",
        "            patient_label = self.load_nii(_patient[\"seg\"])\n",
        "\n",
        "        patient_image = {key: (irm_min_max_preprocess(patient_image[key]) - self.mean[key]) for key in patient_image}\n",
        "        patient_image = np.stack([patient_image[key] for key in patient_image])\n",
        "        patient_label[patient_label==4] = 3\n",
        "        patient_label = patient_label[None,:,:,:]\n",
        "\n",
        "        # Remove maximum extent of the zero-background to make future crop more useful\n",
        "        z_indexes, y_indexes, x_indexes = np.nonzero(np.sum(patient_image, axis=0) != 0)\n",
        "\n",
        "        # Add 1 pixel in each side\n",
        "        zmin, ymin, xmin = [max(0, int(np.min(arr) - 1)) for arr in (z_indexes, y_indexes, x_indexes)]\n",
        "        zmax, ymax, xmax = [int(np.max(arr) + 1) for arr in (z_indexes, y_indexes, x_indexes)]\n",
        "        patient_image, patient_label = patient_image.astype(\"float16\"), patient_label.astype(\"long\")\n",
        "        patient_image, patient_label = [torch.from_numpy(x) for x in [patient_image, patient_label]]\n",
        "        return dict(patient_id=_patient[\"id\"],\n",
        "                    image=patient_image, label=patient_label,\n",
        "                    seg_path=str(_patient[\"seg\"]),\n",
        "                    crop_indexes=((zmin, zmax), (ymin, ymax), (xmin, xmax)),\n",
        "                    )\n",
        "\n",
        "    @staticmethod\n",
        "    def load_nii(path_folder):\n",
        "        return sitk.GetArrayFromImage(sitk.ReadImage(str(path_folder)))\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.datas)\n",
        "\n",
        "\n",
        "def save_prediction_to_mri(args, predictions, patient_ids):\n",
        "    os.makedirs('predicted_segs', exist_ok=True)\n",
        "    for idx, patient_id in enumerate(patient_ids):\n",
        "        path = os.path.join(args.data_root, patient_id, patient_id+'_t1.nii.gz')\n",
        "        img_original = nib.load(path)\n",
        "        img_nifti = nib.Nifti1Image(predictions[idx], img_original.affine, header=img_original.header)\n",
        "        nib.save(img_nifti,'predicted_segs/'+patient_id+'_pred.nii.gz') #not as expected\n",
        "\n",
        "_, val_dataset = get_datasets_brats(data_root=args.data_root)\n",
        "val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=args.batch_size, shuffle=False,\n",
        "    pin_memory=False, num_workers=2)\n",
        "\n",
        "print('valid sample:',len(val_dataset), 'valid minibatch:',len(val_loader))\n",
        "model = UNet3D(inplanes=args.in_channels, num_classes=args.num_classes).cuda()\n",
        "model = torch.nn.DataParallel(model)\n",
        "criterion_dice = EDiceLoss().cuda()\n",
        "model.load_state_dict(torch.load(os.path.join(args.ckpt_dir, 'best_oh.pth.tar')))\n",
        "model.eval()\n",
        "with torch.no_grad():\n",
        "    metrics = []\n",
        "    for i, batch in enumerate(val_loader):\n",
        "        targets = batch[\"label\"].squeeze(1).cuda(non_blocking=True)\n",
        "        inputs = batch[\"image\"].float().cuda()\n",
        "        preds = model(inputs)\n",
        "        preds = preds.data.max(1)[1].squeeze_(1)\n",
        "        if len(targets.shape) < 4:#if batch size=1\n",
        "            targets = targets.unsqueeze(0)\n",
        "        metric_ = criterion_dice.metric_brats(preds, targets)\n",
        "        metrics.extend(metric_)\n",
        "        preds = preds.permute(0,3,2,1).detach().cpu().numpy()\n",
        "        save_prediction_to_mri(args, preds, batch['patient_id'])\n",
        "\n",
        "    metrics = list(zip(*metrics))\n",
        "    metrics = [torch.tensor(dice, device=\"cpu\").numpy() for dice in metrics]\n",
        "    avg_dices = np.mean(metrics,1)\n",
        "\n",
        "print('dice[ET:%.3f, TC:%.3f, WT:%.3f]'%(avg_dices[0], avg_dices[1], avg_dices[2]))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "j3M_BFs5f_Da",
        "outputId": "fa64ab0f-3733-4257-f16f-aa357e8286b5"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "valid sample: 66 valid minibatch: 33\n",
            "dice[ET:0.776, TC:0.826, WT:0.872]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Method-3: Saving the prediction: excluding padding"
      ],
      "metadata": {
        "id": "TzDxoh9zd-ng"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import argparse\n",
        "import os\n",
        "import numpy as np\n",
        "import pathlib\n",
        "import torch\n",
        "from torch.nn import functional as F\n",
        "from model import UNet3D\n",
        "from datasets import get_datasets_brats\n",
        "from utils import seed_everything, EDiceLoss\n",
        "import nibabel as nib\n",
        "import numpy as np\n",
        "import SimpleITK as sitk\n",
        "import random\n",
        "from glob import glob\n",
        "from torch.utils.data.dataset import Dataset\n",
        "import torch.nn.functional as F\n",
        "from torch.utils.data._utils.collate import default_collate\n",
        "from datasets import custom_collate, determinist_collate, pad_batch_to_max_shape, \\\n",
        "pad_batch1_to_compatible_size, irm_min_max_preprocess, pad_or_crop_image\n",
        "\n",
        "import warnings\n",
        "warnings.filterwarnings(\"ignore\")\n",
        "\n",
        "\n",
        "parser = argparse.ArgumentParser(description='SVLS Brats Training')\n",
        "parser.add_argument('--batch_size', default=1, type=int,help='mini-batch size')\n",
        "parser.add_argument('--num_classes', default=4, type=int, help=\"num of classes\")\n",
        "parser.add_argument('--in_channels', default=4, type=int, help=\"num of input channels\")\n",
        "parser.add_argument('--train_option', default='SVLS', help=\"options:[SVLS, LS, OH]\")\n",
        "parser.add_argument('--epochs', default=200, type=int, help='number of total epochs to run')\n",
        "parser.add_argument('--data_root', default='train_valid', help='data directory')\n",
        "parser.add_argument('--ckpt_dir', default='ckpt_brats19', help='ckpt directory')\n",
        "args = parser.parse_args(args=[])\n",
        "\n",
        "def get_datasets_brats(data_root=None, normalisation=\"zscore\"):\n",
        "\n",
        "    data_root = pathlib.Path(data_root)\n",
        "    base_folder_train = pathlib.Path('data/BraTS19/train_train/').resolve()\n",
        "    base_folder_valid = pathlib.Path('data/BraTS19/train_valid/').resolve()\n",
        "    patients_dir_train = sorted([data_root/x.name for x in base_folder_train.iterdir() if (data_root/x.name).is_dir()])\n",
        "    patients_dir_valid = sorted([data_root/x.name for x in base_folder_valid.iterdir() if (data_root/x.name).is_dir()])\n",
        "    train_dataset = brats19(patients_dir_train, training=True, normalisation=normalisation)\n",
        "    val_dataset = brats19(patients_dir_valid, training=False, normalisation=normalisation)\n",
        "    return train_dataset, val_dataset\n",
        "\n",
        "\n",
        "class brats19(Dataset):\n",
        "    def __init__(self, patients_dir, training=True, no_seg=False, normalisation=\"minmax\"):\n",
        "        super(brats19, self).__init__()\n",
        "        self.normalisation = normalisation\n",
        "        self.training = training\n",
        "        self.datas = []\n",
        "        self.validation = no_seg\n",
        "        self.patterns = [ \"_flair\", \"_t1\", \"_t1ce\", \"_t2\"]\n",
        "        # self.mean = dict(flair=0.0860377, t1=0.1216296, t1ce=0.07420689, t2=0.09033176)\n",
        "        self.mean = [0.0860377, 0.1216296, 0.07420689, 0.09033176]\n",
        "        if not no_seg:\n",
        "            self.patterns += [\"_seg\"]\n",
        "        for patient_dir in patients_dir:\n",
        "            patient_id = patient_dir.name\n",
        "            paths = [patient_dir / f\"{patient_id}{value}.nii.gz\" for value in self.patterns]\n",
        "            patient = dict(\n",
        "                id=patient_id, flair=paths[0], t1=paths[1], t1ce=paths[2],\n",
        "                t2=paths[3], seg=paths[4] if not no_seg else None\n",
        "            )\n",
        "            self.datas.append(patient)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        _patient = self.datas[idx]\n",
        "        patient_image = {key: self.load_nii(_patient[key]) for key in _patient if key not in [\"id\", \"seg\"]}\n",
        "        if _patient[\"seg\"] is not None:\n",
        "            patient_label = self.load_nii(_patient[\"seg\"])\n",
        "\n",
        "        # Remove maximum extent of the zero-background to make future crop more useful\n",
        "        patient_image = np.stack([patient_image[key] for key in patient_image])\n",
        "        z_indexes, y_indexes, x_indexes = np.nonzero(np.sum(patient_image, axis=0) != 0)\n",
        "\n",
        "        # Add 1 pixel in each side\n",
        "        zmin, ymin, xmin = [max(0, int(np.min(arr) - 1)) for arr in (z_indexes, y_indexes, x_indexes)]\n",
        "        zmax, ymax, xmax = [int(np.max(arr) + 1) for arr in (z_indexes, y_indexes, x_indexes)]\n",
        "        patient_image = [(irm_min_max_preprocess(patient_image[mod_idx]) - self.mean[mod_idx]) for mod_idx, key in enumerate(patient_image)]\n",
        "        patient_image = np.stack(patient_image)\n",
        "        patient_label[patient_label==4] = 3\n",
        "        patient_label = patient_label[None,:,:,:]\n",
        "        patient_image = patient_image[:, zmin:zmax, ymin:ymax, xmin:xmax]\n",
        "        patient_image, patient_label = patient_image.astype(\"float16\"), patient_label.astype(\"long\")\n",
        "        patient_image, patient_label = [torch.from_numpy(x) for x in [patient_image, patient_label]]\n",
        "        return dict(patient_id=_patient[\"id\"],\n",
        "                    image=patient_image, label=patient_label,\n",
        "                    seg_path=str(_patient[\"seg\"]),\n",
        "                    crop_indexes=((zmin, zmax), (ymin, ymax), (xmin, xmax)),\n",
        "                    )\n",
        "\n",
        "    @staticmethod\n",
        "    def load_nii(path_folder):\n",
        "        return sitk.GetArrayFromImage(sitk.ReadImage(str(path_folder)))\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.datas)\n",
        "\n",
        "\n",
        "def save_prediction_to_mri(args, predictions, patient_ids):\n",
        "    os.makedirs('predicted_segs', exist_ok=True)\n",
        "    for idx, patient_id in enumerate(patient_ids):\n",
        "        path = os.path.join(args.data_root, patient_id, patient_id+'_t1.nii.gz')\n",
        "        img_original = nib.load(path)\n",
        "        img_nifti = nib.Nifti1Image(predictions[idx], img_original.affine, header=img_original.header)\n",
        "        nib.save(img_nifti,'predicted_segs/'+patient_id+'_pred.nii.gz') #not as expected\n",
        "\n",
        "_, val_dataset = get_datasets_brats(data_root=args.data_root)\n",
        "val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=args.batch_size, shuffle=False,\n",
        "    pin_memory=False, num_workers=2)\n",
        "\n",
        "print('valid sample:',len(val_dataset), 'valid minibatch:',len(val_loader))\n",
        "model = UNet3D(inplanes=args.in_channels, num_classes=args.num_classes).cuda()\n",
        "model = torch.nn.DataParallel(model)\n",
        "criterion_dice = EDiceLoss().cuda()\n",
        "model.load_state_dict(torch.load(os.path.join(args.ckpt_dir, 'best_oh.pth.tar')))\n",
        "model.eval()\n",
        "with torch.no_grad():\n",
        "    metrics = []\n",
        "    for i, batch in enumerate(val_loader):\n",
        "        targets = batch[\"label\"].squeeze(1).cuda(non_blocking=True)\n",
        "        inputs = batch[\"image\"].float().cuda()\n",
        "        ((zmin, zmax), (ymin, ymax), (xmin, xmax)) = batch[\"crop_indexes\"]\n",
        "        ((zmin, zmax), (ymin, ymax), (xmin, xmax)) = ((zmin.item(), zmax.item()), (ymin.item(), ymax.item()), (xmin.item(), xmax.item()))\n",
        "        pred_full = torch.zeros(targets.shape)\n",
        "        preds = model(inputs)\n",
        "        preds = preds.data.max(1)[1].squeeze_(1)\n",
        "        if len(targets.shape) < 4:#if batch size=1\n",
        "            targets = targets.unsqueeze(0)\n",
        "\n",
        "        pred_full[:,zmin:zmax, ymin:ymax, xmin:xmax] = preds.cpu()\n",
        "        metric_ = criterion_dice.metric_brats(pred_full, targets.cpu())\n",
        "        metrics.extend(metric_)\n",
        "        pred_full = pred_full.permute(0,3,2,1).detach().cpu().numpy()\n",
        "        save_prediction_to_mri(args, pred_full, batch['patient_id'])\n",
        "\n",
        "    metrics = list(zip(*metrics))\n",
        "    metrics = [torch.tensor(dice, device=\"cpu\").numpy() for dice in metrics]\n",
        "    avg_dices = np.mean(metrics,1)\n",
        "\n",
        "print('dice[ET:%.3f, TC:%.3f, WT:%.3f]'%(avg_dices[0], avg_dices[1], avg_dices[2]))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oPAZ2Bk-cR01",
        "outputId": "9191abdd-855f-4aff-c3dd-efe9edbad764"
      },
      "execution_count": 56,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "valid sample: 66 valid minibatch: 66\n",
            "dice[ET:0.788, TC:0.817, WT:0.860]\n"
          ]
        }
      ]
    }
  ]
}