data_gen.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Self_sup.py : Self supervised model\n",
    "#\n",
    "# Code by: \n",
    "# Karthikeya Kethamakka: kketham\n",
    "# Anuj Patel aap1\n",
    "# Vicky Daiya: vdaiya\n",
    "# In order to run the code you might need to install dependencies along with datasets\n",
    "# To install dependencies follow the tutorial mentioned: https://www.youtube.com/watch?v=tzsft6lQUAE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Segmentation Models: using `tf.keras` framework.\n"
     ]
    },
    {
     "ename": "ModuleNotFoundError",
     "evalue": "No module named 'splitfolders'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_36496/1081890245.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     23\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mtensorflow\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mtf\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     24\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mpandas\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mpd\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 25\u001b[1;33m \u001b[1;32mimport\u001b[0m \u001b[0msplitfolders\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     26\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mos\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     27\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mnumpy\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mModuleNotFoundError\u001b[0m: No module named 'splitfolders'"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import nibabel as nib\n",
    "import glob\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "from tifffile import imsave\n",
    "from keras_applications.resnet import ResNet50\n",
    "import segmentation_models_3D as sm\n",
    "import os\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.layers import Input, Conv3D, MaxPooling3D, concatenate, Conv3DTranspose, BatchNormalization, Dropout, Lambda\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "from tensorflow.keras.metrics import MeanIoU\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras import models, layers, regularizers\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras import backend as K\n",
    "from tensorflow.keras.metrics import MeanIoU\n",
    "from tensorflow.keras import layers\n",
    "from tensorflow.keras import regularizers\n",
    "import tensorflow as tf\n",
    "import pandas as pd\n",
    "import splitfolders \n",
    "import os\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "import random\n",
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.layers import Input, Conv3D, MaxPooling3D, concatenate, Conv3DTranspose, BatchNormalization, Dropout, Lambda\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "from tensorflow.keras.metrics import MeanIoU\n",
    "import os\n",
    "import numpy as np\n",
    "from custom_datagen import imageLoader\n",
    "#import tensorflow as tf\n",
    "import keras as K\n",
    "from matplotlib import pyplot as plt\n",
    "import glob\n",
    "import random\n",
    "from tensorflow.keras.layers import Flatten\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "import os\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import random\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'MinMaxScaler' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_8512/3220903313.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mscaler\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mMinMaxScaler\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'MinMaxScaler' is not defined"
     ]
    }
   ],
   "source": [
    "\n",
    "scaler = MinMaxScaler()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "TRAIN_DATASET_PATH = 'BraTS2020_TrainingData/MICCAI_BraTS2020_TrainingData/'\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1854.603271484375\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'scaler' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_33576/3182842988.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mtest_image_flair\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mnib\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mload\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mTRAIN_DATASET_PATH\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;34m'BraTS20_Training_355/BraTS20_Training_355_flair.nii'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_fdata\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtest_image_flair\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mtest_image_flair\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mscaler\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfit_transform\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtest_image_flair\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtest_image_flair\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtest_image_flair\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      4\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtest_image_flair\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'scaler' is not defined"
     ]
    }
   ],
   "source": [
    "test_image_flair=nib.load(TRAIN_DATASET_PATH + 'BraTS20_Training_355/BraTS20_Training_355_flair.nii').get_fdata()\n",
    "print(test_image_flair.max())\n",
    "test_image_flair=scaler.fit_transform(test_image_flair.reshape(-1, test_image_flair.shape[-1])).reshape(test_image_flair.shape)\n",
    "print(test_image_flair.max())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_image_t1=nib.load(TRAIN_DATASET_PATH + 'BraTS20_Training_355/BraTS20_Training_355_t1.nii').get_fdata()\n",
    "test_image_t1=scaler.fit_transform(test_image_t1.reshape(-1, test_image_t1.shape[-1])).reshape(test_image_t1.shape)\n",
    "\n",
    "test_image_t1ce=nib.load(TRAIN_DATASET_PATH + 'BraTS20_Training_355/BraTS20_Training_355_t1ce.nii').get_fdata()\n",
    "test_image_t1ce=scaler.fit_transform(test_image_t1ce.reshape(-1, test_image_t1ce.shape[-1])).reshape(test_image_t1ce.shape)\n",
    "\n",
    "test_image_t2=nib.load(TRAIN_DATASET_PATH + 'BraTS20_Training_355/BraTS20_Training_355_t2.nii').get_fdata()\n",
    "test_image_t2=scaler.fit_transform(test_image_t2.reshape(-1, test_image_t2.shape[-1])).reshape(test_image_t2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_mask=nib.load(TRAIN_DATASET_PATH + 'BraTS20_Training_355/BraTS20_Training_355_seg.nii').get_fdata()\n",
    "test_mask=test_mask.astype(np.uint8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.unique(test_mask))  \n",
    "test_mask[test_mask==4] = 3  \n",
    "print(np.unique(test_mask)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_slice=random.randint(0, test_mask.shape[2])\n",
    "plt.figure(figsize=(12, 8))\n",
    "plt.subplot(231)\n",
    "plt.imshow(test_image_flair[:,:,n_slice], cmap='gray')\n",
    "plt.title('Image flair')\n",
    "plt.subplot(232)\n",
    "plt.imshow(test_image_t1[:,:,n_slice], cmap='gray')\n",
    "plt.title('Image t1')\n",
    "plt.subplot(233)\n",
    "plt.imshow(test_image_t1ce[:,:,n_slice], cmap='gray')\n",
    "plt.title('Image t1ce')\n",
    "plt.subplot(234)\n",
    "plt.imshow(test_image_t2[:,:,n_slice], cmap='gray')\n",
    "plt.title('Image t2')\n",
    "plt.subplot(235)\n",
    "plt.imshow(test_mask[:,:,n_slice])\n",
    "plt.title('Mask')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "combined_x = np.stack([test_image_flair, test_image_t1ce, test_image_t2], axis=3)\n",
    "print(combined_x.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "combined_x=combined_x[56:184, 56:184, 13:141]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "test_mask = test_mask[56:184, 56:184, 13:141]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_slice=random.randint(0, test_mask.shape[2])\n",
    "plt.figure(figsize=(12, 8))\n",
    "\n",
    "plt.subplot(221)\n",
    "plt.imshow(combined_x[:,:,n_slice, 0], cmap='gray')\n",
    "plt.title('Image flair')\n",
    "plt.subplot(222)\n",
    "plt.imshow(combined_x[:,:,n_slice, 1], cmap='gray')\n",
    "plt.title('Image t1ce')\n",
    "plt.subplot(223)\n",
    "plt.imshow(combined_x[:,:,n_slice, 2], cmap='gray')\n",
    "plt.title('Image t2')\n",
    "plt.subplot(224)\n",
    "plt.imshow(test_mask[:,:,n_slice])\n",
    "plt.title('Mask')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "imsave('BraTS2020_TrainingData/combined255.tif', combined_x)\n",
    "np.save('BraTS2020_TrainingData/combined255.npy', combined_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_img=np.load('BraTS2020_TrainingData/combined255.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_mask = to_categorical(test_mask, num_classes=4)\n",
    "test_mask.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#t1_list = sorted(glob.glob('BraTS2020_TrainingData/MICCAI_BraTS2020_TrainingData/*/*t1.nii'))\n",
    "t2_list = sorted(glob.glob('BraTS2020_TrainingData/MICCAI_BraTS2020_TrainingData/*/*t2.nii'))\n",
    "t1ce_list = sorted(glob.glob('BraTS2020_TrainingData/MICCAI_BraTS2020_TrainingData/*/*t1ce.nii'))\n",
    "flair_list = sorted(glob.glob('BraTS2020_TrainingData/MICCAI_BraTS2020_TrainingData/*/*flair.nii'))\n",
    "mask_list = sorted(glob.glob('BraTS2020_TrainingData/MICCAI_BraTS2020_TrainingData/*/*seg.nii'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(t2_list)\n",
    "len(mask_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for img in range(len(t2_list)):   #Using t1_list as all lists are of same size\n",
    "    print(\"Now preparing image and masks number: \", img)\n",
    "      \n",
    "    temp_image_t2=nib.load(t2_list[img]).get_fdata()\n",
    "    temp_image_t2=scaler.fit_transform(temp_image_t2.reshape(-1, temp_image_t2.shape[-1])).reshape(temp_image_t2.shape)\n",
    "   \n",
    "    temp_image_t1ce=nib.load(t1ce_list[img]).get_fdata()\n",
    "    temp_image_t1ce=scaler.fit_transform(temp_image_t1ce.reshape(-1, temp_image_t1ce.shape[-1])).reshape(temp_image_t1ce.shape)\n",
    "   \n",
    "    temp_image_flair=nib.load(flair_list[img]).get_fdata()\n",
    "    temp_image_flair=scaler.fit_transform(temp_image_flair.reshape(-1, temp_image_flair.shape[-1])).reshape(temp_image_flair.shape)\n",
    "        \n",
    "    temp_mask=nib.load(mask_list[img]).get_fdata()\n",
    "    temp_mask=temp_mask.astype(np.uint8)\n",
    "    temp_mask[temp_mask==4] = 3  \n",
    "\n",
    "    \n",
    "    \n",
    "    temp_combined_images = np.stack([temp_image_flair, temp_image_t1ce, temp_image_t2], axis=3)\n",
    "    \n",
    "\n",
    "    temp_combined_images=temp_combined_images[56:184, 56:184, 13:141]\n",
    "    temp_mask = temp_mask[56:184, 56:184, 13:141]\n",
    "    \n",
    "    val, counts = np.unique(temp_mask, return_counts=True)\n",
    "    \n",
    "    if (1 - (counts[0]/counts.sum())) > 0.01:\n",
    "        print(\"Save\")\n",
    "        temp_mask= to_categorical(temp_mask, num_classes=4)\n",
    "        np.save('BraTS2020_TrainingData/input_data_3channels/images/image_'+str(img)+'.npy', temp_combined_images)\n",
    "        np.save('BraTS2020_TrainingData/input_data_3channels/masks/mask_'+str(img)+'.npy', temp_mask)\n",
    "        \n",
    "    else:\n",
    "        print(\"No Use\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'splitfolders' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_9148/86579887.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0moutput_folder\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'BraTS2020_TrainingData/input_data_128/'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0msplitfolders\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mratio\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minput_folder\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0moutput\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0moutput_folder\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mseed\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m42\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mratio\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m.75\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m.25\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgroup_prefix\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# default values\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'splitfolders' is not defined"
     ]
    }
   ],
   "source": [
    "\n",
    "input_folder = 'BraTS2020_TrainingData/input_data_3channels/'\n",
    "output_folder = 'BraTS2020_TrainingData/input_data_128/'\n",
    "\n",
    "splitfolders.ratio(input_folder, output=output_folder, seed=42, ratio=(.75, .25), group_prefix=None) # default values\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "columns = ['0','1', '2', '3']\n",
    "df = pd.DataFrame(columns=columns)\n",
    "train_mask_list = sorted(glob.glob('BraTS2020_TrainingData/input_data_128/train/masks/*.npy'))\n",
    "for img in range(0,10):\n",
    "    print(img)\n",
    "    temp_image=np.load(train_mask_list[img])\n",
    "    temp_image = np.argmax(temp_image, axis=3)\n",
    "    val, counts = np.unique(temp_image, return_counts=True)\n",
    "    zipped = zip(columns, counts)\n",
    "    conts_dict = dict(zipped)\n",
    "    \n",
    "    df = df.append(conts_dict, ignore_index=True)\n",
    "\n",
    "label_0 = df['0'].sum()\n",
    "label_1 = df['1'].sum()\n",
    "label_2 = df['1'].sum()\n",
    "label_3 = df['3'].sum()\n",
    "total_labels = label_0 + label_1 + label_2 + label_3\n",
    "n_classes = 4\n",
    "\n",
    "wt0 = round((total_labels/(n_classes*label_0)), 2) \n",
    "wt1 = round((total_labels/(n_classes*label_1)), 2)\n",
    "wt2 = round((total_labels/(n_classes*label_2)), 2)\n",
    "wt3 = round((total_labels/(n_classes*label_3)), 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.25 54.34 54.34 27.97\n"
     ]
    }
   ],
   "source": [
    "print(wt0,wt1,wt2,wt3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20143940"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "label_0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "94380"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "label_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "94380"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "label_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_img(img_dir, img_list):\n",
    "    images=[]\n",
    "    for i, image_name in enumerate(img_list):    \n",
    "        if (image_name.split('.')[1] == 'npy'):\n",
    "            \n",
    "            image = np.load(img_dir+image_name)\n",
    "                      \n",
    "            images.append(image)\n",
    "    images = np.array(images)\n",
    "    \n",
    "    return(images)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def imageLoader(img_dir, img_list, mask_dir, mask_list, batch_size):\n",
    "\n",
    "    L = len(img_list)\n",
    "\n",
    "    while True:\n",
    "\n",
    "        batch_start = 0\n",
    "        batch_end = batch_size\n",
    "\n",
    "        while batch_start < L:\n",
    "            limit = min(batch_end, L)\n",
    "                       \n",
    "            X = load_img(img_dir, img_list[batch_start:limit])\n",
    "            Y = load_img(mask_dir, mask_list[batch_start:limit])\n",
    "\n",
    "            yield (X,Y)  \n",
    "\n",
    "            batch_start += batch_size   \n",
    "            batch_end += batch_size\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "import random\n",
    "train_img_dir = \"BraTS2020_TrainingData/input_data_128/train/images/\"\n",
    "train_mask_dir = \"BraTS2020_TrainingData/input_data_128/train/masks/\"\n",
    "train_img_list=os.listdir(train_img_dir)\n",
    "train_mask_list = os.listdir(train_mask_dir)\n",
    "\n",
    "batch_size = 2\n",
    "\n",
    "train_img_datagen = imageLoader(train_img_dir, train_img_list, \n",
    "                                train_mask_dir, train_mask_list, batch_size)\n",
    "\n",
    "img, msk = train_img_datagen.__next__()\n",
    "\n",
    "\n",
    "img_num = random.randint(0,img.shape[0]-1)\n",
    "test_img=img[img_num]\n",
    "test_mask=msk[img_num]\n",
    "test_mask=np.argmax(test_mask, axis=3)\n",
    "\n",
    "n_slice=random.randint(0, test_mask.shape[2])\n",
    "plt.figure(figsize=(12, 8))\n",
    "\n",
    "plt.subplot(221)\n",
    "plt.imshow(test_img[:,:,n_slice, 0], cmap='gray')\n",
    "plt.title('Image flair')\n",
    "plt.subplot(222)\n",
    "plt.imshow(test_img[:,:,n_slice, 1], cmap='gray')\n",
    "plt.title('Image t1ce')\n",
    "plt.subplot(223)\n",
    "plt.imshow(test_img[:,:,n_slice, 2], cmap='gray')\n",
    "plt.title('Image t2')\n",
    "plt.subplot(224)\n",
    "plt.imshow(test_mask[:,:,n_slice])\n",
    "plt.title('Mask')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model\"\n",
      "__________________________________________________________________________________________________\n",
      " Layer (type)                   Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      " input_1 (InputLayer)           [(None, 128, 128, 1  0           []                               \n",
      "                                28, 3)]                                                           \n",
      "                                                                                                  \n",
      " conv3d (Conv3D)                (None, 128, 128, 12  1312        ['input_1[0][0]']                \n",
      "                                8, 16)                                                            \n",
      "                                                                                                  \n",
      " dropout (Dropout)              (None, 128, 128, 12  0           ['conv3d[0][0]']                 \n",
      "                                8, 16)                                                            \n",
      "                                                                                                  \n",
      " conv3d_1 (Conv3D)              (None, 128, 128, 12  6928        ['dropout[0][0]']                \n",
      "                                8, 16)                                                            \n",
      "                                                                                                  \n",
      " max_pooling3d (MaxPooling3D)   (None, 64, 64, 64,   0           ['conv3d_1[0][0]']               \n",
      "                                16)                                                               \n",
      "                                                                                                  \n",
      " conv3d_2 (Conv3D)              (None, 64, 64, 64,   13856       ['max_pooling3d[0][0]']          \n",
      "                                32)                                                               \n",
      "                                                                                                  \n",
      " dropout_1 (Dropout)            (None, 64, 64, 64,   0           ['conv3d_2[0][0]']               \n",
      "                                32)                                                               \n",
      "                                                                                                  \n",
      " conv3d_3 (Conv3D)              (None, 64, 64, 64,   27680       ['dropout_1[0][0]']              \n",
      "                                32)                                                               \n",
      "                                                                                                  \n",
      " max_pooling3d_1 (MaxPooling3D)  (None, 32, 32, 32,   0          ['conv3d_3[0][0]']               \n",
      "                                32)                                                               \n",
      "                                                                                                  \n",
      " conv3d_4 (Conv3D)              (None, 32, 32, 32,   55360       ['max_pooling3d_1[0][0]']        \n",
      "                                64)                                                               \n",
      "                                                                                                  \n",
      " dropout_2 (Dropout)            (None, 32, 32, 32,   0           ['conv3d_4[0][0]']               \n",
      "                                64)                                                               \n",
      "                                                                                                  \n",
      " conv3d_5 (Conv3D)              (None, 32, 32, 32,   110656      ['dropout_2[0][0]']              \n",
      "                                64)                                                               \n",
      "                                                                                                  \n",
      " max_pooling3d_2 (MaxPooling3D)  (None, 16, 16, 16,   0          ['conv3d_5[0][0]']               \n",
      "                                64)                                                               \n",
      "                                                                                                  \n",
      " conv3d_6 (Conv3D)              (None, 16, 16, 16,   221312      ['max_pooling3d_2[0][0]']        \n",
      "                                128)                                                              \n",
      "                                                                                                  \n",
      " dropout_3 (Dropout)            (None, 16, 16, 16,   0           ['conv3d_6[0][0]']               \n",
      "                                128)                                                              \n",
      "                                                                                                  \n",
      " conv3d_7 (Conv3D)              (None, 16, 16, 16,   442496      ['dropout_3[0][0]']              \n",
      "                                128)                                                              \n",
      "                                                                                                  \n",
      " max_pooling3d_3 (MaxPooling3D)  (None, 8, 8, 8, 128  0          ['conv3d_7[0][0]']               \n",
      "                                )                                                                 \n",
      "                                                                                                  \n",
      " conv3d_8 (Conv3D)              (None, 8, 8, 8, 256  884992      ['max_pooling3d_3[0][0]']        \n",
      "                                )                                                                 \n",
      "                                                                                                  \n",
      " dropout_4 (Dropout)            (None, 8, 8, 8, 256  0           ['conv3d_8[0][0]']               \n",
      "                                )                                                                 \n",
      "                                                                                                  \n",
      " conv3d_9 (Conv3D)              (None, 8, 8, 8, 256  1769728     ['dropout_4[0][0]']              \n",
      "                                )                                                                 \n",
      "                                                                                                  \n",
      " conv3d_transpose (Conv3DTransp  (None, 16, 16, 16,   262272     ['conv3d_9[0][0]']               \n",
      " ose)                           128)                                                              \n",
      "                                                                                                  \n",
      " concatenate (Concatenate)      (None, 16, 16, 16,   0           ['conv3d_transpose[0][0]',       \n",
      "                                256)                              'conv3d_7[0][0]']               \n",
      "                                                                                                  \n",
      " conv3d_10 (Conv3D)             (None, 16, 16, 16,   884864      ['concatenate[0][0]']            \n",
      "                                128)                                                              \n",
      "                                                                                                  \n",
      " dropout_5 (Dropout)            (None, 16, 16, 16,   0           ['conv3d_10[0][0]']              \n",
      "                                128)                                                              \n",
      "                                                                                                  \n",
      " conv3d_11 (Conv3D)             (None, 16, 16, 16,   442496      ['dropout_5[0][0]']              \n",
      "                                128)                                                              \n",
      "                                                                                                  \n",
      " conv3d_transpose_1 (Conv3DTran  (None, 32, 32, 32,   65600      ['conv3d_11[0][0]']              \n",
      " spose)                         64)                                                               \n",
      "                                                                                                  \n",
      " concatenate_1 (Concatenate)    (None, 32, 32, 32,   0           ['conv3d_transpose_1[0][0]',     \n",
      "                                128)                              'conv3d_5[0][0]']               \n",
      "                                                                                                  \n",
      " conv3d_12 (Conv3D)             (None, 32, 32, 32,   221248      ['concatenate_1[0][0]']          \n",
      "                                64)                                                               \n",
      "                                                                                                  \n",
      " dropout_6 (Dropout)            (None, 32, 32, 32,   0           ['conv3d_12[0][0]']              \n",
      "                                64)                                                               \n",
      "                                                                                                  \n",
      " conv3d_13 (Conv3D)             (None, 32, 32, 32,   110656      ['dropout_6[0][0]']              \n",
      "                                64)                                                               \n",
      "                                                                                                  \n",
      " conv3d_transpose_2 (Conv3DTran  (None, 64, 64, 64,   16416      ['conv3d_13[0][0]']              \n",
      " spose)                         32)                                                               \n",
      "                                                                                                  \n",
      " concatenate_2 (Concatenate)    (None, 64, 64, 64,   0           ['conv3d_transpose_2[0][0]',     \n",
      "                                64)                               'conv3d_3[0][0]']               \n",
      "                                                                                                  \n",
      " conv3d_14 (Conv3D)             (None, 64, 64, 64,   55328       ['concatenate_2[0][0]']          \n",
      "                                32)                                                               \n",
      "                                                                                                  \n",
      " dropout_7 (Dropout)            (None, 64, 64, 64,   0           ['conv3d_14[0][0]']              \n",
      "                                32)                                                               \n",
      "                                                                                                  \n",
      " conv3d_15 (Conv3D)             (None, 64, 64, 64,   27680       ['dropout_7[0][0]']              \n",
      "                                32)                                                               \n",
      "                                                                                                  \n",
      " conv3d_transpose_3 (Conv3DTran  (None, 128, 128, 12  4112       ['conv3d_15[0][0]']              \n",
      " spose)                         8, 16)                                                            \n",
      "                                                                                                  \n",
      " concatenate_3 (Concatenate)    (None, 128, 128, 12  0           ['conv3d_transpose_3[0][0]',     \n",
      "                                8, 32)                            'conv3d_1[0][0]']               \n",
      "                                                                                                  \n",
      " conv3d_16 (Conv3D)             (None, 128, 128, 12  13840       ['concatenate_3[0][0]']          \n",
      "                                8, 16)                                                            \n",
      "                                                                                                  \n",
      " dropout_8 (Dropout)            (None, 128, 128, 12  0           ['conv3d_16[0][0]']              \n",
      "                                8, 16)                                                            \n",
      "                                                                                                  \n",
      " conv3d_17 (Conv3D)             (None, 128, 128, 12  6928        ['dropout_8[0][0]']              \n",
      "                                8, 16)                                                            \n",
      "                                                                                                  \n",
      " conv3d_18 (Conv3D)             (None, 128, 128, 12  68          ['conv3d_17[0][0]']              \n",
      "                                8, 4)                                                             \n",
      "                                                                                                  \n",
      "==================================================================================================\n",
      "Total params: 5,645,828\n",
      "Trainable params: 5,645,828\n",
      "Non-trainable params: 0\n",
      "__________________________________________________________________________________________________\n",
      "(None, 128, 128, 128, 3)\n",
      "(None, 128, 128, 128, 4)\n"
     ]
    }
   ],
   "source": [
    "def iou(y_true, y_pred):\n",
    "    def f(y_true, y_pred):\n",
    "        intersection = (y_true * y_pred).sum()\n",
    "        union = y_true.sum() + y_pred.sum() - intersection\n",
    "        x = (intersection + 1e-15) / (union + 1e-15)\n",
    "        x = x.astype(np.float32)\n",
    "        return x\n",
    "\n",
    "    return tf.numpy_function(f, [y_true, y_pred], tf.float32)\n",
    "\n",
    "import os\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras.metrics import MeanIoU\n",
    "import os\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.layers import Input, Conv3D, MaxPooling3D, concatenate, Conv3DTranspose, BatchNormalization, Dropout, Lambda\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "from tensorflow.keras.metrics import MeanIoU\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras import models, layers, regularizers\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras import backend as K\n",
    "from tensorflow.keras.metrics import MeanIoU\n",
    "metrics = [\"acc\", tf.keras.metrics.Recall(), tf.keras.metrics.Precision(), iou]\n",
    "def weighted_categorical_crossentropy(weights):\n",
    "    def wcce(y_true, y_pred):\n",
    "        Kweights = K.constant(weights)\n",
    "        y_true = K.cast(y_true, y_pred.dtype)\n",
    "        return K.categorical_crossentropy(y_true, y_pred) * K.sum(y_true * Kweights, axis=-1)\n",
    "    return wcce\n",
    "loss=weighted_categorical_crossentropy([0.25,54.34,54.34,27.97])\n",
    "\n",
    "kernel_initializer =  'he_uniform' \n",
    "\n",
    "def simple_unet_model(IMG_HEIGHT, IMG_WIDTH, IMG_DEPTH, IMG_CHANNELS, num_classes):\n",
    "    inputs = Input((IMG_HEIGHT, IMG_WIDTH, IMG_DEPTH, IMG_CHANNELS))\n",
    "    s = inputs\n",
    "    c1 = Conv3D(16, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(s)\n",
    "    c1 = Dropout(0.1)(c1)\n",
    "    c1 = Conv3D(16, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(c1)\n",
    "    p1 = MaxPooling3D((2, 2, 2))(c1)\n",
    "    \n",
    "    c2 = Conv3D(32, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(p1)\n",
    "    c2 = Dropout(0.1)(c2)\n",
    "    c2 = Conv3D(32, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(c2)\n",
    "    p2 = MaxPooling3D((2, 2, 2))(c2)\n",
    "     \n",
    "    c3 = Conv3D(64, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(p2)\n",
    "    c3 = Dropout(0.2)(c3)\n",
    "    c3 = Conv3D(64, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(c3)\n",
    "    p3 = MaxPooling3D((2, 2, 2))(c3)\n",
    "     \n",
    "    c4 = Conv3D(128, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(p3)\n",
    "    c4 = Dropout(0.2)(c4)\n",
    "    c4 = Conv3D(128, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(c4)\n",
    "    p4 = MaxPooling3D(pool_size=(2, 2, 2))(c4)\n",
    "     \n",
    "    c5 = Conv3D(256, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(p4)\n",
    "    c5 = Dropout(0.3)(c5)\n",
    "    c5 = Conv3D(256, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(c5)\n",
    "    \n",
    "    #Expansive path \n",
    "    u6 = Conv3DTranspose(128, (2, 2, 2), strides=(2, 2, 2), padding='same')(c5)\n",
    "    u6 = concatenate([u6, c4])\n",
    "    c6 = Conv3D(128, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(u6)\n",
    "    c6 = Dropout(0.2)(c6)\n",
    "    c6 = Conv3D(128, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(c6)\n",
    "     \n",
    "    u7 = Conv3DTranspose(64, (2, 2, 2), strides=(2, 2, 2), padding='same')(c6)\n",
    "    u7 = concatenate([u7, c3])\n",
    "    c7 = Conv3D(64, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(u7)\n",
    "    c7 = Dropout(0.2)(c7)\n",
    "    c7 = Conv3D(64, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(c7)\n",
    "     \n",
    "    u8 = Conv3DTranspose(32, (2, 2, 2), strides=(2, 2, 2), padding='same')(c7)\n",
    "    u8 = concatenate([u8, c2])\n",
    "    c8 = Conv3D(32, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(u8)\n",
    "    c8 = Dropout(0.1)(c8)\n",
    "    c8 = Conv3D(32, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(c8)\n",
    "     \n",
    "    u9 = Conv3DTranspose(16, (2, 2, 2), strides=(2, 2, 2), padding='same')(c8)\n",
    "    u9 = concatenate([u9, c1])\n",
    "    c9 = Conv3D(16, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(u9)\n",
    "    c9 = Dropout(0.1)(c9)\n",
    "    c9 = Conv3D(16, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(c9)\n",
    "     \n",
    "    outputs = Conv3D(num_classes, (1, 1, 1), activation='softmax')(c9)\n",
    "     \n",
    "    model = Model(inputs=[inputs], outputs=[outputs])\n",
    "    model.summary()\n",
    "    \n",
    "    return model\n",
    "model = simple_unet_model(128, 128, 128, 3, 4)\n",
    "print(model.input_shape)\n",
    "print(model.output_shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_img_dir = \"BraTS2020_TrainingData/input_data_128/train/images/\"\n",
    "train_mask_dir = \"BraTS2020_TrainingData/input_data_128/train/masks/\"\n",
    "\n",
    "img_list = os.listdir(train_img_dir)\n",
    "msk_list = os.listdir(train_mask_dir)\n",
    "\n",
    "num_images = len(os.listdir(train_img_dir))\n",
    "\n",
    "img_num = random.randint(0,num_images-1)\n",
    "test_img = np.load(train_img_dir+img_list[img_num])\n",
    "test_mask = np.load(train_mask_dir+msk_list[img_num])\n",
    "test_mask = np.argmax(test_mask, axis=3)\n",
    "\n",
    "n_slice=random.randint(0, test_mask.shape[2])\n",
    "plt.figure(figsize=(12, 8))\n",
    "\n",
    "plt.subplot(221)\n",
    "plt.imshow(test_img[:,:,n_slice, 0], cmap='gray')\n",
    "plt.title('Image flair')\n",
    "plt.subplot(222)\n",
    "plt.imshow(test_img[:,:,n_slice, 1], cmap='gray')\n",
    "plt.title('Image t1ce')\n",
    "plt.subplot(223)\n",
    "plt.imshow(test_img[:,:,n_slice, 2], cmap='gray')\n",
    "plt.title('Image t2')\n",
    "plt.subplot(224)\n",
    "plt.imshow(test_mask[:,:,n_slice])\n",
    "plt.title('Mask')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_img_dir = \"BraTS2020_TrainingData/input_data_128/train/images/\"\n",
    "train_mask_dir = \"BraTS2020_TrainingData/input_data_128/train/masks/\"\n",
    "\n",
    "val_img_dir = \"BraTS2020_TrainingData/input_data_128/val/images/\"\n",
    "val_mask_dir = \"BraTS2020_TrainingData/input_data_128/val/masks/\"\n",
    "\n",
    "train_img_list=os.listdir(train_img_dir)\n",
    "train_mask_list = os.listdir(train_mask_dir)\n",
    "\n",
    "val_img_list=os.listdir(val_img_dir)\n",
    "val_mask_list = os.listdir(val_mask_dir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 2\n",
    "\n",
    "train_img_datagen = imageLoader(train_img_dir, train_img_list, \n",
    "                                train_mask_dir, train_mask_list, batch_size)\n",
    "\n",
    "val_img_datagen = imageLoader(val_img_dir, val_img_list, \n",
    "                                val_mask_dir, val_mask_list, batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "index 128 is out of bounds for axis 2 with size 128",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_36496/3114300559.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     10\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     11\u001b[0m \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msubplot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m221\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 12\u001b[1;33m \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mimshow\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtest_img\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mn_slice\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcmap\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'gray'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     13\u001b[0m \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtitle\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Image flair'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     14\u001b[0m \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msubplot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m222\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mIndexError\u001b[0m: index 128 is out of bounds for axis 2 with size 128"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "img, msk = train_img_datagen.__next__()\n",
    "\n",
    "img_num = random.randint(0,img.shape[0]-1)\n",
    "test_img=img[img_num]\n",
    "test_mask=msk[img_num]\n",
    "test_mask=np.argmax(test_mask, axis=3)\n",
    "\n",
    "n_slice=random.randint(0, test_mask.shape[2])\n",
    "plt.figure(figsize=(12, 8))\n",
    "\n",
    "plt.subplot(221)\n",
    "plt.imshow(test_img[:,:,n_slice, 0], cmap='gray')\n",
    "plt.title('Image flair')\n",
    "plt.subplot(222)\n",
    "plt.imshow(test_img[:,:,n_slice, 1], cmap='gray')\n",
    "plt.title('Image t1ce')\n",
    "plt.subplot(223)\n",
    "plt.imshow(test_img[:,:,n_slice, 2], cmap='gray')\n",
    "plt.title('Image t2')\n",
    "plt.subplot(224)\n",
    "plt.imshow(test_mask[:,:,n_slice])\n",
    "plt.title('Mask')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def iou(y_true, y_pred):\n",
    "    def f(y_true, y_pred):\n",
    "        intersection = (y_true * y_pred).sum()\n",
    "        union = y_true.sum() + y_pred.sum() - intersection\n",
    "        x = (intersection + 1e-15) / (union + 1e-15)\n",
    "        x = x.astype(np.float32)\n",
    "        return x\n",
    "\n",
    "    return tf.numpy_function(f, [y_true, y_pred], tf.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "metrics = [\"acc\", tf.keras.metrics.Recall(), tf.keras.metrics.Precision(), iou]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "LR = 0.001\n",
    "optim = tf.keras.optimizers.Adam(LR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "steps_per_epoch = len(train_img_list)//batch_size\n",
    "val_steps_per_epoch = len(val_img_list)//batch_size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(optimizer = optim, loss=loss, metrics=metrics)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model\"\n",
      "__________________________________________________________________________________________________\n",
      " Layer (type)                   Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      " input_1 (InputLayer)           [(None, 128, 128, 1  0           []                               \n",
      "                                28, 3)]                                                           \n",
      "                                                                                                  \n",
      " conv3d (Conv3D)                (None, 128, 128, 12  1312        ['input_1[0][0]']                \n",
      "                                8, 16)                                                            \n",
      "                                                                                                  \n",
      " dropout (Dropout)              (None, 128, 128, 12  0           ['conv3d[0][0]']                 \n",
      "                                8, 16)                                                            \n",
      "                                                                                                  \n",
      " conv3d_1 (Conv3D)              (None, 128, 128, 12  6928        ['dropout[0][0]']                \n",
      "                                8, 16)                                                            \n",
      "                                                                                                  \n",
      " max_pooling3d (MaxPooling3D)   (None, 64, 64, 64,   0           ['conv3d_1[0][0]']               \n",
      "                                16)                                                               \n",
      "                                                                                                  \n",
      " conv3d_2 (Conv3D)              (None, 64, 64, 64,   13856       ['max_pooling3d[0][0]']          \n",
      "                                32)                                                               \n",
      "                                                                                                  \n",
      " dropout_1 (Dropout)            (None, 64, 64, 64,   0           ['conv3d_2[0][0]']               \n",
      "                                32)                                                               \n",
      "                                                                                                  \n",
      " conv3d_3 (Conv3D)              (None, 64, 64, 64,   27680       ['dropout_1[0][0]']              \n",
      "                                32)                                                               \n",
      "                                                                                                  \n",
      " max_pooling3d_1 (MaxPooling3D)  (None, 32, 32, 32,   0          ['conv3d_3[0][0]']               \n",
      "                                32)                                                               \n",
      "                                                                                                  \n",
      " conv3d_4 (Conv3D)              (None, 32, 32, 32,   55360       ['max_pooling3d_1[0][0]']        \n",
      "                                64)                                                               \n",
      "                                                                                                  \n",
      " dropout_2 (Dropout)            (None, 32, 32, 32,   0           ['conv3d_4[0][0]']               \n",
      "                                64)                                                               \n",
      "                                                                                                  \n",
      " conv3d_5 (Conv3D)              (None, 32, 32, 32,   110656      ['dropout_2[0][0]']              \n",
      "                                64)                                                               \n",
      "                                                                                                  \n",
      " max_pooling3d_2 (MaxPooling3D)  (None, 16, 16, 16,   0          ['conv3d_5[0][0]']               \n",
      "                                64)                                                               \n",
      "                                                                                                  \n",
      " conv3d_6 (Conv3D)              (None, 16, 16, 16,   221312      ['max_pooling3d_2[0][0]']        \n",
      "                                128)                                                              \n",
      "                                                                                                  \n",
      " dropout_3 (Dropout)            (None, 16, 16, 16,   0           ['conv3d_6[0][0]']               \n",
      "                                128)                                                              \n",
      "                                                                                                  \n",
      " conv3d_7 (Conv3D)              (None, 16, 16, 16,   442496      ['dropout_3[0][0]']              \n",
      "                                128)                                                              \n",
      "                                                                                                  \n",
      " max_pooling3d_3 (MaxPooling3D)  (None, 8, 8, 8, 128  0          ['conv3d_7[0][0]']               \n",
      "                                )                                                                 \n",
      "                                                                                                  \n",
      " conv3d_8 (Conv3D)              (None, 8, 8, 8, 256  884992      ['max_pooling3d_3[0][0]']        \n",
      "                                )                                                                 \n",
      "                                                                                                  \n",
      " dropout_4 (Dropout)            (None, 8, 8, 8, 256  0           ['conv3d_8[0][0]']               \n",
      "                                )                                                                 \n",
      "                                                                                                  \n",
      " conv3d_9 (Conv3D)              (None, 8, 8, 8, 256  1769728     ['dropout_4[0][0]']              \n",
      "                                )                                                                 \n",
      "                                                                                                  \n",
      " conv3d_transpose (Conv3DTransp  (None, 16, 16, 16,   262272     ['conv3d_9[0][0]']               \n",
      " ose)                           128)                                                              \n",
      "                                                                                                  \n",
      " concatenate (Concatenate)      (None, 16, 16, 16,   0           ['conv3d_transpose[0][0]',       \n",
      "                                256)                              'conv3d_7[0][0]']               \n",
      "                                                                                                  \n",
      " conv3d_10 (Conv3D)             (None, 16, 16, 16,   884864      ['concatenate[0][0]']            \n",
      "                                128)                                                              \n",
      "                                                                                                  \n",
      " dropout_5 (Dropout)            (None, 16, 16, 16,   0           ['conv3d_10[0][0]']              \n",
      "                                128)                                                              \n",
      "                                                                                                  \n",
      " conv3d_11 (Conv3D)             (None, 16, 16, 16,   442496      ['dropout_5[0][0]']              \n",
      "                                128)                                                              \n",
      "                                                                                                  \n",
      " conv3d_transpose_1 (Conv3DTran  (None, 32, 32, 32,   65600      ['conv3d_11[0][0]']              \n",
      " spose)                         64)                                                               \n",
      "                                                                                                  \n",
      " concatenate_1 (Concatenate)    (None, 32, 32, 32,   0           ['conv3d_transpose_1[0][0]',     \n",
      "                                128)                              'conv3d_5[0][0]']               \n",
      "                                                                                                  \n",
      " conv3d_12 (Conv3D)             (None, 32, 32, 32,   221248      ['concatenate_1[0][0]']          \n",
      "                                64)                                                               \n",
      "                                                                                                  \n",
      " dropout_6 (Dropout)            (None, 32, 32, 32,   0           ['conv3d_12[0][0]']              \n",
      "                                64)                                                               \n",
      "                                                                                                  \n",
      " conv3d_13 (Conv3D)             (None, 32, 32, 32,   110656      ['dropout_6[0][0]']              \n",
      "                                64)                                                               \n",
      "                                                                                                  \n",
      " conv3d_transpose_2 (Conv3DTran  (None, 64, 64, 64,   16416      ['conv3d_13[0][0]']              \n",
      " spose)                         32)                                                               \n",
      "                                                                                                  \n",
      " concatenate_2 (Concatenate)    (None, 64, 64, 64,   0           ['conv3d_transpose_2[0][0]',     \n",
      "                                64)                               'conv3d_3[0][0]']               \n",
      "                                                                                                  \n",
      " conv3d_14 (Conv3D)             (None, 64, 64, 64,   55328       ['concatenate_2[0][0]']          \n",
      "                                32)                                                               \n",
      "                                                                                                  \n",
      " dropout_7 (Dropout)            (None, 64, 64, 64,   0           ['conv3d_14[0][0]']              \n",
      "                                32)                                                               \n",
      "                                                                                                  \n",
      " conv3d_15 (Conv3D)             (None, 64, 64, 64,   27680       ['dropout_7[0][0]']              \n",
      "                                32)                                                               \n",
      "                                                                                                  \n",
      " conv3d_transpose_3 (Conv3DTran  (None, 128, 128, 12  4112       ['conv3d_15[0][0]']              \n",
      " spose)                         8, 16)                                                            \n",
      "                                                                                                  \n",
      " concatenate_3 (Concatenate)    (None, 128, 128, 12  0           ['conv3d_transpose_3[0][0]',     \n",
      "                                8, 32)                            'conv3d_1[0][0]']               \n",
      "                                                                                                  \n",
      " conv3d_16 (Conv3D)             (None, 128, 128, 12  13840       ['concatenate_3[0][0]']          \n",
      "                                8, 16)                                                            \n",
      "                                                                                                  \n",
      " dropout_8 (Dropout)            (None, 128, 128, 12  0           ['conv3d_16[0][0]']              \n",
      "                                8, 16)                                                            \n",
      "                                                                                                  \n",
      " conv3d_17 (Conv3D)             (None, 128, 128, 12  6928        ['dropout_8[0][0]']              \n",
      "                                8, 16)                                                            \n",
      "                                                                                                  \n",
      " conv3d_18 (Conv3D)             (None, 128, 128, 12  68          ['conv3d_17[0][0]']              \n",
      "                                8, 4)                                                             \n",
      "                                                                                                  \n",
      "==================================================================================================\n",
      "Total params: 5,645,828\n",
      "Trainable params: 5,645,828\n",
      "Non-trainable params: 0\n",
      "__________________________________________________________________________________________________\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "print(model.summary())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(None, 128, 128, 128, 3)\n",
      "(None, 128, 128, 128, 4)\n",
      "129\n",
      "43\n"
     ]
    }
   ],
   "source": [
    "print(model.input_shape)\n",
    "print(model.output_shape)\n",
    "print(steps_per_epoch)\n",
    "print(val_steps_per_epoch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/100\n",
      "129/129 [==============================] - 129s 919ms/step - loss: 2.5538 - acc: 0.3409 - recall_1: 0.2761 - precision_1: 0.5459 - iou: 0.2442 - val_loss: 2.4562 - val_acc: 0.4452 - val_recall_1: 0.4236 - val_precision_1: 0.8395 - val_iou: 0.3402\n",
      "Epoch 2/100\n",
      "129/129 [==============================] - 131s 1s/step - loss: 2.2991 - acc: 0.4664 - recall_1: 0.4418 - precision_1: 0.6355 - iou: 0.3339 - val_loss: 2.4528 - val_acc: 0.5112 - val_recall_1: 0.4689 - val_precision_1: 0.8348 - val_iou: 0.3765\n",
      "Epoch 3/100\n",
      "129/129 [==============================] - 137s 1s/step - loss: 2.2941 - acc: 0.4906 - recall_1: 0.4598 - precision_1: 0.6512 - iou: 0.3459 - val_loss: 2.4325 - val_acc: 0.4681 - val_recall_1: 0.4369 - val_precision_1: 0.8722 - val_iou: 0.3492\n",
      "Epoch 4/100\n",
      "129/129 [==============================] - 140s 1s/step - loss: 2.2568 - acc: 0.4727 - recall_1: 0.4522 - precision_1: 0.6291 - iou: 0.3393 - val_loss: 2.5685 - val_acc: 0.4980 - val_recall_1: 0.4548 - val_precision_1: 0.8667 - val_iou: 0.3897\n",
      "Epoch 5/100\n",
      "129/129 [==============================] - 141s 1s/step - loss: 2.2609 - acc: 0.4739 - recall_1: 0.4520 - precision_1: 0.5812 - iou: 0.3387 - val_loss: 2.3787 - val_acc: 0.4546 - val_recall_1: 0.4378 - val_precision_1: 0.6245 - val_iou: 0.3287\n",
      "Epoch 6/100\n",
      "129/129 [==============================] - 141s 1s/step - loss: 2.2458 - acc: 0.4703 - recall_1: 0.4485 - precision_1: 0.5833 - iou: 0.3332 - val_loss: 2.4070 - val_acc: 0.5558 - val_recall_1: 0.4889 - val_precision_1: 0.7156 - val_iou: 0.3966\n",
      "Epoch 7/100\n",
      "129/129 [==============================] - 139s 1s/step - loss: 2.2199 - acc: 0.4968 - recall_1: 0.4658 - precision_1: 0.5965 - iou: 0.3480 - val_loss: 2.7670 - val_acc: 0.5219 - val_recall_1: 0.4949 - val_precision_1: 0.7082 - val_iou: 0.3991\n",
      "Epoch 8/100\n",
      "129/129 [==============================] - 142s 1s/step - loss: 2.2272 - acc: 0.4899 - recall_1: 0.4700 - precision_1: 0.5679 - iou: 0.3470 - val_loss: 2.3734 - val_acc: 0.4908 - val_recall_1: 0.4698 - val_precision_1: 0.6035 - val_iou: 0.3614\n",
      "Epoch 9/100\n",
      "129/129 [==============================] - 148s 1s/step - loss: 2.2104 - acc: 0.4972 - recall_1: 0.4669 - precision_1: 0.6071 - iou: 0.3478 - val_loss: 2.3455 - val_acc: 0.5842 - val_recall_1: 0.5015 - val_precision_1: 0.7151 - val_iou: 0.3922\n",
      "Epoch 10/100\n",
      "129/129 [==============================] - 151s 1s/step - loss: 2.1816 - acc: 0.5145 - recall_1: 0.4747 - precision_1: 0.6289 - iou: 0.3571 - val_loss: 2.3222 - val_acc: 0.4673 - val_recall_1: 0.4380 - val_precision_1: 0.6983 - val_iou: 0.3383\n",
      "Epoch 11/100\n",
      "129/129 [==============================] - 154s 1s/step - loss: 2.2134 - acc: 0.4735 - recall_1: 0.4467 - precision_1: 0.5959 - iou: 0.3386 - val_loss: 2.5063 - val_acc: 0.5408 - val_recall_1: 0.4574 - val_precision_1: 0.8153 - val_iou: 0.3997\n",
      "Epoch 12/100\n",
      "129/129 [==============================] - 149s 1s/step - loss: 2.2240 - acc: 0.4754 - recall_1: 0.4458 - precision_1: 0.5951 - iou: 0.3381 - val_loss: 2.4254 - val_acc: 0.5155 - val_recall_1: 0.4714 - val_precision_1: 0.7571 - val_iou: 0.3883\n",
      "Epoch 13/100\n",
      "129/129 [==============================] - 151s 1s/step - loss: 2.1833 - acc: 0.4914 - recall_1: 0.4605 - precision_1: 0.6203 - iou: 0.3507 - val_loss: 2.4911 - val_acc: 0.5031 - val_recall_1: 0.4659 - val_precision_1: 0.7315 - val_iou: 0.3733\n",
      "Epoch 14/100\n",
      "129/129 [==============================] - 153s 1s/step - loss: 2.1859 - acc: 0.4978 - recall_1: 0.4636 - precision_1: 0.5974 - iou: 0.3508 - val_loss: 2.3776 - val_acc: 0.5926 - val_recall_1: 0.4854 - val_precision_1: 0.7460 - val_iou: 0.3977\n",
      "Epoch 15/100\n",
      "129/129 [==============================] - 156s 1s/step - loss: 2.1645 - acc: 0.5024 - recall_1: 0.4646 - precision_1: 0.5996 - iou: 0.3544 - val_loss: 2.3829 - val_acc: 0.5300 - val_recall_1: 0.4924 - val_precision_1: 0.6887 - val_iou: 0.3863\n",
      "Epoch 16/100\n",
      "129/129 [==============================] - 156s 1s/step - loss: 2.1409 - acc: 0.4902 - recall_1: 0.4646 - precision_1: 0.5922 - iou: 0.3531 - val_loss: 2.2611 - val_acc: 0.5006 - val_recall_1: 0.4694 - val_precision_1: 0.6531 - val_iou: 0.3736\n",
      "Epoch 17/100\n",
      "129/129 [==============================] - 156s 1s/step - loss: 2.1301 - acc: 0.4968 - recall_1: 0.4616 - precision_1: 0.5898 - iou: 0.3568 - val_loss: 2.2849 - val_acc: 0.5534 - val_recall_1: 0.4899 - val_precision_1: 0.7157 - val_iou: 0.4029\n",
      "Epoch 18/100\n",
      "129/129 [==============================] - 155s 1s/step - loss: 2.1211 - acc: 0.5049 - recall_1: 0.4662 - precision_1: 0.5909 - iou: 0.3612 - val_loss: 2.2961 - val_acc: 0.5446 - val_recall_1: 0.4893 - val_precision_1: 0.6728 - val_iou: 0.4023\n",
      "Epoch 19/100\n",
      "129/129 [==============================] - 150s 1s/step - loss: 2.0751 - acc: 0.5141 - recall_1: 0.4778 - precision_1: 0.5828 - iou: 0.3686 - val_loss: 2.2784 - val_acc: 0.5571 - val_recall_1: 0.5167 - val_precision_1: 0.6096 - val_iou: 0.4147\n",
      "Epoch 20/100\n",
      "129/129 [==============================] - 153s 1s/step - loss: 2.0430 - acc: 0.5182 - recall_1: 0.4796 - precision_1: 0.5850 - iou: 0.3732 - val_loss: 2.2171 - val_acc: 0.5418 - val_recall_1: 0.5027 - val_precision_1: 0.6185 - val_iou: 0.3960\n",
      "Epoch 21/100\n",
      "129/129 [==============================] - 151s 1s/step - loss: 2.0324 - acc: 0.5196 - recall_1: 0.4852 - precision_1: 0.5768 - iou: 0.3748 - val_loss: 2.2130 - val_acc: 0.5641 - val_recall_1: 0.5157 - val_precision_1: 0.6652 - val_iou: 0.4187\n",
      "Epoch 22/100\n",
      "129/129 [==============================] - 157s 1s/step - loss: 2.0031 - acc: 0.5267 - recall_1: 0.4901 - precision_1: 0.5885 - iou: 0.3824 - val_loss: 2.1813 - val_acc: 0.5609 - val_recall_1: 0.5194 - val_precision_1: 0.6115 - val_iou: 0.4222\n",
      "Epoch 23/100\n",
      "129/129 [==============================] - 154s 1s/step - loss: 1.9921 - acc: 0.5258 - recall_1: 0.4900 - precision_1: 0.5768 - iou: 0.3806 - val_loss: 2.1324 - val_acc: 0.5489 - val_recall_1: 0.5163 - val_precision_1: 0.5973 - val_iou: 0.4131\n",
      "Epoch 24/100\n",
      "129/129 [==============================] - 153s 1s/step - loss: 1.9935 - acc: 0.5233 - recall_1: 0.4873 - precision_1: 0.5814 - iou: 0.3790 - val_loss: 2.0817 - val_acc: 0.5500 - val_recall_1: 0.5133 - val_precision_1: 0.6035 - val_iou: 0.4076\n",
      "Epoch 25/100\n",
      "129/129 [==============================] - 149s 1s/step - loss: 1.9449 - acc: 0.5291 - recall_1: 0.4974 - precision_1: 0.5876 - iou: 0.3878 - val_loss: 2.0674 - val_acc: 0.5432 - val_recall_1: 0.5124 - val_precision_1: 0.5863 - val_iou: 0.4073\n",
      "Epoch 26/100\n",
      "100/129 [======================>.......] - ETA: 29s - loss: 2.0474 - acc: 0.5286 - recall_1: 0.4974 - precision_1: 0.5688 - iou: 0.3836"
     ]
    }
   ],
   "source": [
    "history=model.fit(train_img_datagen,\n",
    "          steps_per_epoch=steps_per_epoch,\n",
    "          epochs=100,\n",
    "          verbose=1,\n",
    "          validation_data=val_img_datagen,\n",
    "          validation_steps=val_steps_per_epoch,\n",
    "          )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.save('brats_3d.hdf5')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.models import load_model\n",
    "\n",
    "model=load_model('brats_3d.hdf5',custom_objects={'iou':iou})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean IoU = 0.75867593\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "unknown is not supported",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_33576/2728338859.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     16\u001b[0m \u001b[0mIOU_keras\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mupdate_state\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtest_pred_batch_argmax\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtest_mask_batch_argmax\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     17\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Mean IoU =\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mIOU_keras\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mresult\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnumpy\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 18\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mclassification_report\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtest_pred_batch\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mtest_mask_batch\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m~\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\sklearn\\metrics\\_classification.py\u001b[0m in \u001b[0;36mclassification_report\u001b[1;34m(y_true, y_pred, labels, target_names, sample_weight, digits, output_dict, zero_division)\u001b[0m\n\u001b[0;32m   2074\u001b[0m     \"\"\"\n\u001b[0;32m   2075\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2076\u001b[1;33m     \u001b[0my_type\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_true\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_pred\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_check_targets\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0my_true\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   2077\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2078\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mlabels\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\sklearn\\metrics\\_classification.py\u001b[0m in \u001b[0;36m_check_targets\u001b[1;34m(y_true, y_pred)\u001b[0m\n\u001b[0;32m    102\u001b[0m     \u001b[1;31m# No metrics support \"multiclass-multioutput\" format\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    103\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0my_type\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32min\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;34m\"binary\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"multiclass\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"multilabel-indicator\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 104\u001b[1;33m         \u001b[1;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"{0} is not supported\"\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0my_type\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    105\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    106\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0my_type\u001b[0m \u001b[1;32min\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;34m\"binary\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"multiclass\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: unknown is not supported"
     ]
    }
   ],
   "source": [
    "from keras.metrics import MeanIoU\n",
    "\n",
    "batch_size=4 #Check IoU for a batch of images\n",
    "test_img_datagen = imageLoader(val_img_dir, val_img_list, \n",
    "                                val_mask_dir, val_mask_list, batch_size)\n",
    "\n",
    "#Verify generator.... In python 3 next() is renamed as __next__()\n",
    "test_image_batch, test_mask_batch = test_img_datagen.__next__()\n",
    "\n",
    "test_mask_batch_argmax = np.argmax(test_mask_batch, axis=4)\n",
    "test_pred_batch = model.predict(test_image_batch)\n",
    "test_pred_batch_argmax = np.argmax(test_pred_batch, axis=4)\n",
    "\n",
    "n_classes = 4\n",
    "IOU_keras = MeanIoU(num_classes=n_classes)  \n",
    "IOU_keras.update_state(test_pred_batch_argmax, test_mask_batch_argmax)\n",
    "print(\"Mean IoU =\", IOU_keras.result().numpy())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import f1_score, precision_score, recall_score, confusion_matrix\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "unknown is not supported",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_33576/1743435792.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mfrom\u001b[0m \u001b[0msklearn\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmetrics\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mclassification_report\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mclassification_report\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtest_pred_batch\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mtest_mask_batch\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m~\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\sklearn\\metrics\\_classification.py\u001b[0m in \u001b[0;36mclassification_report\u001b[1;34m(y_true, y_pred, labels, target_names, sample_weight, digits, output_dict, zero_division)\u001b[0m\n\u001b[0;32m   2074\u001b[0m     \"\"\"\n\u001b[0;32m   2075\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2076\u001b[1;33m     \u001b[0my_type\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_true\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_pred\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_check_targets\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0my_true\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   2077\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2078\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mlabels\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\sklearn\\metrics\\_classification.py\u001b[0m in \u001b[0;36m_check_targets\u001b[1;34m(y_true, y_pred)\u001b[0m\n\u001b[0;32m    102\u001b[0m     \u001b[1;31m# No metrics support \"multiclass-multioutput\" format\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    103\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0my_type\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32min\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;34m\"binary\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"multiclass\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"multilabel-indicator\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 104\u001b[1;33m         \u001b[1;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"{0} is not supported\"\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0my_type\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    105\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    106\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0my_type\u001b[0m \u001b[1;32min\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;34m\"binary\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"multiclass\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: unknown is not supported"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import classification_report\n",
    "print(classification_report(test_pred_batch,test_mask_batch))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "img_num = 82\n",
    "\n",
    "test_img = np.load(\"BraTS2020_TrainingData/input_data_128/val/images/image_\"+str(img_num)+\".npy\")\n",
    "\n",
    "test_mask = np.load(\"BraTS2020_TrainingData/input_data_128/val/masks/mask_\"+str(img_num)+\".npy\")\n",
    "test_mask_argmax=np.argmax(test_mask, axis=3)\n",
    "\n",
    "test_img_input = np.expand_dims(test_img, axis=0)\n",
    "test_prediction = model.predict(test_img_input)\n",
    "test_prediction_argmax=np.argmax(test_prediction, axis=4)[0,:,:,:]\n",
    "\n",
    "\n",
    "\n",
    "from matplotlib import pyplot as plt\n",
    "import random\n",
    "\n",
    "n_slice = 55\n",
    "plt.figure(figsize=(12, 8))\n",
    "plt.subplot(231)\n",
    "plt.title('Testing Image')\n",
    "plt.imshow(test_img[:,:,n_slice,1], cmap='gray')\n",
    "plt.subplot(232)\n",
    "plt.title('Testing Label')\n",
    "plt.imshow(test_mask_argmax[:,:,n_slice])\n",
    "plt.subplot(233)\n",
    "plt.title('Prediction on test image')\n",
    "plt.imshow(test_prediction_argmax[:,:, n_slice])\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'optim' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_33576/1553715792.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m    169\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[0mmodel\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    170\u001b[0m \u001b[0mmodel2\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mAttention_ResUNet\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minput_shape\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m128\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m128\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m128\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mNUM_CLASSES\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdropout_rate\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m0.3\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mbatch_norm\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 171\u001b[1;33m \u001b[0mmodel2\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcompile\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0moptimizer\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0moptim\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mloss\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mloss\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmetrics\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmetrics\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    172\u001b[0m \u001b[0mmodel2\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msummary\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    173\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmodel2\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0minput_shape\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'optim' is not defined"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras.metrics import MeanIoU\n",
    "import os\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.layers import Input, Conv3D, MaxPooling3D, concatenate, Conv3DTranspose, BatchNormalization, Dropout, Lambda\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "from tensorflow.keras.metrics import MeanIoU\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras import models, layers, regularizers\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras import backend as K\n",
    "from tensorflow.keras.metrics import MeanIoU\n",
    "\n",
    "metrics = [\"acc\", tf.keras.metrics.Recall(), tf.keras.metrics.Precision(), iou]\n",
    "def weighted_categorical_crossentropy(weights):\n",
    "    def wcce(y_true, y_pred):\n",
    "        Kweights = K.constant(weights)\n",
    "        y_true = K.cast(y_true, y_pred.dtype)\n",
    "        return K.categorical_crossentropy(y_true, y_pred) * K.sum(y_true * Kweights, axis=-1)\n",
    "    return wcce\n",
    "loss=weighted_categorical_crossentropy([0.25,54.34,54.34,27.97])\n",
    "from tensorflow.keras import models, layers, regularizers\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras import backend as K\n",
    "\n",
    "def res_conv_block(x, filter_size, size, dropout, batch_norm=False):\n",
    "    conv = layers.Conv3D(size, (filter_size, filter_size, filter_size), padding='same')(x)\n",
    "    if batch_norm is True:\n",
    "        conv = layers.BatchNormalization(axis=4)(conv)\n",
    "    conv = layers.Activation('relu')(conv)\n",
    "    \n",
    "    conv = layers.Conv3D(size, (filter_size, filter_size, filter_size), padding='same')(conv)\n",
    "    if batch_norm is True:\n",
    "        conv = layers.BatchNormalization(axis=4)(conv)\n",
    "    #conv = layers.Activation('relu')(conv)    #Activation before addition with shortcut\n",
    "    if dropout > 0:\n",
    "        conv = layers.Dropout(dropout)(conv)\n",
    "\n",
    "    shortcut = layers.Conv3D(size, kernel_size=(1, 1, 1), padding='same')(x)\n",
    "    if batch_norm is True:\n",
    "        shortcut = layers.BatchNormalization(axis=4)(shortcut)\n",
    "\n",
    "    res_path = layers.add([shortcut, conv])\n",
    "    res_path = layers.Activation('relu')(res_path)    #Activation after addition with shortcut (Original residual block)\n",
    "    return res_path\n",
    "\n",
    "def gating_signal(input, out_size, batch_norm=False):\n",
    "    \"\"\"\n",
    "    resize the down layer feature map into the same dimension as the up layer feature map\n",
    "    using 1x1 conv\n",
    "    :return: the gating feature map with the same dimension of the up layer feature map\n",
    "    \"\"\"\n",
    "    x = layers.Conv3D(out_size, (1, 1, 1), padding='same')(input)\n",
    "    if batch_norm:\n",
    "        x = layers.BatchNormalization()(x)\n",
    "    x = layers.Activation('relu')(x)\n",
    "    return x\n",
    "\n",
    "def attention_block(x, gating, inter_shape):\n",
    "    shape_x = K.int_shape(x)\n",
    "    shape_g = K.int_shape(gating)\n",
    "\n",
    "# Getting the x signal to the same shape as the gating signal\n",
    "    theta_x = layers.Conv3D(inter_shape, (2, 2, 2), strides=(2, 2, 2), padding='same')(x)  # 16\n",
    "    shape_theta_x = K.int_shape(theta_x)\n",
    "\n",
    "# Getting the gating signal to the same number of filters as the inter_shape\n",
    "    phi_g = layers.Conv3D(inter_shape, (1, 1, 1), padding='same')(gating)\n",
    "    upsample_g = layers.Conv3DTranspose(inter_shape, (3, 3, 3),\n",
    "                                 strides=(shape_theta_x[1] // shape_g[1], shape_theta_x[2] // shape_g[2], shape_theta_x[3] // shape_g[3]),\n",
    "                                 padding='same')(phi_g)  # 16\n",
    "\n",
    "    concat_xg = layers.add([upsample_g, theta_x])\n",
    "    act_xg = layers.Activation('relu')(concat_xg)\n",
    "    psi = layers.Conv3D(1, (1, 1, 1), padding='same')(act_xg)\n",
    "    sigmoid_xg = layers.Activation('softmax')(psi)\n",
    "    shape_sigmoid = K.int_shape(sigmoid_xg)\n",
    "    upsample_psi = layers.UpSampling3D(size=(shape_x[1] // shape_sigmoid[1], shape_x[2] // shape_sigmoid[2], shape_x[3] // shape_sigmoid[3]))(sigmoid_xg)  # 32\n",
    "\n",
    "    upsample_psi = repeat_elem(upsample_psi, shape_x[4])\n",
    "\n",
    "    y = layers.multiply([upsample_psi, x])\n",
    "\n",
    "    result = layers.Conv3D(shape_x[4], (1, 1, 1), padding='same')(y)\n",
    "    result_bn = layers.BatchNormalization()(result)\n",
    "    return result_bn\n",
    "\n",
    "\n",
    "\n",
    "def repeat_elem(tensor, rep):\n",
    "    # lambda function to repeat Repeats the elements of a tensor along an axis\n",
    "    #by a factor of rep.\n",
    "    # If tensor has shape (None, 256,256,3), lambda will return a tensor of shape \n",
    "    #(None, 256,256,6), if specified axis=3 and rep=2.\n",
    "\n",
    "     return layers.Lambda(lambda x, repnum: K.repeat_elements(x, repnum, axis=4),\n",
    "                          arguments={'repnum': rep})(tensor)\n",
    "\n",
    "\n",
    "\n",
    "def Attention_ResUNet(input_shape, NUM_CLASSES, dropout_rate=0.2, batch_norm=True):\n",
    "    '''\n",
    "    Rsidual UNet, with attention \n",
    "    \n",
    "    '''\n",
    "    # network structure\n",
    "    FILTER_NUM = 8\n",
    "    FILTER_SIZE = 3 # size of the convolutional filter\n",
    "    UP_SAMP_SIZE = 2 # size of upsampling filters\n",
    "    # input data\n",
    "    # dimension of the image depth\n",
    "    inputs = layers.Input(input_shape, dtype=tf.float32)\n",
    "    axis = 4\n",
    "\n",
    "    # Downsampling layers\n",
    "    # DownRes 1, double residual convolution + pooling\n",
    "    conv_128 = res_conv_block(inputs, FILTER_SIZE, FILTER_NUM, dropout_rate, batch_norm)\n",
    "    pool_64 = layers.MaxPooling3D(pool_size=(2,2,2))(conv_128)\n",
    "    # DownRes 2\n",
    "    conv_64 = res_conv_block(pool_64, FILTER_SIZE, 2*FILTER_NUM, dropout_rate, batch_norm)\n",
    "    pool_32 = layers.MaxPooling3D(pool_size=(2,2,2))(conv_64)\n",
    "    # DownRes 3\n",
    "    conv_32 = res_conv_block(pool_32, FILTER_SIZE, 4*FILTER_NUM, dropout_rate, batch_norm)\n",
    "    pool_16 = layers.MaxPooling3D(pool_size=(2,2,2))(conv_32)\n",
    "    # DownRes 4\n",
    "    conv_16 = res_conv_block(pool_16, FILTER_SIZE, 8*FILTER_NUM, dropout_rate, batch_norm)\n",
    "    pool_8 = layers.MaxPooling3D(pool_size=(2,2,2))(conv_16)\n",
    "    # DownRes 5, convolution only\n",
    "    conv_8 = res_conv_block(pool_8, FILTER_SIZE, 16*FILTER_NUM, dropout_rate, batch_norm)\n",
    "\n",
    "    # Upsampling layers\n",
    "    # UpRes 6, attention gated concatenation + upsampling + double residual convolution\n",
    "    gating_16 = gating_signal(conv_8, 8*FILTER_NUM, batch_norm)\n",
    "    att_16 = attention_block(conv_16, gating_16, 8*FILTER_NUM)\n",
    "    up_16 = layers.UpSampling3D(size=(UP_SAMP_SIZE, UP_SAMP_SIZE, UP_SAMP_SIZE), data_format=\"channels_last\")(conv_8)\n",
    "    up_16 = layers.concatenate([up_16, att_16 ], axis=axis)\n",
    "    up_conv_16 = res_conv_block(up_16, FILTER_SIZE, 8*FILTER_NUM, dropout_rate, batch_norm)\n",
    "    # UpRes 7\n",
    "    gating_32 = gating_signal(up_conv_16, 4*FILTER_NUM, batch_norm)\n",
    "    att_32 = attention_block(conv_32, gating_32, 4*FILTER_NUM)\n",
    "    up_32 = layers.UpSampling3D(size=(UP_SAMP_SIZE, UP_SAMP_SIZE, UP_SAMP_SIZE), data_format=\"channels_last\")(up_conv_16)\n",
    "    up_32 = layers.concatenate([up_32, att_32], axis=axis)\n",
    "    up_conv_32 = res_conv_block(up_32, FILTER_SIZE, 4*FILTER_NUM, dropout_rate, batch_norm)\n",
    "    # UpRes 8\n",
    "    gating_64 = gating_signal(up_conv_32, 2*FILTER_NUM, batch_norm)\n",
    "    att_64 = attention_block(conv_64, gating_64, 2*FILTER_NUM)\n",
    "    up_64 = layers.UpSampling3D(size=(UP_SAMP_SIZE, UP_SAMP_SIZE, UP_SAMP_SIZE), data_format=\"channels_last\")(up_conv_32)\n",
    "    up_64 = layers.concatenate([up_64, att_64], axis=axis)\n",
    "    up_conv_64 = res_conv_block(up_64, FILTER_SIZE, 2*FILTER_NUM, dropout_rate, batch_norm)\n",
    "    # UpRes 9\n",
    "    gating_128 = gating_signal(up_conv_64, FILTER_NUM, batch_norm)\n",
    "    att_128 = attention_block(conv_128, gating_128, FILTER_NUM)\n",
    "    up_128 = layers.UpSampling3D(size=(UP_SAMP_SIZE, UP_SAMP_SIZE, UP_SAMP_SIZE), data_format=\"channels_last\")(up_conv_64)\n",
    "    up_128 = layers.concatenate([up_128, att_128], axis=axis)\n",
    "    up_conv_128 = res_conv_block(up_128, FILTER_SIZE, FILTER_NUM, dropout_rate, batch_norm)\n",
    "\n",
    "    # 1*1 convolutional layers\n",
    "    \n",
    "    conv_final = layers.Conv3D(NUM_CLASSES, kernel_size=(1,1,1))(up_conv_128)\n",
    "    conv_final = layers.BatchNormalization(axis=axis)(conv_final)\n",
    "    conv_final = layers.Activation('softmax')(conv_final)  #Change to softmax for multichannel\n",
    "\n",
    "    # Model integration\n",
    "    model = models.Model(inputs, conv_final, name=\"AttentionResUNet\")\n",
    "    return model\n",
    "model2=Attention_ResUNet(input_shape=(128,128,128,3), NUM_CLASSES=4, dropout_rate=0.3, batch_norm=True)\n",
    "model2.compile(optimizer = optim, loss=loss, metrics=metrics)\n",
    "model2.summary()\n",
    "print(model2.input_shape)\n",
    "print(model2.output_shape)\n",
    "steps_per_epoch=len(train_img_list)//batch_size\n",
    "val_steps_per_epoch=len(val_img_list)//batch_size\n",
    "history=model2.fit(train_img_datagen,\n",
    "          steps_per_epoch=steps_per_epoch,\n",
    "          epochs=100,\n",
    "          verbose=1,\n",
    "          validation_data=val_img_datagen,\n",
    "          validation_steps=val_steps_per_epoch,\n",
    "          )\n",
    "model2.save('brats_3d_attention.hdf5')\n",
    "\n",
    "\n",
    "img_num=82\n",
    "test_img = np.load(\"BraTS2020_TrainingData/input_data_128/val/images/image_\"+str(img_num)+\".npy\")\n",
    "test_mask = np.load(\"BraTS2020_TrainingData/input_data_128/val/masks/mask_\"+str(img_num)+\".npy\")\n",
    "\n",
    "test_mask_argmax = np.argmax(test_mask, axis=3)\n",
    "test_img_input = np.expand_dims(test_img, axis=0)\n",
    "test_prediction = model2.predict(test_img_input)\n",
    "test_prediction_argmax = np.argmax(test_prediction, axis=4)[0,:,:,:]\n",
    "\n",
    "from matplotlib import pyplot as plt\n",
    "import random\n",
    "\n",
    "n_slice = 55\n",
    "plt.figure(figsize=(12,8))\n",
    "plt.subplot(231)\n",
    "plt.title('Testing Image')\n",
    "plt.imsave(\"imageplot_attent.png\",test_img[:,:,n_slice,1])\n",
    "plt.subplot(232)\n",
    "plt.title('Testing Label')\n",
    "plt.imsave(\"labelplot_attent.png\",test_mask_argmax[:,:,n_slice])\n",
    "plt.subplot(233)\n",
    "plt.title('Prediction on test image')\n",
    "plt.imsave(\"predimage_attent.png\",test_prediction_argmax[:,:,n_slice])\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def weighted_categorical_crossentropy(weights):\n",
    "    def wcce(y_true, y_pred):\n",
    "        Kweights = K.constant(weights)\n",
    "        y_true = K.cast(y_true, y_pred.dtype)\n",
    "        return K.categorical_crossentropy(y_true, y_pred) * K.sum(y_true * Kweights, axis=-1)\n",
    "    return wcce\n",
    "loss=weighted_categorical_crossentropy([0.25,54.34,54.34,27.97])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "model2=load_model('brats_3d_attention.hdf5',custom_objects={'iou':iou,'wcce':loss})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "ename": "ResourceExhaustedError",
     "evalue": " OOM when allocating tensor with shape[6,32,128,128,128] and type float on /job:localhost/replica:0/task:0/device:GPU:0 by allocator GPU_0_bfc\n\t [[node model_2/concatenate_11/concat\n (defined at C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\backend.py:3224)\n]]\nHint: If you want to see a list of allocated tensors when OOM happens, add report_tensor_allocations_upon_oom to RunOptions for current allocation info. This isn't available when running in Eager mode.\n [Op:__inference_predict_function_23122]\n\nErrors may have originated from an input operation.\nInput Source operations connected to node model_2/concatenate_11/concat:\nIn[0] model_2/conv3d_transpose_11/BiasAdd (defined at C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\layers\\convolutional.py:1660)\t\nIn[1] model_2/conv3d_39/Relu (defined at C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\backend.py:4867)\t\nIn[2] model_2/concatenate_11/concat/axis:\n\nOperation defined at: (most recent call last)\n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\runpy.py\", line 197, in _run_module_as_main\n>>>     return _run_code(code, main_globals, None,\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\runpy.py\", line 87, in _run_code\n>>>     exec(code, run_globals)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\ipykernel_launcher.py\", line 16, in <module>\n>>>     app.launch_new_instance()\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\traitlets\\config\\application.py\", line 846, in launch_instance\n>>>     app.start()\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\ipykernel\\kernelapp.py\", line 677, in start\n>>>     self.io_loop.start()\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\tornado\\platform\\asyncio.py\", line 199, in start\n>>>     self.asyncio_loop.run_forever()\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\asyncio\\base_events.py\", line 596, in run_forever\n>>>     self._run_once()\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\asyncio\\base_events.py\", line 1890, in _run_once\n>>>     handle._run()\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\asyncio\\events.py\", line 80, in _run\n>>>     self._context.run(self._callback, *self._args)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 457, in dispatch_queue\n>>>     await self.process_one()\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 446, in process_one\n>>>     await dispatch(*args)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 353, in dispatch_shell\n>>>     await result\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 648, in execute_request\n>>>     reply_content = await reply_content\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\ipykernel\\ipkernel.py\", line 353, in do_execute\n>>>     res = shell.run_cell(code, store_history=store_history, silent=silent)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\ipykernel\\zmqshell.py\", line 533, in run_cell\n>>>     return super(ZMQInteractiveShell, self).run_cell(*args, **kwargs)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 2901, in run_cell\n>>>     result = self._run_cell(\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 2947, in _run_cell\n>>>     return runner(coro)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\IPython\\core\\async_helpers.py\", line 68, in _pseudo_sync_runner\n>>>     coro.send(None)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 3172, in run_cell_async\n>>>     has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 3364, in run_ast_nodes\n>>>     if (await self.run_code(code, result,  async_=asy)):\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 3444, in run_code\n>>>     exec(code_obj, self.user_global_ns, self.user_ns)\n>>> \n>>>   File \"C:\\Users\\karth\\AppData\\Local\\Temp/ipykernel_33576/1892531261.py\", line 10, in <module>\n>>>     test_pred_batch = model.predict(test_image_batch)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n>>>     return fn(*args, **kwargs)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\engine\\training.py\", line 1789, in predict\n>>>     tmp_batch_outputs = self.predict_function(iterator)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\engine\\training.py\", line 1621, in predict_function\n>>>     return step_function(self, iterator)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\engine\\training.py\", line 1611, in step_function\n>>>     outputs = model.distribute_strategy.run(run_step, args=(data,))\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\engine\\training.py\", line 1604, in run_step\n>>>     outputs = model.predict_step(data)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\engine\\training.py\", line 1572, in predict_step\n>>>     return self(x, training=False)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n>>>     return fn(*args, **kwargs)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\engine\\base_layer.py\", line 1083, in __call__\n>>>     outputs = call_fn(inputs, *args, **kwargs)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 92, in error_handler\n>>>     return fn(*args, **kwargs)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\engine\\functional.py\", line 451, in call\n>>>     return self._run_internal_graph(\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\engine\\functional.py\", line 589, in _run_internal_graph\n>>>     outputs = node.layer(*args, **kwargs)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n>>>     return fn(*args, **kwargs)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\engine\\base_layer.py\", line 1083, in __call__\n>>>     outputs = call_fn(inputs, *args, **kwargs)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 92, in error_handler\n>>>     return fn(*args, **kwargs)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\layers\\merge.py\", line 183, in call\n>>>     return self._merge_function(inputs)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\layers\\merge.py\", line 528, in _merge_function\n>>>     return backend.concatenate(inputs, axis=self.axis)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\backend.py\", line 3224, in concatenate\n>>>     return tf.concat([to_dense(x) for x in tensors], axis)\n>>> ",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mResourceExhaustedError\u001b[0m                    Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_33576/1892531261.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      8\u001b[0m \u001b[0mtest_image_batch\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtest_mask_batch\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtest_img_datagen\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__next__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      9\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 10\u001b[1;33m \u001b[0mtest_pred_batch\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtest_image_batch\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     11\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     12\u001b[0m \u001b[0mn_classes\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m4\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\utils\\traceback_utils.py\u001b[0m in \u001b[0;36merror_handler\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m     65\u001b[0m     \u001b[1;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[1;33m:\u001b[0m  \u001b[1;31m# pylint: disable=broad-except\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     66\u001b[0m       \u001b[0mfiltered_tb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_process_traceback_frames\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0me\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__traceback__\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 67\u001b[1;33m       \u001b[1;32mraise\u001b[0m \u001b[0me\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mwith_traceback\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfiltered_tb\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mfrom\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     68\u001b[0m     \u001b[1;32mfinally\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     69\u001b[0m       \u001b[1;32mdel\u001b[0m \u001b[0mfiltered_tb\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python39\\site-packages\\tensorflow\\python\\eager\\execute.py\u001b[0m in \u001b[0;36mquick_execute\u001b[1;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[0;32m     56\u001b[0m   \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     57\u001b[0m     \u001b[0mctx\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mensure_initialized\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 58\u001b[1;33m     tensors = pywrap_tfe.TFE_Py_Execute(ctx._handle, device_name, op_name,\n\u001b[0m\u001b[0;32m     59\u001b[0m                                         inputs, attrs, num_outputs)\n\u001b[0;32m     60\u001b[0m   \u001b[1;32mexcept\u001b[0m \u001b[0mcore\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_NotOkStatusException\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mResourceExhaustedError\u001b[0m:  OOM when allocating tensor with shape[6,32,128,128,128] and type float on /job:localhost/replica:0/task:0/device:GPU:0 by allocator GPU_0_bfc\n\t [[node model_2/concatenate_11/concat\n (defined at C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\backend.py:3224)\n]]\nHint: If you want to see a list of allocated tensors when OOM happens, add report_tensor_allocations_upon_oom to RunOptions for current allocation info. This isn't available when running in Eager mode.\n [Op:__inference_predict_function_23122]\n\nErrors may have originated from an input operation.\nInput Source operations connected to node model_2/concatenate_11/concat:\nIn[0] model_2/conv3d_transpose_11/BiasAdd (defined at C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\layers\\convolutional.py:1660)\t\nIn[1] model_2/conv3d_39/Relu (defined at C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\backend.py:4867)\t\nIn[2] model_2/concatenate_11/concat/axis:\n\nOperation defined at: (most recent call last)\n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\runpy.py\", line 197, in _run_module_as_main\n>>>     return _run_code(code, main_globals, None,\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\runpy.py\", line 87, in _run_code\n>>>     exec(code, run_globals)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\ipykernel_launcher.py\", line 16, in <module>\n>>>     app.launch_new_instance()\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\traitlets\\config\\application.py\", line 846, in launch_instance\n>>>     app.start()\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\ipykernel\\kernelapp.py\", line 677, in start\n>>>     self.io_loop.start()\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\tornado\\platform\\asyncio.py\", line 199, in start\n>>>     self.asyncio_loop.run_forever()\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\asyncio\\base_events.py\", line 596, in run_forever\n>>>     self._run_once()\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\asyncio\\base_events.py\", line 1890, in _run_once\n>>>     handle._run()\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\asyncio\\events.py\", line 80, in _run\n>>>     self._context.run(self._callback, *self._args)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 457, in dispatch_queue\n>>>     await self.process_one()\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 446, in process_one\n>>>     await dispatch(*args)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 353, in dispatch_shell\n>>>     await result\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 648, in execute_request\n>>>     reply_content = await reply_content\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\ipykernel\\ipkernel.py\", line 353, in do_execute\n>>>     res = shell.run_cell(code, store_history=store_history, silent=silent)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\ipykernel\\zmqshell.py\", line 533, in run_cell\n>>>     return super(ZMQInteractiveShell, self).run_cell(*args, **kwargs)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 2901, in run_cell\n>>>     result = self._run_cell(\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 2947, in _run_cell\n>>>     return runner(coro)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\IPython\\core\\async_helpers.py\", line 68, in _pseudo_sync_runner\n>>>     coro.send(None)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 3172, in run_cell_async\n>>>     has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 3364, in run_ast_nodes\n>>>     if (await self.run_code(code, result,  async_=asy)):\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 3444, in run_code\n>>>     exec(code_obj, self.user_global_ns, self.user_ns)\n>>> \n>>>   File \"C:\\Users\\karth\\AppData\\Local\\Temp/ipykernel_33576/1892531261.py\", line 10, in <module>\n>>>     test_pred_batch = model.predict(test_image_batch)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n>>>     return fn(*args, **kwargs)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\engine\\training.py\", line 1789, in predict\n>>>     tmp_batch_outputs = self.predict_function(iterator)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\engine\\training.py\", line 1621, in predict_function\n>>>     return step_function(self, iterator)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\engine\\training.py\", line 1611, in step_function\n>>>     outputs = model.distribute_strategy.run(run_step, args=(data,))\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\engine\\training.py\", line 1604, in run_step\n>>>     outputs = model.predict_step(data)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\engine\\training.py\", line 1572, in predict_step\n>>>     return self(x, training=False)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n>>>     return fn(*args, **kwargs)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\engine\\base_layer.py\", line 1083, in __call__\n>>>     outputs = call_fn(inputs, *args, **kwargs)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 92, in error_handler\n>>>     return fn(*args, **kwargs)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\engine\\functional.py\", line 451, in call\n>>>     return self._run_internal_graph(\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\engine\\functional.py\", line 589, in _run_internal_graph\n>>>     outputs = node.layer(*args, **kwargs)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n>>>     return fn(*args, **kwargs)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\engine\\base_layer.py\", line 1083, in __call__\n>>>     outputs = call_fn(inputs, *args, **kwargs)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 92, in error_handler\n>>>     return fn(*args, **kwargs)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\layers\\merge.py\", line 183, in call\n>>>     return self._merge_function(inputs)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\layers\\merge.py\", line 528, in _merge_function\n>>>     return backend.concatenate(inputs, axis=self.axis)\n>>> \n>>>   File \"C:\\Users\\karth\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\backend.py\", line 3224, in concatenate\n>>>     return tf.concat([to_dense(x) for x in tensors], axis)\n>>> "
     ]
    }
   ],
   "source": [
    "from keras.metrics import MeanIoU\n",
    "\n",
    "batch_size=6 \n",
    "test_img_datagen = imageLoader(val_img_dir, val_img_list, \n",
    "                                val_mask_dir, val_mask_list, batch_size)\n",
    "\n",
    "\n",
    "test_image_batch, test_mask_batch = test_img_datagen.__next__()\n",
    "\n",
    "test_pred_batch = model.predict(test_image_batch)\n",
    "\n",
    "n_classes = 4\n",
    "IOU_keras = MeanIoU(num_classes=n_classes)  \n",
    "IOU_keras.update_state(test_pred_batch, test_mask_batch)\n",
    "print(\"Mean IoU =\", IOU_keras.result().numpy())\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "img_num = 82\n",
    "\n",
    "test_img = np.load(\"BraTS2020_TrainingData/input_data_128/val/images/image_\"+str(img_num)+\".npy\")\n",
    "\n",
    "test_mask = np.load(\"BraTS2020_TrainingData/input_data_128/val/masks/mask_\"+str(img_num)+\".npy\")\n",
    "test_mask_argmax=np.argmax(test_mask, axis=3)\n",
    "\n",
    "test_img_input = np.expand_dims(test_img, axis=0)\n",
    "test_prediction = model2.predict(test_img_input)\n",
    "test_prediction_argmax=np.argmax(test_prediction, axis=4)[0,:,:,:]\n",
    "\n",
    "\n",
    "\n",
    "from matplotlib import pyplot as plt\n",
    "import random\n",
    "\n",
    "n_slice = 55\n",
    "plt.figure(figsize=(12, 8))\n",
    "plt.subplot(231)\n",
    "plt.title('Testing Image')\n",
    "plt.imshow(test_img[:,:,n_slice,1], cmap='gray')\n",
    "plt.subplot(232)\n",
    "plt.title('Testing Label')\n",
    "plt.imshow(test_mask_argmax[:,:,n_slice])\n",
    "plt.subplot(233)\n",
    "plt.title('Prediction on test image')\n",
    "plt.imshow(test_prediction_argmax[:,:, n_slice])\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 1\n",
    "\n",
    "train_img_datagen = imageLoader(train_img_dir, train_img_list, \n",
    "                                train_mask_dir, train_mask_list, batch_size)\n",
    "\n",
    "val_img_datagen = imageLoader(val_img_dir, val_img_list, \n",
    "                                val_mask_dir, val_mask_list, batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras import models, layers, regularizers\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras import backend as K\n",
    "\n",
    "def res_conv_block(x, filter_size, size, dropout, batch_norm=False):\n",
    "\n",
    "    conv = layers.Conv3D(size, (filter_size, filter_size, filter_size), padding='same')(x)\n",
    "    if batch_norm is True:\n",
    "        conv = layers.BatchNormalization(axis=4)(conv)\n",
    "    conv = layers.Activation('relu')(conv)\n",
    "    \n",
    "    conv = layers.Conv3D(size, (filter_size, filter_size, filter_size), padding='same')(conv)\n",
    "    if batch_norm is True:\n",
    "        conv = layers.BatchNormalization(axis=4)(conv)\n",
    "    if dropout > 0:\n",
    "        conv = layers.Dropout(dropout)(conv)\n",
    "\n",
    "    shortcut = layers.Conv3D(size, kernel_size=(1, 1, 1), padding='same')(x)\n",
    "    if batch_norm is True:\n",
    "        shortcut = layers.BatchNormalization(axis=4)(shortcut)\n",
    "\n",
    "    res_path = layers.add([shortcut, conv])\n",
    "    res_path = layers.Activation('relu')(res_path)   \n",
    "    return res_path\n",
    "\n",
    "\n",
    "def gating_signal(input, out_size, batch_norm=False):\n",
    "    x = layers.Conv3D(out_size, (1, 1, 1), padding='same')(input)\n",
    "    if batch_norm:\n",
    "        x = layers.BatchNormalization()(x)\n",
    "    x = layers.Activation('relu')(x)\n",
    "    return x\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "def attention_block(x, gating, inter_shape):\n",
    "    shape_x = K.int_shape(x)\n",
    "    shape_g = K.int_shape(gating)\n",
    "\n",
    "    theta_x = layers.Conv3D(inter_shape, (2, 2, 2), strides=(2, 2, 2), padding='same')(x)  # 16\n",
    "    shape_theta_x = K.int_shape(theta_x)\n",
    "\n",
    "    phi_g = layers.Conv3D(inter_shape, (1, 1, 1), padding='same')(gating)\n",
    "    upsample_g = layers.Conv3DTranspose(inter_shape, (3, 3, 3),\n",
    "                                 strides=(shape_theta_x[1] // shape_g[1], shape_theta_x[2] // shape_g[2], shape_theta_x[3] // shape_g[3]),\n",
    "                                 padding='same')(phi_g)  # 16\n",
    "\n",
    "    concat_xg = layers.add([upsample_g, theta_x])\n",
    "    act_xg = layers.Activation('relu')(concat_xg)\n",
    "    psi = layers.Conv3D(1, (1, 1, 1), padding='same')(act_xg)\n",
    "    sigmoid_xg = layers.Activation('sigmoid')(psi)\n",
    "    shape_sigmoid = K.int_shape(sigmoid_xg)\n",
    "    upsample_psi = layers.UpSampling3D(size=(shape_x[1] // shape_sigmoid[1], shape_x[2] // shape_sigmoid[2], shape_x[3] // shape_sigmoid[3]))(sigmoid_xg)  # 32\n",
    "\n",
    "    upsample_psi = repeat_elem(upsample_psi, shape_x[4])\n",
    "\n",
    "    y = layers.multiply([upsample_psi, x])\n",
    "\n",
    "    result = layers.Conv3D(shape_x[4], (1, 1, 1), padding='same')(y)\n",
    "    result_bn = layers.BatchNormalization()(result)\n",
    "    return result_bn\n",
    "\n",
    "\n",
    "\n",
    "def repeat_elem(tensor, rep):\n",
    "\n",
    "     return layers.Lambda(lambda x, repnum: K.repeat_elements(x, repnum, axis=4),\n",
    "                          arguments={'repnum': rep})(tensor)\n",
    "\n",
    "\n",
    "\n",
    "def Attention_ResUNet(input_shape, NUM_CLASSES=1, dropout_rate=0.0, batch_norm=True):\n",
    "\n",
    "\n",
    "    FILTER_NUM = 16 \n",
    "    FILTER_SIZE = 2 \n",
    "    UP_SAMP_SIZE = 2\n",
    "    inputs = layers.Input(input_shape, dtype=tf.float32)\n",
    "    axis = 4\n",
    "\n",
    "\n",
    "    conv_128 = res_conv_block(inputs, FILTER_SIZE, FILTER_NUM, dropout_rate, batch_norm)\n",
    "    pool_64 = layers.MaxPooling3D(pool_size=(2,2,2))(conv_128)\n",
    "\n",
    "    conv_64 = res_conv_block(pool_64, FILTER_SIZE, 2*FILTER_NUM, dropout_rate, batch_norm)\n",
    "    pool_32 = layers.MaxPooling3D(pool_size=(2,2,2))(conv_64)\n",
    "\n",
    "    conv_32 = res_conv_block(pool_32, FILTER_SIZE, 4*FILTER_NUM, dropout_rate, batch_norm)\n",
    "    pool_16 = layers.MaxPooling3D(pool_size=(2,2,2))(conv_32)\n",
    "\n",
    "    conv_16 = res_conv_block(pool_16, FILTER_SIZE, 8*FILTER_NUM, dropout_rate, batch_norm)\n",
    "    pool_8 = layers.MaxPooling3D(pool_size=(2,2,2))(conv_16)\n",
    "\n",
    "    conv_8 = res_conv_block(pool_8, FILTER_SIZE, 16*FILTER_NUM, dropout_rate, batch_norm)\n",
    "\n",
    "    gating_16 = gating_signal(conv_8, 8*FILTER_NUM, batch_norm)\n",
    "    att_16 = attention_block(conv_16, gating_16, 8*FILTER_NUM)\n",
    "    up_16 = layers.UpSampling3D(size=(UP_SAMP_SIZE, UP_SAMP_SIZE, UP_SAMP_SIZE), data_format=\"channels_last\")(conv_8)\n",
    "    up_16 = layers.concatenate([up_16, att_16 ], axis=axis)\n",
    "    up_conv_16 = res_conv_block(up_16, FILTER_SIZE, 8*FILTER_NUM, dropout_rate, batch_norm)\n",
    "\n",
    "    gating_32 = gating_signal(up_conv_16, 4*FILTER_NUM, batch_norm)\n",
    "    att_32 = attention_block(conv_32, gating_32, 4*FILTER_NUM)\n",
    "    up_32 = layers.UpSampling3D(size=(UP_SAMP_SIZE, UP_SAMP_SIZE, UP_SAMP_SIZE), data_format=\"channels_last\")(up_conv_16)\n",
    "    up_32 = layers.concatenate([up_32, att_32], axis=axis)\n",
    "    up_conv_32 = res_conv_block(up_32, FILTER_SIZE, 4*FILTER_NUM, dropout_rate, batch_norm)\n",
    "\n",
    "    gating_64 = gating_signal(up_conv_32, 2*FILTER_NUM, batch_norm)\n",
    "    att_64 = attention_block(conv_64, gating_64, 2*FILTER_NUM)\n",
    "    up_64 = layers.UpSampling3D(size=(UP_SAMP_SIZE, UP_SAMP_SIZE, UP_SAMP_SIZE), data_format=\"channels_last\")(up_conv_32)\n",
    "    up_64 = layers.concatenate([up_64, att_64], axis=axis)\n",
    "    up_conv_64 = res_conv_block(up_64, FILTER_SIZE, 2*FILTER_NUM, dropout_rate, batch_norm)\n",
    "\n",
    "    gating_128 = gating_signal(up_conv_64, FILTER_NUM, batch_norm)\n",
    "    att_128 = attention_block(conv_128, gating_128, FILTER_NUM)\n",
    "    up_128 = layers.UpSampling3D(size=(UP_SAMP_SIZE, UP_SAMP_SIZE, UP_SAMP_SIZE), data_format=\"channels_last\")(up_conv_64)\n",
    "    up_128 = layers.concatenate([up_128, att_128], axis=axis)\n",
    "    up_conv_128 = res_conv_block(up_128, FILTER_SIZE, FILTER_NUM, dropout_rate, batch_norm)\n",
    "\n",
    "    \n",
    "    conv_final = layers.Conv3D(NUM_CLASSES, kernel_size=(1,1,1))(up_conv_128)\n",
    "    conv_final = layers.BatchNormalization(axis=axis)(conv_final)\n",
    "    conv_final = layers.Activation('sigmoid')(conv_final)  #Change to softmax for multichannel\n",
    "\n",
    "\n",
    "    model = models.Model(inputs, conv_final, name=\"AttentionResUNet\")\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_43424/3082896205.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mmodel2\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mAttention_ResUNet\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minput_shape\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m128\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m128\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m128\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mNUM_CLASSES\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdropout_rate\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m0.0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mbatch_norm\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_43424/3420290267.py\u001b[0m in \u001b[0;36mAttention_ResUNet\u001b[1;34m(input_shape, NUM_CLASSES, dropout_rate, batch_norm)\u001b[0m\n\u001b[0;32m     82\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     83\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 84\u001b[1;33m     \u001b[0mconv_128\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mres_conv_block\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minputs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mFILTER_SIZE\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mFILTER_NUM\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdropout_rate\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mbatch_norm\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     85\u001b[0m     \u001b[0mpool_64\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mlayers\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mMaxPooling3D\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpool_size\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mconv_128\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     86\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_43424/3420290267.py\u001b[0m in \u001b[0;36mres_conv_block\u001b[1;34m(x, filter_size, size, dropout, batch_norm)\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mres_conv_block\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfilter_size\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msize\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdropout\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mbatch_norm\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mFalse\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m     \u001b[0mconv\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mlayers\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mConv3D\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msize\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mfilter_size\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfilter_size\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfilter_size\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mpadding\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'same'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      8\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mbatch_norm\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mTrue\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      9\u001b[0m         \u001b[0mconv\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mlayers\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mBatchNormalization\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0maxis\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mconv\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\utils\\traceback_utils.py\u001b[0m in \u001b[0;36merror_handler\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m     62\u001b[0m     \u001b[0mfiltered_tb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     63\u001b[0m     \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 64\u001b[1;33m       \u001b[1;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     65\u001b[0m     \u001b[1;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[1;33m:\u001b[0m  \u001b[1;31m# pylint: disable=broad-except\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     66\u001b[0m       \u001b[0mfiltered_tb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_process_traceback_frames\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0me\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__traceback__\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\engine\\base_layer.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1017\u001b[0m     \u001b[1;31m# >> model = tf.keras.Model(inputs, outputs)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1018\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0m_in_functional_construction_mode\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minputs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minput_list\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1019\u001b[1;33m       return self._functional_construction_call(inputs, args, kwargs,\n\u001b[0m\u001b[0;32m   1020\u001b[0m                                                 input_list)\n\u001b[0;32m   1021\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\engine\\base_layer.py\u001b[0m in \u001b[0;36m_functional_construction_call\u001b[1;34m(self, inputs, args, kwargs, input_list)\u001b[0m\n\u001b[0;32m   1158\u001b[0m         layer=self, inputs=inputs, build_graph=True, training=training_value):\n\u001b[0;32m   1159\u001b[0m       \u001b[1;31m# Check input assumptions set after layer building, e.g. input shape.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1160\u001b[1;33m       outputs = self._keras_tensor_symbolic_call(\n\u001b[0m\u001b[0;32m   1161\u001b[0m           inputs, input_masks, args, kwargs)\n\u001b[0;32m   1162\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\engine\\base_layer.py\u001b[0m in \u001b[0;36m_keras_tensor_symbolic_call\u001b[1;34m(self, inputs, input_masks, args, kwargs)\u001b[0m\n\u001b[0;32m    883\u001b[0m       \u001b[1;32mreturn\u001b[0m \u001b[0mtf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnest\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmap_structure\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkeras_tensor\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mKerasTensor\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0moutput_signature\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    884\u001b[0m     \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 885\u001b[1;33m       \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_infer_output_signature\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minputs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minput_masks\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    886\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    887\u001b[0m   \u001b[1;32mdef\u001b[0m \u001b[0m_infer_output_signature\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minputs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minput_masks\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\engine\\base_layer.py\u001b[0m in \u001b[0;36m_infer_output_signature\u001b[1;34m(self, inputs, args, kwargs, input_masks)\u001b[0m\n\u001b[0;32m    926\u001b[0m           \u001b[1;31m# overridden).\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    927\u001b[0m           \u001b[1;31m# TODO(kaftan): do we maybe_build here, or have we already done it?\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 928\u001b[1;33m           \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_maybe_build\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minputs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    929\u001b[0m           \u001b[0minputs\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_maybe_cast_inputs\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minputs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    930\u001b[0m           \u001b[0moutputs\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcall_fn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minputs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\engine\\base_layer.py\u001b[0m in \u001b[0;36m_maybe_build\u001b[1;34m(self, inputs)\u001b[0m\n\u001b[0;32m   2722\u001b[0m         \u001b[1;31m# operations.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2723\u001b[0m         \u001b[1;32mwith\u001b[0m \u001b[0mtf_utils\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmaybe_init_scope\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2724\u001b[1;33m           \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbuild\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minput_shapes\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# pylint:disable=not-callable\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   2725\u001b[0m       \u001b[1;31m# We must set also ensure that the layer is marked as built, and the build\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2726\u001b[0m       \u001b[1;31m# shape is stored since user defined build functions may not be calling\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\layers\\convolutional.py\u001b[0m in \u001b[0;36mbuild\u001b[1;34m(self, input_shape)\u001b[0m\n\u001b[0;32m    197\u001b[0m     \u001b[0moutput_shape\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcompute_output_shape\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minput_shape\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    198\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 199\u001b[1;33m     self.kernel = self.add_weight(\n\u001b[0m\u001b[0;32m    200\u001b[0m         \u001b[0mname\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'kernel'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    201\u001b[0m         \u001b[0mshape\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mkernel_shape\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\engine\\base_layer.py\u001b[0m in \u001b[0;36madd_weight\u001b[1;34m(self, name, shape, dtype, initializer, regularizer, trainable, constraint, use_resource, synchronization, aggregation, **kwargs)\u001b[0m\n\u001b[0;32m    664\u001b[0m         \u001b[0mcaching_device\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    665\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 666\u001b[1;33m     variable = self._add_variable_with_custom_getter(\n\u001b[0m\u001b[0;32m    667\u001b[0m         \u001b[0mname\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    668\u001b[0m         \u001b[0mshape\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python39\\site-packages\\tensorflow\\python\\training\\tracking\\base.py\u001b[0m in \u001b[0;36m_add_variable_with_custom_getter\u001b[1;34m(self, name, shape, dtype, initializer, getter, overwrite, **kwargs_for_getter)\u001b[0m\n\u001b[0;32m    814\u001b[0m         \u001b[1;31m# \"best effort\" to set the initializer with the highest restore UID.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    815\u001b[0m         \u001b[0minitializer\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcheckpoint_initializer\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 816\u001b[1;33m     new_variable = getter(\n\u001b[0m\u001b[0;32m    817\u001b[0m         \u001b[0mname\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    818\u001b[0m         \u001b[0mshape\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\engine\\base_layer_utils.py\u001b[0m in \u001b[0;36mmake_variable\u001b[1;34m(name, shape, dtype, initializer, trainable, caching_device, validate_shape, constraint, use_resource, collections, synchronization, aggregation, partitioner)\u001b[0m\n\u001b[0;32m    115\u001b[0m   \u001b[1;31m# However, this breaks legacy (Estimator) checkpoints\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    116\u001b[0m   \u001b[1;31m# because it changes variable names. Remove this when V1 is fully deprecated.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 117\u001b[1;33m   return tf.compat.v1.Variable(\n\u001b[0m\u001b[0;32m    118\u001b[0m       \u001b[0minitial_value\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0minit_val\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    119\u001b[0m       \u001b[0mname\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python39\\site-packages\\tensorflow\\python\\util\\traceback_utils.py\u001b[0m in \u001b[0;36merror_handler\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m    148\u001b[0m     \u001b[0mfiltered_tb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    149\u001b[0m     \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 150\u001b[1;33m       \u001b[1;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    151\u001b[0m     \u001b[1;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    152\u001b[0m       \u001b[0mfiltered_tb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_process_traceback_frames\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0me\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__traceback__\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python39\\site-packages\\tensorflow\\python\\ops\\variables.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(cls, *args, **kwargs)\u001b[0m\n\u001b[0;32m    266\u001b[0m   \u001b[1;32mdef\u001b[0m \u001b[0m__call__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcls\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    267\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mcls\u001b[0m \u001b[1;32mis\u001b[0m \u001b[0mVariableV1\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 268\u001b[1;33m       \u001b[1;32mreturn\u001b[0m \u001b[0mcls\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_variable_v1_call\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    269\u001b[0m     \u001b[1;32melif\u001b[0m \u001b[0mcls\u001b[0m \u001b[1;32mis\u001b[0m \u001b[0mVariable\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    270\u001b[0m       \u001b[1;32mreturn\u001b[0m \u001b[0mcls\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_variable_v2_call\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python39\\site-packages\\tensorflow\\python\\ops\\variables.py\u001b[0m in \u001b[0;36m_variable_v1_call\u001b[1;34m(cls, initial_value, trainable, collections, validate_shape, caching_device, name, variable_def, dtype, expected_shape, import_scope, constraint, use_resource, synchronization, aggregation, shape)\u001b[0m\n\u001b[0;32m    211\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0maggregation\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    212\u001b[0m       \u001b[0maggregation\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mVariableAggregation\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mNONE\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 213\u001b[1;33m     return previous_getter(\n\u001b[0m\u001b[0;32m    214\u001b[0m         \u001b[0minitial_value\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0minitial_value\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    215\u001b[0m         \u001b[0mtrainable\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtrainable\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python39\\site-packages\\tensorflow\\python\\ops\\variables.py\u001b[0m in \u001b[0;36m<lambda>\u001b[1;34m(**kwargs)\u001b[0m\n\u001b[0;32m    204\u001b[0m                         shape=None):\n\u001b[0;32m    205\u001b[0m     \u001b[1;34m\"\"\"Call on Variable class. Useful to force the signature.\"\"\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 206\u001b[1;33m     \u001b[0mprevious_getter\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mlambda\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mdefault_variable_creator\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    207\u001b[0m     \u001b[1;32mfor\u001b[0m \u001b[0m_\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgetter\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mops\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_default_graph\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_variable_creator_stack\u001b[0m\u001b[1;33m:\u001b[0m  \u001b[1;31m# pylint: disable=protected-access\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    208\u001b[0m       \u001b[0mprevious_getter\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_make_getter\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mgetter\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mprevious_getter\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python39\\site-packages\\tensorflow\\python\\ops\\variable_scope.py\u001b[0m in \u001b[0;36mdefault_variable_creator\u001b[1;34m(next_creator, **kwargs)\u001b[0m\n\u001b[0;32m   2610\u001b[0m   \u001b[1;32mif\u001b[0m \u001b[0muse_resource\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2611\u001b[0m     \u001b[0mdistribute_strategy\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"distribute_strategy\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2612\u001b[1;33m     return resource_variable_ops.ResourceVariable(\n\u001b[0m\u001b[0;32m   2613\u001b[0m         \u001b[0minitial_value\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0minitial_value\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2614\u001b[0m         \u001b[0mtrainable\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtrainable\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python39\\site-packages\\tensorflow\\python\\util\\traceback_utils.py\u001b[0m in \u001b[0;36merror_handler\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m    148\u001b[0m     \u001b[0mfiltered_tb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    149\u001b[0m     \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 150\u001b[1;33m       \u001b[1;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    151\u001b[0m     \u001b[1;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    152\u001b[0m       \u001b[0mfiltered_tb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_process_traceback_frames\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0me\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__traceback__\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python39\\site-packages\\tensorflow\\python\\ops\\variables.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(cls, *args, **kwargs)\u001b[0m\n\u001b[0;32m    270\u001b[0m       \u001b[1;32mreturn\u001b[0m \u001b[0mcls\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_variable_v2_call\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    271\u001b[0m     \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 272\u001b[1;33m       \u001b[1;32mreturn\u001b[0m \u001b[0msuper\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mVariableMetaclass\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcls\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__call__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    273\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    274\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python39\\site-packages\\tensorflow\\python\\ops\\resource_variable_ops.py\u001b[0m in \u001b[0;36m__init__\u001b[1;34m(self, initial_value, trainable, collections, validate_shape, caching_device, name, dtype, variable_def, import_scope, constraint, distribute_strategy, synchronization, aggregation, shape)\u001b[0m\n\u001b[0;32m   1628\u001b[0m       \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_init_from_proto\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mvariable_def\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mimport_scope\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mimport_scope\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1629\u001b[0m     \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1630\u001b[1;33m       self._init_from_args(\n\u001b[0m\u001b[0;32m   1631\u001b[0m           \u001b[0minitial_value\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0minitial_value\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1632\u001b[0m           \u001b[0mtrainable\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtrainable\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python39\\site-packages\\tensorflow\\python\\ops\\resource_variable_ops.py\u001b[0m in \u001b[0;36m_init_from_args\u001b[1;34m(self, initial_value, trainable, collections, caching_device, name, dtype, constraint, synchronization, aggregation, distribute_strategy, shape)\u001b[0m\n\u001b[0;32m   1774\u001b[0m           \u001b[1;32mwith\u001b[0m \u001b[0mops\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mname_scope\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Initializer\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdevice_context_manager\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1775\u001b[0m             \u001b[1;32mif\u001b[0m \u001b[0minit_from_fn\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1776\u001b[1;33m               \u001b[0minitial_value\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0minitial_value\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1777\u001b[0m             \u001b[1;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minitial_value\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtrackable\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mCheckpointInitialValue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1778\u001b[0m               \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_maybe_initialize_trackable\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\initializers\\initializers_v2.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self, shape, dtype, **kwargs)\u001b[0m\n\u001b[0;32m    532\u001b[0m     \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    533\u001b[0m       \u001b[0mlimit\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmath\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m3.0\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mscale\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 534\u001b[1;33m       \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_random_generator\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrandom_uniform\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m-\u001b[0m\u001b[0mlimit\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlimit\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    535\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    536\u001b[0m   \u001b[1;32mdef\u001b[0m \u001b[0mget_config\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\envs\\tf_proj\\lib\\site-packages\\keras\\backend.py\u001b[0m in \u001b[0;36mrandom_uniform\u001b[1;34m(self, shape, minval, maxval, dtype)\u001b[0m\n\u001b[0;32m   1829\u001b[0m       return self._generator.uniform(\n\u001b[0;32m   1830\u001b[0m           shape=shape, minval=minval, maxval=maxval, dtype=dtype)\n\u001b[1;32m-> 1831\u001b[1;33m     return tf.random.uniform(\n\u001b[0m\u001b[0;32m   1832\u001b[0m         \u001b[0mshape\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mminval\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mminval\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmaxval\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmaxval\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mdtype\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1833\u001b[0m         seed=self.make_legacy_seed())\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python39\\site-packages\\tensorflow\\python\\util\\traceback_utils.py\u001b[0m in \u001b[0;36merror_handler\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m    148\u001b[0m     \u001b[0mfiltered_tb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    149\u001b[0m     \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 150\u001b[1;33m       \u001b[1;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    151\u001b[0m     \u001b[1;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    152\u001b[0m       \u001b[0mfiltered_tb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_process_traceback_frames\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0me\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__traceback__\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python39\\site-packages\\tensorflow\\python\\util\\dispatch.py\u001b[0m in \u001b[0;36mop_dispatch_handler\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m   1094\u001b[0m       \u001b[1;31m# Fallback dispatch system (dispatch v1):\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1095\u001b[0m       \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1096\u001b[1;33m         \u001b[1;32mreturn\u001b[0m \u001b[0mdispatch_target\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1097\u001b[0m       \u001b[1;32mexcept\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mTypeError\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mValueError\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1098\u001b[0m         \u001b[1;31m# Note: convert_to_eager_tensor currently raises a ValueError, not a\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python39\\site-packages\\tensorflow\\python\\ops\\random_ops.py\u001b[0m in \u001b[0;36mrandom_uniform\u001b[1;34m(shape, minval, maxval, dtype, seed, name)\u001b[0m\n\u001b[0;32m    302\u001b[0m     \u001b[0mmaxval_is_one\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0misinstance\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmaxval\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mint\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mand\u001b[0m \u001b[0mmaxval\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    303\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0mminval_is_zero\u001b[0m \u001b[1;32mor\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0mmaxval_is_one\u001b[0m \u001b[1;32mor\u001b[0m \u001b[0mdtype\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mis_integer\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 304\u001b[1;33m       \u001b[0mminval\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mops\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconvert_to_tensor\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mminval\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mdtype\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mname\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m\"min\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    305\u001b[0m       \u001b[0mmaxval\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mops\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconvert_to_tensor\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmaxval\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mdtype\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mname\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m\"max\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    306\u001b[0m     \u001b[0mseed1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mseed2\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mrandom_seed\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_seed\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mseed\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python39\\site-packages\\tensorflow\\python\\profiler\\trace.py\u001b[0m in \u001b[0;36mwrapped\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m    161\u001b[0m         \u001b[1;32mwith\u001b[0m \u001b[0mTrace\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtrace_name\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mtrace_kwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    162\u001b[0m           \u001b[1;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 163\u001b[1;33m       \u001b[1;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    164\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    165\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[0mwrapped\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python39\\site-packages\\tensorflow\\python\\framework\\ops.py\u001b[0m in \u001b[0;36mconvert_to_tensor\u001b[1;34m(value, dtype, name, as_ref, preferred_dtype, dtype_hint, ctx, accepted_result_types)\u001b[0m\n\u001b[0;32m   1619\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1620\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mret\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1621\u001b[1;33m       \u001b[0mret\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mconversion_func\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mdtype\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mname\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mas_ref\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mas_ref\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1622\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1623\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mret\u001b[0m \u001b[1;32mis\u001b[0m \u001b[0mNotImplemented\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python39\\site-packages\\tensorflow\\python\\framework\\tensor_conversion_registry.py\u001b[0m in \u001b[0;36m_default_conversion_function\u001b[1;34m(***failed resolving arguments***)\u001b[0m\n\u001b[0;32m     50\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0m_default_conversion_function\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mname\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mas_ref\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     51\u001b[0m   \u001b[1;32mdel\u001b[0m \u001b[0mas_ref\u001b[0m  \u001b[1;31m# Unused.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 52\u001b[1;33m   \u001b[1;32mreturn\u001b[0m \u001b[0mconstant_op\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconstant\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mname\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     53\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     54\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python39\\site-packages\\tensorflow\\python\\framework\\constant_op.py\u001b[0m in \u001b[0;36mconstant\u001b[1;34m(value, dtype, shape, name)\u001b[0m\n\u001b[0;32m    269\u001b[0m     \u001b[0mValueError\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mcalled\u001b[0m \u001b[0mon\u001b[0m \u001b[0ma\u001b[0m \u001b[0msymbolic\u001b[0m \u001b[0mtensor\u001b[0m\u001b[1;33m.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    270\u001b[0m   \"\"\"\n\u001b[1;32m--> 271\u001b[1;33m   return _constant_impl(value, dtype, shape, name, verify_shape=False,\n\u001b[0m\u001b[0;32m    272\u001b[0m                         allow_broadcast=True)\n\u001b[0;32m    273\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python39\\site-packages\\tensorflow\\python\\framework\\constant_op.py\u001b[0m in \u001b[0;36m_constant_impl\u001b[1;34m(value, dtype, shape, name, verify_shape, allow_broadcast)\u001b[0m\n\u001b[0;32m    281\u001b[0m       \u001b[1;32mwith\u001b[0m \u001b[0mtrace\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mTrace\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"tf.constant\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    282\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[0m_constant_eager_impl\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mctx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mshape\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mverify_shape\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 283\u001b[1;33m     \u001b[1;32mreturn\u001b[0m \u001b[0m_constant_eager_impl\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mctx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mshape\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mverify_shape\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    284\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    285\u001b[0m   \u001b[0mg\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mops\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_default_graph\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python39\\site-packages\\tensorflow\\python\\framework\\constant_op.py\u001b[0m in \u001b[0;36m_constant_eager_impl\u001b[1;34m(ctx, value, dtype, shape, verify_shape)\u001b[0m\n\u001b[0;32m    306\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0m_constant_eager_impl\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mctx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mshape\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mverify_shape\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    307\u001b[0m   \u001b[1;34m\"\"\"Creates a constant on the current device.\"\"\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 308\u001b[1;33m   \u001b[0mt\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mconvert_to_eager_tensor\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mctx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    309\u001b[0m   \u001b[1;32mif\u001b[0m \u001b[0mshape\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    310\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[0mt\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "model2=Attention_ResUNet(input_shape=(128,128,128,3), NUM_CLASSES=4, dropout_rate=0.0, batch_norm=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model2.compile(optimizer = , loss='binary_crossentropy', metrics=metrics)\n",
    "model2.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(model2.input_shape)\n",
    "print(model2.output_shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_img_datagen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "history=model2.fit(train_img_datagen,\n",
    "          steps_per_epoch=steps_per_epoch,\n",
    "          epochs=100,\n",
    "          verbose=1,\n",
    "          validation_data=val_img_datagen,\n",
    "          validation_steps=val_steps_per_epoch,\n",
    "          )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Resnet 50 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "img_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_img_dir = \"BraTS2020_TrainingData/input_data_128/train/images/\"\n",
    "train_mask_dir = \"BraTS2020_TrainingData/input_data_128/train/masks/\"\n",
    "\n",
    "val_img_dir = \"BraTS2020_TrainingData/input_data_128/val/images/\"\n",
    "val_mask_dir = \"BraTS2020_TrainingData/input_data_128/val/masks/\"\n",
    "\n",
    "train_img_list=os.listdir(train_img_dir)\n",
    "train_mask_list = os.listdir(train_mask_dir)\n",
    "\n",
    "val_img_list=os.listdir(val_img_dir)\n",
    "val_mask_list = os.listdir(val_mask_dir)\n",
    "\n",
    "def load_img(img_dir, img_list):\n",
    "    images=[]\n",
    "    for i, image_name in enumerate(img_list):    \n",
    "        if (image_name.split('.')[1] == 'npy'):\n",
    "            \n",
    "            image = np.load(img_dir+image_name)\n",
    "                      \n",
    "            images.append(image)\n",
    "    images = np.array(images)\n",
    "    \n",
    "    return(images)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data_list=load_img(train_img_dir,train_img_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data_list.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_mask_list=load_img(train_mask_dir,train_mask_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_mask_list.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "val_data_list=load_img(val_img_dir,val_img_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "val_data_list.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "val_mask_list=load_img(val_mask_dir,val_mask_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "val_mask_list.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras import layers\n",
    "from tensorflow.keras import regularizers\n",
    "import tensorflow as tf\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "AUTO = tf.data.AUTOTUNE\n",
    "BATCH_SIZE = 1\n",
    "EPOCHS = 5\n",
    "CROP_TO = 32\n",
    "SEED = 26\n",
    "\n",
    "PROJECT_DIM = 2048\n",
    "LATENT_DIM = 512\n",
    "WEIGHT_DECAY = 0.0005"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def flip_random_crop(image):\n",
    "    image = tf.image.random_flip_left_right(image)\n",
    "    image = tf.image.random_crop(image, (CROP_TO, CROP_TO,CROP_TO,3))\n",
    "    return image\n",
    "\n",
    "\n",
    "def color_jitter(x, strength=[0.4, 0.4, 0.4, 0.1]):\n",
    "    x = tf.image.random_brightness(x, max_delta=0.8 * strength[0])\n",
    "    x = tf.image.random_contrast(\n",
    "        x, lower=1 - 0.8 * strength[1], upper=1 + 0.8 * strength[1]\n",
    "    )\n",
    "    x = tf.image.random_saturation(\n",
    "        x, lower=1 - 0.8 * strength[2], upper=1 + 0.8 * strength[2]\n",
    "    )\n",
    "    x = tf.image.random_hue(x, max_delta=0.2 * strength[3])\n",
    "    x = tf.clip_by_value(x, 0, 255)\n",
    "    return x\n",
    "\n",
    "\n",
    "def color_drop(x):\n",
    "    x = tf.image.rgb_to_grayscale(x)\n",
    "    x = tf.tile(x, [1, 1,1,3])\n",
    "    return x\n",
    "\n",
    "\n",
    "def random_apply(func, x, p):\n",
    "    if tf.random.uniform([], minval=0, maxval=1) < p:\n",
    "        return func(x)\n",
    "    else:\n",
    "        return x\n",
    "\n",
    "\n",
    "def custom_augment(image):\n",
    "    image = flip_random_crop(image)\n",
    "    image = random_apply(color_jitter, image, p=0.8)\n",
    "    image = random_apply(color_drop, image, p=0.2)\n",
    "    return image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# siam simclr implementation\n",
    "import os\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.layers import Input, Conv3D, MaxPooling3D, concatenate, Conv3DTranspose, BatchNormalization, Dropout, Lambda\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "from tensorflow.keras.metrics import MeanIoU\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras import models, layers, regularizers\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras import backend as K\n",
    "from tensorflow.keras.metrics import MeanIoU\n",
    "\n",
    "def weighted_categorical_crossentropy(weights):\n",
    "    def wcce(y_true, y_pred):\n",
    "        Kweights = K.constant(weights)\n",
    "        y_true = K.cast(y_true, y_pred.dtype)\n",
    "        return K.categorical_crossentropy(y_true, y_pred) * K.sum(y_true * Kweights, axis=-1)\n",
    "    return wcce\n",
    "\n",
    "\n",
    "def iou(y_true, y_pred):\n",
    "    def f(y_true, y_pred):\n",
    "        intersection = (y_true * y_pred).sum()\n",
    "        union = y_true.sum() + y_pred.sum() - intersection\n",
    "        x = (intersection + 1e-15) / (union + 1e-15)\n",
    "        x = x.astype(np.float32)\n",
    "        return x\n",
    "    return tf.numpy_function(f, [y_true, y_pred], tf.float32)\n",
    "\n",
    "metrics = [\"acc\", tf.keras.metrics.Recall(), tf.keras.metrics.Precision(), iou,tf.keras.metrics.MeanIoU(num_classes=4)]\n",
    "kernel_initializer =  'he_uniform'\n",
    "train_img_dir = \"BraTS2020_TrainingData/input_data_128/train/images/\"\n",
    "train_mask_dir = \"BraTS2020_TrainingData/input_data_128/train/masks/\"\n",
    "\n",
    "val_img_dir = \"BraTS2020_TrainingData/input_data_128/val/images/\"\n",
    "val_mask_dir = \"BraTS2020_TrainingData/input_data_128/val/masks/\"\n",
    "\n",
    "train_img_list=os.listdir(train_img_dir)\n",
    "train_mask_list = os.listdir(train_mask_dir)\n",
    "\n",
    "val_img_list=os.listdir(val_img_dir)\n",
    "val_mask_list = os.listdir(val_mask_dir)\n",
    "\n",
    "def load_img(img_dir, img_list):\n",
    "    images=[]\n",
    "    for i, image_name in enumerate(img_list):    \n",
    "        if (image_name.split('.')[1] == 'npy'):\n",
    "            image = np.load(img_dir+image_name)         \n",
    "            images.append(image)\n",
    "    images = np.array(images)\n",
    "    \n",
    "    return(images)\n",
    "\n",
    "\n",
    "def imageLoader(img_dir, img_list, mask_dir, mask_list, batch_size):\n",
    "\n",
    "    L = len(img_list)\n",
    "\n",
    "\n",
    "    while True:\n",
    "\n",
    "        batch_start = 0\n",
    "        batch_end = batch_size\n",
    "\n",
    "        while batch_start < L:\n",
    "            limit = min(batch_end, L)\n",
    "                       \n",
    "            X = load_img(img_dir, img_list[batch_start:limit])\n",
    "            Y = load_img(mask_dir, mask_list[batch_start:limit])\n",
    "\n",
    "            yield (X,Y) \n",
    "\n",
    "            batch_start += batch_size   \n",
    "            batch_end += batch_size\n",
    "\n",
    "\n",
    "train_data_list=load_img(train_img_dir,train_img_list)\n",
    "\n",
    "train_data_list.shape\n",
    "\n",
    "train_mask_list=load_img(train_mask_dir,train_mask_list)\n",
    "\n",
    "train_mask_list.shape\n",
    "\n",
    "val_data_list=load_img(val_img_dir,val_img_list)\n",
    "\n",
    "val_data_list.shape\n",
    "\n",
    "val_mask_list=load_img(val_mask_dir,val_mask_list)\n",
    "\n",
    "val_mask_list.shape\n",
    "\n",
    "from tensorflow.keras import layers\n",
    "from tensorflow.keras import regularizers\n",
    "import tensorflow as tf\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "AUTO = tf.data.experimental.AUTOTUNE\n",
    "BATCH_SIZE = 3\n",
    "EPOCHS =1 \n",
    "CROP_TO = 128\n",
    "SEED = 26\n",
    "\n",
    "PROJECT_DIM = 2048\n",
    "LATENT_DIM = 1024\n",
    "WEIGHT_DECAY = 0.0005\n",
    "\n",
    "\n",
    "def flip_random_crop(image):\n",
    "\n",
    "    image = tf.image.random_flip_left_right(image)\n",
    "    image = tf.image.random_crop(image, (CROP_TO, CROP_TO,CROP_TO,3))\n",
    "    return image\n",
    "\n",
    "\n",
    "def color_jitter(x, strength=[0.4, 0.6, 0.6, 0.1]):\n",
    "    x = tf.image.random_brightness(x, max_delta=0.5 * strength[0])\n",
    "    x = tf.image.random_contrast(\n",
    "        x, lower=1 - 0.7 * strength[1], upper=1 + 0.5 * strength[1]\n",
    "    )\n",
    "    x = tf.image.random_saturation(\n",
    "        x, lower=1 - 0.7 * strength[2], upper=1 + 0.5 * strength[2]\n",
    "    )\n",
    "    x = tf.image.random_hue(x, max_delta=0.2 * strength[3])\n",
    "\n",
    "    x = tf.clip_by_value(x, 0, 255)\n",
    "    return x\n",
    "\n",
    "\n",
    "def color_drop(x):\n",
    "    x = tf.image.rgb_to_grayscale(x)\n",
    "    x = tf.tile(x, [1, 1,1,3])\n",
    "    return x\n",
    "\n",
    "\n",
    "def random_apply(func, x, p):\n",
    "    if tf.random.uniform([], minval=0, maxval=1) < p:\n",
    "        return func(x)\n",
    "    else:\n",
    "        return x\n",
    "\n",
    "\n",
    "def custom_augment(image):\n",
    "\n",
    "    image = flip_random_crop(image)\n",
    "    image = random_apply(color_jitter, image, p=0.7)\n",
    "    image = random_apply(color_drop, image, p=0.3)\n",
    "    return image\n",
    "\n",
    "ssl_ds_one = tf.data.Dataset.from_tensor_slices(train_data_list[20:])\n",
    "ssl_ds_one = (\n",
    "    ssl_ds_one.shuffle(1024, seed=SEED)\n",
    "    .map(custom_augment, num_parallel_calls=AUTO)\n",
    "    .batch(BATCH_SIZE)\n",
    "    .prefetch(AUTO)\n",
    ")\n",
    "\n",
    "ssl_ds_two = tf.data.Dataset.from_tensor_slices(train_data_list[20:])\n",
    "ssl_ds_two = (\n",
    "    ssl_ds_two.shuffle(1024, seed=SEED)\n",
    "    .map(custom_augment, num_parallel_calls=AUTO)\n",
    "    .batch(BATCH_SIZE)\n",
    "    .prefetch(AUTO)\n",
    ")\n",
    "ssl_ds = tf.data.Dataset.zip((ssl_ds_one, ssl_ds_two))\n",
    "\n",
    "\n",
    "N = 2\n",
    "DEPTH = N * 9 + 2\n",
    "NUM_BLOCKS = ((DEPTH - 2) // 9) - 1\n",
    "\n",
    "def get_encoder():\n",
    "\n",
    "    inputs = layers.Input((CROP_TO, CROP_TO,CROP_TO,3))\n",
    "    s = inputs\n",
    "    c1 = Conv3D(16, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(s)\n",
    "    c1 = Conv3D(16, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(c1)\n",
    "    p1 = MaxPooling3D((2, 2, 2))(c1)   \n",
    "    c2 = Conv3D(32, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(p1)\n",
    "    c2 = Conv3D(32, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(c2)\n",
    "    p2 = MaxPooling3D((2, 2, 2))(c2)\n",
    "    c3 = Conv3D(64, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(p2)\n",
    "    c3 = Conv3D(64, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(c3)\n",
    "    p3 = MaxPooling3D((2,2,2))(c3)\n",
    "    c4 = Conv3D(128, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(p3)\n",
    "    c4 = Conv3D(128, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(c4)\n",
    "    p4 = MaxPooling3D(pool_size=(2, 2, 2))(c4)\n",
    "    c5 = Conv3D(256, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(p4)\n",
    "    c5 = Conv3D(256, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same',name='penulti')(c5)\n",
    "    x = layers.GlobalAveragePooling3D(name=\"backbone_pool\")(c5)\n",
    "    # Projection head.\n",
    "    x = layers.Dense(\n",
    "        PROJECT_DIM, use_bias=False, kernel_regularizer=regularizers.l2(WEIGHT_DECAY)\n",
    "    )(x)\n",
    "    x = layers.BatchNormalization()(x)\n",
    "    x = layers.ReLU()(x)\n",
    "    x = layers.Dense(\n",
    "        PROJECT_DIM, use_bias=False, kernel_regularizer=regularizers.l2(WEIGHT_DECAY)\n",
    "    )(x)\n",
    "    outputs = layers.BatchNormalization()(x)\n",
    "    return tf.keras.Model(inputs, outputs, name=\"encoder\")\n",
    "\n",
    "\n",
    "\n",
    "def get_predictor():\n",
    "    model = tf.keras.Sequential(\n",
    "        [\n",
    "\n",
    "            layers.Input((PROJECT_DIM,)),\n",
    "            layers.Dense(\n",
    "                LATENT_DIM,\n",
    "                use_bias=False,\n",
    "                kernel_regularizer=regularizers.l2(WEIGHT_DECAY),\n",
    "            ),\n",
    "            layers.ReLU(),\n",
    "            layers.BatchNormalization(),\n",
    "            layers.Dense(PROJECT_DIM),\n",
    "        ],\n",
    "        name=\"predictor\",\n",
    "    )\n",
    "    return model\n",
    "\n",
    "def compute_loss(p, z):\n",
    "\n",
    "    z = tf.stop_gradient(z)\n",
    "    p = tf.math.l2_normalize(p, axis=1)\n",
    "    z = tf.math.l2_normalize(z, axis=1)\n",
    "\n",
    "    return -tf.reduce_mean(tf.reduce_sum((p * z), axis=1))\n",
    "\n",
    "class SimSiam(tf.keras.Model):\n",
    "    def __init__(self, encoder, predictor):\n",
    "        super(SimSiam, self).__init__()\n",
    "        self.encoder = encoder\n",
    "        self.predictor = predictor\n",
    "        self.loss_tracker = tf.keras.metrics.Mean(name=\"loss\")\n",
    "\n",
    "    @property\n",
    "    def metrics(self):\n",
    "        return [self.loss_tracker]\n",
    "\n",
    "    def train_step(self, data):\n",
    "\n",
    "        ds_one, ds_two = data\n",
    "\n",
    "\n",
    "        with tf.GradientTape() as tape:\n",
    "            z1, z2 = self.encoder(ds_one), self.encoder(ds_two)\n",
    "            p1, p2 = self.predictor(z1), self.predictor(z2)\n",
    "\n",
    "            loss = compute_loss(p1, z2) / 2 + compute_loss(p2, z1) / 2\n",
    "\n",
    "\n",
    "        learnable_params = (\n",
    "            self.encoder.trainable_variables + self.predictor.trainable_variables\n",
    "        )\n",
    "        gradients = tape.gradient(loss, learnable_params)\n",
    "        self.optimizer.apply_gradients(zip(gradients, learnable_params))\n",
    "\n",
    "        # Monitor loss.\n",
    "        self.loss_tracker.update_state(loss)\n",
    "        return {\"loss\": self.loss_tracker.result()}\n",
    "\n",
    "num_training_samples = len(train_data_list)\n",
    "steps = EPOCHS * (num_training_samples // BATCH_SIZE)\n",
    "lr_decayed_fn = tf.compat.v1.train.cosine_decay(\n",
    "    learning_rate=0.003,global_step=tf.Variable(0),decay_steps=steps,alpha=0.0\n",
    ")\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "simsiam = SimSiam(get_encoder(), get_predictor())\n",
    "simsiam.compile(optimizer=tf.keras.optimizers.SGD(lr_decayed_fn,momentum=0.6))\n",
    "history = simsiam.fit(ssl_ds, epochs=EPOCHS)            \n",
    "\n",
    "plt.plot(history.history[\"loss\"])\n",
    "plt.grid()\n",
    "plt.title(\"Negative Cosine Similairty\")\n",
    "plt.show()\n",
    "\n",
    "train_ds = tf.data.Dataset.from_tensor_slices((train_data_list[0:20], train_mask_list[0:20]))\n",
    "test_ds = tf.data.Dataset.from_tensor_slices((val_data_list[0:50],val_mask_list[0:50]))\n",
    "\n",
    "train_ds = (\n",
    "    train_ds.shuffle(1024)\n",
    "    .map(lambda x, y: (flip_random_crop(x), y), num_parallel_calls=AUTO)\n",
    "    .batch(BATCH_SIZE)\n",
    "    .prefetch(AUTO)\n",
    ")\n",
    "test_ds = test_ds.batch(BATCH_SIZE).prefetch(AUTO)\n",
    "backbone = tf.keras.Model(\n",
    "    simsiam.encoder.input, simsiam.encoder.get_layer(\"penulti\").output\n",
    ")\n",
    "print(backbone.input_shape) \n",
    "print(backbone.output_shape)\n",
    "print(backbone.summary())\n",
    "\n",
    "backbone.trainable = False\n",
    "inputs = layers.Input((CROP_TO, CROP_TO,CROP_TO,3))\n",
    "x = backbone(inputs, training=False)\n",
    "\n",
    "u6 = Conv3DTranspose(128, (2, 2, 2), strides=(2, 2, 2), padding='same')(x)\n",
    "c6 = Conv3D(128, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(u6)\n",
    "c6 = Dropout(0.3)(c6)\n",
    "c6 = Conv3D(128, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(c6)\n",
    "u7 = Conv3DTranspose(64, (2, 2, 2), strides=(2, 2, 2), padding='same')(c6)\n",
    "c7 = Conv3D(64, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(u7)\n",
    "c7 = Dropout(0.3)(c7)\n",
    "c7 = Conv3D(64, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(c7)\n",
    "u8 = Conv3DTranspose(32, (2, 2, 2), strides=(2, 2, 2), padding='same')(c7)\n",
    "c8 = Conv3D(32, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(u8)\n",
    "c8 = Dropout(0.3)(c8)\n",
    "c8 = Conv3D(32, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(c8)\n",
    "u9 = Conv3DTranspose(16, (2, 2, 2), strides=(2, 2, 2), padding='same')(c8)\n",
    "c9 = Conv3D(16, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(u9)\n",
    "c9 = Dropout(0.1)(c9)\n",
    "c9 = Conv3D(16, (3, 3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same')(c9)\n",
    "outputs = Conv3D(4, (1, 1, 1), activation='softmax')(c9)\n",
    "linear_model = tf.keras.Model(inputs, outputs, name=\"linear_model\")\n",
    "loss=weighted_categorical_crossentropy([0.25,54.34,54.34,27.97])\n",
    "\n",
    "linear_model.compile(\n",
    "    loss=loss,\n",
    "    metrics=metrics,\n",
    "    optimizer=tf.keras.optimizers.Adam(lr_decayed_fn),\n",
    ")\n",
    "history = linear_model.fit(\n",
    "    train_ds, validation_data=test_ds, epochs=EPOCHS,\n",
    ")\n",
    "\n",
    "\n",
    "test_ds_11 = tf.data.Dataset.from_tensor_slices((val_data_list[50:],val_mask_list[50:]))\n",
    "\n",
    "\n",
    "test_ds_11 = test_ds.batch(BATCH_SIZE).prefetch(AUTO)\n",
    "\n",
    "print(linear_model.evaluate(test_ds_11))\n",
    "\n",
    "\n",
    "img_num=82\n",
    "test_img = np.load(\"BraTS2020_TrainingData/input_data_128/val/images/image_\"+str(img_num)+\".npy\")\n",
    "test_mask = np.load(\"BraTS2020_TrainingData/input_data_128/val/masks/mask_\"+str(img_num)+\".npy\")\n",
    "\n",
    "test_mask_argmax = np.argmax(test_mask, axis=3)\n",
    "test_img_input = np.expand_dims(test_img, axis=0)\n",
    "test_prediction = linear_model.predict(test_img_input)\n",
    "test_prediction_argmax = np.argmax(test_prediction, axis=4)[0,:,:,:]\n",
    "\n",
    "from matplotlib import pyplot as plt\n",
    "import random\n",
    "\n",
    "n_slice = 55\n",
    "plt.figure(figsize=(12,8))\n",
    "plt.subplot(231)\n",
    "plt.title('Testing Image')\n",
    "plt.imsave(\"imageplot.png\",test_img[:,:,n_slice,1])\n",
    "plt.subplot(232)\n",
    "plt.title('Testing Label')\n",
    "plt.imsave(\"labelplot.png\",test_mask_argmax[:,:,n_slice])\n",
    "plt.subplot(233)\n",
    "plt.title('Prediction on test image')\n",
    "plt.imsave(\"predimage.png\",test_prediction_argmax[:,:,n_slice])\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Residual attention U-Net\n",
    "\n",
    "def load_img(img_dir, img_list):\n",
    "    images=[]\n",
    "    for i, image_name in enumerate(img_list):    \n",
    "        if (image_name.split('.')[1] == 'npy'):\n",
    "            \n",
    "            image = np.load(img_dir+image_name)\n",
    "                      \n",
    "            images.append(image)\n",
    "    images = np.array(images)\n",
    "    \n",
    "    return(images)\n",
    "\n",
    "\n",
    "def imageLoader(img_dir, img_list, mask_dir, mask_list, batch_size):\n",
    "\n",
    "    L = len(img_list)\n",
    "\n",
    "    while True:\n",
    "\n",
    "        batch_start = 0\n",
    "        batch_end = batch_size\n",
    "\n",
    "        while batch_start < L:\n",
    "            limit = min(batch_end, L)\n",
    "                       \n",
    "            X = load_img(img_dir, img_list[batch_start:limit])\n",
    "            Y = load_img(mask_dir, mask_list[batch_start:limit])\n",
    "\n",
    "            yield (X,Y) \n",
    "\n",
    "            batch_start += batch_size   \n",
    "            batch_end += batch_size\n",
    "\n",
    "from matplotlib import pyplot as plt\n",
    "import random\n",
    "\n",
    "train_img_dir = \"BraTS2020_TrainingData/input_data_128/train/images/\"\n",
    "train_mask_dir = \"BraTS2020_TrainingData/input_data_128/train/masks/\"\n",
    "train_img_list=os.listdir(train_img_dir)\n",
    "train_mask_list = os.listdir(train_mask_dir)\n",
    "\n",
    "batch_size = 1\n",
    "\n",
    "train_img_datagen = imageLoader(train_img_dir, train_img_list, \n",
    "                                train_mask_dir, train_mask_list, batch_size)\n",
    "img, msk = train_img_datagen.__next__()\n",
    "img_num = random.randint(0,img.shape[0]-1)\n",
    "test_img=img[img_num]\n",
    "test_mask=msk[img_num]\n",
    "test_mask=np.argmax(test_mask, axis=3)\n",
    "n_slice=random.randint(0, test_mask.shape[2])\n",
    "plt.figure(figsize=(12, 8))\n",
    "plt.subplot(221)\n",
    "plt.imshow(test_img[:,:,n_slice, 0], cmap='gray')\n",
    "plt.title('Image flair')\n",
    "plt.subplot(222)\n",
    "plt.imshow(test_img[:,:,n_slice, 1], cmap='gray')\n",
    "plt.title('Image t1ce')\n",
    "plt.subplot(223)\n",
    "plt.imshow(test_img[:,:,n_slice, 2], cmap='gray')\n",
    "plt.title('Image t2')\n",
    "plt.subplot(224)\n",
    "plt.imshow(test_mask[:,:,n_slice])\n",
    "plt.title('Mask')\n",
    "plt.show()\n",
    "train_img_dir = \"BraTS2020_TrainingData/input_data_128/train/images/\"\n",
    "train_mask_dir = \"BraTS2020_TrainingData/input_data_128/train/masks/\"\n",
    "img_list = os.listdir(train_img_dir)\n",
    "msk_list = os.listdir(train_mask_dir)\n",
    "num_images = len(os.listdir(train_img_dir))\n",
    "img_num = random.randint(0,num_images-1)\n",
    "test_img = np.load(train_img_dir+img_list[img_num])\n",
    "test_mask = np.load(train_mask_dir+msk_list[img_num])\n",
    "test_mask = np.argmax(test_mask, axis=3)\n",
    "n_slice=random.randint(0, test_mask.shape[2])\n",
    "plt.figure(figsize=(12, 8))\n",
    "plt.subplot(221)\n",
    "plt.imshow(test_img[:,:,n_slice, 0], cmap='gray')\n",
    "plt.title('Image flair')\n",
    "plt.subplot(222)\n",
    "plt.imshow(test_img[:,:,n_slice, 1], cmap='gray')\n",
    "plt.title('Image t1ce')\n",
    "plt.subplot(223)\n",
    "plt.imshow(test_img[:,:,n_slice, 2], cmap='gray')\n",
    "plt.title('Image t2')\n",
    "plt.subplot(224)\n",
    "plt.imshow(test_mask[:,:,n_slice])\n",
    "plt.title('Mask')\n",
    "plt.show()\n",
    "train_img_dir = \"BraTS2020_TrainingData/input_data_128/train/images/\"\n",
    "train_mask_dir = \"BraTS2020_TrainingData/input_data_128/train/masks/\"\n",
    "val_img_dir = \"BraTS2020_TrainingData/input_data_128/val/images/\"\n",
    "val_mask_dir = \"BraTS2020_TrainingData/input_data_128/val/masks/\"\n",
    "train_img_list=os.listdir(train_img_dir)\n",
    "train_mask_list = os.listdir(train_mask_dir)\n",
    "val_img_list=os.listdir(val_img_dir)\n",
    "val_mask_list = os.listdir(val_mask_dir)\n",
    "batch_size = 2\n",
    "train_img_datagen = imageLoader(train_img_dir, train_img_list, \n",
    "                                train_mask_dir, train_mask_list, batch_size)\n",
    "val_img_datagen = imageLoader(val_img_dir, val_img_list, \n",
    "                                val_mask_dir, val_mask_list, batch_size)\n",
    "img, msk = train_img_datagen.__next__()\n",
    "img_num = random.randint(0,img.shape[0]-1)\n",
    "test_img=img[img_num]\n",
    "test_mask=msk[img_num]\n",
    "test_mask=np.argmax(test_mask, axis=3)\n",
    "n_slice=random.randint(0, test_mask.shape[2])\n",
    "plt.figure(figsize=(12, 8))\n",
    "plt.subplot(221)\n",
    "plt.imshow(test_img[:,:,n_slice, 0], cmap='gray')\n",
    "plt.title('Image flair')\n",
    "plt.subplot(222)\n",
    "plt.imshow(test_img[:,:,n_slice, 1], cmap='gray')\n",
    "plt.title('Image t1ce')\n",
    "plt.subplot(223)\n",
    "plt.imshow(test_img[:,:,n_slice, 2], cmap='gray')\n",
    "plt.title('Image t2')\n",
    "plt.subplot(224)\n",
    "plt.imshow(test_mask[:,:,n_slice])\n",
    "plt.title('Mask')\n",
    "plt.show()\n",
    "def iou(y_true, y_pred):\n",
    "    def f(y_true, y_pred):\n",
    "        intersection = (y_true * y_pred).sum()\n",
    "        union = y_true.sum() + y_pred.sum() - intersection\n",
    "        x = (intersection + 1e-15) / (union + 1e-15)\n",
    "        x = x.astype(np.float32)\n",
    "        return x\n",
    "    return tf.numpy_function(f, [y_true, y_pred], tf.float32)\n",
    "metrics = [\"acc\", tf.keras.metrics.Recall(), tf.keras.metrics.Precision(), iou]\n",
    "LR = 0.01\n",
    "optim = tf.keras.optimizers.Adam(LR)\n",
    "steps_per_epoch = len(train_img_list)//batch_size\n",
    "val_steps_per_epoch = len(val_img_list)//batch_size\n",
    "from tensorflow.keras import models, layers, regularizers\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras import backend as K\n",
    "def res_conv_block(x, filter_size, size, dropout, batch_norm=False):\n",
    "    conv = layers.Conv3D(size, (filter_size, filter_size, filter_size), padding='same')(x)\n",
    "    if batch_norm is True:\n",
    "        conv = layers.BatchNormalization(axis=4)(conv)\n",
    "    conv = layers.Activation('relu')(conv)\n",
    "    conv = layers.Conv3D(size, (filter_size, filter_size, filter_size), padding='same')(conv)\n",
    "    if batch_norm is True:\n",
    "        conv = layers.BatchNormalization(axis=4)(conv)\n",
    "    #conv = layers.Activation('relu')(conv)    #Activation before addition with shortcut\n",
    "    if dropout > 0:\n",
    "        conv = layers.Dropout(dropout)(conv)\n",
    "    shortcut = layers.Conv3D(size, kernel_size=(1, 1, 1), padding='same')(x)\n",
    "    if batch_norm is True:\n",
    "        shortcut = layers.BatchNormalization(axis=4)(shortcut)\n",
    "    res_path = layers.add([shortcut, conv])\n",
    "    res_path = layers.Activation('relu')(res_path)  \n",
    "    return res_path\n",
    "\n",
    "\n",
    "def gating_signal(input, out_size, batch_norm=False):\n",
    "    x = layers.Conv3D(out_size, (1, 1, 1), padding='same')(input)\n",
    "    if batch_norm:\n",
    "        x = layers.BatchNormalization()(x)\n",
    "    x = layers.Activation('relu')(x)\n",
    "    return x\n",
    "\n",
    "def attention_block(x, gating, inter_shape):\n",
    "    shape_x = K.int_shape(x)\n",
    "    shape_g = K.int_shape(gating)\n",
    "    theta_x = layers.Conv3D(inter_shape, (2, 2, 2), strides=(2, 2, 2), padding='same')(x)  # 16\n",
    "    shape_theta_x = K.int_shape(theta_x)\n",
    "\n",
    "    phi_g = layers.Conv3D(inter_shape, (1, 1, 1), padding='same')(gating)\n",
    "    upsample_g = layers.Conv3DTranspose(inter_shape, (3, 3, 3),\n",
    "                                 strides=(shape_theta_x[1] // shape_g[1], shape_theta_x[2] // shape_g[2], shape_theta_x[3] // shape_g[3]),\n",
    "                                padding='same')(phi_g)  # 16\n",
    "    concat_xg = layers.add([upsample_g, theta_x])\n",
    "    act_xg = layers.Activation('relu')(concat_xg)\n",
    "    psi = layers.Conv3D(1, (1, 1, 1), padding='same')(act_xg)\n",
    "    sigmoid_xg = layers.Activation('softmax')(psi)\n",
    "    shape_sigmoid = K.int_shape(sigmoid_xg)\n",
    "    upsample_psi = layers.UpSampling3D(size=(shape_x[1] // shape_sigmoid[1], shape_x[2] // shape_sigmoid[2], shape_x[3] // shape_sigmoid[3]))(sigmoid_xg)  # 32\n",
    "    upsample_psi = repeat_elem(upsample_psi, shape_x[4])\n",
    "    y = layers.multiply([upsample_psi, x])\n",
    "    result = layers.Conv3D(shape_x[4], (1, 1, 1), padding='same')(y)\n",
    "    result_bn = layers.BatchNormalization()(result)\n",
    "    return result_bn\n",
    "\n",
    "\n",
    "\n",
    "def repeat_elem(tensor, rep):\n",
    "     return layers.Lambda(lambda x, repnum: K.repeat_elements(x, repnum, axis=4),\n",
    "                          arguments={'repnum': rep})(tensor)\n",
    "def Attention_ResUNet(input_shape, NUM_CLASSES, dropout_rate=0.2, batch_norm=True):\n",
    "    FILTER_NUM = 16\n",
    "    FILTER_SIZE = 3 \n",
    "    UP_SAMP_SIZE = 2\n",
    "    inputs = layers.Input(input_shape, dtype=tf.float32)\n",
    "    axis = 4\n",
    "    conv_128 = res_conv_block(inputs, FILTER_SIZE, FILTER_NUM, dropout_rate, batch_norm)\n",
    "    pool_64 = layers.MaxPooling3D(pool_size=(2,2,2))(conv_128)\n",
    "    conv_64 = res_conv_block(pool_64, FILTER_SIZE, 2*FILTER_NUM, dropout_rate, batch_norm)\n",
    "    pool_32 = layers.MaxPooling3D(pool_size=(2,2,2))(conv_64)\n",
    "    conv_32 = res_conv_block(pool_32, FILTER_SIZE, 4*FILTER_NUM, dropout_rate, batch_norm)\n",
    "    pool_16 = layers.MaxPooling3D(pool_size=(2,2,2))(conv_32)\n",
    "    conv_16 = res_conv_block(pool_16, FILTER_SIZE, 8*FILTER_NUM, dropout_rate, batch_norm)\n",
    "    pool_8 = layers.MaxPooling3D(pool_size=(2,2,2))(conv_16)\n",
    "    conv_8 = res_conv_block(pool_8, FILTER_SIZE, 16*FILTER_NUM, dropout_rate, batch_norm)\n",
    "    gating_16 = gating_signal(conv_8, 8*FILTER_NUM, batch_norm)\n",
    "    att_16 = attention_block(conv_16, gating_16, 8*FILTER_NUM)\n",
    "    up_16 = layers.UpSampling3D(size=(UP_SAMP_SIZE, UP_SAMP_SIZE, UP_SAMP_SIZE), data_format=\"channels_last\")(conv_8)\n",
    "    up_16 = layers.concatenate([up_16, att_16 ], axis=axis)\n",
    "    up_conv_16 = res_conv_block(up_16, FILTER_SIZE, 8*FILTER_NUM, dropout_rate, batch_norm)\n",
    "    gating_32 = gating_signal(up_conv_16, 4*FILTER_NUM, batch_norm)\n",
    "    att_32 = attention_block(conv_32, gating_32, 4*FILTER_NUM)\n",
    "    up_32 = layers.UpSampling3D(size=(UP_SAMP_SIZE, UP_SAMP_SIZE, UP_SAMP_SIZE), data_format=\"channels_last\")(up_conv_16)\n",
    "    up_32 = layers.concatenate([up_32, att_32], axis=axis)\n",
    "    up_conv_32 = res_conv_block(up_32, FILTER_SIZE, 4*FILTER_NUM, dropout_rate, batch_norm)\n",
    "    gating_64 = gating_signal(up_conv_32, 2*FILTER_NUM, batch_norm)\n",
    "    att_64 = attention_block(conv_64, gating_64, 2*FILTER_NUM)\n",
    "    up_64 = layers.UpSampling3D(size=(UP_SAMP_SIZE, UP_SAMP_SIZE, UP_SAMP_SIZE), data_format=\"channels_last\")(up_conv_32)\n",
    "    up_64 = layers.concatenate([up_64, att_64], axis=axis)\n",
    "    up_conv_64 = res_conv_block(up_64, FILTER_SIZE, 2*FILTER_NUM, dropout_rate, batch_norm)\n",
    "    gating_128 = gating_signal(up_conv_64, FILTER_NUM, batch_norm)\n",
    "    att_128 = attention_block(conv_128, gating_128, FILTER_NUM)\n",
    "    up_128 = layers.UpSampling3D(size=(UP_SAMP_SIZE, UP_SAMP_SIZE, UP_SAMP_SIZE), data_format=\"channels_last\")(up_conv_64)\n",
    "    up_128 = layers.concatenate([up_128, att_128], axis=axis)\n",
    "    up_conv_128 = res_conv_block(up_128, FILTER_SIZE, FILTER_NUM, dropout_rate, batch_norm)\n",
    "    conv_final = layers.Conv3D(NUM_CLASSES, kernel_size=(1,1,1))(up_conv_128)\n",
    "    conv_final = layers.BatchNormalization(axis=axis)(conv_final)\n",
    "    conv_final = layers.Activation('softmax')(conv_final)  #Change to softmax for multichannel\n",
    "    model = models.Model(inputs, conv_final, name=\"AttentionResUNet\")\n",
    "    return model\n",
    "model2=Attention_ResUNet(input_shape=(128,128,128,3), NUM_CLASSES=4, dropout_rate=0.1, batch_norm=True)\n",
    "model2.compile(optimizer = optim, loss='categorical_crossentropy', metrics=metrics)\n",
    "model2.summary()\n",
    "print(model2.input_shape)\n",
    "print(model2.output_shape)\n",
    "steps_per_epoch=len(train_img_list)//batch_size\n",
    "val_steps_per_epoch=len(val_img_list)//batch_size\n",
    "history=model2.fit(train_img_datagen,\n",
    "          steps_per_epoch=steps_per_epoch,\n",
    "          epochs=300,\n",
    "          verbose=1,\n",
    "          validation_data=val_img_datagen,\n",
    "          validation_steps=val_steps_per_epoch,\n",
    "          )\n",
    "model2.save('brats_3d_finalsoft.hdf5')\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "References:\n",
    "\n",
    "1) https://github.com/bnsreenu/python_for_microscopists/tree/master/231_234_BraTa2020_Unet_segmentation\n",
    "\n",
    "\n",
    "2) https://github.com/bnsreenu/python_for_microscopists/blob/master/224_225_226_models.py\n",
    "\n",
    "\n",
    "3) https://keras.io/examples/vision/simsiam/\n",
    "\n",
    "\n",
    "4) https://stackoverflow.com/questions/51361402/weighted-categorical-cross-entropy-semantic-segmentation\n",
    "\n",
    "\n",
    "5) We have utilized IU Carbonate servers to train our models. \n",
    "\n",
    "6) Dataset can be downloaded from the following link: https://www.kaggle.com/awsaf49/brats20-dataset-training-validation\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "82ce0d89ee0bef264e5a5667810de224121ca3a5b737b64db508885920a58418"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}