train_mask_detection.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import os\n",
    "import cv2\n",
    "import sklearn as sk\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from tensorflow import keras\n",
    "#from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
    "#from tensorflow.keras.applications import MobileNetV2\n",
    "#from keras.applications.mobilenet_v2 import preprocess_input\n",
    "from keras.preprocessing.image import img_to_array, load_img\n",
    "from tensorflow.keras.utils import to_categorical\n",
    "from sklearn.preprocessing import LabelBinarizer, LabelEncoder\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import classification_report\n",
    "\n",
    "from tensorflow.keras.layers import AveragePooling2D, Dropout, Flatten, Dense, Input, Conv2D, MaxPooling2D\n",
    "from keras.models import Model, Sequential\n",
    "from tensorflow.keras.optimizers import Adam\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_path = \"/Users/bradleyherctt/Documents/GitHub/face-mask-recognition/dataset\"\n",
    "classes = [\"with_mask\", \"without_mask\", \"incorrect_mask\"]\n",
    "\n",
    "data = []\n",
    "labels = []\n",
    "test_train = []\n",
    "shape = (128, 128)\n",
    "\n",
    "imgs_with_mask = os.listdir(data_path + \"/\" + classes[0])\n",
    "imgs_without_mask = os.listdir(data_path + \"/\" + classes[1])\n",
    "imgs_incorrect_mask = os.listdir(data_path + \"/\" + classes[2])\n",
    "\n",
    "images = [imgs_with_mask, imgs_without_mask, imgs_incorrect_mask]\n",
    "\n",
    "length_with_mask = len(imgs_with_mask)\n",
    "length_without_mask = len(imgs_without_mask)\n",
    "length_incorrect_mask = len(imgs_incorrect_mask)\n",
    "\n",
    "lengths = [length_with_mask, length_without_mask, length_incorrect_mask]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_with_mask = []\n",
    "test_with_mask = []\n",
    "\n",
    "train_without_mask = []\n",
    "test_without_mask = []\n",
    "\n",
    "train_incorrect_mask = []\n",
    "test_incorrect_mask = []\n",
    "\n",
    "partitions = [train_with_mask, train_without_mask, train_incorrect_mask, test_with_mask, test_without_mask, test_incorrect_mask]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All images partitioned into training (80%) & testing (20%) categories successfully.\n"
     ]
    }
   ],
   "source": [
    "# split into 2 groups\n",
    "# 20% testing, 80% training\n",
    "for x in range(3):\n",
    "    i = 0\n",
    "    for img in images[x]:\n",
    "        i += 1\n",
    "        if i - 1 <= 0.8 * lengths[x]:\n",
    "            partitions[x].append(img)\n",
    "        else:\n",
    "            partitions[x + 3].append(img)\n",
    "\n",
    "print(\"All images partitioned into training (80%) & testing (20%) categories successfully.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "init_lr = 1e-4\n",
    "epochs = 5\n",
    "batch_size = 32"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "with_mask\n",
      "without_mask\n",
      "incorrect_mask\n"
     ]
    }
   ],
   "source": [
    "test_data = []\n",
    "test_labels = []\n",
    "train_labels = []\n",
    "train_data = []\n",
    "\n",
    "for i in range(3):\n",
    "    local_path = os.path.join(data_path, classes[i])\n",
    "    x = 0\n",
    "    for img in os.listdir(local_path):\n",
    "        x += 1\n",
    "        img_path = os.path.join(local_path, img)\n",
    "        new_img = load_img(img_path, target_size = shape)\n",
    "        new_img = img_to_array(new_img)\n",
    "        #new_img = cv2.resize(new_img, shape)\n",
    "\n",
    "        data.append(new_img)\n",
    "        labels.append(classes[i])\n",
    "\n",
    "        if (x <= 0.2 * lengths[i]):\n",
    "            test_train.append(\"test\")\n",
    "            test_data.append(new_img)\n",
    "            test_labels.append(classes[i])\n",
    "        else:\n",
    "            test_train.append(\"train\")\n",
    "            train_data.append(new_img)\n",
    "            train_labels.append(classes[i])\n",
    "\n",
    "    print(classes[i])\n",
    "\n",
    "total_length_index = len(labels)\n",
    "\n",
    "#for c in classes:\n",
    "#    local_path = os.path.join(data_path, x)\n",
    "#    for img in os.listdir(local_path):\n",
    "#        img_path = os.path.join(local_path, img)\n",
    "#        new_img = load_img(img_path, target_size=(128, 128))\n",
    "#        new_img = img_to_array(new_img)\n",
    "#        new_img = preprocess_input(new_img)\n",
    "#\n",
    "#        data.append(new_img)\n",
    "#        labels.append(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'z_incorrect_mask'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for q in range(total_length_index):\n",
    "    if labels[q] == 'incorrect_mask':\n",
    "        labels[q] = \"z_incorrect_mask\"\n",
    "\n",
    "labels[6000]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = np.array(data, dtype=\"float32\")\n",
    "labels = np.array(labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_data = np.array(data, dtype=\"float32\")\n",
    "train_data = np.array(data, dtype=\"float32\")\n",
    "test_labels = np.array(test_labels)\n",
    "train_labels = np.array(train_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "le = LabelEncoder()\n",
    "labels = le.fit_transform(labels)\n",
    "labels = to_categorical(labels)\n",
    "#test_labels = le.fit_transform(test_labels)\n",
    "#test_labels = to_categorical(test_labels)\n",
    "#train_labels = le.fit_transform(train_labels)\n",
    "#train_labels = to_categorical(train_labels)\n",
    "\n",
    "lb = LabelBinarizer()\n",
    "test_train = lb.fit_transform(test_train)\n",
    "test_train = to_categorical(test_train)\n",
    "\n",
    "\n",
    "#(trainX, testX, trainY, testY) = train_test_split(data, labels, test_size=0.20, stratify=labels, random_state=42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# no need for data augmentations, dataset already augmented\n",
    "# imagenet pre-trained model specifically for images\n",
    "# \n",
    "#base_mdl = tf.keras.applications.MobileNetV2(weights=\"imagenet\", include_top=False, input_tensor=Input(shape=(128, 128, 3)))\n",
    "\n",
    "# \n",
    "#head_mdl = base_mdl.output\n",
    "#head_mdl = AveragePooling2D(pool_size=(3, 3))(head_mdl)\n",
    "#head_mdl = Flatten(name=\"flatten\")(head_mdl)\n",
    "# 128 neurons\n",
    "#head_mdl = Dense(128, activation=\"relu\")(head_mdl)\n",
    "# helps prevent overfitting\n",
    "#head_mdl = Dropout(0.5)(head_mdl)\n",
    "# 2 layers, with/without mask\n",
    "#head_mdl =  \n",
    "\n",
    "model = Sequential([\n",
    "    Conv2D(32, (3, 3), input_shape = (128, 128, 3)),\n",
    "    MaxPooling2D(2, 2),\n",
    "    Conv2D(32, (3, 3)),\n",
    "    MaxPooling2D(2, 2),\n",
    "    Flatten(),\n",
    "    Dense(128, activation = \"relu\"),\n",
    "    Dense(3, activation = \"softmax\")\n",
    "])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " conv2d_2 (Conv2D)           (None, 126, 126, 32)      896       \n",
      "                                                                 \n",
      " max_pooling2d_2 (MaxPooling  (None, 63, 63, 32)       0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " conv2d_3 (Conv2D)           (None, 61, 61, 32)        9248      \n",
      "                                                                 \n",
      " max_pooling2d_3 (MaxPooling  (None, 30, 30, 32)       0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " flatten_1 (Flatten)         (None, 28800)             0         \n",
      "                                                                 \n",
      " dense_2 (Dense)             (None, 128)               3686528   \n",
      "                                                                 \n",
      " dense_3 (Dense)             (None, 3)                 387       \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 3,697,059\n",
      "Trainable params: 3,697,059\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "# place head on top of base\n",
    "model.summary()\n",
    "#model = Model(inputs = base_mdl.input, outputs = head_mdl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Compiling model...\n",
      "Epoch 1/5\n",
      "225/225 [==============================] - 74s 325ms/step - loss: 10.3239 - accuracy: 0.7115 - val_loss: 1.1797 - val_accuracy: 0.0640\n",
      "Epoch 2/5\n",
      "225/225 [==============================] - 84s 371ms/step - loss: 0.4486 - accuracy: 0.7826 - val_loss: 1.2639 - val_accuracy: 0.0184\n",
      "Epoch 3/5\n",
      "225/225 [==============================] - 87s 389ms/step - loss: 0.3720 - accuracy: 0.7981 - val_loss: 1.1651 - val_accuracy: 0.0657\n",
      "Epoch 4/5\n",
      "225/225 [==============================] - 86s 381ms/step - loss: 0.3268 - accuracy: 0.8164 - val_loss: 1.1711 - val_accuracy: 0.0434\n",
      "Epoch 5/5\n",
      "225/225 [==============================] - 80s 354ms/step - loss: 0.3153 - accuracy: 0.8251 - val_loss: 1.1512 - val_accuracy: 0.1113\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x15f61e320>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"Compiling model...\")\n",
    "opt = Adam(learning_rate = init_lr, decay = init_lr / epochs)\n",
    "model.compile(loss = \"categorical_crossentropy\", optimizer = opt, metrics = [\"accuracy\"])\n",
    "model.fit(data, labels, batch_size=batch_size, epochs=epochs, validation_split=0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 1., 0.],\n",
       "       [0., 1., 0.],\n",
       "       [0., 1., 0.],\n",
       "       ...,\n",
       "       [1., 0., 0.],\n",
       "       [1., 0., 0.],\n",
       "       [1., 0., 0.]], dtype=float32)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Compiling model...\n",
      "Training head...\n",
      "Epoch 1/5\n",
      "149/149 [==============================] - 86s 559ms/step - loss: 0.2435 - accuracy: 0.9241 - val_loss: 0.0357 - val_accuracy: 0.9907\n",
      "Epoch 2/5\n",
      "149/149 [==============================] - 77s 519ms/step - loss: 0.0535 - accuracy: 0.9840 - val_loss: 0.0257 - val_accuracy: 0.9941\n",
      "Epoch 3/5\n",
      "149/149 [==============================] - 87s 587ms/step - loss: 0.0363 - accuracy: 0.9887 - val_loss: 0.0230 - val_accuracy: 0.9941\n",
      "Epoch 4/5\n",
      "149/149 [==============================] - 75s 502ms/step - loss: 0.0272 - accuracy: 0.9920 - val_loss: 0.0232 - val_accuracy: 0.9932\n",
      "Epoch 5/5\n",
      "149/149 [==============================] - 68s 458ms/step - loss: 0.0205 - accuracy: 0.9939 - val_loss: 0.0211 - val_accuracy: 0.9941\n"
     ]
    }
   ],
   "source": [
    "#print(\"Compiling model...\")\n",
    "#opt = Adam(learning_rate = init_lr, decay = init_lr / epochs) # Adam optimizer being used\n",
    "#model.compile(loss = \"binary_crossentropy\", optimizer = opt, metrics = [\"accuracy\"])\n",
    "\n",
    "\n",
    "#F = model.fit(x=trainX, y=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": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] evaluating network...\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "   with_mask       1.00      0.99      0.99       599\n",
      "without_mask       0.99      1.00      0.99       599\n",
      "\n",
      "    accuracy                           0.99      1198\n",
      "   macro avg       0.99      0.99      0.99      1198\n",
      "weighted avg       0.99      0.99      0.99      1198\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#print(\"[INFO] evaluating network...\")\n",
    "#predIdxs = model.predict(testX, batch_size=batch_size)\n",
    "#predIdxs = np.argmax(predIdxs, axis=1)\n",
    "#print(classification_report(testY.argmax(axis=1), predIdxs,\n",
    "#\ttarget_names=lb.classes_))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x155ef04f0>"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#N = epochs\n",
    "#plt.style.use(\"ggplot\")\n",
    "#plt.figure()\n",
    "#plt.plot(np.arange(0, N), F.history[\"loss\"], label=\"train_loss\")\n",
    "#plt.plot(np.arange(0, N), F.history[\"val_loss\"], label=\"val_loss\")\n",
    "#plt.plot(np.arange(0, N), F.history[\"accuracy\"], label=\"train_acc\")\n",
    "#plt.plot(np.arange(0, N), F.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(args[\"plot\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(10,5))\n",
    "\n",
    "plt.subplot(221)\n",
    "plt.plot(history.history['accuracy'),\"\n",
    "plt.plot(history.history(\"val accuracy'],\n",
    "Na--\n",
    "plt.title(\"train_ace vs val_acc)\n",
    "plt.ylabel(\"accuracy\")\n",
    "plt.xlabel(\"epochs\"\n",
    "plt.legend()\n",
    "a lanol-\n",
    "# Plot loss function\n",
    "plt. subplot(222)\n",
    "plt.plot(history. history('loss'], 'bo-•\n",
    "label\n",
    "plt.plot(history.history['val loss').\n",
    "•RO--\n",
    "plt.title(\"train loss vs val loss\")\n",
    "plt.ylabel(\"loss-)\n",
    "plt.xlabel(\"epochs\"\n",
    "loce\n",
    "12h61-\n",
    "\"val_loss\")\n",
    "plt.legend()\n",
    "plt.show@)"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "949777d72b0d2535278d3dc13498b2535136f6dfe0678499012e853ee9abcab1"
  },
  "kernelspec": {
   "display_name": "Python 3.10.4 64-bit",
   "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.10.4"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}