handwriting_recognition.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "handwriting_recognition",
      "provenance": [],
      "collapsed_sections": [],
      "machine_shape": "hm",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/sayakpaul/Handwriting-Recognizer-in-Keras/blob/pr/handwriting_recognition.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dFpKqswLwUev"
      },
      "source": [
        "This example shows how the [Captcha OCR](https://keras.io/examples/vision/captcha_ocr/) example can be extended to the [IAM Dataset](https://fki.tic.heia-fr.ch/databases/iam-handwriting-database) that has variable length ground-truths. IAM Dataset is widely used across many OCR benchmarks so we hope this example serves as a good starting point. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m221vxO3w5SD"
      },
      "source": [
        "## Data collection"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lIYdn1woOS1n"
      },
      "source": [
        "!wget -q https://github.com/sayakpaul/Handwriting-Recognizer-in-Keras/releases/download/v1.0.0/IAM_Words.zip\n",
        "!unzip -qq IAM_Words.zip\n",
        "\n",
        "!mkdir data\n",
        "!mkdir data/words\n",
        "!tar -xf IAM_Words/words.tgz -C data/words\n",
        "!mv IAM_Words/words.txt data"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fYoHz7fOZrjs",
        "outputId": "53d17068-c16e-43ce-d50e-f170afb5fa4b"
      },
      "source": [
        "# Preview how the dataset is organized. Lines prepended by \"#\"\n",
        "# are just metadata information.\n",
        "!head -20 data/words.txt"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "#--- words.txt ---------------------------------------------------------------#\n",
            "#\n",
            "# iam database word information\n",
            "#\n",
            "# format: a01-000u-00-00 ok 154 1 408 768 27 51 AT A\n",
            "#\n",
            "#     a01-000u-00-00  -> word id for line 00 in form a01-000u\n",
            "#     ok              -> result of word segmentation\n",
            "#                            ok: word was correctly\n",
            "#                            er: segmentation of word can be bad\n",
            "#\n",
            "#     154             -> graylevel to binarize the line containing this word\n",
            "#     1               -> number of components for this word\n",
            "#     408 768 27 51   -> bounding box around this word in x,y,w,h format\n",
            "#     AT              -> the grammatical tag for this word, see the\n",
            "#                        file tagset.txt for an explanation\n",
            "#     A               -> the transcription for this word\n",
            "#\n",
            "a01-000u-00-00 ok 154 408 768 27 51 AT A\n",
            "a01-000u-00-01 ok 154 507 766 213 48 NN MOVE\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4_EH-9PSw9fL"
      },
      "source": [
        "## Imports"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QusChyhonqtV"
      },
      "source": [
        "from tensorflow import keras\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import tensorflow as tf\n",
        "import numpy as np\n",
        "import os\n",
        "\n",
        "np.random.seed(42)\n",
        "tf.random.set_seed(42)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Sn7AvDBSxApj"
      },
      "source": [
        "## Dataset splitting"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ADII_aQMZ-WV",
        "outputId": "852b1102-0ef3-4fc7-c84d-2bcf27051593"
      },
      "source": [
        "base_path = \"data\"\n",
        "words_list = []\n",
        "\n",
        "words = open(f\"{base_path}/words.txt\", \"r\").readlines()\n",
        "for line in words:\n",
        "    if line[0]=='#':\n",
        "        continue\n",
        "    if line.split(\" \")[1]!=\"err\": # We don't need to deal with errored entries.\n",
        "        words_list.append(line)\n",
        "\n",
        "len(words_list)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "96456"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jz_vCtkKaAfn"
      },
      "source": [
        "np.random.shuffle(words_list)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1P3-1fxXxEKq"
      },
      "source": [
        "We will split the dataset into 90:5:5 ratio (train:validation:test). "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kYTkga9iaO92",
        "outputId": "ca1e4723-ff61-45ac-d206-e0e067e4f6fc"
      },
      "source": [
        "split_idx = int(0.9 * len(words_list))\n",
        "train_samples = words_list[:split_idx]\n",
        "test_samples = words_list[split_idx:]\n",
        "\n",
        "val_split_idx = int(0.5 * len(test_samples))\n",
        "validation_samples = test_samples[:val_split_idx]\n",
        "test_samples = test_samples[val_split_idx:]\n",
        "\n",
        "assert len(words_list) == len(train_samples) + len(validation_samples) + len(test_samples)\n",
        "\n",
        "print(f\"Total training samples: {len(train_samples)}\")\n",
        "print(f\"Total validation samples: {len(validation_samples)}\")\n",
        "print(f\"Total test samples: {len(test_samples)}\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Total training samples: 86810\n",
            "Total validation samples: 4823\n",
            "Total test samples: 4823\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nEugXwqGxKp4"
      },
      "source": [
        "## Data input pipeline\n",
        "\n",
        "We start building our data input pipeline by first preparing the image paths."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Gf2baPejaQ5P"
      },
      "source": [
        "base_image_path = os.path.join(base_path, \"words\")\n",
        "\n",
        "\n",
        "def get_image_paths_and_labels(samples):\n",
        "    paths = []\n",
        "    corrected_samples = []\n",
        "    for (i, file_line) in enumerate(samples):\n",
        "        line_split = file_line.strip()\n",
        "        line_split = line_split.split(\" \")\n",
        "        \n",
        "        # Each line split will have this format for the corresponding image:\n",
        "        # part1/part1-part2/part1-part2-part3.png\n",
        "        image_name = line_split[0] \n",
        "        partI = image_name.split(\"-\")[0]\n",
        "        partII = image_name.split(\"-\")[1]\n",
        "        img_path =  os.path.join(base_image_path, partI, \n",
        "            partI + \"-\" + partII,\n",
        "            image_name + \".png\"\n",
        "        )\n",
        "        if os.path.getsize(img_path):\n",
        "            paths.append(img_path)\n",
        "            corrected_samples.append(file_line.split(\"\\n\")[0])\n",
        "    \n",
        "    return paths, corrected_samples\n",
        "\n",
        "\n",
        "train_img_paths, train_labels = get_image_paths_and_labels(train_samples)\n",
        "validation_img_paths, validation_labels = get_image_paths_and_labels(validation_samples)\n",
        "test_img_paths, test_labels = get_image_paths_and_labels(test_samples)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dSFcmFihxVHn"
      },
      "source": [
        "Then we segregate the ground-truth labels."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9ypTNYM8HCEe",
        "outputId": "17fc42a9-1a80-4f24-d945-219d3bead957"
      },
      "source": [
        "# Find maximum length and the size of the vocabulary in the training data.\n",
        "train_labels_cleaned = []\n",
        "characters = set()\n",
        "max_len = 0\n",
        "\n",
        "for label in train_labels:\n",
        "    label = label.split(\" \")[-1].strip()\n",
        "    for char in label:\n",
        "        characters.add(char)\n",
        "\n",
        "    max_len = max(max_len, len(label))\n",
        "    train_labels_cleaned.append(label)\n",
        "\n",
        "print(\"Maximum length: \", max_len)\n",
        "print(\"Vocab size: \", len(characters))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Maximum length:  21\n",
            "Vocab size:  78\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IorYpLQOIRD1",
        "outputId": "77fe592c-fab4-455f-d15d-6fdf25b14d7a"
      },
      "source": [
        "# Check some label samples.\n",
        "train_labels_cleaned[:10]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['sure',\n",
              " 'he',\n",
              " 'during',\n",
              " 'of',\n",
              " 'booty',\n",
              " 'gastronomy',\n",
              " 'boy',\n",
              " 'The',\n",
              " 'and',\n",
              " 'in']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aeM_rNREqXKq"
      },
      "source": [
        "def clean_labels(labels):\n",
        "    cleaned_labels = []\n",
        "    for label in labels:\n",
        "        label = label.split(\" \")[-1].strip()\n",
        "        cleaned_labels.append(label)\n",
        "    return cleaned_labels\n",
        "\n",
        "\n",
        "validation_labels_cleaned = clean_labels(validation_labels)\n",
        "test_labels_cleaned = clean_labels(test_labels)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bSxH-M_4xkxW"
      },
      "source": [
        "### Building the character vocabulary\n",
        "\n",
        "Keras provides different preprocessing layers to deal with different modalities of data. [Here](https://keras.io/guides/preprocessing_layers/) you can get a comprehensive introduction about all of them. Our example involves preprocessing labels at a character level. This means that if there are two labels namely \"cat\" and \"dog\" then our character vocabulary should be - (a, c, d, g, o, t) (without any special tokens). We will use the [`StringLookup`](https://keras.io/api/layers/preprocessing_layers/categorical/string_lookup/) layer for this purpose. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wdsMCcqDZDaZ"
      },
      "source": [
        "from tensorflow.keras.layers.experimental.preprocessing import StringLookup\n",
        "AUTOTUNE = tf.data.AUTOTUNE"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BB9X6yWHZDWc"
      },
      "source": [
        "# Mapping characters to integers.\n",
        "char_to_num = StringLookup(vocabulary=list(characters), mask_token=None)\n",
        "\n",
        "# Mapping integers back to original characters.\n",
        "num_to_char = StringLookup(\n",
        "    vocabulary=char_to_num.get_vocabulary(), mask_token=None, invert=True\n",
        ")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kYVdF_a7yWF6"
      },
      "source": [
        "### Resizing images without distortion\n",
        "\n",
        "Instead of square images, many OCR models work with rectangular images. This will become clearer in a moment when we will visualize a few samples from the dataset. While aspect-unaware resizing square images does not introduce a significant amount of distortion this is not the case for rectangular images. But resizing images to a uniform size is a requirement for mini-batching. So, we need to perform our resizing such that the following criteria are maintained:\n",
        "\n",
        "* Aspect ratio is preserved. \n",
        "* Content of the images is not disturbed. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0DHZSX8v2PXu"
      },
      "source": [
        "def distortion_free_resize(image, img_size):\n",
        "    w, h = img_size\n",
        "    image  = tf.image.resize(image, size=(h, w), preserve_aspect_ratio=True)\n",
        "\n",
        "    # Check tha amount of padding needed to be done.\n",
        "    pad_height = h - tf.shape(image)[0]\n",
        "    pad_width = w - tf.shape(image)[1]\n",
        "\n",
        "    # Only necessary if you want to do same amount of padding on both sides.\n",
        "    if pad_height % 2 != 0:\n",
        "        height = pad_height // 2\n",
        "        pad_height_top = height + 1\n",
        "        pad_height_bottom = height\n",
        "    else:\n",
        "        pad_height_top = pad_height_bottom = pad_height // 2\n",
        "    \n",
        "    if pad_width % 2 != 0:\n",
        "        width = pad_width // 2\n",
        "        pad_width_left = width + 1\n",
        "        pad_width_right = width\n",
        "    else:\n",
        "        pad_width_left = pad_width_right = pad_width // 2\n",
        "\n",
        "    image = tf.pad(\n",
        "        image,\n",
        "        paddings=[\n",
        "                  [pad_height_top, pad_height_bottom],\n",
        "                  [pad_width_left, pad_width_right],\n",
        "                  [0, 0]\n",
        "                ]\n",
        "        )\n",
        "\n",
        "    image = tf.transpose(image, perm=[1, 0, 2])\n",
        "    image = tf.image.flip_left_right(image)\n",
        "    return image"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lIFgmr3b4wQQ"
      },
      "source": [
        "If we just go with the plain resizing then the images would look like so:\n",
        "\n",
        "![](https://i.imgur.com/eqq3s4N.png)\n",
        "\n",
        "Notice how this resizing would have introduced unnecessary stretching."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qYWxftJG6hZj"
      },
      "source": [
        "### Putting the utilities together"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Kcvk89Pzi84p"
      },
      "source": [
        "batch_size = 64\n",
        "padding_token = 99\n",
        "image_width = 128\n",
        "image_height = 32\n",
        "\n",
        "\n",
        "def preprocess_image(image_path, img_size=(image_width, image_height)):\n",
        "    image = tf.io.read_file(image_path)\n",
        "    image = tf.image.decode_png(image, 1)\n",
        "    image = distortion_free_resize(image, img_size)\n",
        "    image = tf.cast(image, tf.float32) / 255.\n",
        "    return image\n",
        "\n",
        "\n",
        "def vectorize_label(label):\n",
        "    label = char_to_num(tf.strings.unicode_split(label, input_encoding=\"UTF-8\"))\n",
        "    length = tf.shape(label)[0]\n",
        "    pad_amount = max_len - length\n",
        "    label = tf.pad(label, paddings=[[0, pad_amount]], constant_values=padding_token)\n",
        "    return label\n",
        "\n",
        "\n",
        "def process_images_labels(image_path, label):\n",
        "    image = preprocess_image(image_path)\n",
        "    label = vectorize_label(label)\n",
        "    return {\"image\": image, \"label\": label}\n",
        "\n",
        "\n",
        "def prepare_dataset(image_paths, labels):\n",
        "    dataset = tf.data.Dataset.from_tensor_slices((image_paths, labels)).map(\n",
        "        process_images_labels, num_parallel_calls=AUTOTUNE\n",
        "    )\n",
        "    return dataset.batch(batch_size).cache().prefetch(AUTOTUNE)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NMxzpY1U6ktL"
      },
      "source": [
        "## Prepare `tf.data.Dataset` objects"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UHmpBaA-M_BS"
      },
      "source": [
        "train_ds = prepare_dataset(train_img_paths, train_labels_cleaned)\n",
        "validation_ds = prepare_dataset(validation_img_paths, validation_labels_cleaned)\n",
        "test_ds = prepare_dataset(test_img_paths, test_labels_cleaned)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zho_BLRl6nxh"
      },
      "source": [
        "## Visualize a few samples"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 433
        },
        "id": "A2d636S3PQmO",
        "outputId": "e61dd299-306c-43e0-ec71-bca0a34c3a50"
      },
      "source": [
        "for data in train_ds.take(1):\n",
        "    images, labels = data[\"image\"], data[\"label\"]\n",
        "\n",
        "    _, ax = plt.subplots(4, 4, figsize=(15, 8))\n",
        "\n",
        "    for i in range(16):\n",
        "        img = images[i]\n",
        "        img = tf.image.flip_left_right(img)\n",
        "        img = tf.transpose(img, perm=[1, 0, 2])\n",
        "        img = (img * 255.).numpy().clip(0, 255).astype(np.uint8)\n",
        "        img = img[:, :, 0]\n",
        "\n",
        "        # Gather indices where label!= 99.\n",
        "        label = labels[i]\n",
        "        indices = tf.gather(label, tf.where(tf.math.not_equal(label, padding_token)))\n",
        "        # Convert to string.\n",
        "        label = tf.strings.reduce_join(num_to_char(indices))\n",
        "        label = label.numpy().decode(\"utf-8\")\n",
        "\n",
        "        ax[i // 4, i % 4].imshow(img, cmap=\"gray\")\n",
        "        ax[i // 4, i % 4].set_title(label)\n",
        "        ax[i // 4, i % 4].axis(\"off\")\n",
        "\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1080x576 with 16 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3IV1354Y6qj8"
      },
      "source": [
        "We can notice that the original image is kept as intact as possible and has been accordingly padded. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0-6J6Bp160RL"
      },
      "source": [
        "## Model\n",
        "\n",
        "Our model will use the CTC loss as an endpoint layer. For a detailed understanding of the CTC loss, refer to [this post](https://distill.pub/2017/ctc/). "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QZRjUkjyWUXl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4f244630-60bb-4953-d532-91f8fe2ab212"
      },
      "source": [
        "class CTCLayer(keras.layers.Layer):\n",
        "    def __init__(self, name=None):\n",
        "        super().__init__(name=name)\n",
        "        self.loss_fn = keras.backend.ctc_batch_cost\n",
        "\n",
        "    def call(self, y_true, y_pred):\n",
        "        batch_len = tf.cast(tf.shape(y_true)[0], dtype=\"int64\")\n",
        "        input_length = tf.cast(tf.shape(y_pred)[1], dtype=\"int64\")\n",
        "        label_length = tf.cast(tf.shape(y_true)[1], dtype=\"int64\")\n",
        "\n",
        "        input_length = input_length * tf.ones(shape=(batch_len, 1), dtype=\"int64\")\n",
        "        label_length = label_length * tf.ones(shape=(batch_len, 1), dtype=\"int64\")\n",
        "        loss = self.loss_fn(y_true, y_pred, input_length, label_length)\n",
        "        self.add_loss(loss)\n",
        "\n",
        "        # At test time, just return the computed predictions.\n",
        "        return y_pred\n",
        "\n",
        "\n",
        "def build_model():\n",
        "    # Inputs to the model\n",
        "    input_img =  keras.Input(\n",
        "        shape=(image_width, image_height, 1), name=\"image\")\n",
        "    labels =  keras.layers.Input(name=\"label\", shape=(None,))\n",
        "\n",
        "    # First conv block.\n",
        "    x = keras.layers.Conv2D(\n",
        "        32,\n",
        "        (3, 3),\n",
        "        activation=\"relu\",\n",
        "        kernel_initializer=\"he_normal\",\n",
        "        padding=\"same\",\n",
        "        name=\"Conv1\",\n",
        "    )(input_img)\n",
        "    x =  keras.layers.MaxPooling2D((2, 2), name=\"pool1\")(x)\n",
        "\n",
        "    # Second conv block.\n",
        "    x =  keras.layers.Conv2D(\n",
        "        64,\n",
        "        (3, 3),\n",
        "        activation=\"relu\",\n",
        "        kernel_initializer=\"he_normal\",\n",
        "        padding=\"same\",\n",
        "        name=\"Conv2\",\n",
        "    )(x)\n",
        "    x =  keras.layers.MaxPooling2D((2, 2), name=\"pool2\")(x)\n",
        "\n",
        "    # We have used two max pool with pool size and strides 2.\n",
        "    # Hence, downsampled feature maps are 4x smaller. The number of\n",
        "    # filters in the last layer is 64. Reshape accordingly before\n",
        "    # passing the output to the RNN part of the model.\n",
        "    new_shape = ((image_width // 4), (image_height // 4) * 64)\n",
        "    x =  keras.layers.Reshape(target_shape=new_shape, name=\"reshape\")(x)\n",
        "    x =  keras.layers.Dense(64, activation=\"relu\", name=\"dense1\")(x)\n",
        "    x =  keras.layers.Dropout(0.2)(x)\n",
        "\n",
        "    # RNNs.\n",
        "    x =  keras.layers.Bidirectional(keras.layers.LSTM(128, return_sequences=True, dropout=0.25))(x)\n",
        "    x =  keras.layers.Bidirectional(keras.layers.LSTM(64, return_sequences=True, dropout=0.25))(x)\n",
        "\n",
        "    # Output layer (the tokenizer is char-level)\n",
        "    # +2 is to account for the two special tokens introduced by the CTC loss.\n",
        "    # The recommendation comes here: https://git.io/J0eXP.\n",
        "    x =  keras.layers.Dense(len(char_to_num.get_vocabulary()) + 2, activation=\"softmax\", name=\"dense2\")(x)\n",
        "    \n",
        "    # Add CTC layer for calculating CTC loss at each step.\n",
        "    output = CTCLayer(name=\"ctc_loss\")(labels, x)\n",
        "\n",
        "    # Define the model.\n",
        "    model =  keras.models.Model(\n",
        "        inputs=[input_img, labels], outputs=output, name=\"handwriting_recognizer\"\n",
        "    )\n",
        "    # Optimizer.\n",
        "    opt = keras.optimizers.Adam()\n",
        "    # Compile the model and return.\n",
        "    model.compile(optimizer=opt)\n",
        "    return model\n",
        "\n",
        "\n",
        "# Get the model.\n",
        "model = build_model()\n",
        "model.summary()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Model: \"handwriting_recognizer\"\n",
            "__________________________________________________________________________________________________\n",
            "Layer (type)                    Output Shape         Param #     Connected to                     \n",
            "==================================================================================================\n",
            "image (InputLayer)              [(None, 128, 32, 1)] 0                                            \n",
            "__________________________________________________________________________________________________\n",
            "Conv1 (Conv2D)                  (None, 128, 32, 32)  320         image[0][0]                      \n",
            "__________________________________________________________________________________________________\n",
            "pool1 (MaxPooling2D)            (None, 64, 16, 32)   0           Conv1[0][0]                      \n",
            "__________________________________________________________________________________________________\n",
            "Conv2 (Conv2D)                  (None, 64, 16, 64)   18496       pool1[0][0]                      \n",
            "__________________________________________________________________________________________________\n",
            "pool2 (MaxPooling2D)            (None, 32, 8, 64)    0           Conv2[0][0]                      \n",
            "__________________________________________________________________________________________________\n",
            "reshape (Reshape)               (None, 32, 512)      0           pool2[0][0]                      \n",
            "__________________________________________________________________________________________________\n",
            "dense1 (Dense)                  (None, 32, 64)       32832       reshape[0][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "dropout (Dropout)               (None, 32, 64)       0           dense1[0][0]                     \n",
            "__________________________________________________________________________________________________\n",
            "bidirectional (Bidirectional)   (None, 32, 256)      197632      dropout[0][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "bidirectional_1 (Bidirectional) (None, 32, 128)      164352      bidirectional[0][0]              \n",
            "__________________________________________________________________________________________________\n",
            "label (InputLayer)              [(None, None)]       0                                            \n",
            "__________________________________________________________________________________________________\n",
            "dense2 (Dense)                  (None, 32, 81)       10449       bidirectional_1[0][0]            \n",
            "__________________________________________________________________________________________________\n",
            "ctc_loss (CTCLayer)             (None, 32, 81)       0           label[0][0]                      \n",
            "                                                                 dense2[0][0]                     \n",
            "==================================================================================================\n",
            "Total params: 424,081\n",
            "Trainable params: 424,081\n",
            "Non-trainable params: 0\n",
            "__________________________________________________________________________________________________\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eA1JE2OO7G5M"
      },
      "source": [
        "## Training"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Xy8FdR6ttuB8",
        "outputId": "a3863237-c73e-4e09-d7cf-8c65b8eb17db"
      },
      "source": [
        "epochs = 10 # To get good results this should be at least 50.\n",
        "\n",
        "# Train the model\n",
        "model = build_model()\n",
        "history = model.fit(\n",
        "    train_ds,\n",
        "    validation_data=validation_ds,\n",
        "    epochs=epochs,\n",
        ")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/10\n",
            "1357/1357 [==============================] - 75s 51ms/step - loss: 13.6848 - val_loss: 12.1122\n",
            "Epoch 2/10\n",
            "1357/1357 [==============================] - 48s 36ms/step - loss: 11.1998 - val_loss: 10.2338\n",
            "Epoch 3/10\n",
            "1357/1357 [==============================] - 48s 35ms/step - loss: 9.6957 - val_loss: 8.9139\n",
            "Epoch 4/10\n",
            "1357/1357 [==============================] - 48s 35ms/step - loss: 8.4521 - val_loss: 7.4413\n",
            "Epoch 5/10\n",
            "1357/1357 [==============================] - 48s 35ms/step - loss: 7.1833 - val_loss: 6.0115\n",
            "Epoch 6/10\n",
            "1357/1357 [==============================] - 48s 35ms/step - loss: 6.0520 - val_loss: 4.9040\n",
            "Epoch 7/10\n",
            "1357/1357 [==============================] - 48s 35ms/step - loss: 5.2263 - val_loss: 4.2085\n",
            "Epoch 8/10\n",
            "1357/1357 [==============================] - 48s 35ms/step - loss: 4.6386 - val_loss: 3.7770\n",
            "Epoch 9/10\n",
            "1357/1357 [==============================] - 48s 35ms/step - loss: 4.2225 - val_loss: 3.3560\n",
            "Epoch 10/10\n",
            "1357/1357 [==============================] - 48s 35ms/step - loss: 3.8906 - val_loss: 3.2113\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "92qHMCJ67KLn"
      },
      "source": [
        "## Inference"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bvkvr-HyuI_t",
        "outputId": "2534ba7f-2c12-4c81-f637-e3a555718bd2"
      },
      "source": [
        "# Get the prediction model by extracting layers till the output layer.\n",
        "prediction_model = keras.models.Model(\n",
        "    model.get_layer(name=\"image\").input, model.get_layer(name=\"dense2\").output\n",
        ")\n",
        "prediction_model.summary()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Model: \"model\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "image (InputLayer)           [(None, 128, 32, 1)]      0         \n",
            "_________________________________________________________________\n",
            "Conv1 (Conv2D)               (None, 128, 32, 32)       320       \n",
            "_________________________________________________________________\n",
            "pool1 (MaxPooling2D)         (None, 64, 16, 32)        0         \n",
            "_________________________________________________________________\n",
            "Conv2 (Conv2D)               (None, 64, 16, 64)        18496     \n",
            "_________________________________________________________________\n",
            "pool2 (MaxPooling2D)         (None, 32, 8, 64)         0         \n",
            "_________________________________________________________________\n",
            "reshape (Reshape)            (None, 32, 512)           0         \n",
            "_________________________________________________________________\n",
            "dense1 (Dense)               (None, 32, 64)            32832     \n",
            "_________________________________________________________________\n",
            "dropout_1 (Dropout)          (None, 32, 64)            0         \n",
            "_________________________________________________________________\n",
            "bidirectional_2 (Bidirection (None, 32, 256)           197632    \n",
            "_________________________________________________________________\n",
            "bidirectional_3 (Bidirection (None, 32, 128)           164352    \n",
            "_________________________________________________________________\n",
            "dense2 (Dense)               (None, 32, 81)            10449     \n",
            "=================================================================\n",
            "Total params: 424,081\n",
            "Trainable params: 424,081\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 433
        },
        "id": "_c0nRPOtydHI",
        "outputId": "194d84e8-3c0f-46bd-9d49-0cec661d4ef8"
      },
      "source": [
        "# A utility function to decode the output of the network.\n",
        "def decode_batch_predictions(pred):\n",
        "    input_len = np.ones(pred.shape[0]) * pred.shape[1]\n",
        "    # Use greedy search. For complex tasks, you can use beam search.\n",
        "    results = keras.backend.ctc_decode(pred, input_length=input_len, greedy=True)[0][0][\n",
        "        :, :max_len\n",
        "    ]\n",
        "    # Iterate over the results and get back the text.\n",
        "    output_text = []\n",
        "    for res in results:\n",
        "        res = tf.gather(res, tf.where(tf.math.not_equal(res, -1)))\n",
        "        res = tf.strings.reduce_join(num_to_char(res)).numpy().decode(\"utf-8\")\n",
        "        output_text.append(res)\n",
        "    return output_text\n",
        "\n",
        "\n",
        "#  Let's check results on some test samples.\n",
        "for batch in test_ds.take(1):\n",
        "    batch_images = batch[\"image\"]\n",
        "    _, ax = plt.subplots(4, 4, figsize=(15, 8))\n",
        "\n",
        "    preds = prediction_model.predict(batch_images)\n",
        "    pred_texts = decode_batch_predictions(preds)\n",
        "\n",
        "    for i in range(16):\n",
        "        img = batch_images[i]\n",
        "        img = tf.image.flip_left_right(img)\n",
        "        img = tf.transpose(img, perm=[1, 0, 2])\n",
        "        img = (img * 255.).numpy().clip(0, 255).astype(np.uint8)\n",
        "        img = img[:, :, 0]\n",
        "\n",
        "        title = f\"Prediction: {pred_texts[i]}\"\n",
        "        ax[i // 4, i % 4].imshow(img, cmap=\"gray\")\n",
        "        ax[i // 4, i % 4].set_title(title)\n",
        "        ax[i // 4, i % 4].axis(\"off\")\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1080x576 with 16 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pSPMi-Ep7PCC"
      },
      "source": [
        "To get better results the model should be trained for at least 50 epochs. "
      ]
    }
  ]
}