deep_vineyard_train.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Vineyard Classificator\n",
    "\n",
    "**Objective**: the aim of this notebook is to train multiple classificators with images coming from vineyards. The best trained classificator, in term of performance and accuracy, will be used to control a robot with the probability of the predictions. So, it's a classification tasks with three dinstinct classes, left, center and right.\n",
    "\n",
    "**Models**: A model based approach with Deep Learning algorithms will be exploit. In particular, a technique dubbed transfer learning (fine tuning) will be applied in order to re-train network already trained on ImageNet dataset. This will not only let achieve higher performances, but also will tackle the lack of a large dataset.\n",
    "\n",
    "**Architecture**: \n",
    "   - MobileNet (ncs1 & ncs2 compatible)\n",
    "   - Inception-v3 (ncs1 & ncs2 compatible)\n",
    "   - Xception (Xavier compatible)\n",
    "   - InceptionResNetV2 (ncs2 compatible)\n",
    "   \n",
    "   \n",
    "**Papers**:\n",
    "    - Autonomous Navigation in Vineyards with Deep Learning at the Edge: (https://link.springer.com/chapter/10.1007/978-3-030-48989-2_51)\n",
    "    - Local Motion Planner for Autonomous Navigation in Vineyards with a RGB-D Camera-Based Algorithm and Deep Learning Synergy ("
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1.0 Import the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
    "from sklearn.metrics import classification_report, confusion_matrix\n",
    "from tqdm import tqdm_notebook as tqdm\n",
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#configure your GPU\n",
    "gpus = tf.config.experimental.list_physical_devices('GPU')\n",
    "tf.config.experimental.set_visible_devices(gpus[0], 'GPU')\n",
    "tf.config.experimental.set_memory_growth(gpus[0], True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "PATH_DIR = os.path.abspath('.')\n",
    "dataset_dir = os.path.join(PATH_DIR, 'dataset')\n",
    "train_dir = os.path.join(dataset_dir, 'train')\n",
    "validation_dir =  os.path.join(dataset_dir, 'validation')\n",
    "test_dir =  os.path.join(dataset_dir, 'test')\n",
    "\n",
    "# Parameters\n",
    "batch_size = 64\n",
    "img_sz = (224, 224) # must be equal to the choosen network\n",
    "classes = ['left', 'center', 'right'] #output classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Data Augmentation Parameters\n",
    "z_range = 0.1 # zoom\n",
    "b_range = [1.0, 0.4] # brightenss\n",
    "\n",
    "# create two datagenerator for the train and test set\n",
    "train_image_generator = ImageDataGenerator(rescale = 1./255,\n",
    "                                  zoom_range = z_range,\n",
    "                                  brightness_range = b_range,\n",
    "                                  fill_mode = 'nearest')\n",
    "validation_image_generator = ImageDataGenerator(rescale = 1./255)\n",
    "test_image_generator = ImageDataGenerator(rescale = 1./255)\n",
    "test_casa_image_generator = ImageDataGenerator(rescale = 1./255)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 23530 images belonging to 3 classes.\n",
      "Found 5042 images belonging to 3 classes.\n",
      "Found 5044 images belonging to 3 classes.\n"
     ]
    }
   ],
   "source": [
    "# create two generators\n",
    "train_data_gen = train_image_generator.flow_from_directory(directory = train_dir,\n",
    "                                                          batch_size = batch_size,\n",
    "                                                          classes = classes,\n",
    "                                                          shuffle = False, # only for testing\n",
    "                                                          target_size = img_sz,\n",
    "                                                          class_mode = 'categorical', # it means labels are [1,0,0]\n",
    "                                                          seed = 3)\n",
    "validation_data_gen = test_image_generator.flow_from_directory(directory = validation_dir,\n",
    "                                                        batch_size = batch_size,\n",
    "                                                        classes = classes,\n",
    "                                                        shuffle = False,\n",
    "                                                        seed=3,\n",
    "                                                        target_size = img_sz,\n",
    "                                                        class_mode = 'categorical')\n",
    "test_data_gen = test_image_generator.flow_from_directory(directory = test_dir,\n",
    "                                                        batch_size = batch_size,\n",
    "                                                        classes = classes,\n",
    "                                                        shuffle = False,\n",
    "                                                        seed=3,\n",
    "                                                        target_size = img_sz,\n",
    "                                                        class_mode = 'categorical')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'left': 0, 'center': 1, 'right': 2}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# plot class relations\n",
    "train_data_gen.class_indices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2.0 Plot the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plotImages(images_batch, img_n, classes):\n",
    "    \"\"\"\n",
    "    Take as input a batch from the generator and plt a number of images equal to img_n\n",
    "    Default columns equal to max_c. At least inputs of batch equal two\n",
    "    \"\"\"\n",
    "    max_c = 5\n",
    "    \n",
    "    if img_n <= max_c:\n",
    "        r = 1\n",
    "        c = img_n\n",
    "    else:\n",
    "        r = math.ceil(img_n/max_c)\n",
    "        c = max_c\n",
    "        \n",
    "    fig, axes = plt.subplots(r, c, figsize=(15,15))\n",
    "    axes = axes.flatten()\n",
    "    for img_batch, label_batch, ax in zip(images_batch[0], images_batch[1], axes):\n",
    "        ax.imshow(img_batch)\n",
    "        ax.grid()\n",
    "#    _ = plt.suptitle(\"Batch images\", verticalalignment='top')\n",
    "        ax.set_title('Class: {}'.format(classes[np.argmax(label_batch)]))\n",
    "    plt.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plotImages(next(train_data_gen), 5, classes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3.0 Fine-Tune Selected Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.layers import Dense, GlobalAveragePooling2D\n",
    "from tensorflow.keras.optimizers import Adam, RMSprop, SGD\n",
    "from tensorflow.keras.callbacks import ModelCheckpoint, TensorBoard\n",
    "from datetime import datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_dir = os.path.join(PATH_DIR, 'bin')\n",
    "\n",
    "if not os.path.exists(model_dir):\n",
    "    os.mkdir(model_dir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def buildModel(base_model, first_layer = 1024, output = 3):\n",
    "    \"\"\"Add two fully connected layers to the base model\n",
    "    \"\"\"\n",
    "    \n",
    "    # add a global spatial average pooling layer\n",
    "    x = base_model.output\n",
    "    x = GlobalAveragePooling2D()(x)\n",
    "    x = Dense(first_layer, activation='relu')(x)\n",
    "\n",
    "    predictions = Dense(output, activation='softmax')(x)\n",
    "\n",
    "    # this is the model we will train\n",
    "    model = Model(inputs=base_model.input, outputs=predictions)\n",
    "    \n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plotHistory(history):\n",
    "    \"\"\"\n",
    "    Plot the loss and accuracy curves for training and validation \n",
    "    \"\"\"\n",
    "    fig, ax = plt.subplots(2,1, figsize=(20,15))\n",
    "    ax[0].plot(history.history['loss'], color='b', label=\"Training loss\")\n",
    "    ax[0].plot(history.history['val_loss'], color='r', label=\"validation loss\",axes =ax[0])\n",
    "    legend = ax[0].legend(loc='best', shadow=True)\n",
    "\n",
    "    ax[1].plot(history.history['acc'], color='b', label=\"Training accuracy\")\n",
    "    ax[1].plot(history.history['val_acc'], color='r',label=\"Validation accuracy\")\n",
    "    legend = ax[1].legend(loc='best', shadow=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the optimizer\n",
    "optimizer_r = RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0)\n",
    "optimizer_a = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, amsgrad=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load model if needed\n",
    "from tensorflow.keras.models import load_model\n",
    "\n",
    "model = load_model('bin/MobileNet_final_retrained.h5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## 3.1 MobileNet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "name = 'MobileNet_final'\n",
    "now = datetime.utcnow().strftime(\"%Y%m%d%H%M%S\")\n",
    "root_logdir = \"logs\"\n",
    "logdir = \"{}/run-{}_{}/\".format(root_logdir, now,name)\n",
    "\n",
    "backup_model_path = os.path.join(model_dir, '{}_retrained.h5'.format(name)) # it contains already the weights\n",
    "backup_weights_path = os.path.join(model_dir, '{}_retrained_weights.h5'.format(name))\n",
    "\n",
    "# tensorboard\n",
    "tensorboard = TensorBoard(log_dir = logdir)\n",
    "\n",
    "checkpointer = ModelCheckpoint(filepath=backup_weights_path, \n",
    "                               monitor = 'loss',\n",
    "                               verbose=1, \n",
    "                               save_best_only=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "from keras.applications.mobilenet import MobileNet\n",
    "\n",
    "# create the base pre-trained model\n",
    "base_model = MobileNet(input_shape = (224, 224, 3),\n",
    "                       weights='imagenet', include_top=False,\n",
    "                       alpha=1.0, depth_multiplier=1, dropout=1e-3)\n",
    "\n",
    "model = buildModel(base_model, 256, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# plot the summary\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# for i, layer in enumerate(model.layers):\n",
    "#    print(i, layer.name)\n",
    "# print the depth of the network\n",
    "model_depth = len(model.layers)\n",
    "print(\"Depth of the network: {}\".format(model_depth))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "### 3.1.1 Re-Train the network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# i.e. freeze all base model layers\n",
    "for layer in base_model.layers:\n",
    "    layer.trainable = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# compile the model \n",
    "model.compile(optimizer=optimizer_r, loss='categorical_crossentropy', metrics = ['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "first_n_epochs = 6\n",
    "\n",
    "# train the model on the new data for a few epochs\n",
    "history = model.fit_generator(train_data_gen, ((train_data_gen.n // batch_size) + 1),\n",
    "                    epochs = first_n_epochs,\n",
    "                    validation_data = validation_data_gen, shuffle = True,\n",
    "                    validation_steps = ((validation_data_gen.n // batch_size) + 1),\n",
    "                    callbacks = [tensorboard])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "plotHistory(history)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# save model and weights\n",
    "model.save(backup_model_path)\n",
    "model.save_weights(backup_weights_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### 3.1.2 Test the retrained model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "score = model.evaluate_generator(train_data_gen, steps = (train_data_gen.n // batch_size + 1),  workers=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "for s, m in zip(score, model.metrics_names):\n",
    "    print(\"{}: {}\".format(m, s))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "- MobileNet_second (grugliasco training) **test** new 5044 ==> acc: 0.9484536082474226 loss: 0.4985503224651601\n",
    "- MobileNet_second (grugliasco training) **train** new 23530 ==> acc: 0.9408839778600223 loss: 0.5127158542301014\n",
    "- MobileNet_second (grugliasco training) **validation** new 5042 ==> acc: 0.9430781435938119 loss: loss: 0.5145192529085608"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### 3.1.3 Confusion Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "import itertools\n",
    "# defining the confusion matrix function\n",
    "def plot_confusion_matrix(cm, classes,\n",
    "                          normalize=False,\n",
    "                          title='Confusion matrix',\n",
    "                          cmap=plt.cm.Blues):\n",
    "    \"\"\"\n",
    "    This function prints and plots the confusion matrix.\n",
    "    Normalization can be applied by setting `normalize=True`.\n",
    "    \"\"\"\n",
    "    if normalize:\n",
    "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
    "        print(\"Normalized confusion matrix\")\n",
    "    else:\n",
    "        print('Confusion matrix, without normalization')\n",
    "\n",
    "    plt.figure(figsize=(7,7))\n",
    "    plt.imshow(cm, interpolation='nearest', cmap=cmap)\n",
    "    plt.title(title)\n",
    "    plt.colorbar()\n",
    "    tick_marks = np.arange(len(classes))\n",
    "    plt.xticks(tick_marks, classes, rotation=45)\n",
    "    plt.yticks(tick_marks, classes)\n",
    "\n",
    "    fmt = '.2f' if normalize else 'd'\n",
    "    thresh = cm.max() / 2.\n",
    "    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
    "        plt.text(j, i, format(cm[i, j], fmt),\n",
    "                 horizontalalignment=\"center\",\n",
    "                 color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "\n",
    "    plt.tight_layout()\n",
    "    plt.ylabel('True label')\n",
    "    plt.xlabel('Predicted label')\n",
    "    plt.savefig('confusion_matrix.png')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# collect test predictions\n",
    "y_pred = model.predict_generator(train_data_gen, steps = ((train_data_gen.n // batch_size) + 1), workers=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# predicting with the classifier\n",
    "cm = confusion_matrix(train_data_gen.classes, np.argmax(y_pred, axis=-1))\n",
    "\n",
    "plot_confusion_matrix(cm, classes, title = 'Confusion Matrix')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### 3.1.4 Classifiction Report"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "from sklearn.metrics import classification_report, accuracy_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "accuracy_score(train_data_gen.classes, np.argmax(y_pred, axis=-1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "labels = list((train_data_gen.class_indices).values())\n",
    "target_names = list((train_data_gen.class_indices).keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "clf_report = classification_report(train_data_gen.classes, np.argmax(y_pred, axis=-1),\n",
    "                      labels=labels, target_names=target_names, digits=3)\n",
    "print(clf_report)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## 3.2 Plot Intermediate Layers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "import cv2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "FIRST_IMAGE = cv2.resize(cv2.cvtColor(cv2.imread('dataset/train/left/img_0.jpg') , cv2.COLOR_BGR2RGB), (224,224))/255.0\n",
    "SECOND_IMAGE = cv2.resize(cv2.cvtColor(cv2.imread('dataset/train/center/img_20.jpg') , cv2.COLOR_BGR2RGB), (224,224))/255.0\n",
    "THIRD_IMAGE = cv2.resize(cv2.cvtColor(cv2.imread('dataset/train/right/img_0.jpg') , cv2.COLOR_BGR2RGB), (224,224))/255.0\n",
    "\n",
    "from tensorflow.keras import models\n",
    "layer_outputs = [layer.output for layer in model.layers]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "for i,j in enumerate(layer_outputs):\n",
    "    print(i, j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "selected_layers = [layer_outputs[2], layer_outputs[28], layer_outputs[84]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "selected_layers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "activation_model = Model(inputs = model.input, outputs = selected_layers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "CONVOLUTION_NUMBER = 6\n",
    "fig, ax = plt.subplots(3,4, figsize=(15,15))\n",
    "\n",
    "\n",
    "ax[0,0].imshow(FIRST_IMAGE)\n",
    "#ax[0,0].axis('off')\n",
    "#ax[0,0].grid(True)\n",
    "ax[1,0].imshow(SECOND_IMAGE)\n",
    "#ax[1,0].axis('off')\n",
    "#ax[1,0].grid(True)\n",
    "ax[2,0].imshow(THIRD_IMAGE)\n",
    "#ax[2,0].axis('off')\n",
    "#ax[2,0].grid(True)   \n",
    "\n",
    "\n",
    "for x in range(0, 3):\n",
    "    f1 = activation_model.predict(FIRST_IMAGE.reshape(1,224,224,3))[x]\n",
    "    ax[0,x+1].imshow(f1[0,:,:,CONVOLUTION_NUMBER], cmap='inferno')\n",
    "    ax[0,x+1].grid(False)\n",
    "    \n",
    "    f2 = activation_model.predict(SECOND_IMAGE.reshape(1,224,224,3))[x]\n",
    "    ax[1,x+1].imshow(f2[0,:,:,CONVOLUTION_NUMBER], cmap='inferno')\n",
    "    ax[1,x+1].grid(False)\n",
    "    \n",
    "    f3 = activation_model.predict(THIRD_IMAGE.reshape(1,224,224,3))[x]\n",
    "    ax[2,x+1].imshow(f3[0,:,:,CONVOLUTION_NUMBER], cmap='inferno')\n",
    "    ax[2,x+1].grid(False)\n",
    "plt.tight_layout()\n",
    "plt.subplots_adjust(bottom=1.0, top=1.7, hspace=0.1)\n",
    "plt.savefig('activations_layers_2_28_84.png', dpi=300)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3 Use GradCAM\n",
    "\n",
    "Using GradCAM for a better understanding of where the network focuses \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tf_explain.core.grad_cam import GradCAM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "explainer = GradCAM()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_test, y_test = next(test_data_gen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = model.predict(x_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def explainGradCam(explainer, model, img, y, y_pred, class_names):\n",
    "    data = data = ([img], None)\n",
    "    plt.figure(figsize=(5,5))\n",
    "    y = np.argmax(y)\n",
    "    y_predm = np.argmax(y_pred)\n",
    "    if y == y_predm:\n",
    "        color = 'blue'\n",
    "    else:\n",
    "        color = 'red'\n",
    "        \n",
    "    grid = explainer.explain(data, model, class_index=y_predm, colormap=14) \n",
    "\n",
    "    plt.imshow(grid)\n",
    "\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "index = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "figure_n = index # number of figure (64)\n",
    "index += 1\n",
    "explainGradCam(explainer, model, x_test[figure_n], y_test[figure_n],\n",
    "               y_pred[figure_n], class_names=list(train_data_gen.class_indices.keys()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## 3.2 Xception"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "name = 'Xception'\n",
    "now = datetime.utcnow().strftime(\"%Y%m%d%H%M%S\")\n",
    "root_logdir = \"logs\"\n",
    "logdir = \"{}/run-{}_{}/\".format(root_logdir, now,name)\n",
    "\n",
    "backup_model_path = os.path.join(model_dir, '{}_retrained.h5'.format(name)) # it contains already the weights\n",
    "backup_weights_path = os.path.join(model_dir, '{}_retrained_weights.h5'.format(name))\n",
    "\n",
    "# tensorboard\n",
    "tensorboard = TensorBoard(log_dir = logdir)\n",
    "\n",
    "checkpointer = ModelCheckpoint(filepath=backup_weights_path, \n",
    "                               monitor = 'loss',\n",
    "                               verbose=1, \n",
    "                               save_best_only=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "from keras.applications.xception import Xception\n",
    "\n",
    "# create the base pre-trained model\n",
    "base_model = Xception(input_shape = (299, 299, 3),\n",
    "                       weights='imagenet', include_top=False)\n",
    "\n",
    "model = buildModel(base_model, 256, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# plot the summary\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# for i, layer in enumerate(model.layers):\n",
    "#    print(i, layer.name)\n",
    "# print the depth of the network\n",
    "model_depth = len(model.layers)\n",
    "print(\"Depth of the network: {}\".format(model_depth))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### 3.2.1 Train only the head of the network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# i.e. freeze all base model layers\n",
    "for layer in base_model.layers:\n",
    "    layer.trainable = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# compile the model \n",
    "model.compile(optimizer=optimizer_r, loss='categorical_crossentropy', metrics = ['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "first_n_epochs = 5\n",
    "\n",
    "# train the model on the new data for a few epochs\n",
    "history = model.fit_generator(train_data_gen, ((train_data_gen.n // batch_size) + 1),\n",
    "                    epochs = first_n_epochs,\n",
    "                    validation_data = validation_data_gen, shuffle = True,\n",
    "                    validation_steps = ((validation_data_gen.n // batch_size) + 1),\n",
    "                    callbacks = [tensorboard, checkpointer])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "plotHistory(history)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# save model and weights\n",
    "model.save(backup_model_path)\n",
    "model.save_weights(backup_weights_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## 3.3 MobileNetv2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "name = 'MobileNetv2'\n",
    "now = datetime.utcnow().strftime(\"%Y%m%d%H%M%S\")\n",
    "root_logdir = \"logs\"\n",
    "logdir = \"{}/run-{}_{}/\".format(root_logdir, now,name)\n",
    "\n",
    "backup_model_path = os.path.join(model_dir, '{}_retrained.h5'.format(name)) # it contains already the weights\n",
    "backup_weights_path = os.path.join(model_dir, '{}_retrained_weights.h5'.format(name))\n",
    "\n",
    "# tensorboard\n",
    "tensorboard = TensorBoard(log_dir = logdir)\n",
    "\n",
    "checkpointer = ModelCheckpoint(filepath=backup_weights_path, \n",
    "                               monitor = 'loss',\n",
    "                               verbose=1, \n",
    "                               save_best_only=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "from keras.applications.mobilenet_v2 import MobileNetV2\n",
    "\n",
    "# create the base pre-trained model\n",
    "base_model = MobileNetV2(input_shape = (224, 224, 3),\n",
    "                       weights='imagenet', include_top=False)\n",
    "\n",
    "model = buildModel(base_model, 512, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# plot the summary\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# for i, layer in enumerate(model.layers):\n",
    "#    print(i, layer.name)\n",
    "# print the depth of the network\n",
    "model_depth = len(model.layers)\n",
    "print(\"Depth of the network: {}\".format(model_depth))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "### 3.3.1 Train only the head of the network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# i.e. freeze all base model layers\n",
    "for layer in base_model.layers:\n",
    "    layer.trainable = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# compile the model \n",
    "model.compile(optimizer=optimizer_r, loss='categorical_crossentropy', metrics = ['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "first_n_epochs = 3\n",
    "\n",
    "# train the model on the new data for a few epochs\n",
    "history = model.fit_generator(train_data_gen, ((train_data_gen.n // batch_size) + 1),\n",
    "                    epochs = first_n_epochs,\n",
    "                    validation_data = validation_data_gen, shuffle = True,\n",
    "                    validation_steps = ((validation_data_gen.n // batch_size) + 1),\n",
    "                    callbacks = [tensorboard, checkpointer])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "plotHistory(history)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# save model and weights\n",
    "model.save(backup_model_path)\n",
    "model.save_weights(backup_weights_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "### 3.3.2 Test the retrained model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "score = model.evaluate_generator(test_data_gen, steps = (test_data_gen.n // batch_size + 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "for s, m in zip(score, model.metrics_names):\n",
    "    print(\"{}: {}\".format(m, s))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "# 4.0 Test the model on a new dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "score = model.evaluate_generator(test_data_gen, steps = (test_data_gen.n // batch_size + 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "for s, m in zip(score, model.metrics_names):\n",
    "    print(\"{}: {}\".format(m, s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "y_pred = model.predict_generator(test_casa_data_gen, steps = ((test_casa_data_gen.n // batch_size) + 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "accuracy_score(np.argmax(y_test, axis=-1), np.argmax(y_pred, axis=-1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# predicting with the classifier\n",
    "cm = confusion_matrix(np.argmax(y_test, axis=-1), np.argmax(y_pred, axis=-1))\n",
    "\n",
    "plot_confusion_matrix(cm, classes, title = 'Confusion Matrix')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "# 5.0 Test models on single images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "from keras.applications.mobilenet import MobileNet\n",
    "from keras.preprocessing import image\n",
    "from keras.applications.mobilenet import preprocess_input, decode_predictions\n",
    "import numpy as np\n",
    "\n",
    "file = 'frame_0.jpg'\n",
    "\n",
    "img_path = os.path.join(dataset_dir, test_casa_dir, 'left', file)\n",
    "img = image.load_img(img_path, target_size=(224, 224))\n",
    "x = image.img_to_array(img)\n",
    "x = np.expand_dims(x, axis=0)\n",
    "x = preprocess_input(x)\n",
    "\n",
    "y = model.predict(x)\n",
    "\n",
    "plt.title('Predicted: {}'.format(classes[np.argmax(y)]))\n",
    "_ = plt.imshow(img)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}