Quantization_Tutorial.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# 🪄 Quantization Tutorial\n",
        "\n",
        "Quantization is a technique to reduce the computational and memory costs of running inference by representing the weights and activations with low-precision data types like 8-bit integer (`int8`) instead of the usual 32-bit floating point (`float32`).\n",
        "\n",
        "Reducing the number of bits means the resulting model requires less memory storage, consumes less energy (in theory), and operations like matrix multiplication can be performed much faster with integer arithmetic. It also allows to run models on embedded devices, which sometimes only support integer data types."
      ],
      "metadata": {
        "id": "58mLVj5xAOnB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install tensorflow-model-optimization"
      ],
      "metadata": {
        "id": "440iJM_1G5o1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Imports"
      ],
      "metadata": {
        "id": "J6iTNzmmBpm0"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "cFZQafWY_61t"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import shutil\n",
        "import random\n",
        "import numpy as np\n",
        "from zipfile import ZipFile as unzip\n",
        "from google.colab import files\n",
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow as tf\n",
        "from tensorflow.keras.layers import Flatten, Dense, Conv2D, MaxPooling2D, Dropout\n",
        "from tensorflow.keras.optimizers import RMSprop\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "from keras.preprocessing import image\n",
        "from tensorflow.keras.preprocessing.image import img_to_array, load_img"
      ],
      "metadata": {
        "id": "fix1pgQfAcJ6"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Dataset\n",
        "\n",
        "In this Tutorial we will be building a Binary Image Classification Model for Cats vs Dogs.\n",
        "\n",
        "The dataset is taken from kaggle for ease of use."
      ],
      "metadata": {
        "id": "g6XonslyBrPY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import files\n",
        "files.upload()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 90
        },
        "id": "WHFzaY1eAdkA",
        "outputId": "c6c25df8-ef58-4715-ab94-45fd1efe5180"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-87718f0d-bcdc-4229-9b39-34a3fa32395a\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-87718f0d-bcdc-4229-9b39-34a3fa32395a\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// 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",
              "//      http://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.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving kaggle.json to kaggle.json\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'kaggle.json': b'{\"username\":\"srddev\",\"key\":\"7eb7452f953af3d3dafc92a688f98ed9\"}'}"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "! pip install kaggle\n",
        "! mkdir ~/.kaggle\n",
        "! mv kaggle.json ~/.kaggle/\n",
        "! chmod 600 ~/.kaggle/kaggle.json"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "B6ZVs4PFAfCP",
        "outputId": "a2912449-7c12-4b3c-ab8b-4b7f3975f8b7"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: kaggle in /usr/local/lib/python3.10/dist-packages (1.5.16)\n",
            "Requirement already satisfied: six>=1.10 in /usr/local/lib/python3.10/dist-packages (from kaggle) (1.16.0)\n",
            "Requirement already satisfied: certifi in /usr/local/lib/python3.10/dist-packages (from kaggle) (2023.7.22)\n",
            "Requirement already satisfied: python-dateutil in /usr/local/lib/python3.10/dist-packages (from kaggle) (2.8.2)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from kaggle) (2.27.1)\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from kaggle) (4.65.0)\n",
            "Requirement already satisfied: python-slugify in /usr/local/lib/python3.10/dist-packages (from kaggle) (8.0.1)\n",
            "Requirement already satisfied: urllib3 in /usr/local/lib/python3.10/dist-packages (from kaggle) (1.26.16)\n",
            "Requirement already satisfied: bleach in /usr/local/lib/python3.10/dist-packages (from kaggle) (6.0.0)\n",
            "Requirement already satisfied: webencodings in /usr/local/lib/python3.10/dist-packages (from bleach->kaggle) (0.5.1)\n",
            "Requirement already satisfied: text-unidecode>=1.3 in /usr/local/lib/python3.10/dist-packages (from python-slugify->kaggle) (1.3)\n",
            "Requirement already satisfied: charset-normalizer~=2.0.0 in /usr/local/lib/python3.10/dist-packages (from requests->kaggle) (2.0.12)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->kaggle) (3.4)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!kaggle competitions download -c dogs-vs-cats"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TUekJbVAAgW4",
        "outputId": "36df9aa0-89a1-4c19-a792-2ef9a7d35f77"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading dogs-vs-cats.zip to /content\n",
            " 99% 807M/812M [00:05<00:00, 248MB/s]\n",
            "100% 812M/812M [00:05<00:00, 157MB/s]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for _ , _  , filenames in os.walk('.'):\n",
        "  for filename in filenames:\n",
        "    if filename[-3:]=='zip':\n",
        "      file = unzip(filename,'r')\n",
        "      file.extractall()\n",
        "      file.close()\n",
        "      os.remove(filename)\n",
        "\n",
        "os.remove('sampleSubmission.csv')"
      ],
      "metadata": {
        "id": "DOweRCnOAjEo"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "for _ , _  , filenames in os.walk('.'):\n",
        "  for filename in filenames:\n",
        "    if filename[-3:]=='zip':\n",
        "      file = unzip(filename,'r')\n",
        "      file.extractall()\n",
        "      file.close()\n",
        "      os.remove(filename)"
      ],
      "metadata": {
        "id": "c9dHmY9SB7Zo"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Number of train images: \" , len(os.listdir('./train')) )\n",
        "print(\"Number of test images: \"  , len(os.listdir('./test1')) )"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uFVkXAI3AkuI",
        "outputId": "7efc6745-75e6-478b-af4f-6f6ae8b5e8db"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Number of train images:  25000\n",
            "Number of test images:  12500\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "no_of_cats = len([files for files in os.listdir('./train') if 'cat' in files])\n",
        "no_of_dogs = len([files for files in os.listdir('./train') if 'dog' in files])\n",
        "print(\"Cat images in train dataset: \",  no_of_cats)\n",
        "print(\"Dog images in train dataset: \", no_of_dogs)\n",
        "if no_of_cats==no_of_dogs:\n",
        "  total_images = no_of_cats\n",
        "  print('Balanced dataset')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U2BQFs2IAtAF",
        "outputId": "2251abfb-11d4-4785-841f-c07867bbc8fa"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cat images in train dataset:  12500\n",
            "Dog images in train dataset:  12500\n",
            "Balanced dataset\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Create a folder named `data` which has 3 sub folders namely\n",
        "- train\n",
        "- validation\n",
        "- test"
      ],
      "metadata": {
        "id": "UnEIBMsBODh6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "base_dir = 'data/'\n",
        "dirs = ['train','val','test']\n",
        "sub_dirs = ['cats','dogs']\n",
        "for dir in dirs:\n",
        "  dir =  os.path.join(base_dir, dir)\n",
        "  os.makedirs(dir,exist_ok=True)\n",
        "  for sub_dir in sub_dirs:\n",
        "    sub_dir = os.path.join(dir, sub_dir)\n",
        "    os.makedirs(sub_dir,exist_ok=True)"
      ],
      "metadata": {
        "id": "6aVadGDnAuOp"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "split = {'train': 0.7,\n",
        "         'val': 0.3}\n",
        "\n",
        "for dir in dirs[:2]:\n",
        "    print(int(split[dir]*total_images))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_V5l168aAxTJ",
        "outputId": "c2443e36-afd4-41f5-a50a-a11ecfaf078b"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "8750\n",
            "3750\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "split_size = 0.7\n",
        "\n",
        "split = {'train': (0,int(split_size*total_images)),\n",
        "         'val': (int(split_size*total_images),total_images)}\n",
        "\n",
        "for obj in sub_dirs:\n",
        "  for dir in dirs[:2]:\n",
        "    files = ['{}.{}.jpg'.format(obj[:-1],i) for i in range(*split[dir])]\n",
        "    for filename in files:\n",
        "      src = os.path.join('./train', filename)\n",
        "      dst = os.path.join(base_dir,dir,obj,filename)\n",
        "      shutil.copyfile(src,dst)\n",
        "print(\"Train validation split completed.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "djaPNRVzBCFf",
        "outputId": "4a730c40-1f95-4224-80f1-5914b19a25f4"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Train validation split completed.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "train_dir = os.path.join(base_dir, 'train')\n",
        "validation_dir = os.path.join(base_dir, 'val')\n",
        "\n",
        "# Directory with our training cat/dog pictures\n",
        "train_cats_dir = os.path.join(train_dir, 'cats')\n",
        "train_dogs_dir = os.path.join(train_dir, 'dogs')\n",
        "\n",
        "# Directory with our validation cat/dog pictures\n",
        "validation_cats_dir = os.path.join(validation_dir, 'cats')\n",
        "validation_dogs_dir = os.path.join(validation_dir, 'dogs')"
      ],
      "metadata": {
        "id": "Jw821oIIBECb"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_cat_fnames = os.listdir( train_cats_dir )\n",
        "train_dog_fnames = os.listdir( train_dogs_dir )\n",
        "\n",
        "print(train_cat_fnames[:10])\n",
        "print(train_dog_fnames[:10])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lP5YClFmBH4e",
        "outputId": "65ad1166-609c-4bce-8f2c-130ceb2fe4b8"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['cat.258.jpg', 'cat.2649.jpg', 'cat.7962.jpg', 'cat.6546.jpg', 'cat.6809.jpg', 'cat.7419.jpg', 'cat.5057.jpg', 'cat.1010.jpg', 'cat.7380.jpg', 'cat.2358.jpg']\n",
            "['dog.6198.jpg', 'dog.2620.jpg', 'dog.6557.jpg', 'dog.8016.jpg', 'dog.8122.jpg', 'dog.7579.jpg', 'dog.6551.jpg', 'dog.8035.jpg', 'dog.4384.jpg', 'dog.2017.jpg']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print('total training cat images :', len(os.listdir(train_cats_dir ) ))\n",
        "print('total training dog images :', len(os.listdir(train_dogs_dir ) ))\n",
        "\n",
        "print('total validation cat images :', len(os.listdir(validation_cats_dir )))\n",
        "print('total validation dog images :', len(os.listdir(validation_dogs_dir )))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4MKPvC0QBI0R",
        "outputId": "80ce74a9-d6ec-4708-b7eb-3e7cf2a7ab49"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "total training cat images : 8750\n",
            "total training dog images : 8750\n",
            "total validation cat images : 3750\n",
            "total validation dog images : 3750\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Model Building"
      ],
      "metadata": {
        "id": "FeMctIkvBM-x"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model = tf.keras.Sequential([\n",
        "        Conv2D(128,kernel_size=(3,3),activation='relu',input_shape=(150,150,3)),\n",
        "        Conv2D(64,kernel_size=(3,3),activation='relu'),\n",
        "        MaxPooling2D(4,4),\n",
        "\n",
        "        Conv2D(128,kernel_size=(3,3),activation='relu'),\n",
        "        Conv2D(64,kernel_size=(3,3),activation='relu'),\n",
        "        MaxPooling2D(4,4),\n",
        "\n",
        "        Flatten(),\n",
        "        Dense(512,activation='relu') ,\n",
        "        Dropout(rate=0.3),\n",
        "        Dense(1, activation='sigmoid'),\n",
        "        ])"
      ],
      "metadata": {
        "id": "EgscYUL0BJ9S"
      },
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8Cf-GHZXBPyb",
        "outputId": "871c109d-e699-48ec-ba26-1ee47ddc75d9"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv2d (Conv2D)             (None, 148, 148, 128)     3584      \n",
            "                                                                 \n",
            " conv2d_1 (Conv2D)           (None, 146, 146, 64)      73792     \n",
            "                                                                 \n",
            " max_pooling2d (MaxPooling2D  (None, 36, 36, 64)       0         \n",
            " )                                                               \n",
            "                                                                 \n",
            " conv2d_2 (Conv2D)           (None, 34, 34, 128)       73856     \n",
            "                                                                 \n",
            " conv2d_3 (Conv2D)           (None, 32, 32, 64)        73792     \n",
            "                                                                 \n",
            " max_pooling2d_1 (MaxPooling  (None, 8, 8, 64)         0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " flatten (Flatten)           (None, 4096)              0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 512)               2097664   \n",
            "                                                                 \n",
            " dropout (Dropout)           (None, 512)               0         \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 1)                 513       \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 2,323,201\n",
            "Trainable params: 2,323,201\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model.compile(optimizer=RMSprop(learning_rate=0.001),\n",
        "              loss='binary_crossentropy',\n",
        "              metrics = ['accuracy'])"
      ],
      "metadata": {
        "id": "m-7ukDM3BQ2S"
      },
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "datagen = ImageDataGenerator(rescale = 1.0/255.)\n",
        "\n",
        "train_generator = datagen.flow_from_directory(train_dir,\n",
        "                                              batch_size=20,\n",
        "                                              class_mode ='binary',\n",
        "                                              target_size=(150,150))\n",
        "validation_generator = datagen.flow_from_directory(validation_dir,\n",
        "                                                   batch_size=20,\n",
        "                                                   class_mode='binary',\n",
        "                                                   target_size = (150,150))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UZXFV6NgBSWE",
        "outputId": "890df0fd-73c7-4d9e-b747-8cc87829dc3d"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 17500 images belonging to 2 classes.\n",
            "Found 7500 images belonging to 2 classes.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "histroy = model.fit(train_generator,\n",
        "                    validation_data = validation_generator,\n",
        "                    steps_per_epoch=100,\n",
        "                    epochs=50,\n",
        "                    validation_steps = 50,\n",
        "                    verbose=1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jvSjNTLaBUV_",
        "outputId": "4f364248-dda6-4c04-d332-1e79e4d8bdb7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/50\n",
            "100/100 [==============================] - 21s 79ms/step - loss: 0.7167 - accuracy: 0.5070 - val_loss: 0.6910 - val_accuracy: 0.5100\n",
            "Epoch 2/50\n",
            "100/100 [==============================] - 8s 83ms/step - loss: 0.6955 - accuracy: 0.5410 - val_loss: 0.6904 - val_accuracy: 0.5030\n",
            "Epoch 3/50\n",
            "100/100 [==============================] - 7s 73ms/step - loss: 0.6852 - accuracy: 0.5520 - val_loss: 0.6708 - val_accuracy: 0.6160\n",
            "Epoch 4/50\n",
            "100/100 [==============================] - 11s 109ms/step - loss: 0.6563 - accuracy: 0.6180 - val_loss: 0.6223 - val_accuracy: 0.6360\n",
            "Epoch 5/50\n",
            "100/100 [==============================] - 9s 85ms/step - loss: 0.6319 - accuracy: 0.6380 - val_loss: 0.6217 - val_accuracy: 0.6370\n",
            "Epoch 6/50\n",
            "100/100 [==============================] - 12s 120ms/step - loss: 0.6184 - accuracy: 0.6660 - val_loss: 0.5914 - val_accuracy: 0.6860\n",
            "Epoch 7/50\n",
            "100/100 [==============================] - 12s 119ms/step - loss: 0.5698 - accuracy: 0.7080 - val_loss: 0.5990 - val_accuracy: 0.6800\n",
            "Epoch 8/50\n",
            "100/100 [==============================] - 8s 75ms/step - loss: 0.5329 - accuracy: 0.7400 - val_loss: 0.5286 - val_accuracy: 0.7400\n",
            "Epoch 9/50\n",
            "100/100 [==============================] - 10s 95ms/step - loss: 0.5403 - accuracy: 0.7405 - val_loss: 0.5215 - val_accuracy: 0.7440\n",
            "Epoch 10/50\n",
            "100/100 [==============================] - 9s 89ms/step - loss: 0.5322 - accuracy: 0.7415 - val_loss: 0.5320 - val_accuracy: 0.7480\n",
            "Epoch 11/50\n",
            "100/100 [==============================] - 8s 79ms/step - loss: 0.4943 - accuracy: 0.7635 - val_loss: 0.5376 - val_accuracy: 0.7290\n",
            "Epoch 12/50\n",
            "100/100 [==============================] - 8s 85ms/step - loss: 0.4868 - accuracy: 0.7655 - val_loss: 0.4953 - val_accuracy: 0.7680\n",
            "Epoch 13/50\n",
            "100/100 [==============================] - 8s 78ms/step - loss: 0.4936 - accuracy: 0.7650 - val_loss: 0.4675 - val_accuracy: 0.7760\n",
            "Epoch 14/50\n",
            "100/100 [==============================] - 8s 78ms/step - loss: 0.4560 - accuracy: 0.7855 - val_loss: 0.5394 - val_accuracy: 0.7610\n",
            "Epoch 15/50\n",
            "100/100 [==============================] - 8s 79ms/step - loss: 0.4555 - accuracy: 0.7940 - val_loss: 0.4513 - val_accuracy: 0.8020\n",
            "Epoch 16/50\n",
            "100/100 [==============================] - 8s 78ms/step - loss: 0.4221 - accuracy: 0.8090 - val_loss: 0.4246 - val_accuracy: 0.7880\n",
            "Epoch 17/50\n",
            "100/100 [==============================] - 9s 85ms/step - loss: 0.4385 - accuracy: 0.8090 - val_loss: 0.4650 - val_accuracy: 0.7760\n",
            "Epoch 18/50\n",
            "100/100 [==============================] - 8s 78ms/step - loss: 0.4004 - accuracy: 0.8235 - val_loss: 0.4069 - val_accuracy: 0.8090\n",
            "Epoch 19/50\n",
            "100/100 [==============================] - 8s 81ms/step - loss: 0.3807 - accuracy: 0.8365 - val_loss: 0.3960 - val_accuracy: 0.8200\n",
            "Epoch 20/50\n",
            "100/100 [==============================] - 8s 75ms/step - loss: 0.3795 - accuracy: 0.8295 - val_loss: 0.3880 - val_accuracy: 0.8270\n",
            "Epoch 21/50\n",
            "100/100 [==============================] - 9s 89ms/step - loss: 0.3734 - accuracy: 0.8340 - val_loss: 0.3972 - val_accuracy: 0.8060\n",
            "Epoch 22/50\n",
            "100/100 [==============================] - 9s 87ms/step - loss: 0.3773 - accuracy: 0.8370 - val_loss: 0.4044 - val_accuracy: 0.8210\n",
            "Epoch 23/50\n",
            "100/100 [==============================] - 9s 85ms/step - loss: 0.3410 - accuracy: 0.8445 - val_loss: 0.4230 - val_accuracy: 0.8190\n",
            "Epoch 24/50\n",
            "100/100 [==============================] - 9s 92ms/step - loss: 0.3542 - accuracy: 0.8400 - val_loss: 0.3551 - val_accuracy: 0.8490\n",
            "Epoch 25/50\n",
            "100/100 [==============================] - 9s 87ms/step - loss: 0.3399 - accuracy: 0.8530 - val_loss: 0.4133 - val_accuracy: 0.8180\n",
            "Epoch 26/50\n",
            "100/100 [==============================] - 9s 89ms/step - loss: 0.3343 - accuracy: 0.8530 - val_loss: 0.4022 - val_accuracy: 0.8200\n",
            "Epoch 27/50\n",
            "100/100 [==============================] - 8s 75ms/step - loss: 0.3269 - accuracy: 0.8630 - val_loss: 0.3552 - val_accuracy: 0.8650\n",
            "Epoch 28/50\n",
            "100/100 [==============================] - 8s 79ms/step - loss: 0.3149 - accuracy: 0.8675 - val_loss: 0.3415 - val_accuracy: 0.8640\n",
            "Epoch 29/50\n",
            "100/100 [==============================] - 9s 86ms/step - loss: 0.3126 - accuracy: 0.8580 - val_loss: 0.3391 - val_accuracy: 0.8500\n",
            "Epoch 30/50\n",
            "100/100 [==============================] - 8s 85ms/step - loss: 0.3089 - accuracy: 0.8650 - val_loss: 0.3756 - val_accuracy: 0.8430\n",
            "Epoch 31/50\n",
            "100/100 [==============================] - 9s 88ms/step - loss: 0.3145 - accuracy: 0.8635 - val_loss: 0.3944 - val_accuracy: 0.8360\n",
            "Epoch 32/50\n",
            "100/100 [==============================] - 9s 87ms/step - loss: 0.3037 - accuracy: 0.8735 - val_loss: 0.3396 - val_accuracy: 0.8490\n",
            "Epoch 33/50\n",
            "100/100 [==============================] - 8s 78ms/step - loss: 0.2858 - accuracy: 0.8805 - val_loss: 0.3399 - val_accuracy: 0.8500\n",
            "Epoch 34/50\n",
            "100/100 [==============================] - 8s 75ms/step - loss: 0.3035 - accuracy: 0.8745 - val_loss: 0.3089 - val_accuracy: 0.8740\n",
            "Epoch 35/50\n",
            "100/100 [==============================] - 8s 78ms/step - loss: 0.2788 - accuracy: 0.8800 - val_loss: 0.4041 - val_accuracy: 0.8290\n",
            "Epoch 36/50\n",
            "100/100 [==============================] - 8s 80ms/step - loss: 0.2611 - accuracy: 0.8840 - val_loss: 0.4666 - val_accuracy: 0.8060\n",
            "Epoch 37/50\n",
            "100/100 [==============================] - 8s 76ms/step - loss: 0.2760 - accuracy: 0.8935 - val_loss: 0.5151 - val_accuracy: 0.7870\n",
            "Epoch 38/50\n",
            "100/100 [==============================] - 8s 75ms/step - loss: 0.2922 - accuracy: 0.8835 - val_loss: 0.3328 - val_accuracy: 0.8560\n",
            "Epoch 39/50\n",
            "100/100 [==============================] - 8s 76ms/step - loss: 0.2434 - accuracy: 0.9005 - val_loss: 0.3609 - val_accuracy: 0.8480\n",
            "Epoch 40/50\n",
            "100/100 [==============================] - 9s 89ms/step - loss: 0.2513 - accuracy: 0.9010 - val_loss: 0.4063 - val_accuracy: 0.8400\n",
            "Epoch 41/50\n",
            "100/100 [==============================] - 9s 85ms/step - loss: 0.2666 - accuracy: 0.8955 - val_loss: 0.2957 - val_accuracy: 0.8840\n",
            "Epoch 42/50\n",
            "100/100 [==============================] - 8s 75ms/step - loss: 0.2441 - accuracy: 0.9010 - val_loss: 0.3278 - val_accuracy: 0.8760\n",
            "Epoch 43/50\n",
            "100/100 [==============================] - 8s 75ms/step - loss: 0.2374 - accuracy: 0.9105 - val_loss: 0.3458 - val_accuracy: 0.8630\n",
            "Epoch 44/50\n",
            "100/100 [==============================] - 8s 76ms/step - loss: 0.2443 - accuracy: 0.9025 - val_loss: 0.4163 - val_accuracy: 0.8460\n",
            "Epoch 45/50\n",
            "100/100 [==============================] - 8s 79ms/step - loss: 0.2170 - accuracy: 0.9105 - val_loss: 0.3353 - val_accuracy: 0.8560\n",
            "Epoch 46/50\n",
            "100/100 [==============================] - 8s 76ms/step - loss: 0.2276 - accuracy: 0.9180 - val_loss: 0.3072 - val_accuracy: 0.8680\n",
            "Epoch 47/50\n",
            "100/100 [==============================] - 8s 75ms/step - loss: 0.2081 - accuracy: 0.9150 - val_loss: 0.2707 - val_accuracy: 0.9000\n",
            "Epoch 48/50\n",
            "100/100 [==============================] - 9s 88ms/step - loss: 0.2057 - accuracy: 0.9070 - val_loss: 0.3645 - val_accuracy: 0.8670\n",
            "Epoch 49/50\n",
            " 65/100 [==================>...........] - ETA: 2s - loss: 0.1989 - accuracy: 0.9246"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "save the trained model in a directory `saved_models`"
      ],
      "metadata": {
        "id": "McnlytsvOuZ3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model.save(\"saved_models/\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Qw7uZt_fBW8H",
        "outputId": "61032b92-83b3-44de-ddd8-fe2372958a4e"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 4 of 4). These functions will not be directly callable after loading.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import math\n",
        "\n",
        "def convert_size(size_bytes):\n",
        "   if size_bytes == 0:\n",
        "       return \"0B\"\n",
        "   size_name = (\"B\", \"KB\", \"MB\", \"GB\", \"TB\", \"PB\", \"EB\", \"ZB\", \"YB\")\n",
        "   i = int(math.floor(math.log(size_bytes, 1024)))\n",
        "   p = math.pow(1024, i)\n",
        "   s = round(size_bytes / p, 2)\n",
        "   return \"%s %s\" % (s, size_name[i])"
      ],
      "metadata": {
        "id": "2WjtRSaWHmD8"
      },
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 2. Post Training Quantization"
      ],
      "metadata": {
        "id": "8uHJmXB8CZlc"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Coverting the saved model into a tflite model without **Quantization**"
      ],
      "metadata": {
        "id": "NjR6JLUaCfp9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "converter = tf.lite.TFLiteConverter.from_saved_model(\"saved_models/\")\n",
        "tflite_model = converter.convert()\n",
        "print(convert_size(len(tflite_model)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uYT6NdKjCmWr",
        "outputId": "4660bf04-ddd4-43e0-b0f5-6584a1b05859"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "8.87 MB\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Converting the saved model into a tflite model with **Quantization**"
      ],
      "metadata": {
        "id": "uCIDUwf3CoNc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "converter = tf.lite.TFLiteConverter.from_saved_model(\"saved_models/\")\n",
        "converter.optimizations = [tf.lite.Optimize.DEFAULT]\n",
        "tflite_quant_model = converter.convert()\n",
        "print(convert_size(len(tflite_quant_model)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2yxML_mNCwAD",
        "outputId": "e33a92d8-135d-482d-e7af-c73d76f5ae4c"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2.23 MB\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "with open(\"tflite_model.tflite\", \"wb\") as f:\n",
        "    f.write(tflite_model)\n",
        "\n",
        "with open(\"tflite_quant_model.tflite\", \"wb\") as f:\n",
        "    f.write(tflite_quant_model)"
      ],
      "metadata": {
        "id": "Dgy7WS1cC0xN"
      },
      "execution_count": 28,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3. Quantization aware training\n",
        "\n",
        "Fine-tuning the trained model using Quantization aware training and converting it into tflite model."
      ],
      "metadata": {
        "id": "46RPjgvGC7xx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow_model_optimization as tfmot\n",
        "\n",
        "quantize_model = tfmot.quantization.keras.quantize_model\n",
        "\n",
        "# q_aware stands for for quantization aware.\n",
        "q_aware_model = quantize_model(model)\n",
        "\n",
        "# `quantize_model` requires a recompile.\n",
        "q_aware_model.compile(optimizer=RMSprop(learning_rate=0.001),loss='binary_crossentropy',metrics = ['accuracy'])\n",
        "\n",
        "q_aware_model.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jNQLKoLqC88T",
        "outputId": "d3885530-64ac-4eb9-8ec0-5719de8a5e0b"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " quantize_layer (QuantizeLay  (None, 150, 150, 3)      3         \n",
            " er)                                                             \n",
            "                                                                 \n",
            " quant_conv2d (QuantizeWrapp  (None, 148, 148, 128)    3843      \n",
            " erV2)                                                           \n",
            "                                                                 \n",
            " quant_conv2d_1 (QuantizeWra  (None, 146, 146, 64)     73923     \n",
            " pperV2)                                                         \n",
            "                                                                 \n",
            " quant_max_pooling2d (Quanti  (None, 36, 36, 64)       1         \n",
            " zeWrapperV2)                                                    \n",
            "                                                                 \n",
            " quant_conv2d_2 (QuantizeWra  (None, 34, 34, 128)      74115     \n",
            " pperV2)                                                         \n",
            "                                                                 \n",
            " quant_conv2d_3 (QuantizeWra  (None, 32, 32, 64)       73923     \n",
            " pperV2)                                                         \n",
            "                                                                 \n",
            " quant_max_pooling2d_1 (Quan  (None, 8, 8, 64)         1         \n",
            " tizeWrapperV2)                                                  \n",
            "                                                                 \n",
            " quant_flatten (QuantizeWrap  (None, 4096)             1         \n",
            " perV2)                                                          \n",
            "                                                                 \n",
            " quant_dense (QuantizeWrappe  (None, 512)              2097669   \n",
            " rV2)                                                            \n",
            "                                                                 \n",
            " quant_dropout (QuantizeWrap  (None, 512)              1         \n",
            " perV2)                                                          \n",
            "                                                                 \n",
            " quant_dense_1 (QuantizeWrap  (None, 1)                518       \n",
            " perV2)                                                          \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 2,323,998\n",
            "Trainable params: 2,323,201\n",
            "Non-trainable params: 797\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "q_aware_model.fit(train_generator,validation_data = validation_generator,steps_per_epoch=100,epochs=5,validation_steps = 10,verbose=1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T4LZ4xoXDARN",
        "outputId": "050017fe-2a87-4701-d23e-abd70977c181"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/5\n",
            "100/100 [==============================] - 15s 118ms/step - loss: 0.2164 - accuracy: 0.9175 - val_loss: 0.3407 - val_accuracy: 0.8700\n",
            "Epoch 2/5\n",
            "100/100 [==============================] - 11s 111ms/step - loss: 0.2259 - accuracy: 0.9160 - val_loss: 0.4573 - val_accuracy: 0.8450\n",
            "Epoch 3/5\n",
            "100/100 [==============================] - 10s 100ms/step - loss: 0.2283 - accuracy: 0.9105 - val_loss: 0.4861 - val_accuracy: 0.8100\n",
            "Epoch 4/5\n",
            "100/100 [==============================] - 10s 100ms/step - loss: 0.1892 - accuracy: 0.9355 - val_loss: 0.5461 - val_accuracy: 0.8450\n",
            "Epoch 5/5\n",
            "100/100 [==============================] - 10s 98ms/step - loss: 0.2203 - accuracy: 0.9165 - val_loss: 0.4263 - val_accuracy: 0.8300\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.callbacks.History at 0x798de0e23970>"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "test_dir = os.path.join(base_dir, 'test')\n",
        "test_generator = datagen.flow_from_directory(test_dir,\n",
        "                                                   batch_size=10,\n",
        "                                                   class_mode='binary',\n",
        "                                                   target_size = (150,150))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ub3y9BUdDO37",
        "outputId": "49496a58-2a30-48d4-e5c9-1615427cfe3b"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 0 images belonging to 2 classes.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "converter = tf.lite.TFLiteConverter.from_keras_model(q_aware_model)\n",
        "converter.optimizations = [tf.lite.Optimize.DEFAULT]\n",
        "\n",
        "tflite_qaware_model = converter.convert()\n",
        "\n",
        "len(tflite_qaware_model)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sMg3VngaD2Iu",
        "outputId": "206b8e06-0e5d-4a41-b028-453d043d1a77"
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:absl:Found untraced functions such as conv2d_layer_call_fn, conv2d_layer_call_and_return_conditional_losses, _jit_compiled_convolution_op, conv2d_1_layer_call_fn, conv2d_1_layer_call_and_return_conditional_losses while saving (showing 5 of 20). These functions will not be directly callable after loading.\n",
            "/usr/local/lib/python3.10/dist-packages/tensorflow/lite/python/convert.py:789: UserWarning: Statistics for quantized inputs were expected, but not specified; continuing anyway.\n",
            "  warnings.warn(\"Statistics for quantized inputs were expected, but not \"\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2341456"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(convert_size(len(tflite_qaware_model)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6pqhWYS_Nq9y",
        "outputId": "194582ee-2a6d-4082-9727-ed46adf295b0"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2.23 MB\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "with open(\"tflite_qaware_model.tflite\", 'wb') as f:\n",
        "    f.write(tflite_qaware_model)"
      ],
      "metadata": {
        "id": "Df3vzeBqD6-0"
      },
      "execution_count": 35,
      "outputs": []
    }
  ]
}