diff --git a/model_gen/.gitattributes b/model_gen/.gitattributes
new file mode 100644
index 0000000..6216e61
--- /dev/null
+++ b/model_gen/.gitattributes
@@ -0,0 +1,3 @@
+captcha_75_25.h5 filter=lfs diff=lfs merge=lfs -text
+captcha_75_25.keras filter=lfs diff=lfs merge=lfs -text
+captcha_75_25.tf filter=lfs diff=lfs merge=lfs -text
diff --git a/model_gen/captcha_ocr.ipynb b/model_gen/captcha_ocr.ipynb
new file mode 100644
index 0000000..27b77cc
--- /dev/null
+++ b/model_gen/captcha_ocr.ipynb
@@ -0,0 +1,886 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "mjAScbd2vl9P"
+   },
+   "source": [
+    "# OCR model for reading Captchas\n",
+    "\n",
+    "**Author:** [A_K_Nain](https://twitter.com/A_K_Nain)<br>\n",
+    "**Date created:** 2020/06/14<br>\n",
+    "**Last modified:** 2020/06/26<br>\n",
+    "**Description:** How to implement an OCR model using CNNs, RNNs and CTC loss."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "wWvlZPBJvl9U"
+   },
+   "source": [
+    "## Introduction\n",
+    "\n",
+    "This example demonstrates a simple OCR model built with the Functional API. Apart from\n",
+    "combining CNN and RNN, it also illustrates how you can instantiate a new layer\n",
+    "and use it as an \"Endpoint layer\" for implementing CTC loss. For a detailed\n",
+    "guide to layer subclassing, please check out\n",
+    "[this page](https://keras.io/guides/making_new_layers_and_models_via_subclassing/)\n",
+    "in the developer guides."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Yq0Pe4Zuvl9U"
+   },
+   "source": [
+    "## Setup"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "id": "5q-xCl8Qvl9V"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2023-08-08 08:50:40.669196: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
+      "To enable the following instructions: SSE3 SSE4.1 SSE4.2 AVX AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import sys\n",
+    "\n",
+    "from pathlib import Path\n",
+    "from collections import Counter\n",
+    "\n",
+    "import tensorflow as tf\n",
+    "from tensorflow import keras\n",
+    "from tensorflow.keras import layers\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tf.executing_eagerly()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "sSm7N--8vl9W"
+   },
+   "source": [
+    "## Load the data: [Captcha Images](https://www.kaggle.com/fournierp/captcha-version-2-images)\n",
+    "Let's download the data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "id": "g3EVJfHBvl9X"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of images found:  10056\n",
+      "Number of labels found:  10056\n",
+      "Number of unique characters:  22\n",
+      "Characters present:  [' ', '0', '2', '4', '5', '8', 'A', 'D', 'G', 'H', 'J', 'K', 'M', 'N', 'P', 'R', 'S', 'T', 'V', 'W', 'X', 'Y']\n"
+     ]
+    }
+   ],
+   "source": [
+    "substitutions = {\n",
+    "    'B': '8',\n",
+    "    'F': 'P',\n",
+    "    'U': 'V',\n",
+    "    '6': 'G',\n",
+    "    'Z': '2',\n",
+    "    'O': '0'\n",
+    "}\n",
+    "\n",
+    "def apply_substitutions(input_string):\n",
+    "    output_string = \"\"\n",
+    "    for char in input_string:\n",
+    "        if char in substitutions:\n",
+    "            output_string += substitutions[char]\n",
+    "        else:\n",
+    "            output_string += char\n",
+    "    \n",
+    "    return output_string\n",
+    "    \n",
+    "data_dir = Path(\"./captcha_images_v2/\")\n",
+    "vdata_dir = Path(\"./validation/\")\n",
+    "cdir = Path(\"./cache/\")\n",
+    "\n",
+    "# Get list of all the images\n",
+    "images = sorted(list(map(str, list(data_dir.glob(\"*.png\")))))\n",
+    "labels = [apply_substitutions(img.split(os.path.sep)[-1].split(\".png\")[0]) for img in images]\n",
+    "\n",
+    "images_v = sorted(list(map(str, list(vdata_dir.glob(\"*.png\")))))\n",
+    "labels_v = [img.split(os.path.sep)[-1].split(\".png\")[0] for img in images_v]\n",
+    "\n",
+    "# Maximum length of any captcha in the dataset\n",
+    "max_length = max([len(label) for label in labels])\n",
+    "labels = [x + ' ' * (max_length - len(x)) for x in labels]\n",
+    "labels_v = [x + ' ' * (max_length - len(x)) for x in labels_v]\n",
+    "\n",
+    "characters = set(char for label in labels for char in label)\n",
+    "characters = sorted(list(characters))\n",
+    "\n",
+    "print(\"Number of images found: \", len(images))\n",
+    "print(\"Number of labels found: \", len(labels))\n",
+    "print(\"Number of unique characters: \", len(characters))\n",
+    "print(\"Characters present: \", characters)\n",
+    "\n",
+    "# Batch size for training and validation\n",
+    "batch_size = 4\n",
+    "\n",
+    "# Desired image dimensions\n",
+    "img_width = 300\n",
+    "img_height = 80\n",
+    "\n",
+    "# Factor by which the image is going to be downsampled\n",
+    "# by the convolutional blocks. We will be using two\n",
+    "# convolution blocks and each block will have\n",
+    "# a pooling layer which downsample the features by a factor of 2.\n",
+    "# Hence total downsampling factor would be 4.\n",
+    "downsample_factor = 4\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "gqn-NjRovl9Y"
+   },
+   "source": [
+    "## Preprocessing"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "id": "MjQltH0Mvl9Y"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2023-08-08 08:57:18.156048: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:995] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
+      "2023-08-08 08:57:18.442949: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:995] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
+      "2023-08-08 08:57:18.443125: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:995] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
+      "2023-08-08 08:57:18.446150: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:995] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
+      "2023-08-08 08:57:18.446487: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:995] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
+      "2023-08-08 08:57:18.446778: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:995] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
+      "2023-08-08 08:57:18.532929: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:995] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
+      "2023-08-08 08:57:18.533550: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:995] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
+      "2023-08-08 08:57:18.533758: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:995] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
+      "2023-08-08 08:57:18.533855: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1639] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 2216 MB memory:  -> device: 0, name: NVIDIA GeForce GTX 1650, pci bus id: 0000:01:00.0, compute capability: 7.5\n",
+      "2023-08-08 08:57:18.534141: I tensorflow/core/common_runtime/process_util.cc:146] Creating new thread pool with default inter op setting: 2. Tune using inter_op_parallelism_threads for best performance.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from skimage.morphology import opening, square, label\n",
+    "from skimage.measure import regionprops\n",
+    "from skimage.io import imread, imsave\n",
+    "from skimage import img_as_ubyte\n",
+    "\n",
+    "def crop_and_fill(image, crop_size, fill_value):\n",
+    "    # Create a new image with the desired crop size and fill color\n",
+    "    cropped_image = np.full(crop_size, fill_value, dtype=image.dtype)  \n",
+    "    original_size = image.shape\n",
+    "    cropped_image[0:original_size[0], 0:original_size[1]] = image\n",
+    "\n",
+    "    return cropped_image.reshape(cropped_image.shape[0], cropped_image.shape[1], 1)\n",
+    "    \n",
+    "# Mapping characters to integers\n",
+    "char_to_num = layers.StringLookup(\n",
+    "    vocabulary=list(characters), mask_token=None,\n",
+    ")\n",
+    "\n",
+    "# Mapping integers back to original characters\n",
+    "num_to_char = layers.StringLookup(\n",
+    "    vocabulary=char_to_num.get_vocabulary(), mask_token=None, invert=True\n",
+    ")\n",
+    "\n",
+    "def filter_image(img, kernel_size=3, num_components=8, min_height_ratio=0.25, max_height_ratio=1):\n",
+    "    # Binarize the image\n",
+    "    binary_image = img < 0.5  # Pixels with a value less than 0.5 will be True (1)\n",
+    "\n",
+    "    # Label connected components in the image\n",
+    "    label_image = label(binary_image)\n",
+    "\n",
+    "    # Get properties of the labeled regions\n",
+    "    properties = regionprops(label_image)\n",
+    "\n",
+    "    # Sort the regions by area (in descending order)\n",
+    "    properties.sort(key=lambda x: x.area, reverse=True)\n",
+    "\n",
+    "    # Create an empty image to store the result\n",
+    "    filtered_image = np.zeros_like(label_image, dtype=bool)\n",
+    "\n",
+    "    # Keep only the largest components that satisfy the height constraints\n",
+    "    for prop in properties[:num_components]:\n",
+    "        minr, minc, maxr, maxc = prop.bbox\n",
+    "        height = maxr - minr\n",
+    "        if height > max_height_ratio * img.shape[0] or height < min_height_ratio * img.shape[0]:\n",
+    "            continue\n",
+    "        filtered_image[label_image == prop.label] = 1\n",
+    "\n",
+    "    return filtered_image == 0\n",
+    "\n",
+    "\n",
+    "def read_and_process(imgpath, cdir):\n",
+    "    img = imread(imgpath, as_gray=True);\n",
+    "    img = np.hstack([img, np.ones((img_height, img_width - img.shape[1]))]).astype(\"float32\")\n",
+    "    img = filter_image(img)\n",
+    "    output_path = os.path.join(cdir, Path(imgpath).stem + \".png\")\n",
+    "    imsave(output_path, np.clip(img_as_ubyte(img), 0, 238))\n",
+    "    return tf.convert_to_tensor((1 - img).astype(\"float32\").reshape((80, 300, 1)));\n",
+    "\n",
+    "def load_data(images, labels, cache):\n",
+    "    os.makedirs(cache, exist_ok=True)\n",
+    "    # 1. Get the total size of the dataset\n",
+    "    size = len(images)\n",
+    "    # 2. Make an indices array and shuffle it, if required\n",
+    "    indices = np.arange(size)\n",
+    "    np.random.shuffle(indices)\n",
+    "    # 3. Get the size of training samples\n",
+    "    train_samples = int(size)\n",
+    "    # 4. Split data into training and validation sets\n",
+    "    x_train, y_train = images[indices], labels[indices]\n",
+    "    x_train = [read_and_process(x, cache) for x in x_train]\n",
+    "    return x_train, y_train\n",
+    "\n",
+    "\n",
+    "# Splitting data into training and validation sets\n",
+    "rx_train, ry_train = load_data(np.array(images), np.array(labels), Path(\"sdir\"))\n",
+    "\n",
+    "def pad_image(image, target_height, target_width, pad_value):\n",
+    "    # Compute the padding sizes\n",
+    "    height, width = tf.shape(image)[0], tf.shape(image)[1]\n",
+    "    pad_height = target_height - height\n",
+    "    pad_width = target_width - width\n",
+    "\n",
+    "    # Check if padding is needed\n",
+    "    if pad_height < 0:\n",
+    "        pad_height = 0;\n",
+    "        \n",
+    "    if pad_width < 0:\n",
+    "        pad_width = 0;\n",
+    "\n",
+    "    # Pad the image\n",
+    "    padded_image = tf.pad(image, [[pad_height // 2, pad_height - pad_height // 2], \n",
+    "                                  [pad_width // 2, pad_width - pad_width // 2], \n",
+    "                                  [0, 0]], constant_values=pad_value)\n",
+    "    return padded_image\n",
+    "\n",
+    "def encode_single_sample(img, label):\n",
+    "    img = tf.image.convert_image_dtype(img, tf.float32)\n",
+    "    # 4. Resize to the desired size\n",
+    "    #img = tf.image.resize_with_pad(img, img_height, img_width)\n",
+    "    # 5. Transpose the image because we want the time\n",
+    "    # dimension to correspond to the width of the image.\n",
+    "    img = tf.transpose(img, perm=[1, 0, 2])\n",
+    "    # 6. Map the characters in label to numbers\n",
+    "    label = char_to_num(tf.strings.unicode_split(label, input_encoding=\"UTF-8\"))\n",
+    "    # 7. Return a dict as our model is expecting two inputs\n",
+    "    return {\"image\": img, \"label\": label}\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "fnwhurZ-vl9Z"
+   },
+   "source": [
+    "## Create `Dataset` objects"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2514\n",
+      "7542\n"
+     ]
+    }
+   ],
+   "source": [
+    "split_index = int(len(rx_train) * 0.75)\n",
+    "\n",
+    "# Move the first 75% of x_valid to x_train\n",
+    "x_train = rx_train[:split_index];\n",
+    "# Move the first 75% of y_valid to y_train\n",
+    "y_train = ry_train[:split_index];\n",
+    "\n",
+    "# Keep only the last 25% of x_valid\n",
+    "x_valid = rx_train[split_index:]\n",
+    "# Keep only the last 25% of y_valid\n",
+    "y_valid = ry_train[split_index:]\n",
+    "\n",
+    "print(len(x_valid))\n",
+    "print(len(x_train))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "id": "k2MZdcpXvl9Z"
+   },
+   "outputs": [],
+   "source": [
+    "train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))\n",
+    "train_dataset = (\n",
+    "    train_dataset.map(\n",
+    "        encode_single_sample, num_parallel_calls=tf.data.AUTOTUNE\n",
+    "    )\n",
+    "    .batch(batch_size)\n",
+    "    .prefetch(buffer_size=tf.data.AUTOTUNE)\n",
+    ")\n",
+    "\n",
+    "validation_dataset = tf.data.Dataset.from_tensor_slices((x_valid, y_valid))\n",
+    "validation_dataset = (\n",
+    "    validation_dataset.map(\n",
+    "        encode_single_sample, num_parallel_calls=tf.data.AUTOTUNE\n",
+    "    )\n",
+    "    .batch(batch_size)\n",
+    "    .prefetch(buffer_size=tf.data.AUTOTUNE)\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "NI0NRV5Ivl9Z"
+   },
+   "source": [
+    "## Visualize the data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {
+    "id": "7GT5RSNgvl9Z"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x500 with 16 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "_, ax = plt.subplots(4, 4, figsize=(10, 5))\n",
+    "for batch in train_dataset.take(1):\n",
+    "    images2 = batch[\"image\"]\n",
+    "    labels2 = batch[\"label\"]\n",
+    "    for i in range(batch_size):\n",
+    "        img = (images2[i] * 255).numpy().astype(\"uint8\")\n",
+    "        label = tf.strings.reduce_join(num_to_char(labels2[i])).numpy().decode(\"utf-8\")\n",
+    "        ax[i // 4, i % 4].imshow(img[:, :, 0].T, cmap=\"gray\",  vmin=0, vmax=255)\n",
+    "        ax[i // 4, i % 4].set_title(label)\n",
+    "        ax[i // 4, i % 4].axis(\"off\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "5pgP4jIIvl9a"
+   },
+   "source": [
+    "## Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "id": "ddaZyWUFvl9a",
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: \"ocr_model_v1\"\n",
+      "__________________________________________________________________________________________________\n",
+      " Layer (type)                Output Shape                 Param #   Connected to                  \n",
+      "==================================================================================================\n",
+      " image (InputLayer)          [(None, 300, 80, 1)]         0         []                            \n",
+      "                                                                                                  \n",
+      " conv_2d1 (Conv2D)           (None, 300, 80, 60)          600       ['image[0][0]']               \n",
+      "                                                                                                  \n",
+      " pool5 (MaxPooling2D)        (None, 150, 40, 60)          0         ['conv_2d1[0][0]']            \n",
+      "                                                                                                  \n",
+      " reshape (Reshape)           (None, 75, 4800)             0         ['pool5[0][0]']               \n",
+      "                                                                                                  \n",
+      " bidirectional (Bidirection  (None, 75, 200)              3920800   ['reshape[0][0]']             \n",
+      " al)                                                                                              \n",
+      "                                                                                                  \n",
+      " label (InputLayer)          [(None, None)]               0         []                            \n",
+      "                                                                                                  \n",
+      " dense2 (Dense)              (None, 75, 24)               4824      ['bidirectional[0][0]']       \n",
+      "                                                                                                  \n",
+      " ctc_loss (CTCLayer)         (None, 75, 24)               0         ['label[0][0]',               \n",
+      "                                                                     'dense2[0][0]']              \n",
+      "                                                                                                  \n",
+      "==================================================================================================\n",
+      "Total params: 3926224 (14.98 MB)\n",
+      "Trainable params: 3926224 (14.98 MB)\n",
+      "Non-trainable params: 0 (0.00 Byte)\n",
+      "__________________________________________________________________________________________________\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "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):\n",
+    "        # Compute the training-time loss value and add it\n",
+    "        # to the layer using `self.add_loss()`.\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 = self.loss_fn(y_true, y_pred, input_length, label_length)\n",
+    "        self.add_loss(loss)\n",
+    "\n",
+    "        # At test time, just return the computed predictions\n",
+    "        return y_pred\n",
+    "\n",
+    "\n",
+    "def build_model():\n",
+    "    # Inputs to the model\n",
+    "    input_img = layers.Input(\n",
+    "        shape=(img_width, img_height, 1), name=\"image\", dtype=\"float32\"\n",
+    "    )\n",
+    "    labels = layers.Input(name=\"label\", shape=(None,), dtype=\"float32\")\n",
+    "\n",
+    "\n",
+    "    # First conv block\n",
+    "    x = layers.Conv2D(40, (3, 3), activation=\"relu\", kernel_initializer=\"GlorotUniform\", padding=\"same\",use_bias=True, name=\"conv_2d\")(input_img)  \n",
+    "    x = layers.MaxPooling2D((2, 2), name=\"pool3\")(x)\n",
+    "    x = layers.Conv2D(60, (3, 3), activation=\"relu\", kernel_initializer=\"GlorotUniform\", padding=\"same\",use_bias=True, name=\"conv_2d1\")(input_img)  \n",
+    "    x = layers.MaxPooling2D((2, 2), name=\"pool5\")(x)\n",
+    "\n",
+    "    # Reshape layer to prepare for the RNN layers\n",
+    "    new_shape = ((img_width // 4), (img_height // 4) * 60 * 4)\n",
+    "    #new_shape = (36, 256)\n",
+    "    x = layers.Reshape(target_shape=new_shape, name=\"reshape\")(x)\n",
+    "\n",
+    "\n",
+    "    # RNN layers\n",
+    "    x = layers.Bidirectional(layers.LSTM(100, recurrent_activation=\"sigmoid\", activation=\"tanh\",kernel_initializer=\"GlorotUniform\", recurrent_initializer=\"Orthogonal\", return_sequences=True, dropout=0.3), merge_mode=\"concat\")(x)\n",
+    "    \n",
+    "    # Output layer\n",
+    "    x = layers.Dense(len(char_to_num.get_vocabulary()) + 1, activation=\"softmax\", name=\"dense2\")(x)\n",
+    "\n",
+    "\n",
+    "    # Add CTC layer for calculating CTC loss at each step\n",
+    "    output = CTCLayer(name=\"ctc_loss\")(labels, x)\n",
+    "\n",
+    "    # Define the model\n",
+    "    model = keras.models.Model(\n",
+    "        inputs=[input_img, labels], outputs=output, name=\"ocr_model_v1\"\n",
+    "    )\n",
+    "    # Optimizer\n",
+    "    opt = keras.optimizers.Adam(learning_rate=0.0075)\n",
+    "    # Compile the model and return\n",
+    "    model.compile(optimizer=opt)\n",
+    "    return model\n",
+    "\n",
+    "\n",
+    "# Get the model\n",
+    "model = build_model()\n",
+    "model.summary()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "PCAmf-fzvl9a"
+   },
+   "source": [
+    "## Training"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "id": "M-R6QGjuvl9a"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2023-08-08 09:00:00.538999: I tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:432] Loaded cuDNN version 8902\n",
+      "2023-08-08 09:00:01.417354: I tensorflow/compiler/xla/service/service.cc:168] XLA service 0x7f9eb707a6f0 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n",
+      "2023-08-08 09:00:01.417398: I tensorflow/compiler/xla/service/service.cc:176]   StreamExecutor device (0): NVIDIA GeForce GTX 1650, Compute Capability 7.5\n",
+      "2023-08-08 09:00:01.480666: I tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.cc:255] disabling MLIR crash reproducer, set env var `MLIR_CRASH_REPRODUCER_DIRECTORY` to enable.\n",
+      "2023-08-08 09:00:01.881648: I ./tensorflow/compiler/jit/device_compiler.h:186] Compiled cluster using XLA!  This line is logged at most once for the lifetime of the process.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1886/1886 [==============================] - 66s 32ms/step - loss: 10.4818 - val_loss: 3.5385\n",
+      "Epoch 2/100\n",
+      "1886/1886 [==============================] - 59s 31ms/step - loss: 2.9341 - val_loss: 2.3414\n",
+      "Epoch 3/100\n",
+      "1886/1886 [==============================] - 57s 30ms/step - loss: 2.1140 - val_loss: 1.9919\n",
+      "Epoch 4/100\n",
+      "1886/1886 [==============================] - 58s 31ms/step - loss: 1.7638 - val_loss: 1.7001\n",
+      "Epoch 5/100\n",
+      "1886/1886 [==============================] - 68s 36ms/step - loss: 1.5672 - val_loss: 1.7731\n",
+      "Epoch 6/100\n",
+      "1886/1886 [==============================] - 69s 37ms/step - loss: 1.5323 - val_loss: 1.9233\n",
+      "Epoch 7/100\n",
+      "1886/1886 [==============================] - 67s 36ms/step - loss: 1.4012 - val_loss: 1.6993\n",
+      "Epoch 8/100\n",
+      "1886/1886 [==============================] - 72s 38ms/step - loss: 1.4151 - val_loss: 2.1529\n",
+      "Epoch 9/100\n",
+      "1886/1886 [==============================] - 67s 35ms/step - loss: 1.3961 - val_loss: 1.6122\n",
+      "Epoch 10/100\n",
+      "1886/1886 [==============================] - 63s 34ms/step - loss: 1.3398 - val_loss: 1.7357\n",
+      "Epoch 11/100\n",
+      "1886/1886 [==============================] - 66s 35ms/step - loss: 1.2908 - val_loss: 1.6795\n",
+      "Epoch 12/100\n",
+      "1886/1886 [==============================] - 65s 34ms/step - loss: 1.2644 - val_loss: 1.5135\n",
+      "Epoch 13/100\n",
+      "1886/1886 [==============================] - 67s 36ms/step - loss: 1.2279 - val_loss: 1.6908\n",
+      "Epoch 14/100\n",
+      "1886/1886 [==============================] - 68s 36ms/step - loss: 1.2833 - val_loss: 1.6330\n",
+      "Epoch 15/100\n",
+      "1886/1886 [==============================] - 64s 34ms/step - loss: 1.3665 - val_loss: 1.7188\n",
+      "Epoch 16/100\n",
+      "1886/1886 [==============================] - 59s 31ms/step - loss: 1.2802 - val_loss: 1.4348\n",
+      "Epoch 17/100\n",
+      "1886/1886 [==============================] - 66s 35ms/step - loss: 1.2824 - val_loss: 1.5345\n",
+      "Epoch 18/100\n",
+      "1886/1886 [==============================] - 57s 30ms/step - loss: 1.2963 - val_loss: 1.4366\n",
+      "Epoch 19/100\n",
+      "1886/1886 [==============================] - 61s 32ms/step - loss: 1.2542 - val_loss: 1.4457\n",
+      "Epoch 20/100\n",
+      "1886/1886 [==============================] - 61s 33ms/step - loss: 1.2377 - val_loss: 1.4475\n",
+      "Epoch 21/100\n",
+      "1886/1886 [==============================] - 58s 31ms/step - loss: 1.2494 - val_loss: 1.5095\n",
+      "Epoch 22/100\n",
+      "1886/1886 [==============================] - 58s 31ms/step - loss: 1.2469 - val_loss: 1.5823\n",
+      "Epoch 23/100\n",
+      "1886/1886 [==============================] - 63s 33ms/step - loss: 1.2601 - val_loss: 1.5059\n",
+      "Epoch 24/100\n",
+      "1886/1886 [==============================] - 68s 36ms/step - loss: 1.3095 - val_loss: 1.5356\n",
+      "Epoch 25/100\n",
+      "1886/1886 [==============================] - 67s 35ms/step - loss: 1.6499 - val_loss: 1.7413\n",
+      "Epoch 26/100\n",
+      "1886/1886 [==============================] - 68s 36ms/step - loss: 1.4921 - val_loss: 1.7528\n"
+     ]
+    }
+   ],
+   "source": [
+    "epochs = 100\n",
+    "early_stopping_patience = 10\n",
+    "# Add early stopping\n",
+    "early_stopping = keras.callbacks.EarlyStopping(\n",
+    "    monitor=\"val_loss\", patience=early_stopping_patience, restore_best_weights=True\n",
+    ")\n",
+    "\n",
+    "# Train the model\n",
+    "history = model.fit(\n",
+    "    train_dataset,\n",
+    "    validation_data=validation_dataset,\n",
+    "    epochs=epochs,\n",
+    "    callbacks=[early_stopping],\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "1EpbnVEEvl9a"
+   },
+   "source": [
+    "## Inference\n",
+    "\n",
+    "You can use the trained model hosted on [Hugging Face Hub](https://huggingface.co/keras-io/ocr-for-captcha)\n",
+    "and try the demo on [Hugging Face Spaces](https://huggingface.co/spaces/keras-io/ocr-for-captcha)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "id": "8_xv3ktTvl9b"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: \"model\"\n",
+      "_________________________________________________________________\n",
+      " Layer (type)                Output Shape              Param #   \n",
+      "=================================================================\n",
+      " image (InputLayer)          [(None, 300, 80, 1)]      0         \n",
+      "                                                                 \n",
+      " conv_2d1 (Conv2D)           (None, 300, 80, 60)       600       \n",
+      "                                                                 \n",
+      " pool5 (MaxPooling2D)        (None, 150, 40, 60)       0         \n",
+      "                                                                 \n",
+      " reshape (Reshape)           (None, 75, 4800)          0         \n",
+      "                                                                 \n",
+      " bidirectional (Bidirection  (None, 75, 200)           3920800   \n",
+      " al)                                                             \n",
+      "                                                                 \n",
+      " dense2 (Dense)              (None, 75, 24)            4824      \n",
+      "                                                                 \n",
+      "=================================================================\n",
+      "Total params: 3926224 (14.98 MB)\n",
+      "Trainable params: 3926224 (14.98 MB)\n",
+      "Non-trainable params: 0 (0.00 Byte)\n",
+      "_________________________________________________________________\n",
+      "1/1 [==============================] - 1s 696ms/step\n",
+      "HSXVW \n",
+      "28P0VK\n",
+      "VMTPM \n",
+      "HKYJA2\n",
+      "['HSXVW ', 'HSXVW ']\n",
+      "['28P0VK', '28P0VK']\n",
+      "['VMTPM ', 'VMTPM ']\n",
+      "['HKYJA2', 'HKYJA2']\n",
+      "1/1 [==============================] - 0s 32ms/step\n",
+      "YPDVAK\n",
+      "Y0S4RR\n",
+      "H4DRJ \n",
+      "NJTNKP\n",
+      "['YPDVAK', 'YPDVAK']\n",
+      "['0S4RR ', 'Y0S4RR']\n",
+      "['H4DR  ', 'H4DRJ ']\n",
+      "['NJTNKP', 'NJTNKP']\n",
+      "1/1 [==============================] - 0s 53ms/step\n",
+      "088S4 \n",
+      "PVSSSY\n",
+      "SVK4WA\n",
+      "ASJKKX\n",
+      "['088S4 ', '088S4 ']\n",
+      "['PSSY  ', 'PVSSSY']\n",
+      "['SVK4WA', 'SVK4WA']\n",
+      "['ASJKKX', 'ASJKKX']\n",
+      "1/1 [==============================] - 0s 47ms/step\n",
+      "0RW8HW\n",
+      "0ANDKK\n",
+      "R204S0\n",
+      "4VNHNX\n",
+      "['0RW8HW', '0RW8HW']\n",
+      "['0ANDKK', '0ANDKK']\n",
+      "['R204S0', 'R204S0']\n",
+      "['VNHNX ', '4VNHNX']\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x500 with 16 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from sklearn.metrics import pairwise_distances\n",
+    "\n",
+    "# Get the prediction model by extracting layers till the output layer\n",
+    "prediction_model = keras.models.Model(\n",
+    "    model.get_layer(name=\"image\").input, model.get_layer(name=\"dense2\").output\n",
+    ")\n",
+    "prediction_model.summary()\n",
+    "\n",
+    "# A utility function to decode the output of the network\n",
+    "def decode_batch_predictions(pred):\n",
+    "    input_len = np.ones(pred.shape[0]) * pred.shape[1]\n",
+    "    # Use greedy search. For complex tasks, you can use beam search\n",
+    "    results = keras.backend.ctc_decode(pred, input_length=input_len, greedy=True)[0][0][\n",
+    "        :, :max_length\n",
+    "    ]\n",
+    "    # Iterate over the results and get back the text\n",
+    "    output_text = []\n",
+    "    for res in results:\n",
+    "        res = tf.strings.reduce_join(num_to_char(res)).numpy().decode(\"utf-8\")\n",
+    "        output_text.append(res)\n",
+    "    return output_text\n",
+    "\n",
+    "def lev(s1, s2):\n",
+    "    m, n = len(s1), len(s2)\n",
+    "    dp = np.zeros((m + 1, n + 1), dtype=int)\n",
+    "\n",
+    "    for i in range(m + 1):\n",
+    "        for j in range(n + 1):\n",
+    "            if i == 0:\n",
+    "                dp[i][j] = j\n",
+    "            elif j == 0:\n",
+    "                dp[i][j] = i\n",
+    "            elif s1[i - 1] == s2[j - 1]:\n",
+    "                dp[i][j] = dp[i - 1][j - 1]\n",
+    "            else:\n",
+    "                dp[i][j] = 1 + min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1])\n",
+    "\n",
+    "    return dp[m][n]\n",
+    "#  Let's check results on some validation samples\n",
+    "j = 0\n",
+    "_, ax = plt.subplots(4, 4, figsize=(15, 5))\n",
+    "\n",
+    "for batch in validation_dataset.take(4):\n",
+    "    batch_images = batch[\"image\"]\n",
+    "    batch_labels = batch[\"label\"]\n",
+    "\n",
+    "    preds = prediction_model.predict(batch_images)\n",
+    "    pred_texts = decode_batch_predictions(preds)\n",
+    "\n",
+    "    orig_texts = []\n",
+    "    for label in batch_labels:\n",
+    "        print(tf.strings.reduce_join(num_to_char(label)).numpy().decode(\"utf-8\"))\n",
+    "        label = tf.strings.reduce_join(num_to_char(label)).numpy().decode(\"utf-8\")\n",
+    "        orig_texts.append(label)\n",
+    "\n",
+    "    for i in range(len(pred_texts)):\n",
+    "        img = (batch_images[i, :, :, 0] * 255).numpy().astype(np.uint8)\n",
+    "        img = img.T\n",
+    "        pred = pred_texts[i].replace('[UNK]', '')\n",
+    "        comp = orig_texts[i];\n",
+    "        if len(comp) == 5:\n",
+    "            comp += ' '\n",
+    "        if len(pred) == 5:\n",
+    "            pred += ' '\n",
+    "        dist = lev(pred, comp)\n",
+    "        print([pred, comp])\n",
+    "        title = f\"P: {pred} T: {comp} ({dist})\"\n",
+    "        ax[j // 4,i % 4].imshow(img, cmap=\"gray\")\n",
+    "        ax[j // 4, i % 4].set_title(title, color=('green' if comp in pred else 'red'))\n",
+    "        ax[j // 4, i % 4].axis(\"off\")\n",
+    "        j += 1\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:tensorflow:Assets written to: captcha_75_25.tf/assets\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:tensorflow:Assets written to: captcha_75_25.tf/assets\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.save('captcha_75_25.h5')\n",
+    "model.save('captcha_75_25.keras')\n",
+    "model.save('captcha_75_25.tf')\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "name": "captcha_ocr",
+   "provenance": [],
+   "toc_visible": true
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}