AML_multi-class_FFNN_object_classification.ipynb

{
  "cells": [
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# This notebook was implemented on Colab"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "5GAoEgGUsiDQ",
        "outputId": "67785493-9b5f-4ae9-f8f4-d2f1ff67d8fd"
      },
      "outputs": [
        {
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'/device:GPU:0'"
            ]
          },
          "execution_count": 1,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "import tensorflow as tf\n",
        "tf.test.gpu_device_name()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KSlfsZIOsiDQ"
      },
      "outputs": [],
      "source": [
        "!pip install keras-tuner"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KkUHrAnbsiDR",
        "outputId": "0bfa3176-21ae-4977-e3f2-0c5488923723"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "<ipython-input-2-fd9ef17bd841>:13: DeprecationWarning: `import kerastuner` is deprecated, please use `import keras_tuner`.\n",
            "  from kerastuner import HyperModel, Hyperband\n"
          ]
        }
      ],
      "source": [
        "# Standard library imports\n",
        "import json\n",
        "import os\n",
        "import random\n",
        "import shutil\n",
        "\n",
        "# Third-party imports\n",
        "import tensorflow as tf\n",
        "from keras.callbacks import EarlyStopping\n",
        "from keras.preprocessing.image import ImageDataGenerator\n",
        "from keras_tuner.tuners import RandomSearch\n",
        "from kerastuner import HyperModel, Hyperband\n",
        "from kerastuner.engine.hyperparameters import HyperParameters\n",
        "from tensorflow import keras\n",
        "from tensorflow.keras import layers, regularizers\n",
        "from tensorflow.keras.layers import BatchNormalization\n",
        "\n",
        "# Local application/library specific imports\n",
        "from google.colab import drive"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rNNooJCXsiDR",
        "outputId": "93c2370d-3e88-48ce-98b0-72d3ba895efd"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Not running on TPU.\n"
          ]
        }
      ],
      "source": [
        "# Check if TPU is available\n",
        "if 'COLAB_TPU_ADDR' in os.environ:\n",
        "  tpu_address = 'grpc://' + os.environ['COLAB_TPU_ADDR']\n",
        "  tpu_resolver = tf.distribute.cluster_resolver.TPUClusterResolver(tpu=tpu_address)\n",
        "  tf.config.experimental_connect_to_cluster(tpu_resolver)\n",
        "  tf.tpu.experimental.initialize_tpu_system(tpu_resolver)\n",
        "  tpu_strategy = tf.distribute.TPUStrategy(tpu_resolver)\n",
        "  print(\"Running on TPU.\")\n",
        "else:\n",
        "  tpu_strategy = None\n",
        "  print(\"Not running on TPU.\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "clp4HElEsiDR",
        "outputId": "3dbdba1e-da1c-4489-fd52-58f1fb0b6184"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ],
      "source": [
        "# mount your Google Drive\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "0wvwAf4OsiDR"
      },
      "source": [
        "## Images Classification and splitting ... train 80% - validate 20%"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RwAEU5tAsiDR"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import shutil\n",
        "import random\n",
        "\n",
        "# Define the paths for the input and output directories\n",
        "input_dir = \"output\"\n",
        "output_dir = 'data_categorized'\n",
        "\n",
        "# Create the output directories if they do not exist\n",
        "if not os.path.exists(output_dir):\n",
        "    os.mkdir(output_dir)\n",
        "\n",
        "train_dir = os.path.join(output_dir, \"train\")\n",
        "if not os.path.exists(train_dir):\n",
        "    os.mkdir(train_dir)\n",
        "\n",
        "valid_dir = os.path.join(output_dir, \"test\")\n",
        "if not os.path.exists(valid_dir):\n",
        "    os.mkdir(valid_dir)\n",
        "\n",
        "# Define a dictionary to hold the counts of each image type\n",
        "counts = {}\n",
        "\n",
        "# Loop through each file in the input directory\n",
        "for filename in os.listdir(input_dir):\n",
        "    # Extract the image type from the filename\n",
        "    img_type = filename.split(\"_\")[0]\n",
        "\n",
        "    # Increment the count of the current image type in the dictionary\n",
        "    counts[img_type] = counts.get(img_type, 0) + 1\n",
        "\n",
        "    # Determine whether the current image should be included in the training set or the validation set\n",
        "    if random.random() < 0.8:\n",
        "        output_subdir = train_dir\n",
        "    else:\n",
        "        output_subdir = valid_dir\n",
        "\n",
        "    # Create the output directory for the current image type if it does not exist\n",
        "    type_dir = os.path.join(output_subdir, img_type)\n",
        "    if not os.path.exists(type_dir):\n",
        "        os.mkdir(type_dir)\n",
        "\n",
        "    # Copy the image file to the appropriate output directory\n",
        "    src_path = os.path.join(input_dir, filename)\n",
        "    dst_path = os.path.join(type_dir, filename)\n",
        "    shutil.copy(src_path, dst_path)\n",
        "\n",
        "# # Print the counts of each image type in the dictionary\n",
        "# print(counts)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Ba3ew3Z-siDR"
      },
      "outputs": [],
      "source": [
        "!unrar x '/content/drive/MyDrive/AML/data_categorized.rar' '/content/drive/MyDrive/AML/'"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Data Preprocessing"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vknSioM3siDR"
      },
      "outputs": [],
      "source": [
        "train_directory = '/content/drive/MyDrive/AML/data_categorized/train'\n",
        "test_directory = '/content/drive/MyDrive/AML/data_categorized/test'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C1Y2L89TZtuM",
        "outputId": "4f9b3e7e-5c8c-4bfa-9d2e-b2a10d90a23c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Found 71922 images belonging to 9 classes.\n",
            "Found 18078 images belonging to 9 classes.\n"
          ]
        }
      ],
      "source": [
        "# Set up ImageDataGenerator objects to perform preprocessing and data augmentation\n",
        "from keras.preprocessing.image import ImageDataGenerator\n",
        "\n",
        "train_data_generator = ImageDataGenerator(\n",
        "    rescale=1./255,       # Normalize pixel values between 0 and 1\n",
        "    shear_range=0.4,      # Randomly apply shearing transformations\n",
        "    zoom_range=0.3,       # Randomly zoom in on images\n",
        "    horizontal_flip=True  # Randomly flip images horizontally\n",
        "    )\n",
        "\n",
        "validaiton_data_generator = ImageDataGenerator(rescale=1./255)\n",
        "batch_size = 32\n",
        "target_size = (200, 200), # Resize images to 200x200\n",
        "\n",
        "# prepare an iterators for each dataset .... 2 iterators will be created\n",
        "\n",
        "# Set up training data generator to read images from directory and preprocess them\n",
        "train_generator = train_data_generator.flow_from_directory(train_directory,\n",
        "                                                    target_size = target_size,\n",
        "                                                    batch_size = batch_size,\n",
        "                                                    class_mode = 'categorical', # multi-class classification\n",
        "                                                    )\n",
        "\n",
        "# Set up validaiton data generators to read images from directories and preprocess them \n",
        "validation_generator = validaiton_data_generator.flow_from_directory(test_directory,\n",
        "                                                target_size = target_size,\n",
        "                                                batch_size = batch_size,\n",
        "                                                class_mode = 'categorical' # for multi-class classification\n",
        "                                                )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Modeling"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bOxQaCD0y2r4"
      },
      "outputs": [],
      "source": [
        "def build_model(hp):\n",
        "    \"\"\" build the model with different values of hyperparameters to tune\n",
        "\n",
        "    Args:\n",
        "        hp: hyperparameter\n",
        "\n",
        "    Returns:\n",
        "        model\n",
        "    \"\"\"\n",
        "    num_classes = len(train_generator.class_indices)\n",
        "    model = keras.Sequential()\n",
        "    model.add(layers.Input(shape=(200, 200, 3))) # width, height, rgb\n",
        "    \n",
        "    # Tune the number of hidden dense layers between 1-3\n",
        "    for i in range(hp.Int('num_layers', 1, 3)):\n",
        "        \n",
        "        # Tune number of neurons for each layer\n",
        "        model.add(layers.Dense(units=hp.Int('units_' + str(i), min_value=32, max_value=512, step=32),\n",
        "                               activation=hp.Choice('activation_' + str(i), values=['relu', 'sigmoid', 'tanh'])\n",
        "                               )\n",
        "        )\n",
        "        \n",
        "        # Add Dropout layer if the use_dropout hyperparameter is True\n",
        "        if hp.Boolean('use_dropout_' + str(i)):\n",
        "          model.add(layers.Dropout(rate=hp.Float('dropout_rate_' + str(i), min_value=0.0, max_value=0.5, step=0.3)))  # model.add(layers.Dropout(rate=0.2))\n",
        "\n",
        "        model.add(BatchNormalization())\n",
        "        \n",
        "    # Tune the regularization rate for the kernel weights\n",
        "    # Choose an optimal value between 0.01, 0.001, and 0.0001\n",
        "    hp_kernel_regularizer = hp.Choice('kernel_regularizer_' + str(i), [0.01, 0.001, 0.0001])\n",
        "    model.add(layers.Dense(num_classes, activation='softmax', kernel_regularizer=regularizers.l2(hp_kernel_regularizer)))\n",
        "    \n",
        "\n",
        "    model.add(layers.Flatten())\n",
        "\n",
        "    # Add the output layer\n",
        "    model.add(layers.Dense(num_classes, activation='softmax'))\n",
        "    # Compile the model with the selected hyperparameters\n",
        "    # Tune the learning rate\n",
        "    model.compile(optimizer=keras.optimizers.Adam(\n",
        "        learning_rate=hp.Float('learning_rate', min_value=1e-4, max_value=1e-2, sampling='log')), \n",
        "        loss=hp.Choice('loss_function', values=['sparse_categorical_crossentropy', 'categorical_crossentropy']), # loss='categorical_crossentropy', \n",
        "        metrics=['accuracy'])\n",
        "    \n",
        "    return model"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Hyperprameter tuning"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KGGoGtQxcBrV"
      },
      "outputs": [],
      "source": [
        "# Define the tuner\n",
        "tuner = RandomSearch(\n",
        "    build_model,\n",
        "    objective='val_accuracy',\n",
        "    # max_trials=5,\n",
        "    # executions_per_trial=4,\n",
        "    overwrite=True,\n",
        "    directory='/content/drive/MyDrive/AML/final_model',\n",
        "    project_name='final_object_classification')\n",
        "\n",
        "# tuner = Hyperband(\n",
        "#     build_model,\n",
        "#     objective='val_accuracy',\n",
        "#     # max_epochs=10,\n",
        "#     # factor=3,\n",
        "#     directory='/content/drive/MyDrive/AML/final_model',\n",
        "#     project_name='final_object_classification')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gOr7oKvTjTos",
        "outputId": "5e20bb4d-6835-453b-f85b-d67a98a69870"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Trial 3 Complete [00h 00m 13s]\n",
            "\n",
            "Best val_accuracy So Far: 0.1131209209561348\n",
            "Total elapsed time: 01h 03m 29s\n"
          ]
        }
      ],
      "source": [
        "# Search for the best hyperparameters\n",
        "tuner.search(train_generator,\n",
        "             validation_data=validation_generator,\n",
        "             epochs=3,\n",
        "             verbose=2)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7DE_xZQtOGEA",
        "outputId": "a39228ee-4c7b-45d6-b2ad-fbc4d0f88eb5"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<keras_tuner.tuners.randomsearch.RandomSearch at 0x7f2771774760>"
            ]
          },
          "execution_count": 18,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "tuner"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WlrUllyOOGEB",
        "outputId": "892cebfb-53bc-4d86-f25d-84a5e6e6bade"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[<keras.engine.sequential.Sequential at 0x7f27717af0d0>]"
            ]
          },
          "execution_count": 16,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "tuner.get_best_models(num_models=1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zbiUyi0vOGEC"
      },
      "outputs": [],
      "source": [
        "# Get the best model\n",
        "best_model = tuner.get_best_models(num_models=1)[0]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sOIri0CqOGED",
        "outputId": "de4d5c56-38b2-4e4c-898f-8a667bd40504"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<keras.engine.sequential.Sequential at 0x7f28173c64c0>"
            ]
          },
          "execution_count": 19,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "best_model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L9chJwCOOGEE",
        "outputId": "c4dfe7d4-49da-43c4-e080-fbc80cd092c8"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[<keras.engine.sequential.Sequential at 0x7f28b20dd7c0>]"
            ]
          },
          "execution_count": 17,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "tuner.get_best_models()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NZWd7abeOGEF",
        "outputId": "10281b5d-e080-4ead-e39d-d115806963be"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Best number of layers:  1\n",
            "Best number of units in layer 0:  480\n",
            "Best activation function in layer 0:  tanh\n",
            "Best learning rate:  0.0009313969589226206\n"
          ]
        }
      ],
      "source": [
        "# Print the best hyperparameters\n",
        "best_hyperparameters = tuner.get_best_hyperparameters(num_trials=1)[0]\n",
        "print(\"Best number of layers: \", best_hyperparameters.get('num_layers'))\n",
        "for i in range(best_hyperparameters.get('num_layers')):\n",
        "    print(\"Best number of units in layer \" + str(i) + \": \", best_hyperparameters.get('units_' + str(i)))\n",
        "    print(\"Best activation function in layer \" + str(i) + \": \", best_hyperparameters.get('activation_' + str(i)))\n",
        "print(\"Best learning rate: \", best_hyperparameters.get('learning_rate'))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eLfJhfuFOGEH",
        "outputId": "46ac087d-c072-4ce4-f82b-4825cadc9ebb"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Best Hyperparameters:\n",
            "num_layers: 1\n",
            "units_0: 480\n",
            "activation_0: tanh\n",
            "use_dropout_0: False\n",
            "kernel_regularizer_0: 0.01\n",
            "learning_rate: 0.0009313969589226206\n",
            "loss_function: categorical_crossentropy\n"
          ]
        }
      ],
      "source": [
        "# Get the best hyperparameters\n",
        "best_hps = tuner.get_best_hyperparameters(num_trials=1)[0]\n",
        "\n",
        "# Build the best model with the best hyperparameters\n",
        "model_best_hp__tuner_BatchNormalization_dropout_regularization = build_model(best_hps)\n",
        "\n",
        "# Print the best hyperparameters\n",
        "print(\"Best Hyperparameters:\")\n",
        "print(f\"num_layers: {best_hps.get('num_layers')}\")\n",
        "\n",
        "# if best num_layers > 1\n",
        "for i in range(best_hps.get('num_layers')):\n",
        "    print(f\"units_{i}: {best_hps.get('units_' + str(i))}\")\n",
        "    print(f\"activation_{i}: {best_hps.get('activation_' + str(i))}\")\n",
        "    print(f\"use_dropout_{i}: {best_hps.get('use_dropout_' + str(i))}\")\n",
        "    if best_hps.get('use_dropout_' + str(i)):\n",
        "        print(f\"dropout_rate_{i}: {best_hps.get('dropout_rate_' + str(i))}\")\n",
        "\n",
        "print(f\"kernel_regularizer_{i}: {best_hps.get('kernel_regularizer_' + str(i))}\")\n",
        "print(f\"learning_rate: {best_hps.get('learning_rate')}\")\n",
        "print(f\"loss_function: {best_hps.get('loss_function')}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OcmFvebvOGEJ",
        "outputId": "9e167579-db0d-4769-d2ed-3ecfc217aa6a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "num_layers: 1\n",
            "units_0: 480\n",
            "activation_0: tanh\n",
            "use_dropout_0: False\n",
            "kernel_regularizer_0: 0.01\n",
            "learning_rate: 0.0009313969589226206\n",
            "loss_function: categorical_crossentropy\n"
          ]
        }
      ],
      "source": [
        "# Get the best hyperparameters\n",
        "best_hp = tuner.get_best_hyperparameters()[0]\n",
        "\n",
        "# Print the name and value of each hyperparameter\n",
        "for hp_name, hp_value in best_hp.values.items():\n",
        "    print(f'{hp_name}: {hp_value}')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DprtaxhPOGEK"
      },
      "outputs": [],
      "source": [
        "# Save the best hyperparameters\n",
        "best_hps_dict = best_hps.values\n",
        "with open('/content/drive/MyDrive/AML/best_hps_dict__tuner_BatchNormalization_dropout_regularization.json', 'w') as f:\n",
        "    json.dump(best_hps_dict, f)\n",
        "\n",
        "# Save the best model\n",
        "model_best_hp__tuner_BatchNormalization_dropout_regularization.save('/content/drive/MyDrive/AML/best_model__tuner_BatchNormalization_dropout_regularization.h5')"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "kSiionTqOGEL"
      },
      "source": [
        "## Overfitting removal approach:\n",
        "using early stopping technique"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oLXv7fUeOGEM",
        "outputId": "08c4828d-21bc-4d01-9cab-1497e9fdaa62"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 1/3\n",
            "2248/2248 [==============================] - 1316s 585ms/step - loss: 13.1739 - accuracy: 0.1087 - val_loss: 13.0953 - val_accuracy: 0.1090\n",
            "Epoch 2/3\n",
            "2248/2248 [==============================] - 1269s 564ms/step - loss: 14.0787 - accuracy: 0.1106 - val_loss: 19.5486 - val_accuracy: 0.1090\n",
            "Epoch 3/3\n",
            "2248/2248 [==============================] - 1292s 575ms/step - loss: 13.8709 - accuracy: 0.1124 - val_loss: 14.0395 - val_accuracy: 0.1110\n"
          ]
        }
      ],
      "source": [
        "# Define early stopping callback\n",
        "from keras.callbacks import EarlyStopping\n",
        "\n",
        "early_stopping = EarlyStopping(monitor='val_loss', patience=2, restore_best_weights=True)\n",
        "\n",
        "# Train the model with early stopping\n",
        "history = best_model.fit(train_generator,\n",
        "                         validation_data=validation_generator, # , steps_per_epoch=16\n",
        "                         epochs=3, callbacks=[early_stopping] # callbacks=[EarlyStopping(patience=5)]\n",
        "                         )"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ePzDbWf1OGEO",
        "outputId": "30385ec3-7f5a-4598-ce6b-ca190d799813"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{'loss': [13.173863410949707, 14.078662872314453, 13.870908737182617],\n",
              " 'accuracy': [0.10865937918424606, 0.11055032163858414, 0.11242735385894775],\n",
              " 'val_loss': [13.095309257507324, 19.54863739013672, 14.039475440979004],\n",
              " 'val_accuracy': [0.1089722290635109, 0.1089722290635109, 0.1109636053442955]}"
            ]
          },
          "execution_count": 27,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "history.history"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EOjaOeDFOGEO",
        "outputId": "aa62472d-0a69-40c4-a875-1e4ad1872f92"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{'loss': [13.173863410949707, 14.078662872314453, 13.870908737182617],\n",
              " 'accuracy': [0.10865937918424606, 0.11055032163858414, 0.11242735385894775],\n",
              " 'val_loss': [13.095309257507324, 19.54863739013672, 14.039475440979004],\n",
              " 'val_accuracy': [0.1089722290635109, 0.1089722290635109, 0.1109636053442955]}"
            ]
          },
          "execution_count": 65,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Access the best model\n",
        "early_stopping.model.history.history"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KM_FqWPFOGEP"
      },
      "outputs": [],
      "source": [
        "# # Save the history object\n",
        "# with open('/content/drive/MyDrive/AML/history_all_hp_early_stopping.pkl', 'wb') as f:\n",
        "#     pickle.dump(history.history, f)"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": []
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.10.11"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}