EfficientNetV2_B2_Quantization_CK+.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/OmidGhadami95/EfficientNetV2_Quantization_CK/blob/main/EfficientNetV2_B2_Quantization_CK%2B.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Preprocessing**"
      ],
      "metadata": {
        "id": "SGfzo5r6COEJ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Load data**"
      ],
      "metadata": {
        "id": "r0juzPi2CYEi"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "eyDWIJL6CsJ5"
      },
      "outputs": [],
      "source": [
        "from google.colab import drive\n",
        "from keras.preprocessing.image import ImageDataGenerator\n",
        "import shutil , os\n",
        "import osqp\n",
        "from tensorflow.keras import layers , models\n",
        "from tensorflow.keras import Model\n",
        "from tensorflow.keras.applications import EfficientNetV2B2\n",
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "import matplotlib.pyplot as plt\n",
        "!pip install tensorflow_model_optimization\n",
        "import numpy as np\n",
        "import urllib\n",
        "import zipfile\n",
        "import random\n",
        "from keras import Input\n",
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "import time\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import pandas as pd\n",
        "import tensorflow_model_optimization as tfmot\n",
        "from tensorflow.keras.callbacks import LearningRateScheduler\n",
        "from tensorflow.keras.callbacks import Callback\n",
        "\n",
        "#import seaborn as sns\n",
        "# from sklearn.metrics import confusion_matrix\n",
        "# from sklearn.metrics import f1_score\n",
        "# from sklearn.metrics import precision_score\n",
        "# from sklearn.metrics import recall_score\n",
        "\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Download CK+**"
      ],
      "metadata": {
        "id": "MKXv_hjeE0vE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Download CK+ dataset to Google Drive\n",
        "url = \"https://storage.googleapis.com/kaggle-data-sets/65125/128470/bundle/archive.zip?X-Goog-Algorithm=GOOG4-RSA-SHA256&X-Goog-Credential=gcp-kaggle-com%40kaggle-161607.iam.gserviceaccount.com%2F20230713%2Fauto%2Fstorage%2Fgoog4_request&X-Goog-Date=20230713T184454Z&X-Goog-Expires=259200&X-Goog-SignedHeaders=host&X-Goog-Signature=532508f50062fa30a107a155ccf6a10d784f05e1ea9a0adee2559ecfbed8878b6793635e3495822bd7cbec5ef57f3eb5fae2f6696d511bfb2ae50bf06fe1db7a8fadd4a3ede2591e2f0cb6251f19dbcaa8cd01708f25c596960d2a2c16602bfd5f963cf01766fc436796b21efb121e9deb69ca2075e5d75b9e28a151f3a990b8c83d0faf4f27e4c248ebed040e11c1b9b9445ac2991feaef4b6a26433ed29858ab50abcb8c65c58abb0428358c023f8e3c01f81fcac6ac8579326872df2e2f213e93f81a89475169867e38a672c14f62b06c72b4e606dfc23c50b0d42807b4cf7abe9e77039ea8fa48165cf2d890dcca666b07e2436ba7a13e8d8fee2a2f6e25\"\n",
        "extract_dir = \"/content/drive/MyDrive/CKplus_48.28\"\n",
        "\n",
        "zip_path, _ = urllib.request.urlretrieve(url)\n",
        "with zipfile.ZipFile(zip_path, \"r\") as f:\n",
        "    f.extractall(extract_dir)"
      ],
      "metadata": {
        "id": "f60l6ZaYD_w4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Split data into train, test and validation**"
      ],
      "metadata": {
        "id": "-aWRS8nxE63-"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pQ_3lJ81Ej4I"
      },
      "outputs": [],
      "source": [
        "base_dir = '/content/drive/MyDrive/generatedck+'\n",
        "os.mkdir(base_dir)\n",
        "train_dir = os.path.join(base_dir, 'train')\n",
        "os.mkdir(train_dir)\n",
        "validation_dir = os.path.join(base_dir, 'validation')\n",
        "os.mkdir(validation_dir)\n",
        "test_dir = os.path.join(base_dir, 'test')\n",
        "os.mkdir(test_dir)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "F9XgPnPVEj4I"
      },
      "outputs": [],
      "source": [
        "train_surprise_dir = os.path.join(train_dir, 'surprise')\n",
        "os.mkdir(train_surprise_dir)\n",
        "train_contempt_dir = os.path.join(train_dir, 'contempt')\n",
        "os.mkdir(train_contempt_dir)\n",
        "train_disgust_dir = os.path.join(train_dir, 'disgust')\n",
        "os.mkdir(train_disgust_dir)\n",
        "train_fear_dir = os.path.join(train_dir, 'fear')\n",
        "os.mkdir(train_fear_dir)\n",
        "train_anger_dir = os.path.join(train_dir, 'anger')\n",
        "os.mkdir(train_anger_dir)\n",
        "train_sadness_dir = os.path.join(train_dir, 'sadness')\n",
        "os.mkdir(train_sadness_dir)\n",
        "train_happy_dir = os.path.join(train_dir, 'happy')\n",
        "os.mkdir(train_happy_dir)\n",
        "\n",
        "validation_surprise_dir = os.path.join(validation_dir, 'surprise')\n",
        "os.mkdir(validation_surprise_dir)\n",
        "validation_contempt_dir = os.path.join(validation_dir, 'contempt')\n",
        "os.mkdir(validation_contempt_dir)\n",
        "validation_disgust_dir = os.path.join(validation_dir, 'disgust')\n",
        "os.mkdir(validation_disgust_dir)\n",
        "validation_fear_dir = os.path.join(validation_dir, 'fear')\n",
        "os.mkdir(validation_fear_dir)\n",
        "validation_anger_dir = os.path.join(validation_dir, 'anger')\n",
        "os.mkdir(validation_anger_dir)\n",
        "validation_sadness_dir = os.path.join(validation_dir, 'sadness')\n",
        "os.mkdir(validation_sadness_dir)\n",
        "validation_happy_dir = os.path.join(validation_dir, 'happy')\n",
        "os.mkdir(validation_happy_dir)\n",
        "\n",
        "test_surprise_dir = os.path.join(test_dir, 'surprise')\n",
        "os.mkdir(test_surprise_dir)\n",
        "test_contempt_dir = os.path.join(test_dir, 'contempt')\n",
        "os.mkdir(test_contempt_dir)\n",
        "test_disgust_dir = os.path.join(test_dir, 'disgust')\n",
        "os.mkdir(test_disgust_dir)\n",
        "test_fear_dir = os.path.join(test_dir, 'fear')\n",
        "os.mkdir(test_fear_dir)\n",
        "test_anger_dir = os.path.join(test_dir, 'anger')\n",
        "os.mkdir(test_anger_dir)\n",
        "test_sadness_dir = os.path.join(test_dir, 'sadness')\n",
        "os.mkdir(test_sadness_dir)\n",
        "test_happy_dir = os.path.join(test_dir, 'happy')\n",
        "os.mkdir(test_happy_dir)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ItDPm9_PpmcU"
      },
      "outputs": [],
      "source": [
        "original_surprise_dir = r'/content/drive/MyDrive/CKplus_48.28/ck/CK+48/surprise'\n",
        "original_contempt_dir = r'/content/drive/MyDrive/CKplus_48.28/ck/CK+48/contempt'\n",
        "original_disgust_dir = r'/content/drive/MyDrive/CKplus_48.28/ck/CK+48/disgust'\n",
        "original_fear_dir = r'/content/drive/MyDrive/CKplus_48.28/ck/CK+48/fear'\n",
        "original_anger_dir = r'/content/drive/MyDrive/CKplus_48.28/ck/CK+48/anger'\n",
        "original_sadness_dir = r'/content/drive/MyDrive/CKplus_48.28/ck/CK+48/sadness'\n",
        "original_happy_dir = r'/content/drive/MyDrive/CKplus_48.28/ck/CK+48/happy'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4JKJmLNAGSU4"
      },
      "outputs": [],
      "source": [
        "def get_file_list(input_dir):\n",
        "    return [file for file in os.listdir(input_dir) if os.path.isfile(os.path.join(input_dir, file))]\n",
        "\n",
        "def get_random_files(file_list, N):\n",
        "    return random.sample(file_list, N)\n",
        "\n",
        "def move_files(random_files, input_dir, output_dir):\n",
        "    for file in random_files:\n",
        "        shutil.move(os.path.join(input_dir, file), output_dir)\n",
        "\n",
        "def main(input_dir, output_dir, N):\n",
        "    file_list = get_file_list(input_dir)\n",
        "    random_files = get_random_files(file_list, N)\n",
        "    move_files(random_files, input_dir, output_dir)\n",
        "def remain(input_dir, output_dir):\n",
        "  file_list = get_file_list(input_dir)\n",
        "  for file in file_list:\n",
        "    shutil.move(os.path.join(input_dir, file), output_dir)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "58cmRjxTGSU4",
        "outputId": "c268f06a-0276-4ebd-b082-085c12eda3a7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "surprise train Done!\n",
            "surprise validation Done!\n",
            "surprise test Done!\n",
            "---------------\n",
            "sadness train Done!\n",
            "sadness validation Done!\n",
            "sadness test Done!\n",
            "---------------\n",
            "anger train Done!\n",
            "anger validation Done!\n",
            "anger test Done!\n",
            "---------------\n",
            "contempt train Done!\n",
            "contempt validation Done!\n",
            "contempt test Done!\n",
            "---------------\n",
            "happy train Done!\n",
            "happy validation Done!\n",
            "happy test Done!\n",
            "---------------\n",
            "disgust train Done!\n",
            "disgust validation Done!\n",
            "disgust test Done!\n",
            "---------------\n",
            "fear train Done!\n",
            "fear validation Done!\n",
            "fear test Done!\n",
            "---------------\n"
          ]
        }
      ],
      "source": [
        "transfer_list = [(original_surprise_dir,train_surprise_dir,validation_surprise_dir,test_surprise_dir),\n",
        "                            (original_sadness_dir,train_sadness_dir,validation_sadness_dir,test_sadness_dir),\n",
        "                            (original_anger_dir,train_anger_dir,validation_anger_dir,test_anger_dir),\n",
        "                            (original_contempt_dir,train_contempt_dir,validation_contempt_dir,test_contempt_dir),\n",
        "                            (original_happy_dir,train_happy_dir,validation_happy_dir,test_happy_dir),\n",
        "                            (original_disgust_dir,train_disgust_dir,validation_disgust_dir,test_disgust_dir),\n",
        "                            (original_fear_dir,train_fear_dir,validation_fear_dir,test_fear_dir)]\n",
        "for src, dst1, dst2, dst3 in transfer_list:\n",
        "    main(src , dst1 , int(0.7 * len([name for name in os.listdir(src) if os.path.isfile(os.path.join(src, name))])))\n",
        "    print(src.split('/')[-1], 'train Done!')\n",
        "    main(src , dst2 , int(0.5 * len([name for name in os.listdir(src) if os.path.isfile(os.path.join(src, name))])))\n",
        "    print(src.split('/')[-1], 'validation Done!')\n",
        "    remain(src,dst3)\n",
        "    print(src.split('/')[-1], 'test Done!')\n",
        "    print('---------------')\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QRo-I5L0WmWE"
      },
      "outputs": [],
      "source": [
        "train_surprise_dir = r'/content/drive/MyDrive/generated2/train/surprise'\n",
        "train_contempt_dir = r'/content/drive/MyDrive/generated2/train/contempt'\n",
        "train_disgust_dir = r'/content/drive/MyDrive/generated2/train/disgust'\n",
        "train_fear_dir = r'/content/drive/MyDrive/generated2/train/fear'\n",
        "train_anger_dir = r'/content/drive/MyDrive/generated2/train/anger'\n",
        "train_sadness_dir = r'/content/drive/MyDrive/generated2/train/sadness'\n",
        "train_happy_dir = r'/content/drive/MyDrive/generated2/train/happy'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Id23bItCWmMo"
      },
      "outputs": [],
      "source": [
        "validation_surprise_dir = r'/content/drive/MyDrive/generated2/validation/surprise'\n",
        "validation_contempt_dir = r'/content/drive/MyDrive/generated2/validation/contempt'\n",
        "validation_disgust_dir = r'/content/drive/MyDrive/generated2/validation/disgust'\n",
        "validation_fear_dir = r'/content/drive/MyDrive/generated2/validation/fear'\n",
        "validation_anger_dir = r'/content/drive/MyDrive/generated2/validation/anger'\n",
        "validation_sadness_dir = r'/content/drive/MyDrive/generated2/validation/sadness'\n",
        "validation_happy_dir = r'/content/drive/MyDrive/generated2/validation/happy'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XpX7g4KNX_Dt"
      },
      "outputs": [],
      "source": [
        "test_surprise_dir = r'/content/drive/MyDrive/generated2/test/surprise'\n",
        "test_contempt_dir = r'/content/drive/MyDrive/generated2/test/contempt'\n",
        "test_disgust_dir = r'/content/drive/MyDrive/generated2/test/disgust'\n",
        "test_fear_dir = r'/content/drive/MyDrive/generated2/test/fear'\n",
        "test_anger_dir = r'/content/drive/MyDrive/generated2/test/anger'\n",
        "test_sadness_dir = r'/content/drive/MyDrive/generated2/test/sadness'\n",
        "test_happy_dir = r'/content/drive/MyDrive/generated2/test/happy'"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Preprocessing**"
      ],
      "metadata": {
        "id": "KBKW2fdjHqfC"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GYHxR5FZIsyH"
      },
      "source": [
        "## **Solving imbalanced dataset problem**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kTbNk3hsbq40"
      },
      "outputs": [],
      "source": [
        "t_surprise = len([name for name in os.listdir(train_surprise_dir) if os.path.isfile(os.path.join(train_surprise_dir, name))])\n",
        "t_sadness = len([name for name in os.listdir(train_sadness_dir) if os.path.isfile(os.path.join(train_sadness_dir, name))])\n",
        "t_happy = len([name for name in os.listdir(train_happy_dir) if os.path.isfile(os.path.join(train_happy_dir, name))])\n",
        "t_fear = len([name for name in os.listdir(train_fear_dir) if os.path.isfile(os.path.join(train_fear_dir, name))])\n",
        "t_disgust = len([name for name in os.listdir(train_disgust_dir) if os.path.isfile(os.path.join(train_disgust_dir, name))])\n",
        "t_contempt = len([name for name in os.listdir(train_contempt_dir) if os.path.isfile(os.path.join(train_contempt_dir, name))])\n",
        "t_anger = len([name for name in os.listdir(train_anger_dir) if os.path.isfile(os.path.join(train_anger_dir, name))])\n",
        "label_list = [t_surprise, t_sadness, t_happy, t_fear, t_disgust, t_contempt, t_anger]\n",
        "total = 0\n",
        "max = 0\n",
        "for each in label_list:\n",
        "  total+=each\n",
        "  if each > max:\n",
        "    max = each\n",
        "\n",
        "w_surprise = float(max/t_surprise)\n",
        "w_sadness = float(max/t_sadness)\n",
        "w_happy = float(max/t_happy)\n",
        "w_fear = float(max/t_fear)\n",
        "w_disgust = float(max/t_disgust)\n",
        "w_contempt = float(max/t_contempt)\n",
        "w_anger = float(max/t_anger)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "AlcStAXNUule"
      },
      "outputs": [],
      "source": [
        "class_weight = {0: w_surprise,\n",
        "                1: w_sadness,\n",
        "                2: w_happy,\n",
        "                3: w_fear,\n",
        "                4: w_disgust,\n",
        "                5: w_contempt,\n",
        "                6: w_anger}"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Augmentation, Normalization and Resizing with ImageDataGenerator**"
      ],
      "metadata": {
        "id": "ehMFl-4jH5Cw"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "M_6WpP4j9lfK",
        "outputId": "092e8b45-ed15-4a8e-ec1c-adbdfa57bfe6"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 682 images belonging to 7 classes.\n",
            "Found 147 images belonging to 7 classes.\n",
            "Found 152 images belonging to 7 classes.\n"
          ]
        }
      ],
      "source": [
        "train_datagen = ImageDataGenerator(preprocessing_function=lambda x: (x / 127.5) - 1.0,\n",
        "                                   rotation_range = 40,\n",
        "                                   width_shift_range = 0.25,\n",
        "                                   height_shift_range = 0.25,\n",
        "                                   shear_range = 0.25,\n",
        "                                   zoom_range = 0.25,\n",
        "                                   horizontal_flip = True,\n",
        "                                   fill_mode='nearest')\n",
        "test_datagen = ImageDataGenerator(preprocessing_function=lambda x: (x / 127.5) - 1.0)\n",
        "\n",
        "train_generator = train_datagen.flow_from_directory(\n",
        "        train_dir,\n",
        "        target_size=(260, 260),\n",
        "        batch_size=16,\n",
        "        class_mode='categorical')\n",
        "validation_generator = test_datagen.flow_from_directory(\n",
        "        validation_dir,\n",
        "        target_size=(260, 260),\n",
        "        batch_size=16,\n",
        "        class_mode='categorical')\n",
        "test_generator = test_datagen.flow_from_directory(\n",
        "        test_dir,\n",
        "        target_size=(260, 260),\n",
        "        class_mode='categorical')"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Visualization for images after augmentation, normalization and resizing**"
      ],
      "metadata": {
        "id": "zzBL_ywkId7R"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "ZNyHPxkzOE8W",
        "outputId": "c006168a-6961-422d-d440-565a5a3ae94a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(16, 260, 260, 3)\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[[[-0.60784316 -0.60784316 -0.60784316]\n",
            "   [-0.60784316 -0.60784316 -0.60784316]\n",
            "   [-0.57748514 -0.57748514 -0.57748514]\n",
            "   ...\n",
            "   [-0.96862745 -0.96862745 -0.96862745]\n",
            "   [-0.96862745 -0.96862745 -0.96862745]\n",
            "   [-0.96862745 -0.96862745 -0.96862745]]\n",
            "\n",
            "  [[-0.60784316 -0.60784316 -0.60784316]\n",
            "   [-0.60784316 -0.60784316 -0.60784316]\n",
            "   [-0.60784316 -0.60784316 -0.60784316]\n",
            "   ...\n",
            "   [-0.96862745 -0.96862745 -0.96862745]\n",
            "   [-0.96862745 -0.96862745 -0.96862745]\n",
            "   [-0.96862745 -0.96862745 -0.96862745]]\n",
            "\n",
            "  [[-0.60784316 -0.60784316 -0.60784316]\n",
            "   [-0.60784316 -0.60784316 -0.60784316]\n",
            "   [-0.60784316 -0.60784316 -0.60784316]\n",
            "   ...\n",
            "   [-0.96862745 -0.96862745 -0.96862745]\n",
            "   [-0.96862745 -0.96862745 -0.96862745]\n",
            "   [-0.96862745 -0.96862745 -0.96862745]]\n",
            "\n",
            "  ...\n",
            "\n",
            "  [[-0.7254902  -0.7254902  -0.7254902 ]\n",
            "   [-0.7254902  -0.7254902  -0.7254902 ]\n",
            "   [-0.7254902  -0.7254902  -0.7254902 ]\n",
            "   ...\n",
            "   [-0.00392157 -0.00392157 -0.00392157]\n",
            "   [-0.00392157 -0.00392157 -0.00392157]\n",
            "   [-0.00392157 -0.00392157 -0.00392157]]\n",
            "\n",
            "  [[-0.7254902  -0.7254902  -0.7254902 ]\n",
            "   [-0.72011614 -0.72011614 -0.72011614]\n",
            "   [-0.6900458  -0.6900458  -0.6900458 ]\n",
            "   ...\n",
            "   [-0.00392157 -0.00392157 -0.00392157]\n",
            "   [-0.00392157 -0.00392157 -0.00392157]\n",
            "   [-0.00392157 -0.00392157 -0.00392157]]\n",
            "\n",
            "  [[-0.714151   -0.714151   -0.714151  ]\n",
            "   [-0.6862745  -0.6862745  -0.6862745 ]\n",
            "   [-0.6862745  -0.6862745  -0.6862745 ]\n",
            "   ...\n",
            "   [ 0.0037533   0.0037533   0.0037533 ]\n",
            "   [-0.00392157 -0.00392157 -0.00392157]\n",
            "   [-0.00392157 -0.00392157 -0.00392157]]]\n",
            "\n",
            "\n",
            " [[[-0.9372549  -0.9372549  -0.9372549 ]\n",
            "   [-0.9372549  -0.9372549  -0.9372549 ]\n",
            "   [-0.9372549  -0.9372549  -0.9372549 ]\n",
            "   ...\n",
            "   [ 0.49803925  0.49803925  0.49803925]\n",
            "   [ 0.49803925  0.49803925  0.49803925]\n",
            "   [ 0.49803925  0.49803925  0.49803925]]\n",
            "\n",
            "  [[-0.9372549  -0.9372549  -0.9372549 ]\n",
            "   [-0.9372549  -0.9372549  -0.9372549 ]\n",
            "   [-0.9372549  -0.9372549  -0.9372549 ]\n",
            "   ...\n",
            "   [ 0.49803925  0.49803925  0.49803925]\n",
            "   [ 0.49803925  0.49803925  0.49803925]\n",
            "   [ 0.49803925  0.49803925  0.49803925]]\n",
            "\n",
            "  [[-0.93241775 -0.93241775 -0.93241775]\n",
            "   [-0.9372549  -0.9372549  -0.9372549 ]\n",
            "   [-0.9372549  -0.9372549  -0.9372549 ]\n",
            "   ...\n",
            "   [ 0.49803925  0.49803925  0.49803925]\n",
            "   [ 0.49803925  0.49803925  0.49803925]\n",
            "   [ 0.49750268  0.49750268  0.49750268]]\n",
            "\n",
            "  ...\n",
            "\n",
            "  [[-0.96862745 -0.96862745 -0.96862745]\n",
            "   [-0.96862745 -0.96862745 -0.96862745]\n",
            "   [-0.96703047 -0.96703047 -0.96703047]\n",
            "   ...\n",
            "   [ 0.0196079   0.0196079   0.0196079 ]\n",
            "   [ 0.0196079   0.0196079   0.0196079 ]\n",
            "   [ 0.0196079   0.0196079   0.0196079 ]]\n",
            "\n",
            "  [[-0.96862745 -0.96862745 -0.96862745]\n",
            "   [-0.96862745 -0.96862745 -0.96862745]\n",
            "   [-0.9556409  -0.9556409  -0.9556409 ]\n",
            "   ...\n",
            "   [ 0.01033187  0.01033187  0.01033187]\n",
            "   [ 0.0196079   0.0196079   0.0196079 ]\n",
            "   [ 0.0196079   0.0196079   0.0196079 ]]\n",
            "\n",
            "  [[-0.96862745 -0.96862745 -0.96862745]\n",
            "   [-0.96498245 -0.96498245 -0.96498245]\n",
            "   [-0.94509804 -0.94509804 -0.94509804]\n",
            "   ...\n",
            "   [-0.00392157 -0.00392157 -0.00392157]\n",
            "   [ 0.01075101  0.01075101  0.01075101]\n",
            "   [ 0.0196079   0.0196079   0.0196079 ]]]\n",
            "\n",
            "\n",
            " [[[-0.4588235  -0.4588235  -0.4588235 ]\n",
            "   [-0.4588235  -0.4588235  -0.4588235 ]\n",
            "   [-0.4588235  -0.4588235  -0.4588235 ]\n",
            "   ...\n",
            "   [-0.26732856 -0.26732856 -0.26732856]\n",
            "   [-0.2516203  -0.2516203  -0.2516203 ]\n",
            "   [-0.24705881 -0.24705881 -0.24705881]]\n",
            "\n",
            "  [[-0.4588235  -0.4588235  -0.4588235 ]\n",
            "   [-0.4588235  -0.4588235  -0.4588235 ]\n",
            "   [-0.4588235  -0.4588235  -0.4588235 ]\n",
            "   ...\n",
            "   [-0.24705881 -0.24705881 -0.24705881]\n",
            "   [-0.24705881 -0.24705881 -0.24705881]\n",
            "   [-0.24705881 -0.24705881 -0.24705881]]\n",
            "\n",
            "  [[-0.48920238 -0.48920238 -0.48920238]\n",
            "   [-0.50805223 -0.50805223 -0.50805223]\n",
            "   [-0.5269022  -0.5269022  -0.5269022 ]\n",
            "   ...\n",
            "   [-0.24068648 -0.24068648 -0.24068648]\n",
            "   [-0.24705881 -0.24705881 -0.24705881]\n",
            "   [-0.24705881 -0.24705881 -0.24705881]]\n",
            "\n",
            "  ...\n",
            "\n",
            "  [[-0.7254902  -0.7254902  -0.7254902 ]\n",
            "   [-0.7254902  -0.7254902  -0.7254902 ]\n",
            "   [-0.7254902  -0.7254902  -0.7254902 ]\n",
            "   ...\n",
            "   [-0.47450978 -0.47450978 -0.47450978]\n",
            "   [-0.47450978 -0.47450978 -0.47450978]\n",
            "   [-0.4874575  -0.4874575  -0.4874575 ]]\n",
            "\n",
            "  [[-0.7254902  -0.7254902  -0.7254902 ]\n",
            "   [-0.7254902  -0.7254902  -0.7254902 ]\n",
            "   [-0.7254902  -0.7254902  -0.7254902 ]\n",
            "   ...\n",
            "   [-0.47450978 -0.47450978 -0.47450978]\n",
            "   [-0.47450978 -0.47450978 -0.47450978]\n",
            "   [-0.48128664 -0.48128664 -0.48128664]]\n",
            "\n",
            "  [[-0.7254902  -0.7254902  -0.7254902 ]\n",
            "   [-0.7254902  -0.7254902  -0.7254902 ]\n",
            "   [-0.7254902  -0.7254902  -0.7254902 ]\n",
            "   ...\n",
            "   [-0.47450978 -0.47450978 -0.47450978]\n",
            "   [-0.47450978 -0.47450978 -0.47450978]\n",
            "   [-0.47511572 -0.47511572 -0.47511572]]]\n",
            "\n",
            "\n",
            " ...\n",
            "\n",
            "\n",
            " [[[ 0.00392163  0.00392163  0.00392163]\n",
            "   [ 0.00392163  0.00392163  0.00392163]\n",
            "   [ 0.00392163  0.00392163  0.00392163]\n",
            "   ...\n",
            "   [-0.41176468 -0.41176468 -0.41176468]\n",
            "   [-0.41176468 -0.41176468 -0.41176468]\n",
            "   [-0.41176468 -0.41176468 -0.41176468]]\n",
            "\n",
            "  [[ 0.00392163  0.00392163  0.00392163]\n",
            "   [ 0.00392163  0.00392163  0.00392163]\n",
            "   [ 0.00392163  0.00392163  0.00392163]\n",
            "   ...\n",
            "   [-0.41176468 -0.41176468 -0.41176468]\n",
            "   [-0.41176468 -0.41176468 -0.41176468]\n",
            "   [-0.41176468 -0.41176468 -0.41176468]]\n",
            "\n",
            "  [[ 0.00392163  0.00392163  0.00392163]\n",
            "   [ 0.00392163  0.00392163  0.00392163]\n",
            "   [ 0.00392163  0.00392163  0.00392163]\n",
            "   ...\n",
            "   [-0.41176468 -0.41176468 -0.41176468]\n",
            "   [-0.41176468 -0.41176468 -0.41176468]\n",
            "   [-0.41176468 -0.41176468 -0.41176468]]\n",
            "\n",
            "  ...\n",
            "\n",
            "  [[ 0.6086129   0.6086129   0.6086129 ]\n",
            "   [ 0.60545075  0.60545075  0.60545075]\n",
            "   [ 0.6022887   0.6022887   0.6022887 ]\n",
            "   ...\n",
            "   [-0.42745095 -0.42745095 -0.42745095]\n",
            "   [-0.42745095 -0.42745095 -0.42745095]\n",
            "   [-0.42745095 -0.42745095 -0.42745095]]\n",
            "\n",
            "  [[ 0.6156863   0.6156863   0.6156863 ]\n",
            "   [ 0.6156863   0.6156863   0.6156863 ]\n",
            "   [ 0.6156863   0.6156863   0.6156863 ]\n",
            "   ...\n",
            "   [-0.42745095 -0.42745095 -0.42745095]\n",
            "   [-0.42745095 -0.42745095 -0.42745095]\n",
            "   [-0.42745095 -0.42745095 -0.42745095]]\n",
            "\n",
            "  [[ 0.6156863   0.6156863   0.6156863 ]\n",
            "   [ 0.6156863   0.6156863   0.6156863 ]\n",
            "   [ 0.6156863   0.6156863   0.6156863 ]\n",
            "   ...\n",
            "   [-0.42745095 -0.42745095 -0.42745095]\n",
            "   [-0.42745095 -0.42745095 -0.42745095]\n",
            "   [-0.42745095 -0.42745095 -0.42745095]]]\n",
            "\n",
            "\n",
            " [[[-0.44313723 -0.44313723 -0.44313723]\n",
            "   [-0.44313723 -0.44313723 -0.44313723]\n",
            "   [-0.44313723 -0.44313723 -0.44313723]\n",
            "   ...\n",
            "   [-0.4588235  -0.4588235  -0.4588235 ]\n",
            "   [-0.4588235  -0.4588235  -0.4588235 ]\n",
            "   [-0.4588235  -0.4588235  -0.4588235 ]]\n",
            "\n",
            "  [[-0.44313723 -0.44313723 -0.44313723]\n",
            "   [-0.44313723 -0.44313723 -0.44313723]\n",
            "   [-0.44313723 -0.44313723 -0.44313723]\n",
            "   ...\n",
            "   [-0.4588235  -0.4588235  -0.4588235 ]\n",
            "   [-0.4588235  -0.4588235  -0.4588235 ]\n",
            "   [-0.4588235  -0.4588235  -0.4588235 ]]\n",
            "\n",
            "  [[-0.44313723 -0.44313723 -0.44313723]\n",
            "   [-0.44313723 -0.44313723 -0.44313723]\n",
            "   [-0.44313723 -0.44313723 -0.44313723]\n",
            "   ...\n",
            "   [-0.4588235  -0.4588235  -0.4588235 ]\n",
            "   [-0.4588235  -0.4588235  -0.4588235 ]\n",
            "   [-0.4588235  -0.4588235  -0.4588235 ]]\n",
            "\n",
            "  ...\n",
            "\n",
            "  [[-0.8117647  -0.8117647  -0.8117647 ]\n",
            "   [-0.8117647  -0.8117647  -0.8117647 ]\n",
            "   [-0.8117647  -0.8117647  -0.8117647 ]\n",
            "   ...\n",
            "   [-0.80410004 -0.80410004 -0.80410004]\n",
            "   [-0.7882353  -0.7882353  -0.7882353 ]\n",
            "   [-0.7882353  -0.7882353  -0.7882353 ]]\n",
            "\n",
            "  [[-0.8117647  -0.8117647  -0.8117647 ]\n",
            "   [-0.8117647  -0.8117647  -0.8117647 ]\n",
            "   [-0.8117647  -0.8117647  -0.8117647 ]\n",
            "   ...\n",
            "   [-0.816864   -0.816864   -0.816864  ]\n",
            "   [-0.7882353  -0.7882353  -0.7882353 ]\n",
            "   [-0.7882353  -0.7882353  -0.7882353 ]]\n",
            "\n",
            "  [[-0.8117647  -0.8117647  -0.8117647 ]\n",
            "   [-0.8117647  -0.8117647  -0.8117647 ]\n",
            "   [-0.8117647  -0.8117647  -0.8117647 ]\n",
            "   ...\n",
            "   [-0.827451   -0.827451   -0.827451  ]\n",
            "   [-0.7882353  -0.7882353  -0.7882353 ]\n",
            "   [-0.7882353  -0.7882353  -0.7882353 ]]]\n",
            "\n",
            "\n",
            " [[[-0.8745098  -0.8745098  -0.8745098 ]\n",
            "   [-0.8745098  -0.8745098  -0.8745098 ]\n",
            "   [-0.8745098  -0.8745098  -0.8745098 ]\n",
            "   ...\n",
            "   [-0.9529412  -0.9529412  -0.9529412 ]\n",
            "   [-0.9258623  -0.9258623  -0.9258623 ]\n",
            "   [-0.85882354 -0.85882354 -0.85882354]]\n",
            "\n",
            "  [[-0.9529412  -0.9529412  -0.9529412 ]\n",
            "   [-0.9493377  -0.9493377  -0.9493377 ]\n",
            "   [-0.94565773 -0.94565773 -0.94565773]\n",
            "   ...\n",
            "   [-0.9529412  -0.9529412  -0.9529412 ]\n",
            "   [-0.92161036 -0.92161036 -0.92161036]\n",
            "   [-0.85882354 -0.85882354 -0.85882354]]\n",
            "\n",
            "  [[-0.9529412  -0.9529412  -0.9529412 ]\n",
            "   [-0.9529412  -0.9529412  -0.9529412 ]\n",
            "   [-0.9529412  -0.9529412  -0.9529412 ]\n",
            "   ...\n",
            "   [-0.9607843  -0.9607843  -0.9607843 ]\n",
            "   [-0.9452338  -0.9452338  -0.9452338 ]\n",
            "   [-0.91703546 -0.91703546 -0.91703546]]\n",
            "\n",
            "  ...\n",
            "\n",
            "  [[-0.8117647  -0.8117647  -0.8117647 ]\n",
            "   [-0.8117647  -0.8117647  -0.8117647 ]\n",
            "   [-0.8117647  -0.8117647  -0.8117647 ]\n",
            "   ...\n",
            "   [-0.67058825 -0.67058825 -0.67058825]\n",
            "   [-0.6776319  -0.6776319  -0.6776319 ]\n",
            "   [-0.6784314  -0.6784314  -0.6784314 ]]\n",
            "\n",
            "  [[-0.8117647  -0.8117647  -0.8117647 ]\n",
            "   [-0.8117647  -0.8117647  -0.8117647 ]\n",
            "   [-0.8117647  -0.8117647  -0.8117647 ]\n",
            "   ...\n",
            "   [-0.67058825 -0.67058825 -0.67058825]\n",
            "   [-0.6779862  -0.6779862  -0.6779862 ]\n",
            "   [-0.6784314  -0.6784314  -0.6784314 ]]\n",
            "\n",
            "  [[-0.8117647  -0.8117647  -0.8117647 ]\n",
            "   [-0.8117647  -0.8117647  -0.8117647 ]\n",
            "   [-0.8117647  -0.8117647  -0.8117647 ]\n",
            "   ...\n",
            "   [-0.67058825 -0.67058825 -0.67058825]\n",
            "   [-0.67834055 -0.67834055 -0.67834055]\n",
            "   [-0.6784314  -0.6784314  -0.6784314 ]]]]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(16, 260, 260, 3)\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[[[-0.7176471  -0.7176471  -0.7176471 ]\n",
            "   [-0.7176471  -0.7176471  -0.7176471 ]\n",
            "   [-0.7176471  -0.7176471  -0.7176471 ]\n",
            "   ...\n",
            "   [ 0.16128421  0.16128421  0.16128421]\n",
            "   [ 0.14509809  0.14509809  0.14509809]\n",
            "   [ 0.14509809  0.14509809  0.14509809]]\n",
            "\n",
            "  [[-0.7176471  -0.7176471  -0.7176471 ]\n",
            "   [-0.7176471  -0.7176471  -0.7176471 ]\n",
            "   [-0.7176471  -0.7176471  -0.7176471 ]\n",
            "   ...\n",
            "   [ 0.18431377  0.18431377  0.18431377]\n",
            "   [ 0.17309201  0.17309201  0.17309201]\n",
            "   [ 0.16169262  0.16169262  0.16169262]]\n",
            "\n",
            "  [[-0.5608341  -0.5608341  -0.5608341 ]\n",
            "   [-0.63378966 -0.63378966 -0.63378966]\n",
            "   [-0.70674527 -0.70674527 -0.70674527]\n",
            "   ...\n",
            "   [ 0.18431377  0.18431377  0.18431377]\n",
            "   [ 0.18431377  0.18431377  0.18431377]\n",
            "   [ 0.18431377  0.18431377  0.18431377]]\n",
            "\n",
            "  ...\n",
            "\n",
            "  [[-0.0745098  -0.0745098  -0.0745098 ]\n",
            "   [-0.0745098  -0.0745098  -0.0745098 ]\n",
            "   [-0.0745098  -0.0745098  -0.0745098 ]\n",
            "   ...\n",
            "   [-0.6627451  -0.6627451  -0.6627451 ]\n",
            "   [-0.6627451  -0.6627451  -0.6627451 ]\n",
            "   [-0.6627451  -0.6627451  -0.6627451 ]]\n",
            "\n",
            "  [[-0.0745098  -0.0745098  -0.0745098 ]\n",
            "   [-0.0745098  -0.0745098  -0.0745098 ]\n",
            "   [-0.09028852 -0.09028852 -0.09028852]\n",
            "   ...\n",
            "   [-0.6627451  -0.6627451  -0.6627451 ]\n",
            "   [-0.6627451  -0.6627451  -0.6627451 ]\n",
            "   [-0.6627451  -0.6627451  -0.6627451 ]]\n",
            "\n",
            "  [[-0.0745098  -0.0745098  -0.0745098 ]\n",
            "   [-0.0745098  -0.0745098  -0.0745098 ]\n",
            "   [-0.11179614 -0.11179614 -0.11179614]\n",
            "   ...\n",
            "   [-0.6627451  -0.6627451  -0.6627451 ]\n",
            "   [-0.6627451  -0.6627451  -0.6627451 ]\n",
            "   [-0.6627451  -0.6627451  -0.6627451 ]]]\n",
            "\n",
            "\n",
            " [[[-0.6        -0.6        -0.6       ]\n",
            "   [-0.6        -0.6        -0.6       ]\n",
            "   [-0.6        -0.6        -0.6       ]\n",
            "   ...\n",
            "   [-0.4980392  -0.4980392  -0.4980392 ]\n",
            "   [-0.4980392  -0.4980392  -0.4980392 ]\n",
            "   [-0.4980392  -0.4980392  -0.4980392 ]]\n",
            "\n",
            "  [[-0.6        -0.6        -0.6       ]\n",
            "   [-0.6        -0.6        -0.6       ]\n",
            "   [-0.6        -0.6        -0.6       ]\n",
            "   ...\n",
            "   [-0.4980392  -0.4980392  -0.4980392 ]\n",
            "   [-0.4980392  -0.4980392  -0.4980392 ]\n",
            "   [-0.4980392  -0.4980392  -0.4980392 ]]\n",
            "\n",
            "  [[-0.6        -0.6        -0.6       ]\n",
            "   [-0.6        -0.6        -0.6       ]\n",
            "   [-0.6        -0.6        -0.6       ]\n",
            "   ...\n",
            "   [-0.4980392  -0.4980392  -0.4980392 ]\n",
            "   [-0.4980392  -0.4980392  -0.4980392 ]\n",
            "   [-0.4980392  -0.4980392  -0.4980392 ]]\n",
            "\n",
            "  ...\n",
            "\n",
            "  [[-0.79607844 -0.79607844 -0.79607844]\n",
            "   [-0.79607844 -0.79607844 -0.79607844]\n",
            "   [-0.79607844 -0.79607844 -0.79607844]\n",
            "   ...\n",
            "   [-0.64705884 -0.64705884 -0.64705884]\n",
            "   [-0.64705884 -0.64705884 -0.64705884]\n",
            "   [-0.6429625  -0.6429625  -0.6429625 ]]\n",
            "\n",
            "  [[-0.79607844 -0.79607844 -0.79607844]\n",
            "   [-0.79607844 -0.79607844 -0.79607844]\n",
            "   [-0.79607844 -0.79607844 -0.79607844]\n",
            "   ...\n",
            "   [-0.64705884 -0.64705884 -0.64705884]\n",
            "   [-0.64705884 -0.64705884 -0.64705884]\n",
            "   [-0.6441486  -0.6441486  -0.6441486 ]]\n",
            "\n",
            "  [[-0.79607844 -0.79607844 -0.79607844]\n",
            "   [-0.79607844 -0.79607844 -0.79607844]\n",
            "   [-0.79607844 -0.79607844 -0.79607844]\n",
            "   ...\n",
            "   [-0.64705884 -0.64705884 -0.64705884]\n",
            "   [-0.64705884 -0.64705884 -0.64705884]\n",
            "   [-0.64533454 -0.64533454 -0.64533454]]]\n",
            "\n",
            "\n",
            " [[[-0.46666664 -0.46666664 -0.46666664]\n",
            "   [-0.46666664 -0.46666664 -0.46666664]\n",
            "   [-0.46666664 -0.46666664 -0.46666664]\n",
            "   ...\n",
            "   [ 0.73333335  0.73333335  0.73333335]\n",
            "   [ 0.73333335  0.73333335  0.73333335]\n",
            "   [ 0.6836084   0.6836084   0.6836084 ]]\n",
            "\n",
            "  [[-0.46666664 -0.46666664 -0.46666664]\n",
            "   [-0.46666664 -0.46666664 -0.46666664]\n",
            "   [-0.46666664 -0.46666664 -0.46666664]\n",
            "   ...\n",
            "   [ 0.73333335  0.73333335  0.73333335]\n",
            "   [ 0.73333335  0.73333335  0.73333335]\n",
            "   [ 0.58605766  0.58605766  0.58605766]]\n",
            "\n",
            "  [[-0.46666664 -0.46666664 -0.46666664]\n",
            "   [-0.46666664 -0.46666664 -0.46666664]\n",
            "   [-0.46666664 -0.46666664 -0.46666664]\n",
            "   ...\n",
            "   [ 0.73333335  0.73333335  0.73333335]\n",
            "   [ 0.73333335  0.73333335  0.73333335]\n",
            "   [ 0.4885069   0.4885069   0.4885069 ]]\n",
            "\n",
            "  ...\n",
            "\n",
            "  [[-0.3960784  -0.3960784  -0.3960784 ]\n",
            "   [-0.40776736 -0.40776736 -0.40776736]\n",
            "   [-0.4196939  -0.4196939  -0.4196939 ]\n",
            "   ...\n",
            "   [-0.18003142 -0.18003142 -0.18003142]\n",
            "   [-0.15617824 -0.15617824 -0.15617824]\n",
            "   [-0.13232517 -0.13232517 -0.13232517]]\n",
            "\n",
            "  [[-0.3960784  -0.3960784  -0.3960784 ]\n",
            "   [-0.3960784  -0.3960784  -0.3960784 ]\n",
            "   [-0.3960784  -0.3960784  -0.3960784 ]\n",
            "   ...\n",
            "   [-0.19215685 -0.19215685 -0.19215685]\n",
            "   [-0.19215685 -0.19215685 -0.19215685]\n",
            "   [-0.19215685 -0.19215685 -0.19215685]]\n",
            "\n",
            "  [[-0.3960784  -0.3960784  -0.3960784 ]\n",
            "   [-0.3960784  -0.3960784  -0.3960784 ]\n",
            "   [-0.3960784  -0.3960784  -0.3960784 ]\n",
            "   ...\n",
            "   [-0.19215685 -0.19215685 -0.19215685]\n",
            "   [-0.19215685 -0.19215685 -0.19215685]\n",
            "   [-0.19215685 -0.19215685 -0.19215685]]]\n",
            "\n",
            "\n",
            " ...\n",
            "\n",
            "\n",
            " [[[-0.6784314  -0.6784314  -0.6784314 ]\n",
            "   [-0.6784314  -0.6784314  -0.6784314 ]\n",
            "   [-0.6784314  -0.6784314  -0.6784314 ]\n",
            "   ...\n",
            "   [ 0.28627455  0.28627455  0.28627455]\n",
            "   [ 0.28526294  0.28526294  0.28526294]\n",
            "   [ 0.27578735  0.27578735  0.27578735]]\n",
            "\n",
            "  [[-0.6784314  -0.6784314  -0.6784314 ]\n",
            "   [-0.6784314  -0.6784314  -0.6784314 ]\n",
            "   [-0.6784314  -0.6784314  -0.6784314 ]\n",
            "   ...\n",
            "   [ 0.27143443  0.27143443  0.27143443]\n",
            "   [ 0.26274514  0.26274514  0.26274514]\n",
            "   [ 0.26274514  0.26274514  0.26274514]]\n",
            "\n",
            "  [[-0.6784314  -0.6784314  -0.6784314 ]\n",
            "   [-0.6784314  -0.6784314  -0.6784314 ]\n",
            "   [-0.6784314  -0.6784314  -0.6784314 ]\n",
            "   ...\n",
            "   [ 0.26274514  0.26274514  0.26274514]\n",
            "   [ 0.26274514  0.26274514  0.26274514]\n",
            "   [ 0.26274514  0.26274514  0.26274514]]\n",
            "\n",
            "  ...\n",
            "\n",
            "  [[-0.2862745  -0.2862745  -0.2862745 ]\n",
            "   [-0.2862745  -0.2862745  -0.2862745 ]\n",
            "   [-0.2862745  -0.2862745  -0.2862745 ]\n",
            "   ...\n",
            "   [ 0.11372554  0.11372554  0.11372554]\n",
            "   [ 0.08371699  0.08371699  0.08371699]\n",
            "   [ 0.03529418  0.03529418  0.03529418]]\n",
            "\n",
            "  [[-0.2862745  -0.2862745  -0.2862745 ]\n",
            "   [-0.28746307 -0.28746307 -0.28746307]\n",
            "   [-0.2937801  -0.2937801  -0.2937801 ]\n",
            "   ...\n",
            "   [ 0.11372554  0.11372554  0.11372554]\n",
            "   [ 0.11372554  0.11372554  0.11372554]\n",
            "   [ 0.05036545  0.05036545  0.05036545]]\n",
            "\n",
            "  [[-0.29668206 -0.29668206 -0.29668206]\n",
            "   [-0.30196077 -0.30196077 -0.30196077]\n",
            "   [-0.30196077 -0.30196077 -0.30196077]\n",
            "   ...\n",
            "   [ 0.11372554  0.11372554  0.11372554]\n",
            "   [ 0.11372554  0.11372554  0.11372554]\n",
            "   [ 0.08617294  0.08617294  0.08617294]]]\n",
            "\n",
            "\n",
            " [[[-0.99215686 -0.99215686 -0.99215686]\n",
            "   [-0.99215686 -0.99215686 -0.99215686]\n",
            "   [-0.99215686 -0.99215686 -0.99215686]\n",
            "   ...\n",
            "   [-0.5921569  -0.5921569  -0.5921569 ]\n",
            "   [-0.6826441  -0.6826441  -0.6826441 ]\n",
            "   [-0.8117647  -0.8117647  -0.8117647 ]]\n",
            "\n",
            "  [[-0.99215686 -0.99215686 -0.99215686]\n",
            "   [-0.99215686 -0.99215686 -0.99215686]\n",
            "   [-0.99215686 -0.99215686 -0.99215686]\n",
            "   ...\n",
            "   [-0.5921569  -0.5921569  -0.5921569 ]\n",
            "   [-0.73623836 -0.73623836 -0.73623836]\n",
            "   [-0.8117647  -0.8117647  -0.8117647 ]]\n",
            "\n",
            "  [[-0.99215686 -0.99215686 -0.99215686]\n",
            "   [-0.99215686 -0.99215686 -0.99215686]\n",
            "   [-0.99215686 -0.99215686 -0.99215686]\n",
            "   ...\n",
            "   [-0.5921569  -0.5921569  -0.5921569 ]\n",
            "   [-0.7898326  -0.7898326  -0.7898326 ]\n",
            "   [-0.8117647  -0.8117647  -0.8117647 ]]\n",
            "\n",
            "  ...\n",
            "\n",
            "  [[-0.5529412  -0.5529412  -0.5529412 ]\n",
            "   [-0.5529412  -0.5529412  -0.5529412 ]\n",
            "   [-0.5529412  -0.5529412  -0.5529412 ]\n",
            "   ...\n",
            "   [-0.40392154 -0.40392154 -0.40392154]\n",
            "   [-0.40392154 -0.40392154 -0.40392154]\n",
            "   [-0.40392154 -0.40392154 -0.40392154]]\n",
            "\n",
            "  [[-0.5529412  -0.5529412  -0.5529412 ]\n",
            "   [-0.5529412  -0.5529412  -0.5529412 ]\n",
            "   [-0.5529412  -0.5529412  -0.5529412 ]\n",
            "   ...\n",
            "   [-0.40392154 -0.40392154 -0.40392154]\n",
            "   [-0.40392154 -0.40392154 -0.40392154]\n",
            "   [-0.40392154 -0.40392154 -0.40392154]]\n",
            "\n",
            "  [[-0.5529412  -0.5529412  -0.5529412 ]\n",
            "   [-0.5529412  -0.5529412  -0.5529412 ]\n",
            "   [-0.5529412  -0.5529412  -0.5529412 ]\n",
            "   ...\n",
            "   [-0.40392154 -0.40392154 -0.40392154]\n",
            "   [-0.40392154 -0.40392154 -0.40392154]\n",
            "   [-0.40392154 -0.40392154 -0.40392154]]]\n",
            "\n",
            "\n",
            " [[[-0.83752775 -0.83752775 -0.83752775]\n",
            "   [-0.84615666 -0.84615666 -0.84615666]\n",
            "   [-0.8509804  -0.8509804  -0.8509804 ]\n",
            "   ...\n",
            "   [ 0.3803922   0.3803922   0.3803922 ]\n",
            "   [ 0.3803922   0.3803922   0.3803922 ]\n",
            "   [ 0.3803922   0.3803922   0.3803922 ]]\n",
            "\n",
            "  [[-0.8352941  -0.8352941  -0.8352941 ]\n",
            "   [-0.8352941  -0.8352941  -0.8352941 ]\n",
            "   [-0.8414266  -0.8414266  -0.8414266 ]\n",
            "   ...\n",
            "   [ 0.3803922   0.3803922   0.3803922 ]\n",
            "   [ 0.3803922   0.3803922   0.3803922 ]\n",
            "   [ 0.34721315  0.34721315  0.34721315]]\n",
            "\n",
            "  [[-0.8352941  -0.8352941  -0.8352941 ]\n",
            "   [-0.8352941  -0.8352941  -0.8352941 ]\n",
            "   [-0.8352941  -0.8352941  -0.8352941 ]\n",
            "   ...\n",
            "   [ 0.3803922   0.3803922   0.3803922 ]\n",
            "   [ 0.3803922   0.3803922   0.3803922 ]\n",
            "   [ 0.21993244  0.21993244  0.21993244]]\n",
            "\n",
            "  ...\n",
            "\n",
            "  [[-0.2862745  -0.2862745  -0.2862745 ]\n",
            "   [-0.2862745  -0.2862745  -0.2862745 ]\n",
            "   [-0.2862745  -0.2862745  -0.2862745 ]\n",
            "   ...\n",
            "   [-0.654902   -0.654902   -0.654902  ]\n",
            "   [-0.654902   -0.654902   -0.654902  ]\n",
            "   [-0.654902   -0.654902   -0.654902  ]]\n",
            "\n",
            "  [[-0.2862745  -0.2862745  -0.2862745 ]\n",
            "   [-0.2862745  -0.2862745  -0.2862745 ]\n",
            "   [-0.2862745  -0.2862745  -0.2862745 ]\n",
            "   ...\n",
            "   [-0.654902   -0.654902   -0.654902  ]\n",
            "   [-0.654902   -0.654902   -0.654902  ]\n",
            "   [-0.654902   -0.654902   -0.654902  ]]\n",
            "\n",
            "  [[-0.2862745  -0.2862745  -0.2862745 ]\n",
            "   [-0.2862745  -0.2862745  -0.2862745 ]\n",
            "   [-0.2862745  -0.2862745  -0.2862745 ]\n",
            "   ...\n",
            "   [-0.654902   -0.654902   -0.654902  ]\n",
            "   [-0.654902   -0.654902   -0.654902  ]\n",
            "   [-0.654902   -0.654902   -0.654902  ]]]]\n"
          ]
        }
      ],
      "source": [
        "for _ in range(2):\n",
        "    img, label = train_generator.next()\n",
        "    print(img.shape)   #  (1,256,256,3)\n",
        "    plt.imshow(img[0])\n",
        "    plt.show()\n",
        "    print(img)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mAVA5Rbo9oo9",
        "outputId": "966956b4-e285-41d9-a0cd-961cb4ec3db8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "data batch shape: (16, 260, 260, 3)\n",
            "labels batch shape: (16, 7)\n"
          ]
        }
      ],
      "source": [
        "for data_batch, labels_batch in train_generator:\n",
        "    print('data batch shape:', data_batch.shape)\n",
        "    print('labels batch shape:', labels_batch.shape)\n",
        "    break"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Fine-tuning**"
      ],
      "metadata": {
        "id": "XyFBxQLYIvaj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Load Efficientnetv2-b2 with initializing pre-trained weights and changing last layer**"
      ],
      "metadata": {
        "id": "jYeVWJmCJdI6"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jgeJgkjd9qs0"
      },
      "outputs": [],
      "source": [
        "pre_trained_model = EfficientNetV2B2(include_top = True,\n",
        "                                include_preprocessing=False,\n",
        "                                pooling=None,\n",
        "                                weights = 'imagenet',\n",
        "                                input_tensor=Input(shape=(260, 260, 3)))\n",
        "last_layer = pre_trained_model.get_layer('top_dropout')\n",
        "print('last layer output shape: ', last_layer.output_shape)\n",
        "last_output = last_layer.output\n",
        "x = layers.Dense(7, activation='softmax')(last_output)\n",
        "model = Model(pre_trained_model.input, x)\n",
        "model.summary()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hzr2d12S9t78"
      },
      "outputs": [],
      "source": [
        "model.compile(loss='categorical_crossentropy',\n",
        "              optimizer='adam',    #'keras.optimizers.Adam(learning_rate=0.0001)',\n",
        "              metrics=['accuracy'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ga0i9FbBitCl"
      },
      "outputs": [],
      "source": [
        "class myCallback(tf.keras.callbacks.Callback):\n",
        "  def on_epoch_end(self, epoch, logs={}):\n",
        "    if(logs.get('val_accuracy')>0.98 and logs.get('accuracy')>0.98):\n",
        "      print(\"\\nReached 98% val_accuracy so cancelling training!\")\n",
        "      self.model.stop_training = True\n",
        "    else:\n",
        "      self.model.stop_training = False\n",
        "      print(\" .It's Not good yet!\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KrzNZvB5i0U4"
      },
      "outputs": [],
      "source": [
        "#instantiate myCallback\n",
        "callbacks_instantiate = myCallback()"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Training process**"
      ],
      "metadata": {
        "id": "dORLUHpqKeBN"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lkMnGaaX-D6z",
        "outputId": "99229f72-7aab-4c2b-a81c-2cbd94675039"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 3.2386 - accuracy: 0.3649 .It's Not good yet!\n",
            "42/42 [==============================] - 103s 479ms/step - loss: 3.2386 - accuracy: 0.3649 - val_loss: 1.0402 - val_accuracy: 0.5903\n",
            "Epoch 2/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 2.0634 - accuracy: 0.6171 .It's Not good yet!\n",
            "42/42 [==============================] - 17s 392ms/step - loss: 2.0634 - accuracy: 0.6171 - val_loss: 0.5703 - val_accuracy: 0.7708\n",
            "Epoch 3/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 1.3953 - accuracy: 0.7417 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 385ms/step - loss: 1.3953 - accuracy: 0.7417 - val_loss: 0.3720 - val_accuracy: 0.8611\n",
            "Epoch 4/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 1.1572 - accuracy: 0.8048 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 387ms/step - loss: 1.1572 - accuracy: 0.8048 - val_loss: 0.5573 - val_accuracy: 0.7569\n",
            "Epoch 5/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.8470 - accuracy: 0.8258 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 387ms/step - loss: 0.8470 - accuracy: 0.8258 - val_loss: 0.2656 - val_accuracy: 0.9375\n",
            "Epoch 6/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.8469 - accuracy: 0.8664 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 383ms/step - loss: 0.8469 - accuracy: 0.8664 - val_loss: 0.3182 - val_accuracy: 0.9097\n",
            "Epoch 7/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.7089 - accuracy: 0.8739 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 383ms/step - loss: 0.7089 - accuracy: 0.8739 - val_loss: 0.2788 - val_accuracy: 0.9097\n",
            "Epoch 8/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.6666 - accuracy: 0.8754 .It's Not good yet!\n",
            "42/42 [==============================] - 17s 402ms/step - loss: 0.6666 - accuracy: 0.8754 - val_loss: 0.1458 - val_accuracy: 0.9444\n",
            "Epoch 9/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.5294 - accuracy: 0.9024 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 386ms/step - loss: 0.5294 - accuracy: 0.9024 - val_loss: 0.1530 - val_accuracy: 0.9236\n",
            "Epoch 10/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.5379 - accuracy: 0.9084 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 380ms/step - loss: 0.5379 - accuracy: 0.9084 - val_loss: 0.1201 - val_accuracy: 0.9583\n",
            "Epoch 11/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.5615 - accuracy: 0.9099 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 381ms/step - loss: 0.5615 - accuracy: 0.9099 - val_loss: 0.3018 - val_accuracy: 0.9028\n",
            "Epoch 12/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.4932 - accuracy: 0.9249 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 376ms/step - loss: 0.4932 - accuracy: 0.9249 - val_loss: 0.2620 - val_accuracy: 0.9028\n",
            "Epoch 13/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.3511 - accuracy: 0.9324 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 384ms/step - loss: 0.3511 - accuracy: 0.9324 - val_loss: 0.3543 - val_accuracy: 0.8889\n",
            "Epoch 14/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.3624 - accuracy: 0.9294 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 378ms/step - loss: 0.3624 - accuracy: 0.9294 - val_loss: 0.0885 - val_accuracy: 0.9583\n",
            "Epoch 15/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.2126 - accuracy: 0.9550 .It's Not good yet!\n",
            "42/42 [==============================] - 17s 403ms/step - loss: 0.2126 - accuracy: 0.9550 - val_loss: 0.0951 - val_accuracy: 0.9653\n",
            "Epoch 16/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.1826 - accuracy: 0.9670 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 386ms/step - loss: 0.1826 - accuracy: 0.9670 - val_loss: 0.2292 - val_accuracy: 0.9653\n",
            "Epoch 17/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.3572 - accuracy: 0.9444 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 377ms/step - loss: 0.3572 - accuracy: 0.9444 - val_loss: 0.0957 - val_accuracy: 0.9583\n",
            "Epoch 18/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.3741 - accuracy: 0.9369 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 381ms/step - loss: 0.3741 - accuracy: 0.9369 - val_loss: 0.0213 - val_accuracy: 0.9931\n",
            "Epoch 19/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.2203 - accuracy: 0.9595 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 376ms/step - loss: 0.2203 - accuracy: 0.9595 - val_loss: 0.0351 - val_accuracy: 0.9792\n",
            "Epoch 20/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.2649 - accuracy: 0.9520 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 379ms/step - loss: 0.2649 - accuracy: 0.9520 - val_loss: 0.1156 - val_accuracy: 0.9653\n",
            "Epoch 21/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.3543 - accuracy: 0.9505 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 379ms/step - loss: 0.3543 - accuracy: 0.9505 - val_loss: 0.0444 - val_accuracy: 0.9722\n",
            "Epoch 22/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.2159 - accuracy: 0.9505 .It's Not good yet!\n",
            "42/42 [==============================] - 17s 393ms/step - loss: 0.2159 - accuracy: 0.9505 - val_loss: 0.0994 - val_accuracy: 0.9653\n",
            "Epoch 23/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.3336 - accuracy: 0.9505 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 380ms/step - loss: 0.3336 - accuracy: 0.9505 - val_loss: 0.1049 - val_accuracy: 0.9583\n",
            "Epoch 24/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.3011 - accuracy: 0.9474 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 381ms/step - loss: 0.3011 - accuracy: 0.9474 - val_loss: 0.0637 - val_accuracy: 0.9722\n",
            "Epoch 25/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.2097 - accuracy: 0.9489 .It's Not good yet!\n",
            "42/42 [==============================] - 17s 400ms/step - loss: 0.2097 - accuracy: 0.9489 - val_loss: 0.0280 - val_accuracy: 0.9931\n",
            "Epoch 26/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.2612 - accuracy: 0.9625 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 375ms/step - loss: 0.2612 - accuracy: 0.9625 - val_loss: 0.0917 - val_accuracy: 0.9722\n",
            "Epoch 27/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.4253 - accuracy: 0.9324 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 384ms/step - loss: 0.4253 - accuracy: 0.9324 - val_loss: 0.1302 - val_accuracy: 0.9514\n",
            "Epoch 28/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.2335 - accuracy: 0.9595 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 376ms/step - loss: 0.2335 - accuracy: 0.9595 - val_loss: 0.0912 - val_accuracy: 0.9722\n",
            "Epoch 29/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.1860 - accuracy: 0.9760 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 376ms/step - loss: 0.1860 - accuracy: 0.9760 - val_loss: 0.0745 - val_accuracy: 0.9653\n",
            "Epoch 30/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.2186 - accuracy: 0.9595 .It's Not good yet!\n",
            "42/42 [==============================] - 17s 403ms/step - loss: 0.2186 - accuracy: 0.9595 - val_loss: 0.0647 - val_accuracy: 0.9931\n",
            "Epoch 31/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.2362 - accuracy: 0.9625 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 382ms/step - loss: 0.2362 - accuracy: 0.9625 - val_loss: 0.1402 - val_accuracy: 0.9653\n",
            "Epoch 32/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.1703 - accuracy: 0.9685 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 372ms/step - loss: 0.1703 - accuracy: 0.9685 - val_loss: 0.0542 - val_accuracy: 0.9931\n",
            "Epoch 33/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.2346 - accuracy: 0.9550 .It's Not good yet!\n",
            "42/42 [==============================] - 17s 400ms/step - loss: 0.2346 - accuracy: 0.9550 - val_loss: 0.0641 - val_accuracy: 0.9653\n",
            "Epoch 34/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.1595 - accuracy: 0.9685 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 375ms/step - loss: 0.1595 - accuracy: 0.9685 - val_loss: 0.0192 - val_accuracy: 0.9861\n",
            "Epoch 35/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.2252 - accuracy: 0.9685 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 385ms/step - loss: 0.2252 - accuracy: 0.9685 - val_loss: 0.0488 - val_accuracy: 0.9792\n",
            "Epoch 36/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.1778 - accuracy: 0.9700 .It's Not good yet!\n",
            "42/42 [==============================] - 17s 402ms/step - loss: 0.1778 - accuracy: 0.9700 - val_loss: 0.0837 - val_accuracy: 0.9792\n",
            "Epoch 37/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.2266 - accuracy: 0.9524 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 377ms/step - loss: 0.2266 - accuracy: 0.9524 - val_loss: 0.0734 - val_accuracy: 0.9792\n",
            "Epoch 38/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.3808 - accuracy: 0.9459 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 376ms/step - loss: 0.3808 - accuracy: 0.9459 - val_loss: 0.0693 - val_accuracy: 0.9792\n",
            "Epoch 39/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.1141 - accuracy: 0.9790 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 373ms/step - loss: 0.1141 - accuracy: 0.9790 - val_loss: 0.0679 - val_accuracy: 0.9931\n",
            "Epoch 40/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.1369 - accuracy: 0.9835 .It's Not good yet!\n",
            "42/42 [==============================] - 17s 402ms/step - loss: 0.1369 - accuracy: 0.9835 - val_loss: 0.1573 - val_accuracy: 0.9583\n",
            "Epoch 41/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.1256 - accuracy: 0.9792 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 384ms/step - loss: 0.1256 - accuracy: 0.9792 - val_loss: 0.1131 - val_accuracy: 0.9861\n",
            "Epoch 42/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.1516 - accuracy: 0.9685 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 371ms/step - loss: 0.1516 - accuracy: 0.9685 - val_loss: 0.0571 - val_accuracy: 0.9861\n",
            "Epoch 43/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.2078 - accuracy: 0.9640 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 374ms/step - loss: 0.2078 - accuracy: 0.9640 - val_loss: 0.0392 - val_accuracy: 0.9792\n",
            "Epoch 44/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.3115 - accuracy: 0.9444 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 370ms/step - loss: 0.3115 - accuracy: 0.9444 - val_loss: 0.0398 - val_accuracy: 0.9722\n",
            "Epoch 45/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.2146 - accuracy: 0.9595 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 372ms/step - loss: 0.2146 - accuracy: 0.9595 - val_loss: 0.0661 - val_accuracy: 0.9792\n",
            "Epoch 46/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.1465 - accuracy: 0.9775 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 381ms/step - loss: 0.1465 - accuracy: 0.9775 - val_loss: 0.2015 - val_accuracy: 0.9444\n",
            "Epoch 47/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.2435 - accuracy: 0.9640 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 378ms/step - loss: 0.2435 - accuracy: 0.9640 - val_loss: 0.1696 - val_accuracy: 0.9375\n",
            "Epoch 48/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.1666 - accuracy: 0.9685 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 372ms/step - loss: 0.1666 - accuracy: 0.9685 - val_loss: 0.1374 - val_accuracy: 0.9653\n",
            "Epoch 49/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.1550 - accuracy: 0.9700 .It's Not good yet!\n",
            "42/42 [==============================] - 16s 377ms/step - loss: 0.1550 - accuracy: 0.9700 - val_loss: 0.1005 - val_accuracy: 0.9792\n",
            "Epoch 50/60\n",
            "42/42 [==============================] - ETA: 0s - loss: 0.0823 - accuracy: 0.9880\n",
            "Reached 98% val_accuracy so cancelling training!\n",
            "42/42 [==============================] - 16s 374ms/step - loss: 0.0823 - accuracy: 0.9880 - val_loss: 0.1115 - val_accuracy: 0.9861\n"
          ]
        }
      ],
      "source": [
        "history = model.fit(\n",
        "      train_generator,\n",
        "      steps_per_epoch=42,\n",
        "      epochs=60,\n",
        "      validation_data=validation_generator,\n",
        "      validation_steps=9,\n",
        "      class_weight=class_weight,\n",
        "      callbacks=[callbacks_instantiate])"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Evaluation**"
      ],
      "metadata": {
        "id": "7-gYj9oiKl9c"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 887
        },
        "id": "0ycY2f-IcEpI",
        "outputId": "061c4200-241f-45cc-9033-2dcfbd7ab4da"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "acc = history.history['accuracy']\n",
        "val_acc = history.history['val_accuracy']\n",
        "loss = history.history['loss']\n",
        "val_loss = history.history['val_loss']\n",
        "epochs = range(len(acc))\n",
        "plt.plot(epochs, acc, 'r', label='Training accuracy')\n",
        "plt.plot(epochs, val_acc, 'b', label='Validation accuracy')\n",
        "plt.title('Training and validation accuracy')\n",
        "\n",
        "plt.figure()\n",
        "plt.plot(epochs, loss, 'r', label='Training Loss')\n",
        "plt.plot(epochs, val_loss, 'b', label='Validation Loss')\n",
        "plt.title('Training and validation loss')\n",
        "plt.legend()\n",
        "\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "98FT4iQ1hfU3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7319def3-76e3-4d0f-e5ef-3c80b5ccbafe"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5/5 - 3s - loss: 0.0709 - accuracy: 0.9803 - 3s/epoch - 567ms/step\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0.07085299491882324, 0.9802631735801697]"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ],
      "source": [
        "model.evaluate(test_generator, verbose=2)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model.save('/content/drive/MyDrive/ENV2B2CK+.h5')"
      ],
      "metadata": {
        "id": "W1VOqs8h1cgI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Quantizaion**"
      ],
      "metadata": {
        "id": "TA6q2bsCo-dy"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Quantizaion-aware training (QAT) - Quantization int8 (integer 8) with fine-tuning**"
      ],
      "metadata": {
        "id": "XQ6PqZ8Hqo1Q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model = tf.keras.models.load_model('/content/drive/MyDrive/ENV2B2CK+.h5')"
      ],
      "metadata": {
        "id": "mW58t9ANVTxm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jCmt1HpV-XfU"
      },
      "outputs": [],
      "source": [
        "def apply_quantization_layers(layer):\n",
        "    if 'se_excite' in layer.name:\n",
        "        return layer\n",
        "    return tfmot.quantization.keras.quantize_annotate_layer(layer)\n",
        "\n",
        "annotated_model = tf.keras.models.clone_model(\n",
        "    model,\n",
        "    clone_function=apply_quantization_layers,\n",
        ")\n",
        "\n",
        "quant_aware_model = tfmot.quantization.keras.quantize_apply(annotated_model)\n",
        "quant_aware_model.summary()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "IZSqV_h3gUHk"
      },
      "outputs": [],
      "source": [
        "converter = tf.lite.TFLiteConverter.from_keras_model(quant_aware_model)\n",
        "converter.optimizations = [tf.lite.Optimize.DEFAULT]\n",
        "\n",
        "quantized_tflite_model = converter.convert()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "62DfRM_-9sv6"
      },
      "outputs": [],
      "source": [
        "quant_aware_model.save('/content/drive/MyDrive/ENV2B2quantized.h5')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tM8BSbyyYwth"
      },
      "outputs": [],
      "source": [
        "# Convert model to a quantized model\n",
        "converter = tf.lite.TFLiteConverter.from_keras_model(model)\n",
        "converter.optimizations = [tf.lite.Optimize.DEFAULT]\n",
        "quantized_model = quantized_tflite_model\n",
        "\n",
        "# Load quantized model for fine-tuning\n",
        "with tfmot.quantization.keras.quantize_scope():\n",
        "    modelq = tf.keras.models.load_model('/content/drive/MyDrive/ENV2B2quantized.h5')\n",
        "\n",
        "# Define custom loss function for quantization-aware training\n",
        "def quantization_aware_loss(y_true, y_pred):\n",
        "    # Define loss function here\n",
        "    return tf.keras.losses.sparse_categorical_crossentropy(y_true, y_pred)\n",
        "\n",
        "# Define learning rate schedule for fine-tuning (dynamic learning rate)\n",
        "def lr_schedule(epoch):\n",
        "    lr = 1e-4\n",
        "    if epoch >= 6:\n",
        "        lr *= 0.1\n",
        "    elif epoch >= 7:\n",
        "        lr *= 0.01\n",
        "    return lr\n",
        "\n",
        "# Compile model for quantization-aware fine-tuning\n",
        "modelq.compile(optimizer=tf.keras.optimizers.Adam(lr=1e-4),\n",
        "              loss='categorical_crossentropy',\n",
        "              metrics=['accuracy'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ALiSF6-9pVAi"
      },
      "outputs": [],
      "source": [
        "class StopOnValidationAcc(Callback):\n",
        "    def __init__(self, target_val_acc=0.98):\n",
        "        super(StopOnValidationAcc, self).__init__()\n",
        "        self.target_val_acc = target_val_acc\n",
        "\n",
        "    def on_epoch_end(self, epoch, logs={}):\n",
        "        val_acc = logs.get('val_accuracy')\n",
        "        if val_acc is not None and val_acc >= self.target_val_acc:\n",
        "            print(f'\\nReached {100 * self.target_val_acc}% validation accuracy, stopping training.')\n",
        "            self.model.stop_training = True\n",
        "\n",
        "stop_on_target_val_acc = StopOnValidationAcc(target_val_acc=0.98)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QVoaiQONAEFD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2b017cb4-3246-4891-8f50-f92eec549f8d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/10\n",
            "43/43 [==============================] - 142s 1s/step - loss: 0.6348 - accuracy: 0.8182 - val_loss: 0.4584 - val_accuracy: 0.8435 - lr: 1.0000e-04\n",
            "Epoch 2/10\n",
            "43/43 [==============================] - 45s 1s/step - loss: 0.3836 - accuracy: 0.8651 - val_loss: 0.3480 - val_accuracy: 0.9048 - lr: 1.0000e-04\n",
            "Epoch 3/10\n",
            "43/43 [==============================] - 47s 1s/step - loss: 0.2181 - accuracy: 0.9223 - val_loss: 0.2708 - val_accuracy: 0.9252 - lr: 1.0000e-04\n",
            "Epoch 4/10\n",
            "43/43 [==============================] - 44s 1s/step - loss: 0.1614 - accuracy: 0.9428 - val_loss: 0.2280 - val_accuracy: 0.9456 - lr: 1.0000e-04\n",
            "Epoch 5/10\n",
            "43/43 [==============================] - 45s 1s/step - loss: 0.1593 - accuracy: 0.9472 - val_loss: 0.1694 - val_accuracy: 0.9660 - lr: 1.0000e-04\n",
            "Epoch 6/10\n",
            "43/43 [==============================] - 45s 1s/step - loss: 0.1209 - accuracy: 0.9575 - val_loss: 0.1872 - val_accuracy: 0.9592 - lr: 1.0000e-04\n",
            "Epoch 7/10\n",
            "43/43 [==============================] - 45s 1s/step - loss: 0.1021 - accuracy: 0.9663 - val_loss: 0.1565 - val_accuracy: 0.9660 - lr: 1.0000e-05\n",
            "Epoch 8/10\n",
            "43/43 [==============================] - 47s 1s/step - loss: 0.0774 - accuracy: 0.9736 - val_loss: 0.1412 - val_accuracy: 0.9728 - lr: 1.0000e-05\n",
            "Epoch 9/10\n",
            "43/43 [==============================] - 45s 1s/step - loss: 0.0575 - accuracy: 0.9751 - val_loss: 0.1264 - val_accuracy: 0.9796 - lr: 1.0000e-05\n",
            "Epoch 10/10\n",
            "43/43 [==============================] - 45s 1s/step - loss: 0.0939 - accuracy: 0.9677 - val_loss: 0.1153 - val_accuracy: 0.9796 - lr: 1.0000e-05\n"
          ]
        }
      ],
      "source": [
        "# Fine-tune model with a small learning rate\n",
        "history = modelq.fit(train_generator,\n",
        "                    steps_per_epoch=len(train_generator),\n",
        "                    epochs=10,\n",
        "                    validation_data=validation_generator,\n",
        "                    validation_steps=len(validation_generator),\n",
        "                    callbacks=[LearningRateScheduler(lr_schedule), stop_on_target_val_acc])\n",
        "\n",
        "# # Save quantized model after fine-tuning\n",
        "# modelq.save('/gdrive/MyDrive/quant_aware_modelB0fer.h5')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SiXsDV_f36pE"
      },
      "outputs": [],
      "source": [
        "converter = tf.lite.TFLiteConverter.from_keras_model(modelq)\n",
        "converter.optimizations = [tf.lite.Optimize.DEFAULT]\n",
        "quantized_tflite_model = converter.convert()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3rTf6Qjk36pE"
      },
      "outputs": [],
      "source": [
        "# Save the model to a file\n",
        "with open('/content/drive/MyDrive/ENV2B2QAT.tflite', 'wb') as f:\n",
        "  f.write(quantized_tflite_model)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zhweqvO7U2Yu"
      },
      "source": [
        "## **Post-training quantization (PTQ) - Quantization FP32 (float 32)**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RBFrKDNvXOm5"
      },
      "outputs": [],
      "source": [
        "converter = tf.lite.TFLiteConverter.from_keras_model(model)\n",
        "tflite_model = converter.convert()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5HaywQ4vXiox"
      },
      "outputs": [],
      "source": [
        "with open('/content/drive/MyDrive/ENV2B2PTQ.tflite', 'wb') as f:\n",
        "    f.write(tflite_model)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yHEVekdJVXXY"
      },
      "source": [
        "## **Prepare data**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Kz2nDCNgiTMk",
        "outputId": "d43cf48c-3d8d-4280-c35a-6c024c452e46"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 152 images belonging to 7 classes.\n"
          ]
        }
      ],
      "source": [
        "test_datagen = ImageDataGenerator(preprocessing_function=lambda x: (x / 127.5) - 1.0)\n",
        "test_generator = test_datagen.flow_from_directory(\n",
        "        test_dir,\n",
        "        target_size=(260, 260),\n",
        "        batch_size=1,\n",
        "        shuffle=False,\n",
        "        class_mode='categorical')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DMdVCAnxVcLO"
      },
      "source": [
        "## **Evaluation**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OCdxSGIfbuXS",
        "outputId": "e1c7567e-ca20-4a26-ec62-cd8b72a1c0da"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Simple model size: 106303448 bytes\n",
            "QAT model size: 22072104 bytes\n",
            "PTQ model size: 34731204 bytes\n"
          ]
        }
      ],
      "source": [
        "simple_model = os.path.getsize('/content/drive/MyDrive/ENV2B2CK+.h5')\n",
        "qat = os.path.getsize('/content/drive/MyDrive/ENV2B2QAT.tflite')\n",
        "ptq = os.path.getsize('/content/drive/MyDrive/ENV2B2PTQ.tflite')\n",
        "\n",
        "print(f'Simple model size: {simple_model} bytes')\n",
        "print(f'QAT model size: {qat} bytes')\n",
        "print(f'PTQ model size: {ptq} bytes')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VLHgxe_9jXGl"
      },
      "outputs": [],
      "source": [
        "import time\n",
        "\n",
        "def evaluate_tflite_model(model_path, test_generator, num_images):\n",
        "    interpreter = tf.lite.Interpreter(model_path=model_path)\n",
        "    interpreter.allocate_tensors()\n",
        "    input_details = interpreter.get_input_details()\n",
        "    output_details = interpreter.get_output_details()\n",
        "    correct_count = 0\n",
        "    total_count = 0\n",
        "    total_time = 0.0\n",
        "\n",
        "    for x, y_true in test_generator:\n",
        "        if total_count >= num_images:\n",
        "            break\n",
        "\n",
        "        if x.shape != tuple(input_details[0]['shape']):\n",
        "            x = np.reshape(x, input_details[0]['shape'])\n",
        "        x = x.astype(input_details[0]['dtype'])\n",
        "        interpreter.set_tensor(input_details[0]['index'], x)\n",
        "\n",
        "        # Measure inference time\n",
        "        start_time = time.time()\n",
        "        interpreter.invoke()\n",
        "        end_time = time.time()\n",
        "        total_time += end_time - start_time\n",
        "\n",
        "        y_pred = interpreter.get_tensor(output_details[0]['index'])\n",
        "        y_pred = np.argmax(y_pred, axis=-1)\n",
        "        y_true = np.argmax(y_true, axis=-1)\n",
        "        correct_count += np.sum(y_pred == y_true)\n",
        "        total_count += x.shape[0]\n",
        "\n",
        "    accuracy = correct_count / total_count\n",
        "    avg_inference_time = total_time / total_count\n",
        "    return accuracy, avg_inference_time\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sEua0Lc7a1U_",
        "outputId": "ec98bdff-f828-42c3-ee3d-246edab15751"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(0.9736842105263158, 0.17272629235920153)"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ],
      "source": [
        "evaluate_tflite_model('/content/drive/MyDrive/ENV2B2QAT.tflite', test_generator, 152)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LRApJo6Am-vi",
        "outputId": "d8b3f368-a2a2-446e-c506-4888799be5c2"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(0.9802631578947368, 0.14409283117244118)"
            ]
          },
          "metadata": {},
          "execution_count": 39
        }
      ],
      "source": [
        "evaluate_tflite_model('/content/drive/MyDrive/ENV2B2PTQ.tflite', test_generator, 152)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wthzY6ShLLOA",
        "outputId": "e20d5682-1b47-4dd0-e0b5-67e1d49d8604"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-40-db89e15065ce>:8: UserWarning: `Model.predict_generator` is deprecated and will be removed in a future version. Please use `Model.predict`, which supports generators.\n",
            "  predictions = model.predict_generator(test_generator)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Total inference time: 3.41 seconds\n",
            "Average inference time per image: 0.02246 seconds\n"
          ]
        }
      ],
      "source": [
        "import time\n",
        "import numpy as np\n",
        "\n",
        "start_time = time.time()\n",
        "\n",
        "# Assuming you have a trained model 'model' and a test data generator 'test_generator'\n",
        "# Predict on the test data generator\n",
        "predictions = model.predict_generator(test_generator)\n",
        "\n",
        "end_time = time.time()\n",
        "\n",
        "# Calculate the total inference time\n",
        "inference_time = end_time - start_time\n",
        "\n",
        "# Calculate the average inference time per sample\n",
        "num_samples = len(test_generator)\n",
        "avg_inference_time_per_sample = inference_time / num_samples\n",
        "\n",
        "print(\"Total inference time: {:.2f} seconds\".format(inference_time))\n",
        "print(\"Average inference time per image: {:.5f} seconds\".format(avg_inference_time_per_sample))\n"
      ]
    }
  ]
}