trainer_MaskDetector.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Trainer MaskDetection"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size=4> import the necessary packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "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\n",
    "from tqdm.notebook import tqdm "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "LR = 1e-4 # means 0.0001 learning rate\n",
    "EPOCH =20 \n",
    "BS = 32 # batch size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#imutils help to get images path\n",
    "imagePaths = list(paths.list_images(\"dataset\")) \n",
    "data =[]\n",
    "labels = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This way we get the folder name and mark as label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "🛣full path: dataset\\with_mask\\prajna.jpg\n",
      "📁folderName: with_mask\n"
     ]
    }
   ],
   "source": [
    "print(\"🛣full path: \"+imagePaths[-1])\n",
    "print(\"📁folderName: \"+imagePaths[-1].split(os.path.sep)[-2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3b65cc667c4b4356931ecbf81b2a468d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Progress:   0%|          | 0/1376 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pbar = tqdm(total = len(imagePaths), desc=\"Progress\")\n",
    "for  imagePath in imagePaths:\n",
    "    label = imagePath.split(os.path.sep)[-2] #extract class label\n",
    "    \n",
    "    #load and process image after resizing\n",
    "    image = load_img(imagePath, target_size=(244,244))\n",
    "    image = img_to_array(image)\n",
    "    image = preprocess_input(image)\n",
    "    \n",
    "    #update/store on list\n",
    "    data.append(image)\n",
    "    labels.append(label)\n",
    "    \n",
    "    #update progressBar\n",
    "    pbar.update(1)\n",
    "pbar.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convert the data and labels to NumPy arrays for traning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "🔃: Converting to Numpy....\n",
      "🥂: Conversion completed.\n"
     ]
    }
   ],
   "source": [
    "print(\"🔃: Converting to Numpy....\")\n",
    "data = np.array(data, dtype=\"float32\")\n",
    "labels = np.array(labels)\n",
    "print(\"🥂: Conversion completed.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font  size=4> one-hot encoding on the labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "lb = LabelBinarizer()\n",
    "labels = lb.fit_transform(labels)\n",
    "labels = to_categorical(labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size=3> Train Data 80% and 20% for test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "🔃:training model..... \n",
      "🎉:training completed.\n"
     ]
    }
   ],
   "source": [
    "print(\"🔃:training model..... \")\n",
    "(trainX, testX, trainY, testY) = train_test_split(data, labels, test_size=.20, stratify=labels, random_state=42)\n",
    "print(\"🎉:training completed.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "construct the training image generator for data augmentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  it will improve generalization\n",
    "aug = ImageDataGenerator(\n",
    "    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": 10,
   "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": [
    "baseModel = MobileNetV2(\n",
    "    weights=\"imagenet\",\n",
    "    include_top=False,\n",
    "    input_tensor=Input(shape=(244, 244, 3)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "construct the head of the model that will be placed on top of the base model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "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": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#actual model\n",
    "model = Model(inputs= baseModel.input, outputs= headModel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size=3.3>Freeze update while first training process"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ea56e183f25d4582881b8ddcd5071622",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Done:   0%|          | 0/154 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pbar = tqdm(total=len(baseModel.layers), desc=\"Done\")\n",
    "for layer in baseModel.layers:\n",
    "    layer.trainable = False\n",
    "    pbar.update(1)\n",
    "\n",
    "pbar.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center><font size=4> Compile Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "opt = Adam(lr =LR, decay= LR/ EPOCH)\n",
    "model.compile(loss=\"binary_crossentropy\", optimizer=opt, metrics=[\"accuracy\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center><font size=4.2>Train the head of the network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "34/34 [==============================] - 38s 1s/step - loss: 0.7306 - accuracy: 0.6223 - val_loss: 0.2498 - val_accuracy: 0.9746\n",
      "Epoch 2/20\n",
      "34/34 [==============================] - 32s 952ms/step - loss: 0.2854 - accuracy: 0.9490 - val_loss: 0.1183 - val_accuracy: 0.9855\n",
      "Epoch 3/20\n",
      "34/34 [==============================] - 32s 949ms/step - loss: 0.1358 - accuracy: 0.9851 - val_loss: 0.0730 - val_accuracy: 0.9928\n",
      "Epoch 4/20\n",
      "34/34 [==============================] - 32s 951ms/step - loss: 0.1029 - accuracy: 0.9847 - val_loss: 0.0523 - val_accuracy: 0.9964\n",
      "Epoch 5/20\n",
      "34/34 [==============================] - 32s 945ms/step - loss: 0.0688 - accuracy: 0.9898 - val_loss: 0.0413 - val_accuracy: 0.9964\n",
      "Epoch 6/20\n",
      "34/34 [==============================] - 32s 946ms/step - loss: 0.0557 - accuracy: 0.9852 - val_loss: 0.0379 - val_accuracy: 0.9891\n",
      "Epoch 7/20\n",
      "34/34 [==============================] - 32s 946ms/step - loss: 0.0393 - accuracy: 0.9944 - val_loss: 0.0301 - val_accuracy: 0.9964\n",
      "Epoch 8/20\n",
      "34/34 [==============================] - 33s 954ms/step - loss: 0.0467 - accuracy: 0.9917 - val_loss: 0.0263 - val_accuracy: 0.9964\n",
      "Epoch 9/20\n",
      "34/34 [==============================] - 32s 947ms/step - loss: 0.0478 - accuracy: 0.9900 - val_loss: 0.0238 - val_accuracy: 0.9964\n",
      "Epoch 10/20\n",
      "34/34 [==============================] - 32s 943ms/step - loss: 0.0409 - accuracy: 0.9922 - val_loss: 0.0217 - val_accuracy: 0.9964\n",
      "Epoch 11/20\n",
      "34/34 [==============================] - 34s 989ms/step - loss: 0.0220 - accuracy: 0.9959 - val_loss: 0.0194 - val_accuracy: 0.9964\n",
      "Epoch 12/20\n",
      "34/34 [==============================] - 32s 951ms/step - loss: 0.0256 - accuracy: 0.9951 - val_loss: 0.0182 - val_accuracy: 0.9964\n",
      "Epoch 13/20\n",
      "34/34 [==============================] - 33s 958ms/step - loss: 0.0241 - accuracy: 0.9979 - val_loss: 0.0171 - val_accuracy: 0.9964\n",
      "Epoch 14/20\n",
      "34/34 [==============================] - 33s 954ms/step - loss: 0.0216 - accuracy: 0.9948 - val_loss: 0.0162 - val_accuracy: 0.9964\n",
      "Epoch 15/20\n",
      "34/34 [==============================] - 32s 946ms/step - loss: 0.0219 - accuracy: 0.9953 - val_loss: 0.0153 - val_accuracy: 0.9964\n",
      "Epoch 16/20\n",
      "34/34 [==============================] - 32s 952ms/step - loss: 0.0171 - accuracy: 0.9972 - val_loss: 0.0148 - val_accuracy: 0.9964\n",
      "Epoch 17/20\n",
      "34/34 [==============================] - 35s 1s/step - loss: 0.0161 - accuracy: 0.9963 - val_loss: 0.0142 - val_accuracy: 0.9964\n",
      "Epoch 18/20\n",
      "34/34 [==============================] - 34s 994ms/step - loss: 0.0210 - accuracy: 0.9902 - val_loss: 0.0136 - val_accuracy: 0.9964\n",
      "Epoch 19/20\n",
      "34/34 [==============================] - 32s 952ms/step - loss: 0.0181 - accuracy: 0.9929 - val_loss: 0.0135 - val_accuracy: 0.9964\n",
      "Epoch 20/20\n",
      "34/34 [==============================] - 35s 1s/step - loss: 0.0099 - accuracy: 0.9981 - val_loss: 0.0127 - val_accuracy: 0.9964\n"
     ]
    }
   ],
   "source": [
    "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=EPOCH)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center><font size=4>Evaluating network & Save model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "   with_mask       1.00      0.99      1.00       138\n",
      "without_mask       0.99      1.00      1.00       138\n",
      "\n",
      "    accuracy                           1.00       276\n",
      "   macro avg       1.00      1.00      1.00       276\n",
      "weighted avg       1.00      1.00      1.00       276\n",
      "\n"
     ]
    }
   ],
   "source": [
    "predIdxs = model.predict(testX, batch_size=BS) # predictions on testing set\n",
    "predIdxs = np.argmax(predIdxs, axis = 1) #largest predicted probability\n",
    "\n",
    "print(classification_report(testY.argmax(axis=1), predIdxs, target_names=lb.classes_))\n",
    "      \n",
    "model.save(\"maskDetector11.model\", save_format=\"h5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center><font size=4> Visualize accuracy and loss curves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "N= EPOCH\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(\"plot11\")"
   ]
  },
  {
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}