numa.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LeNet-5 on HODA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Silence TensorFlow\n",
    "We can control the verbosity of TF by setting the `TF_CPP_MIN_LOG_LEVEL` environment variable _before_ importing TensorFlow.\n",
    "\n",
    "This step is enitrely __optional__. But TensorFlow's useless log messages can get annoying..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import logging\n",
    "\n",
    "import keras\n",
    "from keras import layers, optimizers, utils, callbacks\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from numa.dataset import hoda\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set logging level to info (used in some parts of this project)\n",
    "logging.basicConfig(level=logging.INFO)\n",
    "\n",
    "# Learning rate for Gradient descent\n",
    "LEARNING_RATE = 0.01\n",
    "# Number of iterations for training model\n",
    "EPOCHS = 30\n",
    "# Number of samples utilized in one training iteration (Usually 128 or 256 is a good choice for GPU)\n",
    "BATCH_SIZE = 256\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing dataset\n",
    "This step may take a long time to complete. This is due to the fact that the HODA database is __not__ using format compatible with TF, therefore the dataset must be converted before getting fed into the model. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:root:Reading dataset /home/mehrzad/Code/numa/numa/dataset/hoda/Train.cdb\n",
      "INFO:root:Release date: 2005/8/4\n",
      "INFO:root:Records: 60000\n",
      "INFO:root:Reading dataset /home/mehrzad/Code/numa/numa/dataset/hoda/Test.cdb\n",
      "INFO:root:Release date: 2005/8/4\n",
      "INFO:root:Records: 20000\n"
     ]
    }
   ],
   "source": [
    "# 32x32 binary datasets\n",
    "(train_images, train_labels), (test_images,\n",
    "                               test_labels) = hoda.load_dataset(32)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preparing dataset\n",
    "We have to do some preparations on the dataset before feeding it to the model, more specifically we need to normalize the dataset images and convert labels to one-hot labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Normalize\n",
    "train_images = train_images.astype('float32') / 255.0\n",
    "test_images = test_images.astype('float32') / 255.0\n",
    "\n",
    "# One-hot labels\n",
    "train_labels = utils.to_categorical(train_labels)\n",
    "test_labels = utils.to_categorical(test_labels)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model\n",
    "Model configuration:\n",
    "  * Using Gradient descent as the optimizer\n",
    "  * Using 'Categorical crossentropy' as loss function\n",
    "    * Model weights are adjusted in a way to minimize the cross-entropy loss (the smaller the loss the better the model)\n",
    "  * Using 'accuracy' as metric (how often predictions match actual labels)\n",
    "  * Most of the time kernel size of 3x3 or 5x5 works the best"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " conv2d (Conv2D)             (None, 32, 32, 6)         60        \n",
      "                                                                 \n",
      " max_pooling2d (MaxPooling2D  (None, 16, 16, 6)        0         \n",
      " )                                                               \n",
      "                                                                 \n",
      " conv2d_1 (Conv2D)           (None, 14, 14, 16)        880       \n",
      "                                                                 \n",
      " max_pooling2d_1 (MaxPooling  (None, 7, 7, 16)         0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " flatten (Flatten)           (None, 784)               0         \n",
      "                                                                 \n",
      " dense (Dense)               (None, 120)               94200     \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 84)                10164     \n",
      "                                                                 \n",
      " dense_2 (Dense)             (None, 10)                850       \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 106,154\n",
      "Trainable params: 106,154\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "# Define model\n",
    "model = keras.Sequential([\n",
    "    layers.Conv2D(filters=6, kernel_size=(3, 3), activation='relu',\n",
    "                  padding='same', input_shape=(32, 32, 1)),  # C1\n",
    "    layers.MaxPooling2D(pool_size=(2, 2)),  # S2\n",
    "    layers.Conv2D(filters=16, kernel_size=(3, 3), activation='relu'),  # C3\n",
    "    layers.MaxPooling2D(pool_size=(2, 2)),  # S4\n",
    "    layers.Flatten(),\n",
    "    layers.Dense(120, activation='relu'),  # C5\n",
    "    layers.Dense(84, activation='relu'),  # F6\n",
    "    layers.Dense(10, activation='softmax'),  # Output\n",
    "])\n",
    "\n",
    "# Configure model\n",
    "model.compile(optimizer=optimizers.SGD(learning_rate=LEARNING_RATE),\n",
    "              loss='categorical_crossentropy', metrics=['accuracy'])\n",
    "\n",
    "# Print a summary of the model\n",
    "model.summary()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training model\n",
    "This is where the real fun begins! The model defined in the previous cell will get trained by the HODA dataset.\n",
    "\n",
    "This step will take a _long_ time. Go grab a cup of coffee. \n",
    "\n",
    "* How are we supposed to choose the value for `steps_per_epoch` and `validation_steps` fields?\n",
    "\n",
    "  Most of the time `(number of samples / batch size)` will have good results.\n",
    "\n",
    "  In our case `number of samples` is the first field of the dataset array shape.\n",
    "\n",
    "  (Dataset array shape: `(60000, 32, 32)` - that is 60000 images of size 32x32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/30\n",
      "234/234 [==============================] - 16s 20ms/step - loss: 1.5619 - accuracy: 0.5033 - val_loss: 0.5618 - val_accuracy: 0.8042\n",
      "Epoch 2/30\n",
      "234/234 [==============================] - 4s 17ms/step - loss: 0.2241 - accuracy: 0.9333 - val_loss: 0.3474 - val_accuracy: 0.8831\n",
      "Epoch 3/30\n",
      "234/234 [==============================] - 4s 18ms/step - loss: 0.1524 - accuracy: 0.9547 - val_loss: 0.2651 - val_accuracy: 0.9174\n",
      "Epoch 4/30\n",
      "234/234 [==============================] - 4s 17ms/step - loss: 0.1304 - accuracy: 0.9615 - val_loss: 0.2413 - val_accuracy: 0.9234\n",
      "Epoch 5/30\n",
      "234/234 [==============================] - 4s 17ms/step - loss: 0.1123 - accuracy: 0.9668 - val_loss: 0.2175 - val_accuracy: 0.9306\n",
      "Epoch 6/30\n",
      "234/234 [==============================] - 4s 18ms/step - loss: 0.1013 - accuracy: 0.9700 - val_loss: 0.1929 - val_accuracy: 0.9415\n",
      "Epoch 7/30\n",
      "234/234 [==============================] - 4s 18ms/step - loss: 0.0917 - accuracy: 0.9724 - val_loss: 0.1786 - val_accuracy: 0.9454\n",
      "Epoch 8/30\n",
      "234/234 [==============================] - 4s 18ms/step - loss: 0.0853 - accuracy: 0.9750 - val_loss: 0.1741 - val_accuracy: 0.9452\n",
      "Epoch 9/30\n",
      "234/234 [==============================] - 4s 18ms/step - loss: 0.0797 - accuracy: 0.9760 - val_loss: 0.1570 - val_accuracy: 0.9515\n",
      "Epoch 10/30\n",
      "234/234 [==============================] - 4s 18ms/step - loss: 0.0739 - accuracy: 0.9784 - val_loss: 0.1476 - val_accuracy: 0.9549\n",
      "Epoch 11/30\n",
      "234/234 [==============================] - 4s 17ms/step - loss: 0.0697 - accuracy: 0.9798 - val_loss: 0.1676 - val_accuracy: 0.9485\n",
      "Epoch 12/30\n",
      "234/234 [==============================] - 4s 17ms/step - loss: 0.0670 - accuracy: 0.9806 - val_loss: 0.1366 - val_accuracy: 0.9568\n",
      "Epoch 13/30\n",
      "234/234 [==============================] - 4s 18ms/step - loss: 0.0637 - accuracy: 0.9816 - val_loss: 0.1394 - val_accuracy: 0.9564\n",
      "Epoch 14/30\n",
      "234/234 [==============================] - 4s 18ms/step - loss: 0.0604 - accuracy: 0.9820 - val_loss: 0.1242 - val_accuracy: 0.9621\n",
      "Epoch 15/30\n",
      "234/234 [==============================] - 4s 18ms/step - loss: 0.0567 - accuracy: 0.9834 - val_loss: 0.1211 - val_accuracy: 0.9626\n",
      "Epoch 16/30\n",
      "234/234 [==============================] - 4s 17ms/step - loss: 0.0552 - accuracy: 0.9837 - val_loss: 0.1235 - val_accuracy: 0.9615\n",
      "Epoch 17/30\n",
      "234/234 [==============================] - 4s 17ms/step - loss: 0.0537 - accuracy: 0.9842 - val_loss: 0.1125 - val_accuracy: 0.9664\n",
      "Epoch 18/30\n",
      "234/234 [==============================] - 4s 18ms/step - loss: 0.0502 - accuracy: 0.9854 - val_loss: 0.1114 - val_accuracy: 0.9657\n",
      "Epoch 19/30\n",
      "234/234 [==============================] - 4s 17ms/step - loss: 0.0493 - accuracy: 0.9859 - val_loss: 0.1129 - val_accuracy: 0.9654\n",
      "Epoch 20/30\n",
      "234/234 [==============================] - 4s 17ms/step - loss: 0.0466 - accuracy: 0.9868 - val_loss: 0.1075 - val_accuracy: 0.9674\n",
      "Epoch 21/30\n",
      "234/234 [==============================] - 4s 17ms/step - loss: 0.0464 - accuracy: 0.9866 - val_loss: 0.1040 - val_accuracy: 0.9678\n",
      "Epoch 22/30\n",
      "234/234 [==============================] - 4s 17ms/step - loss: 0.0435 - accuracy: 0.9877 - val_loss: 0.1052 - val_accuracy: 0.9672\n",
      "Epoch 23/30\n",
      "234/234 [==============================] - 4s 18ms/step - loss: 0.0442 - accuracy: 0.9868 - val_loss: 0.1074 - val_accuracy: 0.9662\n",
      "Epoch 24/30\n",
      "234/234 [==============================] - 4s 17ms/step - loss: 0.0420 - accuracy: 0.9880 - val_loss: 0.1022 - val_accuracy: 0.9677\n",
      "Epoch 25/30\n",
      "234/234 [==============================] - 4s 17ms/step - loss: 0.0397 - accuracy: 0.9886 - val_loss: 0.0974 - val_accuracy: 0.9696\n",
      "Epoch 26/30\n",
      "234/234 [==============================] - 4s 17ms/step - loss: 0.0402 - accuracy: 0.9886 - val_loss: 0.0947 - val_accuracy: 0.9710\n",
      "Epoch 27/30\n",
      "234/234 [==============================] - 4s 18ms/step - loss: 0.0389 - accuracy: 0.9886 - val_loss: 0.0938 - val_accuracy: 0.9710\n",
      "Epoch 28/30\n",
      "234/234 [==============================] - 4s 17ms/step - loss: 0.0372 - accuracy: 0.9890 - val_loss: 0.0992 - val_accuracy: 0.9692\n",
      "Epoch 29/30\n",
      "234/234 [==============================] - 4s 17ms/step - loss: 0.0362 - accuracy: 0.9891 - val_loss: 0.0904 - val_accuracy: 0.9724\n",
      "Epoch 30/30\n",
      "234/234 [==============================] - 4s 18ms/step - loss: 0.0357 - accuracy: 0.9892 - val_loss: 0.0894 - val_accuracy: 0.9721\n"
     ]
    }
   ],
   "source": [
    "# Interrupt training if `val_loss` hasn't decreased in 10 epochs\n",
    "early_stop = callbacks.EarlyStopping(monitor='val_loss', patience=10)\n",
    "\n",
    "history = model.fit(train_images, train_labels,\n",
    "                    epochs=EPOCHS, batch_size=BATCH_SIZE,\n",
    "                    steps_per_epoch=train_images.shape[0] // BATCH_SIZE,\n",
    "                    validation_data=(test_images, test_labels),\n",
    "                    validation_steps=test_images.shape[0] // BATCH_SIZE,\n",
    "                    callbacks=[early_stop], verbose=1)  # type: ignore\n",
    "\n",
    "# For some weird reason VSCode gets hung up on the verbose=1 argument type, hence the '#type: ignore' comment\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluating model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "625/625 [==============================] - 6s 10ms/step - loss: 0.0893 - accuracy: 0.9722\n",
      "Model accuracy: 97.22%\n"
     ]
    }
   ],
   "source": [
    "_, accuracy = model.evaluate(\n",
    "    test_images, test_labels, verbose=1)  # type: ignore\n",
    "print(f\"Model accuracy: {accuracy * 100:.2f}%\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualization\n",
    "Let's see a fancy visualization of the model accuracy, shall we?\n",
    "\n",
    "The `history` object returned after training the model contains the metrics which we can access just like a `dict`.\n",
    "\n",
    "In our case, the history object contains the following metrics: `loss`, `accuracy`, `val_loss`, `val_accuracy`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(history.history['accuracy'])\n",
    "plt.plot(history.history['val_accuracy'])\n",
    "\n",
    "plt.title('Model accuracy')\n",
    "\n",
    "plt.ylabel('Accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.legend(['Training set', 'Testing set'], loc='lower right')\n",
    "\n",
    "plt.show()\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.6 ('tf')",
   "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.10.6"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "62689e9cca3bb6f299b2d50d7893a1b09a06bde1b76c5f7fb431e5c10031e57c"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}