02_training_model.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# License"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Copyright (c) 2024 Pranjal Choudhury, Bosanta Ranjan Boruah\n",
    "\n",
    "This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License\n",
    "as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.\n",
    "\n",
    "This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of\n",
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.\n",
    "\n",
    "You should have received a copy of the GNU Affero General Public License along with this program. If not, see <http://www.gnu.org/licenses/>.\n",
    "\n",
    "######################################################################################################################################\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This code is prepared based on Deep-STORM and ZeroCostDL4Mic platform. Please also cite their work.\n",
    "\n",
    "This file contains the CNN model which is to be trained. Please load the correct files and run the cells below"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dependencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.layers import Input, Activation, UpSampling2D, Convolution2D, MaxPooling2D, BatchNormalization, Layer, Add\n",
    "from tensorflow.keras.callbacks import Callback\n",
    "from tensorflow.keras import backend as K\n",
    "from tensorflow.keras import optimizers, losses\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
    "from tensorflow.keras.callbacks import ModelCheckpoint\n",
    "from tensorflow.keras.callbacks import ReduceLROnPlateau\n",
    "\n",
    "from scipy.ndimage import gaussian_filter\n",
    "\n",
    "import os\n",
    "import numpy as np\n",
    "from skimage import io\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import h5py\n",
    "import scipy.io as sio\n",
    "import shutil\n",
    "import csv\n",
    "import time\n",
    "\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basic Functionalities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "# project image in floating point values between 0 and 1\n",
    "def project_01(im):\n",
    "    im = np.squeeze(im)\n",
    "    min_val = im.min()\n",
    "    max_val = im.max()\n",
    "    return (im - min_val)/(max_val - min_val)\n",
    "\n",
    "# normalize image given mean and std\n",
    "def normalize_im(im, dmean, dstd):\n",
    "    im = np.squeeze(im)\n",
    "    im_norm = np.zeros(im.shape,dtype=np.float32)\n",
    "    im_norm = (im - dmean)/dstd\n",
    "    return im_norm\n",
    "\n",
    "# Define the loss history recorder\n",
    "class LossHistory(Callback):\n",
    "    def on_train_begin(self, logs={}):\n",
    "        self.losses = []\n",
    "\n",
    "    def on_batch_end(self, batch, logs={}):\n",
    "        self.losses.append(logs.get('loss'))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loss Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# prepare a 2D gaussian \n",
    "def matlab_style_gauss2D(shape=(7,7),sigma=1):\n",
    "\n",
    "    m,n = [(ss-1.)/2. for ss in shape]\n",
    "    y,x = np.ogrid[-m:m+1,-n:n+1]\n",
    "    h = np.exp( -(x*x + y*y) / (2.*sigma*sigma) )\n",
    "    h.astype(dtype=K.floatx())\n",
    "    h[ h < np.finfo(h.dtype).eps*h.max() ] = 0\n",
    "    sumh = h.sum()\n",
    "    if sumh != 0:\n",
    "        h /= sumh\n",
    "    h = h.astype('float32')\n",
    "    return h\n",
    "\n",
    "# Expand the filter dimensions\n",
    "psf_heatmap = matlab_style_gauss2D(shape = (7,7),sigma=1)\n",
    "#psf_heatmap = matlab_style_gauss2D(shape = (7,7),sigma=0.35)\n",
    "gfilter = tf.reshape(psf_heatmap, [7, 7, 1, 1])\n",
    "\n",
    "# The loss function\n",
    "def loss_function(input_shape, norm_ai, weight):\n",
    "\n",
    "    def bump_mse(heatmap_true, spikes_pred):\n",
    "\n",
    "        # generate the heatmap corresponding to the predicted spikes\n",
    "        heatmap_pred = K.conv2d(spikes_pred, gfilter, strides=(1, 1), padding='same')\n",
    "        \n",
    "        # heatmaps MSE\n",
    "        loss_heatmaps = losses.mean_squared_error(heatmap_true,heatmap_pred)\n",
    "        \n",
    "        return loss_heatmaps \n",
    "    return bump_mse\n",
    "\n",
    "def compute_norm_ai(input_dim, upsampling_factor, psf_heatmap):\n",
    "    norm_ai = np.ones((input_dim[0], input_dim[1]), dtype=np.float32)\n",
    "    matr = np.linalg.norm(psf_heatmap)\n",
    "\n",
    "    return matr*norm_ai"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The convolutional block\n",
    "def conv_bn_relu(nb_filter, rk, ck, name):\n",
    "    def f(input):\n",
    "        conv = Convolution2D(nb_filter, kernel_size=(rk, ck), strides=(1,1),\\\n",
    "                               padding=\"same\", use_bias=False,\\\n",
    "                               kernel_initializer=\"Orthogonal\",name='conv-'+name)(input)\n",
    "        conv_norm = BatchNormalization(name='BN-'+name)(conv)\n",
    "        conv_norm_relu = Activation(activation = \"relu\",name='Relu-'+name)(conv_norm)\n",
    "        return conv_norm_relu\n",
    "    return f\n",
    "\n",
    "# The residual block\n",
    "def residual_block(input_features, nb_filter, rk, ck, name):\n",
    "    conv1 = conv_bn_relu(nb_filter, rk, ck, name + '_conv1')(input_features)\n",
    "    conv2 = conv_bn_relu(nb_filter, rk, ck, name + '_conv2')(conv1)\n",
    "    shortcut = Convolution2D(nb_filter, (1, 1), strides=(1, 1), padding='same')(input_features)\n",
    "    output = Add()([conv2, shortcut])\n",
    "    return output\n",
    "\n",
    "# Define the model architecture\n",
    "def CNN_with_residue(input, names):\n",
    "    Features1 = conv_bn_relu(32, 3, 3, names+'F1')(input)\n",
    "    # pool1 = MaxPooling2D(pool_size=(2, 2), name= names+'Pool1')(Features1)\n",
    "    Features2 = residual_block(Features1, 64, 3, 3, names+'Res1')\n",
    "    # pool2 = MaxPooling2D(pool_size=(2, 2), name=names+'Pool2')(Features2)\n",
    "\n",
    "    Features3 = conv_bn_relu(128, 3, 3, names+'F3')(Features2)\n",
    "    up1 = UpSampling2D(size=(2, 2), name = names+ 'Up1')(Features3)\n",
    "    Features4 = conv_bn_relu(64, 3, 3, names+'F4')(up1)\n",
    "    up2 = UpSampling2D(size=(2, 2),name = names+ 'Up3')(Features4)\n",
    "    return up2\n",
    "\n",
    "\n",
    "# Define the Model building for an arbitrary input size\n",
    "def buildModel(input_dim, initial_learning_rate = 0.001, L0_weight = 1):\n",
    "    input_ = Input (shape = (input_dim))\n",
    "    act_ = CNN_with_residue (input_,'CNN')\n",
    "    density_pred = Convolution2D(1, kernel_size=(1, 1), strides=(1, 1), padding=\"same\",\\\n",
    "                                  activation=\"relu\", use_bias = False,\\\n",
    "                                  kernel_initializer=\"Orthogonal\",name='Prediction')(act_)\n",
    "    model = Model (inputs= input_, outputs=density_pred)\n",
    "    opt = optimizers.Adam(learning_rate = initial_learning_rate)\n",
    "    norm_ai = compute_norm_ai(input_dim, 1, psf_heatmap)\n",
    "    model.compile(optimizer=opt, loss = loss_function(input_dim, norm_ai, L0_weight))\n",
    "    return model\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## data preprocessing and training function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define a function that trains a model for a given data SNR and density\n",
    "def train_model(patches, heatmaps, modelPath, epochs, batch_size, \n",
    "                validation_split = 0.2, initial_learning_rate = 0.001, \n",
    "                L2_weighting_factor = 100, L0_weight = 1):\n",
    "    \n",
    "    \n",
    "    # for reproducibility\n",
    "    np.random.seed(123)\n",
    "\n",
    "    X_train, X_test, y_train, y_test = train_test_split(patches, heatmaps, test_size = validation_split, random_state=42)\n",
    "    print('Number of training examples: %d' % X_train.shape[0])\n",
    "    print('Number of validation examples: %d' % X_test.shape[0])\n",
    "       \n",
    "    # Setting type\n",
    "    X_train = X_train.astype('float32')\n",
    "    X_test = X_test.astype('float32')\n",
    "    y_train = y_train.astype('float32')\n",
    "    y_test = y_test.astype('float32')\n",
    "\n",
    "    \n",
    "    #===================== Training set normalization ==========================\n",
    "    # normalize training images to be in the range [0,1] and calculate the \n",
    "    # training set mean and std\n",
    "    mean_train = np.zeros(X_train.shape[0],dtype=np.float32)\n",
    "    std_train = np.zeros(X_train.shape[0], dtype=np.float32)\n",
    "    for i in range(X_train.shape[0]):\n",
    "        X_train[i, :, :] = project_01(X_train[i, :, :])\n",
    "        mean_train[i] = X_train[i, :, :].mean()\n",
    "        std_train[i] = X_train[i, :, :].std()\n",
    "\n",
    "    # resulting normalized training images\n",
    "    mean_val_train = mean_train.mean()\n",
    "    std_val_train = std_train.mean()\n",
    "    X_train_norm = np.zeros(X_train.shape, dtype=np.float32)\n",
    "    for i in range(X_train.shape[0]):\n",
    "        X_train_norm[i, :, :] = normalize_im(X_train[i, :, :], mean_val_train, std_val_train)\n",
    "    \n",
    "    # patch size\n",
    "    psize = X_train_norm.shape[1]\n",
    "\n",
    "    # Reshaping\n",
    "    X_train_norm = X_train_norm.reshape(X_train.shape[0], psize, psize, 1)\n",
    "\n",
    "    # ===================== Test set normalization ==========================\n",
    "    # normalize test images to be in the range [0,1] and calculate the test set \n",
    "    # mean and std\n",
    "    mean_test = np.zeros(X_test.shape[0],dtype=np.float32)\n",
    "    std_test = np.zeros(X_test.shape[0], dtype=np.float32)\n",
    "    for i in range(X_test.shape[0]):\n",
    "        X_test[i, :, :] = project_01(X_test[i, :, :])\n",
    "        mean_test[i] = X_test[i, :, :].mean()\n",
    "        std_test[i] = X_test[i, :, :].std()\n",
    "\n",
    "    # resulting normalized test images\n",
    "    mean_val_test = mean_test.mean()\n",
    "    std_val_test = std_test.mean()\n",
    "\n",
    "    X_test_norm = np.zeros(X_test.shape, dtype=np.float32)\n",
    "    for i in range(X_test.shape[0]):\n",
    "        X_test_norm[i, :, :] = normalize_im(X_test[i, :, :], mean_val_test, std_val_test)\n",
    "        \n",
    "    # Reshaping\n",
    "    X_test_norm = X_test_norm.reshape(X_test.shape[0], psize, psize, 1)\n",
    "\n",
    "    # Reshaping labels\n",
    "    psize_test = y_train.shape[1]\n",
    "    Y_train = y_train.reshape(y_train.shape[0], psize_test, psize_test, 1)\n",
    "    Y_test = y_test.reshape(y_test.shape[0], psize_test, psize_test, 1)\n",
    "\n",
    "    # Save datasets to a matfile to open later in matlab\n",
    "    mdict = {\"mean_test\": mean_val_test, \"std_test\": std_val_test, \n",
    "              \"Normalization factor\": L2_weighting_factor}\n",
    "    sio.savemat(os.path.join(modelPath,\"model_metadata.mat\"), mdict)\n",
    "\n",
    "\n",
    "    # Set the dimensions ordering according to tensorflow consensous\n",
    "    # K.set_image_dim_ordering('tf')\n",
    "    K.set_image_data_format('channels_last')\n",
    "\n",
    "    # Save the model weights after each epoch if the validation loss decreased\n",
    "    checkpointer = ModelCheckpoint(filepath=os.path.join(modelPath,\"weights_best.hdf5\"), verbose=1,\n",
    "                                   save_best_only=True)\n",
    "\n",
    "    # Change learning when loss reaches a plataeu\n",
    "    change_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=5, min_lr=0.00005)\n",
    "    \n",
    "    # Model building and complitation\n",
    "    model = buildModel((psize, psize, 1), initial_learning_rate = initial_learning_rate, L0_weight = L0_weight)\n",
    "    model.summary()\n",
    "\n",
    "\n",
    "    \n",
    "    # Create an image data generator for real time data augmentation\n",
    "    datagen = ImageDataGenerator(\n",
    "        featurewise_center=False,  # set input mean to 0 over the dataset\n",
    "        samplewise_center=False,  # set each sample mean to 0\n",
    "        featurewise_std_normalization=False,  # divide inputs by std of the dataset\n",
    "        samplewise_std_normalization=False,  # divide each input by its std\n",
    "        zca_whitening=False,  # apply ZCA whitening\n",
    "        rotation_range=0.,  # randomly rotate images in the range (degrees, 0 to 180)\n",
    "        width_shift_range=0.,  # randomly shift images horizontally (fraction of total width)\n",
    "        height_shift_range=0.,  # randomly shift images vertically (fraction of total height)\n",
    "        zoom_range=0.,\n",
    "        shear_range=0.,\n",
    "        horizontal_flip=False,  # randomly flip images\n",
    "        vertical_flip=False,  # randomly flip images\n",
    "        fill_mode='constant',\n",
    "        data_format=K.image_data_format())\n",
    "\n",
    "    # Fit the image generator on the training data\n",
    "    datagen.fit(X_train_norm)\n",
    "    \n",
    "    # loss history recorder\n",
    "    history = LossHistory()\n",
    "\n",
    "    # Inform user training begun\n",
    "    print('-------------------------------')\n",
    "    print('Training model...')\n",
    "\n",
    "    # Fit model on the batches generated by datagen.flow()\n",
    "    train_history = model.fit(datagen.flow(X_train_norm, Y_train, batch_size=batch_size), \n",
    "                                        epochs=epochs, verbose=1, \n",
    "                                        validation_data=(X_test_norm, Y_test), \n",
    "                                        callbacks=[history, checkpointer, change_lr])    \n",
    "\n",
    "    # Inform user training ended\n",
    "    print('-------------------------------')\n",
    "    print('Training Complete!')\n",
    "    \n",
    "    # Save the last model\n",
    "    model.save(os.path.join(modelPath, 'weights_last.hdf5'))\n",
    "\n",
    "    # convert the history.history dict to a pandas DataFrame:     \n",
    "    lossData = pd.DataFrame(train_history.history) \n",
    "\n",
    "    if os.path.exists(os.path.join(modelPath,\"Quality Control\")):\n",
    "      shutil.rmtree(os.path.join(modelPath,\"Quality Control\"))\n",
    "\n",
    "    os.makedirs(os.path.join(modelPath,\"Quality Control\"))\n",
    "\n",
    "    # The training evaluation.csv is saved (overwrites the Files if needed). \n",
    "    lossDataCSVpath = os.path.join(modelPath,\"Quality Control/training_evaluation.csv\")\n",
    "    with open(lossDataCSVpath, 'w') as f:\n",
    "      writer = csv.writer(f)\n",
    "      writer.writerow(['loss','val_loss','learning rate'])\n",
    "      for i in range(len(train_history.history['loss'])):\n",
    "        writer.writerow([train_history.history['loss'][i], train_history.history['val_loss'][i], train_history.history['lr'][i]])\n",
    "\n",
    "    return\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "Save_path = 'model'\n",
    "patches = io.imread('data/training_images.tif')\n",
    "heatmaps = io.imread('data/heatmaps.tif')\n",
    "\n",
    "number_of_epochs = 30\n",
    "batch_size = 16\n",
    "percentage_validation = 0.2\n",
    "initial_learning_rate = 0.001\n",
    "\n",
    "L2_weighting_factor = 100\n",
    "L0_weight = 1"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of training examples: 8000\n",
      "Number of validation examples: 2000\n",
      "Model: \"model\"\n",
      "__________________________________________________________________________________________________\n",
      " Layer (type)                   Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      " input_1 (InputLayer)           [(None, 32, 32, 1)]  0           []                               \n",
      "                                                                                                  \n",
      " conv-CNNF1 (Conv2D)            (None, 32, 32, 32)   288         ['input_1[0][0]']                \n",
      "                                                                                                  \n",
      " BN-CNNF1 (BatchNormalization)  (None, 32, 32, 32)   128         ['conv-CNNF1[0][0]']             \n",
      "                                                                                                  \n",
      " Relu-CNNF1 (Activation)        (None, 32, 32, 32)   0           ['BN-CNNF1[0][0]']               \n",
      "                                                                                                  \n",
      " conv-CNNRes1_conv1 (Conv2D)    (None, 32, 32, 64)   18432       ['Relu-CNNF1[0][0]']             \n",
      "                                                                                                  \n",
      " BN-CNNRes1_conv1 (BatchNormali  (None, 32, 32, 64)  256         ['conv-CNNRes1_conv1[0][0]']     \n",
      " zation)                                                                                          \n",
      "                                                                                                  \n",
      " Relu-CNNRes1_conv1 (Activation  (None, 32, 32, 64)  0           ['BN-CNNRes1_conv1[0][0]']       \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " conv-CNNRes1_conv2 (Conv2D)    (None, 32, 32, 64)   36864       ['Relu-CNNRes1_conv1[0][0]']     \n",
      "                                                                                                  \n",
      " BN-CNNRes1_conv2 (BatchNormali  (None, 32, 32, 64)  256         ['conv-CNNRes1_conv2[0][0]']     \n",
      " zation)                                                                                          \n",
      "                                                                                                  \n",
      " Relu-CNNRes1_conv2 (Activation  (None, 32, 32, 64)  0           ['BN-CNNRes1_conv2[0][0]']       \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " conv2d (Conv2D)                (None, 32, 32, 64)   2112        ['Relu-CNNF1[0][0]']             \n",
      "                                                                                                  \n",
      " add (Add)                      (None, 32, 32, 64)   0           ['Relu-CNNRes1_conv2[0][0]',     \n",
      "                                                                  'conv2d[0][0]']                 \n",
      "                                                                                                  \n",
      " conv-CNNF3 (Conv2D)            (None, 32, 32, 128)  73728       ['add[0][0]']                    \n",
      "                                                                                                  \n",
      " BN-CNNF3 (BatchNormalization)  (None, 32, 32, 128)  512         ['conv-CNNF3[0][0]']             \n",
      "                                                                                                  \n",
      " Relu-CNNF3 (Activation)        (None, 32, 32, 128)  0           ['BN-CNNF3[0][0]']               \n",
      "                                                                                                  \n",
      " CNNUp1 (UpSampling2D)          (None, 64, 64, 128)  0           ['Relu-CNNF3[0][0]']             \n",
      "                                                                                                  \n",
      " conv-CNNF4 (Conv2D)            (None, 64, 64, 64)   73728       ['CNNUp1[0][0]']                 \n",
      "                                                                                                  \n",
      " BN-CNNF4 (BatchNormalization)  (None, 64, 64, 64)   256         ['conv-CNNF4[0][0]']             \n",
      "                                                                                                  \n",
      " Relu-CNNF4 (Activation)        (None, 64, 64, 64)   0           ['BN-CNNF4[0][0]']               \n",
      "                                                                                                  \n",
      " CNNUp3 (UpSampling2D)          (None, 128, 128, 64  0           ['Relu-CNNF4[0][0]']             \n",
      "                                )                                                                 \n",
      "                                                                                                  \n",
      " Prediction (Conv2D)            (None, 128, 128, 1)  64          ['CNNUp3[0][0]']                 \n",
      "                                                                                                  \n",
      "==================================================================================================\n",
      "Total params: 206,624\n",
      "Trainable params: 205,920\n",
      "Non-trainable params: 704\n",
      "__________________________________________________________________________________________________\n",
      "-------------------------------\n",
      "Training model...\n",
      "Epoch 1/30\n",
      "500/500 [==============================] - ETA: 0s - loss: 0.0140\n",
      "Epoch 1: val_loss improved from inf to 0.01244, saving model to model\\weights_best.hdf5\n",
      "500/500 [==============================] - 183s 364ms/step - loss: 0.0140 - val_loss: 0.0124 - lr: 0.0010\n",
      "Epoch 2/30\n",
      "500/500 [==============================] - ETA: 0s - loss: 0.0119\n",
      "Epoch 2: val_loss improved from 0.01244 to 0.01170, saving model to model\\weights_best.hdf5\n",
      "500/500 [==============================] - 179s 357ms/step - loss: 0.0119 - val_loss: 0.0117 - lr: 0.0010\n",
      "Epoch 3/30\n",
      "500/500 [==============================] - ETA: 0s - loss: 0.0115\n",
      "Epoch 3: val_loss improved from 0.01170 to 0.01147, saving model to model\\weights_best.hdf5\n",
      "500/500 [==============================] - 179s 358ms/step - loss: 0.0115 - val_loss: 0.0115 - lr: 0.0010\n",
      "Epoch 4/30\n",
      "500/500 [==============================] - ETA: 0s - loss: 0.0113\n",
      "Epoch 4: val_loss improved from 0.01147 to 0.01133, saving model to model\\weights_best.hdf5\n",
      "500/500 [==============================] - 179s 358ms/step - loss: 0.0113 - val_loss: 0.0113 - lr: 0.0010\n",
      "Epoch 5/30\n",
      "500/500 [==============================] - ETA: 0s - loss: 0.0112\n",
      "Epoch 5: val_loss improved from 0.01133 to 0.01123, saving model to model\\weights_best.hdf5\n",
      "500/500 [==============================] - 179s 358ms/step - loss: 0.0112 - val_loss: 0.0112 - lr: 0.0010\n",
      "Epoch 6/30\n",
      "500/500 [==============================] - ETA: 0s - loss: 0.0111\n",
      "Epoch 6: val_loss improved from 0.01123 to 0.01115, saving model to model\\weights_best.hdf5\n",
      "500/500 [==============================] - 179s 358ms/step - loss: 0.0111 - val_loss: 0.0112 - lr: 0.0010\n",
      "Epoch 7/30\n",
      "500/500 [==============================] - ETA: 0s - loss: 0.0111\n",
      "Epoch 7: val_loss improved from 0.01115 to 0.01110, saving model to model\\weights_best.hdf5\n",
      "500/500 [==============================] - 179s 358ms/step - loss: 0.0111 - val_loss: 0.0111 - lr: 0.0010\n",
      "Epoch 8/30\n",
      "500/500 [==============================] - ETA: 0s - loss: 0.0110\n",
      "Epoch 8: val_loss did not improve from 0.01110\n",
      "500/500 [==============================] - 178s 357ms/step - loss: 0.0110 - val_loss: 0.0112 - lr: 0.0010\n",
      "Epoch 9/30\n",
      "500/500 [==============================] - ETA: 0s - loss: 0.0110\n",
      "Epoch 9: val_loss improved from 0.01110 to 0.01101, saving model to model\\weights_best.hdf5\n",
      "500/500 [==============================] - 179s 358ms/step - loss: 0.0110 - val_loss: 0.0110 - lr: 0.0010\n",
      "Epoch 10/30\n",
      "500/500 [==============================] - ETA: 0s - loss: 0.0109\n",
      "Epoch 10: val_loss improved from 0.01101 to 0.01099, saving model to model\\weights_best.hdf5\n",
      "500/500 [==============================] - 179s 358ms/step - loss: 0.0109 - val_loss: 0.0110 - lr: 0.0010\n",
      "Epoch 11/30\n",
      "500/500 [==============================] - ETA: 0s - loss: 0.0109\n",
      "Epoch 11: val_loss improved from 0.01099 to 0.01097, saving model to model\\weights_best.hdf5\n",
      "500/500 [==============================] - 179s 358ms/step - loss: 0.0109 - val_loss: 0.0110 - lr: 0.0010\n",
      "Epoch 12/30\n",
      "500/500 [==============================] - ETA: 0s - loss: 0.0109\n",
      "Epoch 12: val_loss improved from 0.01097 to 0.01095, saving model to model\\weights_best.hdf5\n",
      "500/500 [==============================] - 179s 357ms/step - loss: 0.0109 - val_loss: 0.0110 - lr: 0.0010\n",
      "Epoch 13/30\n",
      "500/500 [==============================] - ETA: 0s - loss: 0.0109\n",
      "Epoch 13: val_loss improved from 0.01095 to 0.01094, saving model to model\\weights_best.hdf5\n",
      "500/500 [==============================] - 179s 358ms/step - loss: 0.0109 - val_loss: 0.0109 - lr: 0.0010\n",
      "Epoch 14/30\n",
      "500/500 [==============================] - ETA: 0s - loss: 0.0108\n",
      "Epoch 14: val_loss improved from 0.01094 to 0.01092, saving model to model\\weights_best.hdf5\n",
      "500/500 [==============================] - 179s 358ms/step - loss: 0.0108 - val_loss: 0.0109 - lr: 0.0010\n",
      "Epoch 15/30\n",
      "500/500 [==============================] - ETA: 0s - loss: 0.0107\n",
      "Epoch 15: val_loss improved from 0.01092 to 0.01085, saving model to model\\weights_best.hdf5\n",
      "500/500 [==============================] - 179s 358ms/step - loss: 0.0107 - val_loss: 0.0108 - lr: 1.0000e-04\n",
      "Epoch 16/30\n",
      "500/500 [==============================] - ETA: 0s - loss: 0.0107\n",
      "Epoch 16: val_loss did not improve from 0.01085\n",
      "500/500 [==============================] - 179s 358ms/step - loss: 0.0107 - val_loss: 0.0108 - lr: 1.0000e-04\n",
      "Epoch 17/30\n",
      "500/500 [==============================] - ETA: 0s - loss: 0.0107\n",
      "Epoch 17: val_loss improved from 0.01085 to 0.01085, saving model to model\\weights_best.hdf5\n",
      "500/500 [==============================] - 179s 358ms/step - loss: 0.0107 - val_loss: 0.0108 - lr: 1.0000e-04\n",
      "Epoch 18/30\n",
      "500/500 [==============================] - ETA: 0s - loss: 0.0107\n",
      "Epoch 18: val_loss did not improve from 0.01085\n",
      "500/500 [==============================] - 179s 357ms/step - loss: 0.0107 - val_loss: 0.0109 - lr: 1.0000e-04\n",
      "Epoch 19/30\n",
      "500/500 [==============================] - ETA: 0s - loss: 0.0107\n",
      "Epoch 19: val_loss did not improve from 0.01085\n",
      "500/500 [==============================] - 178s 357ms/step - loss: 0.0107 - val_loss: 0.0108 - lr: 1.0000e-04\n",
      "Epoch 20/30\n",
      "500/500 [==============================] - ETA: 0s - loss: 0.0107\n",
      "Epoch 20: val_loss did not improve from 0.01085\n",
      "500/500 [==============================] - 179s 358ms/step - loss: 0.0107 - val_loss: 0.0109 - lr: 1.0000e-04\n",
      "Epoch 21/30\n",
      "500/500 [==============================] - ETA: 0s - loss: 0.0107\n",
      "Epoch 21: val_loss improved from 0.01085 to 0.01085, saving model to model\\weights_best.hdf5\n",
      "500/500 [==============================] - 179s 358ms/step - loss: 0.0107 - val_loss: 0.0108 - lr: 5.0000e-05\n",
      "Epoch 22/30\n",
      "500/500 [==============================] - ETA: 0s - loss: 0.0107\n",
      "Epoch 22: val_loss improved from 0.01085 to 0.01084, saving model to model\\weights_best.hdf5\n",
      "500/500 [==============================] - 179s 358ms/step - loss: 0.0107 - val_loss: 0.0108 - lr: 5.0000e-05\n",
      "Epoch 23/30\n",
      "500/500 [==============================] - ETA: 0s - loss: 0.0107\n",
      "Epoch 23: val_loss improved from 0.01084 to 0.01084, saving model to model\\weights_best.hdf5\n",
      "500/500 [==============================] - 179s 358ms/step - loss: 0.0107 - val_loss: 0.0108 - lr: 5.0000e-05\n",
      "Epoch 24/30\n",
      "500/500 [==============================] - ETA: 0s - loss: 0.0107\n",
      "Epoch 24: val_loss did not improve from 0.01084\n",
      "500/500 [==============================] - 178s 357ms/step - loss: 0.0107 - val_loss: 0.0108 - lr: 5.0000e-05\n",
      "Epoch 25/30\n",
      "500/500 [==============================] - ETA: 0s - loss: 0.0107\n",
      "Epoch 25: val_loss did not improve from 0.01084\n",
      "500/500 [==============================] - 178s 357ms/step - loss: 0.0107 - val_loss: 0.0108 - lr: 5.0000e-05\n",
      "Epoch 26/30\n",
      "500/500 [==============================] - ETA: 0s - loss: 0.0107\n",
      "Epoch 26: val_loss did not improve from 0.01084\n",
      "500/500 [==============================] - 179s 358ms/step - loss: 0.0107 - val_loss: 0.0108 - lr: 5.0000e-05\n",
      "Epoch 27/30\n",
      "500/500 [==============================] - ETA: 0s - loss: 0.0107\n",
      "Epoch 27: val_loss did not improve from 0.01084\n",
      "500/500 [==============================] - 179s 357ms/step - loss: 0.0107 - val_loss: 0.0108 - lr: 5.0000e-05\n",
      "Epoch 28/30\n",
      "500/500 [==============================] - ETA: 0s - loss: 0.0107\n",
      "Epoch 28: val_loss did not improve from 0.01084\n",
      "500/500 [==============================] - 179s 357ms/step - loss: 0.0107 - val_loss: 0.0108 - lr: 5.0000e-05\n",
      "Epoch 29/30\n",
      "500/500 [==============================] - ETA: 0s - loss: 0.0107\n",
      "Epoch 29: val_loss did not improve from 0.01084\n",
      "500/500 [==============================] - 178s 357ms/step - loss: 0.0107 - val_loss: 0.0108 - lr: 5.0000e-05\n",
      "Epoch 30/30\n",
      "500/500 [==============================] - ETA: 0s - loss: 0.0107\n",
      "Epoch 30: val_loss did not improve from 0.01084\n",
      "500/500 [==============================] - 179s 357ms/step - loss: 0.0107 - val_loss: 0.0108 - lr: 5.0000e-05\n",
      "-------------------------------\n",
      "Training Complete!\n",
      "Time elapsed: 1.0 hour(s) 29.0 min(s) 29 sec(s)\n"
     ]
    }
   ],
   "source": [
    "##Start training\n",
    "\n",
    "# Start the clock to measure how long it takes\n",
    "start = time.time()\n",
    "\n",
    "#here we check that no model with the same name already exist, if so delete\n",
    "if os.path.exists(Save_path):\n",
    "  shutil.rmtree(Save_path)\n",
    "\n",
    "# Create the model folder!\n",
    "os.makedirs(Save_path)\n",
    "\n",
    "# Let's go !\n",
    "train_model(patches, heatmaps, Save_path, \n",
    "            epochs=number_of_epochs, batch_size=batch_size,\n",
    "            validation_split = percentage_validation,\n",
    "            initial_learning_rate = initial_learning_rate, \n",
    "            L2_weighting_factor = L2_weighting_factor,\n",
    "            L0_weight = L0_weight)\n",
    "\n",
    "\n",
    "\n",
    "# Displaying the time elapsed for training\n",
    "dt = time.time() - start\n",
    "minutes, seconds = divmod(dt, 60) \n",
    "hours, minutes = divmod(minutes, 60) \n",
    "print(\"Time elapsed:\",hours, \"hour(s)\",minutes,\"min(s)\",round(seconds),\"sec(s)\")\n",
    "\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## loss evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "lossDataFromCSV = []\n",
    "vallossDataFromCSV = []\n",
    "\n",
    "csv_ = pd.read_csv('model/Quality Control/training_evaluation.csv')   # the csv  file that records the training loss \n",
    "\n",
    "\n",
    "\n",
    "fig,ax= plt.subplots(1,1, figsize=(12,8))\n",
    "\n",
    "ax.spines['top'].set_visible(False)\n",
    "ax.spines['right'].set_visible(False)\n",
    "ax.spines['left'].set_linewidth(2.5)\n",
    "ax.spines['bottom'].set_linewidth(2.5)\n",
    "\n",
    "ax.plot(csv_['loss'], label='Training loss',  linewidth=2.5, color = 'firebrick')\n",
    "ax.plot(csv_['val_loss'], label='Validation loss',  linewidth=2.5, color = 'green', marker = 'o')\n",
    "\n",
    "\n",
    "ax.set_xlabel('Epoch number', fontsize=20, weight = 'bold')\n",
    "ax.set_ylabel('Loss (x1e-2) ', fontsize=20, weight = 'bold')\n",
    "ax.legend(loc='upper right', ncol=1, fontsize=20, frameon = False)\n",
    "ax.tick_params(axis='both', labelsize=20, width = 2.5)\n",
    "\n",
    "\n",
    "\n",
    "plt.savefig('model/Quality Control/lossCurvePlot.png', bbox_inches='tight', pad_inches=0)\n",
    "plt.show()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Validation of the model prediction"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create validation datasets using '01_training_data_generation..ipynb' and check the output of the CNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_test_images(images_):\n",
    "\n",
    "    X_test = images_.astype('float32')\n",
    "    #===================== Training set normalization ==========================\n",
    "    # normalize training images to be in the range [0,1] and calculate the \n",
    "    # training set mean and std\n",
    "    mean_test = np.zeros(X_test.shape[0],dtype=np.float32)\n",
    "    std_test = np.zeros(X_test.shape[0], dtype=np.float32)\n",
    "    for i in range(X_test.shape[0]):\n",
    "        X_test[i, :, :] = project_01(X_test[i, :, :])\n",
    "        mean_test[i] = X_test[i, :, :].mean()\n",
    "        std_test[i] = X_test[i, :, :].std()\n",
    "\n",
    "    # resulting normalized training images\n",
    "    mean_val_test = mean_test.mean()\n",
    "    std_val_test = std_test.mean()\n",
    "    X_test_norm = np.zeros(X_test.shape, dtype=np.float32)\n",
    "    for i in range(X_test.shape[0]):\n",
    "        X_test_norm[i, :, :] = normalize_im(X_test[i, :, :], mean_val_test, std_val_test)\n",
    "\n",
    "    # patch size\n",
    "    psize = X_test_norm.shape[1]\n",
    "\n",
    "    # Reshaping\n",
    "    X_test_norm = X_test_norm.reshape(X_test.shape[0], psize, psize, 1)\n",
    "\n",
    "    return X_test_norm"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* load the validation images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "validation_image_in = io.imread('data/validation_input.tif')            #the input images\n",
    "validation_image_in_norm = process_test_images(validation_image_in)\n",
    "validation_image_out = io.imread('data/validation_output.tif')          #the actual output images\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* run the cells below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = buildModel((32,32,1))\n",
    "model.load_weights('model/weights_best.hdf5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "validation_image_predict = model.predict(validation_image_in_norm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "image_number = 10\n",
    "\n",
    "fig,ax = plt.subplots(1,3, figsize = (18,6))\n",
    "\n",
    "ax[0].imshow(validation_image_in[image_number], cmap = gray)\n",
    "ax[1].imshow(validation_image_out[image_number], cmap = gray)\n",
    "ax[2].imshow(validation_image_predict[image_number], cmap = gray)\n",
    "\n",
    "ax[0].set_title('input image')\n",
    "ax[1].set_title('output image (actual)')\n",
    "ax[2].set_title('output image (predicted)')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.8.8"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}