{ "cells": [ { "cell_type": "code", "execution_count": null, "id": "b1d8379f", "metadata": {}, "outputs": [], "source": [ "!pip install tf_keras" ] }, { "cell_type": "code", "execution_count": 28, "id": "64b101f5", "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 os" ] }, { "cell_type": "code", "execution_count": 29, "id": "b4822912", "metadata": {}, "outputs": [], "source": [ "# Initialize the initial learning rate, number of epochs to train for,\n", "# and batch size\n", "INIT_LR = 1e-4\n", "EPOCHS = 2\n", "BS = 32\n", "DIRECTORY = '../assets/dataset'" ] }, { "cell_type": "code", "execution_count": 30, "id": "4f22baac", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "without_mask\n", "with_mask\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "d:\\Programming\\Projects\\Mask_detector\\maskVenv\\Lib\\site-packages\\PIL\\Image.py:1000: UserWarning: Palette images with Transparency expressed in bytes should be converted to RGBA images\n", " warnings.warn(\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "['without_mask', 'without_mask', 'without_mask', 'without_mask', 'without_mask', 'without_mask', 'without_mask', 'without_mask', 'without_mask', 'without_mask']\n" ] } ], "source": [ "data = []\n", "labels = []\n", "\n", "for category in os.listdir(DIRECTORY):\n", " print(category)\n", " path = os.path.join(DIRECTORY, category)\n", " for img in os.listdir(path):\n", " img_path = os.path.join(path, img)\n", " image = load_img(img_path, target_size=(224, 224))\n", " image = img_to_array(image)\n", " image = preprocess_input(image)\n", " \n", " data.append(image)\n", " labels.append(category)\n", " \n", "print(labels[:10])" ] }, { "cell_type": "code", "execution_count": 31, "id": "71e7f1b6", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Before: [[1]\n", " [1]] ,type: \n", "After: [[0. 1.]\n", " [0. 1.]] ,type: \n", "Before-data: [array([[[ 0.94509804, 0.94509804, 0.94509804],\n", " [ 0.94509804, 0.94509804, 0.94509804],\n", " [ 0.94509804, 0.94509804, 0.94509804],\n", " ...,\n", " [ 0.92941177, 0.92941177, 0.92941177],\n", " [ 0.92941177, 0.92941177, 0.92941177],\n", " [ 0.92941177, 0.92941177, 0.92941177]],\n", "\n", " [[ 0.94509804, 0.94509804, 0.94509804],\n", " [ 0.94509804, 0.94509804, 0.94509804],\n", " [ 0.94509804, 0.94509804, 0.94509804],\n", " ...,\n", " [ 0.92941177, 0.92941177, 0.92941177],\n", " [ 0.92941177, 0.92941177, 0.92941177],\n", " [ 0.92941177, 0.92941177, 0.92941177]],\n", "\n", " [[ 0.94509804, 0.94509804, 0.94509804],\n", " [ 0.94509804, 0.94509804, 0.94509804],\n", " [ 0.94509804, 0.94509804, 0.94509804],\n", " ...,\n", " [ 0.92941177, 0.92941177, 0.92941177],\n", " [ 0.92941177, 0.92941177, 0.92941177],\n", " [ 0.92941177, 0.92941177, 0.92941177]],\n", "\n", " ...,\n", "\n", " [[-0.7176471 , -0.7176471 , -0.7176471 ],\n", " [-0.7176471 , -0.7176471 , -0.7176471 ],\n", " [-0.64705884, -0.64705884, -0.64705884],\n", " ...,\n", " [-0.7882353 , -0.7882353 , -0.7882353 ],\n", " [-0.7882353 , -0.7882353 , -0.7882353 ],\n", " [-0.7882353 , -0.7882353 , -0.7882353 ]],\n", "\n", " [[-0.70980394, -0.70980394, -0.70980394],\n", " [-0.70980394, -0.70980394, -0.70980394],\n", " [-0.64705884, -0.64705884, -0.64705884],\n", " ...,\n", " [-0.79607844, -0.79607844, -0.79607844],\n", " [-0.79607844, -0.79607844, -0.79607844],\n", " [-0.79607844, -0.79607844, -0.79607844]],\n", "\n", " [[-0.70980394, -0.70980394, -0.70980394],\n", " [-0.70980394, -0.70980394, -0.70980394],\n", " [-0.64705884, -0.64705884, -0.64705884],\n", " ...,\n", " [-0.79607844, -0.79607844, -0.79607844],\n", " [-0.79607844, -0.79607844, -0.79607844],\n", " [-0.79607844, -0.79607844, -0.79607844]]], dtype=float32), array([[[ 0.58431375, 0.52156866, 0.62352943],\n", " [ 0.5529412 , 0.4901961 , 0.5921569 ],\n", " [ 0.5529412 , 0.4901961 , 0.5921569 ],\n", " ...,\n", " [ 0.5372549 , 0.52156866, 0.54509807],\n", " [ 0.5372549 , 0.52156866, 0.54509807],\n", " [ 0.5529412 , 0.5372549 , 0.56078434]],\n", "\n", " [[ 0.58431375, 0.52156866, 0.62352943],\n", " [ 0.5529412 , 0.4901961 , 0.5921569 ],\n", " [ 0.5529412 , 0.4901961 , 0.5921569 ],\n", " ...,\n", " [ 0.5372549 , 0.52156866, 0.54509807],\n", " [ 0.5372549 , 0.52156866, 0.54509807],\n", " [ 0.5529412 , 0.5372549 , 0.56078434]],\n", "\n", " [[ 0.58431375, 0.52156866, 0.62352943],\n", " [ 0.58431375, 0.52156866, 0.62352943],\n", " [ 0.58431375, 0.52156866, 0.62352943],\n", " ...,\n", " [ 0.5529412 , 0.5372549 , 0.56078434],\n", " [ 0.5529412 , 0.5372549 , 0.56078434],\n", " [ 0.58431375, 0.5686275 , 0.5921569 ]],\n", "\n", " ...,\n", "\n", " [[-0.1372549 , -0.18431371, 0.03529418],\n", " [ 0.17647064, 0.12941182, 0.34901965],\n", " [ 0.17647064, 0.12941182, 0.34901965],\n", " ...,\n", " [ 0.12941182, 0.05098045, 0.24705887],\n", " [ 0.12941182, 0.05098045, 0.24705887],\n", " [ 0.33333337, 0.254902 , 0.4431373 ]],\n", "\n", " [[ 0.04313731, 0.01176476, 0.20784318],\n", " [ 0.3411765 , 0.30980396, 0.5058824 ],\n", " [ 0.3411765 , 0.30980396, 0.5058824 ],\n", " ...,\n", " [-0.27058822, -0.34117645, -0.12941176],\n", " [-0.27058822, -0.34117645, -0.12941176],\n", " [-0.05098039, -0.11372548, 0.07450986]],\n", "\n", " [[ 0.04313731, 0.01176476, 0.20784318],\n", " [ 0.3411765 , 0.30980396, 0.5058824 ],\n", " [ 0.3411765 , 0.30980396, 0.5058824 ],\n", " ...,\n", " [-0.27058822, -0.34117645, -0.12941176],\n", " [-0.27058822, -0.34117645, -0.12941176],\n", " [-0.05098039, -0.11372548, 0.07450986]]], dtype=float32)] ,type: \n", "After-After: [[0. 1.]\n", " [0. 1.]] ,type: \n" ] } ], "source": [ "# perform one-hot encoding on the labels\n", "lb = LabelBinarizer()\n", "labels = lb.fit_transform(labels)\n", "print(\"Before: \", labels[:2],\" ,type: \",type(labels))\n", "labels = to_categorical(labels)\n", "print(\"After: \", labels[:2],\" ,type: \",type(labels))\n", "\n", "print(\"Before-data: \", data[:2],\" ,type: \",type(data))\n", "data = np.array(data, dtype=\"float32\")\n", "labels = np.array(labels)\n", "print(\"After-After: \", labels[:2],\" ,type: \",type(labels))" ] }, { "cell_type": "code", "execution_count": 32, "id": "c608337a", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[0., 1.],\n", " [0., 1.],\n", " [0., 1.],\n", " [0., 1.],\n", " [0., 1.],\n", " [0., 1.],\n", " [0., 1.],\n", " [0., 1.],\n", " [0., 1.],\n", " [0., 1.]])" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "labels[:10]" ] }, { "cell_type": "code", "execution_count": 33, "id": "b4a1c892", "metadata": {}, "outputs": [], "source": [ "(trainX, testX, trainY, testY) = train_test_split(data, labels, test_size=0.20, stratify=labels, random_state=42)" ] }, { "cell_type": "code", "execution_count": 34, "id": "716b83e5", "metadata": {}, "outputs": [], "source": [ "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": 35, "id": "0772282d", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "C:\\Users\\VickyWadh\\AppData\\Local\\Temp\\ipykernel_25156\\3680935412.py:2: 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", " baseModel = MobileNetV2(weights=\"imagenet\", include_top=False,\n" ] } ], "source": [ "# load the MobileNetV2 network, ensuring the head FC Layer sets are left off\n", "baseModel = MobileNetV2(weights=\"imagenet\", include_top=False,\n", " input_tensor=Input(shape=(224,224,3)))" ] }, { "cell_type": "code", "execution_count": 36, "id": "185ef084", "metadata": {}, "outputs": [], "source": [ "# construct the head of the model that will be placed on the 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": 37, "id": "204919cd", "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": 38, "id": "27601586", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ] } ], "source": [ "# loop over all the layers in the base model and freeze them so they will \n", "# *not* be updated during the first training process\n", "for layer in baseModel.layers:\n", " print(layer)\n", " layer.trainable = False" ] }, { "cell_type": "code", "execution_count": 45, "id": "3be244cf", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[INFO] compiling model...\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "d:\\Programming\\Projects\\Mask_detector\\maskVenv\\Lib\\site-packages\\keras\\src\\optimizers\\base_optimizer.py:33: UserWarning: Argument `decay` is no longer supported and will be ignored.\n", " warnings.warn(\n" ] } ], "source": [ "import tensorflow as tf\n", "# compile our model\n", "print(\"[INFO] compiling model...\")\n", "opt = Adam(learning_rate=INIT_LR, decay=INIT_LR / EPOCHS)\n", "model.compile(loss=\"binary_crossentropy\", optimizer=opt,metrics=[\"accuracy\"])" ] }, { "cell_type": "code", "execution_count": 46, "id": "18a9b4e5", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[INFO] training head...\n", "Epoch 1/2\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "d:\\Programming\\Projects\\Mask_detector\\maskVenv\\Lib\\site-packages\\keras\\src\\trainers\\data_adapters\\py_dataset_adapter.py:121: UserWarning: Your `PyDataset` class should call `super().__init__(**kwargs)` in its constructor. `**kwargs` can include `workers`, `use_multiprocessing`, `max_queue_size`. Do not pass these arguments to `fit()`, as they will be ignored.\n", " self._warn_if_super_not_called()\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\u001b[1m188/188\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m219s\u001b[0m 1s/step - accuracy: 0.8356 - loss: 0.4183 - val_accuracy: 0.9742 - val_loss: 0.0843\n", "Epoch 2/2\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "C:\\Users\\VickyWadh\\anaconda3\\Lib\\contextlib.py:155: UserWarning: Your input ran out of data; interrupting training. Make sure that your dataset or generator can generate at least `steps_per_epoch * epochs` batches. You may need to use the `.repeat()` function when building your dataset.\n", " self.gen.throw(typ, value, traceback)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\u001b[1m188/188\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 168ms/step - accuracy: 0.9688 - loss: 0.0960 - val_accuracy: 0.9735 - val_loss: 0.0840\n" ] } ], "source": [ "# train the head of the network\n", "print(\"[INFO] training head...\")\n", "H = model.fit(\n", " aug.flow(trainX, trainY, batch_size=BS),\n", " steps_per_epoch=len(trainX) // BS,\n", " validation_data=(testX, testY),\n", " validation_steps=len(testX) // BS,\n", " epochs=EPOCHS)" ] }, { "cell_type": "code", "execution_count": 47, "id": "634f0d23", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[INFO] evaluating network...\n", "\u001b[1m48/48\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 688ms/step\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": 48, "id": "1a891386", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " precision recall f1-score support\n", "\n", " with_mask 0.97 0.97 0.97 745\n", "without_mask 0.98 0.97 0.97 766\n", "\n", " accuracy 0.97 1511\n", " macro avg 0.97 0.97 0.97 1511\n", "weighted avg 0.97 0.97 0.97 1511\n", "\n" ] } ], "source": [ "# for each image in the testing set we need to find the index of the label\n", "# with corresponding largest predicted probability\n", "predIdxs = np.argmax(predIdxs, axis=1)\n", "\n", "# show a nicely formatted classification report\n", "print(classification_report(testY.argmax(axis=1), predIdxs, target_names=lb.classes_))" ] }, { "cell_type": "code", "execution_count": 51, "id": "500c8e0a", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[INFO] saving mask detector model...\n" ] } ], "source": [ "# serialize the model to disk\n", "print(\"[INFO] saving mask detector model...\")\n", "model.save(\"../assets/model/mask_detector.keras\")" ] }, { "cell_type": "code", "execution_count": 52, "id": "4fa65710", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# plotting the training loss and accuracy\n", "N = len(H.history['loss'])\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,len(H.history['val_loss'])), 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,len(H.history[\"val_accuracy\"])), 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(\"plot.png\")" ] }, { "cell_type": "code", "execution_count": 53, "id": "eaee9298", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'accuracy': [0.9156405925750732, 0.96875],\n", " 'loss': [0.25978943705558777, 0.0960015207529068],\n", " 'val_accuracy': [0.974189281463623, 0.9735274910926819],\n", " 'val_loss': [0.0842733383178711, 0.08401167392730713]}" ] }, "execution_count": 53, "metadata": {}, "output_type": "execute_result" } ], "source": [ "H.history" ] }, { "cell_type": "code", "execution_count": null, "id": "f907650a", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "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.11.5" } }, "nbformat": 4, "nbformat_minor": 5 }