hindi-digit-recognition.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/anurags/miniforge3/envs/tensorflow_exp/lib/python3.9/site-packages/scipy/__init__.py:146: UserWarning: A NumPy version >=1.16.5 and <1.23.0 is required for this version of SciPy (detected version 1.23.3\n",
      "  warnings.warn(f\"A NumPy version >={np_minversion} and <{np_maxversion}\"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensor Flow Version: 2.8.0\n",
      "Keras Version: 2.7.0\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import pickle as pkl\n",
    "\n",
    "# import numpy as np\n",
    "# import pandas as pd\n",
    "import tensorflow as tf\n",
    "import keras\n",
    "from keras.preprocessing.image import image_dataset_from_directory\n",
    "from keras import layers\n",
    "from matplotlib import pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "print(f\"Tensor Flow Version: {tf.__version__}\")\n",
    "print(f\"Keras Version: {keras.__version__}\")\n",
    "# print(f\"Pandas {pd.__version__}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Downloading the Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "./data/DevanagariHandwrittenCharacterDataset\n"
     ]
    }
   ],
   "source": [
    "DATA_FOLDER = \"./data\"\n",
    "\n",
    "hindi_handwritten_dataset_zip_url = \"https://archive.ics.uci.edu/ml/machine-learning-databases/00389/DevanagariHandwrittenCharacterDataset.zip\"\n",
    "zip_file_name = hindi_handwritten_dataset_zip_url.rsplit('/', 1)[1]\n",
    "\n",
    "TRAIN_FOLDER_NAME = \"Train\"\n",
    "TEST_FOLDER_NAME = \"Test\"\n",
    "DEVANAGARI_ZIP_PATH = os.path.join(DATA_FOLDER, zip_file_name)\n",
    "DEVANAGARI_DATA_FOLDER = os.path.join(os.path.join(DATA_FOLDER, zip_file_name.rsplit(\".\")[0]))\n",
    "print(DEVANAGARI_DATA_FOLDER)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Zip file already present\n",
      "Files already present on disk\n"
     ]
    }
   ],
   "source": [
    "# Download the dataset and de-compress\n",
    "import requests\n",
    "import zipfile\n",
    "\n",
    "if not os.path.exists(DEVANAGARI_ZIP_PATH):\n",
    "    req = requests.get(hindi_handwritten_dataset_zip_url, allow_redirects=True)\n",
    "    # Writing the file to the local file system\n",
    "    with open(DEVANAGARI_ZIP_PATH, 'wb') as output_file:\n",
    "        output_file.write(req.content)\n",
    "    print(\"Downloaded zip file\")\n",
    "else:\n",
    "    print(\"Zip file already present\")\n",
    "\n",
    "if not os.path.exists(DEVANAGARI_DATA_FOLDER):\n",
    "    with zipfile.ZipFile(DEVANAGARI_ZIP_PATH, 'r') as zip_ref:\n",
    "        zip_ref.extractall(DATA_FOLDER)\n",
    "    print(\"Extracted zip file\")\n",
    "else:\n",
    "    print(\"Files already present on disk\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Removing classes we don't want"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "all_label_names = [\n",
    "    'character_10_yna', 'character_11_taamatar', 'character_12_thaa', 'character_13_daa', 'character_14_dhaa',\n",
    "    'character_15_adna', 'character_16_tabala', 'character_17_tha', 'character_18_da', 'character_19_dha',\n",
    "    'character_1_ka', 'character_20_na', 'character_21_pa', 'character_22_pha', 'character_23_ba', 'character_24_bha',\n",
    "    'character_25_ma', 'character_26_yaw', 'character_27_ra', 'character_28_la', 'character_29_waw', 'character_2_kha',\n",
    "    'character_30_motosaw', 'character_31_petchiryakha', 'character_32_patalosaw', 'character_33_ha',\n",
    "    'character_34_chhya', 'character_35_tra', 'character_36_gya', 'character_3_ga', 'character_4_gha',\n",
    "    'character_5_kna', 'character_6_cha', 'character_7_chha', 'character_8_ja', 'character_9_jha', 'digit_0', 'digit_1',\n",
    "    'digit_2', 'digit_3', 'digit_4', 'digit_5', 'digit_6', 'digit_7', 'digit_8', 'digit_9'\n",
    "]\n",
    "labels_to_keep = [\n",
    "    \"digit_0\", \"digit_1\", \"digit_2\", \"digit_3\", \"digit_4\", \"digit_5\", \"digit_6\", \"digit_7\", \"digit_8\", \"digit_9\"\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import shutil\n",
    "import glob\n",
    "\n",
    "# We will only keep the Hindi digits in training data.\n",
    "folders = glob.glob(os.path.join(DEVANAGARI_DATA_FOLDER, TRAIN_FOLDER_NAME, \"*\"))\n",
    "# print(folders)\n",
    "# print(folders[0].rsplit(\"/\")[-1])\n",
    "for f in folders:\n",
    "    if f.rsplit(\"/\")[-1] not in labels_to_keep:\n",
    "        try:\n",
    "            shutil.rmtree(f)\n",
    "        except OSError as e:\n",
    "            print(\"Error: %s : %s\" % (f, e.strerror))\n",
    "\n",
    "# Doing the same to test data.\n",
    "folders = glob.glob(os.path.join(DEVANAGARI_DATA_FOLDER, TEST_FOLDER_NAME, \"*\"))\n",
    "# print(folders)\n",
    "# print(folders[0].rsplit(\"/\")[-1])\n",
    "for f in folders:\n",
    "    if f.rsplit(\"/\")[-1] not in labels_to_keep:\n",
    "        try:\n",
    "            shutil.rmtree(f)\n",
    "        except OSError as e:\n",
    "            print(\"Error: %s : %s\" % (f, e.strerror))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Dataset and Model Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "RANDOM_SEED = 42\n",
    "\n",
    "# Data parameters\n",
    "IMG_HEIGHT = 32\n",
    "IMG_WIDTH = 32\n",
    "VALIDATION_SPLIT = 0.1\n",
    "\n",
    "# Model parameters\n",
    "BATCH_SIZE = 32\n",
    "KERNEL_SIZE = (3, 3)\n",
    "MAX_POOLING_SIZE = (2, 2)\n",
    "DROPOUT = 0.5\n",
    "\n",
    "num_classes = len(labels_to_keep)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gathering training dataset...\n",
      "Found 17000 files belonging to 10 classes.\n",
      "Using 15300 files for training.\n",
      "Metal device set to: Apple M1\n",
      "Gathering validation dataset...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-03-06 23:13:34.336330: I tensorflow/core/common_runtime/pluggable_device/pluggable_device_factory.cc:305] Could not identify NUMA node of platform GPU ID 0, defaulting to 0. Your kernel may not have been built with NUMA support.\n",
      "2022-03-06 23:13:34.336429: I tensorflow/core/common_runtime/pluggable_device/pluggable_device_factory.cc:271] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 0 MB memory) -> physical PluggableDevice (device: 0, name: METAL, pci bus id: <undefined>)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 17000 files belonging to 10 classes.\n",
      "Using 1700 files for validation.\n",
      "Gathering test dataset...\n",
      "Found 3000 files belonging to 10 classes.\n"
     ]
    }
   ],
   "source": [
    "classes = labels_to_keep\n",
    "classes_to_output_class_names = {\n",
    "    \"digit_0\": \"0\", \"digit_1\": \"1\", \"digit_2\": \"2\", \"digit_3\": \"3\", \"digit_4\": \"4\", \"digit_5\": \"5\", \"digit_6\": \"6\",\n",
    "    \"digit_7\": \"7\", \"digit_8\": \"8\", \"digit_9\": \"9\"\n",
    "}\n",
    "# output_classes = [\n",
    "#     \"ka\", \"kha\", \"ga\", \"gha\", \"kna\", \"cha\", \"chha\", \"ja\", \"jha\", \"yna\", \"t`a\", \"t`ha\", \"d`a\", \"d`ha\", \"adna\", \"ta\",\n",
    "#     \"tha\", \"da\", \"dha\", \"na\", \"pa\", \"pha\", \"ba\", \"bha\", \"ma\", \"yaw\", \"ra\", \"la\", \"waw\", \"sha\", \"shat\", \"sa\", \"ha\",\n",
    "#     \"aksha\", \"tra\", \"gya\", \"0\", \"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\"\n",
    "# ]\n",
    "\n",
    "print(\"Gathering training dataset...\")\n",
    "train_dataset = image_dataset_from_directory(\n",
    "    os.path.join(DEVANAGARI_DATA_FOLDER, TRAIN_FOLDER_NAME),\n",
    "    labels=\"inferred\",\n",
    "    label_mode=\"int\",\n",
    "    class_names=classes,\n",
    "    color_mode=\"grayscale\",\n",
    "    batch_size=BATCH_SIZE,\n",
    "    image_size=(IMG_HEIGHT, IMG_WIDTH),\n",
    "    shuffle=True,\n",
    "    seed=RANDOM_SEED,\n",
    "    validation_split=VALIDATION_SPLIT,\n",
    "    subset=\"training\",\n",
    "    interpolation=\"bilinear\",\n",
    "    follow_links=False,\n",
    "    crop_to_aspect_ratio=False,\n",
    ")\n",
    "\n",
    "print(\"Gathering validation dataset...\")\n",
    "val_dataset = image_dataset_from_directory(\n",
    "    os.path.join(DEVANAGARI_DATA_FOLDER, TRAIN_FOLDER_NAME),\n",
    "    labels=\"inferred\",\n",
    "    label_mode=\"int\",\n",
    "    class_names=classes,\n",
    "    color_mode=\"grayscale\",\n",
    "    batch_size=BATCH_SIZE,\n",
    "    image_size=(IMG_HEIGHT, IMG_WIDTH),\n",
    "    shuffle=True,\n",
    "    seed=RANDOM_SEED,\n",
    "    validation_split=VALIDATION_SPLIT,\n",
    "    subset=\"validation\",\n",
    "    interpolation=\"bilinear\",\n",
    "    follow_links=False,\n",
    "    crop_to_aspect_ratio=False,\n",
    ")\n",
    "\n",
    "print(\"Gathering test dataset...\")\n",
    "test_dataset = image_dataset_from_directory(\n",
    "    os.path.join(DEVANAGARI_DATA_FOLDER, TEST_FOLDER_NAME),\n",
    "    labels=\"inferred\",\n",
    "    label_mode=\"int\",\n",
    "    class_names=classes,\n",
    "    color_mode=\"grayscale\",\n",
    "    batch_size=BATCH_SIZE,\n",
    "    image_size=(IMG_HEIGHT, IMG_WIDTH),\n",
    "    shuffle=True,\n",
    "    seed=RANDOM_SEED,\n",
    "    validation_split=None,  # None, so that we get all the data.\n",
    "    subset=None,\n",
    "    interpolation=\"bilinear\",\n",
    "    follow_links=False,\n",
    "    crop_to_aspect_ratio=False,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(TensorSpec(shape=(None, 32, 32, 1), dtype=tf.float32, name=None),\n",
       " TensorSpec(shape=(None,), dtype=tf.int32, name=None))"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_dataset.element_spec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0: 'digit_0', 1: 'digit_1', 2: 'digit_2', 3: 'digit_3', 4: 'digit_4', 5: 'digit_5', 6: 'digit_6', 7: 'digit_7', 8: 'digit_8', 9: 'digit_9'}\n"
     ]
    }
   ],
   "source": [
    "class_names_to_labels = dict([(cls_name, lbl) for cls_name, lbl in zip(classes, list(range(len(classes))))])\n",
    "# print(class_names_to_labels)\n",
    "labels_to_class_names = dict([(v, k) for k, v in class_names_to_labels.items()])\n",
    "print(labels_to_class_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Look at the data\n",
    "Let us take a look at the data after it has been stored as a tensorflow tf.Data.Dataset object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(32, 32, 1)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-03-06 23:13:34.901606: W tensorflow/core/platform/profile_utils/cpu_utils.cc:128] Failed to get CPU frequency: 0 Hz\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x576 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Take a look at the input data\n",
    "rows = 2\n",
    "columns = 3\n",
    "fig = plt.figure(figsize=(10, 8))\n",
    "j = 1\n",
    "for images, labels in train_dataset.take(1):\n",
    "    print(images[0].shape)\n",
    "    for i, l in zip(images[:6], labels[:6]):\n",
    "        fig.add_subplot(rows, columns, j)\n",
    "        plt.imshow(tf.squeeze(i), cmap='gray', vmin=0, vmax=255)\n",
    "        plt.title(labels_to_class_names[int(l)])\n",
    "        j += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Data Augmentation and Normalisation\n",
    "#### Normalisation\n",
    "\n",
    "The values of pixels in the images range from `[0, 255]`.\n",
    "\n",
    "We should normalize the values to be in the `[0, 1]` range.\n",
    "\n",
    "The purpose of Normalisation is to make values measured on different scales to be all \"squished\" or \"expanded\" to a common scale/range such as `[0, 1]`.\n",
    "This ensures that each variable in the data is given an equal importance and no variable influences the model parameters more than any other purely because it's values are larger.\n",
    "\n",
    "We will perform the normalization using <a href=\"https://www.tensorflow.org/api_docs/python/tf/keras/layers/Rescaling\"><code>tf.keras.layers.Rescaling</code></a>.\n",
    "\n",
    "#### Augmentation\n",
    "Augmenting the data allows us to ensure that the model doesn't just learn something that's common for the entire class, but has no meaning when it comes to classification.\n",
    "\n",
    "For example, consider a dataset with blue cars and red cars.\n",
    "\n",
    "If all the blue cars are facing to the right and all red cars are facing left, then the model will end up being influenced by the orientation of the car in the image, thus producing incorrect predications when you ask the model to predict, say, the color of a blue car facing to the left.\n",
    "\n",
    "By performing augmentations such as Flipping, Rotations, Zooming, Shearing, Translations etc, we prevent the model from learning/memorizing features which are irrelevant."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Scale images to the [0, 1] range\n",
    "normalization_layer = layers.Rescaling(1. / 255)\n",
    "# Data Augmentations\n",
    "with tf.device('/CPU:0'):\n",
    "    data_augmentation_layers = keras.Sequential(\n",
    "        [\n",
    "            # layers.RandomFlip(\"horizontal\",\n",
    "            #                   input_shape=(IMG_HEIGHT,\n",
    "            #                                IMG_WIDTH,\n",
    "            #                                1)),\n",
    "            # layers.RandomRotation(0.1),\n",
    "            layers.RandomZoom(0.05),\n",
    "            layers.RandomTranslation(0.05, 0.05),\n",
    "        ]\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Prefetch and Caching\n",
    "Learn about tf.data.Dataset Prefetching here: <https://www.tensorflow.org/api_docs/python/tf/data/Dataset#prefetch>\n",
    "Learn about tf.data.Dataset Caching here: <https://www.tensorflow.org/api_docs/python/tf/data/Dataset#cache>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# prefetching and caching data to improve performance.\n",
    "AUTOTUNE = tf.data.AUTOTUNE\n",
    "\n",
    "train_ds = train_dataset.cache().shuffle(1000).prefetch(buffer_size=AUTOTUNE)\n",
    "val_ds = val_dataset.cache().prefetch(buffer_size=AUTOTUNE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Checking Data Augmentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x864 with 12 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "rows = 3\n",
    "columns = 4\n",
    "for images, _ in train_dataset.take(1):\n",
    "    plt.imshow(tf.squeeze(images[0]), cmap='gray', vmin=0, vmax=255)\n",
    "    fig = plt.figure(figsize=(10, 12))\n",
    "    for i in range(12):\n",
    "        with tf.device('/CPU:0'):\n",
    "            augmented_images = data_augmentation_layers(images)\n",
    "        fig.add_subplot(rows, columns, i + 1)\n",
    "        # plt.imshow(augmented_images[0].numpy().astype(\"uint8\"))\n",
    "        plt.imshow(tf.squeeze(augmented_images[0]), cmap='gray', vmin=0, vmax=255)\n",
    "        plt.axis(\"off\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Creating the Model\n",
    "\n",
    "First, we'll add the `data_augmentation_layers` and the `normalization_layer`, following which we'll create a convolutional neural network.\n",
    "\n",
    "Learn more about CNNs here: <https://machinelearningmastery.com/convolutional-layers-for-deep-learning-neural-networks/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "model = keras.Sequential(\n",
    "    [\n",
    "        data_augmentation_layers,\n",
    "        normalization_layer,\n",
    "        layers.Conv2D(32, kernel_size=KERNEL_SIZE, activation=\"relu\"),\n",
    "        layers.MaxPooling2D(pool_size=MAX_POOLING_SIZE),\n",
    "        layers.Conv2D(64, kernel_size=KERNEL_SIZE, activation=\"relu\"),\n",
    "        layers.MaxPooling2D(pool_size=MAX_POOLING_SIZE),\n",
    "        layers.Dropout(DROPOUT),\n",
    "        layers.Flatten(),\n",
    "        layers.Dense(128, activation='relu'),\n",
    "        layers.Dense(num_classes, activation=\"softmax\"),\n",
    "    ]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Compiling and Building Model\n",
    "Note that we are using Categorical Crossentropy as the loss function, and this is well suited for categorical output data.\n",
    "Read more here: <https://en.wikipedia.org/wiki/Cross_entropy#Cross-entropy_loss_function_and_logistic_regression>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " sequential (Sequential)     (32, 32, 32, 1)           0         \n",
      "                                                                 \n",
      " rescaling (Rescaling)       (32, 32, 32, 1)           0         \n",
      "                                                                 \n",
      " conv2d (Conv2D)             (32, 30, 30, 32)          320       \n",
      "                                                                 \n",
      " max_pooling2d (MaxPooling2D  (32, 15, 15, 32)         0         \n",
      " )                                                               \n",
      "                                                                 \n",
      " conv2d_1 (Conv2D)           (32, 13, 13, 64)          18496     \n",
      "                                                                 \n",
      " max_pooling2d_1 (MaxPooling  (32, 6, 6, 64)           0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " dropout (Dropout)           (32, 6, 6, 64)            0         \n",
      "                                                                 \n",
      " flatten (Flatten)           (32, 2304)                0         \n",
      "                                                                 \n",
      " dense (Dense)               (32, 128)                 295040    \n",
      "                                                                 \n",
      " dense_1 (Dense)             (32, 10)                  1290      \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 315,146\n",
      "Trainable params: 315,146\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.compile(optimizer='adam',\n",
    "              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),\n",
    "              metrics=['accuracy'])\n",
    "model.build(input_shape=(BATCH_SIZE, IMG_HEIGHT, IMG_WIDTH, 1))\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/15\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/anurags/miniforge3/envs/tensorflow_exp/lib/python3.9/site-packages/tensorflow/python/util/dispatch.py:1082: UserWarning: \"`sparse_categorical_crossentropy` received `from_logits=True`, but the `output` argument was produced by a sigmoid or softmax activation and thus does not represent logits. Was this intended?\"\n",
      "  return dispatch_target(*args, **kwargs)\n",
      "2022-03-06 23:13:36.016510: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "479/479 [==============================] - ETA: 0s - loss: 0.3515 - accuracy: 0.8866"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-03-06 23:13:44.063930: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "479/479 [==============================] - 9s 17ms/step - loss: 0.3515 - accuracy: 0.8866 - val_loss: 0.0545 - val_accuracy: 0.9847\n",
      "Epoch 2/15\n",
      "479/479 [==============================] - 8s 17ms/step - loss: 0.0971 - accuracy: 0.9701 - val_loss: 0.0392 - val_accuracy: 0.9865\n",
      "Epoch 3/15\n",
      "479/479 [==============================] - 8s 17ms/step - loss: 0.0642 - accuracy: 0.9798 - val_loss: 0.0383 - val_accuracy: 0.9871\n",
      "Epoch 4/15\n",
      "479/479 [==============================] - 8s 17ms/step - loss: 0.0508 - accuracy: 0.9849 - val_loss: 0.0221 - val_accuracy: 0.9924\n",
      "Epoch 5/15\n",
      "479/479 [==============================] - 8s 18ms/step - loss: 0.0368 - accuracy: 0.9880 - val_loss: 0.0218 - val_accuracy: 0.9935\n",
      "Epoch 6/15\n",
      "479/479 [==============================] - 8s 18ms/step - loss: 0.0336 - accuracy: 0.9891 - val_loss: 0.0262 - val_accuracy: 0.9900\n",
      "Epoch 7/15\n",
      "479/479 [==============================] - 8s 17ms/step - loss: 0.0278 - accuracy: 0.9911 - val_loss: 0.0211 - val_accuracy: 0.9924\n",
      "Epoch 8/15\n",
      "479/479 [==============================] - 8s 17ms/step - loss: 0.0255 - accuracy: 0.9915 - val_loss: 0.0221 - val_accuracy: 0.9935\n",
      "Epoch 9/15\n",
      "479/479 [==============================] - 8s 17ms/step - loss: 0.0215 - accuracy: 0.9931 - val_loss: 0.0116 - val_accuracy: 0.9947\n",
      "Epoch 10/15\n",
      "479/479 [==============================] - 8s 17ms/step - loss: 0.0211 - accuracy: 0.9942 - val_loss: 0.0099 - val_accuracy: 0.9971\n",
      "Epoch 11/15\n",
      "479/479 [==============================] - 8s 17ms/step - loss: 0.0144 - accuracy: 0.9954 - val_loss: 0.0138 - val_accuracy: 0.9947\n",
      "Epoch 12/15\n",
      "479/479 [==============================] - 8s 17ms/step - loss: 0.0131 - accuracy: 0.9964 - val_loss: 0.0132 - val_accuracy: 0.9947\n",
      "Epoch 13/15\n",
      "479/479 [==============================] - 8s 17ms/step - loss: 0.0151 - accuracy: 0.9956 - val_loss: 0.0209 - val_accuracy: 0.9912\n",
      "Epoch 14/15\n",
      "479/479 [==============================] - 8s 17ms/step - loss: 0.0174 - accuracy: 0.9939 - val_loss: 0.0165 - val_accuracy: 0.9953\n",
      "Epoch 15/15\n",
      "479/479 [==============================] - 8s 17ms/step - loss: 0.0119 - accuracy: 0.9963 - val_loss: 0.0111 - val_accuracy: 0.9965\n"
     ]
    }
   ],
   "source": [
    "epochs = 15\n",
    "history = model.fit(\n",
    "    train_dataset,\n",
    "    validation_data=val_dataset,\n",
    "    epochs=epochs\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Measuring Performance on Training and Test Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1080x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "acc = history.history['accuracy']\n",
    "val_acc = history.history['val_accuracy']\n",
    "\n",
    "loss = history.history['loss']\n",
    "val_loss = history.history['val_loss']\n",
    "\n",
    "epochs_range = range(1, epochs + 1)\n",
    "\n",
    "fig = plt.figure(figsize=(15, 5))\n",
    "fig.add_subplot(1, 2, 1)\n",
    "sns.lineplot(x=epochs_range, y=acc, legend='brief', label='Training Accuracy')\n",
    "sns.lineplot(x=epochs_range, y=val_acc, legend='brief', label='Validation Accuracy')\n",
    "\n",
    "fig.add_subplot(1, 2, 2)\n",
    "sns.lineplot(x=epochs_range, y=loss, legend='brief', label='Training Loss')\n",
    "sns.lineplot(x=epochs_range, y=val_loss, legend='brief', label='Validation Loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Metrics\n",
    "\n",
    "| Data       | Accuracy | Loss   |\n",
    "|:-----------|:--------:|-------:|\n",
    "| Training   | 99.52%   | 0.0139 |\n",
    "| Validation | 99.65%   | 0.0107 |\n",
    "\n",
    "<!-- Training Accuracy: 99.52%\n",
    "\n",
    "Validation Accuracy: 99.65%\n",
    "\n",
    "Training Loss: 0.0139\n",
    "\n",
    "Validation Loss: 0.0107 -->\n",
    "\n",
    "\n",
    "We can see that the model's accuracy and validation accuracy quickly went up during and after the first epoch and then it saturated around epoch #10. \n",
    "\n",
    "Training and validation loss also fell dramatically after the second epoch, and reached a saturation around epoch #11."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluate\n",
      "94/94 [==============================] - 1s 6ms/step - loss: 0.0179 - accuracy: 0.9960\n"
     ]
    }
   ],
   "source": [
    "print(\"Evaluate\")\n",
    "result = model.evaluate(test_dataset)\n",
    "result = dict(zip(model.metrics_names, result))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Test Metrics\n",
    "\n",
    "| Data | Accuracy |   Loss |\n",
    "|:-----|:--------:|-------:|\n",
    "| Test |  99.56%  | 0.0189 |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "#### Overall this is a great result, and it shows that the model has generalized properly and has low variance, while having high bias."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Saving the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "MODEL_FOLDER = \"./models\"\n",
    "HINDI_MNIST_FOLDER = \"hindi_mnist\"\n",
    "MODEL_SAVE_FOLDER = os.path.join(MODEL_FOLDER, HINDI_MNIST_FOLDER)\n",
    "TF_MODEL_SAVE_FOLDER = os.path.join(MODEL_FOLDER, HINDI_MNIST_FOLDER, \"tf_serving\")\n",
    "MODEL_SAVE_PATH = os.path.join(MODEL_FOLDER, HINDI_MNIST_FOLDER, \"model.h5\")\n",
    "# pickle files\n",
    "CLASSES_PKL_FILE = \"classes.pickle\"\n",
    "CLASSES_PKL_PATH = os.path.join(MODEL_SAVE_FOLDER, CLASSES_PKL_FILE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "model.save(\n",
    "    MODEL_SAVE_PATH, overwrite=True, include_optimizer=True, save_format=None,\n",
    "    signatures=None, options=None, save_traces=True\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-03-06 23:15:40.984722: W tensorflow/python/util/util.cc:368] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: ./models/hindi_mnist/tf_serving/assets\n"
     ]
    }
   ],
   "source": [
    "model.save(\n",
    "    TF_MODEL_SAVE_FOLDER, overwrite=True, include_optimizer=True, save_format='tf'\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "with open(CLASSES_PKL_PATH, 'wb') as f:\n",
    "    pkl.dump(classes, f)\n",
    "    pkl.dump(labels_to_class_names, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Delete model and labels_to_class_names to check if we correctly saved the model by loading it from disk and re-evaluating on test data.\n",
    "del model\n",
    "del classes\n",
    "del labels_to_class_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import pickle as pkl\n",
    "from keras.models import load_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "model = load_model(MODEL_SAVE_PATH)\n",
    "\n",
    "with open(CLASSES_PKL_PATH, 'rb') as f:\n",
    "    classes = pkl.load(f)\n",
    "    labels_to_class_names = pkl.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluate\n",
      "20/94 [=====>........................] - ETA: 0s - loss: 4.6448e-04 - accuracy: 1.0000"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/anurags/miniforge3/envs/tensorflow_exp/lib/python3.9/site-packages/tensorflow/python/util/dispatch.py:1082: UserWarning: \"`sparse_categorical_crossentropy` received `from_logits=True`, but the `output` argument was produced by a sigmoid or softmax activation and thus does not represent logits. Was this intended?\"\n",
      "  return dispatch_target(*args, **kwargs)\n",
      "2022-03-06 23:15:41.637264: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "94/94 [==============================] - 1s 6ms/step - loss: 0.0179 - accuracy: 0.9960\n",
      "{'loss': 0.017931433394551277, 'accuracy': 0.9959999918937683}\n"
     ]
    }
   ],
   "source": [
    "print(\"Evaluate\")\n",
    "result = model.evaluate(test_dataset)\n",
    "result = dict(zip(model.metrics_names, result))\n",
    "print(result)"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "name": "conda-env-tensorflow_exp-py",
   "language": "python",
   "display_name": "Python [conda env:tensorflow_exp] *"
  },
  "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.9.7"
  },
  "vscode": {
   "interpreter": {
    "hash": "1a1ba92539025a9776faa821cedc9a98091bd051794ac2a35f86e7b5baaa1b51"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}