Face-Mask-Detection-Train.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",
    "LEARNING_RATE = 1e-4\n",
    "epoch = 10\n",
    "batch_size = 32"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set paths for 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/aneerbanchakraborty/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",
    "        \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",
    "    except:\n",
    "        continue\n",
    "for imagePath in os.listdir(unmaskImage):\n",
    "    try:\n",
    "       \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",
    "    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": {},
   "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(rate = 1 - 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=LEARNING_RATE, decay=LEARNING_RATE / epoch)\n",
    "model.compile(loss=\"binary_crossentropy\", \n",
    "              optimizer=opt,\n",
    "              metrics=[\"accuracy\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "95/95 [==============================] - 97s 1s/step - loss: 0.3196 - accuracy: 0.8664 - val_loss: 0.1074 - val_accuracy: 0.9700\n",
      "Epoch 2/10\n",
      "95/95 [==============================] - 99s 1s/step - loss: 0.1125 - accuracy: 0.9637 - val_loss: 0.0735 - val_accuracy: 0.9804\n",
      "Epoch 3/10\n",
      "95/95 [==============================] - 92s 964ms/step - loss: 0.0910 - accuracy: 0.9703 - val_loss: 0.0658 - val_accuracy: 0.9804\n",
      "Epoch 4/10\n",
      "95/95 [==============================] - 90s 950ms/step - loss: 0.0612 - accuracy: 0.9786 - val_loss: 0.0524 - val_accuracy: 0.9817\n",
      "Epoch 5/10\n",
      "95/95 [==============================] - 87s 911ms/step - loss: 0.0582 - accuracy: 0.9799 - val_loss: 0.0482 - val_accuracy: 0.9817\n",
      "Epoch 6/10\n",
      "95/95 [==============================] - 89s 940ms/step - loss: 0.0432 - accuracy: 0.9842 - val_loss: 0.0474 - val_accuracy: 0.9857\n",
      "Epoch 7/10\n",
      "95/95 [==============================] - 93s 976ms/step - loss: 0.0554 - accuracy: 0.9776 - val_loss: 0.0412 - val_accuracy: 0.9857\n",
      "Epoch 8/10\n",
      "95/95 [==============================] - 89s 937ms/step - loss: 0.0420 - accuracy: 0.9868 - val_loss: 0.0404 - val_accuracy: 0.9883\n",
      "Epoch 9/10\n",
      "95/95 [==============================] - 89s 941ms/step - loss: 0.0392 - accuracy: 0.9885 - val_loss: 0.0414 - val_accuracy: 0.9883\n",
      "Epoch 10/10\n",
      "95/95 [==============================] - 87s 914ms/step - loss: 0.0373 - accuracy: 0.9871 - val_loss: 0.0335 - val_accuracy: 0.9883\n"
     ]
    }
   ],
   "source": [
    "Hist = 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=epoch)"
   ]
  },
  {
   "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.98      0.99      0.99       383\n",
      "without_mask       0.99      0.98      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": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fd9a8bce410>"
      ]
     },
     "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 = epoch\n",
    "plt.style.use(\"ggplot\")\n",
    "plt.figure(figsize=(10,10))\n",
    "plt.plot(np.arange(0, N), Hist.history[\"loss\"], label=\"train_loss\")\n",
    "plt.plot(np.arange(0, N), Hist.history[\"val_loss\"], label=\"val_loss\")\n",
    "plt.plot(np.arange(0, N), Hist.history[\"accuracy\"], label=\"train_acc\")\n",
    "plt.plot(np.arange(0, N), Hist.history[\"val_accuracy\"], label=\"val_acc\")\n",
    "plt.title(\"Training Loss and Accuracy\")\n",
    "plt.xlabel(\"Epoch #\")\n",
    "plt.ylabel(\"Loss/Accuracy\")\n",
    "plt.legend(loc=\"lower left\")"
   ]
  }
 ],
 "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
}