3dCNN_autoenc_reg_tf2_examples2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "09ARH9U4D2Wy"
   },
   "source": [
    "### Imports and helper functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "env: TF_ENABLE_AUTO_MIXED_PRECISION=1\n"
     ]
    }
   ],
   "source": [
    "# Boost up training speed using float 16 automatically. (optional for gpu user)\n",
    "%env TF_ENABLE_AUTO_MIXED_PRECISION=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import crispy as csp\n",
    "from crispy.core.ecf import *\n",
    "from crispy.core.emri import *\n",
    "from crispy.core.eckeras import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set tensorflow gpu (optional for gpu user)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 Physical GPUs, 1 Logical GPUs\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "gpus = tf.config.experimental.list_physical_devices('GPU')\n",
    "if gpus:\n",
    "    try:\n",
    "        # Currently, memory growth needs to be the same across GPUs\n",
    "        for gpu in gpus:\n",
    "            tf.config.experimental.set_memory_growth(gpu, True)\n",
    "        logical_gpus = tf.config.experimental.list_logical_devices('GPU')\n",
    "        print(len(gpus), \"Physical GPUs,\", len(logical_gpus), \"Logical GPUs\")\n",
    "    except RuntimeError as e:\n",
    "        # Memory growth must be set before GPUs have been initialized\n",
    "        print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Set logger and save the contents into a file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "csp.logger.addHandler(csp.make_file_handler(f'''{cds()}.log'''))\n",
    "logger = csp.logger\n",
    "\n",
    "get_ipython().set_custom_exc((Exception,), csp.exception_sound(logger))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GPU is available. [PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]\n"
     ]
    }
   ],
   "source": [
    "# GPU Check (optional for gpu user).\n",
    "if len(tf.config.list_physical_devices('GPU')) == 0:\n",
    "    raise Exception(\"GPU is not available.\")\n",
    "else:\n",
    "    logger.info(f\"GPU is available. {tf.config.list_physical_devices('GPU')}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Get this script to gain reproducible results\n",
    "https://keras.io/getting-started/faq/#how-can-i-obtain-reproducible-results-using-keras-during-development"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import random as rn\n",
    "\n",
    "# The below is necessary for starting Numpy generated random numbers\n",
    "# in a well-defined initial state.\n",
    "\n",
    "np.random.seed(42)\n",
    "\n",
    "# The below is necessary for starting core Python generated random numbers\n",
    "# in a well-defined state.\n",
    "\n",
    "rn.seed(12345)\n",
    "\n",
    "# Force TensorFlow to use single thread.\n",
    "# Multiple threads are a potential source of non-reproducible results.\n",
    "# For further details, see: https://stackoverflow.com/questions/42022950/\n",
    "\n",
    "# session_conf = tf.ConfigProto(intra_op_parallelism_threads=1,\n",
    "#                               inter_op_parallelism_threads=1)\n",
    "\n",
    "from tensorflow.keras import backend as K\n",
    "\n",
    "# The below tf.set_random_seed() will make random number generation\n",
    "# in the TensorFlow backend have a well-defined initial state.\n",
    "# For further details, see:\n",
    "# https://www.tensorflow.org/api_docs/python/tf/set_random_seed\n",
    "\n",
    "tf.random.set_seed(1234)\n",
    "\n",
    "# sess = tf.Session(graph=tf.get_default_graph(), config=session_conf)\n",
    "# K.set_session(sess)\n",
    "\n",
    "# Rest of code follows ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set input size\n",
    "You can adjust input size and batch in accordance with your system."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_size = [80, 96, 64]\n",
    "batch_size = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "piRsc9rYYRzl"
   },
   "source": [
    "## Loading Data\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from multiprocessing import Pool, cpu_count, Value, Lock\n",
    "from ctypes import c_int\n",
    "import datetime, gzip, bz2\n",
    "import _pickle as pickle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "img_types: ('t1ce', 't2', 'flair', 't1', 'seg')\n",
      "input_shape was set to (4, 80, 96, 64).\n",
      "output_channels was set to 3.\n",
      "split random state: 42\n"
     ]
    }
   ],
   "source": [
    "img_types = ('t1ce','t2', 'flair','t1', 'seg') ; logger.info(\"img_types: {}\".format(img_types))\n",
    "input_shape = (len(img_types)-1, *input_size) ; logger.info(f\"input_shape was set to {input_shape}.\")\n",
    "output_channels = 3 ; logger.info(f\"output_channels was set to {output_channels}.\")\n",
    "split_random_state = 42 ; logger.info(f\"split random state: {split_random_state}\")\n",
    "save_dir = \".\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dataset_path: D:\\Workspace\\snubh_follow_up\\data\\Brats\\MICCAI_BraTS2020_TrainingData\n",
      "iwd: D:\\Workspace\\snubh_follow_up\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "dataset_path=os.path.abspath('data/Brats/MICCAI_BraTS2020_TrainingData/') ; logger.info(\"dataset_path: {}\".format(dataset_path))\n",
    "iwd=os.getcwd() ; logger.info(\"iwd: {}\".format(iwd))\n",
    "os.chdir(dataset_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Get a list of files for all modalities individually ### for Brats\n",
    "root_path='./*/'\n",
    "t1 = glob.glob(f'{root_path}*t1.nii.gz')\n",
    "t2 = glob.glob(f'{root_path}*t2.nii.gz')\n",
    "flair = glob.glob(f'{root_path}*flair.nii.gz')\n",
    "t1ce = glob.glob(f'{root_path}*t1ce.nii.gz')\n",
    "seg = glob.glob(f'{root_path}*seg.nii.gz')  # Ground Truth"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Make data_paths for training dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "data_paths = [{\n",
    "    s:item\n",
    "    for s, item in zip(img_types, items)\n",
    "}\n",
    "for items in list(zip(*[globals()[k] for k in img_types]))]\n",
    "\n",
    "data_paths"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Make empty arrays for the data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "x_WhT40dzlHO"
   },
   "source": [
    "In this notebook, data will be taken into numpy array. Please consider to use tf.dataset API for memory efficiency."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "nvbbddauz8ij",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "data = np.empty((len(data_paths),) + input_shape, dtype=np.float32)\n",
    "labels = np.empty((len(data_paths), output_channels) + input_shape[1:], dtype=np.uint8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Read nii images and put them into a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Progress: [======================== ](100 %) (369/369)                                                                                                \n",
      "Wall time: 2min 30s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "os.chdir(dataset_path)\n",
    "\n",
    "nii_dict_list=[]\n",
    "logged = deepcopy(data_paths)\n",
    "\n",
    "for i in range(len(data_paths)):\n",
    "    nii_dict_list.append(read_nii(data_paths[i]))\n",
    "    print_progressbar(len(data_paths), i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cropping original image\n",
    "In auto_crop function,  \n",
    "The threshold is calculated by:<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;min + (max - min) * thresh_percent\n",
    "    \n",
    "   If thresh_percent is 0, it means the threshold = min intensity of the image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Progress: [======================== ](100 %) (369/369)                                                                                                \n",
      "Wall time: 1min 53s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "count=0\n",
    "for i in nii_dict_list:\n",
    "    data, cr = auto_crop([i[k] for k in img_types], buffer_size=0, thresh_percent = 0)\n",
    "    for t in img_types:\n",
    "        i[t] = data[img_types.index(t)]\n",
    "    logged[count]['crop_range'] = cr\n",
    "    \n",
    "    print_progressbar(len(nii_dict_list), count)\n",
    "    count+=1\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Check the cropped data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "plot_prediction_result([[i[t] for t in img_types[:-1]] for i in nii_dict_list], \n",
    "         [[i[t] for t in img_types[-1:]] for i in nii_dict_list],\n",
    "                       [[i[t] for t in img_types[-1:]] for i in nii_dict_list],\n",
    "                       logged = logged,\n",
    "         arrangement=['d1', 'd2', 'd3', 'd4', 'd1-l1'], chunk_size = 50, save_path = f\"{iwd}/{save_dir}/After_auto_crop.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "wHqqrbnH0n2E"
   },
   "source": [
    "## Preprocess the input and put them into numpy arrays\n",
    "Preprocess step includes:\n",
    "+ Resizing\n",
    "+ Normalization(Standardization)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "G4u_yrMf30k4",
    "outputId": "81c1cb4d-8339-41bb-971c-a386bf3c7f69",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "label_criteria = Brats\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "# Parameters for the progress bar\n",
    "total = len(nii_dict_list)\n",
    "step = 25 / total\n",
    "\n",
    "# Assign number to the data\n",
    "data_w_num=list(enumerate(nii_dict_list))\n",
    "\n",
    "# Parameters for prepare_data\n",
    "label_criteria = 'Brats' ; logger.info(f\"label_criteria = {label_criteria}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total: 369\n",
      "The data from 1 to 369 is being processed...\n",
      "Number of samples : 369\n",
      "Processing...\n",
      "62 6\n",
      "Progress: [======================== ](100 %) (369/369)                                                                                                \n",
      "\n",
      "All processes were done.\n",
      "00:01:37.28\n",
      "Elapsed time : 00:01:37.28\n"
     ]
    }
   ],
   "source": [
    "tc=TimeChecker()\n",
    "\n",
    "import multiprocessing as mp\n",
    "\n",
    "from functools import partial\n",
    "stride = 369 # The number of image data this code block processes at a time.\n",
    "ti = arange(0, total, stride)\n",
    "pr = []\n",
    "print('total: ' + f'{total}')\n",
    "\n",
    "\n",
    "\n",
    "for i in range(len(ti)):\n",
    "    if i == len(ti) - 1 : break\n",
    "    i1, i2 = ti[i], ti[i+1]\n",
    "    logger.info(f\"The data from {i1+1} to {i2} is being processed...\")\n",
    "    with Pool(cpu_count()) as p:\n",
    "        partial_pd=partial(prepare_data, resize_output_shape=input_shape[1:], \n",
    "                           only_nonzero=False, label_criteria = label_criteria, \n",
    "                           label_zoom_order = 0, img_types = img_types) ### Set the arguments of prepare_data function at this!\n",
    "        r = p.map_async(partial_pd, data_w_num[i1:i2])\n",
    "        print(f\"Number of samples : {total}\")\n",
    "        print(\"Processing...\")\n",
    "        print(r._number_left, r._chunksize)\n",
    "        csp.track_job(r, total)\n",
    "        csp.print_progressbar(total, total-1)\n",
    "        \n",
    "        \n",
    "        r.wait()                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                \n",
    "        pr.append(r.get())\n",
    "print('\\nAll processes were done.')\n",
    "\n",
    "preprocessed_data = list(itertools.chain(*pr))\n",
    "\n",
    "logger.info(f\"Elapsed time : {tc.set_and_show()}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Return to initial working directory.\n",
    "os.chdir(iwd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "ixs = np.array(\n",
    "    list(zip(*preprocessed_data))[0]\n",
    "        )\n",
    "assert all(ixs == list(range(total))), \"Data has been shuffled.\"\n",
    "\n",
    "data = np.array(\n",
    "    list(zip(*preprocessed_data))[1]\n",
    "        )\n",
    "\n",
    "label = np.array(\n",
    "    list(zip(*preprocessed_data))[2]\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pr was deleted successfully.\n",
      "preprocessed_data was deleted successfully.\n",
      "r was deleted successfully.\n",
      "data_w_num was deleted successfully.\n"
     ]
    }
   ],
   "source": [
    "del_vars('pr', 'preprocessed_data', 'r', 'data_w_num', main_global = globals())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Split Data\n",
    "This code splits the whole dataset into train and validation set only(no test set)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# For Brats data only.\n",
    "toi = list(range(len(data)))\n",
    "from sklearn.model_selection import train_test_split\n",
    "tri, vai = train_test_split(toi, test_size = .2, random_state = 42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "x_train, x_val = data[tri], data[vai]\n",
    "y_train, y_val = label[tri], label[vai]\n",
    "l_train, l_val = itemgetter(*tri)(logged), itemgetter(*vai)(logged)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(295, 4, 80, 96, 64) (74, 4, 80, 96, 64)\n"
     ]
    }
   ],
   "source": [
    "print(x_train.shape,\n",
    "      x_val.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Augmentation for train set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Set Parameters\n",
    "- Available augmentation type for **aug_proc** parameter:\n",
    "  +  br = change_brightness, co = change_contrast, ji = jittering, scale = scale, shift = shift, fl = flip, rr=random_rotation\n",
    "- Details for **aug_pipe_args**:\n",
    "  +  br_values(for brightness change) = [factor 1, factor 2]\n",
    "  +  factors(for contrast change) = [factor 1, factor 2]\n",
    "  +  ji_ms(for jittering) = [m, s], Noises are drawn from a normal distribution with mean = m, standard deviation = s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epochs : 300\n",
      "seed number : 42.\n",
      "aug_proc : ['scale', 'shift', 'fl']\n",
      "aug_mode : gradual\n",
      "aug_pipe_args : {'br_values': [-0.3, 0.3], 'factors': [1e-05, 1.5], 'ji_ms': [-25, 9], 'only_seg': True, 'flip_mode': 'prob'}\n"
     ]
    }
   ],
   "source": [
    "epochs = 300 ; logger.info(f\"Epochs : {epochs}\")\n",
    "seed_number = 42 ; logger.info(f\"seed number : {seed_number}.\")\n",
    "aug_proc = ['scale', 'shift', 'fl'] ; logger.info(f\"aug_proc : {aug_proc}\")\n",
    "aug_mode = 'gradual' ; logger.info(f\"aug_mode : {aug_mode}\")\n",
    "aug_pipe_args = dict(br_values = [-0.3, 0.3], factors = [1e-5, 1.5], ji_ms = [-25, 9],\n",
    "                                       only_seg = True, flip_mode='prob') ; logger.info(f\"aug_pipe_args : {aug_pipe_args}\")\n",
    "fold_number = None # Because we won't use cross validation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Augment data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "fold_dir = set_fold_dir(save_dir, fold_number)\n",
    "\n",
    "x_train, y_train, l_train = data_augmentation(x_train, y_train, l_train, aug_proc, aug_mode, aug_pipe_args, save_dir = save_dir, seed_number = seed_number, data_dtype = np.float32)\n",
    "logger.info(f\"Data was augmented.\")\n",
    "del_vars('nii_dict_list', 'nii_dict_list_original', main_global = globals()) # Delete the loaded original data.\n",
    "\n",
    "x_train, y_train, l_train = truncate_trainset_size(x_train, y_train, l_train, batch_size = batch_size) # If train data is not divisible by batch size, truncate it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Make Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\eck\\anaconda3\\envs\\ml2\\lib\\site-packages\\tensorflow_addons\\utils\\ensure_tf_install.py:68: UserWarning: Tensorflow Addons supports using Python ops for all Tensorflow versions above or equal to 2.2.0 and strictly below 2.4.0 (nightly versions are not supported). \n",
      " The versions of TensorFlow you are currently using is 2.4.0-rc1 and is not supported. \n",
      "Some things might work, some things might not.\n",
      "If you were to encounter a bug, do not file an issue.\n",
      "If you want to make sure you're using a tested and supported configuration, either change the TensorFlow version or the TensorFlow Addons's version. \n",
      "You can find the compatibility matrix in TensorFlow Addon's readme:\n",
      "https://github.com/tensorflow/addons\n",
      "  UserWarning,\n"
     ]
    }
   ],
   "source": [
    "from model_tf2 import conv3d_autoenc_reg, dice_coefficient, DiceLoss\n",
    "from tensorflow.keras.optimizers import Adam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = conv3d_autoenc_reg(input_shape, output_channels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set Callbacks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Learning rate scheduler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lr_schedule(a0=1e-4, total_epoch=300):\n",
    "\n",
    "        def lr_schedule_(epoch):\n",
    "            a=a0*(1-epoch/total_epoch)**0.9\n",
    "\n",
    "            return a\n",
    "\n",
    "        return lr_schedule_\n",
    "\n",
    "lr_scheduler = keras.callbacks.LearningRateScheduler(lr_schedule(1e-4, 300))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Other callbacks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "monitor = \"val_loss\"\n",
    "filename_w = \"keras_weight_epoch-{epoch:02d}_\" + f\"{monitor}\" + \"-{\" + f\"{monitor}\" +\":.4f}.h5\"\n",
    "\n",
    "csv_logger = keras.callbacks.CSVLogger(\"training_log.csv\", append = True)\n",
    "earlystopping_cb = keras.callbacks.EarlyStopping(monitor=monitor, min_delta = 0.01, patience = 10)\n",
    "checkpoint_cb_w = keras.callbacks.ModelCheckpoint(filename_w, monitor=monitor, save_weights_only=True)\n",
    "tensorboard_cb = keras.callbacks.TensorBoard(\"tensorboard_logs\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "callbacks = [tensorboard_cb, checkpoint_cb_w, earlystopping_cb, lr_scheduler, csv_logger]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(\n",
    "        Adam(lr=1e-4),\n",
    "        loss=[DiceLoss()],\n",
    "        metrics=[dice_coefficient]\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fit model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1277/1277 [==============================] - 426s 322ms/step - loss: 0.0985 - dice_coefficient: 0.0165 - val_loss: 0.0439 - val_dice_coefficient: 0.0332\n"
     ]
    }
   ],
   "source": [
    "history = model.fit(x_train, y_train, batch_size = batch_size, epochs = epochs, callbacks = callbacks, validation_data = (x_val, y_val))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "                <audio controls=\"controls\" autoplay=\"autoplay\">\n",
       "                    <source src=\"data:audio/mpeg;base64,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\" type=\"audio/mpeg\" />\n",
       "                    Your browser does not support the audio element.\n",
       "                </audio>\n",
       "              "
      ],
      "text/plain": [
       "<IPython.lib.display.Audio object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "csp.sound_alert()"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "include_colab_link": true,
   "name": "Example on BRATS2018",
   "provenance": [],
   "version": "0.3.2"
  },
  "kernelspec": {
   "display_name": "Python [conda env:ml2]",
   "language": "python",
   "name": "conda-env-ml2-py"
  },
  "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.6.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}