03-object-classification-and-localization.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.applications import VGG16\n",
    "from tensorflow.keras.layers import Flatten\n",
    "from tensorflow.keras.layers import Dropout\n",
    "from tensorflow.keras.layers import Dense\n",
    "from tensorflow.keras.layers import Input\n",
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "from tensorflow.keras.preprocessing.image import img_to_array\n",
    "from tensorflow.keras.preprocessing.image import load_img\n",
    "from tensorflow.keras.utils import to_categorical\n",
    "from sklearn.preprocessing import LabelBinarizer\n",
    "from sklearn.model_selection import train_test_split\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pickle\n",
    "import cv2\n",
    "import os\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define the base path to the input dataset and then use it to derive\n",
    "# the path to the input images and annotation CSV files\n",
    "BASE_PATH = \"dataset2\"\n",
    "IMAGES_PATH = os.path.sep.join([BASE_PATH, \"images\"])\n",
    "ANNOTS_PATH = os.path.sep.join([BASE_PATH, \"annotations\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "initialize the list of data (images), class labels, target bounding box coordinates, and image paths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = []\n",
    "labels = []\n",
    "bboxes = []\n",
    "imagePaths = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['dataset2\\\\annotations\\\\airplane.csv',\n",
       " 'dataset2\\\\annotations\\\\face.csv',\n",
       " 'dataset2\\\\annotations\\\\motorcycle.csv']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "csvPaths = []\n",
    "for (rootDir, dirNames, filenames) in os.walk(ANNOTS_PATH):\n",
    "    # loop over the filenames in the current directory\n",
    "    for filename in filenames:\n",
    "        # determine the file extension of the current file\n",
    "        ext = filename[filename.rfind(\".\"):].lower()\n",
    "\n",
    "        # check to see if the file is an image and should be processed\n",
    "        if ext.endswith(\".csv\"):\n",
    "            # construct the path to the image and yield it\n",
    "            csvPath = os.path.join(rootDir, filename)\n",
    "            csvPaths.append(csvPath)\n",
    "\n",
    "csvPaths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# loop over all CSV files in the annotations directory\n",
    "for csvPath in csvPaths:\n",
    "    # load the contents of the current CSV annotations file\n",
    "    rows = open(csvPath).read().strip().split(\"\\n\")\n",
    "\n",
    "    # loop over the rows\n",
    "    for row in rows:\n",
    "        # break the row into the filename, bounding box coordinates,\n",
    "        # and class label\n",
    "        row = row.split(\",\")\n",
    "        (filename, startX, startY, endX, endY, label) = row\n",
    "\n",
    "        # derive the path to the input image, load the image (in\n",
    "        # OpenCV format), and grab its dimensions\n",
    "        imagePath = os.path.sep.join([IMAGES_PATH, label, filename])\n",
    "        image = cv2.imread(imagePath)\n",
    "        (h, w) = image.shape[:2]\n",
    "\n",
    "        # scale the bounding box coordinates relative to the spatial\n",
    "        # dimensions of the input image\n",
    "        startX = float(startX) / w\n",
    "        startY = float(startY) / h\n",
    "        endX = float(endX) / w\n",
    "        endY = float(endY) / h\n",
    "\n",
    "        # load the image and preprocess it\n",
    "        image = load_img(imagePath, target_size=(224, 224))\n",
    "        image = img_to_array(image)\n",
    "\n",
    "        # update our list of data, class labels, bounding boxes, and\n",
    "        # image paths\n",
    "        data.append(image)\n",
    "        labels.append(label)\n",
    "        bboxes.append((startX, startY, endX, endY))\n",
    "        imagePaths.append(imagePath)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# convert the data, class labels, bounding boxes, and image paths to\n",
    "# NumPy arrays, scaling the input pixel intensities from the range\n",
    "# [0, 255] to [0, 1]\n",
    "data = np.array(data, dtype=\"float32\") / 255.0\n",
    "labels = np.array(labels)\n",
    "bboxes = np.array(bboxes, dtype=\"float32\")\n",
    "imagePaths = np.array(imagePaths)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# perform one-hot encoding on the labels\n",
    "lb = LabelBinarizer()\n",
    "labels = lb.fit_transform(labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# partition the data into training and testing splits using 80% of\n",
    "# the data for training and the remaining 20% for testing\n",
    "split = train_test_split(data, labels, bboxes, imagePaths, test_size=0.20, random_state=42)\n",
    "# unpack the data split\n",
    "(trainImages, testImages) = split[:2]\n",
    "(trainLabels, testLabels) = split[2:4]\n",
    "(trainBBoxes, testBBoxes) = split[4:6]\n",
    "(trainPaths, testPaths) = split[6:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load the VGG16 network, ensuring the head FC layers are left off\n",
    "vgg = VGG16(weights=\"imagenet\", include_top=False, input_tensor=Input(shape=(224, 224, 3)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# freeze all VGG layers so they will *not* be updated during the\n",
    "# training process\n",
    "vgg.trainable = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# flatten the max-pooling output of VGG\n",
    "flatten = vgg.output\n",
    "flatten = Flatten()(flatten)\n",
    "\n",
    "# construct a fully-connected layer header to output the predicted\n",
    "# bounding box coordinates\n",
    "bboxHead = Dense(128, activation=\"relu\")(flatten)\n",
    "bboxHead = Dense(64, activation=\"relu\")(bboxHead)\n",
    "bboxHead = Dense(32, activation=\"relu\")(bboxHead)\n",
    "bboxHead = Dense(4, activation=\"sigmoid\", name=\"bounding_box\")(bboxHead)\n",
    "\n",
    "# construct a second fully-connected layer head, this one to predict\n",
    "# the class label\n",
    "softmaxHead = Dense(512, activation=\"relu\")(flatten)\n",
    "softmaxHead = Dropout(0.5)(softmaxHead)\n",
    "softmaxHead = Dense(512, activation=\"relu\")(softmaxHead)\n",
    "softmaxHead = Dropout(0.5)(softmaxHead)\n",
    "softmaxHead = Dense(len(lb.classes_), activation=\"softmax\", name=\"class_label\")(softmaxHead)\n",
    "\n",
    "# put together our model which accept an input image and then output\n",
    "# bounding box coordinates and a class label\n",
    "model = Model(inputs=vgg.input, outputs=(bboxHead, softmaxHead))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define a dictionary to set the loss methods -- categorical\n",
    "# cross-entropy for the class label head and mean absolute error\n",
    "# for the bounding box head\n",
    "losses = {\n",
    "    \"class_label\": \"categorical_crossentropy\",\n",
    "    \"bounding_box\": \"mean_squared_error\",\n",
    "}\n",
    "\n",
    "# define a dictionary that specifies the weights per loss (both the\n",
    "# class label and bounding box outputs will receive equal weight)\n",
    "lossWeights = {\n",
    "    \"class_label\": 1.0,\n",
    "    \"bounding_box\": 1.0\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initialize the optimizer, compile the model, and show the model\n",
    "# summary\n",
    "opt = Adam(lr=1e-4)\n",
    "model.compile(loss=losses, optimizer=opt, metrics=[\"accuracy\"], loss_weights=lossWeights)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "51/51 [==============================] - 63s 1s/step - loss: 0.2092 - bounding_box_loss: 0.0354 - class_label_loss: 0.1739 - bounding_box_accuracy: 0.7503 - class_label_accuracy: 0.9262 - val_loss: 0.0052 - val_bounding_box_loss: 0.0028 - val_class_label_loss: 0.0025 - val_bounding_box_accuracy: 0.8870 - val_class_label_accuracy: 1.0000\n",
      "Epoch 2/20\n",
      "51/51 [==============================] - 58s 1s/step - loss: 0.0168 - bounding_box_loss: 0.0019 - class_label_loss: 0.0149 - bounding_box_accuracy: 0.8807 - class_label_accuracy: 0.9975 - val_loss: 0.0039 - val_bounding_box_loss: 0.0015 - val_class_label_loss: 0.0025 - val_bounding_box_accuracy: 0.8698 - val_class_label_accuracy: 0.9975\n",
      "Epoch 3/20\n",
      "51/51 [==============================] - 58s 1s/step - loss: 0.0074 - bounding_box_loss: 0.0014 - class_label_loss: 0.0060 - bounding_box_accuracy: 0.8819 - class_label_accuracy: 0.9982 - val_loss: 0.0036 - val_bounding_box_loss: 0.0012 - val_class_label_loss: 0.0023 - val_bounding_box_accuracy: 0.8771 - val_class_label_accuracy: 0.9975\n",
      "Epoch 4/20\n",
      "51/51 [==============================] - 59s 1s/step - loss: 0.0042 - bounding_box_loss: 0.0011 - class_label_loss: 0.0031 - bounding_box_accuracy: 0.8875 - class_label_accuracy: 0.9994 - val_loss: 0.0020 - val_bounding_box_loss: 0.0011 - val_class_label_loss: 8.7081e-04 - val_bounding_box_accuracy: 0.8722 - val_class_label_accuracy: 1.0000\n",
      "Epoch 5/20\n",
      "51/51 [==============================] - 59s 1s/step - loss: 0.0080 - bounding_box_loss: 8.9026e-04 - class_label_loss: 0.0071 - bounding_box_accuracy: 0.8911 - class_label_accuracy: 0.9982 - val_loss: 0.0016 - val_bounding_box_loss: 0.0010 - val_class_label_loss: 6.0486e-04 - val_bounding_box_accuracy: 0.8796 - val_class_label_accuracy: 1.0000\n",
      "Epoch 6/20\n",
      "51/51 [==============================] - 60s 1s/step - loss: 0.0029 - bounding_box_loss: 7.5625e-04 - class_label_loss: 0.0021 - bounding_box_accuracy: 0.8893 - class_label_accuracy: 0.9994 - val_loss: 0.0013 - val_bounding_box_loss: 9.3772e-04 - val_class_label_loss: 3.3180e-04 - val_bounding_box_accuracy: 0.8894 - val_class_label_accuracy: 1.0000\n",
      "Epoch 7/20\n",
      "51/51 [==============================] - 60s 1s/step - loss: 0.0016 - bounding_box_loss: 6.3955e-04 - class_label_loss: 9.4901e-04 - bounding_box_accuracy: 0.8918 - class_label_accuracy: 1.0000 - val_loss: 0.0012 - val_bounding_box_loss: 8.6861e-04 - val_class_label_loss: 3.0960e-04 - val_bounding_box_accuracy: 0.8821 - val_class_label_accuracy: 1.0000\n",
      "Epoch 8/20\n",
      "51/51 [==============================] - 60s 1s/step - loss: 0.0012 - bounding_box_loss: 5.5163e-04 - class_label_loss: 6.9213e-04 - bounding_box_accuracy: 0.8979 - class_label_accuracy: 1.0000 - val_loss: 0.0011 - val_bounding_box_loss: 8.5425e-04 - val_class_label_loss: 2.6472e-04 - val_bounding_box_accuracy: 0.9091 - val_class_label_accuracy: 1.0000\n",
      "Epoch 9/20\n",
      "51/51 [==============================] - 61s 1s/step - loss: 0.0020 - bounding_box_loss: 4.8505e-04 - class_label_loss: 0.0015 - bounding_box_accuracy: 0.9034 - class_label_accuracy: 0.9994 - val_loss: 0.0041 - val_bounding_box_loss: 8.1329e-04 - val_class_label_loss: 0.0033 - val_bounding_box_accuracy: 0.8993 - val_class_label_accuracy: 0.9975\n",
      "Epoch 10/20\n",
      "51/51 [==============================] - 61s 1s/step - loss: 0.0013 - bounding_box_loss: 4.2612e-04 - class_label_loss: 8.4953e-04 - bounding_box_accuracy: 0.9096 - class_label_accuracy: 1.0000 - val_loss: 0.0011 - val_bounding_box_loss: 8.1630e-04 - val_class_label_loss: 2.3785e-04 - val_bounding_box_accuracy: 0.8624 - val_class_label_accuracy: 1.0000\n",
      "Epoch 11/20\n",
      "51/51 [==============================] - 61s 1s/step - loss: 0.0016 - bounding_box_loss: 3.8349e-04 - class_label_loss: 0.0013 - bounding_box_accuracy: 0.9102 - class_label_accuracy: 0.9994 - val_loss: 0.0011 - val_bounding_box_loss: 7.7700e-04 - val_class_label_loss: 3.4893e-04 - val_bounding_box_accuracy: 0.8747 - val_class_label_accuracy: 1.0000\n",
      "Epoch 12/20\n",
      "51/51 [==============================] - 61s 1s/step - loss: 8.0575e-04 - bounding_box_loss: 3.4464e-04 - class_label_loss: 4.6111e-04 - bounding_box_accuracy: 0.9108 - class_label_accuracy: 1.0000 - val_loss: 0.0010 - val_bounding_box_loss: 7.7033e-04 - val_class_label_loss: 2.5242e-04 - val_bounding_box_accuracy: 0.8870 - val_class_label_accuracy: 1.0000\n",
      "Epoch 13/20\n",
      "51/51 [==============================] - 61s 1s/step - loss: 6.9325e-04 - bounding_box_loss: 3.2025e-04 - class_label_loss: 3.7301e-04 - bounding_box_accuracy: 0.9133 - class_label_accuracy: 1.0000 - val_loss: 0.0011 - val_bounding_box_loss: 7.5092e-04 - val_class_label_loss: 3.8558e-04 - val_bounding_box_accuracy: 0.8943 - val_class_label_accuracy: 1.0000\n",
      "Epoch 14/20\n",
      "51/51 [==============================] - 61s 1s/step - loss: 6.1258e-04 - bounding_box_loss: 2.8220e-04 - class_label_loss: 3.3038e-04 - bounding_box_accuracy: 0.9213 - class_label_accuracy: 1.0000 - val_loss: 8.8160e-04 - val_bounding_box_loss: 7.6650e-04 - val_class_label_loss: 1.1510e-04 - val_bounding_box_accuracy: 0.9115 - val_class_label_accuracy: 1.0000\n",
      "Epoch 15/20\n",
      "51/51 [==============================] - 61s 1s/step - loss: 4.2911e-04 - bounding_box_loss: 2.6593e-04 - class_label_loss: 1.6318e-04 - bounding_box_accuracy: 0.9207 - class_label_accuracy: 1.0000 - val_loss: 8.4863e-04 - val_bounding_box_loss: 7.4730e-04 - val_class_label_loss: 1.0133e-04 - val_bounding_box_accuracy: 0.8771 - val_class_label_accuracy: 1.0000\n",
      "Epoch 16/20\n",
      "51/51 [==============================] - 61s 1s/step - loss: 6.0427e-04 - bounding_box_loss: 2.4008e-04 - class_label_loss: 3.6419e-04 - bounding_box_accuracy: 0.9194 - class_label_accuracy: 1.0000 - val_loss: 8.5335e-04 - val_bounding_box_loss: 7.2564e-04 - val_class_label_loss: 1.2771e-04 - val_bounding_box_accuracy: 0.8747 - val_class_label_accuracy: 1.0000\n",
      "Epoch 17/20\n",
      "51/51 [==============================] - 61s 1s/step - loss: 4.7221e-04 - bounding_box_loss: 2.2186e-04 - class_label_loss: 2.5034e-04 - bounding_box_accuracy: 0.9244 - class_label_accuracy: 1.0000 - val_loss: 9.3895e-04 - val_bounding_box_loss: 7.1287e-04 - val_class_label_loss: 2.2608e-04 - val_bounding_box_accuracy: 0.8845 - val_class_label_accuracy: 1.0000\n",
      "Epoch 18/20\n",
      "51/51 [==============================] - 61s 1s/step - loss: 3.2671e-04 - bounding_box_loss: 2.0274e-04 - class_label_loss: 1.2397e-04 - bounding_box_accuracy: 0.9244 - class_label_accuracy: 1.0000 - val_loss: 8.7355e-04 - val_bounding_box_loss: 7.4592e-04 - val_class_label_loss: 1.2763e-04 - val_bounding_box_accuracy: 0.8452 - val_class_label_accuracy: 1.0000\n",
      "Epoch 19/20\n",
      "51/51 [==============================] - 61s 1s/step - loss: 3.1303e-04 - bounding_box_loss: 1.8882e-04 - class_label_loss: 1.2422e-04 - bounding_box_accuracy: 0.9317 - class_label_accuracy: 1.0000 - val_loss: 0.0011 - val_bounding_box_loss: 7.1352e-04 - val_class_label_loss: 3.5801e-04 - val_bounding_box_accuracy: 0.8943 - val_class_label_accuracy: 1.0000\n",
      "Epoch 20/20\n",
      "51/51 [==============================] - 61s 1s/step - loss: 3.3352e-04 - bounding_box_loss: 1.7537e-04 - class_label_loss: 1.5815e-04 - bounding_box_accuracy: 0.9317 - class_label_accuracy: 1.0000 - val_loss: 8.9279e-04 - val_bounding_box_loss: 7.1432e-04 - val_class_label_loss: 1.7847e-04 - val_bounding_box_accuracy: 0.9017 - val_class_label_accuracy: 1.0000\n"
     ]
    }
   ],
   "source": [
    "# construct a dictionary for our target training outputs\n",
    "trainTargets = {\n",
    "    \"class_label\": trainLabels,\n",
    "    \"bounding_box\": trainBBoxes\n",
    "}\n",
    "\n",
    "# construct a second dictionary, this one for our target testing\n",
    "# outputs\n",
    "testTargets = {\n",
    "    \"class_label\": testLabels,\n",
    "    \"bounding_box\": testBBoxes\n",
    "}\n",
    "\n",
    "# train the network for bounding box regression and class label\n",
    "# prediction\n",
    "H = model.fit(\n",
    "    trainImages, trainTargets,\n",
    "    validation_data=(testImages, testTargets),\n",
    "    batch_size=32,\n",
    "    epochs=20,\n",
    "    verbose=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.save('3.h5', save_format=\"h5\")\n",
    "with open('lb3.pickle', \"wb\") as f:\n",
    "    f.write(pickle.dumps(lb))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x230e9fed448>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 936x936 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the total loss, label loss, and bounding box loss\n",
    "lossNames = [\"loss\", \"class_label_loss\", \"bounding_box_loss\"]\n",
    "N = np.arange(0, H.params['epochs'])\n",
    "plt.style.use(\"ggplot\")\n",
    "(fig, ax) = plt.subplots(3, 1, figsize=(13, 13))\n",
    "\n",
    "# loop over the loss names\n",
    "for (i, l) in enumerate(lossNames):\n",
    "    # plot the loss for both the training and validation data\n",
    "    title = \"Loss for {}\".format(l) if l != \"loss\" else \"Total loss\"\n",
    "    ax[i].set_title(title)\n",
    "    ax[i].set_xlabel(\"Epoch #\")\n",
    "    ax[i].set_ylabel(\"Loss\")\n",
    "    ax[i].plot(N, H.history[l], label=l)\n",
    "    ax[i].plot(N, H.history[\"val_\" + l], label=\"val_\" + l)\n",
    "    ax[i].legend()\n",
    "\n",
    "# save the losses figure and create a new figure for the accuracies\n",
    "plt.tight_layout()\n",
    "\n",
    "# create a new figure for the accuracies\n",
    "plt.style.use(\"ggplot\")\n",
    "plt.figure()\n",
    "plt.plot(N, H.history[\"class_label_accuracy\"], label=\"class_label_train_acc\")\n",
    "plt.plot(N, H.history[\"val_class_label_accuracy\"], label=\"val_class_label_acc\")\n",
    "plt.title(\"Class Label Accuracy\")\n",
    "plt.xlabel(\"Epoch #\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "plt.legend(loc=\"lower left\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Source:\n",
    "\n",
    "https://www.pyimagesearch.com/2020/10/12/multi-class-object-detection-and-bounding-box-regression-with-keras-tensorflow-and-deep-learning/"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tf2",
   "language": "python",
   "name": "tf2"
  },
  "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.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}