SHAP_GridSearch_CatsVSDogs.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNgplbQ0Y2FiBME/RYr619/",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/OmidGhadami95/EfficientNetV2_CatVSDog/blob/main/SHAP_GridSearch_CatsVSDogs.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "# Here we implemented EfficientNetV2 to address a binary classification task.\n",
        "\n",
        "In the following cells, this model has been implemented:"
      ],
      "metadata": {
        "id": "evD2bIjWuEu2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import osqp\n",
        "import tensorflow\n",
        "from tensorflow.keras import layers\n",
        "from tensorflow.keras import Model\n",
        "from tensorflow.keras.applications import EfficientNetV2B0\n",
        "from keras import Input\n",
        "import matplotlib.pyplot as plt\n",
        "import urllib\n",
        "import zipfile\n",
        "import os,shutil\n",
        "from keras.preprocessing.image import ImageDataGenerator\n",
        "from keras.applications.efficientnet_v2 import preprocess_input\n",
        "from tensorflow import keras\n",
        "import time\n",
        "from sklearn.metrics import confusion_matrix\n",
        "import numpy as np\n",
        "import seaborn as sns\n",
        "!pip install shap\n",
        "import shap\n",
        "!pip install keras scikit-learn\n",
        "import requests\n",
        "from PIL import Image\n",
        "import numpy as np\n",
        "from sklearn.model_selection import ParameterGrid"
      ],
      "metadata": {
        "id": "W8IPQ83usass",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "71e59509-5064-4739-ed5b-0ebfc4038773"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting shap\n",
            "  Downloading shap-0.44.1-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (535 kB)\n",
            "\u001b[?25l     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/535.7 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K     \u001b[91m━━━━━━━━\u001b[0m\u001b[90m╺\u001b[0m\u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m112.6/535.7 kB\u001b[0m \u001b[31m3.2 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K     \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m\u001b[90m━━━━━━\u001b[0m \u001b[32m450.6/535.7 kB\u001b[0m \u001b[31m6.4 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m535.7/535.7 kB\u001b[0m \u001b[31m6.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from shap) (1.25.2)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.10/dist-packages (from shap) (1.11.4)\n",
            "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.10/dist-packages (from shap) (1.2.2)\n",
            "Requirement already satisfied: pandas in /usr/local/lib/python3.10/dist-packages (from shap) (1.5.3)\n",
            "Requirement already satisfied: tqdm>=4.27.0 in /usr/local/lib/python3.10/dist-packages (from shap) (4.66.1)\n",
            "Requirement already satisfied: packaging>20.9 in /usr/local/lib/python3.10/dist-packages (from shap) (23.2)\n",
            "Collecting slicer==0.0.7 (from shap)\n",
            "  Downloading slicer-0.0.7-py3-none-any.whl (14 kB)\n",
            "Requirement already satisfied: numba in /usr/local/lib/python3.10/dist-packages (from shap) (0.58.1)\n",
            "Requirement already satisfied: cloudpickle in /usr/local/lib/python3.10/dist-packages (from shap) (2.2.1)\n",
            "Requirement already satisfied: llvmlite<0.42,>=0.41.0dev0 in /usr/local/lib/python3.10/dist-packages (from numba->shap) (0.41.1)\n",
            "Requirement already satisfied: python-dateutil>=2.8.1 in /usr/local/lib/python3.10/dist-packages (from pandas->shap) (2.8.2)\n",
            "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas->shap) (2023.4)\n",
            "Requirement already satisfied: joblib>=1.1.1 in /usr/local/lib/python3.10/dist-packages (from scikit-learn->shap) (1.3.2)\n",
            "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from scikit-learn->shap) (3.2.0)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.1->pandas->shap) (1.16.0)\n",
            "Installing collected packages: slicer, shap\n",
            "Successfully installed shap-0.44.1 slicer-0.0.7\n",
            "Requirement already satisfied: keras in /usr/local/lib/python3.10/dist-packages (2.15.0)\n",
            "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.10/dist-packages (1.2.2)\n",
            "Requirement already satisfied: numpy>=1.17.3 in /usr/local/lib/python3.10/dist-packages (from scikit-learn) (1.25.2)\n",
            "Requirement already satisfied: scipy>=1.3.2 in /usr/local/lib/python3.10/dist-packages (from scikit-learn) (1.11.4)\n",
            "Requirement already satisfied: joblib>=1.1.1 in /usr/local/lib/python3.10/dist-packages (from scikit-learn) (1.3.2)\n",
            "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from scikit-learn) (3.2.0)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "up5wxggjX5Gv",
        "outputId": "1145abc1-5c77-4126-f41d-400d266a7d09"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /gdrive\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "# drive.mount('/content/drive')\n",
        "drive.mount('/gdrive')"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Download raw catvsdog dataset\n",
        "\n",
        "# url = \"https://storage.googleapis.com/kaggle-data-sets/23777/30378/bundle/archive.zip?X-Goog-Algorithm=GOOG4-RSA-SHA256&X-Goog-Credential=gcp-kaggle-com%40kaggle-161607.iam.gserviceaccount.com%2F20240128%2Fauto%2Fstorage%2Fgoog4_request&X-Goog-Date=20240128T095047Z&X-Goog-Expires=259200&X-Goog-SignedHeaders=host&X-Goog-Signature=426508ddb5f422fa0e2494723cdd48e0382787982b9ac49a8d86118cd137250df85487df87e698d7570f8b393f97ca1db34ca9ec7431d379336a248d8e8f0b8e113c041c94885d018a3c595b179c13dc754c4ca5b9e6c4409d3db3eb464ec089f4c35faaa785f08e663ff444deafd1671a8e47216fbfde4d4ee1c3c1b8f977e81086797bcade0ef9178607856622a5d273bbb425408eadc627420ad26c68bddd6cfb2690ace3a362129e5350d4dd4c618d85b7592c0dee2dc20b13336c8342d1cc7ba0ed93f44b5c19063bb4a461fb5a1569303dd1f96f572a9beba231f54d5aaedc16e400fc31f06db5e2a09f039b19cf2af2ab910d0dea766b942eadaee6e8\"\n",
        "# extract_dir = \"/gdrive/MyDrive/catVSdog\"\n",
        "\n",
        "# zip_path, _ = urllib.request.urlretrieve(url)\n",
        "# with zipfile.ZipFile(zip_path, \"r\") as f:\n",
        "#     f.extractall(extract_dir)"
      ],
      "metadata": {
        "id": "EZ_y7aexX7Vz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Transfer Data to tmp for reducing the inference time:\n",
        "\n",
        "If we use Google Colab, we need to transfer our data to tmp. Otherwise, Our training time will be increased significantly, especially in the first epoch."
      ],
      "metadata": {
        "id": "76qT4YVwsEeU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#path that contains folder you want to copy\n",
        "%cd /gdrive/MyDrive/catVSdog2\n",
        "%cp -av /gdrive/MyDrive/catVSdog2 /tmp/catVSdog"
      ],
      "metadata": {
        "id": "gS8idp70YVJT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "base_dir = '/tmp/catVSdog'\n",
        "train_dir = os.path.join(base_dir, 'train')\n",
        "validation_dir = os.path.join(base_dir, 'validation')\n",
        "test_dir = os.path.join(base_dir, 'test')"
      ],
      "metadata": {
        "id": "4i7dugTDaK3g"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(os.listdir(train_dir))\n",
        "print(os.listdir(validation_dir))\n",
        "print(os.listdir(test_dir))"
      ],
      "metadata": {
        "id": "Y1UtTLnZYtvy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "* Preparing raw data:\n",
        "\n",
        "Our raw data must be prepared since it just includes train and validation. Hence, we need to split our validation into test and validation parts."
      ],
      "metadata": {
        "id": "BEQecET6tK0_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# train_cat_dir = os.path.join(train_dir, 'cat')\n",
        "# os.mkdir(train_cat_dir)\n",
        "# train_dog_dir = os.path.join(train_dir, 'dog')\n",
        "# os.mkdir(train_dog_dir)\n",
        "\n",
        "\n",
        "# validation_cat_dir = os.path.join(validation_dir, 'cat')\n",
        "# os.mkdir(validation_cat_dir)\n",
        "# validation_dog_dir = os.path.join(validation_dir, 'dog')\n",
        "# os.mkdir(validation_dog_dir)\n",
        "\n",
        "\n",
        "# test_cat_dir = os.path.join(test_dir, 'cat')\n",
        "# os.mkdir(test_cat_dir)\n",
        "# test_dog_dir = os.path.join(test_dir, 'dog')\n",
        "# os.mkdir(test_dog_dir)"
      ],
      "metadata": {
        "id": "ScW2950tcECh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# test_cat_dir = r'/gdrive/MyDrive/catVSdog/test_set/test_set/cats'\n",
        "# test_dog_dir = r'/gdrive/MyDrive/catVSdog/test_set/test_set/dogs'\n",
        "\n",
        "# train_cat_dir = r'/gdrive/MyDrive/catVSdog/training_set/training_set/cats'\n",
        "# train_dog_dir = r'/gdrive/MyDrive/catVSdog/training_set/training_set/dogs'"
      ],
      "metadata": {
        "id": "bm5O_NbhimWl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# original_cat_dir_train = r'/gdrive/MyDrive/catVSdog2/train/cat'\n",
        "# original_dog_dir_train = r'/gdrive/MyDrive/catVSdog2/train/dog'\n",
        "\n",
        "# original_cat_dir_val = r'/gdrive/MyDrive/catVSdog2/validation/cat'\n",
        "# original_dog_dir_val = r'/gdrive/MyDrive/catVSdog2/validation/dog'\n",
        "\n",
        "# original_cat_dir_test = r'/gdrive/MyDrive/catVSdog2/test/cat'\n",
        "# original_dog_dir_test = r'/gdrive/MyDrive/catVSdog2/test/dog'"
      ],
      "metadata": {
        "id": "b8AToiwkc56S"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# transfer_train_list = [(original_cat_dir_train,train_cat_dir),\n",
        "#                        (original_dog_dir_train,train_dog_dir)]\n",
        "\n",
        "# for dst,src in transfer_train_list:\n",
        "#   list_val = os.listdir(src)\n",
        "#   list_size = len(list_val)\n",
        "#   for file_name in list_val:\n",
        "#     shutil.copy(src + '/' + file_name , dst+ '/' + file_name)\n",
        "#   print(dst , 'Done!')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k7_JBmS9lZ5y",
        "outputId": "8500ea31-790f-4ae1-94ac-035753733fed"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/gdrive/MyDrive/catVSdog2/train/cat Done!\n",
            "/gdrive/MyDrive/catVSdog2/train/dog Done!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# transfer_list = [(original_cat_dir_val,original_cat_dir_test,test_cat_dir),\n",
        "#                  (original_dog_dir_val,original_dog_dir_test,test_dog_dir)]\n",
        "\n",
        "# for dst1,dst2,src in transfer_list:\n",
        "#   list_val = os.listdir(src)\n",
        "#   list_size = len(list_val)\n",
        "#   for file_name in list_val[:int(0.7*list_size)]:\n",
        "#     shutil.copy(src + '/' + file_name , dst1+ '/' + file_name)\n",
        "#   for file_name in list_val[int(0.7*list_size):]:\n",
        "#     shutil.copy(src + '/' + file_name , dst2+ '/' + file_name)"
      ],
      "metadata": {
        "id": "2G5mpOsMd3ND"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_datagen = ImageDataGenerator(preprocessing_function=lambda x: (x / 127.5) - 1.0,\n",
        "                                   rotation_range = 30,\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",
        "val_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=(224, 224),\n",
        "        batch_size=32,\n",
        "        class_mode='binary')\n",
        "\n",
        "validation_generator = val_datagen.flow_from_directory(\n",
        "        validation_dir,\n",
        "        target_size=(224, 224),\n",
        "        batch_size=32,\n",
        "        class_mode='binary')\n",
        "\n",
        "test_generator = val_datagen.flow_from_directory(\n",
        "        test_dir,\n",
        "        target_size=(224, 224),\n",
        "        batch_size=32,\n",
        "        class_mode='binary')"
      ],
      "metadata": {
        "id": "XptxmuiNk38G",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bc3d1b9d-db29-4008-bf02-24a557b30e4b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 8005 images belonging to 2 classes.\n",
            "Found 1415 images belonging to 2 classes.\n",
            "Found 608 images belonging to 2 classes.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "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"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O7oKY3QLsMOz",
        "outputId": "d378241f-0a06-4f66-e3e2-cc3bf00077a4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "data batch shape: (32, 224, 224, 3)\n",
            "labels batch shape: (32,)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Handling imbalanced dataset:\n",
        "\n",
        "  For handling the imbalanced dataset problem, many approaches have been proposed. The most typical approach is to reduce our sample of classes to the minimum samples. (For instance, if class A has 200 samples and class B has 500 samples, we reduce samples of class B from 500 to 200) However, in this case, we lose a lot of data. The best solution has been proposed in this book: 'Deep Learning for Computer Vision with Python' by 'Adrian Rosebrock'.\n",
        "  These two cells are based on this method. Briefly, we need to consider weights for different classes based on the number of samples in them to avoid training our model based on the class that has the most samples. The more samples a class has, the less weight it must have."
      ],
      "metadata": {
        "id": "8L4e308p18E2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "train_cat_dir = r'/tmp/catVSdog/train/cat'\n",
        "train_dog_dir = r'/tmp/catVSdog/train/dog'"
      ],
      "metadata": {
        "id": "xHXlEwJYyPNp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "l_cat = len([name for name in os.listdir(train_cat_dir) if os.path.isfile(os.path.join(train_cat_dir, name))])\n",
        "l_dog = len([name for name in os.listdir(train_dog_dir) if os.path.isfile(os.path.join(train_dog_dir, name))])\n",
        "\n",
        "label_list = [l_cat,l_dog]\n",
        "total = 0\n",
        "max = 0\n",
        "for each in label_list:\n",
        "  total+=each\n",
        "  if each > max:\n",
        "    max = each\n",
        "\n",
        "weight_cat = float(max/l_cat)\n",
        "weight_dog = float(max/l_dog)"
      ],
      "metadata": {
        "id": "fnfLlBCcseoM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class_weight = {0: weight_cat,\n",
        "                1: weight_dog}"
      ],
      "metadata": {
        "id": "VNUpQ5UnsmKq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Training"
      ],
      "metadata": {
        "id": "tMhJTxbx6m3Z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# class myCallback(tensorflow.keras.callbacks.Callback):\n",
        "#   def on_epoch_end(self, epoch, logs={}):\n",
        "#     if(logs.get('val_accuracy')>0.95 and logs.get('accuracy')>0.95):\n",
        "#       print(\"\\nReached 95% val_accuracy!\")\n",
        "#       self.model.stop_training = True\n",
        "#     else:\n",
        "#       self.model.stop_training = False\n",
        "#       print(\" .It's Not good yet!\")"
      ],
      "metadata": {
        "id": "I4nv-Ix8yqqR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# callbacks_instantiate = myCallback()"
      ],
      "metadata": {
        "id": "gsa_muFzyyC3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model = EfficientNetV2B0(include_top = True,\n",
        "                         include_preprocessing=False,\n",
        "                         classifier_activation='softmax',\n",
        "                         pooling=None,\n",
        "                         weights = 'imagenet',\n",
        "                         input_tensor=Input(shape=(224, 224, 3)))\n",
        "\n",
        "last_layer = model.get_layer('top_dropout')\n",
        "print('last layer output shape: ', last_layer.output_shape)\n",
        "last_output = last_layer.output\n",
        "print(last_output)\n",
        "x = layers.Dense(1, activation='sigmoid')(last_output)\n",
        "model = Model(model.input, x)\n",
        "model.summary()"
      ],
      "metadata": {
        "id": "1TBDcmovy39n"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model = tensorflow.keras.models.load_model('/gdrive/MyDrive/ENV2B0.h5')"
      ],
      "metadata": {
        "id": "BemUfX1P_U7C"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model.compile(loss='binary_crossentropy',\n",
        "              optimizer='adam',\n",
        "              metrics=['accuracy'])"
      ],
      "metadata": {
        "id": "nx75vUuRy-g1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "history = model.fit(\n",
        "      train_generator,\n",
        "      steps_per_epoch=250,\n",
        "      epochs=15,\n",
        "      validation_data=validation_generator,\n",
        "      validation_steps=44,\n",
        "      class_weight=class_weight)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-o_0_QTEzFAo",
        "outputId": "41e06303-07f6-4c63-f8e0-e37b32a96db5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/15\n",
            "250/250 [==============================] - 189s 588ms/step - loss: 0.1555 - accuracy: 0.9394 - val_loss: 0.0856 - val_accuracy: 0.9730\n",
            "Epoch 2/15\n",
            "250/250 [==============================] - 135s 540ms/step - loss: 0.1130 - accuracy: 0.9535 - val_loss: 0.0863 - val_accuracy: 0.9751\n",
            "Epoch 3/15\n",
            "250/250 [==============================] - 131s 523ms/step - loss: 0.1166 - accuracy: 0.9531 - val_loss: 0.0597 - val_accuracy: 0.9808\n",
            "Epoch 4/15\n",
            "250/250 [==============================] - 132s 529ms/step - loss: 0.0869 - accuracy: 0.9658 - val_loss: 0.0658 - val_accuracy: 0.9766\n",
            "Epoch 5/15\n",
            "250/250 [==============================] - 134s 536ms/step - loss: 0.0765 - accuracy: 0.9680 - val_loss: 0.0676 - val_accuracy: 0.9808\n",
            "Epoch 6/15\n",
            "250/250 [==============================] - 133s 532ms/step - loss: 0.0784 - accuracy: 0.9679 - val_loss: 0.1060 - val_accuracy: 0.9759\n",
            "Epoch 7/15\n",
            "250/250 [==============================] - 132s 530ms/step - loss: 0.0783 - accuracy: 0.9693 - val_loss: 0.0669 - val_accuracy: 0.9794\n",
            "Epoch 8/15\n",
            "250/250 [==============================] - 135s 539ms/step - loss: 0.1047 - accuracy: 0.9601 - val_loss: 0.0916 - val_accuracy: 0.9744\n",
            "Epoch 9/15\n",
            "250/250 [==============================] - 135s 539ms/step - loss: 0.0698 - accuracy: 0.9722 - val_loss: 0.0873 - val_accuracy: 0.9773\n",
            "Epoch 10/15\n",
            "250/250 [==============================] - 133s 531ms/step - loss: 0.0704 - accuracy: 0.9722 - val_loss: 0.0589 - val_accuracy: 0.9815\n",
            "Epoch 11/15\n",
            "250/250 [==============================] - 133s 532ms/step - loss: 0.0585 - accuracy: 0.9765 - val_loss: 0.0733 - val_accuracy: 0.9815\n",
            "Epoch 12/15\n",
            "250/250 [==============================] - 135s 542ms/step - loss: 0.0602 - accuracy: 0.9774 - val_loss: 0.0691 - val_accuracy: 0.9773\n",
            "Epoch 13/15\n",
            "250/250 [==============================] - 132s 528ms/step - loss: 0.0563 - accuracy: 0.9773 - val_loss: 0.0650 - val_accuracy: 0.9780\n",
            "Epoch 14/15\n",
            "250/250 [==============================] - 134s 537ms/step - loss: 0.0545 - accuracy: 0.9791 - val_loss: 0.0919 - val_accuracy: 0.9801\n",
            "Epoch 15/15\n",
            "250/250 [==============================] - 134s 534ms/step - loss: 0.0619 - accuracy: 0.9757 - val_loss: 0.0816 - val_accuracy: 0.9780\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model.save('/gdrive/MyDrive/ENV2B0.h5')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FRuhOEHN-nYj",
        "outputId": "11779b25-6ab1-4430-b9f4-ed49a2c53f9f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/keras/src/engine/training.py:3103: UserWarning: You are saving your model as an HDF5 file via `model.save()`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')`.\n",
            "  saving_api.save_model(\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Visualization and analysis for evaluation:"
      ],
      "metadata": {
        "id": "WHx5QPsV7OKq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "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()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 887
        },
        "id": "WaZxcN8SCdh-",
        "outputId": "ff0dae97-37a2-403f-cb6e-2b50b51a5bd3"
      },
      "execution_count": null,
      "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": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "To conclude, the model seems to perform well overall, demonstrating high accuracy, precision, recall, and F1 score. Also, the average inference time is approximately 0.14s per image on Tesla T4 GPU. So, this model can classify 7 images (224,224,3) per second on this GPU."
      ],
      "metadata": {
        "id": "D1qgalAyKMfT"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5cinqU7uChdS",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3bf2a3ea-a645-4f47-91a5-82c2f7af9047"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "19/19 [==============================] - 2s 78ms/step - loss: 0.0625 - accuracy: 0.9770\n",
            "Total inference time: 2.66 seconds\n",
            "Average inference time per image: 0.14018 seconds\n",
            "Accuracy = [0.06248351186513901, 0.9769737124443054]\n"
          ]
        }
      ],
      "source": [
        "start_time = time.time()\n",
        "predictions = model.evaluate(test_generator)\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",
        "print(\"Accuracy =\" , predictions)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "test_generator = val_datagen.flow_from_directory(\n",
        "        test_dir,\n",
        "        target_size=(224, 224),\n",
        "        shuffle=False,\n",
        "        class_mode='binary')"
      ],
      "metadata": {
        "id": "E7AWK-7XLZ2x",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "66bf2a39-7621-4679-8020-a222afb22681"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 608 images belonging to 2 classes.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Confusion matrix demonstrates that our model is not biased on the cat label or dog label. It can be the effectiveness of balancing our dataset. However, In this dataset, the samples of each classes are equal."
      ],
      "metadata": {
        "id": "P7SkuWljKQIc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import confusion_matrix\n",
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "predictions = model.predict(test_generator, verbose=1)\n",
        "\n",
        "predicted_labels = np.round(predictions)\n",
        "\n",
        "true_labels = test_generator.classes\n",
        "\n",
        "cm = confusion_matrix(true_labels, predicted_labels)\n",
        "\n",
        "precision = cm[1, 1] / (cm[0, 1] + cm[1, 1])\n",
        "recall = cm[1, 1] / (cm[1, 0] + cm[1, 1])\n",
        "f1_score = 2 * (precision * recall) / (precision + recall)\n",
        "\n",
        "print(\"Precision:\", precision)\n",
        "print(\"Recall:\", recall)\n",
        "print(\"F1 Score:\", f1_score)\n",
        "\n",
        "plt.figure(figsize=(6, 6))\n",
        "sns.set(font_scale=1.4)\n",
        "sns.heatmap(cm, annot=True, fmt='d', cmap=\"Blues\", cbar=False, square=True,\n",
        "            xticklabels=[\"Cat\", \"Dog\"],\n",
        "            yticklabels=[\"Cat\", \"Dog\"])\n",
        "plt.xlabel(\"Predicted Labels\")\n",
        "plt.ylabel(\"True Labels\")\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 629
        },
        "id": "oPzbmMxKMIat",
        "outputId": "667efaf8-5d97-42b9-9bde-b7b765bf6acd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "19/19 [==============================] - 2s 78ms/step\n",
            "Precision: 0.9769736842105263\n",
            "Recall: 0.9769736842105263\n",
            "F1 Score: 0.9769736842105263\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 600x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# SHAP (SHapley Additive exPlanations) is a method utilized in explainable artificial intelligence to find out the effectiveness of every feature to the predictions of a machine learning model. One use case in which SHAP can effectively boost model transparency and accountability in image data is in medical images. For instance, for detecting lung tumors from chest X-ray images using a deep learning method, the model performs well in terms of accuracy, but there is a need to understand which regions of the image are more effective in our model's decision. By applying the SHAP method to our model, we can find the specific pixels (features) of the X-ray images that have the most impact on the model's predictions. This information can help medical professionals understand how the model is making its decisions and provide transparency into its reasoning process. It can also aid in identifying potential biases that the model might be relying on. Thus, the SHAP method can improve the accountability of the model significantly by allowing experts to validate the model's predictions. In this case, SHAP can build trust in the model's performance and ensure patient safety.\n",
        "\n",
        "In this dataset (CatVSDog), SHAP can prove to us that our model's detection is not based on non-important features, such as background. Consequently, if we use our model on different datasets with different backgrounds, our accuracy won't decrease.\n"
      ],
      "metadata": {
        "id": "jA-GDBySFvce"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x_train, y_train = train_generator.next()\n",
        "x_test, y_test = test_generator.next()\n",
        "x_val, y_val = validation_generator.next()"
      ],
      "metadata": {
        "id": "L4RN3_QbRACn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "new_list = ['cat' if val == 1 else 'dog' for val in y_val]"
      ],
      "metadata": {
        "id": "sPOjgKXyRACn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def f(X):\n",
        "    tmp = X.copy()\n",
        "    return model(tmp)\n",
        "\n",
        "image_path = \"/gdrive/MyDrive/catVSdog2/test/cat/cat.4699.jpg\"\n",
        "image = Image.open(image_path).resize((224, 224))\n",
        "img = np.expand_dims(image, axis=0)\n",
        "#img = (img / 127.5) - 1.0\n",
        "\n",
        "masker = shap.maskers.Image(\"inpaint_telea\", x_val[0].shape)\n",
        "\n",
        "explainer = shap.Explainer(f, masker, output_names=new_list)\n",
        "\n",
        "shap_values = explainer(\n",
        "    img, max_evals=1000, batch_size=50, outputs=shap.Explanation.argsort.flip[:1]\n",
        ")\n",
        "\n",
        "shap.image_plot(shap_values)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 404,
          "referenced_widgets": [
            "5c2cc61099c2454a98f8ea0b76239fdd",
            "881af615bca741f3a38c392d718ada09",
            "93f6a1942e2a43048641d4b34b5f8c97",
            "11714b9e4d4d4b60b2cb60b93404f3ac",
            "accefa44c04f4f268952401f77dc0bc7",
            "0c53ed8c5f724b529bb4db95fe8bd6c9",
            "1c129c03492f4c619a4af2c519c1b126",
            "afd07dfc3b964060978ac2d103a67ad5",
            "21c426c29713425f971719e5286c5a3f",
            "986aa15722ab4f7db727b53e534fa71f",
            "24f5555507e24644a663782d176c3517"
          ]
        },
        "id": "gSeMQDxtT7Xk",
        "outputId": "a5e79583-ea07-4e9b-e0dd-fa3063260004"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/998 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "5c2cc61099c2454a98f8ea0b76239fdd"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "PartitionExplainer explainer: 2it [03:57, 237.93s/it]              \n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 600x500 with 3 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "Baq6b695TxPZ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Grid Search for Hyperparameter tuning:\n",
        "\n",
        "In terms of accuracy: For hyperparameter tuning, we can use different methods, such as Grid Search, Random Search, Biyasian Optimization, etc. Here we utilized the Grid Search method.\n",
        "\n",
        "\n",
        "In terms of speed:\n",
        "\n",
        "1) Training time: Obviously, the higher batch size or epochs we have, the less training time becomes. Also, the lower the learning rate we have, the less training time becomes and our model will converge slower but it can achieve better accuracy.\n",
        "\n",
        "2) Inference time: None of these three hyperparameters are effective on inference time. To reduce the inference time, we can scale down the resolution, depth of our model, or filter size. Also, pruning and Quantization are practical to reduce the inference time. Most of these methods are effective in reducing inference time and training time.\n"
      ],
      "metadata": {
        "id": "d5IIB-kUJ8YE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "hyperparameter_grid = {\n",
        "    'learning_rate': [0.001, 0.01, 0.1],\n",
        "    'batch_size': [16, 32, 64],\n",
        "    'epochs': [10, 20, 30]\n",
        "}\n",
        "\n",
        "\n",
        "parameter_grid = list(ParameterGrid(hyperparameter_grid))\n",
        "\n",
        "best_accuracy = 0.0\n",
        "best_parameters = {}\n",
        "\n",
        "\n",
        "for params in parameter_grid:\n",
        "    learning_rate = params['learning_rate']\n",
        "    batch_size = params['batch_size']\n",
        "    epochs = params['epochs']\n",
        "\n",
        "    print(f\"Current Hyperparameters: Learning Rate={learning_rate}, Batch Size={batch_size}, Epochs={epochs}\")\n",
        "\n",
        "    model.compile(optimizer=keras.optimizers.Adam(learning_rate=learning_rate),\n",
        "                  loss='categorical_crossentropy',\n",
        "                  metrics=['accuracy'])\n",
        "\n",
        "    model.fit(train_generator,\n",
        "              epochs=epochs,\n",
        "              batch_size=batch_size)\n",
        "\n",
        "\n",
        "    _, accuracy = model.evaluate(validation_generator)\n",
        "\n",
        "    if accuracy > best_accuracy:\n",
        "        best_accuracy = accuracy\n",
        "        best_parameters = params\n",
        "\n",
        "print(f\"\\nBest Hyperparameters: Learning Rate={best_parameters['learning_rate']}, \"\n",
        "      f\"Batch Size={best_parameters['batch_size']}, \"\n",
        "      f\"Epochs={best_parameters['epochs']}\")\n",
        "print(f\"Best Accuracy: {best_accuracy}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YKCpiVXbkwM0",
        "outputId": "bd4b5ae1-c9fd-46b4-896a-d49ec63bf7da"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Current Hyperparameters: Learning Rate=0.001, Batch Size=16, Epochs=10\n",
            "Epoch 1/10\n",
            "86/86 [==============================] - 61s 159ms/step - loss: 0.2531 - accuracy: 0.9185\n",
            "Epoch 2/10\n",
            "86/86 [==============================] - 16s 180ms/step - loss: 0.1376 - accuracy: 0.9549\n",
            "Epoch 3/10\n",
            "86/86 [==============================] - 14s 160ms/step - loss: 0.2278 - accuracy: 0.9214\n",
            "Epoch 4/10\n",
            "86/86 [==============================] - 18s 213ms/step - loss: 0.1588 - accuracy: 0.9447\n",
            "Epoch 5/10\n",
            "86/86 [==============================] - 14s 162ms/step - loss: 0.1724 - accuracy: 0.9345\n",
            "Epoch 6/10\n",
            "86/86 [==============================] - 14s 162ms/step - loss: 0.1977 - accuracy: 0.9330\n",
            "Epoch 7/10\n",
            "86/86 [==============================] - 14s 163ms/step - loss: 0.1204 - accuracy: 0.9607\n",
            "Epoch 8/10\n",
            "86/86 [==============================] - 17s 199ms/step - loss: 0.1423 - accuracy: 0.9592\n",
            "Epoch 9/10\n",
            "86/86 [==============================] - 14s 164ms/step - loss: 0.1182 - accuracy: 0.9622\n",
            "Epoch 10/10\n",
            "86/86 [==============================] - 15s 169ms/step - loss: 0.1043 - accuracy: 0.9665\n",
            "19/19 [==============================] - 4s 110ms/step - loss: 0.0677 - accuracy: 0.9728\n",
            "Current Hyperparameters: Learning Rate=0.01, Batch Size=16, Epochs=10\n",
            "Epoch 1/10\n",
            "86/86 [==============================] - 54s 181ms/step - loss: 2.1808 - accuracy: 0.2751\n",
            "Epoch 2/10\n",
            "86/86 [==============================] - 16s 180ms/step - loss: 1.9437 - accuracy: 0.2780\n",
            "Epoch 3/10\n",
            "86/86 [==============================] - 16s 182ms/step - loss: 1.8409 - accuracy: 0.3071\n",
            "Epoch 4/10\n",
            "86/86 [==============================] - 14s 161ms/step - loss: 1.7637 - accuracy: 0.3435\n",
            "Epoch 5/10\n",
            "86/86 [==============================] - 15s 171ms/step - loss: 1.6532 - accuracy: 0.3755\n",
            "Epoch 6/10\n",
            "86/86 [==============================] - 14s 161ms/step - loss: 1.5999 - accuracy: 0.4090\n",
            "Epoch 7/10\n",
            "86/86 [==============================] - 15s 178ms/step - loss: 1.4659 - accuracy: 0.4789\n",
            "Epoch 8/10\n",
            "86/86 [==============================] - 14s 159ms/step - loss: 1.3905 - accuracy: 0.4993\n",
            "Epoch 9/10\n",
            "86/86 [==============================] - 14s 163ms/step - loss: 1.3789 - accuracy: 0.4847\n",
            "Epoch 10/10\n",
            "86/86 [==============================] - 16s 181ms/step - loss: 1.3256 - accuracy: 0.5357\n",
            "19/19 [==============================] - 2s 51ms/step - loss: 0.8500 - accuracy: 0.7007\n",
            "Current Hyperparameters: Learning Rate=0.1, Batch Size=16, Epochs=10\n",
            "Epoch 1/10\n",
            "86/86 [==============================] - 53s 175ms/step - loss: 5.1293 - accuracy: 0.1921\n",
            "Epoch 2/10\n",
            "86/86 [==============================] - 14s 163ms/step - loss: 2.8159 - accuracy: 0.1776\n",
            "Epoch 3/10\n",
            "86/86 [==============================] - 15s 175ms/step - loss: 2.2307 - accuracy: 0.2023\n",
            "Epoch 4/10\n",
            "86/86 [==============================] - 14s 161ms/step - loss: 2.2547 - accuracy: 0.2242\n",
            "Epoch 5/10\n",
            "86/86 [==============================] - 16s 182ms/step - loss: 2.1783 - accuracy: 0.1761\n",
            "Epoch 6/10\n",
            "86/86 [==============================] - 14s 166ms/step - loss: 2.0652 - accuracy: 0.2023\n",
            "Epoch 7/10\n",
            "86/86 [==============================] - 16s 181ms/step - loss: 2.0970 - accuracy: 0.2344\n",
            "Epoch 8/10\n",
            "86/86 [==============================] - 14s 160ms/step - loss: 2.0864 - accuracy: 0.2198\n",
            "Epoch 9/10\n",
            "86/86 [==============================] - 15s 178ms/step - loss: 2.0801 - accuracy: 0.2183\n",
            "Epoch 10/10\n",
            "86/86 [==============================] - 14s 158ms/step - loss: 2.0029 - accuracy: 0.2373\n",
            "19/19 [==============================] - 2s 34ms/step - loss: 1.9150 - accuracy: 0.2721\n",
            "Current Hyperparameters: Learning Rate=0.001, Batch Size=16, Epochs=20\n",
            "Epoch 1/20\n",
            "86/86 [==============================] - 54s 183ms/step - loss: 1.8720 - accuracy: 0.2737\n",
            "Epoch 2/20\n",
            "86/86 [==============================] - 15s 179ms/step - loss: 1.8085 - accuracy: 0.3013\n",
            "Epoch 3/20\n",
            "86/86 [==============================] - 14s 157ms/step - loss: 1.7942 - accuracy: 0.2795\n",
            "Epoch 4/20\n",
            "86/86 [==============================] - 14s 159ms/step - loss: 1.7753 - accuracy: 0.2911\n",
            "Epoch 5/20\n",
            "86/86 [==============================] - 15s 178ms/step - loss: 1.7501 - accuracy: 0.2853\n",
            "Epoch 6/20\n",
            "86/86 [==============================] - 13s 156ms/step - loss: 1.7487 - accuracy: 0.2984\n",
            "Epoch 7/20\n",
            "86/86 [==============================] - 16s 189ms/step - loss: 1.7306 - accuracy: 0.2955\n",
            "Epoch 8/20\n",
            "86/86 [==============================] - 14s 158ms/step - loss: 1.7207 - accuracy: 0.3100\n",
            "Epoch 9/20\n",
            "86/86 [==============================] - 16s 182ms/step - loss: 1.7341 - accuracy: 0.2911\n",
            "Epoch 10/20\n",
            "86/86 [==============================] - 14s 161ms/step - loss: 1.7214 - accuracy: 0.3188\n",
            "Epoch 11/20\n",
            "86/86 [==============================] - 14s 161ms/step - loss: 1.7235 - accuracy: 0.3144\n",
            "Epoch 12/20\n",
            "86/86 [==============================] - 16s 180ms/step - loss: 1.7155 - accuracy: 0.3115\n",
            "Epoch 13/20\n",
            "86/86 [==============================] - 15s 171ms/step - loss: 1.7272 - accuracy: 0.3028\n",
            "Epoch 14/20\n",
            "86/86 [==============================] - 14s 164ms/step - loss: 1.7175 - accuracy: 0.3202\n",
            "Epoch 15/20\n",
            "86/86 [==============================] - 14s 159ms/step - loss: 1.7036 - accuracy: 0.3290\n",
            "Epoch 16/20\n",
            "86/86 [==============================] - 15s 180ms/step - loss: 1.6862 - accuracy: 0.3319\n",
            "Epoch 17/20\n",
            "86/86 [==============================] - 14s 159ms/step - loss: 1.6788 - accuracy: 0.3202\n",
            "Epoch 18/20\n",
            "86/86 [==============================] - 16s 182ms/step - loss: 1.6543 - accuracy: 0.3523\n",
            "Epoch 19/20\n",
            "86/86 [==============================] - 14s 157ms/step - loss: 1.6544 - accuracy: 0.3872\n",
            "Epoch 20/20\n",
            "86/86 [==============================] - 14s 158ms/step - loss: 1.6567 - accuracy: 0.3537\n",
            "19/19 [==============================] - 2s 33ms/step - loss: 1.5836 - accuracy: 0.4082\n",
            "Current Hyperparameters: Learning Rate=0.01, Batch Size=16, Epochs=20\n",
            "Epoch 1/20\n",
            "86/86 [==============================] - 50s 154ms/step - loss: 1.7333 - accuracy: 0.3290\n",
            "Epoch 2/20\n",
            "86/86 [==============================] - 16s 181ms/step - loss: 1.7057 - accuracy: 0.3493\n",
            "Epoch 3/20\n",
            "86/86 [==============================] - 16s 190ms/step - loss: 1.6879 - accuracy: 0.3406\n",
            "Epoch 4/20\n",
            "86/86 [==============================] - 16s 184ms/step - loss: 1.6667 - accuracy: 0.3275\n",
            "Epoch 5/20\n",
            "86/86 [==============================] - 14s 162ms/step - loss: 1.6158 - accuracy: 0.3828\n",
            "Epoch 6/20\n",
            "86/86 [==============================] - 14s 163ms/step - loss: 1.6650 - accuracy: 0.3654\n",
            "Epoch 7/20\n",
            "86/86 [==============================] - 15s 166ms/step - loss: 1.5808 - accuracy: 0.3726\n",
            "Epoch 8/20\n",
            "86/86 [==============================] - 16s 185ms/step - loss: 1.6279 - accuracy: 0.3610\n",
            "Epoch 9/20\n",
            "86/86 [==============================] - 14s 159ms/step - loss: 1.5669 - accuracy: 0.4178\n",
            "Epoch 10/20\n",
            "86/86 [==============================] - 15s 177ms/step - loss: 1.4997 - accuracy: 0.4134\n",
            "Epoch 11/20\n",
            "86/86 [==============================] - 15s 176ms/step - loss: 1.5204 - accuracy: 0.4265\n",
            "Epoch 12/20\n",
            "86/86 [==============================] - 16s 184ms/step - loss: 1.5151 - accuracy: 0.4236\n",
            "Epoch 13/20\n",
            "86/86 [==============================] - 14s 159ms/step - loss: 1.4566 - accuracy: 0.4658\n",
            "Epoch 14/20\n",
            "86/86 [==============================] - 14s 159ms/step - loss: 1.4165 - accuracy: 0.4789\n",
            "Epoch 15/20\n",
            "86/86 [==============================] - 19s 217ms/step - loss: 1.4655 - accuracy: 0.4367\n",
            "Epoch 16/20\n",
            "86/86 [==============================] - 14s 160ms/step - loss: 1.4139 - accuracy: 0.4600\n",
            "Epoch 17/20\n",
            "86/86 [==============================] - 16s 185ms/step - loss: 1.4147 - accuracy: 0.4891\n",
            "Epoch 18/20\n",
            "86/86 [==============================] - 14s 160ms/step - loss: 1.3640 - accuracy: 0.4934\n",
            "Epoch 19/20\n",
            "86/86 [==============================] - 16s 186ms/step - loss: 1.3322 - accuracy: 0.5036\n",
            "Epoch 20/20\n",
            "86/86 [==============================] - 14s 159ms/step - loss: 1.3059 - accuracy: 0.5167\n",
            "19/19 [==============================] - 2s 35ms/step - loss: 1.1650 - accuracy: 0.5578\n",
            "Current Hyperparameters: Learning Rate=0.1, Batch Size=16, Epochs=20\n",
            "Epoch 1/20\n",
            "86/86 [==============================] - 54s 170ms/step - loss: 2.4903 - accuracy: 0.2227\n",
            "Epoch 2/20\n",
            "86/86 [==============================] - 14s 160ms/step - loss: 2.2112 - accuracy: 0.2300\n",
            "Epoch 3/20\n",
            "86/86 [==============================] - 16s 187ms/step - loss: 2.1185 - accuracy: 0.1820\n",
            "Epoch 4/20\n",
            "86/86 [==============================] - 16s 185ms/step - loss: 2.1580 - accuracy: 0.1994\n",
            "Epoch 5/20\n",
            "86/86 [==============================] - 17s 194ms/step - loss: 2.0407 - accuracy: 0.2140\n",
            "Epoch 6/20\n",
            "86/86 [==============================] - 14s 159ms/step - loss: 1.9870 - accuracy: 0.2082\n",
            "Epoch 7/20\n",
            "86/86 [==============================] - 16s 185ms/step - loss: 2.0966 - accuracy: 0.1980\n",
            "Epoch 8/20\n",
            "86/86 [==============================] - 14s 159ms/step - loss: 2.0664 - accuracy: 0.2402\n",
            "Epoch 9/20\n",
            "86/86 [==============================] - 14s 164ms/step - loss: 2.0283 - accuracy: 0.2373\n",
            "Epoch 10/20\n",
            "86/86 [==============================] - 15s 177ms/step - loss: 1.9681 - accuracy: 0.2227\n",
            "Epoch 11/20\n",
            "86/86 [==============================] - 14s 161ms/step - loss: 1.9509 - accuracy: 0.2314\n",
            "Epoch 12/20\n",
            "86/86 [==============================] - 17s 201ms/step - loss: 1.9276 - accuracy: 0.2154\n",
            "Epoch 13/20\n",
            "86/86 [==============================] - 14s 159ms/step - loss: 1.8843 - accuracy: 0.2431\n",
            "Epoch 14/20\n",
            "86/86 [==============================] - 16s 188ms/step - loss: 1.9518 - accuracy: 0.2285\n",
            "Epoch 15/20\n",
            "86/86 [==============================] - 14s 158ms/step - loss: 1.9318 - accuracy: 0.2227\n",
            "Epoch 16/20\n",
            "86/86 [==============================] - 16s 185ms/step - loss: 1.9387 - accuracy: 0.2096\n",
            "Epoch 17/20\n",
            "86/86 [==============================] - 15s 174ms/step - loss: 1.8717 - accuracy: 0.2271\n",
            "Epoch 18/20\n",
            "86/86 [==============================] - 14s 158ms/step - loss: 1.8384 - accuracy: 0.2562\n",
            "Epoch 19/20\n",
            "86/86 [==============================] - 14s 161ms/step - loss: 1.8717 - accuracy: 0.2300\n",
            "Epoch 20/20\n",
            "86/86 [==============================] - 14s 160ms/step - loss: 1.9069 - accuracy: 0.2111\n",
            "19/19 [==============================] - 3s 52ms/step - loss: 1.9693 - accuracy: 0.2585\n",
            "Current Hyperparameters: Learning Rate=0.001, Batch Size=16, Epochs=30\n",
            "Epoch 1/30\n",
            "86/86 [==============================] - 51s 160ms/step - loss: 1.8513 - accuracy: 0.2344\n",
            "Epoch 2/30\n",
            "86/86 [==============================] - 14s 165ms/step - loss: 1.7921 - accuracy: 0.2649\n",
            "Epoch 3/30\n",
            "86/86 [==============================] - 16s 181ms/step - loss: 1.7664 - accuracy: 0.2576\n",
            "Epoch 4/30\n",
            "86/86 [==============================] - 15s 173ms/step - loss: 1.7649 - accuracy: 0.2504\n",
            "Epoch 5/30\n",
            "86/86 [==============================] - 14s 157ms/step - loss: 1.7289 - accuracy: 0.2809\n",
            "Epoch 6/30\n",
            "86/86 [==============================] - 17s 194ms/step - loss: 1.7338 - accuracy: 0.2795\n",
            "Epoch 7/30\n",
            "86/86 [==============================] - 14s 162ms/step - loss: 1.7481 - accuracy: 0.2693\n",
            "Epoch 8/30\n",
            "86/86 [==============================] - 14s 158ms/step - loss: 1.7319 - accuracy: 0.2926\n",
            "Epoch 9/30\n",
            "86/86 [==============================] - 16s 185ms/step - loss: 1.7128 - accuracy: 0.2940\n",
            "Epoch 10/30\n",
            "86/86 [==============================] - 14s 159ms/step - loss: 1.7267 - accuracy: 0.2707\n",
            "Epoch 11/30\n",
            "86/86 [==============================] - 14s 158ms/step - loss: 1.7193 - accuracy: 0.2969\n",
            "Epoch 12/30\n",
            "86/86 [==============================] - 14s 158ms/step - loss: 1.7327 - accuracy: 0.2809\n",
            "Epoch 13/30\n",
            "86/86 [==============================] - 16s 185ms/step - loss: 1.7094 - accuracy: 0.2969\n",
            "Epoch 14/30\n",
            "86/86 [==============================] - 14s 158ms/step - loss: 1.7310 - accuracy: 0.2897\n",
            "Epoch 15/30\n",
            "86/86 [==============================] - 17s 202ms/step - loss: 1.7257 - accuracy: 0.2868\n",
            "Epoch 16/30\n",
            "86/86 [==============================] - 14s 159ms/step - loss: 1.7169 - accuracy: 0.3100\n",
            "Epoch 17/30\n",
            "86/86 [==============================] - 16s 189ms/step - loss: 1.6969 - accuracy: 0.3042\n",
            "Epoch 18/30\n",
            "86/86 [==============================] - 15s 175ms/step - loss: 1.7147 - accuracy: 0.2868\n",
            "Epoch 19/30\n",
            "86/86 [==============================] - 15s 171ms/step - loss: 1.7235 - accuracy: 0.2882\n",
            "Epoch 20/30\n",
            "86/86 [==============================] - 15s 176ms/step - loss: 1.7279 - accuracy: 0.2926\n",
            "Epoch 21/30\n",
            "86/86 [==============================] - 14s 159ms/step - loss: 1.6938 - accuracy: 0.2911\n",
            "Epoch 22/30\n",
            "86/86 [==============================] - 17s 199ms/step - loss: 1.7057 - accuracy: 0.3042\n",
            "Epoch 23/30\n",
            "86/86 [==============================] - 14s 166ms/step - loss: 1.7239 - accuracy: 0.2780\n",
            "Epoch 24/30\n",
            "86/86 [==============================] - 16s 190ms/step - loss: 1.7149 - accuracy: 0.3028\n",
            "Epoch 25/30\n",
            "86/86 [==============================] - 14s 158ms/step - loss: 1.7087 - accuracy: 0.2882\n",
            "Epoch 26/30\n",
            "86/86 [==============================] - 16s 190ms/step - loss: 1.7162 - accuracy: 0.2969\n",
            "Epoch 27/30\n",
            "86/86 [==============================] - 14s 158ms/step - loss: 1.6948 - accuracy: 0.3028\n",
            "Epoch 28/30\n",
            "86/86 [==============================] - 14s 158ms/step - loss: 1.7164 - accuracy: 0.3100\n",
            "Epoch 29/30\n",
            "86/86 [==============================] - 16s 189ms/step - loss: 1.7077 - accuracy: 0.2999\n",
            "Epoch 30/30\n",
            "86/86 [==============================] - 14s 157ms/step - loss: 1.6929 - accuracy: 0.3130\n",
            "19/19 [==============================] - 3s 33ms/step - loss: 1.6839 - accuracy: 0.3265\n",
            "Current Hyperparameters: Learning Rate=0.01, Batch Size=16, Epochs=30\n",
            "Epoch 1/30\n",
            "86/86 [==============================] - 52s 157ms/step - loss: 1.7435 - accuracy: 0.2795\n",
            "Epoch 2/30\n",
            "86/86 [==============================] - 17s 197ms/step - loss: 1.7085 - accuracy: 0.2766\n",
            "Epoch 3/30\n",
            "86/86 [==============================] - 14s 159ms/step - loss: 1.7136 - accuracy: 0.2911\n",
            "Epoch 4/30\n",
            "86/86 [==============================] - 16s 190ms/step - loss: 1.6917 - accuracy: 0.2795\n",
            "Epoch 5/30\n",
            "86/86 [==============================] - 14s 162ms/step - loss: 1.7226 - accuracy: 0.2868\n",
            "Epoch 6/30\n",
            "86/86 [==============================] - 14s 162ms/step - loss: 1.6900 - accuracy: 0.2926\n",
            "Epoch 7/30\n",
            "86/86 [==============================] - 18s 205ms/step - loss: 1.6853 - accuracy: 0.3057\n",
            "Epoch 8/30\n",
            "86/86 [==============================] - 14s 162ms/step - loss: 1.7033 - accuracy: 0.2780\n",
            "Epoch 9/30\n",
            "86/86 [==============================] - 17s 193ms/step - loss: 1.6861 - accuracy: 0.3159\n",
            "Epoch 10/30\n",
            "86/86 [==============================] - 15s 175ms/step - loss: 1.7005 - accuracy: 0.2955\n",
            "Epoch 11/30\n",
            "86/86 [==============================] - 17s 192ms/step - loss: 1.6961 - accuracy: 0.3057\n",
            "Epoch 12/30\n",
            "86/86 [==============================] - 14s 161ms/step - loss: 1.7067 - accuracy: 0.3013\n",
            "Epoch 13/30\n",
            "86/86 [==============================] - 17s 196ms/step - loss: 1.6795 - accuracy: 0.3028\n",
            "Epoch 14/30\n",
            "86/86 [==============================] - 14s 158ms/step - loss: 1.6994 - accuracy: 0.3421\n",
            "Epoch 15/30\n",
            "86/86 [==============================] - 17s 200ms/step - loss: 1.6686 - accuracy: 0.3304\n",
            "Epoch 16/30\n",
            "86/86 [==============================] - 14s 161ms/step - loss: 1.6736 - accuracy: 0.2868\n",
            "Epoch 17/30\n",
            "86/86 [==============================] - 15s 178ms/step - loss: 1.6654 - accuracy: 0.3217\n",
            "Epoch 18/30\n",
            "86/86 [==============================] - 15s 168ms/step - loss: 1.6659 - accuracy: 0.3231\n",
            "Epoch 19/30\n",
            "86/86 [==============================] - 14s 157ms/step - loss: 1.6963 - accuracy: 0.3028\n",
            "Epoch 20/30\n",
            "86/86 [==============================] - 17s 192ms/step - loss: 1.6811 - accuracy: 0.3348\n",
            "Epoch 21/30\n",
            "86/86 [==============================] - 14s 161ms/step - loss: 1.6884 - accuracy: 0.3304\n",
            "Epoch 22/30\n",
            "86/86 [==============================] - 19s 224ms/step - loss: 1.6595 - accuracy: 0.3639\n",
            "Epoch 23/30\n",
            "86/86 [==============================] - 14s 157ms/step - loss: 1.6230 - accuracy: 0.3785\n",
            "Epoch 24/30\n",
            "86/86 [==============================] - 16s 192ms/step - loss: 1.5978 - accuracy: 0.4061\n",
            "Epoch 25/30\n",
            "86/86 [==============================] - 16s 186ms/step - loss: 1.6804 - accuracy: 0.3261\n",
            "Epoch 26/30\n",
            "86/86 [==============================] - 18s 212ms/step - loss: 1.6343 - accuracy: 0.3668\n",
            "Epoch 27/30\n",
            "86/86 [==============================] - 15s 169ms/step - loss: 1.6265 - accuracy: 0.3654\n",
            "Epoch 28/30\n",
            "86/86 [==============================] - 18s 206ms/step - loss: 1.6287 - accuracy: 0.3421\n",
            "Epoch 29/30\n",
            "86/86 [==============================] - 15s 171ms/step - loss: 1.5976 - accuracy: 0.3828\n",
            "Epoch 30/30\n",
            "86/86 [==============================] - 18s 203ms/step - loss: 1.6450 - accuracy: 0.3552\n",
            "19/19 [==============================] - 2s 32ms/step - loss: 1.6659 - accuracy: 0.3537\n",
            "Current Hyperparameters: Learning Rate=0.1, Batch Size=16, Epochs=30\n",
            "Epoch 1/30\n",
            "86/86 [==============================] - 58s 203ms/step - loss: 1.9161 - accuracy: 0.2213\n",
            "Epoch 2/30\n",
            "86/86 [==============================] - 16s 178ms/step - loss: 1.8282 - accuracy: 0.2460\n",
            "Epoch 3/30\n",
            "86/86 [==============================] - 17s 198ms/step - loss: 1.7970 - accuracy: 0.2795\n",
            "Epoch 4/30\n",
            "86/86 [==============================] - 15s 171ms/step - loss: 1.7925 - accuracy: 0.2475\n",
            "Epoch 5/30\n",
            "86/86 [==============================] - 16s 189ms/step - loss: 1.7591 - accuracy: 0.2606\n",
            "Epoch 6/30\n",
            "86/86 [==============================] - 17s 192ms/step - loss: 1.7813 - accuracy: 0.2518\n",
            "Epoch 7/30\n",
            "86/86 [==============================] - 16s 181ms/step - loss: 1.8047 - accuracy: 0.2518\n",
            "Epoch 8/30\n",
            "86/86 [==============================] - 14s 159ms/step - loss: 1.7785 - accuracy: 0.2591\n",
            "Epoch 9/30\n",
            "86/86 [==============================] - 18s 206ms/step - loss: 1.7733 - accuracy: 0.2693\n",
            "Epoch 10/30\n",
            "86/86 [==============================] - 15s 173ms/step - loss: 1.7762 - accuracy: 0.2504\n",
            "Epoch 11/30\n",
            "86/86 [==============================] - 21s 240ms/step - loss: 1.7780 - accuracy: 0.2460\n",
            "Epoch 12/30\n",
            "86/86 [==============================] - 15s 171ms/step - loss: 1.7673 - accuracy: 0.2678\n",
            "Epoch 13/30\n",
            "86/86 [==============================] - 16s 187ms/step - loss: 1.7716 - accuracy: 0.2722\n",
            "Epoch 14/30\n",
            "86/86 [==============================] - 14s 158ms/step - loss: 1.7751 - accuracy: 0.2751\n",
            "Epoch 15/30\n",
            "86/86 [==============================] - 14s 167ms/step - loss: 1.7528 - accuracy: 0.3028\n",
            "Epoch 16/30\n",
            "86/86 [==============================] - 16s 187ms/step - loss: 1.7515 - accuracy: 0.2751\n",
            "Epoch 17/30\n",
            "86/86 [==============================] - 14s 164ms/step - loss: 1.7675 - accuracy: 0.2780\n",
            "Epoch 18/30\n",
            "86/86 [==============================] - 14s 158ms/step - loss: 1.7559 - accuracy: 0.2533\n",
            "Epoch 19/30\n",
            "86/86 [==============================] - 14s 160ms/step - loss: 1.7385 - accuracy: 0.2751\n",
            "Epoch 20/30\n",
            "86/86 [==============================] - 17s 198ms/step - loss: 1.7769 - accuracy: 0.2649\n",
            "Epoch 21/30\n",
            "86/86 [==============================] - 14s 161ms/step - loss: 1.7546 - accuracy: 0.2853\n",
            "Epoch 22/30\n",
            "86/86 [==============================] - 16s 182ms/step - loss: 1.7407 - accuracy: 0.2707\n",
            "Epoch 23/30\n",
            "86/86 [==============================] - 15s 173ms/step - loss: 1.7594 - accuracy: 0.2722\n",
            "Epoch 24/30\n",
            "86/86 [==============================] - 18s 209ms/step - loss: 1.7268 - accuracy: 0.2737\n",
            "Epoch 25/30\n",
            "86/86 [==============================] - 14s 157ms/step - loss: 1.7501 - accuracy: 0.2853\n",
            "Epoch 26/30\n",
            "86/86 [==============================] - 17s 197ms/step - loss: 1.7410 - accuracy: 0.2737\n",
            "Epoch 27/30\n",
            "86/86 [==============================] - 14s 157ms/step - loss: 1.7735 - accuracy: 0.2635\n",
            "Epoch 28/30\n",
            "86/86 [==============================] - 18s 205ms/step - loss: 1.7775 - accuracy: 0.2838\n",
            "Epoch 29/30\n",
            "86/86 [==============================] - 14s 159ms/step - loss: 1.7600 - accuracy: 0.2751\n",
            "Epoch 30/30\n",
            "86/86 [==============================] - 17s 201ms/step - loss: 1.7503 - accuracy: 0.2649\n",
            "19/19 [==============================] - 3s 52ms/step - loss: 1.8189 - accuracy: 0.2381\n",
            "Current Hyperparameters: Learning Rate=0.001, Batch Size=32, Epochs=10\n",
            "Epoch 1/10\n",
            "86/86 [==============================] - 54s 166ms/step - loss: 1.7084 - accuracy: 0.2868\n",
            "Epoch 2/10\n",
            "86/86 [==============================] - 18s 208ms/step - loss: 1.7183 - accuracy: 0.2751\n",
            "Epoch 3/10\n",
            "86/86 [==============================] - 13s 156ms/step - loss: 1.7026 - accuracy: 0.2969\n",
            "Epoch 4/10\n",
            "86/86 [==============================] - 18s 204ms/step - loss: 1.7136 - accuracy: 0.2911\n",
            "Epoch 5/10\n",
            "86/86 [==============================] - 14s 159ms/step - loss: 1.7090 - accuracy: 0.2824\n",
            "Epoch 6/10\n",
            "86/86 [==============================] - 16s 187ms/step - loss: 1.7140 - accuracy: 0.2882\n",
            "Epoch 7/10\n",
            "86/86 [==============================] - 14s 157ms/step - loss: 1.7111 - accuracy: 0.2955\n",
            "Epoch 8/10\n",
            "86/86 [==============================] - 17s 200ms/step - loss: 1.6877 - accuracy: 0.2926\n",
            "Epoch 9/10\n",
            "86/86 [==============================] - 14s 160ms/step - loss: 1.6932 - accuracy: 0.2984\n",
            "Epoch 10/10\n",
            "86/86 [==============================] - 15s 170ms/step - loss: 1.6822 - accuracy: 0.3144\n",
            "19/19 [==============================] - 2s 34ms/step - loss: 1.7017 - accuracy: 0.2789\n",
            "Current Hyperparameters: Learning Rate=0.01, Batch Size=32, Epochs=10\n",
            "Epoch 1/10\n",
            "86/86 [==============================] - 55s 174ms/step - loss: 1.6918 - accuracy: 0.2926\n",
            "Epoch 2/10\n",
            "86/86 [==============================] - 18s 213ms/step - loss: 1.6922 - accuracy: 0.2999\n",
            "Epoch 3/10\n",
            "86/86 [==============================] - 14s 158ms/step - loss: 1.6758 - accuracy: 0.3188\n",
            "Epoch 4/10\n",
            "86/86 [==============================] - 17s 199ms/step - loss: 1.6684 - accuracy: 0.3333\n",
            "Epoch 5/10\n",
            "86/86 [==============================] - 14s 162ms/step - loss: 1.6813 - accuracy: 0.3188\n",
            "Epoch 6/10\n",
            "86/86 [==============================] - 18s 203ms/step - loss: 1.6811 - accuracy: 0.3333\n",
            "Epoch 7/10\n",
            "86/86 [==============================] - 14s 162ms/step - loss: 1.6857 - accuracy: 0.3115\n",
            "Epoch 8/10\n",
            "86/86 [==============================] - 18s 205ms/step - loss: 1.6821 - accuracy: 0.3333\n",
            "Epoch 9/10\n",
            "86/86 [==============================] - 14s 163ms/step - loss: 1.6653 - accuracy: 0.3231\n",
            "Epoch 10/10\n",
            "86/86 [==============================] - 19s 217ms/step - loss: 1.6634 - accuracy: 0.3392\n",
            "19/19 [==============================] - 2s 34ms/step - loss: 1.6551 - accuracy: 0.3197\n",
            "Current Hyperparameters: Learning Rate=0.1, Batch Size=32, Epochs=10\n",
            "Epoch 1/10\n",
            "86/86 [==============================] - 53s 159ms/step - loss: 1.7533 - accuracy: 0.2926\n",
            "Epoch 2/10\n",
            "86/86 [==============================] - 18s 207ms/step - loss: 1.7205 - accuracy: 0.3042\n",
            "Epoch 3/10\n",
            "86/86 [==============================] - 14s 165ms/step - loss: 1.7361 - accuracy: 0.2868\n",
            "Epoch 4/10\n",
            "86/86 [==============================] - 16s 186ms/step - loss: 1.7452 - accuracy: 0.2678\n",
            "Epoch 5/10\n",
            "86/86 [==============================] - 16s 183ms/step - loss: 1.7686 - accuracy: 0.2999\n",
            "Epoch 6/10\n",
            "86/86 [==============================] - 15s 175ms/step - loss: 1.7631 - accuracy: 0.2693\n",
            "Epoch 7/10\n",
            "86/86 [==============================] - 17s 193ms/step - loss: 1.7455 - accuracy: 0.2969\n",
            "Epoch 8/10\n",
            "86/86 [==============================] - 14s 164ms/step - loss: 1.7649 - accuracy: 0.2693\n",
            "Epoch 9/10\n",
            "86/86 [==============================] - 19s 225ms/step - loss: 1.7610 - accuracy: 0.2824\n",
            "Epoch 10/10\n",
            "86/86 [==============================] - 14s 167ms/step - loss: 1.7533 - accuracy: 0.2664\n",
            "19/19 [==============================] - 3s 52ms/step - loss: 1.7367 - accuracy: 0.2721\n",
            "Current Hyperparameters: Learning Rate=0.001, Batch Size=32, Epochs=20\n",
            "Epoch 1/20\n",
            "86/86 [==============================] - 56s 163ms/step - loss: 1.7361 - accuracy: 0.2853\n",
            "Epoch 2/20\n",
            "86/86 [==============================] - 18s 206ms/step - loss: 1.7149 - accuracy: 0.2868\n",
            "Epoch 3/20\n",
            "86/86 [==============================] - 14s 161ms/step - loss: 1.7126 - accuracy: 0.2911\n",
            "Epoch 4/20\n",
            "86/86 [==============================] - 18s 206ms/step - loss: 1.6966 - accuracy: 0.3057\n",
            "Epoch 5/20\n",
            "86/86 [==============================] - 14s 161ms/step - loss: 1.6776 - accuracy: 0.3028\n",
            "Epoch 6/20\n",
            "86/86 [==============================] - 15s 170ms/step - loss: 1.6947 - accuracy: 0.3159\n",
            "Epoch 7/20\n",
            "86/86 [==============================] - 14s 160ms/step - loss: 1.6912 - accuracy: 0.3173\n",
            "Epoch 8/20\n",
            "86/86 [==============================] - 14s 166ms/step - loss: 1.6718 - accuracy: 0.3188\n",
            "Epoch 9/20\n",
            "86/86 [==============================] - 17s 191ms/step - loss: 1.6598 - accuracy: 0.3173\n",
            "Epoch 10/20\n",
            "86/86 [==============================] - 14s 160ms/step - loss: 1.6656 - accuracy: 0.3086\n",
            "Epoch 11/20\n",
            "86/86 [==============================] - 20s 232ms/step - loss: 1.6797 - accuracy: 0.3202\n",
            "Epoch 12/20\n",
            "86/86 [==============================] - 14s 162ms/step - loss: 1.6730 - accuracy: 0.2940\n",
            "Epoch 13/20\n",
            "86/86 [==============================] - 19s 214ms/step - loss: 1.6573 - accuracy: 0.3392\n",
            "Epoch 14/20\n",
            "86/86 [==============================] - 14s 159ms/step - loss: 1.6650 - accuracy: 0.3202\n",
            "Epoch 15/20\n",
            "86/86 [==============================] - 17s 202ms/step - loss: 1.6736 - accuracy: 0.3290\n",
            "Epoch 16/20\n",
            "86/86 [==============================] - 14s 160ms/step - loss: 1.6670 - accuracy: 0.3100\n",
            "Epoch 17/20\n",
            "86/86 [==============================] - 18s 213ms/step - loss: 1.6522 - accuracy: 0.3362\n",
            "Epoch 18/20\n",
            "86/86 [==============================] - 14s 159ms/step - loss: 1.6664 - accuracy: 0.3130\n",
            "Epoch 19/20\n",
            "86/86 [==============================] - 18s 204ms/step - loss: 1.6433 - accuracy: 0.3188\n",
            "Epoch 20/20\n",
            "86/86 [==============================] - 13s 155ms/step - loss: 1.6698 - accuracy: 0.3202\n",
            "19/19 [==============================] - 2s 34ms/step - loss: 1.6658 - accuracy: 0.3129\n",
            "Current Hyperparameters: Learning Rate=0.01, Batch Size=32, Epochs=20\n",
            "Epoch 1/20\n",
            "86/86 [==============================] - 67s 285ms/step - loss: 1.6666 - accuracy: 0.3231\n",
            "Epoch 2/20\n",
            "86/86 [==============================] - 38s 432ms/step - loss: 1.6547 - accuracy: 0.3333\n",
            "Epoch 3/20\n",
            "86/86 [==============================] - 26s 302ms/step - loss: 1.6531 - accuracy: 0.3290\n",
            "Epoch 4/20\n",
            "86/86 [==============================] - 24s 275ms/step - loss: 1.6465 - accuracy: 0.3493\n",
            "Epoch 5/20\n",
            "86/86 [==============================] - 26s 299ms/step - loss: 1.6500 - accuracy: 0.3493\n",
            "Epoch 6/20\n",
            "86/86 [==============================] - 35s 415ms/step - loss: 1.6219 - accuracy: 0.3639\n",
            "Epoch 7/20\n",
            "86/86 [==============================] - 32s 370ms/step - loss: 1.6484 - accuracy: 0.3537\n",
            "Epoch 8/20\n",
            "86/86 [==============================] - 36s 401ms/step - loss: 1.6327 - accuracy: 0.3581\n",
            "Epoch 9/20\n",
            "86/86 [==============================] - 27s 310ms/step - loss: 1.6260 - accuracy: 0.3523\n",
            "Epoch 10/20\n",
            "86/86 [==============================] - 41s 479ms/step - loss: 1.6273 - accuracy: 0.3523\n",
            "Epoch 11/20\n",
            "86/86 [==============================] - 30s 350ms/step - loss: 1.6078 - accuracy: 0.3741\n",
            "Epoch 12/20\n",
            "86/86 [==============================] - 31s 364ms/step - loss: 1.5703 - accuracy: 0.3916\n",
            "Epoch 13/20\n",
            "86/86 [==============================] - 30s 345ms/step - loss: 1.5831 - accuracy: 0.3916\n",
            "Epoch 14/20\n",
            "86/86 [==============================] - 41s 480ms/step - loss: 1.5811 - accuracy: 0.3872\n",
            "Epoch 15/20\n",
            "86/86 [==============================] - 31s 367ms/step - loss: 1.5593 - accuracy: 0.4207\n",
            "Epoch 16/20\n",
            "86/86 [==============================] - 63s 732ms/step - loss: 1.5919 - accuracy: 0.3726\n",
            "Epoch 17/20\n",
            "86/86 [==============================] - 33s 386ms/step - loss: 1.5606 - accuracy: 0.4017\n",
            "Epoch 18/20\n",
            "86/86 [==============================] - 45s 525ms/step - loss: 1.5785 - accuracy: 0.3930\n",
            "Epoch 19/20\n",
            "86/86 [==============================] - 46s 537ms/step - loss: 1.5707 - accuracy: 0.3916\n",
            "Epoch 20/20\n",
            "86/86 [==============================] - 41s 481ms/step - loss: 1.5210 - accuracy: 0.4352\n",
            "19/19 [==============================] - 5s 211ms/step - loss: 1.4156 - accuracy: 0.5102\n",
            "Current Hyperparameters: Learning Rate=0.1, Batch Size=32, Epochs=20\n",
            "Epoch 1/20\n"
          ]
        }
      ]
    }
  ]
}