Face_Mask_Detection_Training.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import the necessary packages\n",
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
    "from tensorflow.keras.layers import AveragePooling2D, Dropout, Flatten, Dense, Input\n",
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "from tensorflow.keras.applications import MobileNetV2\n",
    "from tensorflow.keras.applications.mobilenet_v2 import preprocess_input\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",
    "from sklearn.metrics import classification_report\n",
    "from imutils import paths\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initialize the initial learning rate, number of epochs and batch size\n",
    "INITIAL_LEARNING_RATE = 1e-4\n",
    "EPOCHS = 10\n",
    "BATCH_SIZE = 32"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set paths for the dataset\n",
    "imagePaths = 'Face_Mask_Detection'\n",
    "maskImage=imagePaths + '/with_mask'\n",
    "unmaskImage=imagePaths + '/without_mask'\n",
    "data = []\n",
    "labels = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/raks/opt/anaconda3/envs/ComputerVision/lib/python3.7/site-packages/PIL/Image.py:960: UserWarning: Palette images with Transparency expressed in bytes should be converted to RGBA images\n",
      "  \"Palette images with Transparency expressed in bytes should be \"\n"
     ]
    }
   ],
   "source": [
    "# loop over the image paths\n",
    "for imagePath in os.listdir(maskImage):\n",
    "    try:\n",
    "        label = 'with_mask'\n",
    "\n",
    "        # load the input image (224x224) and preprocess it\n",
    "        image = load_img(os.path.join(maskImage,imagePath), target_size = (224, 224))\n",
    "        image = img_to_array(image)\n",
    "        image = preprocess_input(image)\n",
    "\n",
    "        # update the data and labels lists, respectively\n",
    "        data.append(image)\n",
    "        labels.append(label)\n",
    "        \n",
    "    except:\n",
    "        continue\n",
    "    \n",
    "    \n",
    "for imagePath in os.listdir(unmaskImage):\n",
    "    try:\n",
    "        label = 'without_mask'\n",
    "\n",
    "        # load the input image (224x224) and preprocess it\n",
    "        image = load_img(os.path.join(unmaskImage,imagePath), target_size=(224, 224))\n",
    "        image = img_to_array(image)\n",
    "        image = preprocess_input(image)\n",
    "\n",
    "        # update the data and labels lists, respectively\n",
    "        data.append(image)\n",
    "        labels.append(label)\n",
    "        \n",
    "    except:\n",
    "        continue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# convert the data and labels to NumPy arrays\n",
    "data = np.array(data, dtype=\"float32\")\n",
    "labels = np.array(labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# perform one-hot encoding on the labels\n",
    "lb = LabelBinarizer()\n",
    "labels = lb.fit_transform(labels)\n",
    "labels = to_categorical(labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# partition the data into training and testing splits using 75% of\n",
    "# the data for training and the remaining 25% for testing\n",
    "(trainX, testX, trainY, testY) = train_test_split(data, \n",
    "                                                  labels,\n",
    "                                                  test_size = 0.20, \n",
    "                                                  stratify = labels, \n",
    "                                                  random_state = 69)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# construct the training image generator for data augmentation\n",
    "aug = ImageDataGenerator(rotation_range = 20,\n",
    "                         zoom_range = 0.15,\n",
    "                         width_shift_range = 0.2,\n",
    "                         height_shift_range = 0.2,\n",
    "                         shear_range = 0.15,\n",
    "                         horizontal_flip = True,\n",
    "                         fill_mode = \"nearest\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:`input_shape` is undefined or non-square, or `rows` is not in [96, 128, 160, 192, 224]. Weights for input shape (224, 224) will be loaded as the default.\n"
     ]
    }
   ],
   "source": [
    "# load the MobileNetV2 network, ensuring the head FC layer sets are left off\n",
    "baseModel = MobileNetV2(weights = \"imagenet\", \n",
    "                        include_top = False,\n",
    "                        input_tensor = Input(shape = (224, 224, 3)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# construct the head of the model that will be placed on top of the base model\n",
    "headModel = baseModel.output\n",
    "headModel = AveragePooling2D(pool_size = (7, 7))(headModel)\n",
    "headModel = Flatten(name = \"flatten\")(headModel)\n",
    "headModel = Dense(128, activation = \"relu\")(headModel)\n",
    "headModel = Dropout(0.5)(headModel)\n",
    "headModel = Dense(2, activation = \"softmax\")(headModel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# place the head FC model on top of the base model\n",
    "# this will become the actual model we will train\n",
    "model = Model(inputs = baseModel.input, outputs = headModel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# loop over all layers in the base model and freeze them\n",
    "# so they will NOT be updated during the first training process\n",
    "for layer in baseModel.layers:\n",
    "    layer.trainable = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# compile our model\n",
    "opt = Adam(lr=INITIAL_LEARNING_RATE, decay=INITIAL_LEARNING_RATE / EPOCHS)\n",
    "model.compile(loss = \"binary_crossentropy\", optimizer = opt, metrics = [\"accuracy\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "95/95 [==============================] - 183s 2s/step - loss: 0.3795 - accuracy: 0.8253 - val_loss: 0.1201 - val_accuracy: 0.9622\n",
      "Epoch 2/10\n",
      "95/95 [==============================] - 213s 2s/step - loss: 0.1165 - accuracy: 0.9614 - val_loss: 0.0736 - val_accuracy: 0.9752\n",
      "Epoch 3/10\n",
      "95/95 [==============================] - 208s 2s/step - loss: 0.0851 - accuracy: 0.9710 - val_loss: 0.0631 - val_accuracy: 0.9778\n",
      "Epoch 4/10\n",
      "95/95 [==============================] - 213s 2s/step - loss: 0.0692 - accuracy: 0.9733 - val_loss: 0.0526 - val_accuracy: 0.9791\n",
      "Epoch 5/10\n",
      "95/95 [==============================] - 240s 3s/step - loss: 0.0608 - accuracy: 0.9796 - val_loss: 0.0463 - val_accuracy: 0.9857\n",
      "Epoch 6/10\n",
      "95/95 [==============================] - 234s 2s/step - loss: 0.0515 - accuracy: 0.9829 - val_loss: 0.0416 - val_accuracy: 0.9870\n",
      "Epoch 7/10\n",
      "95/95 [==============================] - 226s 2s/step - loss: 0.0470 - accuracy: 0.9832 - val_loss: 0.0401 - val_accuracy: 0.9870\n",
      "Epoch 8/10\n",
      "95/95 [==============================] - 243s 3s/step - loss: 0.0346 - accuracy: 0.9875 - val_loss: 0.0394 - val_accuracy: 0.9870\n",
      "Epoch 9/10\n",
      "95/95 [==============================] - 222s 2s/step - loss: 0.0445 - accuracy: 0.9855 - val_loss: 0.0357 - val_accuracy: 0.9896\n",
      "Epoch 10/10\n",
      "95/95 [==============================] - 209s 2s/step - loss: 0.0389 - accuracy: 0.9878 - val_loss: 0.0354 - val_accuracy: 0.9896\n"
     ]
    }
   ],
   "source": [
    "H = model.fit(aug.flow(trainX, trainY, batch_size=BATCH_SIZE),\n",
    "              steps_per_epoch=len(trainX) // BATCH_SIZE,\n",
    "              validation_data=(testX, testY),\n",
    "              validation_steps=len(testX) // BATCH_SIZE,\n",
    "              epochs=EPOCHS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# make predictions on the testing set\n",
    "predIdxs = model.predict(testX, batch_size=BATCH_SIZE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for each image in the testing set we need to find the index of the\n",
    "# label with corresponding largest predicted probability\n",
    "predIdxs = np.argmax(predIdxs, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "   with_mask       0.99      0.99      0.99       383\n",
      "without_mask       0.99      0.99      0.99       384\n",
      "\n",
      "    accuracy                           0.99       767\n",
      "   macro avg       0.99      0.99      0.99       767\n",
      "weighted avg       0.99      0.99      0.99       767\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# show classification report\n",
    "print(classification_report(testY.argmax(axis=1), \n",
    "                            predIdxs,\n",
    "                            target_names=lb.classes_))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# serialize the model to disk\n",
    "model.save(imagePaths+'/model.model', save_format=\"h5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fcfe0f86f10>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the training loss and accuracy\n",
    "N = EPOCHS\n",
    "plt.style.use(\"ggplot\")\n",
    "plt.figure(figsize=(10,10))\n",
    "plt.plot(np.arange(0, N), H.history[\"loss\"], label=\"train_loss\")\n",
    "plt.plot(np.arange(0, N), H.history[\"val_loss\"], label=\"val_loss\")\n",
    "plt.plot(np.arange(0, N), H.history[\"accuracy\"], label=\"train_acc\")\n",
    "plt.plot(np.arange(0, N), H.history[\"val_accuracy\"], label=\"val_acc\")\n",
    "plt.title(\"Training Loss and Accuracy\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"Loss/Accuracy\")\n",
    "plt.legend(loc=\"lower left\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}