plot_optmizerTesting_LeeJaeho.ipynb

{
  "metadata": {
    "kernelspec": {
      "language": "python",
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "version": "3.6.4",
      "file_extension": ".py",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "name": "python",
      "mimetype": "text/x-python"
    },
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "nbformat_minor": 0,
  "nbformat": 4,
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import cv2\n",
        "import numpy as np \n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "from pathlib import Path\n",
        "from collections import Counter\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "from tensorflow.keras import layers\n",
        "print(\"Tensorflow version: \", tf.__version__)\n",
        "\n",
        "seed = 1234\n",
        "np.random.seed(seed)\n",
        "tf.random.set_seed(seed)"
      ],
      "metadata": {
        "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5",
        "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MsmJtNa34A42",
        "outputId": "d653aefd-a807-40b9-ac32-a1bad1030a7f"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Tensorflow version:  2.12.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!dir"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YFQTi1GLOJjw",
        "outputId": "b7976629-8451-4825-87fd-1cfcbfe4959b"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "sample_data\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4yGS0iRROPkP",
        "outputId": "300b96ad-8d52-4242-b38d-a97facfb1d52"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Path to the data directory\n",
        "data_dir = Path(\"/content/drive/MyDrive/input/samples\")\n",
        "\n",
        "\n",
        "\n",
        "# Get list of all the images\n",
        "images = list(data_dir.glob(\"*.png\"))\n",
        "print(\"Number of images found: \", len(images))\n",
        "\n",
        "\n",
        "# Let's take a look at some samples first. \n",
        "# Always look at your data!\n",
        "sample_images = images[:4]\n",
        "\n",
        "_,ax = plt.subplots(2,2, figsize=(5,3))\n",
        "for i in range(4):\n",
        "    img = cv2.imread(str(sample_images[i]))\n",
        "    print(\"Shape of image: \", img.shape)\n",
        "    ax[i//2, i%2].imshow(img)\n",
        "    ax[i//2, i%2].axis('off')\n",
        "plt.show()"
      ],
      "metadata": {
        "_uuid": "d629ff2d2480ee46fbb7e2d37f6b5fab8052498a",
        "_cell_guid": "79c7e3d0-c299-4dcb-8224-4455121ee9b0",
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 298
        },
        "id": "1bIFmJPl4A45",
        "outputId": "c3eb0325-cbac-4bb1-deab-812346e6e09f"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Number of images found:  1040\n",
            "Shape of image:  (50, 200, 3)\n",
            "Shape of image:  (50, 200, 3)\n",
            "Shape of image:  (50, 200, 3)\n",
            "Shape of image:  (50, 200, 3)\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 500x300 with 4 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Store all the characters in a set\n",
        "characters = set()\n",
        "\n",
        "# A list to store the length of each captcha\n",
        "captcha_length = []\n",
        "\n",
        "# Store image-label info\n",
        "dataset = []\n",
        "\n",
        "# Iterate over the dataset and store the\n",
        "# information needed\n",
        "for img_path in images:\n",
        "    # 1. Get the label associated with each image\n",
        "    label = img_path.name.split(\".png\")[0]\n",
        "    # 2. Store the length of this cpatcha\n",
        "    captcha_length.append(len(label))\n",
        "    # 3. Store the image-label pair info\n",
        "    dataset.append((str(img_path), label))\n",
        "    \n",
        "    # 4. Store the characters present\n",
        "    for ch in label:\n",
        "        characters.add(ch)\n",
        "\n",
        "# Sort the characters        \n",
        "characters = sorted(characters)\n",
        "\n",
        "# Convert the dataset info into a dataframe\n",
        "dataset = pd.DataFrame(dataset, columns=[\"img_path\", \"label\"], index=None)\n",
        "\n",
        "# Shuffle the dataset\n",
        "dataset = dataset.sample(frac=1.).reset_index(drop=True)\n",
        "\n",
        "\n",
        "print(\"Number of unqiue charcaters in the whole dataset: \", len(characters))\n",
        "print(\"Maximum length of any captcha: \", max(Counter(captcha_length).keys()))\n",
        "print(\"Characters present: \", characters)\n",
        "print(\"Total number of samples in the dataset: \", len(dataset))\n",
        "dataset.head()"
      ],
      "metadata": {
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        },
        "id": "sfacnY4d4A46",
        "outputId": "e45097d4-227e-4213-d62c-a1743ddaf83a"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Number of unqiue charcaters in the whole dataset:  19\n",
            "Maximum length of any captcha:  5\n",
            "Characters present:  ['2', '3', '4', '5', '6', '7', '8', 'b', 'c', 'd', 'e', 'f', 'g', 'm', 'n', 'p', 'w', 'x', 'y']\n",
            "Total number of samples in the dataset:  1040\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "                                         img_path  label\n",
              "0  /content/drive/MyDrive/input/samples/c4527.png  c4527\n",
              "1  /content/drive/MyDrive/input/samples/y2ye8.png  y2ye8\n",
              "2  /content/drive/MyDrive/input/samples/4m2w5.png  4m2w5\n",
              "3  /content/drive/MyDrive/input/samples/cm6yb.png  cm6yb\n",
              "4  /content/drive/MyDrive/input/samples/cpc8c.png  cpc8c"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-e7bf218b-88fd-493f-81fc-fb718a6e1ebd\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>img_path</th>\n",
              "      <th>label</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>/content/drive/MyDrive/input/samples/c4527.png</td>\n",
              "      <td>c4527</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>/content/drive/MyDrive/input/samples/y2ye8.png</td>\n",
              "      <td>y2ye8</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>/content/drive/MyDrive/input/samples/4m2w5.png</td>\n",
              "      <td>4m2w5</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>/content/drive/MyDrive/input/samples/cm6yb.png</td>\n",
              "      <td>cm6yb</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>/content/drive/MyDrive/input/samples/cpc8c.png</td>\n",
              "      <td>cpc8c</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-e7bf218b-88fd-493f-81fc-fb718a6e1ebd')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-e7bf218b-88fd-493f-81fc-fb718a6e1ebd button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-e7bf218b-88fd-493f-81fc-fb718a6e1ebd');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Split the dataset into training and validation sets\n",
        "training_data, validation_data = train_test_split(dataset, test_size=0.1, random_state=seed)\n",
        "\n",
        "training_data = training_data.reset_index(drop=True)\n",
        "validation_data = validation_data.reset_index(drop=True)\n",
        "\n",
        "print(\"Number of training samples: \", len(training_data))\n",
        "print(\"Number of validation samples: \", len(validation_data))\n",
        "\n",
        "\n",
        "\n",
        "# Map text to numeric labels \n",
        "char_to_labels = {char:idx for idx, char in enumerate(characters)}\n",
        "\n",
        "# Map numeric labels to text\n",
        "labels_to_char = {val:key for key, val in char_to_labels.items()}\n",
        "\n",
        "\n",
        "\n",
        "# Sanity check for corrupted images\n",
        "def is_valid_captcha(captcha):\n",
        "    for ch in captcha:\n",
        "        if not ch in characters:\n",
        "            return False\n",
        "    return True\n",
        "\n",
        "\n",
        "\n",
        "# Store arrays in memory as it's not a much big dataset\n",
        "def generate_arrays(df, resize=True, img_height=50, img_width=200):\n",
        "    \"\"\"Generates image array and labels array from a dataframe.\n",
        "    \n",
        "    Args:\n",
        "        df: dataframe from which we want to read the data\n",
        "        resize (bool)    : whether to resize images or not\n",
        "        img_weidth (int): width of the resized images\n",
        "        img_height (int): height of the resized images\n",
        "        \n",
        "    Returns:\n",
        "        images (ndarray): grayscale images\n",
        "        labels (ndarray): corresponding encoded labels\n",
        "    \"\"\"\n",
        "    \n",
        "    num_items = len(df)\n",
        "    images = np.zeros((num_items, img_height, img_width), dtype=np.float32)\n",
        "    labels = [0]*num_items\n",
        "    \n",
        "    for i in range(num_items):\n",
        "        img = cv2.imread(df[\"img_path\"][i])\n",
        "        img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n",
        "        \n",
        "        if resize: \n",
        "            img = cv2.resize(img, (img_width, img_height))\n",
        "        \n",
        "        img = (img/255.).astype(np.float32)\n",
        "        label = df[\"label\"][i]\n",
        "        \n",
        "        # Add only if it is a valid captcha\n",
        "        if is_valid_captcha(label):\n",
        "            images[i, :, :] = img\n",
        "            labels[i] = label\n",
        "    \n",
        "    return images, np.array(labels)\n",
        "\n",
        "\n",
        "\n",
        "# Build training data\n",
        "training_data, training_labels = generate_arrays(df=training_data)\n",
        "print(\"Number of training images: \", training_data.shape)\n",
        "print(\"Number of training labels: \", training_labels.shape)\n",
        "\n",
        "\n",
        "# Build validation data\n",
        "validation_data, validation_labels = generate_arrays(df=validation_data)\n",
        "print(\"Number of validation images: \", validation_data.shape)\n",
        "print(\"Number of validation labels: \", validation_labels.shape)"
      ],
      "metadata": {
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ecL0v4hx4A47",
        "outputId": "b3338ae3-fa03-4511-e9a2-7d0b7b9b1ece"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Number of training samples:  936\n",
            "Number of validation samples:  104\n",
            "Number of training images:  (936, 50, 200)\n",
            "Number of training labels:  (936,)\n",
            "Number of validation images:  (104, 50, 200)\n",
            "Number of validation labels:  (104,)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class DataGenerator(keras.utils.Sequence):\n",
        "    \"\"\"Generates batches from a given dataset.\n",
        "    \n",
        "    Args:\n",
        "        data: training or validation data\n",
        "        labels: corresponding labels\n",
        "        char_map: dictionary mapping char to labels\n",
        "        batch_size: size of a single batch\n",
        "        img_width: width of the resized\n",
        "        img_height: height of the resized\n",
        "        downsample_factor: by what factor did the CNN downsample the images\n",
        "        max_length: maximum length of any captcha\n",
        "        shuffle: whether to shuffle data or not after each epoch\n",
        "    Returns:\n",
        "        batch_inputs: a dictionary containing batch inputs \n",
        "        batch_labels: a batch of corresponding labels \n",
        "    \"\"\"\n",
        "    \n",
        "    def __init__(self,\n",
        "                 data,\n",
        "                 labels,\n",
        "                 char_map,\n",
        "                 batch_size=16,\n",
        "                 img_width=200,\n",
        "                 img_height=50,\n",
        "                 downsample_factor=4,\n",
        "                 max_length=5,\n",
        "                 shuffle=True\n",
        "                ):\n",
        "        self.data = data\n",
        "        self.labels = labels\n",
        "        self.char_map = char_map\n",
        "        self.batch_size = batch_size\n",
        "        self.img_width = img_width\n",
        "        self.img_height = img_height\n",
        "        self.downsample_factor = downsample_factor\n",
        "        self.max_length = max_length\n",
        "        self.shuffle = shuffle\n",
        "        self.indices = np.arange(len(data))    \n",
        "        self.on_epoch_end()\n",
        "        \n",
        "    def __len__(self):\n",
        "        return int(np.ceil(len(self.data) / self.batch_size))\n",
        "    \n",
        "    def __getitem__(self, idx):\n",
        "        # 1. Get the next batch indices\n",
        "        curr_batch_idx = self.indices[idx*self.batch_size:(idx+1)*self.batch_size]\n",
        "        \n",
        "        # 2. This isn't necessary but it can help us save some memory\n",
        "        # as not all batches the last batch may not have elements\n",
        "        # equal to the batch_size \n",
        "        batch_len = len(curr_batch_idx)\n",
        "        \n",
        "        # 3. Instantiate batch arrays\n",
        "        batch_images = np.ones((batch_len, self.img_width, self.img_height, 1),\n",
        "                               dtype=np.float32)\n",
        "        batch_labels = np.ones((batch_len, self.max_length), dtype=np.float32)\n",
        "        input_length = np.ones((batch_len, 1), dtype=np.int64) * \\\n",
        "                                (self.img_width // self.downsample_factor - 2)\n",
        "        label_length = np.zeros((batch_len, 1), dtype=np.int64)\n",
        "        \n",
        "        \n",
        "        for j, idx in enumerate(curr_batch_idx):\n",
        "            # 1. Get the image and transpose it\n",
        "            img = self.data[idx].T\n",
        "            # 2. Add extra dimenison\n",
        "            img = np.expand_dims(img, axis=-1)\n",
        "            # 3. Get the correpsonding label\n",
        "            text = self.labels[idx]\n",
        "            # 4. Include the pair only if the captcha is valid\n",
        "            if is_valid_captcha(text):\n",
        "                label = [self.char_map[ch] for ch in text]\n",
        "                batch_images[j] = img\n",
        "                batch_labels[j] = label\n",
        "                label_length[j] = len(text)\n",
        "        \n",
        "        batch_inputs = {\n",
        "                'input_data': batch_images,\n",
        "                'input_label': batch_labels,\n",
        "                'input_length': input_length,\n",
        "                'label_length': label_length,\n",
        "                }\n",
        "        return batch_inputs, np.zeros(batch_len).astype(np.float32)\n",
        "        \n",
        "    \n",
        "    def on_epoch_end(self):\n",
        "        if self.shuffle:\n",
        "            np.random.shuffle(self.indices)"
      ],
      "metadata": {
        "trusted": true,
        "id": "yOQu8z0r4A48"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Batch size for training and validation\n",
        "batch_size = 32\n",
        "\n",
        "# Desired image dimensions\n",
        "img_width=200\n",
        "img_height=50 \n",
        "\n",
        "# Factor  by which the image is going to be downsampled\n",
        "# by the convolutional blocks\n",
        "downsample_factor=4\n",
        "\n",
        "# Maximum length of any captcha in the data\n",
        "max_length=5\n",
        "\n",
        "# Get a generator object for the training data\n",
        "train_data_generator = DataGenerator(data=training_data,\n",
        "                                     labels=training_labels,\n",
        "                                     char_map=char_to_labels,\n",
        "                                     batch_size=batch_size,\n",
        "                                     img_width=img_width,\n",
        "                                     img_height=img_height,\n",
        "                                     downsample_factor=downsample_factor,\n",
        "                                     max_length=max_length,\n",
        "                                     shuffle=True\n",
        "                                    )\n",
        "\n",
        "# Get a generator object for the validation data \n",
        "valid_data_generator = DataGenerator(data=validation_data,\n",
        "                                     labels=validation_labels,\n",
        "                                     char_map=char_to_labels,\n",
        "                                     batch_size=batch_size,\n",
        "                                     img_width=img_width,\n",
        "                                     img_height=img_height,\n",
        "                                     downsample_factor=downsample_factor,\n",
        "                                     max_length=max_length,\n",
        "                                     shuffle=False\n",
        "                                    )"
      ],
      "metadata": {
        "trusted": true,
        "id": "FjlSMQX24A49"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class CTCLayer(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, input_length, label_length):\n",
        "        # Compute the training-time loss value and add it\n",
        "        # to the layer using `self.add_loss()`.\n",
        "        loss = self.loss_fn(y_true, y_pred, input_length, label_length)\n",
        "        self.add_loss(loss)\n",
        "        \n",
        "        # On test time, just return the computed loss\n",
        "        return loss\n",
        "\n",
        "\n",
        "\n",
        "def build_model(opt, lr=0.001):\n",
        "    # Inputs to the model\n",
        "    input_img = layers.Input(shape=(img_width, img_height, 1),\n",
        "                            name='input_data',\n",
        "                            dtype='float32')\n",
        "    labels = layers.Input(name='input_label', shape=[max_length], dtype='float32')\n",
        "    input_length = layers.Input(name='input_length', shape=[1], dtype='int64')\n",
        "    label_length = layers.Input(name='label_length', shape=[1], dtype='int64')\n",
        "    \n",
        "    # First conv block\n",
        "    x = layers.Conv2D(32,\n",
        "               (3,3),\n",
        "               activation='relu',\n",
        "               kernel_initializer='he_normal',\n",
        "               padding='same',\n",
        "               name='Conv1')(input_img)\n",
        "    x = layers.MaxPooling2D((2,2), name='pool1')(x)\n",
        "    \n",
        "    # Second conv block\n",
        "    x = layers.Conv2D(64,\n",
        "               (3,3),\n",
        "               activation='relu',\n",
        "               kernel_initializer='he_normal',\n",
        "               padding='same',\n",
        "               name='Conv2')(x)\n",
        "    x = layers.MaxPooling2D((2,2), name='pool2')(x)\n",
        "    \n",
        "    # We have used two max pool with pool size and strides of 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 it to RNNs\n",
        "    new_shape = ((img_width // 4), (img_height // 4)*64)\n",
        "    x = layers.Reshape(target_shape=new_shape, name='reshape')(x)\n",
        "    x = layers.Dense(64, activation='relu', name='dense1')(x)\n",
        "    x = layers.Dropout(0.2)(x)\n",
        "    \n",
        "    # RNNs\n",
        "    x = layers.Bidirectional(layers.LSTM(128,\n",
        "                                         return_sequences=True,\n",
        "                                         dropout=0.2))(x)\n",
        "    x = layers.Bidirectional(layers.LSTM(64,\n",
        "                                         return_sequences=True,\n",
        "                                         dropout=0.25))(x)\n",
        "    \n",
        "    # Predictions\n",
        "    x = layers.Dense(len(characters)+1,\n",
        "              activation='softmax', \n",
        "              name='dense2',\n",
        "              kernel_initializer='he_normal')(x)\n",
        "    \n",
        "    # Calculate CTC\n",
        "    output = CTCLayer(name='ctc_loss')(labels, x, input_length, label_length)\n",
        "    \n",
        "    # Define the model\n",
        "    model = keras.models.Model(inputs=[input_img,\n",
        "                                       labels,\n",
        "                                       input_length,\n",
        "                                       label_length],\n",
        "                                outputs=output,\n",
        "                                name='ocr_model_v1')\n",
        "    \n",
        "    # Optimizer\n",
        "    sgd = keras.optimizers.legacy.SGD(learning_rate=lr,\n",
        "                               decay=1e-6,\n",
        "                               momentum=0.9,\n",
        "                               nesterov=True,\n",
        "                               clipnorm=5)\n",
        "    \n",
        "    Adam = tf.keras.optimizers.Adam(\n",
        "        learning_rate=lr,\n",
        "        beta_1=0.9,\n",
        "        beta_2=0.999,\n",
        "        epsilon=1e-07,\n",
        "        amsgrad=False,\n",
        "        weight_decay=None,\n",
        "        clipnorm=None,\n",
        "        clipvalue=None,\n",
        "        global_clipnorm=None,\n",
        "        use_ema=False,\n",
        "        ema_momentum=0.99,\n",
        "        ema_overwrite_frequency=None,\n",
        "        jit_compile=True)\n",
        "\n",
        "    if opt=='SGD':\n",
        "      opt=sgd\n",
        "\n",
        "    if opt=='Adam':\n",
        "      opt=Adam  \n",
        "      \n",
        "    # Compile the model and return\n",
        "    model.compile(optimizer=opt, metrics=['accuracy'])\n",
        "    return model"
      ],
      "metadata": {
        "trusted": true,
        "id": "Xo6-sWZI4A4-"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# optimzier와 learing rate별로 그래프 그리기\n",
        "'''\n",
        "optimzier 종류:\n",
        "SGD\n",
        "RMSprop\n",
        "Adam\n",
        "AdamW => X\n",
        "Adadelta\n",
        "Adagrad\n",
        "Adamax\n",
        "Adafactor => X\n",
        "Nadam\n",
        "Ftrl\n",
        "'''\n",
        "\n",
        "def lr_and_opt_test(lr_list, opt_list):\n",
        "  for lr in lr_list:\n",
        "    for opt in opt_list:\n",
        "      print('****************** optimizer:',opt,'lr:',lr,'******************')\n",
        "      model = build_model(opt=opt)\n",
        "      # Add early stopping\n",
        "      es = keras.callbacks.EarlyStopping(monitor='val_loss',\n",
        "                                        patience=5,\n",
        "                                        restore_best_weights=True)\n",
        "\n",
        "      # Train the model\n",
        "      history = model.fit_generator(train_data_generator,\n",
        "                          validation_data=valid_data_generator,\n",
        "                          epochs=100,\n",
        "                          callbacks=[es])\n",
        "      \n",
        "      final_acc = history.history['accuracy'][-1]\n",
        "      final_val_acc = history.history['val_accuracy'][-1]\n",
        "\n",
        "      # 정확도 그래프 그리기 및 저장\n",
        "      plt.plot(history.history['accuracy'], color='red')\n",
        "      plt.plot(history.history['val_accuracy'], color='blue')\n",
        "      plt.title('model accuracy')\n",
        "      plt.ylabel('accuracy')\n",
        "      plt.xlabel('epoch')\n",
        "      plt.legend(['train_accuracy', 'test_accuracy'], loc='upper left')\n",
        "      plt.savefig(f'/content/drive/MyDrive/ML/{opt}/model_acc_{lr}.png')\n",
        "\n",
        "      plt.clf() # 그래프 초기화\n",
        "\n",
        "      # loss 그래프 그리기 및 저장\n",
        "      plt.plot(history.history['loss'], color='brown')\n",
        "      plt.plot(history.history['val_loss'], color='green')\n",
        "      plt.title('model loss')\n",
        "      plt.ylabel('loss')\n",
        "      plt.xlabel('epoch')\n",
        "      plt.legend(['train_loss', 'test_loss'], loc='upper left')\n",
        "      plt.savefig(f'/content/drive/MyDrive/ML/{opt}/model_loss_{lr}.png')\n",
        "\n",
        "      plt.clf() # 그래프 초기화\n",
        "\n",
        "      # acc과 loss 둘 다 반영한 그래프\n",
        "      plt.plot(history.history['accuracy'], color='red')\n",
        "      plt.plot(history.history['loss'], color='brown')\n",
        "      plt.plot(history.history['val_accuracy'], color='blue')\n",
        "      plt.plot(history.history['val_loss'], color='green')\n",
        "      plt.xlabel('epoch')\n",
        "      plt.legend(['train_accuracy', 'train_loss', 'test_accuracy', 'test_loss'], loc='upper left')\n",
        "      plt.savefig(f'/content/drive/MyDrive/ML/{opt}/model_acc_loss_{lr}.png')\n",
        "\n",
        "      plt.clf() # 그래프 초기화\n",
        "\n",
        "      # log.txt에 값 저장하기. columns: opt,\tlr,\ttrain_acc,\ttest_acc\n",
        "      file_path = '/content/drive/MyDrive/log.txt'\n",
        "      new_text_content = ''\n",
        "\n",
        "      with open(file_path,'r') as f:\n",
        "        lines = f.readlines()\n",
        "        for i, l in enumerate(lines):\n",
        "          new_string = l.strip()\n",
        "          if new_string:\n",
        "            new_text_content += new_string + '\\n'\n",
        "            \n",
        "      new_text_content += f'{opt}\\t{lr}\\t{final_acc}\\t{final_val_acc}' + '\\n'\n",
        "        \n",
        "      with open(file_path, 'w') as f:\n",
        "          f.write(new_text_content)\n",
        "\n",
        "lr_list = [0.0005, 0.001, 0.002, 0.003, 0.005, 0.01]\n",
        "opt_list = ['SGD', 'Adam']\n",
        "lr_and_opt_test(lr_list, opt_list)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "K9eEwtijM20p",
        "outputId": "b809499c-38e2-4523-ad85-ad2b32a310ed"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "****************** optimizer: SGD lr: 0.0005 ******************\n",
            "Epoch 1/100\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-10-4a5df570a20f>:27: UserWarning: `Model.fit_generator` is deprecated and will be removed in a future version. Please use `Model.fit`, which supports generators.\n",
            "  history = model.fit_generator(train_data_generator,\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 밑에서 부터는 기존 코드\n",
        "model = build_model(opt='SGD')\n",
        "model.summary()"
      ],
      "metadata": {
        "trusted": true,
        "id": "n2wvGBbp4A4_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Add early stopping\n",
        "es = keras.callbacks.EarlyStopping(monitor='val_loss',\n",
        "                                        patience=5,\n",
        "                                        restore_best_weights=True)\n",
        "\n",
        "# Train the model\n",
        "history = model.fit_generator(train_data_generator,\n",
        "                          validation_data=valid_data_generator,\n",
        "                          epochs=100,\n",
        "                          callbacks=[es])"
      ],
      "metadata": {
        "id": "vmI_ttZNQmSm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "prediction_model = keras.models.Model(model.get_layer(name='input_data').input,\n",
        "                                        model.get_layer(name='dense2').output)\n",
        "prediction_model.summary()"
      ],
      "metadata": {
        "trusted": true,
        "id": "A-F3E9894A5A"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# A utility to decode the output of the network\n",
        "def decode_batch_predictions(pred):\n",
        "    pred = pred[:, :-2]\n",
        "    input_len = np.ones(pred.shape[0])*pred.shape[1]\n",
        "    \n",
        "    # Use greedy search. For complex tasks, you can use beam search\n",
        "    results = keras.backend.ctc_decode(pred, \n",
        "                                        input_length=input_len,\n",
        "                                        greedy=True)[0][0]\n",
        "    \n",
        "    # Iterate over the results and get back the text\n",
        "    output_text = []\n",
        "    for res in results.numpy():\n",
        "        outstr = ''\n",
        "        for c in res:\n",
        "            if c < len(characters) and c >=0:\n",
        "                outstr += labels_to_char[c]\n",
        "        output_text.append(outstr)\n",
        "    \n",
        "    # return final text results\n",
        "    return output_text"
      ],
      "metadata": {
        "trusted": true,
        "id": "L1fgmxem4A5A"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "p_texts = []\n",
        "o_texts = []\n",
        "\n",
        "#  Let's check results on some validation samples\n",
        "for p, (inp_value, _) in enumerate(valid_data_generator):\n",
        "    bs = inp_value['input_data'].shape[0]\n",
        "    X_data = inp_value['input_data']\n",
        "    labels = inp_value['input_label']\n",
        "    \n",
        "    preds = prediction_model.predict(X_data)\n",
        "    pred_texts = decode_batch_predictions(preds)\n",
        "    \n",
        "    \n",
        "    orig_texts = []\n",
        "    for label in labels:\n",
        "        text = ''.join([labels_to_char[int(x)] for x in label])\n",
        "        orig_texts.append(text)\n",
        "\n",
        "    p_texts.append(pred_texts)\n",
        "    o_texts.append(orig_texts)\n",
        "    \n",
        "    for i in range(bs):\n",
        "        print(f'Ground truth: {orig_texts[i]} \\t Predicted: {pred_texts[i]} \\t Correct: {orig_texts[i]==pred_texts[i]}')\n",
        "    break"
      ],
      "metadata": {
        "trusted": true,
        "id": "omVwRt0P4A5B"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Please upvote if you liked the notebook.**"
      ],
      "metadata": {
        "id": "mmcxN9vL4A5C"
      }
    }
  ]
}