ConvLSTM.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ConvLSTM\n",
    "\n",
    "## Pre-setup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Import the required libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-11-03 15:05:21.648393: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX512F AVX512_VNNI FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2022-11-03 15:05:21.775926: I tensorflow/core/util/util.cc:169] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
      "2022-11-03 15:05:21.806583: E tensorflow/stream_executor/cuda/cuda_blas.cc:2981] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2022-11-03 15:05:22.382411: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer.so.7'; dlerror: libnvinfer.so.7: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /usr/local/lib:/usr/local/nvidia/lib:/usr/local/nvidia/lib64\n",
      "2022-11-03 15:05:22.382507: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer_plugin.so.7'; dlerror: libnvinfer_plugin.so.7: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /usr/local/lib:/usr/local/nvidia/lib:/usr/local/nvidia/lib64\n",
      "2022-11-03 15:05:22.382512: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Cannot dlopen some TensorRT libraries. If you would like to use Nvidia GPU with TensorRT, please make sure the missing libraries mentioned above are installed properly.\n"
     ]
    }
   ],
   "source": [
    "# Import the required libraries.\n",
    "import os\n",
    "import math\n",
    "import random\n",
    "import numpy as np\n",
    "import datetime as datetime\n",
    "from collections import deque\n",
    "import matplotlib.pyplot as plt\n",
    "#from moviepy.editor import *\n",
    "%matplotlib inline\n",
    "from sklearn.model_selection import train_test_split\n",
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from batch_data_generator import DataGenerator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import tensorflow and check for GPU support"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Num GPUs Available:  2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU'),\n",
       " PhysicalDevice(name='/physical_device:GPU:1', device_type='GPU')]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Print num of GPUs if available to use\n",
    "print(\"Num GPUs Available: \", len(tf.config.experimental.list_physical_devices('GPU')))\n",
    "tf.config.list_physical_devices('GPU')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set a seed to reproduce the results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "seed_constant = 123\n",
    "np.random.seed(seed_constant)\n",
    "random.seed(seed_constant)\n",
    "tf.random.set_seed(seed_constant)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set data directories and other constants for the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Data paths are defined here\n",
    "DATA_DIR = 'data'\n",
    "VIDEO_PATH = os.path.join(DATA_DIR, 'videos')\n",
    "ANNOTATION_PATH = os.path.join(DATA_DIR, 'annotations')\n",
    "TRAINING_PATH = os.path.join(VIDEO_PATH, 'training')\n",
    "TESTING_PATH = os.path.join(VIDEO_PATH, 'testing')\n",
    "VALIDATION_PATH = os.path.join(VIDEO_PATH, 'validation')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Specify the number of frames of a video that will be fed to the model as one sequence.\n",
    "SEQUENCE_LENGTH = 30\n",
    "\n",
    "# Set a minimum duration in seconds to extract sequence in multiples of\n",
    "MIN_DURATION = 150\n",
    "\n",
    "(DIMENSION_X, DIMENSION_Y, DIMENSION_C) = (224, 224, 3)\n",
    "\n",
    "# Get the names of all classes/categories in our dataset.\n",
    "CLASSES_LIST = os.listdir(TRAINING_PATH)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a easily readable class name mapping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class_mapping = {\n",
    "'_cut___chop___slice_a_vegetable,_fruit,_or_meat_' : 'cut vegetables, herbs or meat',\n",
    "'browse_through_clothing_items_on_rack___shelf___hanger' : 'browse through clothing items',\n",
    "'clean___wipe_other_surface_or_object' : 'clean surface',\n",
    "'dig_or_till_the_soil_with_a_hoe_or_other_tool' : 'till soil with a hoe',\n",
    "'read_a_book___magazine___shopping_list_etc' : 'read a book',\n",
    "'throw_away_trash___put_trash_in_trash_can' : 'throw away trash',\n",
    "'wash_dishes___utensils___bakeware_etc' : 'wash utensils'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Read npy files in data generator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get the file paths and corresponsing labels for the data generator (**Run everytime kernel is (re)started**)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_nparray_and_labels_in_partition(partition_path):\n",
    "\tnparrayfile_paths = []\n",
    "\tlabels = {}\n",
    "\tfor class_name in os.listdir(partition_path):\n",
    "\t\tif class_name not in CLASSES_LIST:\n",
    "\t\t\tprint(f'{class_name} not found in class list!')\n",
    "\t\t\tcontinue\n",
    "\t\tfor video_file_name in os.listdir(os.path.join(partition_path, class_name)):\n",
    "\t\t\tif not video_file_name.endswith('.npy'): continue\n",
    "\t\t\tnparrayfile_path = os.path.join(partition_path, class_name, video_file_name)\n",
    "\t\t\tnparrayfile_paths.append(nparrayfile_path)\n",
    "\t\t\tlabels[nparrayfile_path] = CLASSES_LIST.index(class_name)\n",
    "\treturn nparrayfile_paths, labels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Split the data into train, validation and test sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "nparray_partition = {}\n",
    "nparray_labels = {}\n",
    "nparray_partition['train'], nparray_labels['train'] = get_nparray_and_labels_in_partition(TRAINING_PATH)\n",
    "nparray_partition['test'], nparray_labels['test'] = get_nparray_and_labels_in_partition(TESTING_PATH)\n",
    "nparray_partition['validation'], nparray_labels['validation'] = get_nparray_and_labels_in_partition(VALIDATION_PATH)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define parameters for data generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data_generator_params = {\n",
    "\t'batch_size' : 5,\n",
    "\t'sequence_length' : SEQUENCE_LENGTH,\n",
    "\t'n_classes' : len(CLASSES_LIST),\n",
    "\t'min_duration' : MIN_DURATION,\n",
    "\t'shuffle' : True\n",
    "}\n",
    "\n",
    "validation_data_generator_params = {\n",
    "\t'batch_size' : 5,\n",
    "\t'sequence_length' : SEQUENCE_LENGTH,\n",
    "\t'n_classes' : len(CLASSES_LIST),\n",
    "\t'min_duration' : MIN_DURATION,\n",
    "\t'shuffle' : True\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_generator = DataGenerator(nparray_partition['train'], nparray_labels['train'], **train_data_generator_params)\n",
    "validation_generator = DataGenerator(nparray_partition['validation'], nparray_labels['validation'], **validation_data_generator_params)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create model - ConvLSTM"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.layers import ConvLSTM2D, MaxPooling3D, TimeDistributed, Dropout, Flatten, Dense, Input, BatchNormalization\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.utils import to_categorical\n",
    "from tensorflow.keras.callbacks import EarlyStopping\n",
    "from tensorflow.keras.utils import plot_model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Function to create keras sequential model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_convlstm_model():\n",
    "    '''\n",
    "    This function will construct the required convlstm model.\n",
    "    Returns:\n",
    "        model: It is the required constructed convlstm model.\n",
    "    '''\n",
    "\n",
    "    # We will use a Sequential model for model construction\n",
    "    model = Sequential()\n",
    "\n",
    "    # Define the Model Architecture.\n",
    "    ########################################################################################################################\n",
    "    model.add(Input(shape=(SEQUENCE_LENGTH, DIMENSION_X, DIMENSION_Y, DIMENSION_C)))\n",
    "    \n",
    "    model.add(ConvLSTM2D(filters = 4, kernel_size = (3, 3), activation = 'tanh',data_format = \"channels_last\",\n",
    "                         recurrent_dropout=0.4, return_sequences=True))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(MaxPooling3D(pool_size=(1, 2, 2), padding='same', data_format='channels_last'))\n",
    "    model.add(TimeDistributed(Dropout(0.4)))\n",
    "    \n",
    "    model.add(ConvLSTM2D(filters = 8, kernel_size = (3, 3), activation = 'tanh', data_format = \"channels_last\",\n",
    "                         recurrent_dropout=0.4, return_sequences=True))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(MaxPooling3D(pool_size=(1, 2, 2), padding='same', data_format='channels_last'))\n",
    "    model.add(TimeDistributed(Dropout(0.4)))\n",
    "    \n",
    "    model.add(ConvLSTM2D(filters = 14, kernel_size = (3, 3), activation = 'tanh', data_format = \"channels_last\",\n",
    "                         recurrent_dropout=0.4, return_sequences=True))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(MaxPooling3D(pool_size=(1, 2, 2), padding='same', data_format='channels_last'))\n",
    "    model.add(TimeDistributed(Dropout(0.4)))\n",
    "    \n",
    "    # model.add(ConvLSTM2D(filters = 16, kernel_size = (3, 3), activation = 'tanh', data_format = \"channels_last\",\n",
    "    #                      recurrent_dropout=0.2, return_sequences=True))\n",
    "    # model.add(BatchNormalization())\n",
    "    # model.add(MaxPooling3D(pool_size=(1, 2, 2), padding='same', data_format='channels_last'))\n",
    "    # model.add(TimeDistributed(Dropout(0.2)))\n",
    "    \n",
    "    model.add(Flatten()) \n",
    "    \n",
    "    model.add(Dense(len(CLASSES_LIST), activation = \"softmax\"))\n",
    "    \n",
    "    ########################################################################################################################\n",
    "     \n",
    "    # Display the models summary.\n",
    "    model.summary()\n",
    "    \n",
    "    # Return the constructed convlstm model.\n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-11-03 15:05:23.580392: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX512F AVX512_VNNI FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2022-11-03 15:05:24.806958: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1616] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 13584 MB memory:  -> device: 0, name: Tesla T4, pci bus id: 0000:3b:00.0, compute capability: 7.5\n",
      "2022-11-03 15:05:24.808878: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1616] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 13584 MB memory:  -> device: 1, name: Tesla T4, pci bus id: 0000:d8:00.0, compute capability: 7.5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " conv_lstm2d (ConvLSTM2D)    (None, 30, 222, 222, 4)   1024      \n",
      "                                                                 \n",
      " batch_normalization (BatchN  (None, 30, 222, 222, 4)  16        \n",
      " ormalization)                                                   \n",
      "                                                                 \n",
      " max_pooling3d (MaxPooling3D  (None, 30, 111, 111, 4)  0         \n",
      " )                                                               \n",
      "                                                                 \n",
      " time_distributed (TimeDistr  (None, 30, 111, 111, 4)  0         \n",
      " ibuted)                                                         \n",
      "                                                                 \n",
      " conv_lstm2d_1 (ConvLSTM2D)  (None, 30, 109, 109, 8)   3488      \n",
      "                                                                 \n",
      " batch_normalization_1 (Batc  (None, 30, 109, 109, 8)  32        \n",
      " hNormalization)                                                 \n",
      "                                                                 \n",
      " max_pooling3d_1 (MaxPooling  (None, 30, 55, 55, 8)    0         \n",
      " 3D)                                                             \n",
      "                                                                 \n",
      " time_distributed_1 (TimeDis  (None, 30, 55, 55, 8)    0         \n",
      " tributed)                                                       \n",
      "                                                                 \n",
      " conv_lstm2d_2 (ConvLSTM2D)  (None, 30, 53, 53, 14)    11144     \n",
      "                                                                 \n",
      " batch_normalization_2 (Batc  (None, 30, 53, 53, 14)   56        \n",
      " hNormalization)                                                 \n",
      "                                                                 \n",
      " max_pooling3d_2 (MaxPooling  (None, 30, 27, 27, 14)   0         \n",
      " 3D)                                                             \n",
      "                                                                 \n",
      " time_distributed_2 (TimeDis  (None, 30, 27, 27, 14)   0         \n",
      " tributed)                                                       \n",
      "                                                                 \n",
      " flatten (Flatten)           (None, 306180)            0         \n",
      "                                                                 \n",
      " dense (Dense)               (None, 7)                 2143267   \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 2,159,027\n",
      "Trainable params: 2,158,975\n",
      "Non-trainable params: 52\n",
      "_________________________________________________________________\n",
      "Model Created Successfully!\n",
      "You must install pydot (`pip install pydot`) and install graphviz (see instructions at https://graphviz.gitlab.io/download/) for plot_model to work.\n"
     ]
    }
   ],
   "source": [
    "# Construct the required convlstm model.\n",
    "convlstm_model = create_convlstm_model()\n",
    "\n",
    "# Display the success message. \n",
    "print(\"Model Created Successfully!\")\n",
    "plot_model(convlstm_model, to_file = 'convlstm_model_structure_plot.png', show_shapes = True, show_layer_names = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compile and train the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 20.4 ms, sys: 233 µs, total: 20.6 ms\n",
      "Wall time: 17.3 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# Create an Instance of Early Stopping Callback\n",
    "early_stopping_callback = EarlyStopping(monitor = 'val_loss', patience = 15, mode = 'min', restore_best_weights = True)\n",
    "optimizer = 'sgd'\n",
    "# Compile the model and specify loss function, optimizer and metrics values to the model\n",
    "convlstm_model.compile(loss = 'categorical_crossentropy', optimizer = optimizer, metrics = [\"accuracy\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/60\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-11-03 15:05:34.224875: I tensorflow/stream_executor/cuda/cuda_dnn.cc:384] Loaded cuDNN version 8400\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "197/197 [==============================] - 225s 1s/step - loss: 65.4779 - accuracy: 0.2548 - val_loss: 4.0769 - val_accuracy: 0.2837\n",
      "Epoch 2/60\n",
      "197/197 [==============================] - 219s 1s/step - loss: 2.6853 - accuracy: 0.4914 - val_loss: 2.8781 - val_accuracy: 0.1674\n",
      "Epoch 3/60\n",
      "197/197 [==============================] - 219s 1s/step - loss: 1.1607 - accuracy: 0.6853 - val_loss: 2.9474 - val_accuracy: 0.3721\n",
      "Epoch 4/60\n",
      "197/197 [==============================] - 217s 1s/step - loss: 0.3289 - accuracy: 0.8893 - val_loss: 4.3472 - val_accuracy: 0.3674\n",
      "Epoch 5/60\n",
      "197/197 [==============================] - 217s 1s/step - loss: 0.2080 - accuracy: 0.9421 - val_loss: 4.6795 - val_accuracy: 0.3023\n",
      "Epoch 6/60\n",
      "197/197 [==============================] - 218s 1s/step - loss: 0.1365 - accuracy: 0.9543 - val_loss: 4.3654 - val_accuracy: 0.3302\n",
      "Epoch 7/60\n",
      "197/197 [==============================] - 219s 1s/step - loss: 0.1036 - accuracy: 0.9716 - val_loss: 5.1923 - val_accuracy: 0.3581\n",
      "Epoch 8/60\n",
      "197/197 [==============================] - 218s 1s/step - loss: 0.0725 - accuracy: 0.9766 - val_loss: 4.6727 - val_accuracy: 0.3488\n",
      "Epoch 9/60\n",
      "197/197 [==============================] - 215s 1s/step - loss: 0.0984 - accuracy: 0.9675 - val_loss: 5.2761 - val_accuracy: 0.3581\n",
      "Epoch 10/60\n",
      "197/197 [==============================] - 218s 1s/step - loss: 0.0428 - accuracy: 0.9868 - val_loss: 5.0785 - val_accuracy: 0.3442\n",
      "Epoch 11/60\n",
      "197/197 [==============================] - 217s 1s/step - loss: 0.0401 - accuracy: 0.9898 - val_loss: 5.5659 - val_accuracy: 0.3907\n",
      "Epoch 12/60\n",
      "197/197 [==============================] - 214s 1s/step - loss: 0.0984 - accuracy: 0.9706 - val_loss: 5.5332 - val_accuracy: 0.3256\n",
      "Epoch 13/60\n",
      "197/197 [==============================] - 220s 1s/step - loss: 0.0217 - accuracy: 0.9939 - val_loss: 5.8547 - val_accuracy: 0.3535\n",
      "Epoch 14/60\n",
      "197/197 [==============================] - 215s 1s/step - loss: 0.0260 - accuracy: 0.9929 - val_loss: 6.3009 - val_accuracy: 0.3953\n",
      "Epoch 15/60\n",
      "197/197 [==============================] - 216s 1s/step - loss: 0.0282 - accuracy: 0.9878 - val_loss: 6.1770 - val_accuracy: 0.3721\n",
      "Epoch 16/60\n",
      "197/197 [==============================] - 216s 1s/step - loss: 0.0144 - accuracy: 0.9959 - val_loss: 6.2405 - val_accuracy: 0.3395\n",
      "Epoch 17/60\n",
      "197/197 [==============================] - 218s 1s/step - loss: 0.0145 - accuracy: 0.9980 - val_loss: 6.3234 - val_accuracy: 0.3767\n",
      "CPU times: user 1h 38min 12s, sys: 58min 3s, total: 2h 36min 15s\n",
      "Wall time: 1h 1min 45s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# Start training the model.\n",
    "convlstm_model_training_history = convlstm_model.fit(x = training_generator, \n",
    "    validation_data = validation_generator,\n",
    "    use_multiprocessing=True,\n",
    "    workers=6, \n",
    "    epochs = 60,\n",
    "    callbacks = [early_stopping_callback])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Display some values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "acc: 99.8\n",
      "val_acc: 37.7\n"
     ]
    }
   ],
   "source": [
    "print(f\"acc: {convlstm_model_training_history.history['accuracy'][-1]*100:.1f}\")\n",
    "print(f\"val_acc: {convlstm_model_training_history.history['val_accuracy'][-1]*100:.1f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1.22 ms, sys: 276 ms, total: 277 ms\n",
      "Wall time: 113 ms\n"
     ]
    }
   ],
   "source": [
    "%%time \n",
    "# Define a useful name for our model to make it easy for us while navigating through multiple saved models.\n",
    "model_file_name = f'ConvLSTM_model_{optimizer}.h5'\n",
    "\n",
    "# Save the Model.\n",
    "convlstm_model.save(model_file_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_metric(model_training_history, metric_name_1, metric_name_2, plot_name,y_label='accuracy'):\n",
    "    '''\n",
    "    This function will plot the metrics passed to it in a graph.\n",
    "    Args:\n",
    "        model_training_history: A history object containing a record of training and validation \n",
    "                                loss values and metrics values at successive epochs\n",
    "        metric_name_1:          The name of the first metric that needs to be plotted in the graph.\n",
    "        metric_name_2:          The name of the second metric that needs to be plotted in the graph.\n",
    "        plot_name:              The title of the graph.\n",
    "    '''\n",
    "    # Get metric values using metric names as identifiers.\n",
    "    metric_value_1 = model_training_history.history[metric_name_1]\n",
    "    metric_value_2 = model_training_history.history[metric_name_2]\n",
    "\n",
    "    # Construct a range object which will be used as x-axis (horizontal plane) of the graph.\n",
    "    epochs = range(len(metric_value_1))\n",
    "\n",
    "    # Plot the Graph.\n",
    "    plt.plot(epochs, metric_value_1, 'blue', label = metric_name_1)\n",
    "    plt.plot(epochs, metric_value_2, 'red', label = metric_name_2)\n",
    "\n",
    "    # Add title to the plot.\n",
    "    plt.title(str(plot_name))\n",
    "    \n",
    "    plt.xlabel('Epochs')\n",
    "    plt.ylabel(y_label)\n",
    "\n",
    "    # Add legend to the plot.\n",
    "    plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_metric(convlstm_model_training_history, 'loss', 'val_loss', 'Testing Loss vs Validation Loss', 'Loss')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_metric(convlstm_model_training_history, 'accuracy', 'val_accuracy', 'Testing Accuracy vs Validation Accuracy') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 2s 2s/step\n",
      "1/1 [==============================] - 0s 325ms/step\n",
      "1/1 [==============================] - 0s 106ms/step\n",
      "1/1 [==============================] - 0s 133ms/step\n",
      "1/1 [==============================] - 0s 151ms/step\n",
      "1/1 [==============================] - 0s 118ms/step\n",
      "1/1 [==============================] - 0s 121ms/step\n",
      "1/1 [==============================] - 0s 124ms/step\n",
      "1/1 [==============================] - 0s 121ms/step\n",
      "1/1 [==============================] - 0s 123ms/step\n",
      "1/1 [==============================] - 0s 137ms/step\n",
      "1/1 [==============================] - 0s 120ms/step\n",
      "1/1 [==============================] - 0s 116ms/step\n",
      "1/1 [==============================] - 0s 119ms/step\n",
      "1/1 [==============================] - 0s 116ms/step\n",
      "1/1 [==============================] - 0s 118ms/step\n",
      "1/1 [==============================] - 0s 128ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 109ms/step\n",
      "1/1 [==============================] - 0s 125ms/step\n",
      "1/1 [==============================] - 0s 124ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 109ms/step\n",
      "1/1 [==============================] - 0s 111ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 103ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 109ms/step\n",
      "1/1 [==============================] - 0s 105ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 102ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 105ms/step\n",
      "1/1 [==============================] - 0s 128ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 103ms/step\n",
      "1/1 [==============================] - 0s 106ms/step\n",
      "1/1 [==============================] - 0s 106ms/step\n",
      "1/1 [==============================] - 0s 114ms/step\n",
      "1/1 [==============================] - 0s 109ms/step\n",
      "1/1 [==============================] - 0s 110ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 111ms/step\n",
      "1/1 [==============================] - 0s 109ms/step\n",
      "1/1 [==============================] - 0s 109ms/step\n",
      "1/1 [==============================] - 0s 104ms/step\n",
      "1/1 [==============================] - 0s 106ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 125ms/step\n",
      "1/1 [==============================] - 0s 123ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 110ms/step\n",
      "1/1 [==============================] - 0s 110ms/step\n",
      "1/1 [==============================] - 0s 102ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 109ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 106ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 109ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 106ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 106ms/step\n",
      "1/1 [==============================] - 0s 121ms/step\n",
      "1/1 [==============================] - 0s 119ms/step\n",
      "1/1 [==============================] - 0s 105ms/step\n",
      "1/1 [==============================] - 0s 119ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 106ms/step\n",
      "1/1 [==============================] - 0s 104ms/step\n",
      "1/1 [==============================] - 0s 105ms/step\n",
      "1/1 [==============================] - 0s 106ms/step\n",
      "1/1 [==============================] - 0s 106ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 113ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 112ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 106ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 106ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 106ms/step\n",
      "1/1 [==============================] - 0s 104ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 106ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 113ms/step\n",
      "1/1 [==============================] - 0s 112ms/step\n",
      "1/1 [==============================] - 0s 109ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 124ms/step\n",
      "1/1 [==============================] - 0s 112ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 104ms/step\n",
      "1/1 [==============================] - 0s 104ms/step\n",
      "1/1 [==============================] - 0s 106ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 105ms/step\n",
      "1/1 [==============================] - 0s 104ms/step\n",
      "1/1 [==============================] - 0s 104ms/step\n",
      "1/1 [==============================] - 0s 102ms/step\n",
      "1/1 [==============================] - 0s 104ms/step\n",
      "1/1 [==============================] - 0s 105ms/step\n",
      "1/1 [==============================] - 0s 119ms/step\n",
      "1/1 [==============================] - 0s 120ms/step\n",
      "1/1 [==============================] - 0s 98ms/step\n",
      "1/1 [==============================] - 0s 104ms/step\n",
      "1/1 [==============================] - 0s 101ms/step\n",
      "1/1 [==============================] - 0s 105ms/step\n",
      "1/1 [==============================] - 0s 102ms/step\n",
      "1/1 [==============================] - 0s 105ms/step\n",
      "1/1 [==============================] - 0s 105ms/step\n",
      "1/1 [==============================] - 0s 103ms/step\n",
      "1/1 [==============================] - 0s 105ms/step\n",
      "1/1 [==============================] - 0s 122ms/step\n",
      "1/1 [==============================] - 0s 104ms/step\n",
      "1/1 [==============================] - 0s 103ms/step\n",
      "1/1 [==============================] - 0s 105ms/step\n",
      "1/1 [==============================] - 0s 105ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 106ms/step\n",
      "1/1 [==============================] - 0s 105ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 105ms/step\n",
      "1/1 [==============================] - 0s 106ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 104ms/step\n",
      "1/1 [==============================] - 0s 106ms/step\n",
      "1/1 [==============================] - 0s 109ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 105ms/step\n",
      "1/1 [==============================] - 0s 122ms/step\n",
      "1/1 [==============================] - 0s 123ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 109ms/step\n",
      "1/1 [==============================] - 0s 109ms/step\n",
      "1/1 [==============================] - 0s 106ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 114ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 109ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 124ms/step\n",
      "1/1 [==============================] - 0s 106ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 106ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 109ms/step\n",
      "1/1 [==============================] - 0s 109ms/step\n",
      "1/1 [==============================] - 0s 109ms/step\n",
      "1/1 [==============================] - 0s 134ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 104ms/step\n",
      "1/1 [==============================] - 0s 109ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 103ms/step\n",
      "1/1 [==============================] - 0s 122ms/step\n",
      "1/1 [==============================] - 0s 106ms/step\n",
      "1/1 [==============================] - 0s 104ms/step\n",
      "1/1 [==============================] - 0s 104ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 105ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 106ms/step\n",
      "1/1 [==============================] - 0s 109ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 109ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 125ms/step\n",
      "1/1 [==============================] - 0s 124ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 109ms/step\n",
      "1/1 [==============================] - 0s 109ms/step\n",
      "1/1 [==============================] - 0s 106ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 104ms/step\n",
      "1/1 [==============================] - 0s 109ms/step\n",
      "1/1 [==============================] - 0s 109ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 110ms/step\n",
      "1/1 [==============================] - 0s 107ms/step\n",
      "1/1 [==============================] - 0s 108ms/step\n",
      "1/1 [==============================] - 0s 121ms/step\n",
      "Test Accuracy = 0.228310502283105\n",
      "CPU times: user 45.4 s, sys: 21.1 s, total: 1min 6s\n",
      "Wall time: 48.8 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "from keras.applications.vgg16 import preprocess_input\n",
    "\n",
    "correct_preds = 0\n",
    "total = len(nparray_labels[\"test\"].keys())\n",
    "for file_name in nparray_labels[\"test\"].keys():\n",
    "\tframe = np.load(file_name)\n",
    "\tframe = frame/127.5\n",
    "\tframe -= 1.\n",
    "\tprediction = np.argmax(convlstm_model.predict(np.array([frame])))\n",
    "\tactual = nparray_labels[\"test\"][file_name]\n",
    "\tif prediction == actual:\n",
    "\t\tcorrect_preds += 1\n",
    "\t# print(f'Prediction = {CLASSES_LIST[np.argmax(pred)]}')\n",
    "\t# print(f'Actual = {CLASSES_LIST[nparray_labels[\"test\"]]}')\n",
    "\n",
    "test_accuracy = correct_preds/total\n",
    "print(f'Test Accuracy = {test_accuracy}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python",
   "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.10"
  },
  "vscode": {
   "interpreter": {
    "hash": "7b16c9da95f04883170e058a5ab5debfb744b1406582038da61280139aa5eca4"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}