Numbers_OCR_Tensorflow_bank.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Numbers_OCR_Tensorflow_bank.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "import os\n",
        "# os.getcwd()\n",
        "os.chdir('/content/drive/My Drive/DeepLearning_FinalProject')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "azUxkQY2H19z",
        "outputId": "7526daa7-f61a-41d4-cffd-24fe6f601fef"
      },
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!ls"
      ],
      "metadata": {
        "id": "MyetfLNOLvbT",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8a3075b8-aaec-4193-bea2-7bd093e8ab99"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            " checkpoints\t\t\t     test_data_bank.txt\n",
            " DataGenerator.ipynb\t\t     test_data_melli.txt\n",
            " Fonts\t\t\t\t     test_dataset\n",
            " logs\t\t\t\t    'test_dataset (1)'\n",
            " main_model_2.h5\t\t     test_data.txt\n",
            " main_model.h5\t\t\t     train_data\n",
            " model1.h5\t\t\t     train_data_1\n",
            " model.h5\t\t\t     train_data_bank.txt\n",
            " new_test_data\t\t\t     train_data_melli.txt\n",
            " new_train_data\t\t\t     train_dataset\n",
            " new_validation_data\t\t    'train_dataset (1)'\n",
            " Numbers_OCR.ipynb\t\t     train_data.txt\n",
            "'Numbers_OCR_Tensorflow (1).ipynb'   validation_data\n",
            " Numbers_OCR_Tensorflow.ipynb\t     validation_data_bank.txt\n",
            " requirements.txt\t\t     validation_data_melli.txt\n",
            " src\t\t\t\t     validation_dataset\n",
            " test\t\t\t\t    'validation_dataset (1)'\n",
            " test_data\t\t\t     validation_data.txt\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "2vYPFVUK5SSl"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "from torch.utils.data import Dataset\n",
        "from torch.utils.data import sampler\n",
        "import torchvision.transforms as transforms\n",
        "from PIL import Image\n",
        "\n",
        "alphabet=\"0123456789 \"\n",
        "traindir = \"./train_dataset\"\n",
        "testdir = \"./test_dataset\"\n",
        "valdir = \"./validation_dataset\"\n",
        "\n",
        "\n",
        "class SynthDataset(Dataset):\n",
        "  def __init__(self, imgdir):\n",
        "    super(SynthDataset, self).__init__()\n",
        "    self.path = os.path.join(imgdir)\n",
        "    self.images = os.listdir(self.path)\n",
        "    self.nSamples = len(self.images)\n",
        "    f = lambda x: os.path.join(self.path, x)\n",
        "    self.imagepaths = list(map(f, self.images))\n",
        "    transform_list =  [transforms.Grayscale(1),\n",
        "                        transforms.ToTensor(), \n",
        "                        transforms.Normalize((0.5,), (0.5,))]\n",
        "    self.transform = transforms.Compose(transform_list)\n",
        "\n",
        "  def __len__(self):\n",
        "    return self.nSamples\n",
        "\n",
        "  def __getitem__(self, index):\n",
        "    assert index <= len(self), 'index range error'\n",
        "    imagepath = self.imagepaths[index]\n",
        "    imagefile = os.path.basename(imagepath)\n",
        "    img = Image.open(imagepath)\n",
        "    # print(imagepath)\n",
        "    if self.transform is not None:\n",
        "        img = self.transform(img)\n",
        "    item = {'img': img, 'idx':index}\n",
        "    item['label'] = imagefile.split('_')[0]\n",
        "    return item\n",
        "    \n",
        "  def get_all_items(self, num_of_data, width, num_len):\n",
        "    inputs_mat = []\n",
        "    outputs_mat = []\n",
        "    counter = 0\n",
        "    for i in range(0, num_of_data):\n",
        "      o_mat = np.zeros((num_len, len(alphabet)))\n",
        "      imagepath = self.imagepaths[i]\n",
        "      # print(imagepath)\n",
        "      imagefile = os.path.basename(imagepath)\n",
        "      if(imagefile[4] == ' '):\n",
        "        img = Image.open(imagepath)\n",
        "        if self.transform is not None:\n",
        "            img = self.transform(img)\n",
        "        image = np.ones((img.shape[0], img.shape[1], width), dtype=np.float32)\n",
        "        image[:, :, 0:img.shape[2]] = img\n",
        "        image = image.reshape((image.shape[1], image.shape[2], 1))\n",
        "        inputs_mat.append(image)\n",
        "        label = imagefile.split('_')[0]\n",
        "        if(len(label) == 19):\n",
        "          label += ' ' * (num_of_data - 19)\n",
        "        for j in range(0, num_len):\n",
        "          index_num = alphabet.find(label[j])\n",
        "          o_mat[j, index_num] = 1\n",
        "        outputs_mat.append(o_mat)\n",
        "        counter += 1\n",
        "        if(i % 500 == 0):\n",
        "          print(\"----------\", i)\n",
        "        # if counter == num_of_data:\n",
        "        #   break;\n",
        "    \n",
        "    inputs_mat = np.array(inputs_mat)\n",
        "    outputs_mat = np.array(outputs_mat)\n",
        "    return inputs_mat, outputs_mat \n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# # del list\n",
        "\n",
        "import os\n",
        "\n",
        "dir = './validation_dataset'\n",
        "lists = os.listdir(dir) \n",
        "number_files = len(lists)\n",
        "print(number_files)"
      ],
      "metadata": {
        "id": "U0ymylqEQR9z",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "77eb20d5-5463-4787-e2c6-b1422b4c6ce5"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2675\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "width = 222\n",
        "num_len = 20\n",
        "num_of_train_data = 25000\n",
        "\n",
        "data = SynthDataset(traindir)\n",
        "train_x, train_y = data.get_all_items(num_of_train_data, width, num_len)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L92mVTWd8Xnd",
        "outputId": "94dbbfa6-519d-4fb1-9050-60075f7e476c"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "---------- 0\n",
            "---------- 500\n",
            "---------- 1000\n",
            "---------- 1500\n",
            "---------- 2000\n",
            "---------- 2500\n",
            "---------- 3000\n",
            "---------- 3500\n",
            "---------- 4000\n",
            "---------- 4500\n",
            "---------- 5000\n",
            "---------- 8500\n",
            "---------- 11000\n",
            "---------- 11500\n",
            "---------- 12000\n",
            "---------- 12500\n",
            "---------- 13000\n",
            "---------- 13500\n",
            "---------- 14000\n",
            "---------- 14500\n",
            "---------- 16000\n",
            "---------- 20500\n",
            "---------- 21000\n",
            "---------- 21500\n",
            "---------- 22000\n",
            "---------- 22500\n",
            "---------- 23000\n",
            "---------- 23500\n",
            "---------- 24000\n",
            "---------- 24500\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "width = 222\n",
        "num_len = 20\n",
        "num_of_test_data = 3124\n",
        "num_of_val_data = 2674\n",
        "\n",
        "data = SynthDataset(testdir)\n",
        "test_x, test_y = data.get_all_items(num_of_test_data, width, num_len)\n",
        "\n",
        "data = SynthDataset(valdir)\n",
        "validation_x, validation_y = data.get_all_items(num_of_val_data, width, num_len)"
      ],
      "metadata": {
        "id": "vmmLI2FZ75gn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6cb80ddc-7b02-4996-be97-f2fd911a254a"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "---------- 500\n",
            "---------- 1500\n",
            "---------- 2000\n",
            "---------- 3000\n",
            "---------- 0\n",
            "---------- 2000\n",
            "---------- 2500\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(train_x.shape)\n",
        "print(train_y.shape)\n",
        "print(test_x.shape)\n",
        "print(test_y.shape)\n",
        "print(validation_x.shape)\n",
        "print(validation_y.shape)"
      ],
      "metadata": {
        "id": "fUgoWyFLOLsi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e326d7c2-6edb-4e98-89c4-338a15e1d075"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(15000, 32, 222, 1)\n",
            "(15000, 20, 11)\n",
            "(1874, 32, 222, 1)\n",
            "(1874, 20, 11)\n",
            "(1425, 32, 222, 1)\n",
            "(1425, 20, 11)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        " # height = 32\n",
        "# # width = 210\n",
        "\n",
        "# num_len = 32\n",
        "# # num_of_data = 10\n",
        "\n",
        "# # data = SynthDataset(traindir)\n",
        "# # x =SynthCollator()\n",
        "\n",
        "# def data_preprocessing(dir, num_of_data=100):\n",
        "#   train_x = []\n",
        "#   train_y = []\n",
        "#   counter = 0\n",
        "#   width = 222\n",
        "#   train_y = np.zeros((num_of_data, num_len, len(alphabet)))\n",
        "#   data = SynthDataset(dir)\n",
        "#   print(len(images_mat))\n",
        "#   for x, y in data:\n",
        "#     image = np.ones((x.shape[0], x.shape[1], width), dtype=np.float32)\n",
        "#     # print(y)\n",
        "#     image[:, :, 0:x.shape[2]] = x\n",
        "#     # a, b, c = SynthCollator()\n",
        "#     image = image.reshape((image.shape[1], image.shape[2], 1))\n",
        "#     # print(x.shape)\n",
        "#     train_x.append(image)\n",
        "#     if(len(y) == 10):\n",
        "#       y += ' ' * 22\n",
        "#     elif(len(y) == 19):\n",
        "#       y += ' ' * 13\n",
        "#     for i in range(0, num_len):\n",
        "#       index_num = alphabet.find(y[i])\n",
        "#       train_y[counter, i, index_num] = 1\n",
        "\n",
        "#     # print(y, train_y[counter])\n",
        "#     # train_x.append(code)\n",
        "#     train_y = np.array(train_y)\n",
        "#     counter +=1\n",
        "#     print(counter)\n",
        "#     if(counter % 500 == 0):\n",
        "#       print(\"----------\", counter)\n",
        "#     if counter == num_of_data:\n",
        "#       break;\n",
        "#   return train_x, train_y\n",
        "\n",
        "# data_preprocessing(traindir, num_of_data=1600)\n",
        "# train_x, train_y = data_preprocessing(traindir, num_of_data=1600)\n",
        "# test_x, test_y = data_preprocessing(testdir, num_of_data=2000)\n",
        "# validation_x, validation_y = data_preprocessing(valdir, num_of_data=2000)\n",
        "# print(train_y)\n",
        "# train_x = np.array(train_x)\n",
        "# print(train_x.shape)\n",
        "# train_x = [data[i]['img'] for i in range(0, number_files)]\n",
        "# train_x = np.array(train_x)\n",
        "# print(train_x.shape)\n",
        "# print(data[0]['img'].numpy())\n"
      ],
      "metadata": {
        "id": "Rg5c-zUWOUEz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from matplotlib import pyplot as plt\n",
        "from tensorflow.keras.utils import to_categorical\n",
        "\n",
        "def convert_output_to_text(output):\n",
        "  output_text = \"\"\n",
        "  for i in range(0, output.shape[0]):\n",
        "    for j in range(0, output.shape[1]):\n",
        "      index_word = np.argmax(output[i, j] == 1)\n",
        "      output_text += alphabet[index_word]\n",
        "  return output_text\n",
        "\n",
        "\n",
        "for i in range(10):\n",
        "  temp = train_x[i].reshape((train_x[i].shape[0], train_x[i].shape[1]))\n",
        "  plt.imshow(temp, cmap='gray', aspect=\"auto\", interpolation='nearest')\n",
        "  # title = \"number \" + str(train_y[i])\n",
        "  # plt.title(title)\n",
        "  plt.show()\n",
        "# train_y = to_categorical(train_y)\n",
        "print(train_y)\n",
        "\n",
        "print(train_x.shape)\n",
        "print(train_y.shape)"
      ],
      "metadata": {
        "id": "3nvik0c1Lks2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "1beb163a-6452-4b2d-a5dd-7d64dce0dae5"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAAD5CAYAAAA+0W6bAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO2da2xc6Xnf/+/ceREvQw7vpESJul9W0mpvsHdj7zrpJnHjpC0MG0XqokY2BWKgRlMUrgM0/tAPSdskSIEgwaY24hRO7DiJsYtmXcfeBKv1rnclakXdbxRJieL9Tg45w8OZefvhzPvoPaMZkroNdeL/DxB2eHguz3nf9zw7mvnpeZTWGoQQQvxHYKsDIIQQ8mAwgRNCiE9hAieEEJ/CBE4IIT6FCZwQQnwKEzghhPiU0MMcrJR6FcAfAggC+N9a699Zb//Gxka9Y8eOh7kkIYT81HHmzJlprXWicPsDJ3ClVBDAHwH4WQB3AJxWSr2ptb5c6pgdO3agt7f3QS9JCCE/lSilbhXb/jAfoTwLoF9rPaC1dgB8G8BnHuJ8hBBC7oOHSeDtAIatn+/ktxFCCCkDj/1LTKXUa0qpXqVU79TU1OO+HCGE/NTwMAl8BECn9XNHfpsHrfXrWusTWusTicQ9n8ETQgh5QB4mgZ8GsFsp1a2UigD4HIA3H01YhBBCNuKBLRStdUYp9SUAP4CrEX5Da33pkUVGCCFkXR7KA9davwXgrUcUCyGEkPuA/xKTEEJ8ChM4IYT4FCZwQgjxKUzghBDiU5jACSHEpzCBE0KIT2ECJ4QQn8IETgghPoUJnBBCfAoTOCGE+BQmcEII8SlM4IQQ4lOYwAkhxKcwgRNCiE9hAieEEJ/CBE4IIT6FCZwQQnwKEzghhPgUJnBCCPEpTOCEEOJTmMAJIcSnMIETQohPYQInhBCfwgROCCE+hQmcEEJ8SuhhDlZKDQFYApAFkNFan3gUQRFCCNmYh0rgeT6ptZ5+BOchhBByH/AjFEII8SkPm8A1gL9XSp1RSr32KAIihBCyOR72I5SPa61HlFJNAH6olLqqtT5p75BP7K8BQFdX10NejhBCiOGh3oFrrUfy/50E8D0AzxbZ53Wt9Qmt9YlEIvEwlyOEEGLxwAlcKVWllNpmXgP4OQAXH1VghBBC1udhPkJpBvA9pZQ5z19orf/fI4mKEELIhjxwAtdaDwB46hHGQggh5D6gRkgIIT6FCZwQQnwKEzghhPgUJnBCCPEpTOCEEOJTmMAJIcSnMIETQohPYQInhBCfwgROCCE+hQmcEEJ8ChM4IYT4lEfRUu2+yGazCAQCyBfBKvo7APf8PpvNAgC01giFNh+24zhyTvu4bDaLYDAo+0QikXXPs7q6img0WvR3KysrAIDKykrPdc05s9kstNb3xJBMJhEOhwEA0WgUq6ur8tqQyWTk3kOhkMRsfgfAsy2Xy92zDYBcH7h3bB8FJpZQKCTXchxH7rcwHkOpcc1kMnKMUkrOWSp2x3Fkn0gkIvutd/711pHWuui1MpmMjHE4HJbX2WxW5tI+znEceR2JRO752ZBKpeR1RUWFxFCKYrHZMW9mvh3HKRrzZshms7IuC58dc20zNkDp+S9GqbHPZrMyfrFYTPZJpVIyZps9z/3Esx5mDB7V+e4XvgMnhBCfwgROCCE+hQmcEEJ8ChM4IYT4FCZwQgjxKUzghBDiU8quEa6n2xjdz2CrUBvphZlMRn5na0226qW1ltdGewPuVQ2NzhcMBj0anDkmnU7LNcLhcEkdzeyvlCq6T3V1tefnYvuEQiHPPdtjUmx/8/vV1VU5LhgMesbPjJn5r9nHPkcpBcweN3N9Wwu156HUuGitkU6nAcCjf5W6N6216GOhUOiedQLcq7LZepd9n7aOau7RPl+x+y5cs7Z6Zx9rX8dec/a9FFNLlVJFdb711L5iimEul5N47Nc2dozrqbPFzm/HY6+pwn3tdVfsvMXWna2K2nHa5wgGg0UVy1Jzv14M9tibNZ3L5UrOeSmKjXE54TtwQgjxKUzghBDiU5jACSHEpzCBE0KIT2ECJ4QQn8IETgghPmVDjVAp9Q0AnwYwqbU+lN8WB/AdADsADAH4rNZ67mGDsTUlW7PKZrOeKntGuQK8OpFRf1ZXVz2KmK0O2ucxutHq6qqcMxQKyXZbFwTu6mN25btAIOCpvmf2sau1xWIx2SeVSkkMFRUVoiGl0+miFdXs+7LHoZS+ZH5feB373OZ8tkpnj/fa2ppH47Kvb1f8s1UrE08ymZQxsxUt4K4aWKiS2fNcTD10HKdkFT+7UmPhMebe7fPbGF00m83K2ovFYgDu1QmLVdgLhUJYW1u7Jxa7kmI0Gi2pspkY7bFcW1uT7YFAwFNJsZQ6aMbYvg+72qI993bFz1IUaqTFKHyu7HlYT090HEf2LRzjUuNkq4aGdDotVUBra2tlzArPU6yKZSgUkjGz17o5Hrh3fReb/1JVVcvJZt6B/xmAVwu2fQXA21rr3QDezv9MCCGkjGyYwLXWJwHMFmz+DIBv5l9/E8AvP+K4CCGEbMCDfgberLUey78eB9D8iOIhhBCySR76S0ztfjhUsnWIUuo1pVSvUqp3amrqYS9HCCEkz4Mm8AmlVCsA5P87WWpHrfXrWusTWusTiUTiAS9HCCGkkAdN4G8C+EL+9RcAvPFowiGEELJZNqMR/iWATwBoVErdAfDbAH4HwF8ppb4I4BaAz272goU6TqGKY5SeZDKJpaUlAMDi4qIoQ6FQSKr41dbWora2FoC3KfDt27dhPq6xq7LZypfRxcw1W1paAAANDQ2YnXW/s52amvJUKjPHLC4uyuvKykqPsmbOU11dLRrSwsIC5uZcy3J+fl72j0ajqK+vl3uxK60V05Ns/cuu3ra8vCxjlkwmAQBLS0sylnV1dRJXLBYTvcyuvDg3Nyf3nUwmJcZwOCyxBAIBadzc1tbmUdzsMTMxpNNpT3U8E68dj6192RUfFxcX5Zxm7s24xuNxAMC2bdtke2GT4mKqnOM4Etv09DTm5+cBuOvC1sfM8WadtbS0yDoz42Puz/5Y0NbRzP7Nzc0yr/Z1CnU3c87R0VEZ+8bGRrnHSCTi0fPMPslkEgsLCwDcdWCqPK6trcl17fiDwWBJ9a1U9U97u3mGUqmUjN/y8rLE1tjY6NFUAXedmRjn5+elgXM6nZYxq6qq8jzXZp0Fg0G515WVFRmn+fl5LC4uAnCfO6PvNjY2orm5WWK3x8vWjM28zc7OenTbqqoqAEA8HvesL/sZKNRRt5INE7jW+vMlfvXKI46FEELIfcB/iUkIIT6FCZwQQnwKEzghhPgUJnBCCPEpTOCEEOJTyt7UuBC7kajWGmNj7r/QHx0dxYULFwB4laFgMCgaWVdXF/bv3w8A6O7uxvDwMACgr68P586dA+DqaMWq79n6YjAYxL59+wAAO3fuFD3q+vXrorKl02nRmbLZrOhGgUBA1KrOzk688MILAIDdu3eLOnXjxg0MDQ0BcFUoo1FlMhns2LEDAHDo0CHs3LkTgKtUGQVsvSa3Zkxu3LgBALh69SpmZmYAuBqhudfm5ma0t7cDAPbt24fGxkYArpJndKq+vj5cvnwZADA5OelpyGwUraqqKmzfvh0A8Oyzz0qMi4uL6O/vBwCcOXMGAwMDAFy9zOhruVxOlMWenh4Zp127dok+lslkcPv2bQDAhQsXMDg4CAAyXoCrd/X09AAADhw4gKamJgBeBRG4qwPa1e+mp6dx6dIlOf+dO3cAuOvC3KM5R01NDfbs2QMAOHHihNxrKpXC9evXAQC3bt3CzZs35TizDsLhMFpbWwEAe/fulTmuq6sT/VQpJfc1Pj4u43fp0iXRIZ955hns3r3bcz/mWuPj4wC8a2t2dlbWXC6XEw2uu7tb1ndXV5dHiSxG4TozP9vVKMfGxuQZGxsbEy302LFjstbsap9mzG7cuOHRVc0ara+vlzF76qmn0NXVBcCd18lJ998JXrlyRfKDfa+ZTAZ1dXUA3Of30KFDcq9m3DKZjGjJly9flvEeGhqSOGtrayWG/fv3yzqzx0sptemGx+WA78AJIcSnMIETQohPYQInhBCfwgROCCE+hQmcEEJ8ChM4IYT4lLJrhLa6ZzAaz+zsLK5duwYAOHfuHH7yk5/IMcUajMbjcVH+stmsVCpbWFjA9PQ0AIiCZDDV2lZWVkRDikQiUvEuEonIPhMTE6Jrra6ueqqQGf1pcnJStKiDBw+ioaEBgFul0GiQ586dE2UtHA6LqjY/Py8K4NDQED71qU8BcNU6o2LZDYBDoZDcezKZFF3v1KlTAIDe3l5RpeyGwrFYTOICIEpZJBKR2Pv6+vDee+/JuW11yqhYdoW2VCol2tzCwoLoXe+88w5GR0cBuIqluQ+llGiE27Ztk3lTSsn9jY+PSwwffPCBZ+7MeIfDYY+m+PzzzwMAWltbPc2Li1Xcm52dxZkzZwAA7733nmiYxbTNxsZGUeMcx5GKjyMjI+jt7QUAnD17VlRAx3E8TZLN+fr7+/HSSy8BAJ5++mlZx+l0Wube1l7PnDkjc1VTUyM6XSwWk2Onp6flOTlz5oy8npubK1qF8caNG5iYmAAAvPTSS6ImVlVVyf3aim2hJmfmx3Ec0VSvXLmCH/7whwBc3fbw4cMAgKamJtF8TSxXrlzBhx9+CMB9FsyY2ZUG7cqc9tpqbm4WnfTDDz8UZXJ5eVnGG7jb1PrmzZsS48c//nHRXhcXF0VR/cEPfiDK8czMjIxBOByW2O2qoYcPHxbVFYBnzLYavgMnhBCfwgROCCE+hQmcEEJ8ChM4IYT4FCZwQgjxKWW3UIr1ezTfcs/Pz0vRm9OnT8s30d3d3di1axcA9xtq8439zZs3pXdePB6XokE9PT1SNMjYDubapjfl1NSU2BvAXdOiqalJClVVV1d7jreL+phv9U+dOiUmRzgclj6Rtj1SXV2Njo4OAG7PTbPP8PCwfDN+6tQp+Ra+urpa7A3groEB3O2FODU1JUbF+fPnAbiWhRmDzs5OsXLu3LkjVs7p06fFkKipqRG7YmZmRvZPJBI4evQoANd+MPtXV1dLsZ/m5mYpAOU4jhgd09PTSCQSANx5M/FEIhH51r61tdXTE9PYQBcvXpQ5mZyclDFramoSM2hkZETGLBAIiDUQj8c9PToNwWBQbIiVlRWZt2Qyic7OTgBuwSlj3di9To0BEo/HJfZMJiNrpb6+XgqQ2ebG5OSkmCF9fX1y7s7OTrElZmdncfHiRQBuAauRkREA7ryadT81NSX3XVlZKdfVWks8sVhM1kpra6sUKnMcR+yNoaEhMZJaWlpk7O0+m/YaK8RYI8lkUmI+f/68rLtbt27J2l1aWpI1aq55+fJlXLlyBYC7PkyRKLvg282bN2Vec7kcampqJEZzvkgkImvLLlQFwHOvZn/biBkbGxMT5sKFC/KMHzhwQPaZmJgQW8wYZGbMzPyaZwFw84Ddh3Ur4DtwQgjxKUzghBDiU5jACSHEpzCBE0KIT2ECJ4QQn8IETgghPmVDB0Yp9Q0AnwYwqbU+lN/2NQC/BmAqv9tXtdZvbXQurTUcx7lH9zK6XTqdlkI0d+7cwXPPPQfALcBjeijOzs5KEZupqSnR/Obm5nDkyBEArj5kCjY5jiMaWS6Xkx6QIyMjom7lcjlRsXp6etDW1gbA1eDsPodG6XIcR3rqzc/Py/n37t0rhYLa29tFzeru7hYNqb29XRSp69ev46233GF79913RaE8evSop3enXTTHKFJzc3PS39EUfYrH4/jkJz8JAHjhhRdEmXv33XdF4/roo49En+vo6BBFLJvNSl/B48eP49VXXwXgao92H0dzH3axq1QqJQpiOBzGgQMHAAAvvvgiuru7Abj6ldG+otGoKIjZbFbUzsHBQSkyVF9fL0WgDh8+LHG+//77+OCDD2R/Mw979+4Vxcwmm83K+kqlUnKeeDyOZ599FgDwMz/zM6LfmfvL5XJy39XV1aKQtrS04MSJEwDcomCmyFFtba0oZgMDA/jud78LwC0wZop7zczMoLm5WWIxhccASOxtbW3yfESjUVlbkUhElLWGhgYp0mTrhbW1tTIvS0tLOHnyJAC3v6xZC+Pj46KOmvleD8dxZMxWVlZkzQ0PD8ucm/gAt6iUWaOmQNzY2Jhopo2NjXjllVcAAJ/4xCekWNybb74phczGxsZkbGKxmKirR44ckeu0t7d77vVHP/oRAO9zPTU1Jfc6MTEh2mM6ncbBgwcBAJ/+9KdFBT179izeeOMNAO5cmX6nCwsL8sxWVFTI87ieelkuNvMO/M8AvFpk+x9orY/m/2yYvAkhhDxaNkzgWuuTAGbLEAshhJD74GE+A/+SUuq8UuobSqn6RxYRIYSQTfGgCfyPAewCcBTAGIDfK7WjUuo1pVSvUqrXfP5MCCHk4XmgBK61ntBaZ7XWOQB/CuDZdfZ9XWt9Qmt9otiXTIQQQh6MB0rgSqlW68dfAXDx0YRDCCFks2xGI/xLAJ8A0KiUugPgtwF8Qil1FIAGMATg1zdzMaVU0YpxRpXSWovGFQqFZHtNTY2og6urq2hqagLgKkZGT6qtrRXVJxqNigKWTqdF+4lEIrJ/f3+/KEbd3d146qmnALiamNHO4vG4VDtcXV0VnUopJUrS4OCg9Ik8evSo6IjRaBT79+8HAFERAVdJMyrU8vKy6GsVFRWiXQWDQbnfiooKT6U783pmZkYquZl4jx8/LlUEAYgO+eKLL0rFxJGREVHBuru7RY9bWlqS8yQSCblvU7XN3Lf5ORKJyP7ZbFbGOBqNShW6hoYGUb2UUlKxbm1tzdO/0tz3uXPn5L6PHj2KvXv3ypyYsT948CBu3boFwK0YZ5SxpaUlOT9wt0diIBAQrW1tbc3Tk9WMZTQaFaXO3JNdqQ/w9mE195TNZmVus9msrLlEIiFr0e6VWVVVJdesr6/Hiy++CMBVV41Ol06npSqfibOQYDAoKqip9miuZcdrlMXGxkbRMzOZjJzTrpiptfZU1jNzEo1GZexPnjwp/UBbW1tFpzSKqjmPUUSNZmf3nK2vr/f0VTVj1tzcLFqiqQ4IuPNo7rWlpcWz/szzGwgE5F4TiYSs9ZmZGRnLsbExUZTr6+vxzDPPAHCrGhoV9Omnn5Z5+MEPfiB9XgcGBqQypd0X134Gis1TOdgwgWutP19k89cfQyyEEELuA/5LTEII8SlM4IQQ4lOYwAkhxKcwgRNCiE9hAieEEJ+ytR0589jNf03D1cbGRqk0d+7cOVGMFhcXpYEpANH2EomEaFDhcFh0Mbt62OLiouhU/f39oiR1dHSImhiJREqqW0aLGh0dlfOEQiFPzEaRsqvvOY4jal0wGBTda35+XvQq4G51uFgsJjHYFQAL4zH3Zc6XSqVkX7vSnFJKYk8mk6K1ra2tearvGS3xypUrMn7Nzc2iddn/EMvWy1ZWVkTpymQyomL19fWJxhWJRGSuGhsb5fXy8rKnyqM9b6a6X0VFhSilbW1tol4CEGVsenrao5cacrmcjH0mk5F7n5ubk/VVX1+PoaEhAPBUFzT3G4/HPc1sTby2Pjk7OysV9Pr7+6UCYUtLizTktmOLxWKyVqqqquT8ly5dkuqSpnqnid0QDAZFx81kMqLGzs/Pyzzfvn0bfX19cq9mzOxqmLlcrqT+Zs6/sLAg43Tr1i1RBO0m0qOjozI/Jj7gboXCRCIh9zo7OyvNuGdmZmQsb968Kc9jd3c3GhoaZGzMsY7jyHjba9dWcJPJpGzftm2bvLYrUTY1NYlyum3bNrmnSCQi+qxSSnJOMpmUebBV5ycBvgMnhBCfwgROCCE+hQmcEEJ8ChM4IYT4FCZwQgjxKUzghBDiU7ZEI3Qcx1PpzdDQ0ICenh4Artpnmte+8847uHz5MgBX4TK6Wzwex7FjxwC4Vdnsxqo2Rq2yG5WOjIyIJnbgwAGp3GdXqQO81ceMwnT16lVpQFxZWYk9e/YAcCu0GRXKjiEcDss5g8GgNFYeHBzE9PQ0AFdhMo1q6+rqPMcbtc5WmCorK0W1MtreyMiIxGW0PsCtpmaq9o2MjMhxyWRS4o3FYqKqXb9+XfS8TCYjClpHR4c0bT5+/LjohRUVFZ4mxUaxPHnypGxXSskY79ixQxoK19bWiq61uroq+1dXV4tyF4lEZOzr6upEgwsEArIW7AbB9vxFIhFRwOwKgysrK7h27RoAV7Mzx5g1YTfGPnz4sFSjsytFzs7OynjfuHFDqtfdvn1bxnv//v1SIdJWXQsrHZr7CIfDsl7t6oKlGugmk0nRagcHB2XeLl++LPe3trYmzaW3b98uWp6tJpo4AHcOjXJ3+fJlvP/++wBc1e/QoUMA3GfGrN2hoSG5r2AwKCqmucd9+/bJOJ0+fRrvvPMOAFcPtjVJU+Xx0KFDopkarc+czx4Tw9TUlIz98vKyHNve3i4xpNNpmbfq6moZg1gsJs9XNBqVtRWLxaQR9MLCgowHcPd5tMdsq+A7cEII8SlM4IQQ4lOYwAkhxKcwgRNCiE9hAieEEJ+yJRZKJpPxfAtvfzNviszYxZgGBwflm/ZMJiNFdNra2tDa2irnsO0D+xt1Y2TYdkA2m5Vjd+7cKddzHMdTuMh8U6+Ukm+ib9y4IebHrl27xJxpbGyUe9Faizlg2yNLS0u4evUqAPdbeFOIqL29XXpAJhKJkgVzzLg1NjaK/XLnzh0Zp7feekvGz8QyMTEhFsDc3JzHPjDf/O/fv1/iDQQCcv3p6WkZ+2vXrsl5AoGA9HRMJBIylgcPHsT8/LzEasYslUrhwoULAFzLxVgXL774orxeW1uT+7OLWdkUmhMmZqWUHBsMBj29Cs32pqYmHDhwQPY3+wQCASmqZBduMnOczWbF1onH43JPc3Nz0hv1/Pnz0nNxcXFR5nVtbc1jaBjLxsZxHDmn3cM1FApJ7PZxWmsxKhYXFz29G2/cuAHAXaPGSGlqapL47fOEQiGPoWNYXl6WglqXL1+WwlyNjY04cuQIALeXpDl2dXXVU2zO9Ak1toZtDq2srMi5q6urpQhVZWWlrP/a2lqPfWLft4kzlUrJeX784x/LGq2qqpJetDt27JA5dhzHY3aZ4lu23WMbNNFoVH63vLx8z7ozlLKDygXfgRNCiE9hAieEEJ/CBE4IIT6FCZwQQnwKEzghhPgUJnBCCPEpG2qESqlOAH8OoBmABvC61voPlVJxAN8BsAPAEIDPaq3nNnPRQkXOaFNzc3OiLNl9/MLhsGhFS0tLokfNz89Lz8Xa2lopflRdXS16TzabFU1tcHBQzh+JRKQwU1tbm+hJyWRS4rF7SWYyGSmENTAwIHpSV1cXOjo65LqGXC4nqtLa2ppoVtevX8epU6cAuMWBTEGoI0eOSPEko1IWjo/dwzCRSEhhIaNTXb16Ve5vfHzcU8jHaFAVFRVSzCqRSEiRpsrKSlHsbDVqdXVVilOdPn1aXvf29krxrba2Nhw+fFjGw9xrMBgUTWx6elp6NF65cgVXrlwB4OqTZn4KsYsGGbLZbEl1y+7LaMYslUqJOtfZ2YmXX34ZAKTAlDmn0fiMFnj16lVR8qqqqqQQV2VlpWis1dXVsoYcxxF1MJlMim55+/Zt6QFZUVEhxbLMOcx9FupsgFtQyahvhWNh72PWUEtLiyh84XBYnhPgbu/Q/v5+6eHa2toqOmIkEpFrLC0tyfxcvHhRxmb//v2yNgOBgMzt2tqajHc6nfYUFgPcdW7U0qqqKhmDRCIhcS0tLXlUTjPejuPIvNqq8NTUFE6fPg0AeO+99+S+Dxw4gOPHj8v9GW04k8nIsfY6KcSMQSAQkP3W23+r2UxkGQC/qbU+AOB5AL+hlDoA4CsA3tZa7wbwdv5nQgghZWLDBK61HtNaf5R/vQTgCoB2AJ8B8M38bt8E8MuPK0hCCCH3cl9/N1BK7QBwDMCHAJq11mP5X43D/YiFEEJImdh0AldKVQP4GwBf1lov2r/T7gdgRSubK6VeU0r1KqV6TSMDQgghD8+mErhSKgw3eX9La/23+c0TSqnW/O9bAUwWO1Zr/brW+oTW+oT58oIQQsjDs2ECV+7Xsl8HcEVr/fvWr94E8IX86y8AeOPRh0cIIaQUm6lG+DEAvwrgglKqL7/tqwB+B8BfKaW+COAWgM9u9qLRaNTTS84oQP39/aLY3b59WxSto0ePYufOnQBcfejdd98F4Op8586dA+BqUEaPikajotCtrq5KlTi7QltnZ6doc6Y/HuDtSWhXtZuenhYdbGpqCs3N7kf+e/bsES3PrugWCARESUomk9Kf8MyZM6KnRSIRqZz2/PPPyzntSnnFKiyamE38Zp+dO3eKrpXNZmX77OysaGupVEoqB9bW1oqC1tDQgF27dsn5zbG5XE6q3Wmt8f3vfx+AW5lwYGAAgFv1zdyHUcHM/RkFbX5+XuLv7++XvqDDw8NSdTAWi8n+S0tLorjZBIPBolplIBCQ6nihUEj0u1wuJ6/j8bjoqHaFyGw2K3GbypJvvPEGTp48CcCt9mj6I+7du1cqONrVM/fu3Sv65OzsrBz77rvvyhrt6emR+7ZjsXt1mngAV6ErVgVPKSXzmUgkPNUWzdhMTU1Jhb7e3l7cunULgFsB0zxLLS0tngp9ZvxGR0flOfzJT34i+9h6biQSkT61g4ODompeu3ZNniez70cffSTP3b59+/DMM88AcHusmnG9fPmyKH+nT5+WZ7mrq0vGO5VKiaJ4/vx5iTGVSsm8PfPMM/K6qqpKYo9Go/I85nI5GWOttWx3HEfm0HEcT39WM97F1NatZMMErrX+MYBSUb/yaMMhhBCyWZ5cQ50QQsi6MIETQohPYQInhBCfwgROCCE+hQmcEEJ8StmbGhu9zaiDWmup9jU2NiZqkuM4Up3vxIkTogbZOtrc3JwobuPj46KgZbNZUdDspryDg4Oijj377LNSTc/W86LRqKhbWmvRigYGBqRCm9ZaGrDu3r1bdDBba7MrEF67dg0ffvghALcaodGTnnrqKVGqtm/f7lHJjNJVUVFRVF0KBAKiV5lGs+3t7aIRmhgAt6KcaXzc1PM3ShQAABbDSURBVNQk1eAqKipEp4pGo56qa+Y+7CbPFRUVsk8mk/E0r7V1R1MVUikl+9vKYjAYlLnSWsv2eDyOoaEhAG4jZqN/JhIJaUw9PT3tqbJnmlHX1tZ6tEDz2h5Tu0Kkic/EY/YzKue2bds8KqWZD8dxZL2Ew2EZm/3798t8j46OSoXI8+fPS7zLy8uiKzqOI+vGjimbzcq4rq2tyetCTDzBYFDGz465o6NDqmPevHkTFy9eBODqhbYqZ2LIZDIeZdHEGQgE5H6Hh4dF9QMgz9WlS5dk/BoaGmRuzdgMDg5KvAcPHsQLL7wAwK0WaLTAbdu24Z133gEAnD17VqqMTkxMiAo4Pj6OS5cuAXDXtBnXPXv2SHXJgwcPisaolJL10djYKOtyfn5ejl1cXJTt6XQa09PTANy5MvHX1dXJ6yetMuGTFQ0hhJBNwwROCCE+hQmcEEJ8ChM4IYT4FCZwQgjxKUzghBDiU8qqEWqtRfGyq4EZBWllZUV0scrKSo92ZvQ4x3Gkmp7dFHVubk50J1v/GxsbEzVtamoK7e3tAFw10Wh4KysrUm3Mjm1tbU00p+HhYdHaKioqsGPHDgBuQ1+7mpnRjVZXV9Hf3w8AuHDhgmhcyWRSmhE//fTTUhmucEzMaxu78W02m/WohsBdpc5gxnJpaUmUr5aWFo9GaM5p63GO43iUPNOsd3FxUfavq6uTptPZbFb0sm3btnmq6ZmGxXaFyEgkIueprq6WeOLxuDSOnp2dlTlPJpMyD3fu3PFohGaNJBIJmcPCsTN6XCqVEi0vEAiInhYIBOR+TdPm+fl5iTEWi4n6aVesS6fToqvaFS0dx5FYQqGQ3IetrNlNje3qeADkWlVVVbLN1jQzmYynEbQ5p32tSCQi17CbI9vVB+1rptNpOU9nZ6esUZtsNutpXmzWRUtLizwD1dXVUp2zqakJANDX1yfH2cqm1lrWbkNDg8QbDofl3LOzs6JD3rp1S3TcyclJeX57enqkcmk8HpfnIpvNyjORSCREmZyamhLNc35+Xs5vN6ZeXV31NEm3dVRbO95qrZDvwAkhxKcwgRNCiE9hAieEEJ/CBE4IIT6FCZwQQnxK2YtZmW9tzbfPAKRPYE1NjVgiZ8+elV6CjuNI/8dUKiVFb4aGhuSb7ra2NjEMQqGQfOM8NDQkvfPq6+vxsY99DIBruZhv9m1zAoCnf6QxWPr7++Ub/l/8xV+UeNbW1lBTUyPXXVlZkeuaON977z0punXs2DEpzJVKpXD27FkA3m/nu7q6pCdgJpPxFJwy5HI5uV9jTiSTSRnfiYkJ9PX1SezG1ti3bx86OjoAuN+um2MHBgbk2Lq6Ooklk8ngo48+AgCcOnVKtu/bt08sgJmZGSkCND8/L3O7bds2MQIuXbqE3t5eGSdTNKqrq0tiO378uNgs/f39sv/S0pIYNR988IHEnEgkxAaKRCIeO8CMWSAQkMJMo6Ojcn6ttdgH2WxWzBZTROny5csyHt3d3RLj8PCwGCCZTEbW2fDwsNgjw8PD+Id/+AcA7to+fPiw3KuxVSoqKjzFo8yxq6urYoqk02m5j1QqJWO/sLAghtPk5KSsi/r6etlndnZWnp8LFy7IXO3cuVPWq00sFpNxCgaDeOmllwC4ppQpTpXJZGQeYrGYpyelif9Tn/qUPBt2MTLzXFy/fh3vv/8+AODQoUNiF507d07OHQwG5bmOxWK4cOECAODv/u7vcP78eQBusa49e/YAcOfeFGubnJyU57q1tVXutbq6Gt3d3QDc3rgmhnQ6Lc/jzZs3ZXs0GpUicT09PbK27MJymUxmy3tk8h04IYT4FCZwQgjxKUzghBDiU5jACSHEpzCBE0KIT2ECJ4QQn7KhRqiU6gTw5wCaAWgAr2ut/1Ap9TUAvwZgKr/rV7XWb21wLoRCIWSzWVG0lFJStKetrU2UnuXlZdGH7ty5I0pZLpfD6OgoAFcvNDpaZ2enFEVyHAfj4+MAIEVrALdgjtm/rq5ONK5IJOIpFmSYmZmR84yOjqKzsxOAq0WZIjnV1dWeAkFGpxsbG5P4b968KUpVKBSSAki2FhiLxdDW1gbAVQ2NDhaPxz3ntwt2Gf3y6tWrAFz1bW5uDoCrFJqiS9FoVHS75557Tu5Day3xnj9/Xsa1sA+j0ciUUqJu9fT0SLGfiYkJXLt2DQBw5swZOc4u0DU/Py+amq3/HThwwNOX0aheFy5cwAcffCCxmblKp9Mybrt375Z47HGye2KurKyI/jkwMIDTp08DAEZGRmSfUCgk5zcq28rKCrq6ugAAu3btkhhv374tWuXIyIioiDYrKyuybhKJhMS4Y8cOT1EkGxNLbW2tFFSKxWKor68H4GqHZt1MTU3JeF+8eFG0xmAwKOsjl8uJopdOp+Veenp6RNW1C3CFQiG5l1gsJr/LZrOeImt2T0+jZG7fvl00wra2NplDs56vXbuGgYEBAO5z9PbbbwNw59WstZmZGbnv/fv3S8G6ZDIp6mBfX58opOl0Wo69evWq5JBgMCixHz58GMePHwfgFtZ67rnnALjzZubnRz/6kawz+5np6emRXFRTU+N5Vg12z9etYjMeeAbAb2qtP1JKbQNwRin1w/zv/kBr/T8fX3iEEEJKsWEC11qPARjLv15SSl0B0P64AyOEELI+9/X+Xym1A8AxAB/mN31JKXVeKfUNpVT9I46NEELIOmw6gSulqgH8DYAva60XAfwxgF0AjsJ9h/57JY57TSnVq5TqNZ/ZEkIIeXg2lcCVUmG4yftbWuu/BQCt9YTWOqu1zgH4UwDPFjtWa/261vqE1vqE+ZKREELIw7NhAldutZavA7iitf59a3urtduvALj46MMjhBBSis1YKB8D8KsALiil+vLbvgrg80qpo3DVwiEAv77Zi2qtpUpdNBoVRau7u1s0npqaGtG1UqmU6IDBYFB6Mba1teHpp58G4CpDZns6nZbzRCIR6ZfX2dkpPShra2uLVhgD7vZQzGazoso1Nzd7VCxT3c3WwmzlKpfLyX1t375d+gTW1dWJDmb3NayrqxNVaWFhQcancNwMSilPpTrA7QtqPqbK5XKiOu7evVuUqMOHD4tylU6nRV+LRCJyzeXlZRmTlZUV0TN37dolvRKPHDki2tnq6qqnh6ZR8RzHEc0qGo1KFcTDhw/LeTo6OuS+AoGAVMGLxWK4fv26xGBX3Nu1axcAV4ncu3evnN9gK6H2+qqurhbdbXl5We7X7hlpxmbXrl04evQoALdKoqmwuLS0JOdIp9OyVtbW1uQ+QqGQqHR79uzBCy+8IK/NsTbhcNjT39FU0Gtvb79nfRns/qK2Amk0v8rKSjnn7t27pbLesWPHsNHfhEOhkEddLUYqlZLn4emnn5Yx7+jokPObuX/llVdEC7x48aJonRMTE3JcdXW1PL8vv/yyPKerq6tyrw0NDTKXNTU1sj2bzcp9a61FL5yfn5c5bmtrk7mdmpqS3qtDQ0NSibKyshIHDx4E4K4tk1vi8bjkAZti6nG52YyF8mMAxWomrut8E0IIebzwX2ISQohPYQInhBCfwgROCCE+hQmcEEJ8ChM4IYT4FGWraY+bEydO6N7eXo9uV1idzeiCk5OTUsFvYWFBmqJGIhHRoxoaGqSymq1GOY4j5xkdHRVtL5FIFK3EZpPNZkUHS6VSouWNj4/LMc3NzRKDUkrUMKWU6IuTk5NSMW5xcVHUpsrKSuRyOTm/0fVqampEu9q+fbtU67ObPyulPOqSGR/TiHdkZETGNRgMinLV1NQkleGMSgW46ptRukZGRjAxMSFjYLSpxcVFqYjX1NQk1RwTiYSoZrOzs1Ld7datW6I1Oo4j+8RiMdEau7q6JJ5cLuepTGnm+datW1J5zm7oa44341SsQW+pRrOzs7NSFW9kZEQUs2AwKMeY8WlpaRHtMR6Py5qYnp7G4OAgAHdNmLVlEwqFRInr6OiQBtX2XAJ3dVWllIzZjRs3ZA1t375dxj4ajcrcJ5NJWd/j4+Oio66trUk8FRUVMv/xeFzWvYnFXL/UWBWrsmfva1f8HBsbk991dnbKPNvnMpULb9++LfHaGmt1dbU8U52dndJE2nEcaeA8PDzsGTPz2m4IbquWLS0tHm3YjM3i4qI812NjY6K9VlRUyPpub2+XxsqlKkiWE6XUGa31icLtfAdOCCE+hQmcEEJ8ChM4IYT4FCZwQgjxKUzghBDiU5jACSHEp2yJRqi1LqkvmXjW1tZE83IcR5ShUCjk0faMhhQMBj2V3oxOZFf1i0QiG1ZZK2y4bMhkMnJO+xzZbNYTj2F1dVXUQVs1i0Qisp9drS8Sicj+sVjMoy6VGisTj1Hv1tbWRP+zGwoHg0Gp1qe1lu32+DmOI/qarREGg0GPumgUyFLjvby87FG5ilVsC4fDHu3LriRoz5tZC47jyDxu27bNo+MVzm/heewGx3YVTLtxs621mn2rqqrktb1vLBaTn824F7u2+TkajXq0VKP22THaY7SwsCDb6+vrPeNtYzd5tqtn2nquWae2Zne/FfQK84OJJxAIyLXW1tZkHdvPhq352eNuz40dr5nXcDhcdI1ms1nRLTOZjEerNMfaz0osFvOMt4nBvic7zwQCAc84mXutqKjwNHY21yhnNUJqhIQQ8k8MJnBCCPEpTOCEEOJTmMAJIcSnMIETQohPYQInhBCfUnaN8PTp0/docaW0M6MhAXf1ILtKWi6Xu6fRr9nHvkap5sWlthfD1tHWw9YgbVXObLcr3xUeZ7YXu6f14jH729tyuZxHU7Nj3+i+M5mMKFThcNizn61TFYvRnp9S423Oba5lK46mOW04HPYoaUbFtJVDO87CinFGDbOVtGw2KzHZ92U3wjVEIhGPxmjGrzAmW9Wz79PW7cxrWy8sRSmNtZBSz22xY7LZrKeKX7mq69nrsph6Z48TAM99m/nLZrMebdRWJs1asKsqrrf+DIXPcrHnp1Sj81wuV1QbftxQIySEkH9iMIETQohPYQInhBCfwgROCCE+hQmcEEJ8yvqVnQAopWIATgKI5vf/a631byulugF8G0ADgDMAflVr7ZQ+k5zP87NtoJTat9D+sI2OYtjWx3qGxEbfItt2gl3gqdh9FF7XLvYTDAaLGhj2dvub+vUK5tjnL4xFKSXXLDR07OM3sl1CoZDn2357n2Jjbt934bmKXbfQALDnqlTRJWMc2AWQ7OJDhdeyTQFjithxFb42+9vzY/axzRebwmJnBjt222wovO/CHpOA16ZxHGdD42EzJkThOrMLwxV7/gr7YRazkOx7sQuKFVpL5jqlYi9mgwAoanCVOqf9unBcN1OEymxfr9CdfexG41FONvMOfBXAy1rrpwAcBfCqUup5AL8L4A+01j0A5gB88fGFSQghpJANE7h2SeZ/DOf/aAAvA/jr/PZvAvjlxxIhIYSQomzqM3ClVFAp1QdgEsAPAdwEMK+1Nn9vvAOg/fGESAghpBibSuBa66zW+iiADgDPAti32QsopV5TSvUqpXqnpqYeMExCCCGF3JeForWeB/CPAF4AUKeUMp/6dwAYKXHM61rrE1rrE4lE4qGCJYQQcpcNE7hSKqGUqsu/rgDwswCuwE3k/yq/2xcAvPG4giSEEHIvG2qEAFoBfFMpFYSb8P9Ka/1/lVKXAXxbKfXfAJwF8PX7ubDdh84uIFOsGJSNrT0VFrYqpvIUFrYqha2m2VpeKU3NVt/Ma631PUqTwdaQim1fT2GylT67eFKhAna/KlMul/MUfbJjKFYkyu4Lal/LHrNC5WujgkaF911KTzNxBAKBksWeTI9Kuwdo4XrZSHEstc0uiGX3MbV/b8dl93G0e6mWKkL1oEXlCu+vWGE4W6Vcb7xLxWXHVizOcDgs62UzvW4Nhc+W3Q/V9LK013mp50sp5dE4N+p7a1/LXMNgP2vmXiKRSMlxKmcxwGJseKda6/MAjhXZPgD383BCCCFbAP8lJiGE+BQmcEII8SlM4IQQ4lOYwAkhxKcwgRNCiE8pa09MpdQUgGUA02W76OZoxJMXE8C47pcnMa4nMSaAcd0PT0JM27XW9/xLyLImcABQSvUWa865lTyJMQGM6355EuN6EmMCGNf98CTGZOBHKIQQ4lOYwAkhxKdsRQJ/fQuuuRFPYkwA47pfnsS4nsSYAMZ1PzyJMQHYgs/ACSGEPBr4EQohhPiUsiVwpdSrSqlrSql+pdRXynXdInF0KqX+USl1WSl1SSn1H/Lbv6aUGlFK9eX//MIWxDaklLqQv35vfltcKfVDpdSN/H/ryxjPXms8+pRSi0qpL2/FWCmlvqGUmlRKXbS2FR0b5fK/8mvtvFLqeJnj+h9Kqav5a3/PKse8QymVssbtT8ocV8l5U0r9l/x4XVNK/bMyxvQdK56hfOevco9VqZyw5etrQ0y5yMf5B0AQbhu2nQAiAM4BOFCOaxeJpRXA8fzrbQCuAzgA4GsA/tNWxGTFNgSgsWDbfwfwlfzrrwD43S2KLQhgHMD2rRgrAC8BOA7g4kZjA+AXAHwfgALwPIAPyxzXzwEI5V//rhXXDnu/LRivovOWX//nAEQBdOef1WA5Yir4/e8B+K9bMFalcsKWr6+N/pTrHfizAPq11gNaawfAtwF8pkzX9qC1HtNaf5R/vQS3OcWT3M/zM3CbRgNb2zz6FQA3tda3tuLiWuuTAGYLNpcam88A+HPt8gHc7lGt5YpLa/33+m6/2A/gdqwqKyXGqxSfAfBtrfWq1noQQD8eQ6no9WJSbvHtzwL4y0d93Y1YJyds+fraiHIl8HYAw9bPT0QTZKXUDri1zj/Mb/pS/q9E3yjnRxUWGsDfK6XOKKVey29r1lqP5V+PA2jegrgA4HPwPlxbPVZA6bF5ktbbv4P7bs3QrZQ6q5R6Ryn14hbEU2zenoTxehHAhNb6hrWt7GNVkBOe+PX1U/slplKqGsDfAPiy1noRwB8D2AXgKIAxuH+dKzcf11ofB/DzAH5DKfWS/Uvt/v2t7NqQUioC4JcAfDe/6UkYKw9bNTbroZT6LQAZAN/KbxoD0KW1PgbgPwL4C6VUTRlDeuLmzeLz8L5BKPtYFckJwpO4voDyJfARAJ3WzyWbIJcDpVQY7kR9S2v9twCgtZ7QWme11jkAf4ot6DaktR7J/3cSwPfyMUyYv57l/ztZ7rjg/g/lI631RD6+LR+rPKXGZsvXm1Lq3wL4NIB/nX/4kf+IYib/+gzcz5r3lCumdeZtS8dLuc3R/wWA71ixlnWsiuUEPMHry1CuBH4awG6lVHf+3dznALxZpmt7yH/W9nUAV7TWv29ttz/D+hUAFwuPfcxxVSmltpnXcL8Iuwh3nL6Q322rmkd73h1t9VhZlBqbNwH8m7wt8DyABeuvwo8dpdSrAP4zgF/SWq9Y2xPK7S0LpdROALsBDJQxrlLz9iaAzymlokqp7nxcp8oVF4BPAbiqtb5jNpRzrErlBDyh68tDub4thfvN7XW4/yf9ra361hbAx+H+Veg8gL78n18A8H8AXMhvfxNAa5nj2gnXBDgH4JIZIwANAN4GcAPAjwDEyxxXFYAZALXWtrKPFdz/gYwBWIP7meMXS40NXDvgj/Jr7QKAE2WOqx/uZ6Rmff1Jft9/mZ/bPgAfAfjnZY6r5LwB+K38eF0D8PPliim//c8A/PuCfcs5VqVywpavr43+8F9iEkKIT/mp/RKTEEL8DhM4IYT4FCZwQgjxKUzghBDiU5jACSHEpzCBE0KIT2ECJ4QQn8IETgghPuX/AwMIcluo3rQqAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[[0. 0. 0. ... 0. 1. 0.]\n",
            "  [0. 0. 0. ... 0. 0. 0.]\n",
            "  [0. 0. 0. ... 0. 0. 0.]\n",
            "  ...\n",
            "  [0. 0. 1. ... 0. 0. 0.]\n",
            "  [0. 0. 0. ... 0. 0. 0.]\n",
            "  [0. 0. 0. ... 0. 0. 1.]]\n",
            "\n",
            " [[0. 0. 1. ... 0. 0. 0.]\n",
            "  [0. 0. 0. ... 0. 0. 0.]\n",
            "  [0. 0. 0. ... 0. 0. 0.]\n",
            "  ...\n",
            "  [0. 0. 0. ... 0. 0. 0.]\n",
            "  [0. 0. 0. ... 1. 0. 0.]\n",
            "  [0. 0. 0. ... 0. 0. 1.]]\n",
            "\n",
            " [[0. 0. 0. ... 0. 0. 0.]\n",
            "  [0. 1. 0. ... 0. 0. 0.]\n",
            "  [0. 0. 0. ... 0. 0. 0.]\n",
            "  ...\n",
            "  [0. 0. 0. ... 0. 0. 0.]\n",
            "  [0. 0. 0. ... 0. 0. 0.]\n",
            "  [0. 0. 0. ... 0. 0. 1.]]\n",
            "\n",
            " ...\n",
            "\n",
            " [[0. 0. 0. ... 0. 0. 0.]\n",
            "  [0. 0. 0. ... 0. 0. 0.]\n",
            "  [0. 0. 0. ... 0. 0. 0.]\n",
            "  ...\n",
            "  [1. 0. 0. ... 0. 0. 0.]\n",
            "  [0. 0. 0. ... 0. 0. 0.]\n",
            "  [0. 0. 0. ... 0. 0. 1.]]\n",
            "\n",
            " [[0. 0. 0. ... 0. 0. 0.]\n",
            "  [0. 1. 0. ... 0. 0. 0.]\n",
            "  [1. 0. 0. ... 0. 0. 0.]\n",
            "  ...\n",
            "  [0. 0. 1. ... 0. 0. 0.]\n",
            "  [0. 0. 0. ... 0. 0. 0.]\n",
            "  [0. 0. 0. ... 0. 0. 1.]]\n",
            "\n",
            " [[0. 0. 0. ... 0. 1. 0.]\n",
            "  [0. 0. 0. ... 0. 0. 0.]\n",
            "  [0. 0. 0. ... 0. 0. 0.]\n",
            "  ...\n",
            "  [0. 0. 0. ... 1. 0. 0.]\n",
            "  [0. 0. 0. ... 1. 0. 0.]\n",
            "  [0. 0. 0. ... 0. 0. 1.]]]\n",
            "(15000, 32, 222, 1)\n",
            "(15000, 20, 11)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from tensorflow.keras.backend import ctc_batch_cost\n",
        "import tensorflow as tf\n",
        "\n",
        "def custom_ctc():\n",
        "    def loss(y_true, y_pred):\n",
        "        batch_labels = y_true[:, :, 0]\n",
        "        label_length = y_true[:, 0, 1]\n",
        "        input_length = y_true[:, 0, 2]\n",
        "\n",
        "        label_length = tf.expand_dims(label_length, -1)\n",
        "        input_length = tf.expand_dims(input_length, -1)\n",
        "        return ctc_batch_cost(batch_labels, y_pred, input_length, label_length)\n",
        "    return loss\n",
        "\n",
        "def CTCLoss(y_true, y_pred):\n",
        "    # Compute the training-time loss value\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",
        "\n",
        "    loss = keras.backend.ctc_batch_cost(y_true, y_pred, input_length, label_length)\n",
        "    return loss"
      ],
      "metadata": {
        "id": "hGtvRRW-gDPA"
      },
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from tensorflow.python.keras.backend import conv2d\n",
        "from numpy.core.fromnumeric import shape\n",
        "import keras\n",
        "from tensorflow.keras import Sequential\n",
        "import tensorboard\n",
        "from keras.models import load_model\n",
        "\n",
        "def model():\n",
        "  model = Sequential(\n",
        "    [\n",
        "     tf.keras.layers.Input(shape=(train_x.shape[1], train_x.shape[2], 1)),\n",
        "     tf.keras.layers.Conv2D(16, kernel_size=(3, 3), activation=\"relu\", padding=\"same\"),\n",
        "     tf.keras.layers.BatchNormalization(),\n",
        "     tf.keras.layers.Conv2D(32, kernel_size=(3, 3), activation=\"relu\", padding=\"same\"),\n",
        "     tf.keras.layers.BatchNormalization(),\n",
        "     tf.keras.layers.Dropout(0.2),\n",
        "    #  tf.keras.layers.MaxPooling2D(pool_size=(2, 2), padding=\"same\"),\n",
        "     tf.keras.layers.Conv2D(32, kernel_size=(3, 3), activation=\"relu\", padding=\"same\"),\n",
        "     tf.keras.layers.BatchNormalization(),\n",
        "     tf.keras.layers.Dropout(0.2),\n",
        "     tf.keras.layers.Conv2D(64, kernel_size=(3, 3), activation=\"relu\", padding=\"same\"),\n",
        "     tf.keras.layers.BatchNormalization(),\n",
        "     tf.keras.layers.MaxPooling2D(pool_size=(2, 2), padding=\"SAME\"),\n",
        "     tf.keras.layers.ZeroPadding2D(padding=(2,2)),\n",
        "     tf.keras.layers.Dropout(0.2),\n",
        "     tf.keras.layers.TimeDistributed(tf.keras.layers.Flatten()),\n",
        "     tf.keras.layers.LSTM(32, activation='relu', return_sequences=True),\n",
        "     tf.keras.layers.LSTM(11, activation='softmax', return_sequences=True)\n",
        "    ])\n",
        "  return model\n",
        "\n",
        "model = model()\n",
        "model.summary()\n",
        "# custom_loss = custom_ctc()\n",
        "# custom_loss = CTCLoss()\n",
        "# model = load_model('model.h5')\n",
        "model.compile(\n",
        "    optimizer = tf.keras.optimizers.Adam(\n",
        "    learning_rate=0.001, name='Adam'),\n",
        "    loss = 'categorical_crossentropy',\n",
        "    metrics=['accuracy']\n",
        ")\n",
        "# print(train_x.shape)\n",
        "# print(train_y.shape)\n",
        "\n",
        "# tf.keras.models.save_model(model, \"saved_models\", overwrite=True, include_optimizer=False)\n",
        "\n"
      ],
      "metadata": {
        "id": "2BIGTVlR93-I",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c63c1c0f-64ef-4ba8-8d10-90e588967669"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "WARNING:tensorflow:Layer lstm_6 will not use cuDNN kernels since it doesn't meet the criteria. It will use a generic GPU kernel as fallback when running on GPU.\n",
            "WARNING:tensorflow:Layer lstm_7 will not use cuDNN kernels since it doesn't meet the criteria. It will use a generic GPU kernel as fallback when running on GPU.\n",
            "Model: \"sequential_3\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv2d_12 (Conv2D)          (None, 32, 222, 16)       160       \n",
            "                                                                 \n",
            " batch_normalization_12 (Bat  (None, 32, 222, 16)      64        \n",
            " chNormalization)                                                \n",
            "                                                                 \n",
            " conv2d_13 (Conv2D)          (None, 32, 222, 32)       4640      \n",
            "                                                                 \n",
            " batch_normalization_13 (Bat  (None, 32, 222, 32)      128       \n",
            " chNormalization)                                                \n",
            "                                                                 \n",
            " dropout_9 (Dropout)         (None, 32, 222, 32)       0         \n",
            "                                                                 \n",
            " conv2d_14 (Conv2D)          (None, 32, 222, 32)       9248      \n",
            "                                                                 \n",
            " batch_normalization_14 (Bat  (None, 32, 222, 32)      128       \n",
            " chNormalization)                                                \n",
            "                                                                 \n",
            " dropout_10 (Dropout)        (None, 32, 222, 32)       0         \n",
            "                                                                 \n",
            " conv2d_15 (Conv2D)          (None, 32, 222, 64)       18496     \n",
            "                                                                 \n",
            " batch_normalization_15 (Bat  (None, 32, 222, 64)      256       \n",
            " chNormalization)                                                \n",
            "                                                                 \n",
            " max_pooling2d_3 (MaxPooling  (None, 16, 111, 64)      0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " zero_padding2d_3 (ZeroPaddi  (None, 20, 115, 64)      0         \n",
            " ng2D)                                                           \n",
            "                                                                 \n",
            " dropout_11 (Dropout)        (None, 20, 115, 64)       0         \n",
            "                                                                 \n",
            " time_distributed_3 (TimeDis  (None, 20, 7360)         0         \n",
            " tributed)                                                       \n",
            "                                                                 \n",
            " lstm_6 (LSTM)               (None, 20, 32)            946304    \n",
            "                                                                 \n",
            " lstm_7 (LSTM)               (None, 20, 11)            1936      \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 981,360\n",
            "Trainable params: 981,072\n",
            "Non-trainable params: 288\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from keras.models import load_model\n",
        "\n",
        "model = load_model('model_bank.h5')\n",
        "\n",
        "history = model.fit(train_x, train_y, epochs=5, batch_size=32, validation_data=(validation_x, validation_y), shuffle=True,\n",
        "                     callbacks=keras.callbacks.TensorBoard(log_dir='logs/model'))\n",
        "model.save('model_bank.h5')\n",
        "model.summary()"
      ],
      "metadata": {
        "id": "OD7eDDHT980J",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4a89f023-7b16-4fa8-8b5c-a123bf3a3e8b"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "WARNING:tensorflow:Layer lstm_6 will not use cuDNN kernels since it doesn't meet the criteria. It will use a generic GPU kernel as fallback when running on GPU.\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:tensorflow:Layer lstm_6 will not use cuDNN kernels since it doesn't meet the criteria. It will use a generic GPU kernel as fallback when running on GPU.\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "WARNING:tensorflow:Layer lstm_7 will not use cuDNN kernels since it doesn't meet the criteria. It will use a generic GPU kernel as fallback when running on GPU.\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:tensorflow:Layer lstm_7 will not use cuDNN kernels since it doesn't meet the criteria. It will use a generic GPU kernel as fallback when running on GPU.\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/5\n",
            "469/469 [==============================] - 57s 116ms/step - loss: 1.2706 - accuracy: 0.4904 - val_loss: 1.1222 - val_accuracy: 0.5455\n",
            "Epoch 2/5\n",
            "469/469 [==============================] - 51s 108ms/step - loss: 1.2591 - accuracy: 0.4945 - val_loss: 1.1549 - val_accuracy: 0.5415\n",
            "Epoch 3/5\n",
            "469/469 [==============================] - 51s 109ms/step - loss: 1.2572 - accuracy: 0.4947 - val_loss: 1.1092 - val_accuracy: 0.5404\n",
            "Epoch 4/5\n",
            "469/469 [==============================] - 51s 108ms/step - loss: 1.2579 - accuracy: 0.4940 - val_loss: 1.1104 - val_accuracy: 0.5445\n",
            "Epoch 5/5\n",
            "469/469 [==============================] - 51s 108ms/step - loss: 1.2527 - accuracy: 0.4959 - val_loss: 1.1164 - val_accuracy: 0.5419\n",
            "Model: \"sequential_3\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv2d_12 (Conv2D)          (None, 32, 222, 16)       160       \n",
            "                                                                 \n",
            " batch_normalization_12 (Bat  (None, 32, 222, 16)      64        \n",
            " chNormalization)                                                \n",
            "                                                                 \n",
            " conv2d_13 (Conv2D)          (None, 32, 222, 32)       4640      \n",
            "                                                                 \n",
            " batch_normalization_13 (Bat  (None, 32, 222, 32)      128       \n",
            " chNormalization)                                                \n",
            "                                                                 \n",
            " dropout_9 (Dropout)         (None, 32, 222, 32)       0         \n",
            "                                                                 \n",
            " conv2d_14 (Conv2D)          (None, 32, 222, 32)       9248      \n",
            "                                                                 \n",
            " batch_normalization_14 (Bat  (None, 32, 222, 32)      128       \n",
            " chNormalization)                                                \n",
            "                                                                 \n",
            " dropout_10 (Dropout)        (None, 32, 222, 32)       0         \n",
            "                                                                 \n",
            " conv2d_15 (Conv2D)          (None, 32, 222, 64)       18496     \n",
            "                                                                 \n",
            " batch_normalization_15 (Bat  (None, 32, 222, 64)      256       \n",
            " chNormalization)                                                \n",
            "                                                                 \n",
            " max_pooling2d_3 (MaxPooling  (None, 16, 111, 64)      0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " zero_padding2d_3 (ZeroPaddi  (None, 20, 115, 64)      0         \n",
            " ng2D)                                                           \n",
            "                                                                 \n",
            " dropout_11 (Dropout)        (None, 20, 115, 64)       0         \n",
            "                                                                 \n",
            " time_distributed_3 (TimeDis  (None, 20, 7360)         0         \n",
            " tributed)                                                       \n",
            "                                                                 \n",
            " lstm_6 (LSTM)               (None, 20, 32)            946304    \n",
            "                                                                 \n",
            " lstm_7 (LSTM)               (None, 20, 11)            1936      \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 981,360\n",
            "Trainable params: 981,072\n",
            "Non-trainable params: 288\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%load_ext tensorboard\n",
        "%tensorboard --logdir logs"
      ],
      "metadata": {
        "id": "Dco8sw1F9-mx",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 945
        },
        "outputId": "2ddcaa82-a871-48ba-ac20-041649321f62"
      },
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "Launching TensorBoard..."
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "ERROR:root:Internal Python error in the inspect module.\n",
            "Below is the traceback from this internal error.\n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/IPython/core/interactiveshell.py\", line 2882, in run_code\n",
            "    exec(code_obj, self.user_global_ns, self.user_ns)\n",
            "  File \"<ipython-input-35-155764cb9c8c>\", line 2, in <module>\n",
            "    get_ipython().magic('tensorboard --logdir logs')\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/IPython/core/interactiveshell.py\", line 2160, in magic\n",
            "    return self.run_line_magic(magic_name, magic_arg_s)\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/IPython/core/interactiveshell.py\", line 2081, in run_line_magic\n",
            "    result = fn(*args,**kwargs)\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/tensorboard/notebook.py\", line 117, in _start_magic\n",
            "    return start(line)\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/tensorboard/notebook.py\", line 152, in start\n",
            "    start_result = manager.start(parsed_args)\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/tensorboard/manager.py\", line 401, in start\n",
            "    working_directory=os.getcwd(),\n",
            "FileNotFoundError: [Errno 2] No such file or directory\n",
            "\n",
            "During handling of the above exception, another exception occurred:\n",
            "\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/IPython/core/interactiveshell.py\", line 1823, in showtraceback\n",
            "    stb = value._render_traceback_()\n",
            "AttributeError: 'FileNotFoundError' object has no attribute '_render_traceback_'\n",
            "\n",
            "During handling of the above exception, another exception occurred:\n",
            "\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/IPython/core/ultratb.py\", line 1132, in get_records\n",
            "    return _fixed_getinnerframes(etb, number_of_lines_of_context, tb_offset)\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/IPython/core/ultratb.py\", line 313, in wrapped\n",
            "    return f(*args, **kwargs)\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/IPython/core/ultratb.py\", line 358, in _fixed_getinnerframes\n",
            "    records = fix_frame_records_filenames(inspect.getinnerframes(etb, context))\n",
            "  File \"/usr/lib/python3.7/inspect.py\", line 1502, in getinnerframes\n",
            "    frameinfo = (tb.tb_frame,) + getframeinfo(tb, context)\n",
            "  File \"/usr/lib/python3.7/inspect.py\", line 1460, in getframeinfo\n",
            "    filename = getsourcefile(frame) or getfile(frame)\n",
            "  File \"/usr/lib/python3.7/inspect.py\", line 696, in getsourcefile\n",
            "    if getattr(getmodule(object, filename), '__loader__', None) is not None:\n",
            "  File \"/usr/lib/python3.7/inspect.py\", line 725, in getmodule\n",
            "    file = getabsfile(object, _filename)\n",
            "  File \"/usr/lib/python3.7/inspect.py\", line 709, in getabsfile\n",
            "    return os.path.normcase(os.path.abspath(_filename))\n",
            "  File \"/usr/lib/python3.7/posixpath.py\", line 383, in abspath\n",
            "    cwd = os.getcwd()\n",
            "FileNotFoundError: [Errno 2] No such file or directory\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "FileNotFoundError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from keras.models import load_model\n",
        "\n",
        "\n",
        "# text = \"onmltsrqpoihgrezcba lknrvjihgfueiizltflk\"\n",
        "# text_arr = np.array([text[i:i+word_len] for i in range(0, len(text), word_len)])\n",
        "# test_x = np.zeros((len(text_arr), word_len, len(alphabet)))\n",
        "\n",
        "def convert_output_to_text(output):\n",
        "  output_text = \"\"\n",
        "  for i in range(0, output.shape[0]):\n",
        "    for j in range(0, output.shape[1]):\n",
        "      index_word = np.argmax(output[i, j] == 1)\n",
        "      output_text += alphabet[index_word]\n",
        "  return output_text\n",
        "\n",
        "model = load_model('model_bank.h5')\n",
        "\n",
        "for i in range(0, 32):\n",
        "  input = test_x[i]\n",
        "  input = input.reshape((1, input.shape[0], input.shape[1]))\n",
        "  pred_y = model.predict(input)\n",
        "  pred_y = tf.one_hot(tf.argmax(pred_y, axis=2), pred_y.shape[2])\n",
        "  # print(pred_y.shape)\n",
        "  print(convert_output_to_text(pred_y))"
      ],
      "metadata": {
        "id": "N1SHe1J6-E3P",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bcaf8658-32b2-4cf6-e3fc-02e24b80698c"
      },
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "WARNING:tensorflow:Layer lstm_6 will not use cuDNN kernels since it doesn't meet the criteria. It will use a generic GPU kernel as fallback when running on GPU.\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:tensorflow:Layer lstm_6 will not use cuDNN kernels since it doesn't meet the criteria. It will use a generic GPU kernel as fallback when running on GPU.\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "WARNING:tensorflow:Layer lstm_7 will not use cuDNN kernels since it doesn't meet the criteria. It will use a generic GPU kernel as fallback when running on GPU.\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:tensorflow:Layer lstm_7 will not use cuDNN kernels since it doesn't meet the criteria. It will use a generic GPU kernel as fallback when running on GPU.\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0283 8596 0699 6665 \n",
            "0283 5948 1896 0962 \n",
            "0283 8088 0644 6162 \n",
            "0283 5819 8033 4662 \n",
            "0283 8666 6562 6665 \n",
            "0283 5806 3596 8920 \n",
            "0283 8886 0644 6065 \n",
            "0283 5602 0005 9996 \n",
            "0283 8666 0649 6565 \n",
            "0283 5889 0005 9663 \n",
            "0283 5809 0000 9996 \n",
            "0283 5829 0333 6988 \n",
            "0283 5921 1695 2902 \n",
            "0283 8289 2969 0961 \n",
            "0283 8889 6099 6961 \n",
            "0283 6880 4025 6968 \n",
            "0283 8496 4099 6665 \n",
            "0283 5580 4460 0602 \n",
            "0283 6808 0044 6665 \n",
            "0283 5809 0333 1662 \n",
            "0283 5818 1116 1668 \n",
            "0283 6866 6400 6665 \n",
            "0283 0656 6004 6665 \n",
            "0283 6855 5556 6666 \n",
            "0283 8840 9404 6262 \n",
            "0283 8866 0504 6665 \n",
            "0283 8620 6003 6665 \n",
            "0283 8888 0044 6662 \n",
            "0283 6860 0044 6665 \n",
            "0283 8459 6066 5968 \n",
            "0283 8626 6565 6665 \n",
            "0283 5071 0509 2154 \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "7FQBr6WT1DXo"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}