Image Captioning - Implement an image captioning model using a CNN and a Transformer.

image_captioning_keras.ipynb

{
  "cells": [
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "EFwSaNB8jF7s"
      },
      "source": [
        "# Image Captioning Keras-IO"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "```\n",
        "Title: Image Captioning\n",
        "Author: [A_K_Nain](https://twitter.com/A_K_Nain)\n",
        "Date created: 2021/05/29\n",
        "Last modified: 2021/10/31\n",
        "Description: Implement an image captioning model using a CNN and a Transformer.\n",
        "Accelerator: GPU\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5bwwk4uxRz6A"
      },
      "source": [
        "## Setup"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nQ6q39Vd-y-7"
      },
      "source": [
        "This tutorial uses lots of imports, mostly for loading the dataset(s)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "cellView": "form",
        "id": "U8l4RJ0XRPEm"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import re\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "from tensorflow.keras import layers\n",
        "from tensorflow.keras.applications import efficientnet\n",
        "from tensorflow.keras.layers import TextVectorization\n",
        "\n",
        "\n",
        "seed = 111\n",
        "np.random.seed(seed)\n",
        "tf.random.set_seed(seed)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Kl9qGnjWrv80"
      },
      "source": [
        "## [Optional] Data handling\n",
        "\n",
        "This section downloads a captions dataset and prepares it for training. It tokenizes the input text, and caches the results of running all the images through a pretrained feature-extractor model. It's not critical to understand everything in this section.\n",
        "\n",
        " <section class=\"expandable tfo-display-only-on-site\">\n",
        " <button type=\"button\" class=\"button-red button expand-control\">Toggle section</button>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q5e_SigQFiWf"
      },
      "source": [
        "### Choose a dataset\n",
        "\n",
        "This tutorial is set up to give a choice of datasets. Either [Flickr8k](https://www.ijcai.org/Proceedings/15/Papers/593.pdf) or a small slice of the [Conceptual Captions](https://ai.google.com/research/ConceptualCaptions/) dataset. These two are downloaded and converted from scratch, but it wouldn't be hard to convert the tutorial to use the caption datasets available in [TensorFlow Datasets](https://www.tensorflow.org/datasets): [Coco Captions](https://www.tensorflow.org/datasets/catalog/coco_captions) and the full [Conceptual Captions](https://www.tensorflow.org/datasets/community_catalog/huggingface/conceptual_captions).\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wqGXX9Dc5c0v"
      },
      "source": [
        "#### Flickr8k"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "kaNy_l7tGuAZ"
      },
      "outputs": [],
      "source": [
        "def flickr8k(path='flickr8k'):\n",
        "  path = pathlib.Path(path)\n",
        "\n",
        "  if len(list(path.rglob('*'))) < 16197:\n",
        "    tf.keras.utils.get_file(\n",
        "        origin='https://github.com/jbrownlee/Datasets/releases/download/Flickr8k/Flickr8k_Dataset.zip',\n",
        "        cache_dir='.',\n",
        "        cache_subdir=path,\n",
        "        extract=True)\n",
        "    tf.keras.utils.get_file(\n",
        "        origin='https://github.com/jbrownlee/Datasets/releases/download/Flickr8k/Flickr8k_text.zip',\n",
        "        cache_dir='.',\n",
        "        cache_subdir=path,\n",
        "        extract=True)\n",
        "    \n",
        "  captions = (path/\"Flickr8k.token.txt\").read_text().splitlines()\n",
        "  captions = (line.split('\\t') for line in captions)\n",
        "  captions = ((fname.split('#')[0], caption) for (fname, caption) in captions)\n",
        "\n",
        "  cap_dict = collections.defaultdict(list)\n",
        "  for fname, cap in captions:\n",
        "    cap_dict[fname].append(cap)\n",
        "\n",
        "  train_files = (path/'Flickr_8k.trainImages.txt').read_text().splitlines()\n",
        "  train_captions = [(str(path/'Flicker8k_Dataset'/fname), cap_dict[fname]) for fname in train_files]\n",
        "\n",
        "  test_files = (path/'Flickr_8k.testImages.txt').read_text().splitlines()\n",
        "  test_captions = [(str(path/'Flicker8k_Dataset'/fname), cap_dict[fname]) for fname in test_files]\n",
        "\n",
        "  train_ds = tf.data.experimental.from_list(train_captions)\n",
        "  test_ds = tf.data.experimental.from_list(test_captions)\n",
        "\n",
        "  return train_ds, test_ds"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zQICBAF4FmSL"
      },
      "source": [
        "#### Conceptual Captions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vQwnxXZXRl12"
      },
      "outputs": [],
      "source": [
        "def conceptual_captions(*, data_dir=\"conceptual_captions\", num_train, num_val):\n",
        "  def iter_index(index_path):\n",
        "    with open(index_path) as f:\n",
        "      for line in f:\n",
        "        caption, url = line.strip().split('\\t')\n",
        "        yield caption, url\n",
        "\n",
        "  def download_image_urls(data_dir, urls):\n",
        "    ex = concurrent.futures.ThreadPoolExecutor(max_workers=100)\n",
        "    def save_image(url):\n",
        "      hash = hashlib.sha1(url.encode())\n",
        "      # Name the files after the hash of the URL.\n",
        "      file_path = data_dir/f'{hash.hexdigest()}.jpeg'\n",
        "      if file_path.exists():\n",
        "        # Only download each file once.\n",
        "        return file_path\n",
        "\n",
        "      try:\n",
        "        result = requests.get(url, timeout=5)\n",
        "      except Exception:\n",
        "        file_path = None\n",
        "      else:\n",
        "        file_path.write_bytes(result.content)\n",
        "      return file_path\n",
        "    \n",
        "    result = []\n",
        "    out_paths = ex.map(save_image, urls)\n",
        "    for file_path in tqdm.tqdm(out_paths, total=len(urls)):\n",
        "      result.append(file_path)\n",
        "\n",
        "    return result\n",
        "\n",
        "  def ds_from_index_file(index_path, data_dir, count):\n",
        "    data_dir.mkdir(exist_ok=True)\n",
        "    index = list(itertools.islice(iter_index(index_path), count))\n",
        "    captions = [caption for caption, url in index]\n",
        "    urls = [url for caption, url in index]\n",
        "\n",
        "    paths = download_image_urls(data_dir, urls)\n",
        "\n",
        "    new_captions = []\n",
        "    new_paths = []\n",
        "    for cap, path in zip(captions, paths):\n",
        "      if path is None:\n",
        "        # Download failed, so skip this pair.\n",
        "        continue\n",
        "      new_captions.append(cap)\n",
        "      new_paths.append(path)\n",
        "    \n",
        "    new_paths = [str(p) for p in new_paths]\n",
        "\n",
        "    ds = tf.data.Dataset.from_tensor_slices((new_paths, new_captions))\n",
        "    ds = ds.map(lambda path,cap: (path, cap[tf.newaxis])) # 1 caption per image\n",
        "    return ds\n",
        "\n",
        "  data_dir = pathlib.Path(data_dir)\n",
        "  train_index_path = tf.keras.utils.get_file(\n",
        "    origin='https://storage.googleapis.com/gcc-data/Train/GCC-training.tsv',\n",
        "    cache_subdir=data_dir,\n",
        "    cache_dir='.')\n",
        "  \n",
        "  val_index_path = tf.keras.utils.get_file(\n",
        "    origin='https://storage.googleapis.com/gcc-data/Validation/GCC-1.1.0-Validation.tsv',\n",
        "    cache_subdir=data_dir,\n",
        "    cache_dir='.')\n",
        "  \n",
        "  train_raw = ds_from_index_file(train_index_path, data_dir=data_dir/'train', count=num_train)\n",
        "  test_raw = ds_from_index_file(val_index_path, data_dir=data_dir/'val', count=num_val)\n",
        "\n",
        "  return train_raw, test_raw"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rBAagBw5p-TM"
      },
      "source": [
        "#### Download the dataset"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WFtTZaobquNr"
      },
      "source": [
        "The Flickr8k is a good choice because it contains 5-captions per image, more data for a smaller download."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "EJySPbzJ4Wxw"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Downloading data from https://github.com/jbrownlee/Datasets/releases/download/Flickr8k/Flickr8k_Dataset.zip\n",
            "1115419746/1115419746 [==============================] - 913s 1us/step\n",
            "Downloading data from https://github.com/jbrownlee/Datasets/releases/download/Flickr8k/Flickr8k_text.zip\n",
            "2340801/2340801 [==============================] - 2s 1us/step\n"
          ]
        }
      ],
      "source": [
        "choose = 'flickr8k'\n",
        "\n",
        "if choose == 'flickr8k':\n",
        "  train_raw, test_raw = flickr8k()\n",
        "else:\n",
        "  train_raw, test_raw = conceptual_captions(num_train=10000, num_val=5000)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-UAc275FHxm8"
      },
      "source": [
        "The loaders for both datasets above return `tf.data.Dataset`s containing `(image_path, captions)` pairs. The Flickr8k dataset contains 5 captions per image, while Conceptual Captions has 1:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 369,
      "metadata": {
        "id": "sAQSps5F8RQI"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(TensorSpec(shape=(), dtype=tf.string, name=None),\n",
              " TensorSpec(shape=(5,), dtype=tf.string, name=None))"
            ]
          },
          "execution_count": 369,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "train_raw.element_spec"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 370,
      "metadata": {
        "id": "xIa0ZaP4tBez"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "2023-05-12 19:56:51.980092: I tensorflow/core/common_runtime/executor.cc:1210] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'Placeholder/_6376' with dtype string\n",
            "\t [[{{node Placeholder/_6376}}]]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tf.Tensor(b'flickr8k/Flicker8k_Dataset/2513260012_03d33305cf.jpg', shape=(), dtype=string)\n",
            "tf.Tensor(\n",
            "[b'A black dog is running after a white dog in the snow .'\n",
            " b'Black dog chasing brown dog through snow'\n",
            " b'Two dogs chase each other across the snowy ground .'\n",
            " b'Two dogs play together in the snow .'\n",
            " b'Two dogs running through a low lying body of water .'], shape=(5,), dtype=string)\n"
          ]
        }
      ],
      "source": [
        "for ex_path, ex_captions in train_raw.take(1):\n",
        "  print(ex_path)\n",
        "  print(ex_captions)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 103,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Path to the images\n",
        "IMAGES_PATH = \"/Users/aa849190/Downloads/github/autopilotai/autopilotai-ml/flickr8k/Flicker8k_Dataset\"\n",
        "\n",
        "# Desired image dimensions\n",
        "IMAGE_SIZE = (299, 299)\n",
        "\n",
        "# Vocabulary size\n",
        "VOCAB_SIZE = 10000\n",
        "\n",
        "# Fixed length allowed for any sequence\n",
        "SEQ_LENGTH = 25\n",
        "\n",
        "# Dimension for the image embeddings and token embeddings\n",
        "EMBED_DIM = 512\n",
        "\n",
        "# Per-layer units in the feed-forward network\n",
        "FF_DIM = 512\n",
        "\n",
        "# Other training parameters\n",
        "BATCH_SIZE = 64\n",
        "EPOCHS = 1 #30\n",
        "AUTOTUNE = tf.data.AUTOTUNE"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uEWM9xrYcg45"
      },
      "source": [
        "### Prepare the datasets"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 75,
      "metadata": {
        "id": "CZGUsuGzUfzt"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Number of training samples:  6114\n",
            "Number of validation samples:  1529\n"
          ]
        }
      ],
      "source": [
        "def load_captions_data(filename):\n",
        "    \"\"\"Loads captions (text) data and maps them to corresponding images.\n",
        "\n",
        "    Args:\n",
        "        filename: Path to the text file containing caption data.\n",
        "\n",
        "    Returns:\n",
        "        caption_mapping: Dictionary mapping image names and the corresponding captions\n",
        "        text_data: List containing all the available captions\n",
        "    \"\"\"\n",
        "\n",
        "    with open(filename) as caption_file:\n",
        "        caption_data = caption_file.readlines()\n",
        "        caption_mapping = {}\n",
        "        text_data = []\n",
        "        images_to_skip = set()\n",
        "\n",
        "        for line in caption_data:\n",
        "            line = line.rstrip(\"\\n\")\n",
        "            # Image name and captions are separated using a tab\n",
        "            img_name, caption = line.split(\"\\t\")\n",
        "\n",
        "            # Each image is repeated five times for the five different captions.\n",
        "            # Each image name has a suffix `#(caption_number)`\n",
        "            img_name = img_name.split(\"#\")[0]\n",
        "            img_name = os.path.join(IMAGES_PATH, img_name.strip())\n",
        "\n",
        "            # We will remove caption that are either too short to too long\n",
        "            tokens = caption.strip().split()\n",
        "\n",
        "            if len(tokens) < 5 or len(tokens) > SEQ_LENGTH:\n",
        "                images_to_skip.add(img_name)\n",
        "                continue\n",
        "\n",
        "            if img_name.endswith(\"jpg\") and img_name not in images_to_skip:\n",
        "                # We will add a start and an end token to each caption\n",
        "                caption = \"<start> \" + caption.strip() + \" <end>\"\n",
        "                text_data.append(caption)\n",
        "\n",
        "                if img_name in caption_mapping:\n",
        "                    caption_mapping[img_name].append(caption)\n",
        "                else:\n",
        "                    caption_mapping[img_name] = [caption]\n",
        "\n",
        "        for img_name in images_to_skip:\n",
        "            if img_name in caption_mapping:\n",
        "                del caption_mapping[img_name]\n",
        "\n",
        "        return caption_mapping, text_data\n",
        "\n",
        "\n",
        "def train_val_split(caption_data, train_size=0.8, shuffle=True):\n",
        "    \"\"\"Split the captioning dataset into train and validation sets.\n",
        "\n",
        "    Args:\n",
        "        caption_data (dict): Dictionary containing the mapped caption data\n",
        "        train_size (float): Fraction of all the full dataset to use as training data\n",
        "        shuffle (bool): Whether to shuffle the dataset before splitting\n",
        "\n",
        "    Returns:\n",
        "        Traning and validation datasets as two separated dicts\n",
        "    \"\"\"\n",
        "\n",
        "    # 1. Get the list of all image names\n",
        "    all_images = list(caption_data.keys())\n",
        "\n",
        "    # 2. Shuffle if necessary\n",
        "    if shuffle:\n",
        "        np.random.shuffle(all_images)\n",
        "\n",
        "    # 3. Split into training and validation sets\n",
        "    train_size = int(len(caption_data) * train_size)\n",
        "\n",
        "    training_data = {\n",
        "        img_name: caption_data[img_name] for img_name in all_images[:train_size]\n",
        "    }\n",
        "    validation_data = {\n",
        "        img_name: caption_data[img_name] for img_name in all_images[train_size:]\n",
        "    }\n",
        "\n",
        "    # 4. Return the splits\n",
        "    return training_data, validation_data\n",
        "\n",
        "\n",
        "# Load the dataset\n",
        "captions_mapping, text_data = load_captions_data(\"/Users/aa849190/Downloads/github/autopilotai/autopilotai-ml/flickr8k/Flickr8k.token.txt\")\n",
        "\n",
        "# Split the dataset into training and validation sets\n",
        "train_data, valid_data = train_val_split(captions_mapping)\n",
        "print(\"Number of training samples: \", len(train_data))\n",
        "print(\"Number of validation samples: \", len(valid_data))"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Vectorizing the text data\n",
        "\n",
        "```\n",
        "We'll use the `TextVectorization` layer to vectorize the text data,\n",
        "that is to say, to turn the\n",
        "original strings into integer sequences where each integer represents the index of\n",
        "a word in a vocabulary. We will use a custom string standardization scheme\n",
        "(strip punctuation characters except `<` and `>`) and the default\n",
        "splitting scheme (split on whitespace).\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 76,
      "metadata": {},
      "outputs": [],
      "source": [
        "def custom_standardization(input_string):\n",
        "    lowercase = tf.strings.lower(input_string)\n",
        "    return tf.strings.regex_replace(lowercase, \"[%s]\" % re.escape(strip_chars), \"\")\n",
        "\n",
        "\n",
        "strip_chars = \"!\\\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~\"\n",
        "strip_chars = strip_chars.replace(\"<\", \"\")\n",
        "strip_chars = strip_chars.replace(\">\", \"\")\n",
        "\n",
        "vectorization = TextVectorization(\n",
        "    max_tokens=VOCAB_SIZE,\n",
        "    output_mode=\"int\",\n",
        "    output_sequence_length=SEQ_LENGTH,\n",
        "    standardize=custom_standardization,\n",
        ")\n",
        "vectorization.adapt(text_data)\n",
        "\n",
        "# Data augmentation for image data\n",
        "image_augmentation = keras.Sequential(\n",
        "    [\n",
        "        layers.RandomFlip(\"horizontal\"),\n",
        "        layers.RandomRotation(0.2),\n",
        "        layers.RandomContrast(0.3),\n",
        "    ]\n",
        ")"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Building a `tf.data.Dataset` pipeline for training\n",
        "\n",
        "```\n",
        "We will generate pairs of images and corresponding captions using a `tf.data.Dataset` object.\n",
        "The pipeline consists of two steps:\n",
        "\n",
        "1. Read the image from the disk\n",
        "2. Tokenize all the five captions corresponding to the image\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 77,
      "metadata": {},
      "outputs": [],
      "source": [
        "def decode_and_resize(img_path):\n",
        "    img = tf.io.read_file(img_path)\n",
        "    img = tf.image.decode_jpeg(img, channels=3)\n",
        "    img = tf.image.resize(img, IMAGE_SIZE)\n",
        "    img = tf.image.convert_image_dtype(img, tf.float32)\n",
        "    return img\n",
        "\n",
        "\n",
        "def process_input(img_path, captions):\n",
        "    return decode_and_resize(img_path), vectorization(captions)\n",
        "\n",
        "\n",
        "def make_dataset(images, captions):\n",
        "    dataset = tf.data.Dataset.from_tensor_slices((images, captions))\n",
        "    dataset = dataset.shuffle(BATCH_SIZE * 8)\n",
        "    dataset = dataset.map(process_input, num_parallel_calls=AUTOTUNE)\n",
        "    dataset = dataset.batch(BATCH_SIZE).prefetch(AUTOTUNE)\n",
        "\n",
        "    return dataset\n",
        "\n",
        "\n",
        "# Pass the list of images and the list of corresponding captions\n",
        "train_dataset = make_dataset(list(train_data.keys()), list(train_data.values()))\n",
        "\n",
        "valid_dataset = make_dataset(list(valid_data.keys()), list(valid_data.values()))"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Building the model\n",
        "\n",
        "```\n",
        "Our image captioning architecture consists of three models:\n",
        "\n",
        "1. A CNN: used to extract the image features\n",
        "2. A TransformerEncoder: The extracted image features are then passed to a Transformer\n",
        "                    based encoder that generates a new representation of the inputs\n",
        "3. A TransformerDecoder: This model takes the encoder output and the text data\n",
        "                    (sequences) as inputs and tries to learn to generate the caption.\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 170,
      "metadata": {},
      "outputs": [],
      "source": [
        "def get_cnn_model():\n",
        "    base_model = efficientnet.EfficientNetB0(\n",
        "        input_shape=(*IMAGE_SIZE, 3),\n",
        "        include_top=False,\n",
        "        weights=\"imagenet\",\n",
        "    )\n",
        "    # We freeze our feature extractor\n",
        "    base_model.trainable = False\n",
        "    base_model_out = base_model.output\n",
        "    base_model_out = layers.Reshape((-1, base_model_out.shape[-1]))(base_model_out)\n",
        "    cnn_model = keras.models.Model(base_model.input, base_model_out)\n",
        "    return cnn_model\n",
        "\n",
        "\n",
        "class TransformerEncoderBlock(layers.Layer):\n",
        "    def __init__(self, embed_dim, dense_dim, num_heads, **kwargs):\n",
        "        super().__init__(**kwargs)\n",
        "        self.embed_dim = embed_dim\n",
        "        self.dense_dim = dense_dim\n",
        "        self.num_heads = num_heads\n",
        "        self.attention_1 = layers.MultiHeadAttention(\n",
        "            num_heads=num_heads, key_dim=embed_dim, dropout=0.0\n",
        "        )\n",
        "        self.layernorm_1 = layers.LayerNormalization()\n",
        "        self.layernorm_2 = layers.LayerNormalization()\n",
        "        self.dense_1 = layers.Dense(embed_dim, activation=\"relu\")\n",
        "\n",
        "    def call(self, inputs, training, mask=None):\n",
        "        inputs = self.layernorm_1(inputs)\n",
        "        inputs = self.dense_1(inputs)\n",
        "\n",
        "        attention_output_1 = self.attention_1(\n",
        "            query=inputs,\n",
        "            value=inputs,\n",
        "            key=inputs,\n",
        "            attention_mask=None,\n",
        "            training=training,\n",
        "        )\n",
        "        out_1 = self.layernorm_2(inputs + attention_output_1)\n",
        "        return out_1\n",
        "\n",
        "\n",
        "class PositionalEmbedding(layers.Layer):\n",
        "    def __init__(self, sequence_length, vocab_size, embed_dim, **kwargs):\n",
        "        super().__init__(**kwargs)\n",
        "        self.token_embeddings = layers.Embedding(\n",
        "            input_dim=vocab_size, output_dim=embed_dim\n",
        "        )\n",
        "        self.position_embeddings = layers.Embedding(\n",
        "            input_dim=sequence_length, output_dim=embed_dim\n",
        "        )\n",
        "        self.sequence_length = sequence_length\n",
        "        self.vocab_size = vocab_size\n",
        "        self.embed_dim = embed_dim\n",
        "        self.embed_scale = tf.math.sqrt(tf.cast(embed_dim, tf.float32))\n",
        "\n",
        "    def call(self, inputs):\n",
        "        length = tf.shape(inputs)[-1]\n",
        "        positions = tf.range(start=0, limit=length, delta=1)\n",
        "        embedded_tokens = self.token_embeddings(inputs)\n",
        "        embedded_tokens = embedded_tokens * self.embed_scale\n",
        "        embedded_positions = self.position_embeddings(positions)\n",
        "        return embedded_tokens + embedded_positions\n",
        "\n",
        "    def compute_mask(self, inputs, mask=None):\n",
        "        return tf.math.not_equal(inputs, 0)\n",
        "\n",
        "\n",
        "class TransformerDecoderBlock(layers.Layer):\n",
        "    def __init__(self, embed_dim, ff_dim, num_heads, **kwargs):\n",
        "        super().__init__(**kwargs)\n",
        "        self.embed_dim = embed_dim\n",
        "        self.ff_dim = ff_dim\n",
        "        self.num_heads = num_heads\n",
        "        self.attention_1 = layers.MultiHeadAttention(\n",
        "            num_heads=num_heads, key_dim=embed_dim, dropout=0.1\n",
        "        )\n",
        "        self.attention_2 = layers.MultiHeadAttention(\n",
        "            num_heads=num_heads, key_dim=embed_dim, dropout=0.1\n",
        "        )\n",
        "        self.ffn_layer_1 = layers.Dense(ff_dim, activation=\"relu\")\n",
        "        self.ffn_layer_2 = layers.Dense(embed_dim)\n",
        "\n",
        "        self.layernorm_1 = layers.LayerNormalization()\n",
        "        self.layernorm_2 = layers.LayerNormalization()\n",
        "        self.layernorm_3 = layers.LayerNormalization()\n",
        "\n",
        "        self.embedding = PositionalEmbedding(\n",
        "            embed_dim=EMBED_DIM, sequence_length=SEQ_LENGTH, vocab_size=VOCAB_SIZE\n",
        "        )\n",
        "        self.out = layers.Dense(VOCAB_SIZE, activation=\"softmax\")\n",
        "\n",
        "        self.dropout_1 = layers.Dropout(0.3)\n",
        "        self.dropout_2 = layers.Dropout(0.5)\n",
        "        self.supports_masking = True\n",
        "\n",
        "    def call(self, inputs, encoder_outputs, training, mask=None):\n",
        "        inputs = self.embedding(inputs)\n",
        "        causal_mask = self.get_causal_attention_mask(inputs)\n",
        "\n",
        "        if mask is not None:\n",
        "            padding_mask = tf.cast(mask[:, :, tf.newaxis], dtype=tf.int32)\n",
        "            combined_mask = tf.cast(mask[:, tf.newaxis, :], dtype=tf.int32)\n",
        "            combined_mask = tf.minimum(combined_mask, causal_mask)\n",
        "\n",
        "        attention_output_1 = self.attention_1(\n",
        "            query=inputs,\n",
        "            value=inputs,\n",
        "            key=inputs,\n",
        "            attention_mask=combined_mask,\n",
        "            training=training,\n",
        "        )\n",
        "        out_1 = self.layernorm_1(inputs + attention_output_1)\n",
        "\n",
        "        attention_output_2 = self.attention_2(\n",
        "            query=out_1,\n",
        "            value=encoder_outputs,\n",
        "            key=encoder_outputs,\n",
        "            attention_mask=padding_mask,\n",
        "            training=training,\n",
        "        )\n",
        "        out_2 = self.layernorm_2(out_1 + attention_output_2)\n",
        "\n",
        "        ffn_out = self.ffn_layer_1(out_2)\n",
        "        ffn_out = self.dropout_1(ffn_out, training=training)\n",
        "        ffn_out = self.ffn_layer_2(ffn_out)\n",
        "\n",
        "        ffn_out = self.layernorm_3(ffn_out + out_2, training=training)\n",
        "        ffn_out = self.dropout_2(ffn_out, training=training)\n",
        "        preds = self.out(ffn_out)\n",
        "        return preds\n",
        "\n",
        "    def get_causal_attention_mask(self, inputs):\n",
        "        input_shape = tf.shape(inputs)\n",
        "        batch_size, sequence_length = input_shape[0], input_shape[1]\n",
        "        i = tf.range(sequence_length)[:, tf.newaxis]\n",
        "        j = tf.range(sequence_length)\n",
        "        mask = tf.cast(i >= j, dtype=\"int32\")\n",
        "        mask = tf.reshape(mask, (1, input_shape[1], input_shape[1]))\n",
        "        mult = tf.concat(\n",
        "            [tf.expand_dims(batch_size, -1), tf.constant([1, 1], dtype=tf.int32)],\n",
        "            axis=0,\n",
        "        )\n",
        "        return tf.tile(mask, mult)\n",
        "\n",
        "\n",
        "class ImageCaptioningModel(keras.Model):\n",
        "    def __init__(\n",
        "        self,\n",
        "        cnn_model,\n",
        "        encoder,\n",
        "        decoder,\n",
        "        num_captions_per_image=5,\n",
        "        image_aug=None,\n",
        "    ):\n",
        "        super().__init__()\n",
        "        self.cnn_model = cnn_model\n",
        "        self.encoder = encoder\n",
        "        self.decoder = decoder\n",
        "        self.loss_tracker = keras.metrics.Mean(name=\"loss\")\n",
        "        self.acc_tracker = keras.metrics.Mean(name=\"accuracy\")\n",
        "        self.num_captions_per_image = num_captions_per_image\n",
        "        self.image_aug = image_aug\n",
        "\n",
        "    def calculate_loss(self, y_true, y_pred, mask):\n",
        "        loss = self.loss(y_true, y_pred)\n",
        "        mask = tf.cast(mask, dtype=loss.dtype)\n",
        "        loss *= mask\n",
        "        return tf.reduce_sum(loss) / tf.reduce_sum(mask)\n",
        "\n",
        "    def calculate_accuracy(self, y_true, y_pred, mask):\n",
        "        accuracy = tf.equal(y_true, tf.argmax(y_pred, axis=2))\n",
        "        accuracy = tf.math.logical_and(mask, accuracy)\n",
        "        accuracy = tf.cast(accuracy, dtype=tf.float32)\n",
        "        mask = tf.cast(mask, dtype=tf.float32)\n",
        "        return tf.reduce_sum(accuracy) / tf.reduce_sum(mask)\n",
        "\n",
        "    def _compute_caption_loss_and_acc(self, img_embed, batch_seq, training=True):\n",
        "        encoder_out = self.encoder(img_embed, training=training)\n",
        "        batch_seq_inp = batch_seq[:, :-1]\n",
        "        batch_seq_true = batch_seq[:, 1:]\n",
        "        mask = tf.math.not_equal(batch_seq_true, 0)\n",
        "        batch_seq_pred = self.decoder(\n",
        "            batch_seq_inp, encoder_out, training=training, mask=mask\n",
        "        )\n",
        "        loss = self.calculate_loss(batch_seq_true, batch_seq_pred, mask)\n",
        "        acc = self.calculate_accuracy(batch_seq_true, batch_seq_pred, mask)\n",
        "        return loss, acc\n",
        "\n",
        "    def train_step(self, batch_data):\n",
        "        batch_img, batch_seq = batch_data\n",
        "        batch_loss = 0\n",
        "        batch_acc = 0\n",
        "\n",
        "        if self.image_aug:\n",
        "            batch_img = self.image_aug(batch_img)\n",
        "\n",
        "        # 1. Get image embeddings\n",
        "        img_embed = self.cnn_model(batch_img)\n",
        "\n",
        "        # 2. Pass each of the five captions one by one to the decoder\n",
        "        # along with the encoder outputs and compute the loss as well as accuracy\n",
        "        # for each caption.\n",
        "        for i in range(self.num_captions_per_image):\n",
        "            with tf.GradientTape() as tape:\n",
        "                loss, acc = self._compute_caption_loss_and_acc(\n",
        "                    img_embed, batch_seq[:, i, :], training=True\n",
        "                )\n",
        "\n",
        "                # 3. Update loss and accuracy\n",
        "                batch_loss += loss\n",
        "                batch_acc += acc\n",
        "\n",
        "            # 4. Get the list of all the trainable weights\n",
        "            train_vars = (\n",
        "                self.encoder.trainable_variables + self.decoder.trainable_variables\n",
        "            )\n",
        "\n",
        "            # 5. Get the gradients\n",
        "            grads = tape.gradient(loss, train_vars)\n",
        "\n",
        "            # 6. Update the trainable weights\n",
        "            self.optimizer.apply_gradients(zip(grads, train_vars))\n",
        "\n",
        "        # 7. Update the trackers\n",
        "        batch_acc /= float(self.num_captions_per_image)\n",
        "        self.loss_tracker.update_state(batch_loss)\n",
        "        self.acc_tracker.update_state(batch_acc)\n",
        "\n",
        "        # 8. Return the loss and accuracy values\n",
        "        return {\"loss\": self.loss_tracker.result(), \"acc\": self.acc_tracker.result()}\n",
        "\n",
        "    def test_step(self, batch_data):\n",
        "        batch_img, batch_seq = batch_data\n",
        "        batch_loss = 0\n",
        "        batch_acc = 0\n",
        "\n",
        "        # 1. Get image embeddings\n",
        "        img_embed = self.cnn_model(batch_img)\n",
        "\n",
        "        # 2. Pass each of the five captions one by one to the decoder\n",
        "        # along with the encoder outputs and compute the loss as well as accuracy\n",
        "        # for each caption.\n",
        "        for i in range(self.num_captions_per_image):\n",
        "            loss, acc = self._compute_caption_loss_and_acc(\n",
        "                img_embed, batch_seq[:, i, :], training=False\n",
        "            )\n",
        "\n",
        "            # 3. Update batch loss and batch accuracy\n",
        "            batch_loss += loss\n",
        "            batch_acc += acc\n",
        "\n",
        "        batch_acc /= float(self.num_captions_per_image)\n",
        "\n",
        "        # 4. Update the trackers\n",
        "        self.loss_tracker.update_state(batch_loss)\n",
        "        self.acc_tracker.update_state(batch_acc)\n",
        "\n",
        "        # 5. Return the loss and accuracy values\n",
        "        return {\"loss\": self.loss_tracker.result(), \"acc\": self.acc_tracker.result()}\n",
        "\n",
        "    @property\n",
        "    def metrics(self):\n",
        "        # We need to list our metrics here so the `reset_states()` can be\n",
        "        # called automatically.\n",
        "        return [self.loss_tracker, self.acc_tracker]\n",
        "\n",
        "    # @tf.function(input_signature=[tf.TensorSpec(shape=[None], dtype=tf.float32)])\n",
        "    # def call(self, x):\n",
        "    #     result = x + x\n",
        "    #     return {\n",
        "    #         \"encoded_result\": result\n",
        "    #     }\n",
        "    @tf.function(input_signature=[tf.TensorSpec(shape=[299, 299, 3], dtype=tf.float32)])\n",
        "    def call(self, image):\n",
        "        vocab = vectorization.get_vocabulary()\n",
        "        index_lookup = dict(zip(range(len(vocab)), vocab))\n",
        "        max_decoded_sentence_length = SEQ_LENGTH - 1\n",
        "\n",
        "        # Read the image from the disk\n",
        "        sample_img = decode_and_resize(image)\n",
        "        img = sample_img.numpy().clip(0, 255).astype(np.uint8)\n",
        "\n",
        "        # Pass the image to the CNN\n",
        "        img = tf.expand_dims(sample_img, 0)\n",
        "        img = self.cnn_model(img)\n",
        "\n",
        "        # Pass the image features to the Transformer encoder\n",
        "        encoded_img = self.encoder(img, training=False)\n",
        "\n",
        "        # Generate the caption using the Transformer decoder\n",
        "        decoded_caption = \"<start> \"\n",
        "        for i in range(max_decoded_sentence_length):\n",
        "            tokenized_caption = vectorization([decoded_caption])[:, :-1]\n",
        "            mask = tf.math.not_equal(tokenized_caption, tf.constant(0))\n",
        "            predictions = self.decoder(\n",
        "                tokenized_caption, encoded_img, training=False, mask=mask\n",
        "            )\n",
        "            sampled_token_index = np.argmax(predictions[0, i, :])\n",
        "            sampled_token = index_lookup[sampled_token_index]\n",
        "            # if sampled_token == \"<end>\":\n",
        "            #     break\n",
        "            # tf.cond(sampled_token == \"<end>\", lambda: \"test\", lambda: \"continue\")\n",
        "            decoded_caption += \" \" + sampled_token\n",
        "\n",
        "        decoded_caption = decoded_caption.replace(\"<start> \", \"\")\n",
        "        decoded_caption = decoded_caption.replace(\" <end>\", \"\").strip()\n",
        "        return {\n",
        "            \"result\": decoded_caption\n",
        "        }\n",
        "\n",
        "cnn_model = get_cnn_model()\n",
        "encoder = TransformerEncoderBlock(embed_dim=EMBED_DIM, dense_dim=FF_DIM, num_heads=1)\n",
        "decoder = TransformerDecoderBlock(embed_dim=EMBED_DIM, ff_dim=FF_DIM, num_heads=2)\n",
        "caption_model = ImageCaptioningModel(\n",
        "    cnn_model=cnn_model,\n",
        "    encoder=encoder,\n",
        "    decoder=decoder,\n",
        "    image_aug=image_augmentation,\n",
        ")"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Model training"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 171,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "96/96 [==============================] - 357s 4s/step - loss: 24.4085 - acc: 0.1952 - val_loss: 19.6365 - val_acc: 0.3251\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "<keras.src.callbacks.History at 0x4a2a27310>"
            ]
          },
          "execution_count": 171,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Define the loss function\n",
        "cross_entropy = keras.losses.SparseCategoricalCrossentropy(\n",
        "    from_logits=False, reduction=\"none\"\n",
        ")\n",
        "\n",
        "# EarlyStopping criteria\n",
        "early_stopping = keras.callbacks.EarlyStopping(patience=3, restore_best_weights=True)\n",
        "\n",
        "\n",
        "# Learning Rate Scheduler for the optimizer\n",
        "class LRSchedule(keras.optimizers.schedules.LearningRateSchedule):\n",
        "    def __init__(self, post_warmup_learning_rate, warmup_steps):\n",
        "        super().__init__()\n",
        "        self.post_warmup_learning_rate = post_warmup_learning_rate\n",
        "        self.warmup_steps = warmup_steps\n",
        "\n",
        "    def __call__(self, step):\n",
        "        global_step = tf.cast(step, tf.float32)\n",
        "        warmup_steps = tf.cast(self.warmup_steps, tf.float32)\n",
        "        warmup_progress = global_step / warmup_steps\n",
        "        warmup_learning_rate = self.post_warmup_learning_rate * warmup_progress\n",
        "        return tf.cond(\n",
        "            global_step < warmup_steps,\n",
        "            lambda: warmup_learning_rate,\n",
        "            lambda: self.post_warmup_learning_rate,\n",
        "        )\n",
        "\n",
        "\n",
        "# Create a learning rate schedule\n",
        "num_train_steps = len(train_dataset) * EPOCHS\n",
        "num_warmup_steps = num_train_steps // 15\n",
        "lr_schedule = LRSchedule(post_warmup_learning_rate=1e-4, warmup_steps=num_warmup_steps)\n",
        "\n",
        "# Compile the model\n",
        "caption_model.compile(optimizer=tf.keras.optimizers.legacy.Adam(lr_schedule), loss=cross_entropy)\n",
        "\n",
        "# Fit the model\n",
        "caption_model.fit(\n",
        "    train_dataset,\n",
        "    epochs=EPOCHS,\n",
        "    validation_data=valid_dataset,\n",
        "    callbacks=[early_stopping],\n",
        ")"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Check sample predictions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 172,
      "metadata": {},
      "outputs": [],
      "source": [
        "\"\"\"\n",
        "## Check sample predictions\n",
        "\"\"\"\n",
        "\n",
        "vocab = vectorization.get_vocabulary()\n",
        "index_lookup = dict(zip(range(len(vocab)), vocab))\n",
        "max_decoded_sentence_length = SEQ_LENGTH - 1\n",
        "valid_images = list(valid_data.keys())\n",
        "\n",
        "def generate_caption():\n",
        "    # Select a random image from the validation dataset\n",
        "    sample_img = np.random.choice(valid_images)\n",
        "\n",
        "    # Read the image from the disk\n",
        "    sample_img = decode_and_resize(sample_img)\n",
        "    img = sample_img.numpy().clip(0, 255).astype(np.uint8)\n",
        "    plt.imshow(img)\n",
        "    plt.show()\n",
        "\n",
        "    # Pass the image to the CNN\n",
        "    img = tf.expand_dims(sample_img, 0)\n",
        "    img = caption_model.cnn_model(img)\n",
        "\n",
        "    # Pass the image features to the Transformer encoder\n",
        "    encoded_img = caption_model.encoder(img, training=False)\n",
        "\n",
        "    # Generate the caption using the Transformer decoder\n",
        "    decoded_caption = \"<start> \"\n",
        "    for i in range(max_decoded_sentence_length):\n",
        "        tokenized_caption = vectorization([decoded_caption])[:, :-1]\n",
        "        mask = tf.math.not_equal(tokenized_caption, 0)\n",
        "        predictions = caption_model.decoder(\n",
        "            tokenized_caption, encoded_img, training=False, mask=mask\n",
        "        )\n",
        "        sampled_token_index = np.argmax(predictions[0, i, :])\n",
        "        sampled_token = index_lookup[sampled_token_index]\n",
        "        if sampled_token == \"<end>\":\n",
        "            break\n",
        "        decoded_caption += \" \" + sampled_token\n",
        "\n",
        "    decoded_caption = decoded_caption.replace(\"<start> \", \"\")\n",
        "    decoded_caption = decoded_caption.replace(\" <end>\", \"\").strip()\n",
        "    print(\"Predicted Caption: \", decoded_caption)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 173,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Predicted Caption:  a man is standing on a beach\n"
          ]
        }
      ],
      "source": [
        "# Check predictions for a sample\n",
        "generate_caption()"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Saving and Converting the Model to Tensorflow Lite\n",
        "\n",
        "Save the Tensorflow Model from `Keras Model`.\n",
        "\n",
        "After the Model is saved to disk, convert the model to a more efficient mobile version of the model using Tensorflow Lite."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 174,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:Skipping full serialization of Keras layer <__main__.ImageCaptioningModel object at 0x4b2b65d10>, because it is not built.\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:Skipping full serialization of Keras layer <__main__.ImageCaptioningModel object at 0x4b2b65d10>, because it is not built.\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:Model's `__init__()` arguments contain non-serializable objects. Please implement a `get_config()` method in the subclassed Model for proper saving and loading. Defaulting to empty config.\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:Model's `__init__()` arguments contain non-serializable objects. Please implement a `get_config()` method in the subclassed Model for proper saving and loading. Defaulting to empty config.\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:Model's `__init__()` arguments contain non-serializable objects. Please implement a `get_config()` method in the subclassed Model for proper saving and loading. Defaulting to empty config.\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:Model's `__init__()` arguments contain non-serializable objects. Please implement a `get_config()` method in the subclassed Model for proper saving and loading. Defaulting to empty config.\n"
          ]
        },
        {
          "ename": "OperatorNotAllowedInGraphError",
          "evalue": "Exception encountered when calling layer 'image_captioning_model_14' (type ImageCaptioningModel).\n\nin user code:\n\n    File \"/var/folders/2b/p4gxgkbj4qlg9wgcqphy88sw0000gq/T/ipykernel_94456/1975170582.py\", line 276, in call  *\n        vocab = vectorization.get_vocabulary()\n    File \"/Users/aa849190/miniconda/envs/my-proj/lib/python3.11/site-packages/keras/src/layers/preprocessing/text_vectorization.py\", line 493, in get_vocabulary  **\n        return self._lookup_layer.get_vocabulary(include_special_tokens)\n    File \"/Users/aa849190/miniconda/envs/my-proj/lib/python3.11/site-packages/keras/src/layers/preprocessing/index_lookup.py\", line 382, in get_vocabulary\n        if self.lookup_table.size() == 0:\n\n    OperatorNotAllowedInGraphError: Using a symbolic `tf.Tensor` as a Python `bool` is not allowed: AutoGraph did convert this function. This might indicate you are trying to use an unsupported feature.\n\n\nCall arguments received by layer 'image_captioning_model_14' (type ImageCaptioningModel):\n  • image=tf.Tensor(shape=(299, 299, 3), dtype=float32)",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mOperatorNotAllowedInGraphError\u001b[0m            Traceback (most recent call last)",
            "Cell \u001b[0;32mIn[174], line 14\u001b[0m\n\u001b[1;32m      7\u001b[0m converter \u001b[39m=\u001b[39m tf\u001b[39m.\u001b[39mlite\u001b[39m.\u001b[39mTFLiteConverter\u001b[39m.\u001b[39mfrom_keras_model(caption_model)\n\u001b[1;32m      9\u001b[0m converter\u001b[39m.\u001b[39mtarget_spec\u001b[39m.\u001b[39msupported_ops \u001b[39m=\u001b[39m [\n\u001b[1;32m     10\u001b[0m   tf\u001b[39m.\u001b[39mlite\u001b[39m.\u001b[39mOpsSet\u001b[39m.\u001b[39mTFLITE_BUILTINS, \u001b[39m# enable TensorFlow Lite ops.\u001b[39;00m\n\u001b[1;32m     11\u001b[0m   tf\u001b[39m.\u001b[39mlite\u001b[39m.\u001b[39mOpsSet\u001b[39m.\u001b[39mSELECT_TF_OPS \u001b[39m# enable TensorFlow ops.\u001b[39;00m\n\u001b[1;32m     12\u001b[0m ]\n\u001b[0;32m---> 14\u001b[0m tflite_model \u001b[39m=\u001b[39m converter\u001b[39m.\u001b[39mconvert()\n\u001b[1;32m     16\u001b[0m \u001b[39m# Print the signatures from the converted model\u001b[39;00m\n\u001b[1;32m     17\u001b[0m interpreter \u001b[39m=\u001b[39m tf\u001b[39m.\u001b[39mlite\u001b[39m.\u001b[39mInterpreter(model_content\u001b[39m=\u001b[39mtflite_model)\n",
            "File \u001b[0;32m~/miniconda/envs/my-proj/lib/python3.11/site-packages/tensorflow/lite/python/lite.py:1065\u001b[0m, in \u001b[0;36m_export_metrics.<locals>.wrapper\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1062\u001b[0m \u001b[39m@functools\u001b[39m\u001b[39m.\u001b[39mwraps(convert_func)\n\u001b[1;32m   1063\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mwrapper\u001b[39m(\u001b[39mself\u001b[39m, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[1;32m   1064\u001b[0m   \u001b[39m# pylint: disable=protected-access\u001b[39;00m\n\u001b[0;32m-> 1065\u001b[0m   \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_convert_and_export_metrics(convert_func, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n",
            "File \u001b[0;32m~/miniconda/envs/my-proj/lib/python3.11/site-packages/tensorflow/lite/python/lite.py:1042\u001b[0m, in \u001b[0;36mTFLiteConverterBase._convert_and_export_metrics\u001b[0;34m(self, convert_func, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1040\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_save_conversion_params_metric()\n\u001b[1;32m   1041\u001b[0m start_time \u001b[39m=\u001b[39m time\u001b[39m.\u001b[39mprocess_time()\n\u001b[0;32m-> 1042\u001b[0m result \u001b[39m=\u001b[39m convert_func(\u001b[39mself\u001b[39m, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[1;32m   1043\u001b[0m elapsed_time_ms \u001b[39m=\u001b[39m (time\u001b[39m.\u001b[39mprocess_time() \u001b[39m-\u001b[39m start_time) \u001b[39m*\u001b[39m \u001b[39m1000\u001b[39m\n\u001b[1;32m   1044\u001b[0m \u001b[39mif\u001b[39;00m result:\n",
            "File \u001b[0;32m~/miniconda/envs/my-proj/lib/python3.11/site-packages/tensorflow/lite/python/lite.py:1531\u001b[0m, in \u001b[0;36mTFLiteKerasModelConverterV2.convert\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m   1527\u001b[0m \u001b[39mif\u001b[39;00m saved_model_convert_result:\n\u001b[1;32m   1528\u001b[0m   \u001b[39mreturn\u001b[39;00m saved_model_convert_result\n\u001b[1;32m   1530\u001b[0m graph_def, input_tensors, output_tensors, frozen_func \u001b[39m=\u001b[39m (\n\u001b[0;32m-> 1531\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_freeze_keras_model()\n\u001b[1;32m   1532\u001b[0m )\n\u001b[1;32m   1534\u001b[0m graph_def \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_optimize_tf_model(\n\u001b[1;32m   1535\u001b[0m     graph_def, input_tensors, output_tensors, frozen_func\n\u001b[1;32m   1536\u001b[0m )\n\u001b[1;32m   1538\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39msuper\u001b[39m(TFLiteKerasModelConverterV2, \u001b[39mself\u001b[39m)\u001b[39m.\u001b[39mconvert(\n\u001b[1;32m   1539\u001b[0m     graph_def, input_tensors, output_tensors\n\u001b[1;32m   1540\u001b[0m )\n",
            "File \u001b[0;32m~/miniconda/envs/my-proj/lib/python3.11/site-packages/tensorflow/lite/python/convert_phase.py:215\u001b[0m, in \u001b[0;36mconvert_phase.<locals>.actual_decorator.<locals>.wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    213\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m \u001b[39mas\u001b[39;00m error:\n\u001b[1;32m    214\u001b[0m   report_error_message(\u001b[39mstr\u001b[39m(error))\n\u001b[0;32m--> 215\u001b[0m   \u001b[39mraise\u001b[39;00m error \u001b[39mfrom\u001b[39;00m \u001b[39mNone\u001b[39;00m\n",
            "File \u001b[0;32m~/miniconda/envs/my-proj/lib/python3.11/site-packages/tensorflow/lite/python/convert_phase.py:205\u001b[0m, in \u001b[0;36mconvert_phase.<locals>.actual_decorator.<locals>.wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    202\u001b[0m \u001b[39m@functools\u001b[39m\u001b[39m.\u001b[39mwraps(func)\n\u001b[1;32m    203\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mwrapper\u001b[39m(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[1;32m    204\u001b[0m   \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m--> 205\u001b[0m     \u001b[39mreturn\u001b[39;00m func(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[1;32m    206\u001b[0m   \u001b[39mexcept\u001b[39;00m ConverterError \u001b[39mas\u001b[39;00m converter_error:\n\u001b[1;32m    207\u001b[0m     \u001b[39mif\u001b[39;00m converter_error\u001b[39m.\u001b[39merrors:\n",
            "File \u001b[0;32m~/miniconda/envs/my-proj/lib/python3.11/site-packages/tensorflow/lite/python/lite.py:1478\u001b[0m, in \u001b[0;36mTFLiteKerasModelConverterV2._freeze_keras_model\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m   1476\u001b[0m \u001b[39m# TODO(b/169898786): Use the Keras public API when TFLite moves out of TF\u001b[39;00m\n\u001b[1;32m   1477\u001b[0m func \u001b[39m=\u001b[39m _trace_model_call(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_keras_model, input_signature)\n\u001b[0;32m-> 1478\u001b[0m concrete_func \u001b[39m=\u001b[39m func\u001b[39m.\u001b[39mget_concrete_function()\n\u001b[1;32m   1479\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_funcs \u001b[39m=\u001b[39m [concrete_func]\n\u001b[1;32m   1481\u001b[0m frozen_func, graph_def \u001b[39m=\u001b[39m (\n\u001b[1;32m   1482\u001b[0m     _convert_to_constants\u001b[39m.\u001b[39mconvert_variables_to_constants_v2_as_graph(\n\u001b[1;32m   1483\u001b[0m         \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_funcs[\u001b[39m0\u001b[39m], lower_control_flow\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m\n\u001b[1;32m   1484\u001b[0m     )\n\u001b[1;32m   1485\u001b[0m )\n",
            "File \u001b[0;32m~/miniconda/envs/my-proj/lib/python3.11/site-packages/tensorflow/python/eager/polymorphic_function/polymorphic_function.py:1189\u001b[0m, in \u001b[0;36mFunction.get_concrete_function\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1187\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mget_concrete_function\u001b[39m(\u001b[39mself\u001b[39m, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[1;32m   1188\u001b[0m   \u001b[39m# Implements GenericFunction.get_concrete_function.\u001b[39;00m\n\u001b[0;32m-> 1189\u001b[0m   concrete \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_get_concrete_function_garbage_collected(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[1;32m   1190\u001b[0m   concrete\u001b[39m.\u001b[39m_garbage_collector\u001b[39m.\u001b[39mrelease()  \u001b[39m# pylint: disable=protected-access\u001b[39;00m\n\u001b[1;32m   1191\u001b[0m   \u001b[39mreturn\u001b[39;00m concrete\n",
            "File \u001b[0;32m~/miniconda/envs/my-proj/lib/python3.11/site-packages/tensorflow/python/eager/polymorphic_function/polymorphic_function.py:1169\u001b[0m, in \u001b[0;36mFunction._get_concrete_function_garbage_collected\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1167\u001b[0m   \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_variable_creation_fn \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m   1168\u001b[0m     initializers \u001b[39m=\u001b[39m []\n\u001b[0;32m-> 1169\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_initialize(args, kwargs, add_initializers_to\u001b[39m=\u001b[39minitializers)\n\u001b[1;32m   1170\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_initialize_uninitialized_variables(initializers)\n\u001b[1;32m   1172\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_created_variables:\n\u001b[1;32m   1173\u001b[0m   \u001b[39m# In this case we have created variables on the first call, so we run the\u001b[39;00m\n\u001b[1;32m   1174\u001b[0m   \u001b[39m# version which is guaranteed to never create variables.\u001b[39;00m\n",
            "File \u001b[0;32m~/miniconda/envs/my-proj/lib/python3.11/site-packages/tensorflow/python/eager/polymorphic_function/polymorphic_function.py:694\u001b[0m, in \u001b[0;36mFunction._initialize\u001b[0;34m(self, args, kwds, add_initializers_to)\u001b[0m\n\u001b[1;32m    691\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_variable_creation_fn\u001b[39m.\u001b[39m_name \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_name  \u001b[39m# pylint: disable=protected-access\u001b[39;00m\n\u001b[1;32m    692\u001b[0m \u001b[39m# Force the definition of the function for these arguments\u001b[39;00m\n\u001b[1;32m    693\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_concrete_variable_creation_fn \u001b[39m=\u001b[39m (\n\u001b[0;32m--> 694\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_variable_creation_fn    \u001b[39m# pylint: disable=protected-access\u001b[39;00m\n\u001b[1;32m    695\u001b[0m     \u001b[39m.\u001b[39m_get_concrete_function_internal_garbage_collected(\n\u001b[1;32m    696\u001b[0m         \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwds))\n\u001b[1;32m    698\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39minvalid_creator_scope\u001b[39m(\u001b[39m*\u001b[39munused_args, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39munused_kwds):\n\u001b[1;32m    699\u001b[0m \u001b[39m  \u001b[39m\u001b[39m\"\"\"Disables variable creation.\"\"\"\u001b[39;00m\n",
            "File \u001b[0;32m~/miniconda/envs/my-proj/lib/python3.11/site-packages/tensorflow/python/eager/polymorphic_function/tracing_compiler.py:176\u001b[0m, in \u001b[0;36mTracingCompiler._get_concrete_function_internal_garbage_collected\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    174\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"Returns a concrete function which cleans up its graph function.\"\"\"\u001b[39;00m\n\u001b[1;32m    175\u001b[0m \u001b[39mwith\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_lock:\n\u001b[0;32m--> 176\u001b[0m   concrete_function, _ \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_maybe_define_concrete_function(args, kwargs)\n\u001b[1;32m    177\u001b[0m \u001b[39mreturn\u001b[39;00m concrete_function\n",
            "File \u001b[0;32m~/miniconda/envs/my-proj/lib/python3.11/site-packages/tensorflow/python/eager/polymorphic_function/tracing_compiler.py:171\u001b[0m, in \u001b[0;36mTracingCompiler._maybe_define_concrete_function\u001b[0;34m(self, args, kwargs)\u001b[0m\n\u001b[1;32m    168\u001b[0m   args \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39minput_signature\n\u001b[1;32m    169\u001b[0m   kwargs \u001b[39m=\u001b[39m {}\n\u001b[0;32m--> 171\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_maybe_define_function(args, kwargs)\n",
            "File \u001b[0;32m~/miniconda/envs/my-proj/lib/python3.11/site-packages/tensorflow/python/eager/polymorphic_function/tracing_compiler.py:398\u001b[0m, in \u001b[0;36mTracingCompiler._maybe_define_function\u001b[0;34m(self, args, kwargs)\u001b[0m\n\u001b[1;32m    395\u001b[0m args \u001b[39m=\u001b[39m placeholder_bound_args\u001b[39m.\u001b[39margs\n\u001b[1;32m    396\u001b[0m kwargs \u001b[39m=\u001b[39m placeholder_bound_args\u001b[39m.\u001b[39mkwargs\n\u001b[0;32m--> 398\u001b[0m concrete_function \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_create_concrete_function(\n\u001b[1;32m    399\u001b[0m     args, kwargs, func_graph)\n\u001b[1;32m    401\u001b[0m \u001b[39m# TODO(b/263520817): Remove access to private attribute.\u001b[39;00m\n\u001b[1;32m    402\u001b[0m graph_capture_container \u001b[39m=\u001b[39m concrete_function\u001b[39m.\u001b[39mgraph\u001b[39m.\u001b[39mfunction_captures\n",
            "File \u001b[0;32m~/miniconda/envs/my-proj/lib/python3.11/site-packages/tensorflow/python/eager/polymorphic_function/tracing_compiler.py:305\u001b[0m, in \u001b[0;36mTracingCompiler._create_concrete_function\u001b[0;34m(self, args, kwargs, func_graph)\u001b[0m\n\u001b[1;32m    301\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m    302\u001b[0m   arg_names \u001b[39m=\u001b[39m base_arg_names\n\u001b[1;32m    304\u001b[0m concrete_function \u001b[39m=\u001b[39m monomorphic_function\u001b[39m.\u001b[39mConcreteFunction(\n\u001b[0;32m--> 305\u001b[0m     func_graph_module\u001b[39m.\u001b[39mfunc_graph_from_py_func(\n\u001b[1;32m    306\u001b[0m         \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_name,\n\u001b[1;32m    307\u001b[0m         \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_python_function,\n\u001b[1;32m    308\u001b[0m         args,\n\u001b[1;32m    309\u001b[0m         kwargs,\n\u001b[1;32m    310\u001b[0m         \u001b[39mNone\u001b[39;00m,\n\u001b[1;32m    311\u001b[0m         func_graph\u001b[39m=\u001b[39mfunc_graph,\n\u001b[1;32m    312\u001b[0m         arg_names\u001b[39m=\u001b[39marg_names,\n\u001b[1;32m    313\u001b[0m         capture_by_value\u001b[39m=\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_capture_by_value,\n\u001b[1;32m    314\u001b[0m         create_placeholders\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m),\n\u001b[1;32m    315\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_function_attributes,\n\u001b[1;32m    316\u001b[0m     spec\u001b[39m=\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mfunction_spec,\n\u001b[1;32m    317\u001b[0m     \u001b[39m# Tell the ConcreteFunction to clean up its graph once it goes out of\u001b[39;00m\n\u001b[1;32m    318\u001b[0m     \u001b[39m# scope. This is not the default behavior since it gets used in some\u001b[39;00m\n\u001b[1;32m    319\u001b[0m     \u001b[39m# places (like Keras) where the FuncGraph lives longer than the\u001b[39;00m\n\u001b[1;32m    320\u001b[0m     \u001b[39m# ConcreteFunction.\u001b[39;00m\n\u001b[1;32m    321\u001b[0m     shared_func_graph\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m)\n\u001b[1;32m    322\u001b[0m \u001b[39mreturn\u001b[39;00m concrete_function\n",
            "File \u001b[0;32m~/miniconda/envs/my-proj/lib/python3.11/site-packages/tensorflow/python/framework/func_graph.py:1055\u001b[0m, in \u001b[0;36mfunc_graph_from_py_func\u001b[0;34m(name, python_func, args, kwargs, signature, func_graph, add_control_dependencies, arg_names, op_return_value, collections, capture_by_value, create_placeholders)\u001b[0m\n\u001b[1;32m   1052\u001b[0m   \u001b[39mreturn\u001b[39;00m x\n\u001b[1;32m   1054\u001b[0m _, original_func \u001b[39m=\u001b[39m tf_decorator\u001b[39m.\u001b[39munwrap(python_func)\n\u001b[0;32m-> 1055\u001b[0m func_outputs \u001b[39m=\u001b[39m python_func(\u001b[39m*\u001b[39mfunc_args, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mfunc_kwargs)\n\u001b[1;32m   1057\u001b[0m \u001b[39m# invariant: `func_outputs` contains only Tensors, CompositeTensors,\u001b[39;00m\n\u001b[1;32m   1058\u001b[0m \u001b[39m# TensorArrays and `None`s.\u001b[39;00m\n\u001b[1;32m   1059\u001b[0m func_outputs \u001b[39m=\u001b[39m variable_utils\u001b[39m.\u001b[39mconvert_variables_to_tensors(func_outputs)\n",
            "File \u001b[0;32m~/miniconda/envs/my-proj/lib/python3.11/site-packages/tensorflow/python/eager/polymorphic_function/polymorphic_function.py:597\u001b[0m, in \u001b[0;36mFunction._compiler_with_scope.<locals>.wrapped_fn\u001b[0;34m(*args, **kwds)\u001b[0m\n\u001b[1;32m    593\u001b[0m \u001b[39mwith\u001b[39;00m default_graph\u001b[39m.\u001b[39m_variable_creator_scope(scope, priority\u001b[39m=\u001b[39m\u001b[39m50\u001b[39m):  \u001b[39m# pylint: disable=protected-access\u001b[39;00m\n\u001b[1;32m    594\u001b[0m   \u001b[39m# __wrapped__ allows AutoGraph to swap in a converted function. We give\u001b[39;00m\n\u001b[1;32m    595\u001b[0m   \u001b[39m# the function a weak reference to itself to avoid a reference cycle.\u001b[39;00m\n\u001b[1;32m    596\u001b[0m   \u001b[39mwith\u001b[39;00m OptionalXlaContext(compile_with_xla):\n\u001b[0;32m--> 597\u001b[0m     out \u001b[39m=\u001b[39m weak_wrapped_fn()\u001b[39m.\u001b[39m__wrapped__(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwds)\n\u001b[1;32m    598\u001b[0m   \u001b[39mreturn\u001b[39;00m out\n",
            "File \u001b[0;32m~/miniconda/envs/my-proj/lib/python3.11/site-packages/tensorflow/lite/python/tflite_keras_util.py:190\u001b[0m, in \u001b[0;36mtrace_model_call.<locals>._wrapped_model\u001b[0;34m(*args)\u001b[0m\n\u001b[1;32m    186\u001b[0m inputs \u001b[39m=\u001b[39m args[\u001b[39m0\u001b[39m] \u001b[39mif\u001b[39;00m \u001b[39mlen\u001b[39m(input_signature) \u001b[39m==\u001b[39m \u001b[39m1\u001b[39m \u001b[39melse\u001b[39;00m \u001b[39mlist\u001b[39m(args)\n\u001b[1;32m    188\u001b[0m \u001b[39mwith\u001b[39;00m keras_deps\u001b[39m.\u001b[39mget_call_context_function()()\u001b[39m.\u001b[39menter(\n\u001b[1;32m    189\u001b[0m     model, inputs\u001b[39m=\u001b[39minputs, build_graph\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m, training\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m, saving\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m):\n\u001b[0;32m--> 190\u001b[0m   outputs \u001b[39m=\u001b[39m model(inputs, training\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m)\n\u001b[1;32m    192\u001b[0m \u001b[39mreturn\u001b[39;00m outputs\n",
            "File \u001b[0;32m~/miniconda/envs/my-proj/lib/python3.11/site-packages/keras/src/utils/traceback_utils.py:70\u001b[0m, in \u001b[0;36mfilter_traceback.<locals>.error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     67\u001b[0m     filtered_tb \u001b[39m=\u001b[39m _process_traceback_frames(e\u001b[39m.\u001b[39m__traceback__)\n\u001b[1;32m     68\u001b[0m     \u001b[39m# To get the full stack trace, call:\u001b[39;00m\n\u001b[1;32m     69\u001b[0m     \u001b[39m# `tf.debugging.disable_traceback_filtering()`\u001b[39;00m\n\u001b[0;32m---> 70\u001b[0m     \u001b[39mraise\u001b[39;00m e\u001b[39m.\u001b[39mwith_traceback(filtered_tb) \u001b[39mfrom\u001b[39;00m \u001b[39mNone\u001b[39;00m\n\u001b[1;32m     71\u001b[0m \u001b[39mfinally\u001b[39;00m:\n\u001b[1;32m     72\u001b[0m     \u001b[39mdel\u001b[39;00m filtered_tb\n",
            "File \u001b[0;32m~/miniconda/envs/my-proj/lib/python3.11/site-packages/tensorflow/python/eager/polymorphic_function/autograph_util.py:52\u001b[0m, in \u001b[0;36mpy_func_from_autograph.<locals>.autograph_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     50\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m \u001b[39mas\u001b[39;00m e:  \u001b[39m# pylint:disable=broad-except\u001b[39;00m\n\u001b[1;32m     51\u001b[0m   \u001b[39mif\u001b[39;00m \u001b[39mhasattr\u001b[39m(e, \u001b[39m\"\u001b[39m\u001b[39mag_error_metadata\u001b[39m\u001b[39m\"\u001b[39m):\n\u001b[0;32m---> 52\u001b[0m     \u001b[39mraise\u001b[39;00m e\u001b[39m.\u001b[39mag_error_metadata\u001b[39m.\u001b[39mto_exception(e)\n\u001b[1;32m     53\u001b[0m   \u001b[39melse\u001b[39;00m:\n\u001b[1;32m     54\u001b[0m     \u001b[39mraise\u001b[39;00m\n",
            "\u001b[0;31mOperatorNotAllowedInGraphError\u001b[0m: Exception encountered when calling layer 'image_captioning_model_14' (type ImageCaptioningModel).\n\nin user code:\n\n    File \"/var/folders/2b/p4gxgkbj4qlg9wgcqphy88sw0000gq/T/ipykernel_94456/1975170582.py\", line 276, in call  *\n        vocab = vectorization.get_vocabulary()\n    File \"/Users/aa849190/miniconda/envs/my-proj/lib/python3.11/site-packages/keras/src/layers/preprocessing/text_vectorization.py\", line 493, in get_vocabulary  **\n        return self._lookup_layer.get_vocabulary(include_special_tokens)\n    File \"/Users/aa849190/miniconda/envs/my-proj/lib/python3.11/site-packages/keras/src/layers/preprocessing/index_lookup.py\", line 382, in get_vocabulary\n        if self.lookup_table.size() == 0:\n\n    OperatorNotAllowedInGraphError: Using a symbolic `tf.Tensor` as a Python `bool` is not allowed: AutoGraph did convert this function. This might indicate you are trying to use an unsupported feature.\n\n\nCall arguments received by layer 'image_captioning_model_14' (type ImageCaptioningModel):\n  • image=tf.Tensor(shape=(299, 299, 3), dtype=float32)"
          ]
        }
      ],
      "source": [
        "# Build Keras model.\n",
        "#input_shape=(*IMAGE_SIZE, 3)\n",
        "#caption_model.build(input_shape)\n",
        "\n",
        "# Convert the keras model using TFLiteConverter.\n",
        "# Keras model converter API uses the default signature automatically.\n",
        "converter = tf.lite.TFLiteConverter.from_keras_model(caption_model)\n",
        "\n",
        "converter.target_spec.supported_ops = [\n",
        "  tf.lite.OpsSet.TFLITE_BUILTINS, # enable TensorFlow Lite ops.\n",
        "  tf.lite.OpsSet.SELECT_TF_OPS # enable TensorFlow ops.\n",
        "]\n",
        "\n",
        "tflite_model = converter.convert()\n",
        "\n",
        "# Print the signatures from the converted model\n",
        "interpreter = tf.lite.Interpreter(model_content=tflite_model)\n",
        "\n",
        "signatures = interpreter.get_signature_list()\n",
        "print('Signatures:', signatures)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 158,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Signature: {'serving_default': {'inputs': ['x'], 'outputs': ['encoded_result']}}\n",
            "Input: [{'name': 'serving_default_x:0', 'index': 0, 'shape': array([1], dtype=int32), 'shape_signature': array([-1], dtype=int32), 'dtype': <class 'numpy.float32'>, 'quantization': (0.0, 0), 'quantization_parameters': {'scales': array([], dtype=float32), 'zero_points': array([], dtype=int32), 'quantized_dimension': 0}, 'sparsity_parameters': {}}]\n",
            "Output: [{'name': 'PartitionedCall:0', 'index': 1, 'shape': array([1], dtype=int32), 'shape_signature': array([-1], dtype=int32), 'dtype': <class 'numpy.float32'>, 'quantization': (0.0, 0), 'quantization_parameters': {'scales': array([], dtype=float32), 'zero_points': array([], dtype=int32), 'quantized_dimension': 0}, 'sparsity_parameters': {}}]\n"
          ]
        }
      ],
      "source": [
        "# Convert the model\n",
        "#converter = tf.lite.TFLiteConverter.from_saved_model(\"my_model2\") # path to the SavedModel directory\n",
        "#converter = tf.lite.TFLiteConverter.from_keras_model(tflite_model)\n",
        "#tflite_model = converter.convert()\n",
        "\n",
        "# Save the model.\n",
        "with open('model2.tflite', 'wb') as f:\n",
        "  f.write(tflite_model)\n",
        "\n",
        "# Load the TFLite model and allocate tensors.\n",
        "interpreter = tf.lite.Interpreter(model_path=\"model2.tflite\")\n",
        "interpreter.allocate_tensors()\n",
        "\n",
        "# Get input and output tensors.\n",
        "input_details = interpreter.get_input_details()\n",
        "output_details = interpreter.get_output_details()\n",
        "\n",
        "print('Signature:', interpreter.get_signature_list())\n",
        "print('Input:', input_details)\n",
        "print('Output:',output_details)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Load and run the TFLite Model in Python\n",
        "\n",
        "The Python API for running an inference is provided in the tf.lite module. From which, you mostly need only tf.lite.Interpreter to load a model and run an inference.\n",
        "\n",
        "The following example shows how to use the Python interpreter to load a .tflite file and run inference with random input data:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 164,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Results: {'encoded_result': 2.0}\n"
          ]
        }
      ],
      "source": [
        "# Load the TFLite model and allocate tensors.\n",
        "interpreter = tf.lite.Interpreter(model_path=\"model2.tflite\")\n",
        "interpreter.allocate_tensors()\n",
        "\n",
        "# encode and decode are callable with input as arguments.\n",
        "my_signature = interpreter.get_signature_runner('serving_default')\n",
        "\n",
        "# my_signature is callable with input as arguments.\n",
        "input = tf.constant(1, dtype=tf.float32)\n",
        "output = my_signature(x=input)\n",
        "print('Results:', output)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## End Notes\n",
        "\n",
        "```\n",
        "We saw that the model starts to generate reasonable captions after a few epochs. To keep\n",
        "this example easily runnable, we have trained it with a few constraints, like a minimal\n",
        "number of attention heads. To improve the predictions, you can try changing these training\n",
        "settings and find a good model for your use case.\n",
        "```"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [],
      "name": "image_captioning.ipynb",
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "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": 0
}