Tumor_Detection_ResUNet.ipynb

{"cells":[{"cell_type":"markdown","metadata":{"id":"8BnhlfxrlXte"},"source":["# Tumor Detection with Deep residual learning and UNet"]},{"cell_type":"code","execution_count":37,"metadata":{"executionInfo":{"elapsed":6,"status":"ok","timestamp":1649846156181,"user":{"displayName":"amasil zaidi","userId":"11575204533084856158"},"user_tz":-300},"id":"HVIXnzdGUU81"},"outputs":[],"source":[""]},{"cell_type":"markdown","metadata":{"id":"AvdAhjsGl-_h"},"source":["## Liberaries Installation"]},{"cell_type":"code","execution_count":38,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":4470,"status":"ok","timestamp":1649846160646,"user":{"displayName":"amasil zaidi","userId":"11575204533084856158"},"user_tz":-300},"id":"R5sS4HtZmeXH","outputId":"01e04462-4ffb-4648-f6a9-9e4d7fb80d3d"},"outputs":[{"name":"stdout","output_type":"stream","text":["Requirement already satisfied: pydicom in /usr/local/lib/python3.7/dist-packages (2.3.0)\n"]}],"source":["!pip install pydicom"]},{"cell_type":"code","execution_count":39,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":6404,"status":"ok","timestamp":1649846167028,"user":{"displayName":"amasil zaidi","userId":"11575204533084856158"},"user_tz":-300},"id":"jkJ2li04eXGZ","outputId":"1331ffce-9525-4258-f82e-da1c3f6355c6"},"outputs":[{"name":"stdout","output_type":"stream","text":["Requirement already satisfied: scikit-plot in /usr/local/lib/python3.7/dist-packages (0.3.7)\n","Requirement already satisfied: scipy\u003e=0.9 in /usr/local/lib/python3.7/dist-packages (from scikit-plot) (1.4.1)\n","Requirement already satisfied: scikit-learn\u003e=0.18 in /usr/local/lib/python3.7/dist-packages (from scikit-plot) (1.0.2)\n","Requirement already satisfied: joblib\u003e=0.10 in /usr/local/lib/python3.7/dist-packages (from scikit-plot) (1.1.0)\n","Requirement already satisfied: matplotlib\u003e=1.4.0 in /usr/local/lib/python3.7/dist-packages (from scikit-plot) (3.2.2)\n","Requirement already satisfied: numpy\u003e=1.11 in /usr/local/lib/python3.7/dist-packages (from matplotlib\u003e=1.4.0-\u003escikit-plot) (1.21.5)\n","Requirement already satisfied: cycler\u003e=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib\u003e=1.4.0-\u003escikit-plot) (0.11.0)\n","Requirement already satisfied: kiwisolver\u003e=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib\u003e=1.4.0-\u003escikit-plot) (1.4.0)\n","Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,\u003e=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib\u003e=1.4.0-\u003escikit-plot) (3.0.7)\n","Requirement already satisfied: python-dateutil\u003e=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib\u003e=1.4.0-\u003escikit-plot) (2.8.2)\n","Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from kiwisolver\u003e=1.0.1-\u003ematplotlib\u003e=1.4.0-\u003escikit-plot) (3.10.0.2)\n","Requirement already satisfied: six\u003e=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil\u003e=2.1-\u003ematplotlib\u003e=1.4.0-\u003escikit-plot) (1.15.0)\n","Requirement already satisfied: threadpoolctl\u003e=2.0.0 in /usr/local/lib/python3.7/dist-packages (from scikit-learn\u003e=0.18-\u003escikit-plot) (3.1.0)\n"]}],"source":["!pip install scikit-plot"]},{"cell_type":"code","execution_count":40,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":899,"status":"ok","timestamp":1649846167909,"user":{"displayName":"amasil zaidi","userId":"11575204533084856158"},"user_tz":-300},"id":"fTQ1qrsNYEXs","outputId":"9e5bfebe-11ec-4120-ad2a-6de1039ebc65"},"outputs":[{"name":"stdout","output_type":"stream","text":["Requirement already satisfied: tensorflow in /usr/local/lib/python3.7/dist-packages (2.8.0)\n","Requirement already satisfied: gast\u003e=0.2.1 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (0.5.3)\n","Requirement already satisfied: libclang\u003e=9.0.1 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (13.0.0)\n","Requirement already satisfied: typing-extensions\u003e=3.6.6 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (3.10.0.2)\n","Requirement already satisfied: wrapt\u003e=1.11.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (1.14.0)\n","Collecting tf-estimator-nightly==2.8.0.dev2021122109\n","  Downloading tf_estimator_nightly-2.8.0.dev2021122109-py2.py3-none-any.whl (462 kB)\n","\u001b[K     |████████████████████████████████| 462 kB 28.1 MB/s \n","\u001b[?25hRequirement already satisfied: keras-preprocessing\u003e=1.1.1 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (1.1.2)\n","Requirement already satisfied: termcolor\u003e=1.1.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (1.1.0)\n","Requirement already satisfied: astunparse\u003e=1.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (1.6.3)\n","Requirement already satisfied: tensorflow-io-gcs-filesystem\u003e=0.23.1 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (0.24.0)\n","Requirement already satisfied: protobuf\u003e=3.9.2 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (3.17.3)\n","Requirement already satisfied: tensorboard\u003c2.9,\u003e=2.8 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (2.8.0)\n","Requirement already satisfied: google-pasta\u003e=0.1.1 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (0.2.0)\n","Requirement already satisfied: grpcio\u003c2.0,\u003e=1.24.3 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (1.44.0)\n","Requirement already satisfied: flatbuffers\u003e=1.12 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (2.0)\n","Requirement already satisfied: absl-py\u003e=0.4.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (1.0.0)\n","Requirement already satisfied: numpy\u003e=1.20 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (1.21.5)\n","Requirement already satisfied: keras\u003c2.9,\u003e=2.8.0rc0 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (2.8.0)\n","Requirement already satisfied: h5py\u003e=2.9.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (3.1.0)\n","Requirement already satisfied: opt-einsum\u003e=2.3.2 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (3.3.0)\n","Requirement already satisfied: six\u003e=1.12.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow) (1.15.0)\n","Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from tensorflow) (57.4.0)\n","Requirement already satisfied: wheel\u003c1.0,\u003e=0.23.0 in /usr/local/lib/python3.7/dist-packages (from astunparse\u003e=1.6.0-\u003etensorflow) (0.37.1)\n","Requirement already satisfied: cached-property in /usr/local/lib/python3.7/dist-packages (from h5py\u003e=2.9.0-\u003etensorflow) (1.5.2)\n","Requirement already satisfied: markdown\u003e=2.6.8 in /usr/local/lib/python3.7/dist-packages (from tensorboard\u003c2.9,\u003e=2.8-\u003etensorflow) (3.3.6)\n","Requirement already satisfied: tensorboard-plugin-wit\u003e=1.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard\u003c2.9,\u003e=2.8-\u003etensorflow) (1.8.1)\n","Requirement already satisfied: tensorboard-data-server\u003c0.7.0,\u003e=0.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard\u003c2.9,\u003e=2.8-\u003etensorflow) (0.6.1)\n","Requirement already satisfied: google-auth\u003c3,\u003e=1.6.3 in /usr/local/lib/python3.7/dist-packages (from tensorboard\u003c2.9,\u003e=2.8-\u003etensorflow) (1.35.0)\n","Requirement already satisfied: werkzeug\u003e=0.11.15 in /usr/local/lib/python3.7/dist-packages (from tensorboard\u003c2.9,\u003e=2.8-\u003etensorflow) (1.0.1)\n","Requirement already satisfied: google-auth-oauthlib\u003c0.5,\u003e=0.4.1 in /usr/local/lib/python3.7/dist-packages (from tensorboard\u003c2.9,\u003e=2.8-\u003etensorflow) (0.4.6)\n","Requirement already satisfied: requests\u003c3,\u003e=2.21.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard\u003c2.9,\u003e=2.8-\u003etensorflow) (2.23.0)\n","Requirement already satisfied: cachetools\u003c5.0,\u003e=2.0.0 in /usr/local/lib/python3.7/dist-packages (from google-auth\u003c3,\u003e=1.6.3-\u003etensorboard\u003c2.9,\u003e=2.8-\u003etensorflow) (4.2.4)\n","Requirement already satisfied: pyasn1-modules\u003e=0.2.1 in /usr/local/lib/python3.7/dist-packages (from google-auth\u003c3,\u003e=1.6.3-\u003etensorboard\u003c2.9,\u003e=2.8-\u003etensorflow) (0.2.8)\n","Requirement already satisfied: rsa\u003c5,\u003e=3.1.4 in /usr/local/lib/python3.7/dist-packages (from google-auth\u003c3,\u003e=1.6.3-\u003etensorboard\u003c2.9,\u003e=2.8-\u003etensorflow) (4.8)\n","Requirement already satisfied: requests-oauthlib\u003e=0.7.0 in /usr/local/lib/python3.7/dist-packages (from google-auth-oauthlib\u003c0.5,\u003e=0.4.1-\u003etensorboard\u003c2.9,\u003e=2.8-\u003etensorflow) (1.3.1)\n","Requirement already satisfied: importlib-metadata\u003e=4.4 in /usr/local/lib/python3.7/dist-packages (from markdown\u003e=2.6.8-\u003etensorboard\u003c2.9,\u003e=2.8-\u003etensorflow) (4.11.3)\n","Requirement already satisfied: zipp\u003e=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata\u003e=4.4-\u003emarkdown\u003e=2.6.8-\u003etensorboard\u003c2.9,\u003e=2.8-\u003etensorflow) (3.7.0)\n","Requirement already satisfied: pyasn1\u003c0.5.0,\u003e=0.4.6 in /usr/local/lib/python3.7/dist-packages (from pyasn1-modules\u003e=0.2.1-\u003egoogle-auth\u003c3,\u003e=1.6.3-\u003etensorboard\u003c2.9,\u003e=2.8-\u003etensorflow) (0.4.8)\n","Requirement already satisfied: idna\u003c3,\u003e=2.5 in /usr/local/lib/python3.7/dist-packages (from requests\u003c3,\u003e=2.21.0-\u003etensorboard\u003c2.9,\u003e=2.8-\u003etensorflow) (2.10)\n","Requirement already satisfied: chardet\u003c4,\u003e=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests\u003c3,\u003e=2.21.0-\u003etensorboard\u003c2.9,\u003e=2.8-\u003etensorflow) (3.0.4)\n","Requirement already satisfied: certifi\u003e=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests\u003c3,\u003e=2.21.0-\u003etensorboard\u003c2.9,\u003e=2.8-\u003etensorflow) (2021.10.8)\n","Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,\u003c1.26,\u003e=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests\u003c3,\u003e=2.21.0-\u003etensorboard\u003c2.9,\u003e=2.8-\u003etensorflow) (1.24.3)\n","Requirement already satisfied: oauthlib\u003e=3.0.0 in /usr/local/lib/python3.7/dist-packages (from requests-oauthlib\u003e=0.7.0-\u003egoogle-auth-oauthlib\u003c0.5,\u003e=0.4.1-\u003etensorboard\u003c2.9,\u003e=2.8-\u003etensorflow) (3.2.0)\n","Installing collected packages: tf-estimator-nightly\n","Successfully installed tf-estimator-nightly-2.8.0.dev2021122109\n"]}],"source":["!pip install tensorflow"]},{"cell_type":"markdown","metadata":{"id":"UMQ70OfVmKO-"},"source":["## Drive Mount\n"]},{"cell_type":"code","execution_count":41,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":5181,"status":"ok","timestamp":1649846173079,"user":{"displayName":"amasil zaidi","userId":"11575204533084856158"},"user_tz":-300},"id":"YFUDmY7IlWJS","outputId":"824b7a3e-6400-43b1-fa4f-2e03e5230abc"},"outputs":[{"name":"stdout","output_type":"stream","text":["Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"]}],"source":["from google.colab import drive\n","drive.mount('/content/drive')"]},{"cell_type":"markdown","metadata":{"id":"DsmSDWYMl5vh"},"source":["\n","\n","```\n","# This is formatted as code\n","```\n","\n","## Import Liberaries"]},{"cell_type":"code","execution_count":42,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":39,"status":"ok","timestamp":1649846173080,"user":{"displayName":"amasil zaidi","userId":"11575204533084856158"},"user_tz":-300},"id":"LD9kKqjVsP6f","outputId":"d543766d-b894-43ba-c461-8f8ee6ad18ed"},"outputs":[{"name":"stderr","output_type":"stream","text":["/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:30: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n","Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n"]}],"source":["import os, glob\n","import sys\n","import copy \n","import pydicom\n","import random\n","import re\n","import scipy\n","import scipy.misc\n","import numpy as np\n","import cv2\n","import imageio\n","import seaborn as sns\n","import matplotlib.pyplot as plt\n","from PIL import Image, ImageEnhance\n","import tensorflow.compat.v1 as tf\n","from tensorflow import keras\n","from scipy.ndimage import rotate\n","from skimage import exposure\n","from sklearn.metrics import confusion_matrix\n","from operator import add \n","plt.set_cmap('gray')\n","%matplotlib inline\n","## Seeding \n","seed = 2019\n","random.seed = seed\n","np.random.seed = seed\n","tf.seed = seed\n","\n","\n","IMG_DTYPE = np.float\n","SEG_DTYPE = np.uint8\n"]},{"cell_type":"code","execution_count":43,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":38,"status":"ok","timestamp":1649846173086,"user":{"displayName":"amasil zaidi","userId":"11575204533084856158"},"user_tz":-300},"id":"QYNQMMrOsP6m","outputId":"574d674f-71a8-4937-d012-4103bbee02fc"},"outputs":[{"name":"stdout","output_type":"stream","text":["Please install GPU version of TF\n"]}],"source":["if tf.test.gpu_device_name():\n","    print('Default GPU Device: {}'.format(tf.test.gpu_device_name()))\n","else:\n","    print(\"Please install GPU version of TF\")"]},{"cell_type":"markdown","metadata":{"id":"syVQuyditXQt"},"source":["\n","\n","```\n","# This is formatted as code\n","```\n","\n","# Access Dataset Path"]},{"cell_type":"code","execution_count":44,"metadata":{"executionInfo":{"elapsed":33,"status":"ok","timestamp":1649846173087,"user":{"displayName":"amasil zaidi","userId":"11575204533084856158"},"user_tz":-300},"id":"t8VLgOiRsP6n"},"outputs":[],"source":["masks_path = os.path.join('/content/drive/MyDrive/Dataset/train','masks')\n","training_path = os.path.join('/content/drive/MyDrive/Dataset/train','patients')"]},{"cell_type":"markdown","metadata":{"id":"a9UZuMzro90K"},"source":["## Image Visualization funtions\n","\n","\u003e Indented block\n","\n"]},{"cell_type":"code","execution_count":45,"metadata":{"executionInfo":{"elapsed":33,"status":"ok","timestamp":1649846173087,"user":{"displayName":"amasil zaidi","userId":"11575204533084856158"},"user_tz":-300},"id":"ETgPh-octrCa"},"outputs":[],"source":["def displayimage(*args,**kwargs):\n","    cmap = kwargs.get('cmap', 'gray')\n","    title= kwargs.get('title','')\n","    if len(args)==0:\n","        raise ValueError(\"No images given to imshow\")\n","    elif len(args)==1:\n","        plt.title(title)\n","        plt.imshow(args[0], interpolation='none')\n","    else:\n","        n=len(args)\n","        if type(cmap)==str:\n","            cmap = [cmap]*n\n","        if type(title)==str:\n","            title= [title]*n\n","        plt.figure(figsize=(n*5,10))\n","        for i in range(n):\n","            plt.subplot(1,n,i+1)\n","            plt.title(title[i])\n","            plt.imshow(args[i], cmap[i])\n","    plt.show()"]},{"cell_type":"markdown","metadata":{"id":"unxng09DtviS"},"source":["# Image Preprocessing Functions"]},{"cell_type":"code","execution_count":46,"metadata":{"executionInfo":{"elapsed":33,"status":"ok","timestamp":1649846173088,"user":{"displayName":"amasil zaidi","userId":"11575204533084856158"},"user_tz":-300},"id":"fqJPjJ8AsP6o"},"outputs":[],"source":["def imagenormalization(img):\n","    \"\"\" Normalize image values to [0,1] \"\"\"\n","    min_, max_ = float(np.min(img)), float(np.max(img))\n","    return (img - min_) / (max_ - min_)\n","\n","def dice(im1, im2):\n","\n","    im1 = np.asarray(im1).astype(np.bool)\n","    im2 = np.asarray(im2).astype(np.bool)\n","\n","    if im1.shape != im2.shape:\n","        raise ValueError(\"Shape mismatch: im1 and im2 must have the same shape.\")\n","\n","    intersection = np.logical_and(im1, im2)\n","\n","    return 2. * intersection.sum() / (im1.sum() + im2.sum())"]},{"cell_type":"markdown","metadata":{"id":"05nBIWfNpfjN"},"source":["# Image Data Aqcuisition and Preprocessing\n","\n"]},{"cell_type":"code","execution_count":47,"metadata":{"executionInfo":{"elapsed":32,"status":"ok","timestamp":1649846173089,"user":{"displayName":"amasil zaidi","userId":"11575204533084856158"},"user_tz":-300},"id":"JaMIuJMSsP6p"},"outputs":[],"source":["class DataGen(keras.utils.Sequence):\n","\n","\n","    def __init__(self, ids, path, batch_size=8, image_size=128):\n","        self.ids = ids\n","        self.path = path\n","        self.batch_size = batch_size\n","        self.image_size = image_size\n","        self.on_epoch_end()\n","\n","    def image_preprocessing(self,image_sliced):   \n","        image_sliced[image_sliced\u003e1200] = 0\n","        image_sliced   = np.clip(image_sliced, -100, 400)\n","        image_sliced = imagenormalization(image_sliced)\n","\n","    \n","        image_sliced = image_sliced * 255\n","        image_sliced = image_sliced.astype('uint8')\n","        image_sliced = cv2.equalizeHist(image_sliced)\n","        image_sliced = imagenormalization(image_sliced)\n","        return image_sliced\n","        \n","    def __load__(self, id_name):\n","        patient_id = id_name.split('_')\n","        image_path = os.path.join(self.path,\"patients\", id_name)\n","        mask_path = os.path.join(self.path,\"masks\")\n","        all_masks = os.listdir(mask_path)\n","        dicom_image = pydicom.dcmread(image_path)\n","        image = self.image_preprocessing(dicom_image.pixel_array)\n","        image = imagenormalization(image)\n","        image = np.array(Image.fromarray(image).resize([image_size, image_size])).astype(IMG_DTYPE)\n","        \n","        mask = pydicom.dcmread(os.path.join(mask_path,patient_id[0]+'_liver' , id_name)).pixel_array\n","        mask = mask/255.0\n","        mask = np.clip(mask, 0, 1)\n","        mask = np.array(Image.fromarray(mask).resize([image_size, image_size])).astype(IMG_DTYPE)\n","        mask = mask[:, :, np.newaxis]\n","        return image, mask\n","    \n","    def __getitem__(self, index):\n","        if(index+1)*self.batch_size \u003e len(self.ids):\n","            self.batch_size = len(self.ids) - index*self.batch_size\n","        \n","        files_batch = self.ids[index*self.batch_size : (index+1)*self.batch_size]\n","\n","        image = []\n","        mask  = []\n","    \n","        for id_name in files_batch:\n","            _img, _mask = self.__load__(id_name)\n","            _img = np.stack((_img,)*3, axis=-1)\n","            image.append(_img)\n","            mask.append(_mask)\n","        \n","        image = np.array(image)\n","        mask  = np.array(mask)\n","\n","        return image, mask\n","    \n","    def on_epoch_end(self):\n","        pass\n","    \n","    def __len__(self):\n","        return int(np.ceil(len(self.ids)/float(self.batch_size)))\n","    \n"]},{"cell_type":"code","execution_count":48,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":32,"status":"ok","timestamp":1649846173089,"user":{"displayName":"amasil zaidi","userId":"11575204533084856158"},"user_tz":-300},"id":"1pmA4iAWsP6q","outputId":"5636f86e-bea5-4892-d2e6-bde23c0c301d"},"outputs":[{"name":"stdout","output_type":"stream","text":["585\n"]}],"source":["image_size =  256\n","train_path = \"/content/drive/MyDrive/Dataset/train\"\n","batch_size = 8\n","epochs = 50\n","## Training Ids\n","images = []\n","for file in os.listdir(os.path.join(train_path, \"patients\")):\n","\n","    images.append(file)\n","\n","\n","## Validation Data Size\n","val_data_size = len(images)//5 # 20% validation Data\n","# factor = 0\n","valid_ids = images[:val_data_size]\n","train_ids = images[val_data_size:]\n","print(len(train_ids))"]},{"cell_type":"markdown","metadata":{"id":"1gF9VQZMuPms"},"source":["# Image Slicing Function"]},{"cell_type":"code","execution_count":49,"metadata":{"executionInfo":{"elapsed":30,"status":"ok","timestamp":1649846173090,"user":{"displayName":"amasil zaidi","userId":"11575204533084856158"},"user_tz":-300},"id":"0JJY43eUsP6q"},"outputs":[],"source":["def step1_preprocess_img_slice(img_slc):  \n","    img_slc[img_slc\u003e1200] = 0\n","    img_slc   = np.clip(img_slc, -100, 400)\n","    img_slc = imagenormalization(img_slc)\n","\n","    \n","    img_slc = img_slc * 255\n","    img_slc = img_slc.astype('uint8')\n","    img_slc = cv2.equalizeHist(img_slc)\n","    img_slc = imagenormalization(img_slc)\n","    return img_slc\n"]},{"cell_type":"code","execution_count":50,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":29,"status":"ok","timestamp":1649846173090,"user":{"displayName":"amasil zaidi","userId":"11575204533084856158"},"user_tz":-300},"id":"8HJFdME_ef_5","outputId":"ca35c859-b44d-4019-bc41-b6e09156e95f","scrolled":true},"outputs":[{"name":"stdout","output_type":"stream","text":["(8, 256, 256, 3) (8, 256, 256, 1)\n"]}],"source":["gen = DataGen(train_ids, train_path, batch_size=batch_size, image_size=image_size)\n","x, y = gen.__getitem__(0)\n","print(x.shape,y.shape)"]},{"cell_type":"markdown","metadata":{"id":"XyHKo79aqL1y"},"source":["## Image visalization with Segmentation"]},{"cell_type":"code","execution_count":51,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":336},"executionInfo":{"elapsed":9711,"status":"ok","timestamp":1649846182775,"user":{"displayName":"amasil zaidi","userId":"11575204533084856158"},"user_tz":-300},"id":"NoeOFZNIef_6","outputId":"11cb1e85-d0e1-4a16-be2f-8ed63bc4882a"},"outputs":[{"name":"stderr","output_type":"stream","text":["Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"]},{"name":"stdout","output_type":"stream","text":["0\n"]},{"data":{"text/plain":["\u003cmatplotlib.image.AxesImage at 0x7fbf68f19390\u003e"]},"execution_count":51,"metadata":{},"output_type":"execute_result"},{"data":{"image/png":"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\n","text/plain":["\u003cFigure size 720x720 with 2 Axes\u003e"]},"metadata":{},"output_type":"display_data"}],"source":["r = random.randint(0, len(x)-1)\n","r = 0\n","fig = plt.figure(figsize=(10, 10))\n","fig.subplots_adjust(hspace=0.4, wspace=0.4)\n","ax = fig.add_subplot(1, 2, 1)\n","ax.imshow(x[r])\n","print(r)\n","ax = fig.add_subplot(1, 2, 2)\n","ax.imshow(np.reshape(y[r], (image_size, image_size)), cmap=\"gray\")"]},{"cell_type":"markdown","metadata":{"id":"NHwuroEsqyGh"},"source":["# Convolutional Neural Network Implimentation\n","\n","1.   List item\n","2.   List item\n","\n"]},{"cell_type":"markdown","metadata":{"id":"4HjRwXCRqHJy"},"source":["## Model Configration"]},{"cell_type":"code","execution_count":52,"metadata":{"executionInfo":{"elapsed":20,"status":"ok","timestamp":1649846182777,"user":{"displayName":"amasil zaidi","userId":"11575204533084856158"},"user_tz":-300},"id":"ija8SlszsP6u"},"outputs":[],"source":["def bn_act(x, act=True):\n","    x = keras.layers.BatchNormalization()(x)\n","    if act == True:\n","        x = keras.layers.Activation(\"relu\")(x)\n","    return x\n","\n","def conv_block(x, filters, kernel_size=(3, 3), padding=\"same\", strides=1):\n","    conv = bn_act(x)\n","    conv = keras.layers.Conv2D(filters, kernel_size, padding=padding, strides=strides)(conv)\n","    return conv\n","\n","def stem(x, filters, kernel_size=(3, 3), padding=\"same\", strides=1):\n","    conv = keras.layers.Conv2D(filters, kernel_size, padding=padding, strides=strides)(x)\n","    conv = conv_block(conv, filters, kernel_size=kernel_size, padding=padding, strides=strides)\n","    \n","    shortcut = keras.layers.Conv2D(filters, kernel_size=(1, 1), padding=padding, strides=strides)(x)\n","    shortcut = bn_act(shortcut, act=False)\n","    \n","    output = keras.layers.Add()([conv, shortcut])\n","    return output\n","\n","def residual_block(x, filters, kernel_size=(3, 3), padding=\"same\", strides=1):\n","    res = conv_block(x, filters, kernel_size=kernel_size, padding=padding, strides=strides)\n","    res = conv_block(res, filters, kernel_size=kernel_size, padding=padding, strides=1)\n","    \n","    shortcut = keras.layers.Conv2D(filters, kernel_size=(1, 1), padding=padding, strides=strides)(x)\n","    shortcut = bn_act(shortcut, act=False)\n","    \n","    output = keras.layers.Add()([shortcut, res])\n","    return output\n","\n","def upsample_concat_block(x, xskip):\n","    u = keras.layers.UpSampling2D((2, 2))(x)\n","    c = keras.layers.Concatenate()([u, xskip])\n","    return c"]},{"cell_type":"code","execution_count":53,"metadata":{"executionInfo":{"elapsed":23,"status":"ok","timestamp":1649846182782,"user":{"displayName":"amasil zaidi","userId":"11575204533084856158"},"user_tz":-300},"id":"i00yiCsQsP6v"},"outputs":[],"source":["def ResUNet():\n","    f = [16, 32, 64, 128, 256]\n","    inputs = keras.layers.Input((image_size, image_size, 3))\n","    \n","    ## Encoder\n","    e0 = inputs\n","    e1 = stem(e0, f[0])\n","    e2 = residual_block(e1, f[1], strides=2)\n","    e3 = residual_block(e2, f[2], strides=2)\n","    e4 = residual_block(e3, f[3], strides=2)\n","    e5 = residual_block(e4, f[4], strides=2)\n","    \n","    ## Bridge\n","    b0 = conv_block(e5, f[4], strides=1)\n","    b1 = conv_block(b0, f[4], strides=1)\n","    \n","    ## Decoder\n","    u1 = upsample_concat_block(b1, e4)\n","    d1 = residual_block(u1, f[4])\n","    \n","    u2 = upsample_concat_block(d1, e3)\n","    d2 = residual_block(u2, f[3])\n","    \n","    u3 = upsample_concat_block(d2, e2)\n","    d3 = residual_block(u3, f[2])\n","    \n","    u4 = upsample_concat_block(d3, e1)\n","    d4 = residual_block(u4, f[1])\n","    \n","    outputs = keras.layers.Conv2D(1, (1, 1), padding=\"same\", activation=\"sigmoid\")(d4)\n","    model = keras.models.Model(inputs, outputs)\n","    return model"]},{"cell_type":"code","execution_count":54,"metadata":{"executionInfo":{"elapsed":29,"status":"ok","timestamp":1649846182789,"user":{"displayName":"amasil zaidi","userId":"11575204533084856158"},"user_tz":-300},"id":"0tu7DsZQsP6v"},"outputs":[],"source":["smooth = 1.\n","\n","def dice_coef(y_true, y_pred):\n","    y_true_f = tf.layers.flatten(y_true)\n","    y_pred_f = tf.layers.flatten(y_pred)\n","    intersection = tf.reduce_sum(y_true_f * y_pred_f)\n","    return (2. * intersection + smooth) / (tf.reduce_sum(y_true_f) + tf.reduce_sum(y_pred_f) + smooth)\n","\n","\n","def dice_coef_loss(y_true, y_pred):\n","    return 1.0 - dice_coef(y_true, y_pred)"]},{"cell_type":"code","execution_count":55,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":2789,"status":"ok","timestamp":1649846185550,"user":{"displayName":"amasil zaidi","userId":"11575204533084856158"},"user_tz":-300},"id":"SQ34JAmcef_7","outputId":"f89ea1ed-0a96-4911-e4c9-c8179b481518"},"outputs":[{"name":"stdout","output_type":"stream","text":["Model: \"model_6\"\n","__________________________________________________________________________________________________\n"," Layer (type)                   Output Shape         Param #     Connected to                     \n","==================================================================================================\n"," input_7 (InputLayer)           [(None, 256, 256, 3  0           []                               \n","                                )]                                                                \n","                                                                                                  \n"," conv2d_180 (Conv2D)            (None, 256, 256, 16  448         ['input_7[0][0]']                \n","                                )                                                                 \n","                                                                                                  \n"," batch_normalization_168 (Batch  (None, 256, 256, 16  64         ['conv2d_180[0][0]']             \n"," Normalization)                 )                                                                 \n","                                                                                                  \n"," activation_114 (Activation)    (None, 256, 256, 16  0           ['batch_normalization_168[0][0]']\n","                                )                                                                 \n","                                                                                                  \n"," conv2d_182 (Conv2D)            (None, 256, 256, 16  64          ['input_7[0][0]']                \n","                                )                                                                 \n","                                                                                                  \n"," conv2d_181 (Conv2D)            (None, 256, 256, 16  2320        ['activation_114[0][0]']         \n","                                )                                                                 \n","                                                                                                  \n"," batch_normalization_169 (Batch  (None, 256, 256, 16  64         ['conv2d_182[0][0]']             \n"," Normalization)                 )                                                                 \n","                                                                                                  \n"," add_54 (Add)                   (None, 256, 256, 16  0           ['conv2d_181[0][0]',             \n","                                )                                 'batch_normalization_169[0][0]']\n","                                                                                                  \n"," batch_normalization_170 (Batch  (None, 256, 256, 16  64         ['add_54[0][0]']                 \n"," Normalization)                 )                                                                 \n","                                                                                                  \n"," activation_115 (Activation)    (None, 256, 256, 16  0           ['batch_normalization_170[0][0]']\n","                                )                                                                 \n","                                                                                                  \n"," conv2d_183 (Conv2D)            (None, 128, 128, 32  4640        ['activation_115[0][0]']         \n","                                )                                                                 \n","                                                                                                  \n"," batch_normalization_171 (Batch  (None, 128, 128, 32  128        ['conv2d_183[0][0]']             \n"," Normalization)                 )                                                                 \n","                                                                                                  \n"," conv2d_185 (Conv2D)            (None, 128, 128, 32  544         ['add_54[0][0]']                 \n","                                )                                                                 \n","                                                                                                  \n"," activation_116 (Activation)    (None, 128, 128, 32  0           ['batch_normalization_171[0][0]']\n","                                )                                                                 \n","                                                                                                  \n"," batch_normalization_172 (Batch  (None, 128, 128, 32  128        ['conv2d_185[0][0]']             \n"," Normalization)                 )                                                                 \n","                                                                                                  \n"," conv2d_184 (Conv2D)            (None, 128, 128, 32  9248        ['activation_116[0][0]']         \n","                                )                                                                 \n","                                                                                                  \n"," add_55 (Add)                   (None, 128, 128, 32  0           ['batch_normalization_172[0][0]',\n","                                )                                 'conv2d_184[0][0]']             \n","                                                                                                  \n"," batch_normalization_173 (Batch  (None, 128, 128, 32  128        ['add_55[0][0]']                 \n"," Normalization)                 )                                                                 \n","                                                                                                  \n"," activation_117 (Activation)    (None, 128, 128, 32  0           ['batch_normalization_173[0][0]']\n","                                )                                                                 \n","                                                                                                  \n"," conv2d_186 (Conv2D)            (None, 64, 64, 64)   18496       ['activation_117[0][0]']         \n","                                                                                                  \n"," batch_normalization_174 (Batch  (None, 64, 64, 64)  256         ['conv2d_186[0][0]']             \n"," Normalization)                                                                                   \n","                                                                                                  \n"," conv2d_188 (Conv2D)            (None, 64, 64, 64)   2112        ['add_55[0][0]']                 \n","                                                                                                  \n"," activation_118 (Activation)    (None, 64, 64, 64)   0           ['batch_normalization_174[0][0]']\n","                                                                                                  \n"," batch_normalization_175 (Batch  (None, 64, 64, 64)  256         ['conv2d_188[0][0]']             \n"," Normalization)                                                                                   \n","                                                                                                  \n"," conv2d_187 (Conv2D)            (None, 64, 64, 64)   36928       ['activation_118[0][0]']         \n","                                                                                                  \n"," add_56 (Add)                   (None, 64, 64, 64)   0           ['batch_normalization_175[0][0]',\n","                                                                  'conv2d_187[0][0]']             \n","                                                                                                  \n"," batch_normalization_176 (Batch  (None, 64, 64, 64)  256         ['add_56[0][0]']                 \n"," Normalization)                                                                                   \n","                                                                                                  \n"," activation_119 (Activation)    (None, 64, 64, 64)   0           ['batch_normalization_176[0][0]']\n","                                                                                                  \n"," conv2d_189 (Conv2D)            (None, 32, 32, 128)  73856       ['activation_119[0][0]']         \n","                                                                                                  \n"," batch_normalization_177 (Batch  (None, 32, 32, 128)  512        ['conv2d_189[0][0]']             \n"," Normalization)                                                                                   \n","                                                                                                  \n"," conv2d_191 (Conv2D)            (None, 32, 32, 128)  8320        ['add_56[0][0]']                 \n","                                                                                                  \n"," activation_120 (Activation)    (None, 32, 32, 128)  0           ['batch_normalization_177[0][0]']\n","                                                                                                  \n"," batch_normalization_178 (Batch  (None, 32, 32, 128)  512        ['conv2d_191[0][0]']             \n"," Normalization)                                                                                   \n","                                                                                                  \n"," conv2d_190 (Conv2D)            (None, 32, 32, 128)  147584      ['activation_120[0][0]']         \n","                                                                                                  \n"," add_57 (Add)                   (None, 32, 32, 128)  0           ['batch_normalization_178[0][0]',\n","                                                                  'conv2d_190[0][0]']             \n","                                                                                                  \n"," batch_normalization_179 (Batch  (None, 32, 32, 128)  512        ['add_57[0][0]']                 \n"," Normalization)                                                                                   \n","                                                                                                  \n"," activation_121 (Activation)    (None, 32, 32, 128)  0           ['batch_normalization_179[0][0]']\n","                                                                                                  \n"," conv2d_192 (Conv2D)            (None, 16, 16, 256)  295168      ['activation_121[0][0]']         \n","                                                                                                  \n"," batch_normalization_180 (Batch  (None, 16, 16, 256)  1024       ['conv2d_192[0][0]']             \n"," Normalization)                                                                                   \n","                                                                                                  \n"," conv2d_194 (Conv2D)            (None, 16, 16, 256)  33024       ['add_57[0][0]']                 \n","                                                                                                  \n"," activation_122 (Activation)    (None, 16, 16, 256)  0           ['batch_normalization_180[0][0]']\n","                                                                                                  \n"," batch_normalization_181 (Batch  (None, 16, 16, 256)  1024       ['conv2d_194[0][0]']             \n"," Normalization)                                                                                   \n","                                                                                                  \n"," conv2d_193 (Conv2D)            (None, 16, 16, 256)  590080      ['activation_122[0][0]']         \n","                                                                                                  \n"," add_58 (Add)                   (None, 16, 16, 256)  0           ['batch_normalization_181[0][0]',\n","                                                                  'conv2d_193[0][0]']             \n","                                                                                                  \n"," batch_normalization_182 (Batch  (None, 16, 16, 256)  1024       ['add_58[0][0]']                 \n"," Normalization)                                                                                   \n","                                                                                                  \n"," activation_123 (Activation)    (None, 16, 16, 256)  0           ['batch_normalization_182[0][0]']\n","                                                                                                  \n"," conv2d_195 (Conv2D)            (None, 16, 16, 256)  590080      ['activation_123[0][0]']         \n","                                                                                                  \n"," batch_normalization_183 (Batch  (None, 16, 16, 256)  1024       ['conv2d_195[0][0]']             \n"," Normalization)                                                                                   \n","                                                                                                  \n"," activation_124 (Activation)    (None, 16, 16, 256)  0           ['batch_normalization_183[0][0]']\n","                                                                                                  \n"," conv2d_196 (Conv2D)            (None, 16, 16, 256)  590080      ['activation_124[0][0]']         \n","                                                                                                  \n"," up_sampling2d_24 (UpSampling2D  (None, 32, 32, 256)  0          ['conv2d_196[0][0]']             \n"," )                                                                                                \n","                                                                                                  \n"," concatenate_24 (Concatenate)   (None, 32, 32, 384)  0           ['up_sampling2d_24[0][0]',       \n","                                                                  'add_57[0][0]']                 \n","                                                                                                  \n"," batch_normalization_184 (Batch  (None, 32, 32, 384)  1536       ['concatenate_24[0][0]']         \n"," Normalization)                                                                                   \n","                                                                                                  \n"," activation_125 (Activation)    (None, 32, 32, 384)  0           ['batch_normalization_184[0][0]']\n","                                                                                                  \n"," conv2d_197 (Conv2D)            (None, 32, 32, 256)  884992      ['activation_125[0][0]']         \n","                                                                                                  \n"," batch_normalization_185 (Batch  (None, 32, 32, 256)  1024       ['conv2d_197[0][0]']             \n"," Normalization)                                                                                   \n","                                                                                                  \n"," conv2d_199 (Conv2D)            (None, 32, 32, 256)  98560       ['concatenate_24[0][0]']         \n","                                                                                                  \n"," activation_126 (Activation)    (None, 32, 32, 256)  0           ['batch_normalization_185[0][0]']\n","                                                                                                  \n"," batch_normalization_186 (Batch  (None, 32, 32, 256)  1024       ['conv2d_199[0][0]']             \n"," Normalization)                                                                                   \n","                                                                                                  \n"," conv2d_198 (Conv2D)            (None, 32, 32, 256)  590080      ['activation_126[0][0]']         \n","                                                                                                  \n"," add_59 (Add)                   (None, 32, 32, 256)  0           ['batch_normalization_186[0][0]',\n","                                                                  'conv2d_198[0][0]']             \n","                                                                                                  \n"," up_sampling2d_25 (UpSampling2D  (None, 64, 64, 256)  0          ['add_59[0][0]']                 \n"," )                                                                                                \n","                                                                                                  \n"," concatenate_25 (Concatenate)   (None, 64, 64, 320)  0           ['up_sampling2d_25[0][0]',       \n","                                                                  'add_56[0][0]']                 \n","                                                                                                  \n"," batch_normalization_187 (Batch  (None, 64, 64, 320)  1280       ['concatenate_25[0][0]']         \n"," Normalization)                                                                                   \n","                                                                                                  \n"," activation_127 (Activation)    (None, 64, 64, 320)  0           ['batch_normalization_187[0][0]']\n","                                                                                                  \n"," conv2d_200 (Conv2D)            (None, 64, 64, 128)  368768      ['activation_127[0][0]']         \n","                                                                                                  \n"," batch_normalization_188 (Batch  (None, 64, 64, 128)  512        ['conv2d_200[0][0]']             \n"," Normalization)                                                                                   \n","                                                                                                  \n"," conv2d_202 (Conv2D)            (None, 64, 64, 128)  41088       ['concatenate_25[0][0]']         \n","                                                                                                  \n"," activation_128 (Activation)    (None, 64, 64, 128)  0           ['batch_normalization_188[0][0]']\n","                                                                                                  \n"," batch_normalization_189 (Batch  (None, 64, 64, 128)  512        ['conv2d_202[0][0]']             \n"," Normalization)                                                                                   \n","                                                                                                  \n"," conv2d_201 (Conv2D)            (None, 64, 64, 128)  147584      ['activation_128[0][0]']         \n","                                                                                                  \n"," add_60 (Add)                   (None, 64, 64, 128)  0           ['batch_normalization_189[0][0]',\n","                                                                  'conv2d_201[0][0]']             \n","                                                                                                  \n"," up_sampling2d_26 (UpSampling2D  (None, 128, 128, 12  0          ['add_60[0][0]']                 \n"," )                              8)                                                                \n","                                                                                                  \n"," concatenate_26 (Concatenate)   (None, 128, 128, 16  0           ['up_sampling2d_26[0][0]',       \n","                                0)                                'add_55[0][0]']                 \n","                                                                                                  \n"," batch_normalization_190 (Batch  (None, 128, 128, 16  640        ['concatenate_26[0][0]']         \n"," Normalization)                 0)                                                                \n","                                                                                                  \n"," activation_129 (Activation)    (None, 128, 128, 16  0           ['batch_normalization_190[0][0]']\n","                                0)                                                                \n","                                                                                                  \n"," conv2d_203 (Conv2D)            (None, 128, 128, 64  92224       ['activation_129[0][0]']         \n","                                )                                                                 \n","                                                                                                  \n"," batch_normalization_191 (Batch  (None, 128, 128, 64  256        ['conv2d_203[0][0]']             \n"," Normalization)                 )                                                                 \n","                                                                                                  \n"," conv2d_205 (Conv2D)            (None, 128, 128, 64  10304       ['concatenate_26[0][0]']         \n","                                )                                                                 \n","                                                                                                  \n"," activation_130 (Activation)    (None, 128, 128, 64  0           ['batch_normalization_191[0][0]']\n","                                )                                                                 \n","                                                                                                  \n"," batch_normalization_192 (Batch  (None, 128, 128, 64  256        ['conv2d_205[0][0]']             \n"," Normalization)                 )                                                                 \n","                                                                                                  \n"," conv2d_204 (Conv2D)            (None, 128, 128, 64  36928       ['activation_130[0][0]']         \n","                                )                                                                 \n","                                                                                                  \n"," add_61 (Add)                   (None, 128, 128, 64  0           ['batch_normalization_192[0][0]',\n","                                )                                 'conv2d_204[0][0]']             \n","                                                                                                  \n"," up_sampling2d_27 (UpSampling2D  (None, 256, 256, 64  0          ['add_61[0][0]']                 \n"," )                              )                                                                 \n","                                                                                                  \n"," concatenate_27 (Concatenate)   (None, 256, 256, 80  0           ['up_sampling2d_27[0][0]',       \n","                                )                                 'add_54[0][0]']                 \n","                                                                                                  \n"," batch_normalization_193 (Batch  (None, 256, 256, 80  320        ['concatenate_27[0][0]']         \n"," Normalization)                 )                                                                 \n","                                                                                                  \n"," activation_131 (Activation)    (None, 256, 256, 80  0           ['batch_normalization_193[0][0]']\n","                                )                                                                 \n","                                                                                                  \n"," conv2d_206 (Conv2D)            (None, 256, 256, 32  23072       ['activation_131[0][0]']         \n","                                )                                                                 \n","                                                                                                  \n"," batch_normalization_194 (Batch  (None, 256, 256, 32  128        ['conv2d_206[0][0]']             \n"," Normalization)                 )                                                                 \n","                                                                                                  \n"," conv2d_208 (Conv2D)            (None, 256, 256, 32  2592        ['concatenate_27[0][0]']         \n","                                )                                                                 \n","                                                                                                  \n"," activation_132 (Activation)    (None, 256, 256, 32  0           ['batch_normalization_194[0][0]']\n","                                )                                                                 \n","                                                                                                  \n"," batch_normalization_195 (Batch  (None, 256, 256, 32  128        ['conv2d_208[0][0]']             \n"," Normalization)                 )                                                                 \n","                                                                                                  \n"," conv2d_207 (Conv2D)            (None, 256, 256, 32  9248        ['activation_132[0][0]']         \n","                                )                                                                 \n","                                                                                                  \n"," add_62 (Add)                   (None, 256, 256, 32  0           ['batch_normalization_195[0][0]',\n","                                )                                 'conv2d_207[0][0]']             \n","                                                                                                  \n"," conv2d_209 (Conv2D)            (None, 256, 256, 1)  33          ['add_62[0][0]']                 \n","                                                                                                  \n","==================================================================================================\n","Total params: 4,723,057\n","Trainable params: 4,715,761\n","Non-trainable params: 7,296\n","__________________________________________________________________________________________________\n"]}],"source":["model = ResUNet()\n","adam = keras.optimizers.Adam()\n","model.compile(optimizer=adam, loss=dice_coef_loss, metrics=[\"acc\", dice_coef])\n","model.summary()"]},{"cell_type":"markdown","metadata":{"id":"FMGTtORYqyEe"},"source":["# Model Training"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"background_save":true,"base_uri":"https://localhost:8080/"},"id":"ga9-TIRKef_8","scrolled":false},"outputs":[{"name":"stderr","output_type":"stream","text":["/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:9: UserWarning: `Model.fit_generator` is deprecated and will be removed in a future version. Please use `Model.fit`, which supports generators.\n","  if __name__ == '__main__':\n"]},{"name":"stdout","output_type":"stream","text":["Epoch 1/50\n"]},{"name":"stderr","output_type":"stream","text":["/usr/local/lib/python3.7/dist-packages/tensorflow/python/autograph/impl/api.py:459: UserWarning: `tf.layers.flatten` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Flatten` instead.\n","  return f(*args)\n","/usr/local/lib/python3.7/dist-packages/keras/legacy_tf_layers/core.py:541: UserWarning: `layer.apply` is deprecated and will be removed in a future version. Please use `layer.__call__` method instead.\n","  return layer.apply(inputs)\n","/usr/local/lib/python3.7/dist-packages/keras/legacy_tf_layers/base.py:573: UserWarning: `layer.updates` will be removed in a future version. This property should not be used in TensorFlow 2.0, as `updates` are applied automatically.\n","  _add_elements_to_collection(self.updates, tf.compat.v1.GraphKeys.UPDATE_OPS)\n"]},{"name":"stdout","output_type":"stream","text":["73/73 [==============================] - 569s 7s/step - loss: 0.8212 - acc: 0.8747 - dice_coef: 0.0865 - val_loss: 0.8642 - val_acc: 0.0723 - val_dice_coef: 0.1358\n","Epoch 2/50\n","73/73 [==============================] - 146s 2s/step - loss: 0.5525 - acc: 0.9409 - dice_coef: 0.4475 - val_loss: 0.9972 - val_acc: 0.9035 - val_dice_coef: 0.0028\n","Epoch 3/50\n","73/73 [==============================] - 144s 2s/step - loss: 0.5378 - acc: 0.9635 - dice_coef: 0.4622 - val_loss: 0.8669 - val_acc: 0.9076 - val_dice_coef: 0.1331\n","Epoch 4/50\n","73/73 [==============================] - 144s 2s/step - loss: 0.6571 - acc: 0.9571 - dice_coef: 0.3429 - val_loss: 0.7782 - val_acc: 0.9035 - val_dice_coef: 0.2218\n","Epoch 5/50\n","73/73 [==============================] - 143s 2s/step - loss: 0.6813 - acc: 0.9470 - dice_coef: 0.3187 - val_loss: 0.7777 - val_acc: 0.9035 - val_dice_coef: 0.2223\n","Epoch 6/50\n","73/73 [==============================] - 144s 2s/step - loss: 0.7519 - acc: 0.9345 - dice_coef: 0.2481 - val_loss: 0.7777 - val_acc: 0.9035 - val_dice_coef: 0.2223\n","Epoch 7/50\n","73/73 [==============================] - 147s 2s/step - loss: 0.7116 - acc: 0.9410 - dice_coef: 0.2884 - val_loss: 0.7777 - val_acc: 0.9035 - val_dice_coef: 0.2223\n","Epoch 8/50\n","73/73 [==============================] - 143s 2s/step - loss: 0.7205 - acc: 0.9457 - dice_coef: 0.2795 - val_loss: 0.7777 - val_acc: 0.9035 - val_dice_coef: 0.2223\n","Epoch 9/50\n","73/73 [==============================] - 145s 2s/step - loss: 0.6479 - acc: 0.9614 - dice_coef: 0.3521 - val_loss: 0.7777 - val_acc: 0.9035 - val_dice_coef: 0.2223\n","Epoch 10/50\n","73/73 [==============================] - 144s 2s/step - loss: 0.6826 - acc: 0.9473 - dice_coef: 0.3174 - val_loss: 0.7777 - val_acc: 0.9035 - val_dice_coef: 0.2223\n","Epoch 11/50\n","73/73 [==============================] - 145s 2s/step - loss: 0.6505 - acc: 0.9452 - dice_coef: 0.3495 - val_loss: 0.7777 - val_acc: 0.9035 - val_dice_coef: 0.2223\n","Epoch 12/50\n","73/73 [==============================] - 146s 2s/step - loss: 0.6542 - acc: 0.9508 - dice_coef: 0.3458 - val_loss: 0.7777 - val_acc: 0.9035 - val_dice_coef: 0.2223\n","Epoch 13/50\n","73/73 [==============================] - 145s 2s/step - loss: 0.7529 - acc: 0.9421 - dice_coef: 0.2471 - val_loss: 0.7777 - val_acc: 0.9035 - val_dice_coef: 0.2223\n","Epoch 14/50\n","73/73 [==============================] - 148s 2s/step - loss: 0.6272 - acc: 0.9489 - dice_coef: 0.3728 - val_loss: 0.7777 - val_acc: 0.9035 - val_dice_coef: 0.2223\n","Epoch 15/50\n","73/73 [==============================] - 146s 2s/step - loss: 0.6392 - acc: 0.9495 - dice_coef: 0.3608 - val_loss: 0.7777 - val_acc: 0.9035 - val_dice_coef: 0.2223\n","Epoch 16/50\n","73/73 [==============================] - 147s 2s/step - loss: 0.6424 - acc: 0.9484 - dice_coef: 0.3576 - val_loss: 0.7777 - val_acc: 0.9035 - val_dice_coef: 0.2223\n","Epoch 17/50\n","73/73 [==============================] - 146s 2s/step - loss: 0.6692 - acc: 0.9507 - dice_coef: 0.3308 - val_loss: 0.7777 - val_acc: 0.9035 - val_dice_coef: 0.2223\n","Epoch 18/50\n","73/73 [==============================] - 144s 2s/step - loss: 0.6347 - acc: 0.9538 - dice_coef: 0.3653 - val_loss: 0.7777 - val_acc: 0.9035 - val_dice_coef: 0.2223\n","Epoch 19/50\n","59/73 [=======================\u003e......] - ETA: 24s - loss: 0.6807 - acc: 0.9482 - dice_coef: 0.3193"]}],"source":["train_gen = DataGen(train_ids, train_path, image_size=image_size, batch_size=batch_size)\n","valid_gen = DataGen(valid_ids, train_path, image_size=image_size, batch_size=batch_size)\n","# test_gen  = DataGenTest(train_ids, train_path, image_size=image_size, batch_size=batch_size)\n","\n","train_steps = len(train_ids)//batch_size\n","valid_steps = len(valid_ids)//batch_size\n","\n","model.fit_generator(train_gen, validation_data=valid_gen, steps_per_epoch=train_steps, validation_steps=valid_steps, \n","                    epochs=epochs)"]},{"cell_type":"markdown","metadata":{"id":"f9XF7V17ric4"},"source":["## Save Model"]},{"cell_type":"markdown","metadata":{"id":"nBPs_7loqifT"},"source":[""]},{"cell_type":"code","execution_count":null,"metadata":{"id":"STg4TPBFjoFd"},"outputs":[],"source":["model.save('/content/drive/MyDrive/Dataset/model/tumor_model_50epochs.h5')  # creates a HDF5 file 'my_model.h5'\n","model.save_weights(\"/content/drive/MyDrive/Dataset/model/tumor_model_50epochs.h5\")"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"DYFI_ltKjoFe"},"outputs":[],"source":["# del model\n","model.save(os.path.join('/content/drive/MyDrive/Dataset/model','tumor_model_50epochs.h5'))  # creates a HDF5 file 'my_model.h5'\n","\n","model = keras.models.load_model(os.path.join('/content/drive/MyDrive/Dataset/model','tumor_model_50epochs.h5'), compile= False)\n","# model.summary()\n","valid_gen = DataGen(valid_ids, train_path, image_size=image_size, batch_size=batch_size)"]},{"cell_type":"markdown","metadata":{"id":"5dWskrWtr1pj"},"source":["## Model Testing"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"uZEmBRJJef_8"},"outputs":[],"source":["x, y = valid_gen.__getitem__(2)\n","result = model.predict(x)\n","\n","# result = result \u003e 0.5\n","\n","imshow(x[1])\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"xQ6wnyfBef_8"},"outputs":[],"source":["fig = plt.figure()\n","fig.subplots_adjust(hspace=0.4, wspace=0.4)\n","\n","ax = fig.add_subplot(1, 2, 1)\n","ax.imshow(np.reshape(y[1]*255, (image_size, image_size)), cmap=\"gray\")\n","\n","ax = fig.add_subplot(1, 2, 2)\n","ax.imshow(np.reshape(result[1]*255, (image_size, image_size)), cmap=\"gray\")"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"ZL5FpA3Xef_9","scrolled":false},"outputs":[],"source":["# imshow(np.reshape(y[2]*255, (image_size, image_size)), cmap=\"gray\")\n","for i in range(1, 5, 1):\n","    ## Dataset for prediction\n","    x, y = valid_gen.__getitem__(i)\n","    result = model.predict(x)\n","    result = result \u003e 0.4\n","#     print(id_name)\n","    for j in range(len(result)):\n","        fig = plt.figure(figsize=(20,20))\n","        fig.subplots_adjust(hspace=0.4, wspace=0.4)\n","\n","        ax = fig.add_subplot(1, 2, 1)\n","        ax.imshow(np.reshape(y[j]*255, (image_size, image_size)), cmap=\"gray\")\n","#         ax.imshow(y[i])\n","        ax = fig.add_subplot(1, 2, 2)\n","        ax.imshow(np.reshape(result[j]*255, (image_size, image_size)), cmap=\"gray\")"]},{"cell_type":"markdown","metadata":{"id":"Hb5k-bw7u61q"},"source":["# Model Performance"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"wggbVA5qef_9"},"outputs":[],"source":["random_batch = random.randint(0, len(valid_ids)//batch_size - 1)\n","random_sample = random.randint(0, batch_size-1)\n","random_batch = 4\n","random_sample = 2\n","print(random_batch)\n","print(random_sample)\n","x, y = valid_gen.__getitem__(random_batch)\n","result =  model.predict(x)\n","result = result \u003e 0\n","\n","fig2 = plt.figure(figsize=(6,6))\n","ax2 = fig2.add_subplot(1,1,1)\n","ax2.imshow(x[random_sample])\n","\n","fig = plt.figure(figsize=(10,10))\n","fig.subplots_adjust(hspace=0.4, wspace=0.4)\n","\n","ax = fig.add_subplot(1, 2, 1)\n","ax.imshow(np.reshape(y[random_sample]*255, (image_size, image_size)), cmap=\"gray\")\n","#         ax.imshow(y[i])\n","ax = fig.add_subplot(1, 2, 2)\n","ax.imshow(np.reshape(result[random_sample]*255, (image_size, image_size)), cmap=\"gray\")\n","\n","# imshow(np.reshape(y[random_sample]*255, (image_size, image_size)), cmap=\"gray\")\n","cm_2d = confusion_matrix(y[random_sample].flatten(), result[random_sample].flatten())\n","cm = cm_2d.ravel()\n","\n","# (tn, fp, fn, tp)\n","print(cm_2d)\n","print(cm)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"BldnTwiBef_-"},"outputs":[],"source":["print(\"Pixel Accuracy \" + str(((cm[3]+cm[0])/(cm[3]+cm[0]+cm[1]+cm[2])*100))+'%' )\n","print(\"True Positive Accuracy \" + str(((cm[3])/(cm[3]+cm[2])*100))+'%' )\n","print(\"Dice Coefficient \" + str(dice(y[random_sample], result[random_sample])))\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"rr-kDb1ief_-"},"outputs":[],"source":["ax= plt.subplot()\n","cm_2d = cm_2d.astype('float') / cm_2d.sum(axis=1)[:, np.newaxis]\n","sns.heatmap(cm_2d, annot=True, ax = ax); #annot=True to annotate cells\n","\n","print(count_cms)\n","# labels, title and ticks\n","ax.set_xlabel('Predicted labels');ax.set_ylabel('True labels'); \n","ax.set_title('Confusion Matrix'); \n","ax.xaxis.set_ticklabels(['No Tumor', 'Tumor']); ax.yaxis.set_ticklabels(['No Tumor', 'Tumor']);\n","\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"YdJuVl8dkwuD"},"outputs":[],"source":["from numpy.core.fromnumeric import size\n","from sklearn.metrics import confusion_matrix\n","from sklearn.preprocessing import LabelEncoder\n","import scikitplot as skplt\n","from sklearn.metrics import accuracy_score\n","from sklearn.model_selection import cross_val_score\n","from sklearn.metrics import confusion_matrix\n","from sklearn.metrics import accuracy_score\n","from sklearn import metrics\n","from sklearn.model_selection import KFold, cross_val_score\n","from sklearn.metrics import r2_score, roc_auc_score, roc_curve\n","from scipy import stats  # For in-built method to get PCC\n","from sklearn.metrics import mean_squared_error\n","from sklearn.metrics import mean_absolute_error\n","from sklearn.metrics import classification_report\n","from sklearn.metrics import roc_curve\n","from sklearn.metrics import roc_auc_score\n","from sklearn.metrics import precision_recall_curve\n","from sklearn.metrics import roc_curve\n","random_batch = random.randint(0, len(valid_ids)//batch_size - 1)\n","random_sample = random.randint(0, batch_size-1)\n","random_batch = 3\n","random_sample = 2\n","print(random_batch)\n","print(random_sample)\n","x, y = valid_gen.__getitem__(random_batch)\n","result =  model.predict(x)\n","result = result \u003e 0\n","\n","# imshow(np.reshape(y[random_sample]*255, (image_size, image_size)), cmap=\"gray\")\n","#cm_2d = confusion_matrix(y[random_sample].flatten(), np.round(abs(result[random_sample].flatten())))\n","#cm = cm_2d.ravel()\n","y_test=np.round(abs(y[random_sample].flatten()))\n","preds=np.round(abs(result[random_sample].flatten()))\n","fpr, tpr, threshold = metrics.roc_curve(y_test, preds)\n","roc_auc = metrics.auc(fpr, tpr)\n","\n","# method I: plt\n","import matplotlib.pyplot as plt\n","plt.title('Receiver Operating Characteristic')\n","plt.plot(fpr, tpr, 'b', label = 'AUC = %0.2f' % roc_auc)\n","plt.legend(loc = 'lower right')\n","plt.plot([0, 1], [0, 1],'r--')\n","plt.xlim([0, 1])\n","plt.ylim([0, 1])\n","plt.ylabel('True Positive Rate')\n","plt.xlabel('False Positive Rate')\n","plt.show()\n","# (tn, fp, fn, tp)\n","#print(cm_2d)\n","#print(cm)\n","rms = np.sqrt(np.mean(np.power((np.array(y_test) - np.array(preds)), 2)))\n","score = r2_score(y_test, preds)\n","mae = mean_absolute_error(y_test, preds)\n","mse = mean_squared_error(y_test, preds)\n","  #rms = math.sqrt(mse)\n","pearson_coef, p_value = stats.pearsonr(y_test, preds)\n","\n","print(\"root mean square:\", rms)\n","print(\"score:\", score)\n","print(\"mean absolute error:\", mae)\n","print(\"mean squared error:\", mse)\n","print(\"pearson_coef:\", pearson_coef)\n","print(\"p_value:\", p_value)\n","print(\"=======================================================================\\n\\n\")\n","skplt.metrics.plot_confusion_matrix(\n","  y_test,\n","  preds,\n","figsize=(10, 6), title=\"Confusion matrix\\n Deposite Category Tumor ResUNet \")\n","plt.xlim(-0.5, len(np.unique(y_test)) - 0.5)\n","plt.ylim(len(np.unique(y_test)) - 0.5, -0.5)\n","plt.savefig('cvroc.png')\n","plt.show()\n","# Bagging\n","ns_probs = [0 for _ in range(len(y_test))]\n","#lr_probs = predictions\n","#best_found_fina=individual_list\n","#ns_aucb = roc_auc_score(y_test, ns_probs)\n","ns_aucb = roc_auc_score(y_test, ns_probs)\n","lr_aucb = roc_auc_score(y_test, preds)\n","precision, recall, thresholds = precision_recall_curve(y_test, preds)\n","no_skill = len(y_test[y_test==1]) / len(y_test)\n","plt.plot([0, 1], [no_skill, no_skill], linestyle='--', label='No Skill')\n","plt.plot(precision, recall,thresholds, marker='.', label='Logistic')\n","# axis labels\n","plt.xlabel('Recall')\n","plt.ylabel('Precision')\n","# show the legend\n","plt.legend()\n","# show the plot\n","plt.show()\n","  # summarize scores\n","#print('No Skill: ROC AUC=%.3f' % (ns_aucb))\n","\n","#print('Logistic: ROC AUC=%.3f' % (lr_aucb))\n","\n","    # calculate roc curves\n","ns_fprb, ns_tprb, _ = roc_curve(y_test, ns_probs)\n","lr_fprb, lr_tprb, _ = roc_curve(y_test, preds)\n","    # plot the roc curve for the model\n","plt.plot(ns_fprb, ns_tprb, linestyle='--', label='No Skill')\n","plt.plot(lr_fprb, lr_tprb, marker='.', label='target')\n","plt.plot(lr_fprb, lr_tprb, marker='.', label='Tumor ResUNet')\n","    # axis labels\n","plt.xlabel('False Positive Rate')\n","plt.ylabel('True Positive Rate')\n","    # show the legend\n","plt.legend()\n","plt.title(\"ROC Curve Graph\")\n","plt.savefig('comparisonroc.png')\n","    # show the plot\n","plt.show()"]}],"metadata":{"colab":{"collapsed_sections":[],"name":"Tumor_Detection_ResUNet.ipynb","version":""},"kernelspec":{"display_name":"Python 3","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.7.3"}},"nbformat":4,"nbformat_minor":0}