vgg19_satellite_image_classification_Code.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2023-06-07T13:19:17.470898Z",
          "iopub.status.busy": "2023-06-07T13:19:17.470584Z",
          "iopub.status.idle": "2023-06-07T13:19:27.241417Z",
          "shell.execute_reply": "2023-06-07T13:19:27.240485Z",
          "shell.execute_reply.started": "2023-06-07T13:19:17.470871Z"
        },
        "id": "SQRc89I4dhfV"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import glob\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import shutil\n",
        "import random\n",
        "import cv2\n",
        "import matplotlib.pyplot as plt\n",
        "from matplotlib.image import imread\n",
        "import seaborn as sns\n",
        "sns.set(rc={'figure.figsize':(10,6)})\n",
        "sns.set(font_scale=1.3)\n",
        "plt.style.use('fivethirtyeight')\n",
        "\n",
        "\n",
        "!pip install -U -q pyDrive\n",
        "from pydrive.auth import GoogleAuth\n",
        "from pydrive.drive import GoogleDrive\n",
        "from google.colab import auth\n",
        "from oauth2client.client import GoogleCredentials\n",
        "\n",
        "auth.authenticate_user()\n",
        "gauth = GoogleAuth()\n",
        "gauth.credentials = GoogleCredentials.get_application_default()\n",
        "drive = GoogleDrive(gauth)\n",
        "\n",
        "from google.colab import drive\n",
        "drive.mount('/content/gdrive')\n",
        "\n",
        "\n",
        "!pip install tensorflow\n",
        "\n",
        "!pip install -q keras\n",
        "\n",
        "from sklearn.model_selection import train_test_split\n",
        "import tensorflow as tf\n",
        "from tensorflow.keras.applications import VGG19\n",
        "from tensorflow.keras.applications.vgg19 import preprocess_input\n",
        "from tensorflow.keras.models import Sequential, Model\n",
        "from tensorflow.keras.layers import Activation,Input, Dropout, Flatten, Dense, Conv2D, MaxPooling2D\n",
        "from tensorflow.keras.optimizers import Adam\n",
        "from keras.optimizers import SGD, RMSprop\n",
        "from keras.layers import BatchNormalization, GlobalAveragePooling2D\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "#from keras.callbacks import EarlyStopping\n",
        "from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau\n",
        "from keras.regularizers import l2\n",
        "\n",
        "import warnings\n",
        "warnings.filterwarnings(action=\"ignore\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2023-06-07T13:20:05.059403Z",
          "iopub.status.busy": "2023-06-07T13:20:05.058354Z",
          "iopub.status.idle": "2023-06-07T13:20:17.044562Z",
          "shell.execute_reply": "2023-06-07T13:20:17.043371Z",
          "shell.execute_reply.started": "2023-06-07T13:20:05.059366Z"
        },
        "id": "fFzMV8oDdhfz",
        "outputId": "4d778f2a-aba6-4a17-90f0-896b5a5aef66",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting split-folders\n",
            "  Downloading split_folders-0.5.1-py3-none-any.whl (8.4 kB)\n",
            "Installing collected packages: split-folders\n",
            "Successfully installed split-folders-0.5.1\n"
          ]
        }
      ],
      "source": [
        "! pip install split-folders"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2023-06-07T13:20:17.047852Z",
          "iopub.status.busy": "2023-06-07T13:20:17.047468Z",
          "iopub.status.idle": "2023-06-07T13:20:17.058630Z",
          "shell.execute_reply": "2023-06-07T13:20:17.057712Z",
          "shell.execute_reply.started": "2023-06-07T13:20:17.047817Z"
        },
        "id": "VU72Kn9Ldhf0"
      },
      "outputs": [],
      "source": [
        "import splitfolders"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2023-06-07T13:20:17.060630Z",
          "iopub.status.busy": "2023-06-07T13:20:17.060258Z",
          "iopub.status.idle": "2023-06-07T13:20:47.615266Z",
          "shell.execute_reply": "2023-06-07T13:20:47.614364Z",
          "shell.execute_reply.started": "2023-06-07T13:20:17.060599Z"
        },
        "id": "P9017uoGdhf0",
        "outputId": "6f14a59f-445d-4181-b64f-c34529c7b7b6"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "Copying files: 5631 files [00:30, 184.42 files/s]\n"
          ]
        }
      ],
      "source": [
        "input_folder = \"/content/gdrive/MyDrive/Colab Notebooks/data1\"\n",
        "output = \"/content/gdrive/MyDrive/Colab Notebooks/data2\"\n",
        "\n",
        "splitfolders.ratio(input_folder, output=output, seed=42, ratio=(0.7,0.3))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2023-06-07T13:20:47.618696Z",
          "iopub.status.busy": "2023-06-07T13:20:47.617797Z",
          "iopub.status.idle": "2023-06-07T13:20:47.733623Z",
          "shell.execute_reply": "2023-06-07T13:20:47.732589Z",
          "shell.execute_reply.started": "2023-06-07T13:20:47.618659Z"
        },
        "id": "AEU2Rh14dhf1",
        "outputId": "a810d083-ae72-4a4a-e955-00b9ae3f250a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 3941 images belonging to 4 classes.\n"
          ]
        }
      ],
      "source": [
        "train_datagen = ImageDataGenerator(preprocessing_function=preprocess_input,rescale = 1./255,\n",
        "                                   shear_range = 0.2,\n",
        "                                   zoom_range = 0.2,\n",
        "                                   horizontal_flip = True)\n",
        "training_set = train_datagen.flow_from_directory('/content/gdrive/MyDrive/Colab Notebooks/data2/train',\n",
        "                                                 target_size = (224, 224),\n",
        "                                                 batch_size = 32,\n",
        "                                                 class_mode = 'categorical',\n",
        "                                                 shuffle=True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2023-06-07T13:20:47.735439Z",
          "iopub.status.busy": "2023-06-07T13:20:47.735088Z",
          "iopub.status.idle": "2023-06-07T13:20:47.740365Z",
          "shell.execute_reply": "2023-06-07T13:20:47.739207Z",
          "shell.execute_reply.started": "2023-06-07T13:20:47.735405Z"
        },
        "id": "PjhSL-Jidhf1"
      },
      "outputs": [],
      "source": [
        "# test_datagen = ImageDataGenerator(preprocessing_function=preprocess_input, rescale = 1./255)\n",
        "# test_set = test_datagen.flow_from_directory('/working/dataset/test',\n",
        "#                                             target_size = (224, 224),\n",
        "#                                             batch_size = 32,\n",
        "#                                             class_mode = 'categorical')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2023-06-07T13:20:47.742620Z",
          "iopub.status.busy": "2023-06-07T13:20:47.742254Z",
          "iopub.status.idle": "2023-06-07T13:20:47.803723Z",
          "shell.execute_reply": "2023-06-07T13:20:47.802866Z",
          "shell.execute_reply.started": "2023-06-07T13:20:47.742589Z"
        },
        "id": "8Nensd8Ddhf1",
        "outputId": "a056161a-84a2-40a0-ba6f-84a0405ef0af",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 1690 images belonging to 4 classes.\n"
          ]
        }
      ],
      "source": [
        "val_datagen = ImageDataGenerator(preprocessing_function=preprocess_input,rescale = 1./255)\n",
        "val_set = val_datagen.flow_from_directory('/content/gdrive/MyDrive/Colab Notebooks/data2/val',\n",
        "                                            target_size = (224, 224),\n",
        "                                            batch_size = 32,\n",
        "                                            class_mode = 'categorical',\n",
        "                                            shuffle=False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2023-06-07T13:20:47.805566Z",
          "iopub.status.busy": "2023-06-07T13:20:47.805219Z",
          "iopub.status.idle": "2023-06-07T13:20:47.811560Z",
          "shell.execute_reply": "2023-06-07T13:20:47.810492Z",
          "shell.execute_reply.started": "2023-06-07T13:20:47.805534Z"
        },
        "id": "AjEb0RG4dhf2"
      },
      "outputs": [],
      "source": [
        "early = EarlyStopping(monitor='val_loss',patience=5)\n",
        "reduce = ReduceLROnPlateau(monitor='val_loss', patience=3, factor=0.2, mil_lr=0.001)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2023-06-07T13:20:47.814579Z",
          "iopub.status.busy": "2023-06-07T13:20:47.813454Z",
          "iopub.status.idle": "2023-06-07T13:20:47.821572Z",
          "shell.execute_reply": "2023-06-07T13:20:47.820422Z",
          "shell.execute_reply.started": "2023-06-07T13:20:47.814517Z"
        },
        "id": "dP5qIWFadhf2"
      },
      "outputs": [],
      "source": [
        "output_classes = 4\n",
        "batch_size = 32\n",
        "epochs = 10\n",
        "image_shape=(224,224,3)\n",
        "nb_train_samples = 3941\n",
        "nb_validation_samples = 1690\n",
        "# nb_test_samples = 564"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2023-06-07T13:52:35.627372Z",
          "iopub.status.busy": "2023-06-07T13:52:35.626987Z",
          "iopub.status.idle": "2023-06-07T13:52:36.124380Z",
          "shell.execute_reply": "2023-06-07T13:52:36.123485Z",
          "shell.execute_reply.started": "2023-06-07T13:52:35.627341Z"
        },
        "id": "0xzTj3Aqdhf2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fec47856-8ea8-4321-d844-a447d6636742"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/vgg19/vgg19_weights_tf_dim_ordering_tf_kernels_notop.h5\n",
            "80134624/80134624 [==============================] - 1s 0us/step\n"
          ]
        }
      ],
      "source": [
        "base_model = VGG19(weights='imagenet', include_top=False, pooling='avg', input_shape=image_shape)\n",
        "x = base_model.output\n",
        "# x = GlobalAveragePooling2D()(x)\n",
        "x = Dense(1024, kernel_regularizer=l2(0.0001), bias_regularizer=l2(0.0001))(x)\n",
        "x = BatchNormalization()(x)\n",
        "x = Activation(\"relu\")(x)\n",
        "x = Dropout(0.5)(x)\n",
        "x = Dense(1024, kernel_regularizer=l2(0.0001), bias_regularizer=l2(0.0001))(x)\n",
        "x = BatchNormalization()(x)\n",
        "x = Activation(\"relu\")(x)\n",
        "x = Dropout(0.5)(x)\n",
        "prediction = Dense(output_classes, activation=tf.nn.softmax)(x)\n",
        "\n",
        "model = Model(inputs=base_model.input,outputs=prediction)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2023-06-07T13:52:42.960250Z",
          "iopub.status.busy": "2023-06-07T13:52:42.959893Z",
          "iopub.status.idle": "2023-06-07T13:52:42.966031Z",
          "shell.execute_reply": "2023-06-07T13:52:42.965086Z",
          "shell.execute_reply.started": "2023-06-07T13:52:42.960220Z"
        },
        "id": "DglNs2T5dhf3"
      },
      "outputs": [],
      "source": [
        "base_model.trainable = False"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2023-06-07T13:52:50.350361Z",
          "iopub.status.busy": "2023-06-07T13:52:50.349997Z",
          "iopub.status.idle": "2023-06-07T13:52:50.406380Z",
          "shell.execute_reply": "2023-06-07T13:52:50.405645Z",
          "shell.execute_reply.started": "2023-06-07T13:52:50.350330Z"
        },
        "id": "RmbliKNUdhf3",
        "outputId": "8242dba1-9569-4812-9485-b6f035d18e91",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"model\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " input_1 (InputLayer)        [(None, 224, 224, 3)]     0         \n",
            "                                                                 \n",
            " block1_conv1 (Conv2D)       (None, 224, 224, 64)      1792      \n",
            "                                                                 \n",
            " block1_conv2 (Conv2D)       (None, 224, 224, 64)      36928     \n",
            "                                                                 \n",
            " block1_pool (MaxPooling2D)  (None, 112, 112, 64)      0         \n",
            "                                                                 \n",
            " block2_conv1 (Conv2D)       (None, 112, 112, 128)     73856     \n",
            "                                                                 \n",
            " block2_conv2 (Conv2D)       (None, 112, 112, 128)     147584    \n",
            "                                                                 \n",
            " block2_pool (MaxPooling2D)  (None, 56, 56, 128)       0         \n",
            "                                                                 \n",
            " block3_conv1 (Conv2D)       (None, 56, 56, 256)       295168    \n",
            "                                                                 \n",
            " block3_conv2 (Conv2D)       (None, 56, 56, 256)       590080    \n",
            "                                                                 \n",
            " block3_conv3 (Conv2D)       (None, 56, 56, 256)       590080    \n",
            "                                                                 \n",
            " block3_conv4 (Conv2D)       (None, 56, 56, 256)       590080    \n",
            "                                                                 \n",
            " block3_pool (MaxPooling2D)  (None, 28, 28, 256)       0         \n",
            "                                                                 \n",
            " block4_conv1 (Conv2D)       (None, 28, 28, 512)       1180160   \n",
            "                                                                 \n",
            " block4_conv2 (Conv2D)       (None, 28, 28, 512)       2359808   \n",
            "                                                                 \n",
            " block4_conv3 (Conv2D)       (None, 28, 28, 512)       2359808   \n",
            "                                                                 \n",
            " block4_conv4 (Conv2D)       (None, 28, 28, 512)       2359808   \n",
            "                                                                 \n",
            " block4_pool (MaxPooling2D)  (None, 14, 14, 512)       0         \n",
            "                                                                 \n",
            " block5_conv1 (Conv2D)       (None, 14, 14, 512)       2359808   \n",
            "                                                                 \n",
            " block5_conv2 (Conv2D)       (None, 14, 14, 512)       2359808   \n",
            "                                                                 \n",
            " block5_conv3 (Conv2D)       (None, 14, 14, 512)       2359808   \n",
            "                                                                 \n",
            " block5_conv4 (Conv2D)       (None, 14, 14, 512)       2359808   \n",
            "                                                                 \n",
            " block5_pool (MaxPooling2D)  (None, 7, 7, 512)         0         \n",
            "                                                                 \n",
            " global_average_pooling2d (G  (None, 512)              0         \n",
            " lobalAveragePooling2D)                                          \n",
            "                                                                 \n",
            " dense (Dense)               (None, 1024)              525312    \n",
            "                                                                 \n",
            " batch_normalization (BatchN  (None, 1024)             4096      \n",
            " ormalization)                                                   \n",
            "                                                                 \n",
            " activation (Activation)     (None, 1024)              0         \n",
            "                                                                 \n",
            " dropout (Dropout)           (None, 1024)              0         \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 1024)              1049600   \n",
            "                                                                 \n",
            " batch_normalization_1 (Batc  (None, 1024)             4096      \n",
            " hNormalization)                                                 \n",
            "                                                                 \n",
            " activation_1 (Activation)   (None, 1024)              0         \n",
            "                                                                 \n",
            " dropout_1 (Dropout)         (None, 1024)              0         \n",
            "                                                                 \n",
            " dense_2 (Dense)             (None, 4)                 4100      \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 21,611,588\n",
            "Trainable params: 1,583,108\n",
            "Non-trainable params: 20,028,480\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "model.summary()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2023-06-07T13:52:55.955613Z",
          "iopub.status.busy": "2023-06-07T13:52:55.955240Z",
          "iopub.status.idle": "2023-06-07T13:52:55.977113Z",
          "shell.execute_reply": "2023-06-07T13:52:55.976234Z",
          "shell.execute_reply.started": "2023-06-07T13:52:55.955579Z"
        },
        "id": "bFC5Lvyedhf3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "aaa9b749-dd54-46df-ae72-249ffbd25b8c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:absl:`lr` is deprecated in Keras optimizer, please use `learning_rate` or use the legacy optimizer, e.g.,tf.keras.optimizers.legacy.Adam.\n"
          ]
        }
      ],
      "source": [
        "adam_opt=Adam(lr=0.00001, beta_1=0.6, beta_2=0.9, amsgrad=True)\n",
        "model.compile(optimizer= adam_opt, loss = 'categorical_crossentropy', metrics=['accuracy'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2023-06-07T13:53:08.506037Z",
          "iopub.status.busy": "2023-06-07T13:53:08.505467Z",
          "iopub.status.idle": "2023-06-07T14:04:38.227913Z",
          "shell.execute_reply": "2023-06-07T14:04:38.226848Z",
          "shell.execute_reply.started": "2023-06-07T13:53:08.506002Z"
        },
        "id": "gozZDjJfdhf4",
        "outputId": "8ac9be7a-6af3-4b11-a564-3f499ef87093",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 228
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training started it takes few minutes\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "name 'model' is not defined",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-3-c27d7474ed98>\u001b[0m in \u001b[0;36m<cell line: 5>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mstart_time\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m history = model.fit(\n\u001b[0m\u001b[1;32m      6\u001b[0m   \u001b[0mtraining_set\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m   \u001b[0msteps_per_epoch\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnb_train_samples\u001b[0m \u001b[0;34m//\u001b[0m \u001b[0mbatch_size\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'model' is not defined"
          ]
        }
      ],
      "source": [
        "import time\n",
        "print(\"Training started it takes few minutes\")\n",
        "start_time = time.time()\n",
        "\n",
        "history = model.fit(\n",
        "  training_set,\n",
        "  steps_per_epoch = nb_train_samples // batch_size,\n",
        "  epochs = epochs,\n",
        "  validation_data = val_set,\n",
        "  validation_steps = nb_validation_samples // batch_size,\n",
        "  callbacks = [early, reduce])\n",
        "\n",
        "print(\"successfully completed the traing session\")\n",
        "print(\"--- took %d:%.2d minutes ---\" % divmod(time.time() - start_time, 60))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2023-06-07T14:04:45.605541Z",
          "iopub.status.busy": "2023-06-07T14:04:45.605157Z",
          "iopub.status.idle": "2023-06-07T14:04:46.374961Z",
          "shell.execute_reply": "2023-06-07T14:04:46.373901Z",
          "shell.execute_reply.started": "2023-06-07T14:04:45.605508Z"
        },
        "id": "BrcWvDSxdhf4"
      },
      "outputs": [],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "plt.style.use(\"ggplot\")\n",
        "\n",
        "plt.plot(history.history['accuracy'])\n",
        "plt.plot(history.history['val_accuracy'])\n",
        "plt.title('model accuracy')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.xlabel('Epoch')\n",
        "plt.legend(['Training Acc', 'Test Acc'], loc='upper left')\n",
        "plt.show()\n",
        "\n",
        "# summarize history for loss\n",
        "plt.plot(history.history['loss'])\n",
        "plt.plot(history.history['val_loss'])\n",
        "plt.title('model loss')\n",
        "plt.ylabel('Loss')\n",
        "plt.xlabel('Epoch')\n",
        "plt.legend(['Training Loss', 'Test Loss'], loc='upper left')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2023-06-07T14:04:55.519641Z",
          "iopub.status.busy": "2023-06-07T14:04:55.519195Z",
          "iopub.status.idle": "2023-06-07T14:05:00.758171Z",
          "shell.execute_reply": "2023-06-07T14:05:00.752810Z",
          "shell.execute_reply.started": "2023-06-07T14:04:55.519606Z"
        },
        "id": "ek3unkt5dhf5",
        "outputId": "b2baba3f-a7db-4881-fe9f-b59532113520"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Validation Score:  0.24223266541957855\n",
            "Validation Accuracy:  0.9606249928474426\n"
          ]
        }
      ],
      "source": [
        "score = model.evaluate_generator(val_set, steps=50)\n",
        "\n",
        "print ('Validation Score: ', score[0])\n",
        "print ('Validation Accuracy: ',score[1])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.status.busy": "2023-06-07T13:20:56.085911Z",
          "iopub.status.idle": "2023-06-07T13:20:56.086922Z",
          "shell.execute_reply": "2023-06-07T13:20:56.086711Z",
          "shell.execute_reply.started": "2023-06-07T13:20:56.086690Z"
        },
        "id": "oeQE1y8zdhf5"
      },
      "outputs": [],
      "source": [
        "# accuracy_score = model.evaluate_generator(test_set, steps=50)\n",
        "# print(\"Accuracy Score:\", accuracy_score[0])\n",
        "# print(\"Accuracy:\",accuracy_score[1])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2023-06-07T14:05:03.568333Z",
          "iopub.status.busy": "2023-06-07T14:05:03.567936Z",
          "iopub.status.idle": "2023-06-07T14:05:09.968116Z",
          "shell.execute_reply": "2023-06-07T14:05:09.967136Z",
          "shell.execute_reply.started": "2023-06-07T14:05:03.568298Z"
        },
        "id": "EkKfq3o9dhf6"
      },
      "outputs": [],
      "source": [
        "_, acc = model.evaluate(val_set, verbose=1)\n",
        "print('> %.3f' % (acc * 100.0))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2023-06-07T14:06:16.900095Z",
          "iopub.status.busy": "2023-06-07T14:06:16.899724Z",
          "iopub.status.idle": "2023-06-07T14:06:17.126203Z",
          "shell.execute_reply": "2023-06-07T14:06:17.125265Z",
          "shell.execute_reply.started": "2023-06-07T14:06:16.900063Z"
        },
        "id": "CnbNDNssdhf6"
      },
      "outputs": [],
      "source": [
        "model.save(\"Test\" + '.h5')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Vs8PQjfodhf6"
      },
      "source": [
        "### Model Evaluation\n",
        "\n",
        "The evaluate_model function loads a trained model from a saved file and evaluates it using the validation generator. It calculates overall metrics (accuracy, precision, recall, F1-score) and class-specific metrics. These metrics provide a detailed view of model performance."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2023-06-07T14:06:21.759167Z",
          "iopub.status.busy": "2023-06-07T14:06:21.758569Z",
          "iopub.status.idle": "2023-06-07T14:06:21.773584Z",
          "shell.execute_reply": "2023-06-07T14:06:21.772650Z",
          "shell.execute_reply.started": "2023-06-07T14:06:21.759125Z"
        },
        "id": "5CsNqVdGdhgG"
      },
      "outputs": [],
      "source": [
        "def evaluate_model(saved_model_path, validation_generator):\n",
        "    # Load the saved model\n",
        "    loaded_model = tf.keras.models.load_model(saved_model_path)\n",
        "\n",
        "    # Evaluate the model on the test set\n",
        "    test_loss, test_accuracy = loaded_model.evaluate(validation_generator)\n",
        "    print('Test Loss:', test_loss)\n",
        "    print('Test Accuracy:', test_accuracy)\n",
        "\n",
        "    # Perform thorough evaluation\n",
        "    y_true = validation_generator.classes\n",
        "    y_pred = loaded_model.predict(validation_generator)\n",
        "    y_pred_classes = np.argmax(y_pred, axis=1)\n",
        "\n",
        "    # Calculate overall metrics\n",
        "    accuracy = metrics.accuracy_score(y_true, y_pred_classes)\n",
        "    precision = metrics.precision_score(y_true, y_pred_classes, average='weighted')\n",
        "    recall = metrics.recall_score(y_true, y_pred_classes, average='weighted')\n",
        "    f1_score = metrics.f1_score(y_true, y_pred_classes, average='weighted')\n",
        "\n",
        "    print('Overall Metrics:')\n",
        "    print('Accuracy:', accuracy)\n",
        "    print('Precision:', precision)\n",
        "    print('Recall:', recall)\n",
        "    print('F1-Score:', f1_score)\n",
        "\n",
        "    # Calculate metrics per class\n",
        "    class_metrics = metrics.classification_report(y_true, y_pred_classes, target_names=validation_generator.class_indices.keys())\n",
        "    print('\\nMetrics per Class:')\n",
        "    print(class_metrics)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2023-06-07T14:06:35.386348Z",
          "iopub.status.busy": "2023-06-07T14:06:35.385448Z",
          "iopub.status.idle": "2023-06-07T14:06:46.120584Z",
          "shell.execute_reply": "2023-06-07T14:06:46.119604Z",
          "shell.execute_reply.started": "2023-06-07T14:06:35.386310Z"
        },
        "id": "C2iWfx06dhgH"
      },
      "outputs": [],
      "source": [
        "import sklearn.metrics as metrics\n",
        "saved_model_path = '/content/gdrive/MyDrive/Colab Notebooks/Test.h5'\n",
        "\n",
        "evaluate_model(saved_model_path, val_set)\n",
        "# plot_training_history(history)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "esz3UlJadhgH"
      },
      "source": [
        "## Build a function to predict random images from the internet\n",
        "### Predicting on New Data\n",
        "The predict_images_from_urls function predicts the class of new images provided via URLs. It fetches the images, preprocesses them, and feeds them into the model for prediction. The function also displays the images along with their predicted class. This function allows you to easily use the model to make predictions on new, unseen data."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2023-06-07T14:08:04.315072Z",
          "iopub.status.busy": "2023-06-07T14:08:04.314702Z",
          "iopub.status.idle": "2023-06-07T14:08:04.326667Z",
          "shell.execute_reply": "2023-06-07T14:08:04.325408Z",
          "shell.execute_reply.started": "2023-06-07T14:08:04.315045Z"
        },
        "id": "4ARWBnsLdhgH"
      },
      "outputs": [],
      "source": [
        "def predict_images_from_urls(model, classes, image_urls, target_size):\n",
        "    num_images = len(image_urls)\n",
        "    num_rows = (num_images + 3) // 4\n",
        "\n",
        "    fig, axs = plt.subplots(nrows=num_rows, ncols=4, figsize=(12, 6))\n",
        "\n",
        "    for i, image_url in enumerate(image_urls):\n",
        "        row = i // 4\n",
        "        col = i % 4\n",
        "\n",
        "        # Download the image from the URL\n",
        "        response = requests.get(image_url)\n",
        "\n",
        "        if response.status_code == 200:\n",
        "            try:\n",
        "                image = Image.open(BytesIO(response.content))\n",
        "                image = image.convert(\"RGB\")  # Convert to RGB format\n",
        "\n",
        "                # Resize the image\n",
        "                image = image.resize(target_size)\n",
        "\n",
        "                # Preprocess the image\n",
        "                image_array = np.array(image) / 255.0\n",
        "                image_array = np.expand_dims(image_array, axis=0)\n",
        "\n",
        "                # Make the prediction\n",
        "                prediction = model.predict(image_array)\n",
        "                predicted_class_index = np.argmax(prediction)\n",
        "\n",
        "                # Create a reverse dictionary of classes\n",
        "                reverse_classes = {v: k for k, v in classes.items()}\n",
        "\n",
        "                # Get the predicted class label\n",
        "                predicted_class = reverse_classes[predicted_class_index]\n",
        "\n",
        "                # Display the image and predicted class\n",
        "                axs[row, col].imshow(image)\n",
        "                axs[row, col].axis('off')\n",
        "                axs[row, col].set_title(f\"Predicted Class: {predicted_class}\")\n",
        "            except (UnidentifiedImageError, ImageDecompressionBombError) as e:\n",
        "                print(f\"Error processing image: {image_url}\\n{e}\")\n",
        "\n",
        "    # Remove any empty subplots\n",
        "    for i in range(num_images, num_rows * 4):\n",
        "        row = i // 4\n",
        "        col = i % 4\n",
        "        fig.delaxes(axs[row, col])\n",
        "\n",
        "    fig.tight_layout()\n",
        "    plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2023-06-07T14:08:07.517115Z",
          "iopub.status.busy": "2023-06-07T14:08:07.516749Z",
          "iopub.status.idle": "2023-06-07T14:08:07.522330Z",
          "shell.execute_reply": "2023-06-07T14:08:07.521287Z",
          "shell.execute_reply.started": "2023-06-07T14:08:07.517083Z"
        },
        "id": "T509WI8gdhgI"
      },
      "outputs": [],
      "source": [
        "import requests\n",
        "from PIL import Image, UnidentifiedImageError\n",
        "from io import BytesIO"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gxA7ldMedhgI"
      },
      "outputs": [],
      "source": [
        "# Example list of image URLs\n",
        "image_urls = [\n",
        "    'https://previews.123rf.com/images/vampy1/vampy12007/vampy1200700021/151785736-satellite-view-of-namibia-desert-landscape-and-mountains-nature-and-aerial-view-global-warming.jpg',\n",
        "    'https://thumbs.dreamstime.com/b/desert-land-satellite-photo-topography-aerial-top-view-earth-surface-as-abstract-background-nature-pattern-southern-sand-229623767.jpg',\n",
        "    'https://cdn.mos.cms.futurecdn.net/Fry8CGJGgP6vgXBupGTqwT.jpg',\n",
        "    'https://miro.medium.com/v2/resize:fit:1000/0*59yUF7X3jRrcrUnu.jpg',\n",
        "    'https://media.rff.org/images/resized_erie_oli_2015209_lrg_40.2e16d0ba.fill-1270x1120.jpg',\n",
        "    'https://img.rasset.ie/0014aa0a-500.jpg',\n",
        "    'https://www.nasa.gov/images/content/624724main_pia15399-673.jpg',\n",
        "    'https://cdn.mos.cms.futurecdn.net/aa3h9RKfsPcS8sPwyzSgu9-320-80.jpg',\n",
        "]\n",
        "\n",
        "# Load the saved custom model and classes\n",
        "loaded_model = tf.keras.models.load_model(saved_model_path)\n",
        "classes = {'cloudy':0, 'desert':1, 'green_area':2, 'water':3}\n",
        "target_size = (224, 224)\n",
        "\n",
        "# Predict and display the images from the URLs\n",
        "predict_images_from_urls(loaded_model, classes, image_urls, target_size)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7zr_gBjLdhgJ"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "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.9"
    },
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "accelerator": "GPU"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}