Data Augmentation and Model Training.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the necessary packages\n",
    "\n",
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
    "from tensorflow.keras.applications import MobileNetV2\n",
    "from tensorflow.keras.layers import AveragePooling2D\n",
    "from tensorflow.keras.layers import Dropout\n",
    "from tensorflow.keras.layers import Flatten\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.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 argparse\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initialize the initial learning rate, number of epochs to train for, and batch size\n",
    "INIT_LR = 1e-4\n",
    "EPOCHS = 20\n",
    "BS = 32\n",
    "\n",
    "dataset= 'dataset'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] loading images...\n"
     ]
    }
   ],
   "source": [
    "# grab the list of images in our dataset directory, then initialize the list of data (i.e., images) and class images\n",
    "print(\"[INFO] loading images...\")\n",
    "imagePaths = list(paths.list_images(dataset))\n",
    "data = []\n",
    "labels = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# loop over the image paths\n",
    "for imagePath in imagePaths:\n",
    "\t# extract the class label from the filename\n",
    "\tlabel = imagePath.split(os.path.sep)[-2]\n",
    "\n",
    "\t# load the input image (224x224) and preprocess it\n",
    "\timage = load_img(imagePath, target_size=(224, 224))\n",
    "\timage = img_to_array(image)\n",
    "\timage = preprocess_input(image)\n",
    "\n",
    "\t# update the data and labels lists, respectively\n",
    "\tdata.append(image)\n",
    "\tlabels.append(label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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": 12,
   "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": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# partition the data into training and testing splits using 75% of the data for training and the remaining 25% for testing\n",
    "(trainX, testX, trainY, testY) = train_test_split(data, labels,\n",
    "\ttest_size=0.20, stratify=labels, random_state=42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# construct the training image generator for data augmentation\n",
    "aug = ImageDataGenerator(\n",
    "\trotation_range=20,\n",
    "\tzoom_range=0.15,\n",
    "\twidth_shift_range=0.2,\n",
    "\theight_shift_range=0.2,\n",
    "\tshear_range=0.15,\n",
    "\thorizontal_flip=True,\n",
    "\tfill_mode=\"nearest\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\user\\Anaconda3\\lib\\site-packages\\keras_applications\\mobilenet_v2.py:294: UserWarning: `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",
      "  warnings.warn('`input_shape` is undefined or non-square, '\n"
     ]
    }
   ],
   "source": [
    "# load the MobileNetV2 network, ensuring the head FC layer sets are left off\n",
    "baseModel = MobileNetV2(weights=\"imagenet\", include_top=False, input_tensor=Input(shape=(224, 224, 3)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# construct the head of the model that will be placed on top of the 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": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# place the head FC model on top of the base model (this will become the actual model we will train)\n",
    "model = Model(inputs=baseModel.input, outputs=headModel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# loop over all layers in the base model and freeze them so they will *not* be updated during the first training process\n",
    "for layer in baseModel.layers:\n",
    "\tlayer.trainable = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] compiling model...\n"
     ]
    }
   ],
   "source": [
    "# compile our model\n",
    "print(\"[INFO] compiling model...\")\n",
    "opt = Adam(lr=INIT_LR, decay=INIT_LR / EPOCHS)\n",
    "model.compile(loss=\"binary_crossentropy\", optimizer=opt,\n",
    "\tmetrics=[\"accuracy\"])\n",
    "\n",
    "print(\"Done !!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] training head...\n",
      "Train for 34 steps, validate on 276 samples\n",
      "Epoch 1/20\n",
      "34/34 [==============================] - 265s 8s/step - loss: 0.6542 - accuracy: 0.6507 - val_loss: 0.2815 - val_accuracy: 0.9414\n",
      "Epoch 2/20\n",
      "34/34 [==============================] - 179s 5s/step - loss: 0.3795 - accuracy: 0.8240 - val_loss: 0.1673 - val_accuracy: 0.9805\n",
      "Epoch 3/20\n",
      "34/34 [==============================] - 166s 5s/step - loss: 0.2880 - accuracy: 0.8867 - val_loss: 0.1015 - val_accuracy: 0.9922\n",
      "Epoch 4/20\n",
      "34/34 [==============================] - 171s 5s/step - loss: 0.2379 - accuracy: 0.9017 - val_loss: 0.0860 - val_accuracy: 0.9922\n",
      "Epoch 5/20\n",
      "34/34 [==============================] - 176s 5s/step - loss: 0.1982 - accuracy: 0.9307 - val_loss: 0.0665 - val_accuracy: 0.9922\n",
      "Epoch 6/20\n",
      "34/34 [==============================] - 177s 5s/step - loss: 0.1835 - accuracy: 0.9232 - val_loss: 0.0525 - val_accuracy: 0.9922\n",
      "Epoch 7/20\n",
      "34/34 [==============================] - 165s 5s/step - loss: 0.1455 - accuracy: 0.9466 - val_loss: 0.0501 - val_accuracy: 0.9961\n",
      "Epoch 8/20\n",
      "34/34 [==============================] - 171s 5s/step - loss: 0.1485 - accuracy: 0.9429 - val_loss: 0.0658 - val_accuracy: 0.9805\n",
      "Epoch 9/20\n",
      "34/34 [==============================] - 161s 5s/step - loss: 0.1301 - accuracy: 0.9504 - val_loss: 0.0439 - val_accuracy: 0.9883\n",
      "Epoch 10/20\n",
      "34/34 [==============================] - 173s 5s/step - loss: 0.1087 - accuracy: 0.9597 - val_loss: 0.0392 - val_accuracy: 0.9922\n",
      "Epoch 11/20\n",
      "34/34 [==============================] - 174s 5s/step - loss: 0.1337 - accuracy: 0.9457 - val_loss: 0.0406 - val_accuracy: 0.9883\n",
      "Epoch 12/20\n",
      "34/34 [==============================] - 165s 5s/step - loss: 0.1221 - accuracy: 0.9541 - val_loss: 0.0447 - val_accuracy: 0.9883\n",
      "Epoch 13/20\n",
      "34/34 [==============================] - 175s 5s/step - loss: 0.0882 - accuracy: 0.9719 - val_loss: 0.0402 - val_accuracy: 0.9883\n",
      "Epoch 14/20\n",
      "34/34 [==============================] - 172s 5s/step - loss: 0.1046 - accuracy: 0.9654 - val_loss: 0.0410 - val_accuracy: 0.9883\n",
      "Epoch 15/20\n",
      "34/34 [==============================] - 171s 5s/step - loss: 0.0864 - accuracy: 0.9672 - val_loss: 0.0441 - val_accuracy: 0.9883\n",
      "Epoch 16/20\n",
      "34/34 [==============================] - 166s 5s/step - loss: 0.0817 - accuracy: 0.9682 - val_loss: 0.0422 - val_accuracy: 0.9883\n",
      "Epoch 17/20\n",
      "34/34 [==============================] - 168s 5s/step - loss: 0.0893 - accuracy: 0.9635 - val_loss: 0.0347 - val_accuracy: 0.9922\n",
      "Epoch 18/20\n",
      "34/34 [==============================] - 162s 5s/step - loss: 0.1001 - accuracy: 0.9625 - val_loss: 0.0413 - val_accuracy: 0.9883\n",
      "Epoch 19/20\n",
      "34/34 [==============================] - 181s 5s/step - loss: 0.0719 - accuracy: 0.9803 - val_loss: 0.0673 - val_accuracy: 0.9727\n",
      "Epoch 20/20\n",
      "34/34 [==============================] - 173s 5s/step - loss: 0.0775 - accuracy: 0.9682 - val_loss: 0.0396 - val_accuracy: 0.9844\n"
     ]
    }
   ],
   "source": [
    "# train the head of the network\n",
    "print(\"[INFO] training head...\")\n",
    "H = model.fit(\n",
    "\taug.flow(trainX, trainY, batch_size=BS),\n",
    "\tsteps_per_epoch=len(trainX) // BS,\n",
    "\tvalidation_data=(testX, testY),\n",
    "\tvalidation_steps=len(testX) // BS,\n",
    "\tepochs=EPOCHS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] evaluating network...\n"
     ]
    }
   ],
   "source": [
    "# make predictions on the testing set\n",
    "print(\"[INFO] evaluating network...\")\n",
    "predIdxs = model.predict(testX, batch_size=BS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "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": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "   with_mask       0.97      1.00      0.99       138\n",
      "without_mask       1.00      0.97      0.99       138\n",
      "\n",
      "    accuracy                           0.99       276\n",
      "   macro avg       0.99      0.99      0.99       276\n",
      "weighted avg       0.99      0.99      0.99       276\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# show a nicely formatted classification report\n",
    "print(classification_report(testY.argmax(axis=1), predIdxs,\n",
    "\ttarget_names=lb.classes_))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] saving mask detector model...\n",
      "Done !\n"
     ]
    }
   ],
   "source": [
    "# serialize the model to disk\n",
    "print(\"[INFO] saving mask detector model...\")\n",
    "model.save('mask-detector-model.model', save_format=\"h5\")\n",
    "print(\"Done !\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 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()\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(\"Epoch #\")\n",
    "plt.ylabel(\"Loss/Accuracy\")\n",
    "plt.legend(loc=\"lower left\")\n",
    "plt.savefig('evaluation.png')"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}