Car_Make_Model_Detection_Sai_Kiran_Cropped_Images.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/belanasaikiran/Team-6-Big-Data-Project/blob/main/Car_Make_Model_Detection_Sai_Kiran_Cropped_Images.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PaAXM_g_gXEK"
      },
      "source": [
        "# Car Model Detection:\n",
        "\n",
        "### Team 6:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3uEvKsqaRA77"
      },
      "source": [
        "## Todo:\n",
        "- [x] Import the DataSet.\n",
        "- [x] Preprocessing\n",
        "- [ ] Feature Selection\n",
        "- [ ] Model Selection\n",
        "- [ ] Training the Model"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# !rm -r DataSet/ A Simple reset call to delete DataSet folder. Use it at caution"
      ],
      "metadata": {
        "id": "Clhe4owIAI-z"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sTXcmwR0REvG",
        "outputId": "596ac0f2-179c-409d-b471-5cd5ac31e2a5"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/gdrive\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/gdrive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "KTEuipBbc1rR"
      },
      "outputs": [],
      "source": [
        "!unzip gdrive/MyDrive/DataSet/DataSet.zip > /dev/null # output to null"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Checking if image dataset is loaded"
      ],
      "metadata": {
        "id": "Z_-Q-VBLs_xw"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QDPKza5ud7kv"
      },
      "outputs": [],
      "source": [
        "import tensorflow as tf\n",
        "img = tf.keras.preprocessing.image.load_img('DataSet/images/cars_train/00001.jpg')\n",
        "img"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(img.width, img.height)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KnPpvSJ3mccY",
        "outputId": "4a77d785-5620-43b1-bc4e-08f3dc488f41"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "600 400\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "cwPChQdPfwGQ"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import pandas as pd"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "p7yXq6FUIvtn"
      },
      "outputs": [],
      "source": [
        "metadata = pd.read_csv(\"DataSet/data/meta.csv\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "id": "vnySNtxYI8fW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "73cff832-179b-44ec-8361-e07f770cb457"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Meta Data: \n",
            "\n",
            "Head:\n",
            "   Unnamed: 0                  class_name\n",
            "0           1  AM General Hummer SUV 2000\n",
            "1           2         Acura RL Sedan 2012\n",
            "2           3         Acura TL Sedan 2012\n",
            "3           4        Acura TL Type-S 2008\n",
            "4           5        Acura TSX Sedan 2012\n",
            "\n",
            " Info:\n",
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 196 entries, 0 to 195\n",
            "Data columns (total 2 columns):\n",
            " #   Column      Non-Null Count  Dtype \n",
            "---  ------      --------------  ----- \n",
            " 0   Unnamed: 0  196 non-null    int64 \n",
            " 1   class_name  196 non-null    object\n",
            "dtypes: int64(1), object(1)\n",
            "memory usage: 3.2+ KB\n",
            "None\n",
            "\n",
            " Columns:\n",
            "Index(['Unnamed: 0', 'class_name'], dtype='object')\n"
          ]
        }
      ],
      "source": [
        "print(\"Meta Data: \\n\")\n",
        "print(\"Head:\")\n",
        "print(metadata.head())\n",
        "print(\"\\n Info:\")\n",
        "print(metadata.info())\n",
        "print(\"\\n Columns:\")\n",
        "print(metadata.columns)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Load the Train & Test Datasets"
      ],
      "metadata": {
        "id": "idyYVAlP9WcY"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Train Data"
      ],
      "metadata": {
        "id": "JfY7N0zhvFnq"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "id": "tsbx5WOwJH_E",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3cb28f79-058c-483f-c904-d2b97af39eda"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            " Train Data: \n",
            "Head: \n",
            "\n",
            "Describe:\n",
            "         Unnamed: 0            x1            y1            x2            y2  \\\n",
            "count  12948.000000  12948.000000  12948.000000  12948.000000  12948.000000   \n",
            "mean    3451.892339     64.701189    108.592833    638.598625    416.670683   \n",
            "std     2200.262018     81.774972    106.195279    409.613163    272.818630   \n",
            "min        0.000000      1.000000      1.000000     76.000000     41.000000   \n",
            "25%     1618.000000     19.000000     42.000000    394.000000    250.000000   \n",
            "50%     3236.500000     39.000000     80.000000    572.000000    361.000000   \n",
            "75%     4906.250000     78.000000    138.000000    742.250000    475.000000   \n",
            "max     8143.000000   1648.000000   1651.000000   5205.000000   3389.000000   \n",
            "\n",
            "              class  \n",
            "count  12948.000000  \n",
            "mean      99.008573  \n",
            "std       56.540538  \n",
            "min        1.000000  \n",
            "25%       50.000000  \n",
            "50%       99.000000  \n",
            "75%      148.000000  \n",
            "max      196.000000  \n",
            "\n",
            "Info:\n",
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 12948 entries, 0 to 12947\n",
            "Data columns (total 7 columns):\n",
            " #   Column      Non-Null Count  Dtype \n",
            "---  ------      --------------  ----- \n",
            " 0   Unnamed: 0  12948 non-null  int64 \n",
            " 1   x1          12948 non-null  int64 \n",
            " 2   y1          12948 non-null  int64 \n",
            " 3   x2          12948 non-null  int64 \n",
            " 4   y2          12948 non-null  int64 \n",
            " 5   class       12948 non-null  int64 \n",
            " 6   fname       12948 non-null  object\n",
            "dtypes: int64(6), object(1)\n",
            "memory usage: 708.2+ KB\n",
            "None\n",
            "\n",
            "Columns:\n",
            "Index(['Unnamed: 0', 'x1', 'y1', 'x2', 'y2', 'class', 'fname'], dtype='object')\n",
            "\n",
            "Shape:\n",
            "(12948, 7)\n"
          ]
        }
      ],
      "source": [
        "train_data = pd.read_csv(\"DataSet/data/train.csv\")\n",
        "\n",
        "print(\"\\n Train Data: \\nHead: \")\n",
        "train_data.head()\n",
        "print(\"\\nDescribe:\")\n",
        "print(train_data.describe())\n",
        "print(\"\\nInfo:\")\n",
        "print(train_data.info())\n",
        "print(\"\\nColumns:\")\n",
        "print(train_data.columns)\n",
        "print(\"\\nShape:\")\n",
        "print(train_data.shape)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Test Data"
      ],
      "metadata": {
        "id": "AzlLdnMvvHuH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "test_data = pd.read_csv(\"DataSet/data/test.csv\") #load test data\n",
        "\n",
        "\n",
        "print(\"\\n Train Data: \\nHead: \")\n",
        "test_data.head()\n",
        "print(\"\\nDescribe:\")\n",
        "print(test_data.describe())\n",
        "print(\"\\nInfo:\")\n",
        "print(test_data.info())\n",
        "print(\"\\nColumns:\")\n",
        "print(test_data.columns)\n",
        "print(\"\\nShape:\")\n",
        "print(test_data.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tE312kT-9j61",
        "outputId": "3e8cff2a-01fb-4c85-8b77-6459c3a9422b"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            " Train Data: \n",
            "Head: \n",
            "\n",
            "Describe:\n",
            "        Unnamed: 0           x1           y1           x2           y2  \\\n",
            "count  3237.000000  3237.000000  3237.000000  3237.000000  3237.000000   \n",
            "mean   1618.000000    66.103491   106.835650   639.691999   417.637010   \n",
            "std     934.585737    84.198376   106.736782   417.499266   279.758425   \n",
            "min       0.000000     1.000000     1.000000    72.000000    49.000000   \n",
            "25%     809.000000    18.000000    40.000000   389.000000   242.000000   \n",
            "50%    1618.000000    39.000000    77.000000   573.000000   363.000000   \n",
            "75%    2427.000000    80.000000   135.000000   763.000000   487.000000   \n",
            "max    3236.000000   872.000000  1311.000000  7224.000000  3835.000000   \n",
            "\n",
            "             class  \n",
            "count  3237.000000  \n",
            "mean     98.852950  \n",
            "std      56.359186  \n",
            "min       1.000000  \n",
            "25%      51.000000  \n",
            "50%      99.000000  \n",
            "75%     148.000000  \n",
            "max     196.000000  \n",
            "\n",
            "Info:\n",
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 3237 entries, 0 to 3236\n",
            "Data columns (total 7 columns):\n",
            " #   Column      Non-Null Count  Dtype \n",
            "---  ------      --------------  ----- \n",
            " 0   Unnamed: 0  3237 non-null   int64 \n",
            " 1   x1          3237 non-null   int64 \n",
            " 2   y1          3237 non-null   int64 \n",
            " 3   x2          3237 non-null   int64 \n",
            " 4   y2          3237 non-null   int64 \n",
            " 5   class       3237 non-null   int64 \n",
            " 6   fname       3237 non-null   object\n",
            "dtypes: int64(6), object(1)\n",
            "memory usage: 177.1+ KB\n",
            "None\n",
            "\n",
            "Columns:\n",
            "Index(['Unnamed: 0', 'x1', 'y1', 'x2', 'y2', 'class', 'fname'], dtype='object')\n",
            "\n",
            "Shape:\n",
            "(3237, 7)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Let's get an Average of images available per class**\n",
        "\n",
        "We should get around 66 images per class with the `stanford car dataset`"
      ],
      "metadata": {
        "id": "RIWc3R9NvKPo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "counter = 0 #no. of images available per class in our dataset\n",
        "average = 0 #average no. of images availabe for all our classes for training\n",
        "\n",
        "for y in range(1, 197):\n",
        "  for x in train_data['class']:\n",
        "    if (x == y):\n",
        "      # print(\"x, y\", x, y)\n",
        "      counter = counter+1;\n",
        "  average = (average + counter)/y\n",
        "\n",
        "\n",
        "print(\"Average:\", average)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y020KOLKHJdV",
        "outputId": "c5cf0243-bb21-4881-a03c-20bf7be24f6b"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Average: 66.4000624886608\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Image Resising and Fixing the `fname` for one of the value in CSV"
      ],
      "metadata": {
        "id": "yuTIayHPvZ8B"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from PIL import Image\n",
        "import os"
      ],
      "metadata": {
        "id": "2hVvvxzUaIzv"
      },
      "execution_count": 26,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# fix the file names here\n",
        "train_data.loc[9998, 'fname'] = '09999.jpg'"
      ],
      "metadata": {
        "id": "Sc9g6SkPvZi0"
      },
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The below function does the resizing of all our images to the specified resolution"
      ],
      "metadata": {
        "id": "upVNeo7Fdnh7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the resize function\n",
        "\n",
        "def resize_image_and_bbox(image_path, new_size, bbox):\n",
        "  image = Image.open(image_path)\n",
        "  original_size = image.size\n",
        "\n",
        "\n",
        "  resized_image = image.resize(new_size)\n",
        "\n",
        "  scale_x = new_size[0] / original_size[0]\n",
        "  scale_y = new_size[1] / original_size[1]\n",
        "\n",
        "  resized_bbox = np.array(bbox) * [scale_x, scale_y, scale_x, scale_y]\n",
        "\n",
        "  # Uncomment to verify the parameters when using this function\n",
        "  # if(image_path == 'DataSet/images/cars_train/00001.jpg'):\n",
        "  #   print(\"Image Size: \", original_size)\n",
        "  #   print(\"Scale_X: \", scale_x)\n",
        "  #   print(\"np.array(bbox): \", np.array(bbox))\n",
        "  #   print(\"Original bbox: \", bbox)\n",
        "  #   print(\"Resized_bbox: \", resized_bbox.tolist())\n",
        "\n",
        "  return resized_image, resized_bbox.tolist()"
      ],
      "metadata": {
        "id": "o5iTcu38aQ6g"
      },
      "execution_count": 28,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "resizing the images to 128x128 resolution"
      ],
      "metadata": {
        "id": "yyl_FArBdgyU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "new_size = (128,128)"
      ],
      "metadata": {
        "id": "rdvfOEgWa92E"
      },
      "execution_count": 66,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Creating a variable for resized data that we can use to update the bounding box information"
      ],
      "metadata": {
        "id": "eAnYLMmhzNGl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "train_data_resized = train_data.copy()\n",
        "train_data_resized.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ARS9Fjz3x7HW",
        "outputId": "ac25fd52-492a-4ee4-a20c-f1d456fdc9be"
      },
      "execution_count": 67,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(12948, 7)"
            ]
          },
          "metadata": {},
          "execution_count": 67
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "ld-wBGbGdnA8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# train_data.head(10000)"
      ],
      "metadata": {
        "id": "ZsefLvqVrPWz"
      },
      "execution_count": 68,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## ***Before I resize the images, I wanna see the small resolution image available in the dataset to avoid any mis handling of images during the training phase of dataset***"
      ],
      "metadata": {
        "id": "oiQaIjuFvx87"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "temp_width = 190000 # some random value which should be high to compare and get the smallest width(px size) of the available images in the dataset\n",
        "temp_height = 19000\n",
        "\n",
        "smallest_width_image = \"\"\n",
        "smallest_height_image = \"\"\n",
        "\n",
        "\n",
        "def ImageSizeChecker():\n",
        "  global temp_width, temp_height, smallest_height_image, smallest_width_image\n",
        "  # print(train_data['fname'][0])\n",
        "  for i in range(1, 12948):\n",
        "    image_path = 'DataSet/images/cars_train/' + train_data['fname'][i]\n",
        "    img = tf.keras.preprocessing.image.load_img(image_path)\n",
        "    # print(img.width, img.height)\n",
        "    if (img.width < temp_width):\n",
        "      temp_width = img.width\n",
        "      smallest_width_image = train_data['fname'][i]\n",
        "      # print(\"Image Width Size for \", i, \"th image: \",  temp_width)\n",
        "    if (img.height < temp_height):\n",
        "      temp_height = img.width\n",
        "      smallest_height_image = train_data['fname'][i]\n",
        "      # print(\"Image height Size for \", i, \"th image: \",  temp_width)\n",
        "    if i == 12947:\n",
        "      print(\"END\")\n",
        "      print(temp_width, temp_height)\n",
        "      print(smallest_width_image, smallest_height_image)\n",
        "\n",
        "\n",
        "ImageSizeChecker()\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WW2GcD80v9Hk",
        "outputId": "46060ae2-70bb-4d4a-e041-0ec35d461e75"
      },
      "execution_count": 62,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "END\n",
            "78 96\n",
            "00097.jpg 12942.jpg\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Checking which images have low resolution"
      ],
      "metadata": {
        "id": "0bLXDFLc0V8F"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "small_image_1 = 'DataSet/images/cars_train/' + train_data['fname'][96]\n",
        "print(\"train_data name\", train_data['fname'][96])\n",
        "img1 = tf.keras.preprocessing.image.load_img(small_image_1)\n",
        "\n",
        "\n",
        "small_image_2 = 'DataSet/images/cars_train/' + train_data['fname'][12941]\n",
        "print(\"train_data name\", train_data['fname'][12941])\n",
        "img2 = tf.keras.preprocessing.image.load_img(small_image_2)\n",
        "img1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 111
        },
        "id": "g1LsstB40Zq0",
        "outputId": "4feeb716-8311-4400-aacb-c7e17af780a1"
      },
      "execution_count": 63,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "train_data name 00097.jpg\n",
            "train_data name 12942.jpg\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=78x58>"
            ],
            "image/png": "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\n"
          },
          "metadata": {},
          "execution_count": 63
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "img2"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 81
        },
        "id": "I5mUKdTv2UVe",
        "outputId": "10eb7e73-303b-4cf8-b08b-e361bb244d2d"
      },
      "execution_count": 64,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=96x64>"
            ],
            "image/png": "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\n"
          },
          "metadata": {},
          "execution_count": 64
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Resizing the Training DataSet images to 128x128 pixels:\n",
        "\n",
        "\n",
        "\n",
        "*   Read the dataset from CSV file\n",
        "*   Iterate over each image, resize it and its bounding box in CSV\n",
        "*   Save the resize image\n",
        "*   Update the bounding box coordinates in the new dataframe called `train_data_resized`.\n",
        "\n",
        "> Resizing the dataset helps in training the model much faster as we deal with larger datasets\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "Olrf1iNG2cE7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# dataset folder\n",
        "dataset_image_folder = 'DataSet/images/cars_train/'\n",
        "# process each image - resizing\n",
        "for index, row in train_data.iterrows():\n",
        "  image_path = dataset_image_folder + row['fname']\n",
        "  bbox = [row['x1'], row['y1'], row['x2'], row['y2']]\n",
        "\n",
        "  # resize image and box\n",
        "  resized_image, resized_bbox = resize_image_and_bbox(image_path, new_size, bbox)\n",
        "\n",
        "  #save the resized image\n",
        "  save_path ='DataSet/resized_images' #setting a custom path for storing the resized data\n",
        "  if not os.path.exists(save_path):\n",
        "    os.makedirs(save_path)\n",
        "\n",
        "  filename = os.path.basename(image_path)\n",
        "  resized_image.save(os.path.join(save_path, filename))\n",
        "\n",
        "  # update the dataframe with the resized bbox coordinates - updating the train_data_resized dataframe object\n",
        "  train_data_resized.loc[index, ['x1', 'y1', 'x2', 'y2']] = resized_bbox\n",
        "\n",
        "\n",
        "# Image Cropper Function\n",
        "def ImageCropper(save_path, class_name, image_path, x1, y1,x2, y2):\n",
        "  im = Image.open(image_path);\n",
        "  croppedImage = im.crop((x1, y1, x2, y2))\n",
        "\n",
        "  # print(\"Cropping Finished\")\n",
        "  filename = os.path.basename(image_path)\n",
        "  # class_image_save_path = save_path + \"/\" + str(class_name) + \"/\" # this line separates all the images to separate folders according to the class no.\n",
        "  class_image_save_path = save_path + \"/\"\n",
        "\n",
        "  # print(class_image_save_path+filename)\n",
        "\n",
        "  #save the resized image\n",
        "  if not os.path.exists(class_image_save_path):\n",
        "    os.makedirs(class_image_save_path)\n",
        "\n",
        "  croppedImage.save(os.path.join(class_image_save_path, filename))\n",
        "\n"
      ],
      "metadata": {
        "id": "qnJv3oK9bFCM"
      },
      "execution_count": 70,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#!ls DataSet/images/cars_train #uncomment to see the show the no. of images we have"
      ],
      "metadata": {
        "id": "ZjwpyPTcdGC0"
      },
      "execution_count": 71,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#!ls DataSet/resized_images/ #let's see the count of resized images."
      ],
      "metadata": {
        "id": "DuPYULGQtLtz"
      },
      "execution_count": 72,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_data_resized.head()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "id": "FXvydDqWw3uV",
        "outputId": "82d062c2-b2c7-49cc-f290-0c7ea0406c65"
      },
      "execution_count": 73,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "   Unnamed: 0         x1         y1          x2          y2  class      fname\n",
              "0           0   8.320000  37.120000  121.386667  120.000000     14  00001.jpg\n",
              "1           1   5.120000  21.997037  123.448889  111.312593      3  00002.jpg\n",
              "2           2  17.000000  29.066667  120.200000  101.600000     91  00003.jpg\n",
              "3           3  37.851429  36.294372   90.453333  101.217893    134  00004.jpg\n",
              "4           4  12.444444  42.666667  118.222222  117.333333    106  00005.jpg"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-3b6b6822-386e-4b4a-bd0e-6afd6fe4c310\" class=\"colab-df-container\">\n",
              "    <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Unnamed: 0</th>\n",
              "      <th>x1</th>\n",
              "      <th>y1</th>\n",
              "      <th>x2</th>\n",
              "      <th>y2</th>\n",
              "      <th>class</th>\n",
              "      <th>fname</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>0</td>\n",
              "      <td>8.320000</td>\n",
              "      <td>37.120000</td>\n",
              "      <td>121.386667</td>\n",
              "      <td>120.000000</td>\n",
              "      <td>14</td>\n",
              "      <td>00001.jpg</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>1</td>\n",
              "      <td>5.120000</td>\n",
              "      <td>21.997037</td>\n",
              "      <td>123.448889</td>\n",
              "      <td>111.312593</td>\n",
              "      <td>3</td>\n",
              "      <td>00002.jpg</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>2</td>\n",
              "      <td>17.000000</td>\n",
              "      <td>29.066667</td>\n",
              "      <td>120.200000</td>\n",
              "      <td>101.600000</td>\n",
              "      <td>91</td>\n",
              "      <td>00003.jpg</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>3</td>\n",
              "      <td>37.851429</td>\n",
              "      <td>36.294372</td>\n",
              "      <td>90.453333</td>\n",
              "      <td>101.217893</td>\n",
              "      <td>134</td>\n",
              "      <td>00004.jpg</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>4</td>\n",
              "      <td>12.444444</td>\n",
              "      <td>42.666667</td>\n",
              "      <td>118.222222</td>\n",
              "      <td>117.333333</td>\n",
              "      <td>106</td>\n",
              "      <td>00005.jpg</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "    <div class=\"colab-df-buttons\">\n",
              "\n",
              "  <div class=\"colab-df-container\">\n",
              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-3b6b6822-386e-4b4a-bd0e-6afd6fe4c310')\"\n",
              "            title=\"Convert this dataframe to an interactive table.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
              "  </svg>\n",
              "    </button>\n",
              "\n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    .colab-df-buttons div {\n",
              "      margin-bottom: 4px;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "    <script>\n",
              "      const buttonEl =\n",
              "        document.querySelector('#df-3b6b6822-386e-4b4a-bd0e-6afd6fe4c310 button.colab-df-convert');\n",
              "      buttonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "      async function convertToInteractive(key) {\n",
              "        const element = document.querySelector('#df-3b6b6822-386e-4b4a-bd0e-6afd6fe4c310');\n",
              "        const dataTable =\n",
              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                    [key], {});\n",
              "        if (!dataTable) return;\n",
              "\n",
              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "          + ' to learn more about interactive tables.';\n",
              "        element.innerHTML = '';\n",
              "        dataTable['output_type'] = 'display_data';\n",
              "        await google.colab.output.renderOutput(dataTable, element);\n",
              "        const docLink = document.createElement('div');\n",
              "        docLink.innerHTML = docLinkHtml;\n",
              "        element.appendChild(docLink);\n",
              "      }\n",
              "    </script>\n",
              "  </div>\n",
              "\n",
              "\n",
              "<div id=\"df-0e479662-47b7-4d8e-95fe-f3e44fb4efcd\">\n",
              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-0e479662-47b7-4d8e-95fe-f3e44fb4efcd')\"\n",
              "            title=\"Suggest charts\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "     width=\"24px\">\n",
              "    <g>\n",
              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
              "    </g>\n",
              "</svg>\n",
              "  </button>\n",
              "\n",
              "<style>\n",
              "  .colab-df-quickchart {\n",
              "      --bg-color: #E8F0FE;\n",
              "      --fill-color: #1967D2;\n",
              "      --hover-bg-color: #E2EBFA;\n",
              "      --hover-fill-color: #174EA6;\n",
              "      --disabled-fill-color: #AAA;\n",
              "      --disabled-bg-color: #DDD;\n",
              "  }\n",
              "\n",
              "  [theme=dark] .colab-df-quickchart {\n",
              "      --bg-color: #3B4455;\n",
              "      --fill-color: #D2E3FC;\n",
              "      --hover-bg-color: #434B5C;\n",
              "      --hover-fill-color: #FFFFFF;\n",
              "      --disabled-bg-color: #3B4455;\n",
              "      --disabled-fill-color: #666;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart {\n",
              "    background-color: var(--bg-color);\n",
              "    border: none;\n",
              "    border-radius: 50%;\n",
              "    cursor: pointer;\n",
              "    display: none;\n",
              "    fill: var(--fill-color);\n",
              "    height: 32px;\n",
              "    padding: 0;\n",
              "    width: 32px;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart:hover {\n",
              "    background-color: var(--hover-bg-color);\n",
              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "    fill: var(--button-hover-fill-color);\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart-complete:disabled,\n",
              "  .colab-df-quickchart-complete:disabled:hover {\n",
              "    background-color: var(--disabled-bg-color);\n",
              "    fill: var(--disabled-fill-color);\n",
              "    box-shadow: none;\n",
              "  }\n",
              "\n",
              "  .colab-df-spinner {\n",
              "    border: 2px solid var(--fill-color);\n",
              "    border-color: transparent;\n",
              "    border-bottom-color: var(--fill-color);\n",
              "    animation:\n",
              "      spin 1s steps(1) infinite;\n",
              "  }\n",
              "\n",
              "  @keyframes spin {\n",
              "    0% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "      border-left-color: var(--fill-color);\n",
              "    }\n",
              "    20% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    30% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    40% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    60% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    80% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "    90% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "  }\n",
              "</style>\n",
              "\n",
              "  <script>\n",
              "    async function quickchart(key) {\n",
              "      const quickchartButtonEl =\n",
              "        document.querySelector('#' + key + ' button');\n",
              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
              "      try {\n",
              "        const charts = await google.colab.kernel.invokeFunction(\n",
              "            'suggestCharts', [key], {});\n",
              "      } catch (error) {\n",
              "        console.error('Error during call to suggestCharts:', error);\n",
              "      }\n",
              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
              "    }\n",
              "    (() => {\n",
              "      let quickchartButtonEl =\n",
              "        document.querySelector('#df-0e479662-47b7-4d8e-95fe-f3e44fb4efcd button');\n",
              "      quickchartButtonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "    })();\n",
              "  </script>\n",
              "</div>\n",
              "    </div>\n",
              "  </div>\n"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "dataframe",
              "variable_name": "train_data_resized",
              "summary": "{\n  \"name\": \"train_data_resized\",\n  \"rows\": 12948,\n  \"fields\": [\n    {\n      \"column\": \"Unnamed: 0\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 2200,\n        \"min\": 0,\n        \"max\": 8143,\n        \"num_unique_values\": 8144,\n        \"samples\": [\n          7437,\n          483,\n          7598\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"x1\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 9.448086288761314,\n        \"min\": 0.041666666666666664,\n        \"max\": 82.72,\n        \"num_unique_values\": 4541,\n        \"samples\": [\n          11.221917808219178,\n          4.466666666666667,\n          22.240000000000002\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"y1\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 15.581281890991328,\n        \"min\": 0.04938271604938271,\n        \"max\": 94.45989304812834,\n        \"num_unique_values\": 6957,\n        \"samples\": [\n          20.131455399061032,\n          37.219858156028366,\n          29.653333333333336\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"x2\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 9.327438260262896,\n        \"min\": 44.900000000000006,\n        \"max\": 128.0,\n        \"num_unique_values\": 4443,\n        \"samples\": [\n          110.26327944572748,\n          122.79322033898305,\n          118.98591549295774\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"y2\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 10.315925476342953,\n        \"min\": 57.0,\n        \"max\": 128.0,\n        \"num_unique_values\": 6093,\n        \"samples\": [\n          117.78403755868545,\n          116.9262086513995,\n          96.52117263843648\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"class\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 56,\n        \"min\": 1,\n        \"max\": 196,\n        \"num_unique_values\": 196,\n        \"samples\": [\n          7,\n          50,\n          73\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"fname\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 12948,\n        \"samples\": [\n          \"07278.jpg\",\n          \"05322.jpg\",\n          \"08421.jpg\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    }\n  ]\n}"
            }
          },
          "metadata": {},
          "execution_count": 73
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Check the resized image."
      ],
      "metadata": {
        "id": "fVbZmPkL3gMy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "scaled_img = tf.keras.preprocessing.image.load_img('DataSet/resized_images/00097.jpg')\n",
        "scaled_img"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 145
        },
        "id": "NEv2e-DdxOzR",
        "outputId": "9f02b2ab-93e4-4008-a62b-87932f51550a"
      },
      "execution_count": 77,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=128x128>"
            ],
            "image/png": "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\n"
          },
          "metadata": {},
          "execution_count": 77
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Split data into Training and validation set"
      ],
      "metadata": {
        "id": "q95dbXpY6EqP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.model_selection import train_test_split\n",
        "import tensorflow as tf"
      ],
      "metadata": {
        "id": "IaiHAdOT-AaD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "X_train = train_data_resized.drop(columns=[\"class\"])  # Features\n",
        "y_train = train_data_resized[\"class\"]  # Target variable which in our case is class"
      ],
      "metadata": {
        "id": "_5dXp8n76G6f"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.2, random_state=42) #training set 80% validation set 20%"
      ],
      "metadata": {
        "id": "xBpgWdt_6KN9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "X_train.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VUVYXjc16Zhx",
        "outputId": "0415dae7-ce2b-4cf9-efa8-d80b8c269e9b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(10358, 6)"
            ]
          },
          "metadata": {},
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "X_val.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sDMvz_gy6bYW",
        "outputId": "e742c3eb-9135-4baf-8d54-0a5d6aa4eba9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2590, 6)"
            ]
          },
          "metadata": {},
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "y_train.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f74FXmKI6c9C",
        "outputId": "f1e6dbfe-ff42-4f2f-c16c-52eea59945e5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(10358,)"
            ]
          },
          "metadata": {},
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "y_val.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MuNuW4m16ex3",
        "outputId": "b256eb52-90d2-43d1-b064-a9987b98c203"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2590,)"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "X_train.head()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "id": "A26WYpYA6kLk",
        "outputId": "9991d863-61a0-4797-c08b-d9c81fbe763e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "      Unnamed: 0         x1         y1          x2          y2      fname\n",
              "6821        6821   2.750000  31.000000  121.875000  108.666667  06822.jpg\n",
              "2498        2498   7.979644  42.406504  119.368957  113.951220  02499.jpg\n",
              "1851        1851   5.400000   5.600000  125.200000  115.466667  01852.jpg\n",
              "8128        8128  42.320000  49.386667  104.480000   86.186667  08129.jpg\n",
              "4533        4533   5.979239  25.185984  122.906574  113.854447  04534.jpg"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-3d98cfc5-43f7-4dbd-931b-2c369ce2f123\" class=\"colab-df-container\">\n",
              "    <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Unnamed: 0</th>\n",
              "      <th>x1</th>\n",
              "      <th>y1</th>\n",
              "      <th>x2</th>\n",
              "      <th>y2</th>\n",
              "      <th>fname</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>6821</th>\n",
              "      <td>6821</td>\n",
              "      <td>2.750000</td>\n",
              "      <td>31.000000</td>\n",
              "      <td>121.875000</td>\n",
              "      <td>108.666667</td>\n",
              "      <td>06822.jpg</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2498</th>\n",
              "      <td>2498</td>\n",
              "      <td>7.979644</td>\n",
              "      <td>42.406504</td>\n",
              "      <td>119.368957</td>\n",
              "      <td>113.951220</td>\n",
              "      <td>02499.jpg</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1851</th>\n",
              "      <td>1851</td>\n",
              "      <td>5.400000</td>\n",
              "      <td>5.600000</td>\n",
              "      <td>125.200000</td>\n",
              "      <td>115.466667</td>\n",
              "      <td>01852.jpg</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>8128</th>\n",
              "      <td>8128</td>\n",
              "      <td>42.320000</td>\n",
              "      <td>49.386667</td>\n",
              "      <td>104.480000</td>\n",
              "      <td>86.186667</td>\n",
              "      <td>08129.jpg</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4533</th>\n",
              "      <td>4533</td>\n",
              "      <td>5.979239</td>\n",
              "      <td>25.185984</td>\n",
              "      <td>122.906574</td>\n",
              "      <td>113.854447</td>\n",
              "      <td>04534.jpg</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "    <div class=\"colab-df-buttons\">\n",
              "\n",
              "  <div class=\"colab-df-container\">\n",
              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-3d98cfc5-43f7-4dbd-931b-2c369ce2f123')\"\n",
              "            title=\"Convert this dataframe to an interactive table.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
              "  </svg>\n",
              "    </button>\n",
              "\n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    .colab-df-buttons div {\n",
              "      margin-bottom: 4px;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "    <script>\n",
              "      const buttonEl =\n",
              "        document.querySelector('#df-3d98cfc5-43f7-4dbd-931b-2c369ce2f123 button.colab-df-convert');\n",
              "      buttonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "      async function convertToInteractive(key) {\n",
              "        const element = document.querySelector('#df-3d98cfc5-43f7-4dbd-931b-2c369ce2f123');\n",
              "        const dataTable =\n",
              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                    [key], {});\n",
              "        if (!dataTable) return;\n",
              "\n",
              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "          + ' to learn more about interactive tables.';\n",
              "        element.innerHTML = '';\n",
              "        dataTable['output_type'] = 'display_data';\n",
              "        await google.colab.output.renderOutput(dataTable, element);\n",
              "        const docLink = document.createElement('div');\n",
              "        docLink.innerHTML = docLinkHtml;\n",
              "        element.appendChild(docLink);\n",
              "      }\n",
              "    </script>\n",
              "  </div>\n",
              "\n",
              "\n",
              "<div id=\"df-b7cdfa1f-8a41-4df8-9009-4711fd6d9c6c\">\n",
              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-b7cdfa1f-8a41-4df8-9009-4711fd6d9c6c')\"\n",
              "            title=\"Suggest charts\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "     width=\"24px\">\n",
              "    <g>\n",
              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
              "    </g>\n",
              "</svg>\n",
              "  </button>\n",
              "\n",
              "<style>\n",
              "  .colab-df-quickchart {\n",
              "      --bg-color: #E8F0FE;\n",
              "      --fill-color: #1967D2;\n",
              "      --hover-bg-color: #E2EBFA;\n",
              "      --hover-fill-color: #174EA6;\n",
              "      --disabled-fill-color: #AAA;\n",
              "      --disabled-bg-color: #DDD;\n",
              "  }\n",
              "\n",
              "  [theme=dark] .colab-df-quickchart {\n",
              "      --bg-color: #3B4455;\n",
              "      --fill-color: #D2E3FC;\n",
              "      --hover-bg-color: #434B5C;\n",
              "      --hover-fill-color: #FFFFFF;\n",
              "      --disabled-bg-color: #3B4455;\n",
              "      --disabled-fill-color: #666;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart {\n",
              "    background-color: var(--bg-color);\n",
              "    border: none;\n",
              "    border-radius: 50%;\n",
              "    cursor: pointer;\n",
              "    display: none;\n",
              "    fill: var(--fill-color);\n",
              "    height: 32px;\n",
              "    padding: 0;\n",
              "    width: 32px;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart:hover {\n",
              "    background-color: var(--hover-bg-color);\n",
              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "    fill: var(--button-hover-fill-color);\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart-complete:disabled,\n",
              "  .colab-df-quickchart-complete:disabled:hover {\n",
              "    background-color: var(--disabled-bg-color);\n",
              "    fill: var(--disabled-fill-color);\n",
              "    box-shadow: none;\n",
              "  }\n",
              "\n",
              "  .colab-df-spinner {\n",
              "    border: 2px solid var(--fill-color);\n",
              "    border-color: transparent;\n",
              "    border-bottom-color: var(--fill-color);\n",
              "    animation:\n",
              "      spin 1s steps(1) infinite;\n",
              "  }\n",
              "\n",
              "  @keyframes spin {\n",
              "    0% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "      border-left-color: var(--fill-color);\n",
              "    }\n",
              "    20% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    30% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    40% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    60% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    80% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "    90% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "  }\n",
              "</style>\n",
              "\n",
              "  <script>\n",
              "    async function quickchart(key) {\n",
              "      const quickchartButtonEl =\n",
              "        document.querySelector('#' + key + ' button');\n",
              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
              "      try {\n",
              "        const charts = await google.colab.kernel.invokeFunction(\n",
              "            'suggestCharts', [key], {});\n",
              "      } catch (error) {\n",
              "        console.error('Error during call to suggestCharts:', error);\n",
              "      }\n",
              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
              "    }\n",
              "    (() => {\n",
              "      let quickchartButtonEl =\n",
              "        document.querySelector('#df-b7cdfa1f-8a41-4df8-9009-4711fd6d9c6c button');\n",
              "      quickchartButtonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "    })();\n",
              "  </script>\n",
              "</div>\n",
              "    </div>\n",
              "  </div>\n"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "dataframe",
              "variable_name": "X_train",
              "summary": "{\n  \"name\": \"X_train\",\n  \"rows\": 10358,\n  \"fields\": [\n    {\n      \"column\": \"Unnamed: 0\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 2199,\n        \"min\": 0,\n        \"max\": 8143,\n        \"num_unique_values\": 7303,\n        \"samples\": [\n          1958,\n          2544,\n          1514\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"x1\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 9.467154530367248,\n        \"min\": 0.053156146179401995,\n        \"max\": 82.72,\n        \"num_unique_values\": 3901,\n        \"samples\": [\n          6.593939393939394,\n          3.547344110854503,\n          19.32075471698113\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"y1\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 15.561957186771036,\n        \"min\": 0.04938271604938271,\n        \"max\": 89.4070351758794,\n        \"num_unique_values\": 5889,\n        \"samples\": [\n          15.907514450867051,\n          49.152,\n          10.931129476584022\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"x2\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 9.294862106400565,\n        \"min\": 44.900000000000006,\n        \"max\": 128.0,\n        \"num_unique_values\": 3835,\n        \"samples\": [\n          108.18782608695652,\n          114.91271820448877,\n          89.06560636182903\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"y2\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 10.32440476468517,\n        \"min\": 57.0,\n        \"max\": 128.0,\n        \"num_unique_values\": 5204,\n        \"samples\": [\n          119.46666666666668,\n          117.16923076923077,\n          125.79310344827586\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"fname\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 10358,\n        \"samples\": [\n          \"05807.jpg\",\n          \"00375.jpg\",\n          \"09288.jpg\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    }\n  ]\n}"
            }
          },
          "metadata": {},
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Prepare the Data for Machine Learning Algorithms\n",
        "\n",
        "Checking we have any missing value"
      ],
      "metadata": {
        "id": "5XXG2uTr7235"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sample_incomplete_rows = train_data_resized[train_data_resized.isnull().any(axis=1)].head() #maybe we don't have any missing data\n",
        "pd.set_option('display.max_columns', None)\n",
        "sample_incomplete_rows"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "id": "9ErQKqUr6lvK",
        "outputId": "6c32a44f-1c30-43d9-bba8-751a1f7cf26d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Empty DataFrame\n",
              "Columns: [Unnamed: 0, x1, y1, x2, y2, class, fname]\n",
              "Index: []"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-71de0588-39a5-4010-92c5-e8bef780f803\" class=\"colab-df-container\">\n",
              "    <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Unnamed: 0</th>\n",
              "      <th>x1</th>\n",
              "      <th>y1</th>\n",
              "      <th>x2</th>\n",
              "      <th>y2</th>\n",
              "      <th>class</th>\n",
              "      <th>fname</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "    <div class=\"colab-df-buttons\">\n",
              "\n",
              "  <div class=\"colab-df-container\">\n",
              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-71de0588-39a5-4010-92c5-e8bef780f803')\"\n",
              "            title=\"Convert this dataframe to an interactive table.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
              "  </svg>\n",
              "    </button>\n",
              "\n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    .colab-df-buttons div {\n",
              "      margin-bottom: 4px;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "    <script>\n",
              "      const buttonEl =\n",
              "        document.querySelector('#df-71de0588-39a5-4010-92c5-e8bef780f803 button.colab-df-convert');\n",
              "      buttonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "      async function convertToInteractive(key) {\n",
              "        const element = document.querySelector('#df-71de0588-39a5-4010-92c5-e8bef780f803');\n",
              "        const dataTable =\n",
              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                    [key], {});\n",
              "        if (!dataTable) return;\n",
              "\n",
              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "          + ' to learn more about interactive tables.';\n",
              "        element.innerHTML = '';\n",
              "        dataTable['output_type'] = 'display_data';\n",
              "        await google.colab.output.renderOutput(dataTable, element);\n",
              "        const docLink = document.createElement('div');\n",
              "        docLink.innerHTML = docLinkHtml;\n",
              "        element.appendChild(docLink);\n",
              "      }\n",
              "    </script>\n",
              "  </div>\n",
              "\n",
              "    </div>\n",
              "  </div>\n"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "dataframe",
              "variable_name": "sample_incomplete_rows",
              "repr_error": "Out of range float values are not JSON compliant: nan"
            }
          },
          "metadata": {},
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Calculate the width and height of Bounding Boxes"
      ],
      "metadata": {
        "id": "4GE6r4j08ERz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Calculate width of bounding boxes\n",
        "train_data_resized['bbox_width'] = train_data_resized['x2'] - train_data_resized['x1']\n",
        "\n",
        "# Calculate height of bounding boxes\n",
        "train_data_resized['bbox_height'] = train_data_resized['y2'] - train_data_resized['y1']\n",
        "\n",
        "# Print the first few rows to verify the new features\n",
        "print(train_data_resized[['bbox_width', 'bbox_height']].head())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vbD5FBh17_A8",
        "outputId": "2ae241fa-d2a8-41df-bad3-74c4d78f21b9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "   bbox_width  bbox_height\n",
            "0  113.066667    82.880000\n",
            "1  118.328889    89.315556\n",
            "2  103.200000    72.533333\n",
            "3   52.601905    64.923521\n",
            "4  105.777778    74.666667\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Calculate summary statistics for numerical features to determine should we apply Normalization and Standardization\n"
      ],
      "metadata": {
        "id": "Spk0Ggzl8It8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Calculate summary statistics for numerical features\n",
        "summary_statistics = train_data_resized.describe()\n",
        "\n",
        "# Print summary statistics to check the scale of features\n",
        "# print(summary_statistics)"
      ],
      "metadata": {
        "id": "67ao_TAX8GSy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Cropping the images using bounding boxes and separating the images into their respective folders accoringly.\n",
        "\n",
        "> This step helps in training the transfer learning model much easier."
      ],
      "metadata": {
        "id": "NmpSXag89RLX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!rm -r DataSet/cropped_images/"
      ],
      "metadata": {
        "id": "r79_4JD4oE9W",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7589cd6f-3d78-4729-e9da-b430495882d3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "rm: cannot remove 'DataSet/cropped_images/': No such file or directory\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Image Cropper Function\n",
        "def ImageCropper(save_path, class_name, image_path, x1, y1,x2, y2):\n",
        "  im = Image.open(image_path);\n",
        "  croppedImage = im.crop((x1, y1, x2, y2))\n",
        "\n",
        "  # print(\"Cropping Finished\")\n",
        "  filename = os.path.basename(image_path)\n",
        "  # class_image_save_path = save_path + \"/\" + str(class_name) + \"/\" # this line separates all the images to separate folders according to the class no.\n",
        "  class_image_save_path = save_path + \"/\"\n",
        "\n",
        "  # print(class_image_save_path+filename)\n",
        "\n",
        "  #save the resized image\n",
        "  if not os.path.exists(class_image_save_path):\n",
        "    os.makedirs(class_image_save_path)\n",
        "\n",
        "  croppedImage.save(os.path.join(class_image_save_path, filename))"
      ],
      "metadata": {
        "id": "J4N1WPXE8Kkq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "save_path ='DataSet/cropped_images' #setting a custom path for storing the resized data\n",
        "\n",
        "# process each image - cropping\n",
        "for index, row in train_data.iterrows():\n",
        "\n",
        "  # Call the image cropper function\n",
        "  ImageCropper(save_path, train_data['class'][index] , dataset_image_folder + train_data['fname'][index], train_data['x1'][index], train_data['y1'][index], train_data['x2'][index], train_data['y2'][index])\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "CTSe4-j-BjtT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Load all the Images to start traning\n"
      ],
      "metadata": {
        "id": "OiA2dqQog3aN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import cv2  # Or from PIL import Image  if using Pillow\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator"
      ],
      "metadata": {
        "id": "ljlibckWg3Gr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Define data paths"
      ],
      "metadata": {
        "id": "YnJC0eawivz7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "image_train_data_dir = \"DataSet/cropped_images/\"\n",
        "# test_data_dir = \"\" # let's redefine it later"
      ],
      "metadata": {
        "id": "E2RWn2sAg8_m"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def load_image(filepath, target_size=(224, 224)):  # Adjust target size if needed\n",
        "    img = cv2.imread(filepath)  # Or img = Image.open(filepath) for Pillow\n",
        "    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)  # Convert to RGB if using OpenCV\n",
        "    img = cv2.resize(img, target_size)\n",
        "    return img"
      ],
      "metadata": {
        "id": "XQwQO-3Ui2lI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Prepare Training Data\n",
        "\n",
        "Creating a dictionary to map image filenames to their corresponding class labels"
      ],
      "metadata": {
        "id": "SXLwaZdQsWO2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "image_label_map = dict(zip(train_data[\"fname\"], train_data[\"class\"]))  # Adjust column names if needed\n"
      ],
      "metadata": {
        "id": "ouez78UdsfMM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###  Data Augmentation (Highly Recommended):\n",
        "\n",
        "Create an ImageDataGenerator object to perform on-the-fly data augmentation during training, which helps prevent overfitting and improve model generalization\n",
        "\n",
        "perform Data Augmentation"
      ],
      "metadata": {
        "id": "1oEqFXT9i-Ja"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "train_datagen = ImageDataGenerator(\n",
        "    rescale=1./255,  # Normalize pixel values to [0, 1]\n",
        "    shear_range=0.2,\n",
        "    zoom_range=0.2,\n",
        "    horizontal_flip=True,\n",
        "    validation_split=0.2  # Split 20% for validation (optional)\n",
        ")"
      ],
      "metadata": {
        "id": "_P-6dxRDi9do"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Load and Augment Training Data:\n",
        "\n",
        "Use train_datagen.flow_from_directory to automatically load, preprocess, and augment images from your training directory:\n",
        "\n",
        "Use train_datagen.flow_from_dataframe to generate batches of images and labels from your DataFrame:"
      ],
      "metadata": {
        "id": "3oUYmvqUjFPQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "train_generator = train_datagen.flow_from_directory(\n",
        "    image_train_data_dir,\n",
        "    target_size=(224, 224),  # Adjust target size if needed\n",
        "    batch_size=32,  # Adjust batch size as needed\n",
        "    class_mode='categorical',  # Multi-class classification\n",
        "    subset='training'  # Use 'validation' for validation split\n",
        ")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XrVn00CFjE9A",
        "outputId": "fc1690e2-9ff1-41a7-97f1-1c41a169b61c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 0 images belonging to 0 classes.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Convert \"class\" column to string before using flow_from_dataframe\n",
        "train_data['class'] = train_data['class'].astype(str)"
      ],
      "metadata": {
        "id": "-tWTY0dBtisa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_generator = train_datagen.flow_from_dataframe(\n",
        "    dataframe=train_data,\n",
        "    directory=image_train_data_dir,  # Point to the image directory\n",
        "    x_col=\"fname\",  # Column containing image filenames (adjust if needed)\n",
        "    y_col=\"class\",  # Column containing class labels (adjust if needed)\n",
        "    target_size=(224, 224),  # Adjust target size if needed\n",
        "    batch_size=32,  # Adjust batch size as needed\n",
        "    class_mode='categorical',  # Multi-class classification\n",
        "    shuffle=True,  # Shuffle data for better training\n",
        "    function=load_image  # Use the custom load_image function\n",
        ")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iV3tWoMMtA9A",
        "outputId": "824b2ee8-a700-4d37-a4b7-da5e124eb485"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 12948 validated image filenames belonging to 196 classes.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# PENDING FROM HERE"
      ],
      "metadata": {
        "id": "qxyiTsQHjTXk"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Imporing ResNet50 to the Transfer learning as the training data for each class is minimal in our dataset"
      ],
      "metadata": {
        "id": "xpKajCjhfc06"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from tensorflow.keras.applications import ResNet50\n",
        "from tensorflow.keras.layers import Dense, Dropout, Flatten\n",
        "from tensorflow.keras.models import Model\n"
      ],
      "metadata": {
        "id": "LCyog2mzlJfc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Load the pre-trained ResNet50 model, excluding the top (classification) layer\n",
        "base_model = ResNet50(weights='imagenet', include_top=False, input_shape=(224, 224, 3))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hU0SH2BofnES",
        "outputId": "bb0bf159-2b2c-41e4-fc98-5781e49f762f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/resnet/resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5\n",
            "94765736/94765736 [==============================] - 1s 0us/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Freeze the base model layers (optional, adjust as needed)\n",
        "base_model.trainable = False"
      ],
      "metadata": {
        "id": "ZHfRySvmfzSn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Add your custom layers for car make/model classification\n",
        "x = base_model.output\n",
        "x = Flatten()(x)\n",
        "x = Dense(1024, activation='relu')(x)\n",
        "x = Dropout(0.5)(x)\n",
        "predictions = Dense(196, activation='softmax')(x)"
      ],
      "metadata": {
        "id": "qbusQUWYf2sG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Create the final model\n",
        "model = Model(inputs=base_model.input, outputs=predictions)"
      ],
      "metadata": {
        "id": "ewrXj0vwf-Ip"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Compile the model for training with your specific optimizer and loss function\n",
        "model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])\n"
      ],
      "metadata": {
        "id": "Qu0tEbUugABC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Train the model on your car image dataset (data preparation not shown here)\n",
        "# model.fit(train_generator, your_training_labels, epochs=10)"
      ],
      "metadata": {
        "id": "Vgs-K7z9gCtG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Use the trained model for car make/model prediction on new images\n",
        "# predictions = model.predict(your_new_image)"
      ],
      "metadata": {
        "id": "oz_BBOAtgGqU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Train the model on the training data\n",
        "model.fit(\n",
        "    train_generator,\n",
        "    epochs=10,  # Adjust the number of epochs as needed\n",
        "    steps_per_epoch=len(train_generator)  # Adjust if using validation split\n",
        ")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jJ9AahNggJ9k",
        "outputId": "6801b6c2-5c11-4bd1-a940-a42f24244bd2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/10\n",
            "405/405 [==============================] - 191s 448ms/step - loss: 5.7296 - accuracy: 0.0060\n",
            "Epoch 2/10\n",
            "405/405 [==============================] - 181s 447ms/step - loss: 5.2860 - accuracy: 0.0087\n",
            "Epoch 3/10\n",
            "405/405 [==============================] - 179s 441ms/step - loss: 5.2890 - accuracy: 0.0089\n",
            "Epoch 4/10\n",
            "405/405 [==============================] - 178s 441ms/step - loss: 5.2859 - accuracy: 0.0089\n",
            "Epoch 5/10\n",
            "405/405 [==============================] - 178s 439ms/step - loss: 5.2809 - accuracy: 0.0089\n",
            "Epoch 6/10\n",
            "405/405 [==============================] - 178s 438ms/step - loss: 5.2807 - accuracy: 0.0088\n",
            "Epoch 7/10\n",
            "405/405 [==============================] - 178s 439ms/step - loss: 5.2735 - accuracy: 0.0089\n",
            "Epoch 8/10\n",
            "405/405 [==============================] - 179s 442ms/step - loss: 5.2751 - accuracy: 0.0090\n",
            "Epoch 9/10\n",
            "405/405 [==============================] - 183s 450ms/step - loss: 5.2759 - accuracy: 0.0090\n",
            "Epoch 10/10\n",
            "118/405 [=======>......................] - ETA: 2:08 - loss: 5.2724 - accuracy: 0.0069"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "> **NOTE:** It is best to have validation set for evaluating the performance"
      ],
      "metadata": {
        "id": "hhTLq07yu7cq"
      }
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}