2d_max_results.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3",
      "language": "python"
    },
    "language_info": {
      "name": "python",
      "version": "3.7.6",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    },
    "colab": {
      "name": "2d-max-results.ipynb",
      "provenance": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/shalabh147/Brain-Tumor-Segmentation-and-Survival-Prediction-using-Deep-Neural-Networks/blob/master/2d_max_results.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5",
        "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
        "trusted": true,
        "id": "GBiDbEX5XfzO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import random\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "#%matplotlib inline\n",
        "#import tensorflow as tf\n",
        "import keras.backend as K\n",
        "import keras\n",
        "avg_sens = [0,0,0,0]\n",
        "avg_spec = [0,0,0,0]\n",
        "\n",
        "from keras.models import Model, load_model\n",
        "#from keras.layers import Input, BatchNormalization, Activation, Dense, Dropout,Maximum\n",
        "#from keras.layers.core import Lambda, RepeatVector, Reshape\n",
        "#from keras.layers.convolutional import Conv2D, Conv2DTranspose,Conv3D,Conv3DTranspose\n",
        "#from keras.layers.pooling import MaxPooling2D, GlobalMaxPool2D,MaxPooling3D\n",
        "#from keras.layers.merge import concatenate, add\n",
        "#from keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau\n",
        "from keras.optimizers import Adam\n",
        "#from keras.preprocessing.image import ImageDataGenerator, array_to_img, img_to_array, load_img\n",
        "\n",
        "#from skimage.io import imread, imshow, concatenate_images\n",
        "#from skimage.transform import resize\n",
        "\n",
        "def standardize(image):\n",
        "\n",
        "  standardized_image = np.zeros(image.shape)\n",
        "\n",
        "  #\n",
        "  \n",
        "      # iterate over the `z` dimension\n",
        "  for z in range(image.shape[2]):\n",
        "      # get a slice of the image \n",
        "      # at channel c and z-th dimension `z`\n",
        "      image_slice = image[:,:,z]\n",
        "\n",
        "      # subtract the mean from image_slice\n",
        "      centered = image_slice - np.mean(image_slice)\n",
        "      \n",
        "      # divide by the standard deviation (only if it is different from zero)\n",
        "      if(np.std(centered)!=0):\n",
        "          centered = centered/np.std(centered) \n",
        "\n",
        "      # update  the slice of standardized image\n",
        "      # with the scaled centered and scaled image\n",
        "      standardized_image[:, :, z] = centered\n",
        "\n",
        "  ### END CODE HERE ###\n",
        "\n",
        "  return standardized_image\n",
        "\n",
        "\n",
        "def dice_coef(y_true, y_pred, epsilon=0.00001):\n",
        "    \"\"\"\n",
        "    Dice = (2*|X & Y|)/ (|X|+ |Y|)\n",
        "         =  2*sum(|A*B|)/(sum(A^2)+sum(B^2))\n",
        "    ref: https://arxiv.org/pdf/1606.04797v1.pdf\n",
        "    \n",
        "    \"\"\"\n",
        "    axis = (0,1,2)\n",
        "    dice_numerator = 2. * K.sum(y_true * y_pred, axis=axis) + epsilon\n",
        "    dice_denominator = K.sum(y_true*y_true, axis=axis) + K.sum(y_pred*y_pred, axis=axis) + epsilon\n",
        "    return K.mean((dice_numerator)/(dice_denominator))\n",
        "\n",
        "def dice_coef_loss(y_true, y_pred):\n",
        "    return 1-dice_coef(y_true, y_pred)\n",
        "\n",
        "def compute_class_sens_spec(pred, label, class_num):\n",
        "    \"\"\"\n",
        "    Compute sensitivity and specificity for a particular example\n",
        "    for a given class.\n",
        "    Args:\n",
        "        pred (np.array): binary arrary of predictions, shape is\n",
        "                         (num classes, height, width, depth).\n",
        "        label (np.array): binary array of labels, shape is\n",
        "                          (num classes, height, width, depth).\n",
        "        class_num (int): number between 0 - (num_classes -1) which says\n",
        "                         which prediction class to compute statistics\n",
        "                         for.\n",
        "    Returns:\n",
        "        sensitivity (float): precision for given class_num.\n",
        "        specificity (float): recall for given class_num\n",
        "    \"\"\"\n",
        "\n",
        "    # extract sub-array for specified class\n",
        "    class_pred = pred[:,:,:,class_num]\n",
        "    class_label = label[:,:,:,class_num]\n",
        "\n",
        "    ### START CODE HERE (REPLACE INSTANCES OF 'None' with your code) ###\n",
        "    \n",
        "    # compute true positives, false positives, \n",
        "    # true negatives, false negatives\n",
        "    tp = np.sum((class_pred == 1) & (class_label == 1))\n",
        "    tn = np.sum((class_pred == 0) & (class_label == 0))\n",
        "    fp = np.sum((class_pred == 1) & (class_label == 0))\n",
        "    fn = np.sum((class_pred == 0) & (class_label == 1))\n",
        "\n",
        "    # compute sensitivity and specificity\n",
        "    sensitivity = tp / (tp + fn)\n",
        "    specificity = tn / (tn + fp)\n",
        "\n",
        "    ### END CODE HERE ###\n",
        "\n",
        "    return sensitivity, specificity\n",
        "\n",
        "\n",
        "def get_sens_spec_df(pred, label):\n",
        "    patch_metrics = pd.DataFrame(\n",
        "        columns = ['Nothing',\n",
        "                    'Edema', \n",
        "                   'Non-Enhancing Tumor', \n",
        "                   'Enhancing Tumor'], \n",
        "        index = ['Sensitivity',\n",
        "                 'Specificity'])\n",
        "    \n",
        "    for i, class_name in enumerate(patch_metrics.columns):\n",
        "        sens, spec = compute_class_sens_spec(pred, label, i)\n",
        "        avg_sens[i] += sens\n",
        "        avg_spec[i] += spec\n",
        "        patch_metrics.loc['Sensitivity', class_name] = round(sens,4)\n",
        "        patch_metrics.loc['Specificity', class_name] = round(spec,4)\n",
        "\n",
        "    #return patch_metrics\n",
        "\n",
        "\n",
        "\n",
        "import os\n",
        "model_axis1 = load_model('../input/evaluate2daxis1/2d_4class_axis1.h5',custom_objects = {'dice_coef_loss' : dice_coef_loss , 'dice_coef' : dice_coef})\n",
        "model_axis2 = load_model('../input/evalutate2daxis2/2d_4class_axis2.h5',custom_objects = {'dice_coef_loss' : dice_coef_loss , 'dice_coef' : dice_coef})\n",
        "model_axis3 = load_model('../input/evaluate2daxis3/2d_4class_axis3.h5',custom_objects = {'dice_coef_loss' : dice_coef_loss , 'dice_coef' : dice_coef})\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "d629ff2d2480ee46fbb7e2d37f6b5fab8052498a",
        "_cell_guid": "79c7e3d0-c299-4dcb-8224-4455121ee9b0",
        "trusted": true,
        "id": "unRckP-8XfzV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "path = '../input/vs-brats2018/miccai_brats_2018_data_training/HGG'\n",
        "all_images = os.listdir(path)\n",
        "#print(len(all_images))\n",
        "all_images.sort()\n",
        "data = np.zeros((240,240,155,4))\n",
        "image_data2=np.zeros((240,240,155))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "c1YgpGFuXfzX",
        "colab_type": "code",
        "colab": {},
        "outputId": "9875a359-2bbf-4bf6-c9ab-78c1deb9da7d"
      },
      "source": [
        "import nibabel as nib\n",
        "mean_loss = 0\n",
        "mean_accu = 0\n",
        "for image_num in range(180,210):\n",
        "    data = np.zeros((240,240,155,4))\n",
        "    #print(epochs)\n",
        "    print(\"Entering Image\" , image_num)\n",
        "\n",
        "# data preprocessing starts here\n",
        "\n",
        "    x = all_images[image_num]\n",
        "    #print(x)\n",
        "    folder_path = path + '/' + x;\n",
        "    modalities = os.listdir(folder_path)\n",
        "    modalities.sort()\n",
        "    #data = []\n",
        "    w = 0\n",
        "    for j in range(len(modalities)):\n",
        "      image_path = folder_path + '/' + modalities[j]\n",
        "      if not(image_path.find('seg.nii') == -1):\n",
        "        img = nib.load(image_path);\n",
        "        image_data2 = img.get_data()\n",
        "        image_data2 = np.asarray(image_data2)\n",
        "        #print(\"Entered ground truth\")\n",
        "      else:\n",
        "        img = nib.load(image_path);\n",
        "        image_data = img.get_data()\n",
        "        image_data = np.asarray(image_data)\n",
        "        image_data = standardize(image_data)\n",
        "        data[:,:,:,w] = image_data\n",
        "        #print(\"Entered modality\")\n",
        "        w = w+1\n",
        "        \n",
        "    image_data2[image_data2 == 4] = 3\n",
        "    image_data2 = keras.utils.to_categorical(image_data2, num_classes = 4)\n",
        "\n",
        "    data_axis1=data\n",
        "    data_axis2=np.moveaxis(data,1,0)\n",
        "    data_axis3=np.moveaxis(data,2,0)\n",
        "\n",
        "\n",
        "    Y_hat_axis1 = model_axis1.predict(x=data_axis1)\n",
        "    Y_hat_axis2 = model_axis2.predict(x=data_axis2)\n",
        "    Y_hat_axis3 = model_axis3.predict(x=data_axis3)\n",
        "        \n",
        "    Y_hat_axis2 = np.moveaxis(Y_hat_axis2,0,1)\n",
        "    Y_hat_axis3 = np.moveaxis(Y_hat_axis3,0,2)\n",
        "\n",
        "    Y_hat_average = np.maximum(np.maximum(Y_hat_axis1,Y_hat_axis2),Y_hat_axis3)/3\n",
        "    dice_acc=K.eval(dice_coef(Y_hat_average,image_data2))\n",
        "    dice_loss=1- dice_acc\n",
        "    print(dice_acc)\n",
        "\n",
        "    Y_hat_average_onehot = np.argmax(Y_hat_average,axis = -1)\n",
        "    Y_hat_average_onehot = keras.utils.to_categorical(Y_hat_average_onehot,num_classes=4)\n",
        "\n",
        "    get_sens_spec_df(Y_hat_average_onehot,image_data2)\n",
        "\n",
        "    mean_loss += dice_loss\n",
        "    mean_accu += dice_acc\n",
        "    \n",
        "print()\n",
        "print(\"Mean Dice Loss\" , mean_loss/30)\n",
        "print(\"Mean Dice Coefficient(Accuracy)\" , mean_accu/30)\n",
        "print()\n",
        "print(\"Mean Sensitivity for class 0\" , avg_sens[0]/30)\n",
        "print(\"Mean Specificity for class 0\" , avg_spec[0]/30)\n",
        "print()\n",
        "print(\"Mean Sensitivity for class 1\" , avg_sens[1]/30)\n",
        "print(\"Mean Specificity for class 1\" , avg_spec[1]/30)\n",
        "print()\n",
        "print(\"Mean Sensitivity for class 2\" , avg_sens[2]/30)\n",
        "print(\"Mean Specificity for class 2\" , avg_spec[2]/30)\n",
        "print()\n",
        "print(\"Mean Sensitivity for class 3\" , avg_sens[3]/30)\n",
        "print(\"Mean Specificity for class 3\" , avg_spec[3]/30)\n",
        "print()\n",
        "        \n",
        "    \n",
        "        \n",
        "         \n",
        "        "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Entering Image 180\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/opt/conda/lib/python3.7/site-packages/ipykernel_launcher.py:27: DeprecationWarning: get_data() is deprecated in favor of get_fdata(), which has a more predictable return type. To obtain get_data() behavior going forward, use numpy.asanyarray(img.dataobj).\n",
            "\n",
            "* deprecated from version: 3.0\n",
            "* Will raise <class 'nibabel.deprecator.ExpiredDeprecationError'> as of version: 5.0\n",
            "/opt/conda/lib/python3.7/site-packages/ipykernel_launcher.py:22: DeprecationWarning: get_data() is deprecated in favor of get_fdata(), which has a more predictable return type. To obtain get_data() behavior going forward, use numpy.asanyarray(img.dataobj).\n",
            "\n",
            "* deprecated from version: 3.0\n",
            "* Will raise <class 'nibabel.deprecator.ExpiredDeprecationError'> as of version: 5.0\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "0.3613948\n",
            "Entering Image 181\n",
            "0.54365546\n",
            "Entering Image 182\n",
            "0.3764307\n",
            "Entering Image 183\n",
            "0.5071401\n",
            "Entering Image 184\n",
            "0.3269897\n",
            "Entering Image 185\n",
            "0.4800731\n",
            "Entering Image 186\n",
            "0.44443768\n",
            "Entering Image 187\n",
            "0.5442215\n",
            "Entering Image 188\n",
            "0.4251073\n",
            "Entering Image 189\n",
            "0.33766252\n",
            "Entering Image 190\n",
            "0.39408684\n",
            "Entering Image 191\n",
            "0.48349178\n",
            "Entering Image 192\n",
            "0.5101219\n",
            "Entering Image 193\n",
            "0.470814\n",
            "Entering Image 194\n",
            "0.422185\n",
            "Entering Image 195\n",
            "0.5332395\n",
            "Entering Image 196\n",
            "0.47690552\n",
            "Entering Image 197\n",
            "0.36605856\n",
            "Entering Image 198\n",
            "0.50161356\n",
            "Entering Image 199\n",
            "0.5264089\n",
            "Entering Image 200\n",
            "0.44709092\n",
            "Entering Image 201\n",
            "0.51998997\n",
            "Entering Image 202\n",
            "0.44875357\n",
            "Entering Image 203\n",
            "0.54045844\n",
            "Entering Image 204\n",
            "0.38569903\n",
            "Entering Image 205\n",
            "0.4301867\n",
            "Entering Image 206\n",
            "0.4588433\n",
            "Entering Image 207\n",
            "0.28700173\n",
            "Entering Image 208\n",
            "0.5020062\n",
            "Entering Image 209\n",
            "0.54406226\n",
            "\n",
            "Mean Dice Loss 0.5467956513166428\n",
            "Mean Dice Coefficient(Accuracy) 0.45320434868335724\n",
            "\n",
            "Mean Sensitivity for class 0 0.9993326775309127\n",
            "Mean Specificity for class 0 0.7909022676987746\n",
            "\n",
            "Mean Sensitivity for class 1 0.37333702430247206\n",
            "Mean Specificity for class 1 0.9998774327369188\n",
            "\n",
            "Mean Sensitivity for class 2 0.6180197363479182\n",
            "Mean Specificity for class 2 0.9992300572007102\n",
            "\n",
            "Mean Sensitivity for class 3 0.8409394920705737\n",
            "Mean Specificity for class 3 0.9984759426996422\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "M77tW3dpXfzb",
        "colab_type": "code",
        "colab": {},
        "outputId": "498161a4-abda-4ac4-f403-05de23c55dd5"
      },
      "source": [
        "import nibabel as nib\n",
        "x = all_images[203]\n",
        "print(\"Results on image number 203\")\n",
        "folder_path = path + '/' + x;\n",
        "modalities = os.listdir(folder_path)\n",
        "modalities.sort()\n",
        "data = np.zeros((240,240,155,4))\n",
        "#data = []\n",
        "w = 0\n",
        "for j in range(len(modalities)):\n",
        "  #print(modalities[j])\n",
        "\n",
        "  image_path = folder_path + '/' + modalities[j]\n",
        "  if not(image_path.find('seg.nii') == -1):\n",
        "    img = nib.load(image_path);\n",
        "    image_data2 = img.get_data()\n",
        "    image_data2 = np.asarray(image_data2)\n",
        "    print(\"Entered ground truth\")\n",
        "  else:\n",
        "    img = nib.load(image_path);\n",
        "    image_data = img.get_data()\n",
        "    image_data = np.asarray(image_data)\n",
        "    image_data = standardize(image_data)\n",
        "    data[:,:,:,w] = image_data\n",
        "    print(\"Entered modality\")\n",
        "    w = w+1\n",
        "    \n",
        "    \n",
        "image_data2[image_data2 == 4] = 3\n",
        "\n",
        "data_axis1=data\n",
        "data_axis2=np.moveaxis(data,1,0)\n",
        "data_axis3=np.moveaxis(data,2,0)\n",
        "\n",
        "image_data2_axis1=image_data2\n",
        "image_data2_axis2=np.moveaxis(image_data2,1,0)\n",
        "image_data2_axis3=np.moveaxis(image_data2,2,0)\n",
        "\n",
        "Y_hat_axis1 = model_axis1.predict(x=data_axis1)\n",
        "Y_hat_axis2 = model_axis2.predict(x=data_axis2)\n",
        "Y_hat_axis3 = model_axis3.predict(x=data_axis3)\n",
        "\n",
        "Y_hat_axis2 = np.moveaxis(Y_hat_axis2,0,1)\n",
        "Y_hat_axis3 = np.moveaxis(Y_hat_axis3,0,2)\n",
        "\n",
        "Y_hat_average = np.maximum(np.maximum(Y_hat_axis1,Y_hat_axis2),Y_hat_axis3)/3\n",
        "\n",
        "Y_hat_average_onehot = np.argmax(Y_hat_average,axis = -1)\n",
        "\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "#import matplotlib.pyplot as plt\n",
        "img = data[:,:,75,0]\n",
        "imgplot = plt.imshow(img)\n",
        "plt.title('Flair Modality 75th slice alon')\n",
        "plt.savefig('Flair')\n",
        "plt.show()\n",
        "\n",
        "img2 = image_data2[:,:,75]\n",
        "imgplot2 = plt.imshow(img2)\n",
        "plt.title('Ground Truth of 75th slice')\n",
        "plt.savefig('Ground_Truth')\n",
        "plt.show()\n",
        "\n",
        "img3 = Y_hat_average_onehot[:,:,75]\n",
        "imgplot3 = plt.imshow(img3)\n",
        "plt.title('Our Segmentation -> 75th slice')\n",
        "plt.savefig('Our Segmentation')\n",
        "plt.show()\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Results on image number 203\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/opt/conda/lib/python3.7/site-packages/ipykernel_launcher.py:21: DeprecationWarning: get_data() is deprecated in favor of get_fdata(), which has a more predictable return type. To obtain get_data() behavior going forward, use numpy.asanyarray(img.dataobj).\n",
            "\n",
            "* deprecated from version: 3.0\n",
            "* Will raise <class 'nibabel.deprecator.ExpiredDeprecationError'> as of version: 5.0\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Entered modality\n",
            "Entered ground truth\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/opt/conda/lib/python3.7/site-packages/ipykernel_launcher.py:16: DeprecationWarning: get_data() is deprecated in favor of get_fdata(), which has a more predictable return type. To obtain get_data() behavior going forward, use numpy.asanyarray(img.dataobj).\n",
            "\n",
            "* deprecated from version: 3.0\n",
            "* Will raise <class 'nibabel.deprecator.ExpiredDeprecationError'> as of version: 5.0\n",
            "  app.launch_new_instance()\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Entered modality\n",
            "Entered modality\n",
            "Entered modality\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}