ml_kit_custom_model.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TBFXQGKYUc4X"
      },
      "source": [
        "##### Copyright 2023 fbernaly."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "1z4xy2gTUc4a"
      },
      "outputs": [],
      "source": [
        "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
        "# you may not use this file except in compliance with the License.\n",
        "# You may obtain a copy of the License at\n",
        "#\n",
        "# https://www.apache.org/licenses/LICENSE-2.0\n",
        "#\n",
        "# Unless required by applicable law or agreed to in writing, software\n",
        "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
        "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
        "# See the License for the specific language governing permissions and\n",
        "# limitations under the License."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I9_dxNJh4QYb"
      },
      "source": [
        "<table class=\"tfo-notebook-buttons\" align=\"left\">\n",
        "  <td>\n",
        "    <a target=\"_blank\" href=\"https://colab.research.google.com/github/flutter-ml/mlkit-custom-model/blob/main/ml_kit_custom_model.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" />Run in Google Colab</a>\n",
        "  </td>\n",
        "  <td>\n",
        "    <a target=\"_blank\" href=\"https://github.com/flutter-ml/mlkit-custom-model/blob/main/ml_kit_custom_model.ipynb\"><img src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" />View source on GitHub</a>\n",
        "  </td>\n",
        "</table>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FE7KNzPPVrVV"
      },
      "source": [
        "# Custom Model for ML Kit: Image classification"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gN7G9GFmVrVY"
      },
      "source": [
        "This notebook is based on the [Image classification notebook](https://www.tensorflow.org/tutorials/images/classification) found in [TensorFlow](https://www.tensorflow.org/).\n",
        "\n",
        "The main focus of this notebook is to demonstrate how to convert a keras model to a [TensorFlow Lite](https://www.tensorflow.org/lite/) model, and how to make it compatible for on-device machine learning on mobile using [ML Kit](https://developers.google.com/ml-kit).\n",
        "\n",
        "This tutorial shows how to create a [custom model](https://developers.google.com/ml-kit/custom-models) for [ML Kit](https://developers.google.com/ml-kit) to classify images of flowers using a `tf.keras.Sequential` model and load data using `tf.keras.utils.image_dataset_from_directory`. It demonstrates the following concepts:\n",
        "\n",
        "\n",
        "* Efficiently loading a dataset off disk.\n",
        "* Identifying overfitting and applying techniques to mitigate it, including data augmentation and dropout.\n",
        "\n",
        "This tutorial follows a basic machine learning workflow:\n",
        "\n",
        "1. Examine and understand data\n",
        "2. Build an input pipeline\n",
        "3. Build the model\n",
        "4. Train the model\n",
        "5. Test the model\n",
        "6. Improve the model and repeat the process\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zF9uvbXNVrVY"
      },
      "source": [
        "## Setup\n",
        "\n",
        "Import TensorFlow and other necessary libraries:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "L1WtoaOHVrVh"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import matplotlib.pyplot as plt\n",
        "import flatbuffers\n",
        "import tensorflow as tf\n",
        "import pathlib\n",
        "import numpy as np"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UZZI6lNkVrVm"
      },
      "source": [
        "## Download and explore the dataset"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DPHx8-t-VrVo"
      },
      "source": [
        "This tutorial uses a dataset of about 3,700 photos of flowers. The dataset contains five sub-directories, one per class:\n",
        "\n",
        "```\n",
        "flower_photo/\n",
        "  daisy/\n",
        "  dandelion/\n",
        "  roses/\n",
        "  sunflowers/\n",
        "  tulips/\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "57CcilYSG0zv",
        "outputId": "c8a5f404-8e27-4c26-8627-d69efe489c7e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "directory: /root/.keras/datasets/flower_photos\n"
          ]
        }
      ],
      "source": [
        "dataset_url = \"https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz\"\n",
        "data_dir = tf.keras.utils.get_file('flower_photos.tar', origin=dataset_url, extract=True)\n",
        "\n",
        "data_dir = pathlib.Path(data_dir).with_suffix('')\n",
        "\n",
        "print(\"directory: {}\".format(data_dir))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VpmywIlsVrVx"
      },
      "source": [
        "After downloading, you should now have a copy of the dataset available. There are 3,670 total images:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SbtTDYhOHZb6",
        "outputId": "cf9bfa59-6bb1-4767-f68a-090b264c5f04"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "3670\n"
          ]
        }
      ],
      "source": [
        "image_count = len(list(data_dir.glob('*/*.jpg')))\n",
        "print(image_count)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gIjgz7_JIo_m"
      },
      "source": [
        "## Load data using a Keras utility\n",
        "\n",
        "Next, load these images off disk using the helpful `tf.keras.utils.image_dataset_from_directory` utility. This will take you from a directory of images on disk to a `tf.data.Dataset` in just a couple lines of code. If you like, you can also write your own data loading code from scratch by visiting the [Load and preprocess images](https://www.tensorflow.org/tutorials/load_data/images) tutorial."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xyDNn9MbIzfT"
      },
      "source": [
        "### Create a dataset"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "anqiK_AGI086"
      },
      "source": [
        "Define some parameters for the loader:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "H74l2DoDI2XD"
      },
      "outputs": [],
      "source": [
        "batch_size = 32\n",
        "img_height = 180\n",
        "img_width = 180"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pFBhRrrEI49z"
      },
      "source": [
        "It's good practice to use a validation split when developing your model. Use 80% of the images for training and 20% for validation."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fIR0kRZiI_AT",
        "outputId": "9e16abd1-18ed-46da-e5d4-397c4214472d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Found 3670 files belonging to 5 classes.\n",
            "Using 2936 files for training.\n"
          ]
        }
      ],
      "source": [
        "train_ds = tf.keras.utils.image_dataset_from_directory(\n",
        "  data_dir,\n",
        "  validation_split=0.2,\n",
        "  subset=\"training\",\n",
        "  seed=123,\n",
        "  shuffle=True,\n",
        "  image_size=(img_height, img_width),\n",
        "  batch_size=batch_size)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iscU3UoVJBXj",
        "outputId": "f245faea-4299-4abd-b8a5-0f3127528f39"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Found 3670 files belonging to 5 classes.\n",
            "Using 734 files for validation.\n"
          ]
        }
      ],
      "source": [
        "val_ds = tf.keras.utils.image_dataset_from_directory(\n",
        "  data_dir,\n",
        "  validation_split=0.2,\n",
        "  subset=\"validation\",\n",
        "  seed=123,\n",
        "  shuffle=True,\n",
        "  image_size=(img_height, img_width),\n",
        "  batch_size=batch_size)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WLQULyAvJC3X"
      },
      "source": [
        "You can find the class names in the `class_names` attribute on these datasets. These correspond to the directory names in alphabetical order."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZHAxkHX5JD3k",
        "outputId": "091115b8-3d25-4e72-afcf-24c7fc0a850d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "['daisy', 'dandelion', 'roses', 'sunflowers', 'tulips']\n"
          ]
        }
      ],
      "source": [
        "class_names = train_ds.class_names\n",
        "print(class_names)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ITa8euI-XrQF"
      },
      "source": [
        "Save those class names to `labels.txt`, it will be used later for metadata."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "iaWIh12JXqWZ"
      },
      "outputs": [],
      "source": [
        "label_file_path = 'labels.txt'\n",
        "with open(label_file_path, 'w') as f:\n",
        "    f.write('\\n'.join(class_names))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4Dr0at41KcAU"
      },
      "source": [
        "## Configure the dataset for performance\n",
        "\n",
        "Make sure to use buffered prefetching, so you can yield data from disk without having I/O become blocking. These are two important methods you should use when loading data:\n",
        "\n",
        "- `Dataset.cache` keeps the images in memory after they're loaded off disk during the first epoch. This will ensure the dataset does not become a bottleneck while training your model. If your dataset is too large to fit into memory, you can also use this method to create a performant on-disk cache.\n",
        "- `Dataset.prefetch` overlaps data preprocessing and model execution while training.\n",
        "\n",
        "Interested readers can learn more about both methods, as well as how to cache data to disk in the *Prefetching* section of the [Better performance with the tf.data API](../../guide/data_performance.ipynb) guide."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nOjJSm7DKoZA"
      },
      "outputs": [],
      "source": [
        "AUTOTUNE = tf.data.AUTOTUNE\n",
        "\n",
        "train_ds = train_ds.cache().shuffle(1000).prefetch(buffer_size=AUTOTUNE)\n",
        "val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aiiFaJtR3xha"
      },
      "source": [
        "## Train Keras model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WcUTyDOPKucd"
      },
      "source": [
        "### Create the model\n",
        "\n",
        "The Keras [Sequential](https://www.tensorflow.org/guide/keras/sequential_model) model consists of three convolution blocks (`tf.keras.layers.Conv2D`) with a max pooling layer (`tf.keras.layers.MaxPooling2D`) in each of them. There's a fully-connected layer (`tf.keras.layers.Dense`) with 128 units on top of it that is activated by a ReLU activation function (`'relu'`).\n",
        "\n",
        "The RGB channel values are in the `[0, 255]` range. This is not ideal for a neural network; in general you should seek to make your input values small.\n",
        "\n",
        "Here, you will standardize values to be in the `[0, 1]` range by using `tf.keras.layers.Rescaling`. You can include the layer inside your model definition, which can simplify deployment.\n",
        "\n",
        "**NOTE**: You previously resized images using the `image_size` argument of `tf.keras.utils.image_dataset_from_directory`. If you want to include the resizing logic in your model as well, you can use the `tf.keras.layers.Resizing` layer.\n",
        "\n",
        "When there are a small number of training examples, the model sometimes learns from noises or unwanted details from training examples—to an extent that it negatively impacts the performance of the model on new examples. This phenomenon is known as [overfitting](https://www.tensorflow.org/tutorials/keras/overfit_and_underfit). It means that the model will have a difficult time generalizing on a new dataset.\n",
        "\n",
        "There are multiple ways to fight [overfitting](https://www.tensorflow.org/tutorials/keras/overfit_and_underfit) in the training process. In this tutorial, you'll use [data augmentation](https://www.tensorflow.org/tutorials/images/data_augmentation) and add dropout to your model.\n",
        "\n",
        "[Overfitting](https://www.tensorflow.org/tutorials/keras/overfit_and_underfit) generally occurs when there are a small number of training examples. [Data augmentation](https://www.tensorflow.org/tutorials/images/data_augmentation) takes the approach of generating additional training data from your existing examples by augmenting them using random transformations that yield believable-looking images. This helps expose the model to more aspects of the data and generalize better.\n",
        "\n",
        "You can implement data augmentation using the  [Keras image preprocessing layers](https://www.tensorflow.org/guide/keras/preprocessing_layers#image_preprocessing) and [image data augmentation](https://www.tensorflow.org/guide/keras/preprocessing_layers#image_data_augmentation). These can be included inside your model like other layers, and run on the GPU.\n",
        "\n",
        "Another technique to reduce [overfitting](https://www.tensorflow.org/tutorials/keras/overfit_and_underfit) is to introduce [dropout regularization](https://developers.google.com/machine-learning/glossary#dropout_regularization) to the network.\n",
        "\n",
        "When you apply [dropout to a layer](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Dropout), it randomly drops out (by setting the activation to zero) a number of output units from the layer during the training process. Dropout takes a fractional number as its input value, in the form such as 0.1, 0.2, 0.4, etc. This means dropping out 10%, 20% or 40% of the output units randomly from the applied layer. To read more about it go [here](https://towardsdatascience.com/understanding-and-implementing-dropout-in-tensorflow-and-keras-a8a3a02c1bfa).\n",
        "\n",
        "**NOTE**: This model has NOT been tuned for high accuracy; the goal of this tutorial is to show a standard approach."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QR6argA1K074"
      },
      "outputs": [],
      "source": [
        "num_classes = len(class_names)\n",
        "\n",
        "data_augmentation = tf.keras.Sequential(\n",
        "    [\n",
        "        tf.keras.layers.RandomFlip(input_shape=(img_height,\n",
        "                                                img_width,\n",
        "                                                3)),\n",
        "        tf.keras.layers.RandomRotation(0.1),\n",
        "        tf.keras.layers.RandomZoom(0.1),\n",
        "    ]\n",
        ")\n",
        "\n",
        "model = tf.keras.Sequential([\n",
        "  data_augmentation,\n",
        "\n",
        "  tf.keras.layers.Rescaling(1./255, input_shape=(img_height, img_width, 3)),\n",
        "\n",
        "  tf.keras.layers.Normalization(),\n",
        "\n",
        "  tf.keras.layers.Conv2D(16, 3, padding='same', activation='relu'),\n",
        "  tf.keras.layers.MaxPooling2D(),\n",
        "\n",
        "  tf.keras.layers.Conv2D(32, 3, padding='same', activation='relu'),\n",
        "  tf.keras.layers.MaxPooling2D(),\n",
        "\n",
        "  tf.keras.layers.Conv2D(64, 3, padding='same', activation='relu'),\n",
        "  tf.keras.layers.MaxPooling2D(),\n",
        "\n",
        "  tf.keras.layers.Dropout(0.2),\n",
        "  tf.keras.layers.Flatten(),\n",
        "  tf.keras.layers.Dense(128, activation='relu'),\n",
        "  tf.keras.layers.Dense(num_classes, activation='softmax')\n",
        "])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EaKFzz72Lqpg"
      },
      "source": [
        "### Compile the model\n",
        "\n",
        "For this tutorial, choose the `tf.keras.optimizers.Adam` optimizer and `tf.keras.losses.SparseCategoricalCrossentropy` loss function. To view training and validation accuracy for each training epoch, pass the `metrics` argument to `Model.compile`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jloGNS1MLx3A"
      },
      "outputs": [],
      "source": [
        "model.compile(optimizer='adam',\n",
        "              loss=tf.keras.losses.SparseCategoricalCrossentropy(),\n",
        "              metrics=['accuracy'])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aMJ4DnuJL55A"
      },
      "source": [
        "### Model summary\n",
        "\n",
        "View all the layers of the network using the Keras `Model.summary` method:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "llLYH-BXL7Xe",
        "outputId": "cced7632-3cd6-4559-a10d-c3a7d945d208"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Model: \"sequential_11\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " sequential_10 (Sequential)  (None, 180, 180, 3)       0         \n",
            "                                                                 \n",
            " rescaling_5 (Rescaling)     (None, 180, 180, 3)       0         \n",
            "                                                                 \n",
            " normalization_5 (Normalizat  (None, 180, 180, 3)      7         \n",
            " ion)                                                            \n",
            "                                                                 \n",
            " conv2d_15 (Conv2D)          (None, 180, 180, 16)      448       \n",
            "                                                                 \n",
            " max_pooling2d_15 (MaxPoolin  (None, 90, 90, 16)       0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            " conv2d_16 (Conv2D)          (None, 90, 90, 32)        4640      \n",
            "                                                                 \n",
            " max_pooling2d_16 (MaxPoolin  (None, 45, 45, 32)       0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            " conv2d_17 (Conv2D)          (None, 45, 45, 64)        18496     \n",
            "                                                                 \n",
            " max_pooling2d_17 (MaxPoolin  (None, 22, 22, 64)       0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            " dropout_5 (Dropout)         (None, 22, 22, 64)        0         \n",
            "                                                                 \n",
            " flatten_5 (Flatten)         (None, 30976)             0         \n",
            "                                                                 \n",
            " dense_10 (Dense)            (None, 128)               3965056   \n",
            "                                                                 \n",
            " dense_11 (Dense)            (None, 5)                 645       \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 3,989,292\n",
            "Trainable params: 3,989,285\n",
            "Non-trainable params: 7\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "model.summary()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NiYHcbvaL9H-"
      },
      "source": [
        "### Train the model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j30F69T4sIVN"
      },
      "source": [
        "Train the model for 15 epochs with the Keras `Model.fit` method:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5fWToCqYMErH",
        "outputId": "dc8e5121-448d-427c-a2e5-36a3ffcf6e06"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 1/15\n",
            "92/92 [==============================] - 10s 44ms/step - loss: 1.3892 - accuracy: 0.3971 - val_loss: 1.1844 - val_accuracy: 0.5054\n",
            "Epoch 2/15\n",
            "92/92 [==============================] - 3s 30ms/step - loss: 1.1079 - accuracy: 0.5518 - val_loss: 1.0346 - val_accuracy: 0.5763\n",
            "Epoch 3/15\n",
            "92/92 [==============================] - 3s 30ms/step - loss: 1.0060 - accuracy: 0.5943 - val_loss: 1.0775 - val_accuracy: 0.5504\n",
            "Epoch 4/15\n",
            "92/92 [==============================] - 3s 30ms/step - loss: 0.9513 - accuracy: 0.6148 - val_loss: 0.9411 - val_accuracy: 0.6104\n",
            "Epoch 5/15\n",
            "92/92 [==============================] - 3s 29ms/step - loss: 0.8802 - accuracy: 0.6557 - val_loss: 0.9513 - val_accuracy: 0.6281\n",
            "Epoch 6/15\n",
            "92/92 [==============================] - 3s 29ms/step - loss: 0.8455 - accuracy: 0.6584 - val_loss: 0.8672 - val_accuracy: 0.6485\n",
            "Epoch 7/15\n",
            "92/92 [==============================] - 3s 29ms/step - loss: 0.8290 - accuracy: 0.6730 - val_loss: 0.9199 - val_accuracy: 0.6390\n",
            "Epoch 8/15\n",
            "92/92 [==============================] - 3s 29ms/step - loss: 0.7759 - accuracy: 0.7040 - val_loss: 0.7915 - val_accuracy: 0.6785\n",
            "Epoch 9/15\n",
            "92/92 [==============================] - 3s 29ms/step - loss: 0.7609 - accuracy: 0.6989 - val_loss: 0.7779 - val_accuracy: 0.6744\n",
            "Epoch 10/15\n",
            "92/92 [==============================] - 3s 29ms/step - loss: 0.7385 - accuracy: 0.7105 - val_loss: 0.7866 - val_accuracy: 0.6757\n",
            "Epoch 11/15\n",
            "92/92 [==============================] - 3s 29ms/step - loss: 0.7258 - accuracy: 0.7139 - val_loss: 0.7803 - val_accuracy: 0.6703\n",
            "Epoch 12/15\n",
            "92/92 [==============================] - 3s 31ms/step - loss: 0.6926 - accuracy: 0.7272 - val_loss: 0.8040 - val_accuracy: 0.6812\n",
            "Epoch 13/15\n",
            "92/92 [==============================] - 3s 30ms/step - loss: 0.6770 - accuracy: 0.7367 - val_loss: 0.8048 - val_accuracy: 0.6866\n",
            "Epoch 14/15\n",
            "92/92 [==============================] - 3s 29ms/step - loss: 0.6740 - accuracy: 0.7350 - val_loss: 0.7418 - val_accuracy: 0.7262\n",
            "Epoch 15/15\n",
            "92/92 [==============================] - 3s 31ms/step - loss: 0.6633 - accuracy: 0.7544 - val_loss: 0.7179 - val_accuracy: 0.7098\n"
          ]
        }
      ],
      "source": [
        "epochs = 15\n",
        "history = model.fit(\n",
        "  train_ds,\n",
        "  validation_data=val_ds,\n",
        "  epochs=epochs\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SyFKdQpXMJT4"
      },
      "source": [
        "## Visualize training results"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dFvOvmAmMK9w"
      },
      "source": [
        "Create plots of the loss and accuracy on the training and validation sets:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 699
        },
        "id": "jWnopEChMMCn",
        "outputId": "74880bc9-2ba3-4d4a-b829-15f656caa467"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 800x800 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "acc = history.history['accuracy']\n",
        "val_acc = history.history['val_accuracy']\n",
        "\n",
        "loss = history.history['loss']\n",
        "val_loss = history.history['val_loss']\n",
        "\n",
        "epochs_range = range(epochs)\n",
        "\n",
        "plt.figure(figsize=(8, 8))\n",
        "plt.subplot(1, 2, 1)\n",
        "plt.plot(epochs_range, acc, label='Training Accuracy')\n",
        "plt.plot(epochs_range, val_acc, label='Validation Accuracy')\n",
        "plt.legend(loc='lower right')\n",
        "plt.title('Training and Validation Accuracy')\n",
        "\n",
        "plt.subplot(1, 2, 2)\n",
        "plt.plot(epochs_range, loss, label='Training Loss')\n",
        "plt.plot(epochs_range, val_loss, label='Validation Loss')\n",
        "plt.legend(loc='upper right')\n",
        "plt.title('Training and Validation Loss')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dtv5VbaVb-3W"
      },
      "source": [
        "## Predict on new data using Keras model\n",
        "\n",
        "Use the trained Keras model to classify an image that wasn't included in the training or validation sets.\n",
        "\n",
        "**NOTE**: Data augmentation and dropout layers are inactive at inference time."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dC40sRITBSsQ",
        "outputId": "2f5bf323-25ff-4e22-c53a-abf0b0d611b7"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:6 out of the last 7 calls to <function Model.make_predict_function.<locals>.predict_function at 0x7ab4e10ae4d0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1/1 [==============================] - 0s 90ms/step\n",
            "This image most likely belongs to sunflowers with a 92.63 percent confidence.\n"
          ]
        }
      ],
      "source": [
        "sunflower_url = \"https://storage.googleapis.com/download.tensorflow.org/example_images/592px-Red_sunflower.jpg\"\n",
        "sunflower_path = tf.keras.utils.get_file('Red_sunflower', origin=sunflower_url)\n",
        "\n",
        "img = tf.keras.utils.load_img(\n",
        "    sunflower_path, target_size=(img_height, img_width)\n",
        ")\n",
        "img_array = tf.keras.utils.img_to_array(img)\n",
        "img_array = tf.expand_dims(img_array, 0) # Create a batch\n",
        "\n",
        "predictions = model.predict(img_array)\n",
        "score = tf.nn.softmax(predictions[0])\n",
        "\n",
        "print(\n",
        "    \"This image most likely belongs to {} with a {:.2f} percent confidence.\"\n",
        "    .format(class_names[np.argmax(score)], 100 * np.max(score))\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aOc3PZ2N2r18"
      },
      "source": [
        "## TensorFlow Lite\n",
        "\n",
        "[TensorFlow Lite](https://www.tensorflow.org/lite/) is a set of tools that enables on-device machine learning by helping developers run their models on mobile, embedded, and edge devices."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cThu25rh4LPP"
      },
      "source": [
        "### Convert the Keras Sequential model to a TensorFlow Lite model\n",
        "\n",
        "To use the trained model with on-device applications, first [convert it](https://www.tensorflow.org/lite/models/convert) to a smaller and more efficient model format called a [TensorFlow Lite](https://www.tensorflow.org/lite/) model.\n",
        "\n",
        "Take the trained Keras Sequential model and use `tf.lite.TFLiteConverter.from_keras_model` to generate a [TensorFlow Lite](https://www.tensorflow.org/lite/) model.\n",
        "\n",
        "To use the [TensorFlow Lite](https://www.tensorflow.org/lite/) model in [ML Kit](https://developers.google.com/ml-kit) it should meet [these requirements](https://developers.google.com/ml-kit/custom-models#model-compatibility). For this example the data is FLOAT32 type, which should set before calling `converter.convert()`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mXo6ftuL2ufx",
        "outputId": "4760673b-e44f-4fe1-a251-15967365be68"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 3 of 3). These functions will not be directly callable after loading.\n"
          ]
        }
      ],
      "source": [
        "# Convert the model.\n",
        "converter = tf.lite.TFLiteConverter.from_keras_model(model)\n",
        "\n",
        "# quantization, set the optimization mode and data type\n",
        "converter.optimizations = [tf.lite.Optimize.DEFAULT]\n",
        "converter.target_spec.supported_types = [tf.float32]\n",
        "\n",
        "tflite_model = converter.convert()\n",
        "\n",
        "# Save the model.\n",
        "model_file = 'model.tflite'\n",
        "with open(model_file, 'wb') as f:\n",
        "  f.write(tflite_model)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4R26OU4gGKhh"
      },
      "source": [
        "The [TensorFlow Lite](https://www.tensorflow.org/lite/) model you saved in the previous step can contain several function signatures. The Keras model converter API uses the default signature automatically. Learn more about [TensorFlow Lite signatures](https://www.tensorflow.org/lite/guide/signatures)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O7pQWOsckX3e"
      },
      "source": [
        "### Add Metadata\n",
        "\n",
        "To make the [TensorFlow Lite](https://www.tensorflow.org/lite/) model compatible with [ML Kit](https://developers.google.com/ml-kit), if the input tensor type is FLOAT32, it must specify the NormalizationOptions by [attaching Metadata](https://www.tensorflow.org/lite/models/convert/metadata) to the model.\n",
        "\n",
        "There are three parts to the model metadata:\n",
        "\n",
        "1. Model information - Overall description of the model as well as items such as license terms.\n",
        "2. Input information - Description of the inputs and pre-processing required such as normalization.\n",
        "3. Output information - Description of the output and post-processing required such as mapping to labels."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W89zTUpjmEia"
      },
      "source": [
        "#### Model information\n",
        "\n",
        "Metadata starts by creating a new model info:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OdqwYkZamUXd",
        "outputId": "18e8669d-b1a8-4ca7-cd0e-df6106a8f180"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: tflite-support in /usr/local/lib/python3.10/dist-packages (0.4.4)\n",
            "Requirement already satisfied: absl-py>=0.7.0 in /usr/local/lib/python3.10/dist-packages (from tflite-support) (1.4.0)\n",
            "Requirement already satisfied: numpy>=1.20.0 in /usr/local/lib/python3.10/dist-packages (from tflite-support) (1.22.4)\n",
            "Requirement already satisfied: flatbuffers>=2.0 in /usr/local/lib/python3.10/dist-packages (from tflite-support) (23.5.26)\n",
            "Requirement already satisfied: protobuf<4,>=3.18.0 in /usr/local/lib/python3.10/dist-packages (from tflite-support) (3.20.3)\n",
            "Requirement already satisfied: sounddevice>=0.4.4 in /usr/local/lib/python3.10/dist-packages (from tflite-support) (0.4.6)\n",
            "Requirement already satisfied: pybind11>=2.6.0 in /usr/local/lib/python3.10/dist-packages (from tflite-support) (2.11.0)\n",
            "Requirement already satisfied: CFFI>=1.0 in /usr/local/lib/python3.10/dist-packages (from sounddevice>=0.4.4->tflite-support) (1.15.1)\n",
            "Requirement already satisfied: pycparser in /usr/local/lib/python3.10/dist-packages (from CFFI>=1.0->sounddevice>=0.4.4->tflite-support) (2.21)\n"
          ]
        }
      ],
      "source": [
        "pip install tflite-support"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "z6DQU5GUmTNg"
      },
      "outputs": [],
      "source": [
        "from tflite_support import metadata_schema_py_generated as _metadata_fb\n",
        "from tflite_support import metadata as _metadata"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6BIUIvyCnCr3"
      },
      "outputs": [],
      "source": [
        "# Creates model info.\n",
        "model_meta = _metadata_fb.ModelMetadataT()\n",
        "model_meta.name = \"YOUR_image_classifier_name\"\n",
        "model_meta.description = (\"Identify the most prominent object in the \"\n",
        "                          \"image from a set of %d categories.\" %\n",
        "                          num_classes)\n",
        "model_meta.version = \"v1\"\n",
        "model_meta.author = \"YOUR_name\"\n",
        "model_meta.license = (\"Apache License. Version 2.0 \"\n",
        "                      \"http://www.apache.org/licenses/LICENSE-2.0.\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uILNyxzynLf1"
      },
      "source": [
        "#### Input / output information\n",
        "\n",
        "This section shows you how to describe your model's input and output signature. This metadata may be used by automatic code generators to create pre- and post- processing code. To create input or output information about a tensor:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5-pBo6QNnyPi"
      },
      "source": [
        "##### Image input\n",
        "\n",
        "Image is a common input type for machine learning. TensorFlow Lite metadata supports information such as colorspace and pre-processing information such as normalization. The dimension of the image does not require manual specification since it is already provided by the shape of the input tensor and can be automatically inferred.\n",
        "\n",
        "For FLOAT32 input tensor type, [ML Kit requires](https://developers.google.com/ml-kit/custom-models#model-compatibility) to specify the NormalizationOptions in the Metadata. Depending on your NormalizationOptions you need to set `input_normalization.options.mean` and `input_normalization.options.std` accordingly. For this examples, since we are using `tf.keras.layers.Normalization()` in the Keras Sequential Model, we are setting `mean = 0.0` and `std = 1.0`.\n",
        "\n",
        "**NOTE**: If you fail in providing the correct mean and std in your NormalizationOptions, your model will NOT infere correctly in [ML Kit](https://developers.google.com/ml-kit). Read more [here](https://developers.google.com/ml-kit/custom-models#model-compatibility)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "W8Grnsoon-Ck"
      },
      "outputs": [],
      "source": [
        "# Creates input info.\n",
        "input_meta = _metadata_fb.TensorMetadataT()\n",
        "input_meta.name = \"image\"\n",
        "input_meta.description = (\n",
        "    \"Input image to be classified. The expected image is {0} x {1}, with \"\n",
        "    \"three channels (red, blue, and green) per pixel. Each value in the \"\n",
        "    \"tensor is a single byte between 0 and 255.\".format(img_width, img_height))\n",
        "input_meta.content = _metadata_fb.ContentT()\n",
        "input_meta.content.contentProperties = _metadata_fb.ImagePropertiesT()\n",
        "input_meta.content.contentProperties.colorSpace = (\n",
        "    _metadata_fb.ColorSpaceType.RGB)\n",
        "input_meta.content.contentPropertiesType = (\n",
        "    _metadata_fb.ContentProperties.ImageProperties)\n",
        "input_normalization = _metadata_fb.ProcessUnitT()\n",
        "input_normalization.optionsType = (\n",
        "    _metadata_fb.ProcessUnitOptions.NormalizationOptions)\n",
        "input_normalization.options = _metadata_fb.NormalizationOptionsT()\n",
        "input_normalization.options.mean = [0.0]\n",
        "input_normalization.options.std = [1.0]\n",
        "input_meta.processUnits = [input_normalization]\n",
        "input_stats = _metadata_fb.StatsT()\n",
        "input_stats.max = [255]\n",
        "input_stats.min = [0]\n",
        "input_meta.stats = input_stats"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9NLW3Ps8n9m5"
      },
      "source": [
        "##### Label output\n",
        "\n",
        "Label can be mapped to an output tensor via an associated file using `TENSOR_AXIS_LABELS`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "meqPBvfgolG0"
      },
      "outputs": [],
      "source": [
        "# Creates output info.\n",
        "output_meta = _metadata_fb.TensorMetadataT()\n",
        "output_meta.name = \"probability\"\n",
        "output_meta.description = \"Probabilities of the {} labels respectively.\".format(num_classes)\n",
        "output_meta.content = _metadata_fb.ContentT()\n",
        "output_meta.content.content_properties = _metadata_fb.FeaturePropertiesT()\n",
        "output_meta.content.contentPropertiesType = (\n",
        "    _metadata_fb.ContentProperties.FeatureProperties)\n",
        "output_stats = _metadata_fb.StatsT()\n",
        "output_stats.max = [1.0]\n",
        "output_stats.min = [0.0]\n",
        "output_meta.stats = output_stats\n",
        "label_file = _metadata_fb.AssociatedFileT()\n",
        "label_file.name = os.path.basename(label_file_path)\n",
        "label_file.description = \"Labels for objects that the model can recognize.\"\n",
        "label_file.type = _metadata_fb.AssociatedFileType.TENSOR_AXIS_LABELS\n",
        "output_meta.associatedFiles = [label_file]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BXWrtmOto8Tv"
      },
      "source": [
        "#### Create the metadata Flatbuffers\n",
        "\n",
        "Combine the model information with the input and output information:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gKwK5PWho3oh"
      },
      "outputs": [],
      "source": [
        "# Creates subgraph info.\n",
        "subgraph = _metadata_fb.SubGraphMetadataT()\n",
        "subgraph.inputTensorMetadata = [input_meta]\n",
        "subgraph.outputTensorMetadata = [output_meta]\n",
        "model_meta.subgraphMetadata = [subgraph]\n",
        "\n",
        "b = flatbuffers.Builder(0)\n",
        "b.Finish(\n",
        "    model_meta.Pack(b),\n",
        "    _metadata.MetadataPopulator.METADATA_FILE_IDENTIFIER)\n",
        "metadata_buf = b.Output()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u1EZLECJpJOk"
      },
      "source": [
        "#### Pack metadata and associated files into the model\n",
        "Once the metadata Flatbuffers is created, the metadata and the label file are written into the TFLite file via the populate method:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OmjfSfSQpOao"
      },
      "outputs": [],
      "source": [
        "# copies model_file to export_path\n",
        "export_model_path = \"model_with_metadata.tflite\"\n",
        "tf.io.gfile.copy(model_file, export_model_path, overwrite=True)\n",
        "\n",
        "# populates metadata\n",
        "populator = _metadata.MetadataPopulator.with_model_file(export_model_path)\n",
        "populator.load_metadata_buffer(metadata_buf)\n",
        "populator.load_associated_files([label_file_path])\n",
        "populator.populate()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7fjQfXaV2l-5"
      },
      "source": [
        "## Predict on new data using TensorFlow Lite model\n",
        "\n",
        "\n",
        "You can access the TensorFlow Lite saved model signatures in Python via the `tf.lite.Interpreter` class.\n",
        "\n",
        "Load the model with the `Interpreter`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "cHYcip_FOaHq"
      },
      "outputs": [],
      "source": [
        "interpreter = tf.lite.Interpreter(model_path=export_model_path)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x3rSjwlAspwt"
      },
      "source": [
        "Get the input and output details:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MktSrFbTs1KQ",
        "outputId": "d94dfb70-0ae1-4d53-bbf0-731843dd62af"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "n--------Input Details of Model-------------------n\n",
            "[{'name': 'serving_default_sequential_10_input:0', 'index': 0, 'shape': array([  1, 180, 180,   3], dtype=int32), 'shape_signature': array([ -1, 180, 180,   3], 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",
            "\n",
            "n--------Output Details of Model-------------------n\n",
            "[{'name': 'StatefulPartitionedCall:0', 'index': 24, 'shape': array([1, 5], dtype=int32), 'shape_signature': array([-1,  5], 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": [
        "# Obtain input and output details of the model.\n",
        "print(\"n--------Input Details of Model-------------------n\")\n",
        "input_details = interpreter.get_input_details()\n",
        "print(input_details)\n",
        "\n",
        "print(\"\\nn--------Output Details of Model-------------------n\")\n",
        "output_details = interpreter.get_output_details()\n",
        "print(output_details)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b1mfRcBOnEx0"
      },
      "source": [
        "Now allocate tensors so that we can use the `set_tensor()` method to feed the processed image"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sEqR27YcnFvc"
      },
      "outputs": [],
      "source": [
        "interpreter.allocate_tensors()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VagFDVN6uWrI"
      },
      "source": [
        "You have already tensorized that image and saved it as `img_array`. Now, pass it to `set_tensor()`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZKP_GFeKUWb5"
      },
      "outputs": [],
      "source": [
        "interpreter.set_tensor(input_details[0]['index'], img_array)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eP8H35oju63h"
      },
      "source": [
        "Inference is performed by calling:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BXHdZ9p_u5Cn"
      },
      "outputs": [],
      "source": [
        "interpreter.invoke()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oQNW3IK7vCCY"
      },
      "source": [
        " Compute softmax activations, and then print the prediction for the class with the highest computed probability."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gTgq2G3zvOJa",
        "outputId": "cec05de9-465a-4181-e34b-47e638054520"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "This image most likely belongs to sunflowers with a 92.63 percent confidence.\n"
          ]
        }
      ],
      "source": [
        "predictions = interpreter.get_tensor(output_details[0]['index'])\n",
        "score_lite = tf.nn.softmax(predictions)\n",
        "print(\n",
        "    \"This image most likely belongs to {} with a {:.2f} percent confidence.\"\n",
        "    .format(class_names[np.argmax(score_lite)], 100 * np.max(score_lite))\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AFPHRmzywXq2"
      },
      "source": [
        "To read more about using the interpreter go [here](https://helloworld.co.in/article/image-classification-tensorflow-lite)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1RlfCY9v2_ir"
      },
      "source": [
        "## Next steps\n",
        "\n",
        "This tutorial showed how to train a model for image classification, test it, convert it to the [TensorFlow Lite](https://www.tensorflow.org/lite/) format and make it compatible for [ML Kit](https://developers.google.com/ml-kit) for on-device applications (such as an [image classification](https://developers.google.com/ml-kit/vision/image-labeling) and [object detection](https://developers.google.com/ml-kit/vision/object-detection)), and perform inference with the [TensorFlow Lite](https://www.tensorflow.org/lite/) model with the Python API.\n",
        "\n",
        "You can download the generated tflite file (model_with_metadata.tflite) from the `Files` tab and use it in [Google's ML Kit sample app](https://github.com/googlesamples/mlkit) or in [google_ml_kit_flutter](https://github.com/flutter-ml/google_ml_kit_flutter) [example app](https://github.com/flutter-ml/google_ml_kit_flutter/tree/master/packages/example). Follow this [guide](https://developers.google.com/ml-kit/custom-models).\n",
        "\n",
        "To get a copy of this [Python script](https://github.com/flutter-ml/mlkit-custom-model/blob/main/ml_kit_custom_model.py) and run it in your local terminal go [here](https://github.com/flutter-ml/mlkit-custom-model).\n",
        "\n",
        "You can learn more about [TensorFlow Lite](https://www.tensorflow.org/lite/) through [tutorials](https://www.tensorflow.org/lite/tutorials) and [guides](https://www.tensorflow.org/lite/guide)."
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}