From 63cdc77d533415a5f343b5d102ebf40b0c071ea9 Mon Sep 17 00:00:00 2001
From: Sayak Paul <spsayakpaul@gmail.com>
Date: Tue, 10 Aug 2021 20:23:11 -0700
Subject: [PATCH] adding keras_ocr notebook

---
 Recognizer_KerasOCR.ipynb | 663 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 663 insertions(+)
 create mode 100644 Recognizer_KerasOCR.ipynb

diff --git a/Recognizer_KerasOCR.ipynb b/Recognizer_KerasOCR.ipynb
new file mode 100644
index 0000000..7c7b7b0
--- /dev/null
+++ b/Recognizer_KerasOCR.ipynb
@@ -0,0 +1,663 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "name": "Recognizer_KerasOCR.ipynb",
+      "provenance": [],
+      "collapsed_sections": [],
+      "include_colab_link": true
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "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/main/Recognizer_KerasOCR.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "1V4_9chGp_oE"
+      },
+      "source": [
+        "## References:\n",
+        "* https://keras-ocr.readthedocs.io/en/latest/examples/fine_tuning_recognizer.html"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "LkhO0e3oPCSE"
+      },
+      "source": [
+        "## Initial setup"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "6H6yrSa8k4Wo"
+      },
+      "source": [
+        "!pip install -U git+https://github.com/faustomorales/keras-ocr.git#egg=keras-ocr\n",
+        "!pip install -U opencv-python # We need the most recent version of OpenCV."
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Fsa1uhREgcOW",
+        "outputId": "5e284cc6-09c3-404d-cd21-4b239588b42a"
+      },
+      "source": [
+        "import matplotlib.pyplot as plt\n",
+        "import numpy as np\n",
+        "import keras_ocr\n",
+        "import imgaug\n",
+        "import os\n",
+        "\n",
+        "import tensorflow as tf\n",
+        "print(tf.__version__)\n",
+        "tf.random.set_seed(42)\n",
+        "np.random.seed(42)"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "2.4.0\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "6esKhA_iaurG",
+        "outputId": "31b102eb-0dcf-49d0-9c38-8a4e7d611cf6"
+      },
+      "source": [
+        "!nvidia-smi"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "Fri Jan 22 08:20:55 2021       \n",
+            "+-----------------------------------------------------------------------------+\n",
+            "| NVIDIA-SMI 460.32.03    Driver Version: 418.67       CUDA Version: 10.1     |\n",
+            "|-------------------------------+----------------------+----------------------+\n",
+            "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
+            "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
+            "|                               |                      |               MIG M. |\n",
+            "|===============================+======================+======================|\n",
+            "|   0  Tesla P100-PCIE...  Off  | 00000000:00:04.0 Off |                    0 |\n",
+            "| N/A   33C    P0    25W / 250W |      0MiB / 16280MiB |      0%      Default |\n",
+            "|                               |                      |                 ERR! |\n",
+            "+-------------------------------+----------------------+----------------------+\n",
+            "                                                                               \n",
+            "+-----------------------------------------------------------------------------+\n",
+            "| Processes:                                                                  |\n",
+            "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
+            "|        ID   ID                                                   Usage      |\n",
+            "|=============================================================================|\n",
+            "|  No running processes found                                                 |\n",
+            "+-----------------------------------------------------------------------------+\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "5M0KAlL3PFP4"
+      },
+      "source": [
+        "## Dataset gathering"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "NvHIcL_4gHzE"
+      },
+      "source": [
+        "!wget -q https://pis-datasets.s3.us-east-2.amazonaws.com/IAM_Words.zip\n",
+        "!unzip -qq IAM_Words.zip"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "n0oX7nx-bih-"
+      },
+      "source": [
+        "!mkdir data\n",
+        "!mkdir data/words\n",
+        "!tar -C /content/data/words -xf IAM_Words/words.tgz\n",
+        "!mv IAM_Words/words.txt /content/data"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "L_-4laoHjfW8",
+        "outputId": "7902767f-e2ad-408e-881a-d3261963a194"
+      },
+      "source": [
+        "!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": "kQJ2tHzePI7d"
+      },
+      "source": [
+        "## Create training and validation splits"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "2qFEmslChS3m",
+        "outputId": "daf038e6-2931-4d6a-8862-0f703f4c009e"
+      },
+      "source": [
+        "words_list = []\n",
+        "\n",
+        "words = open('/content/data/words.txt', 'r').readlines()\n",
+        "for line in words:\n",
+        "    if line[0]=='#':\n",
+        "        continue\n",
+        "    if line.split(\" \")[1]!=\"err\": # We won'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": 7
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Gt5ajRZBhvfU",
+        "outputId": "39b2c2ff-45c8-48d1-8f32-922101e90e96"
+      },
+      "source": [
+        "np.random.shuffle(words_list)\n",
+        "splitIdx = int(0.9 * len(words_list))\n",
+        "trainSamples = words_list[:splitIdx]\n",
+        "validationSamples = words_list[splitIdx:]\n",
+        "\n",
+        "len(trainSamples), len(validationSamples)"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(86810, 9646)"
+            ]
+          },
+          "metadata": {
+            "tags": []
+          },
+          "execution_count": 11
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "Fp0w9LRBhzeF"
+      },
+      "source": [
+        "def parse_path(file_line):\n",
+        "    lineSplit = file_line.strip()\n",
+        "    lineSplit = lineSplit.split(\" \")\n",
+        "    # part1/part1-part2/part1-part2-part3.png\n",
+        "    imageName = lineSplit[0] \n",
+        "    partI = imageName.split(\"-\")[0]\n",
+        "    partII = imageName.split(\"-\")[1]\n",
+        "    img_path =  os.path.join(\"/content/data/words/\", partI, \n",
+        "                (partI + '-' + partII),\n",
+        "                (imageName + \".png\")\n",
+        "    )\n",
+        "    label = file_line.split(' ')[8:][0].strip() \n",
+        "    if (os.path.getsize(img_path)!=0) & (label!=None):\n",
+        "        return (img_path, None, label.lower())"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "YsGOsNYRi4Wv",
+        "outputId": "4366d320-2e5e-44d9-f3d6-f6e055a20260"
+      },
+      "source": [
+        "train_labels = [parse_path(file_line) for file_line in trainSamples \n",
+        "                if parse_path(file_line)!=None]\n",
+        "val_labels = [parse_path(file_line) for file_line in validationSamples \n",
+        "              if parse_path(file_line)!=None]\n",
+        "len(train_labels), len(val_labels)"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(86809, 9645)"
+            ]
+          },
+          "metadata": {
+            "tags": []
+          },
+          "execution_count": 20
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "313NgDI7mmuj",
+        "outputId": "767379c8-72fb-470a-e211-f523f9b8671b"
+      },
+      "source": [
+        "train_labels[:5]"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "[('/content/data/words/f02/f02-033/f02-033-00-02.png', None, 'do'),\n",
+              " ('/content/data/words/n02/n02-049/n02-049-05-01.png', None, 'his'),\n",
+              " ('/content/data/words/g05/g05-087/g05-087-02-04.png', None, 'evidently'),\n",
+              " ('/content/data/words/h07/h07-025/h07-025-01-03.png', None, 'prime'),\n",
+              " ('/content/data/words/n01/n01-031/n01-031-03-09.png', None, ';')]"
+            ]
+          },
+          "metadata": {
+            "tags": []
+          },
+          "execution_count": 21
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "KlLmci2PPOJ2"
+      },
+      "source": [
+        "## Create data generators"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "bRjFe0fEmCnV",
+        "outputId": "9614c69d-558b-482e-8c81-82778f5dc89f"
+      },
+      "source": [
+        "recognizer = keras_ocr.recognition.Recognizer()\n",
+        "recognizer.compile()"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "Looking for /root/.keras-ocr/crnn_kurapan.h5\n",
+            "Downloading /root/.keras-ocr/crnn_kurapan.h5\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "nnrILOAekgXz"
+      },
+      "source": [
+        "batch_size = 8\n",
+        "augmenter = imgaug.augmenters.Sequential([\n",
+        "    imgaug.augmenters.GammaContrast(gamma=(0.25, 3.0)),\n",
+        "])\n",
+        "\n",
+        "(training_image_gen, training_steps), (validation_image_gen, validation_steps) = [\n",
+        "    (\n",
+        "        keras_ocr.datasets.get_recognizer_image_generator(\n",
+        "            labels=labels,\n",
+        "            height=recognizer.model.input_shape[1],\n",
+        "            width=recognizer.model.input_shape[2],\n",
+        "            alphabet=recognizer.alphabet,\n",
+        "            augmenter=augmenter\n",
+        "        ),\n",
+        "        len(labels) // batch_size\n",
+        "    ) for labels, augmenter in [(train_labels, augmenter), (val_labels, None)]     \n",
+        "]\n",
+        "training_gen, validation_gen = [\n",
+        "    recognizer.get_batch_generator(\n",
+        "        image_generator=image_generator,\n",
+        "        batch_size=batch_size\n",
+        "    )\n",
+        "    for image_generator in [training_image_gen, validation_image_gen]\n",
+        "]"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 133
+        },
+        "id": "spWIuIL4l64J",
+        "outputId": "5ce0e5a5-68e3-45f6-e2bc-33b02c19cd9a"
+      },
+      "source": [
+        "image, text = next(training_image_gen)\n",
+        "plt.imshow(image)\n",
+        "plt.title(text)\n",
+        "plt.show()"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "12322 / 86809 instances have illegal characters.\n"
+          ],
+          "name": "stdout"
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ]
+          },
+          "metadata": {
+            "tags": [],
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "bNU09rthNiyg"
+      },
+      "source": [
+        "[Here's](https://keras-ocr.readthedocs.io/en/latest/examples/end_to_end_training.html#generating-synthetic-data) where you can know on what basis a character is termed as illegal in the framework. "
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "My5CauLVPRKI"
+      },
+      "source": [
+        "## Model training and sample inference"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "jnIa6taxNhhB",
+        "outputId": "a0a53e2f-0981-428f-90cb-be658a30bf50"
+      },
+      "source": [
+        "callbacks = [\n",
+        "    tf.keras.callbacks.EarlyStopping(monitor='val_loss', min_delta=0, patience=10, restore_best_weights=True),\n",
+        "]\n",
+        "history = recognizer.training_model.fit_generator(\n",
+        "    generator=training_gen,\n",
+        "    steps_per_epoch=training_steps,\n",
+        "    validation_steps=validation_steps,\n",
+        "    validation_data=validation_gen,\n",
+        "    callbacks=callbacks,\n",
+        "    epochs=1000\n",
+        ")"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "/usr/local/lib/python3.6/dist-packages/tensorflow/python/keras/engine/training.py:1844: UserWarning: `Model.fit_generator` is deprecated and will be removed in a future version. Please use `Model.fit`, which supports generators.\n",
+            "  warnings.warn('`Model.fit_generator` is deprecated and '\n"
+          ],
+          "name": "stderr"
+        },
+        {
+          "output_type": "stream",
+          "text": [
+            "Epoch 1/1000\n",
+            "10851/10851 [==============================] - ETA: 0s - loss: 4.83491396 / 9645 instances have illegal characters.\n",
+            "10851/10851 [==============================] - 765s 69ms/step - loss: 4.8348 - val_loss: 2.7913\n",
+            "Epoch 2/1000\n",
+            "10851/10851 [==============================] - 728s 67ms/step - loss: 2.7352 - val_loss: 2.3814\n",
+            "Epoch 3/1000\n",
+            "10851/10851 [==============================] - 703s 65ms/step - loss: 2.5155 - val_loss: 2.6978\n",
+            "Epoch 4/1000\n",
+            "10851/10851 [==============================] - 725s 67ms/step - loss: 5.8838 - val_loss: 2.4806\n",
+            "Epoch 5/1000\n",
+            "10851/10851 [==============================] - 718s 66ms/step - loss: 2.1935 - val_loss: 2.2792\n",
+            "Epoch 6/1000\n",
+            "10851/10851 [==============================] - 710s 65ms/step - loss: 2.1851 - val_loss: 2.2507\n",
+            "Epoch 7/1000\n",
+            "10851/10851 [==============================] - 700s 65ms/step - loss: 2.1589 - val_loss: 2.5480\n",
+            "Epoch 8/1000\n",
+            "10851/10851 [==============================] - 692s 64ms/step - loss: 2.2597 - val_loss: 2.5064\n",
+            "Epoch 9/1000\n",
+            "10851/10851 [==============================] - 706s 65ms/step - loss: 2.3399 - val_loss: 3.0601\n",
+            "Epoch 10/1000\n",
+            "10851/10851 [==============================] - 712s 66ms/step - loss: 2.5872 - val_loss: 2.8665\n",
+            "Epoch 11/1000\n",
+            "10851/10851 [==============================] - 720s 66ms/step - loss: 2.6751 - val_loss: 2.8264\n",
+            "Epoch 12/1000\n",
+            "10851/10851 [==============================] - 717s 66ms/step - loss: 2.6408 - val_loss: 3.2452\n",
+            "Epoch 13/1000\n",
+            "10851/10851 [==============================] - 721s 66ms/step - loss: 2.8635 - val_loss: 3.0980\n",
+            "Epoch 14/1000\n",
+            "10851/10851 [==============================] - 722s 67ms/step - loss: 2.9155 - val_loss: 3.0788\n",
+            "Epoch 15/1000\n",
+            "10851/10851 [==============================] - 723s 67ms/step - loss: 2.9245 - val_loss: 3.0868\n",
+            "Epoch 16/1000\n",
+            "10851/10851 [==============================] - 723s 67ms/step - loss: 3.1534 - val_loss: 3.2880\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 295
+        },
+        "id": "mDdtiiziSE_f",
+        "outputId": "2ddbdaeb-7f28-422b-c67f-8451671edfac"
+      },
+      "source": [
+        "plt.figure()\n",
+        "plt.plot(history.history[\"loss\"], label=\"train_loss\")\n",
+        "plt.plot(history.history[\"val_loss\"], label=\"val_loss\")\n",
+        "plt.title(\"Training and Validation Loss on Dataset\")\n",
+        "plt.xlabel(\"Epoch #\")\n",
+        "plt.ylabel(\"Loss\")\n",
+        "plt.legend(loc=\"lower left\")\n",
+        "plt.show()"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ]
+          },
+          "metadata": {
+            "tags": [],
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "QoEiOzwuOr5p"
+      },
+      "source": [
+        "The training seems to be a bit unstable. This can likely be mitigated by using a lower learning rate. "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 201
+        },
+        "id": "GowCOjhCOe6x",
+        "outputId": "e0c4f00a-a7e4-45e3-e143-5a594d537ae2"
+      },
+      "source": [
+        "image_filepath, _, actual = val_labels[1]\n",
+        "predicted = recognizer.recognize(image_filepath)\n",
+        "print(f'Predicted: {predicted}, Actual: {actual}')\n",
+        "_ = plt.imshow(keras_ocr.tools.read(image_filepath))"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "Predicted: and, Actual: and\n"
+          ],
+          "name": "stdout"
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ]
+          },
+          "metadata": {
+            "tags": [],
+            "needs_background": "light"
+          }
+        }
+      ]
+    }
+  ]
+}
\ No newline at end of file