Facemask_detection_last1_Final.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Valiev-Koyiljon/Face-mask-detection-Pytorch/blob/main/Facemask_detection_last1_Final.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ld7UXiLgi9nk"
      },
      "source": [
        "#Facemask Detection\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GRT0CJM9k0jl"
      },
      "source": [
        "\n",
        "Title: Real-time Face Mask Detection using Pre-trained ResNet Model\n",
        "\n",
        "Description:\n",
        "The project aims to detect whether a person is wearing a face mask or not in real-time using computer vision techniques and a pre-trained ResNet model. The system captures video frames from a webcam, applies face detection to locate faces in the frames, and then utilizes a deep learning model to classify each detected face as either wearing a mask or not.\n",
        "\n",
        "The project consists of two main parts:\n",
        "\n",
        "1. Training the Face Mask Detection Model:\n",
        "   - The project starts with training a face mask detection model using a pre-trained ResNet model.\n",
        "   - A dataset of 100 images is used for training the model, where each image is labeled as either having a person wearing a mask or not.\n",
        "   - The pre-trained ResNet model, specifically ResNet-50, is employed as a feature extractor, and the final fully connected layer is modified to have two output neurons representing mask and no-mask classes.\n",
        "   - The model is trained using the dataset, and the training process involves optimizing the model's parameters using an Adam optimizer and cross-entropy loss.\n",
        "   - After training, the model is saved to a file for later use during real-time face mask detection.\n",
        "\n",
        "2. Real-time Face Mask Detection:\n",
        "   - Once the model is trained and saved, the project focuses on real-time face mask detection using OpenCV.\n",
        "   - The system captures video frames from the webcam and applies face detection using the Haar cascade classifier provided by OpenCV.\n",
        "   - For each detected face, the model is utilized to classify whether the person is wearing a mask or not by passing the face through the trained model.\n",
        "   - The result is then displayed on the screen by drawing a rectangle around the face and adding a label indicating whether the person is wearing a mask or not.\n",
        "   - The process continues in real-time, detecting faces and updating the display accordingly.\n",
        "   - The system allows the user to exit the application by pressing the 'q' key.\n",
        "\n",
        "The project combines deep learning techniques with computer vision to address the important task of face mask detection. It can be applied in various settings, such as public spaces, workplaces, and healthcare facilities, to help ensure adherence to face mask policies and promote public health and safety."
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Deep Learning. Part I"
      ],
      "metadata": {
        "id": "0tToFcQuh1t6"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FbTn6pw8zOuO",
        "outputId": "7ba7d0d8-c568-48df-c782-248ac4271c14"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ],
      "source": [
        "# Mounting google drive to colab\n",
        "\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AwRQCBEyzqVB",
        "outputId": "c6fc522b-85de-4c9c-fa61-56491a37cee1"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Folder extraction completed.\n"
          ]
        }
      ],
      "source": [
        "import zipfile\n",
        "\n",
        "\n",
        "#  path to the ZIP file\n",
        "zip_file_path = \"/content/drive/MyDrive/Colab Notebooks/mask_images_ready.zip\"\n",
        "destination_folder = \"/content/drive/MyDrive/Colab Notebooks/\"\n",
        "with zipfile.ZipFile(zip_file_path, 'r') as zip_ref:\n",
        "    zip_ref.extractall(destination_folder)\n",
        "\n",
        "\n",
        "print(\"Folder extraction completed.\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 52,
      "metadata": {
        "id": "Ir_4iYKUO8jo"
      },
      "outputs": [],
      "source": [
        "# Import necessary packages and libraries\n",
        "import os\n",
        "import cv2\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "import torch.nn.functional as F\n",
        "from torch.utils.data import Dataset, DataLoader\n",
        "from torchvision import transforms, models\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 53,
      "metadata": {
        "id": "4q4dlSH6BMNk"
      },
      "outputs": [],
      "source": [
        "# changing the device\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 54,
      "metadata": {
        "id": "V9yqjG37BOl9"
      },
      "outputs": [],
      "source": [
        "#  FaceMaskDataset class for training, validation, and test data\n",
        "class FaceMaskDataset(Dataset):\n",
        "    def __init__(self, image_paths, labels, transform=None):\n",
        "        self.image_paths = image_paths\n",
        "        self.labels = labels\n",
        "        self.transform = transform\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.image_paths)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        image_path = self.image_paths[idx]\n",
        "        label = self.labels[idx]\n",
        "        image = cv2.imread(image_path)\n",
        "        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
        "        image = cv2.resize(image, (224, 224))\n",
        "\n",
        "        if self.transform:\n",
        "            image = self.transform(image)\n",
        "\n",
        "        return image, label"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 55,
      "metadata": {
        "id": "uNMz5n10BX6D"
      },
      "outputs": [],
      "source": [
        "# FaceMaskDetector class\n",
        "class FaceMaskDetector:\n",
        "    def __init__(self, model_path):\n",
        "        self.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "        self.model = self.load_model(model_path).to(self.device)\n",
        "        self.transform = transforms.Compose([\n",
        "            transforms.ToPILImage(),\n",
        "            transforms.Resize((224, 224)),\n",
        "            transforms.ToTensor(),\n",
        "            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n",
        "        ])\n",
        "\n",
        "    def load_model(self, model_path):\n",
        "        model = models.resnet50(pretrained=False)\n",
        "        num_features = model.fc.in_features\n",
        "        model.fc = nn.Linear(num_features, 2)\n",
        "        model.load_state_dict(torch.load(model_path, map_location=self.device))\n",
        "        model.eval()\n",
        "        return model\n",
        "\n",
        "    def detect(self, frame):\n",
        "        frame = self.transform(frame).unsqueeze(0).to(self.device)\n",
        "        with torch.no_grad():\n",
        "            output = self.model(frame)\n",
        "        probabilities = torch.softmax(output, dim=1)[0]\n",
        "        mask_probability = probabilities[1].item()\n",
        "        no_mask_probability = probabilities[0].item()\n",
        "        label = \"Mask\" if mask_probability > no_mask_probability else \"No Mask\"\n",
        "        return label"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 56,
      "metadata": {
        "id": "SIUyRUYJBdaj"
      },
      "outputs": [],
      "source": [
        "# The training parameters\n",
        "train_data_dir = \"/content/drive/MyDrive/Colab Notebooks/mask_images_ready/train\"\n",
        "val_data_dir = \"/content/drive/MyDrive/Colab Notebooks/mask_images_ready/val\"\n",
        "test_data_dir = \"/content/drive/MyDrive/Colab Notebooks/mask_images_ready/test\"\n",
        "model_save_path = \"/content/drive/MyDrive/Colab Notebooks/Final_FaceMask_detection_model.pt\"\n",
        "batch_size = 16\n",
        "num_epochs = 12"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 57,
      "metadata": {
        "id": "jzCgrc3qBjbB"
      },
      "outputs": [],
      "source": [
        "# Load the training data\n",
        "train_image_paths = []\n",
        "train_labels = []\n",
        "\n",
        "for folder_name in os.listdir(train_data_dir):\n",
        "    folder_path = os.path.join(train_data_dir, folder_name)\n",
        "    if os.path.isdir(folder_path):\n",
        "        for file_name in os.listdir(folder_path):\n",
        "            if file_name.endswith(\".png\"): \n",
        "                file_path = os.path.join(folder_path, file_name)\n",
        "                train_image_paths.append(file_path)\n",
        "                train_labels.append(1 if folder_name == \"1\" else 0)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 58,
      "metadata": {
        "id": "gg5NWFP9Bldu"
      },
      "outputs": [],
      "source": [
        "# Load the validation data\n",
        "val_image_paths = []\n",
        "val_labels = []\n",
        "\n",
        "for folder_name in os.listdir(val_data_dir):\n",
        "    folder_path = os.path.join(val_data_dir, folder_name)\n",
        "    if os.path.isdir(folder_path):\n",
        "        for file_name in os.listdir(folder_path):\n",
        "            if file_name.endswith(\".png\"):\n",
        "                file_path = os.path.join(folder_path, file_name)\n",
        "                val_image_paths.append(file_path)\n",
        "                val_labels.append(1 if folder_name == \"1\" else 0)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 59,
      "metadata": {
        "id": "20jEDZs_BlI6"
      },
      "outputs": [],
      "source": [
        "# Load the test data\n",
        "test_image_paths = []\n",
        "test_labels = []\n",
        "\n",
        "for folder_name in os.listdir(test_data_dir):\n",
        "    folder_path = os.path.join(test_data_dir, folder_name)\n",
        "    if os.path.isdir(folder_path):\n",
        "        for file_name in os.listdir(folder_path):\n",
        "            if file_name.endswith(\".png\"):\n",
        "                file_path = os.path.join(folder_path, file_name)\n",
        "                test_image_paths.append(file_path)\n",
        "                test_labels.append(1 if folder_name == \"1\" else 0)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 60,
      "metadata": {
        "id": "JLL6meijB0Fr"
      },
      "outputs": [],
      "source": [
        "# FaceMaskDataset class for training, validation, and test data\n",
        "train_dataset = FaceMaskDataset(train_image_paths, train_labels, transform=transforms.ToTensor())\n",
        "val_dataset = FaceMaskDataset(val_image_paths, val_labels, transform=transforms.ToTensor())\n",
        "test_dataset = FaceMaskDataset(test_image_paths, test_labels, transform=transforms.ToTensor())\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 61,
      "metadata": {
        "id": "NlObLVgUB1sk"
      },
      "outputs": [],
      "source": [
        "#  training, validation, and test data loaders\n",
        "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
        "val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)\n",
        "test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Function to show a batch of images during training\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "def show_batch(images, labels):\n",
        "    fig, axes = plt.subplots(figsize=(12, 6), ncols=4)\n",
        "    for i, ax in enumerate(axes):\n",
        "        ax.imshow(images[i].permute(1, 2, 0))\n",
        "        ax.set_title(\"With Mask\" if labels[i] == 1 else \"Without Mask\")\n",
        "        ax.axis(\"off\")\n",
        "    plt.tight_layout()\n",
        "    plt.show()\n"
      ],
      "metadata": {
        "id": "U9vDPEj39Lxu"
      },
      "execution_count": 62,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 63,
      "metadata": {
        "id": "GLjJ5QJWB8Td",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "71f20b76-c900-4c72-c768-c3de7ddeb0c8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.10/dist-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=ResNet50_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet50_Weights.DEFAULT` to get the most up-to-date weights.\n",
            "  warnings.warn(msg)\n"
          ]
        }
      ],
      "source": [
        "# FaceMaskModel class\n",
        "class FaceMaskModel(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(FaceMaskModel, self).__init__()\n",
        "        self.model = models.resnet50(pretrained=True)\n",
        "        num_features = self.model.fc.in_features\n",
        "        self.model.fc = nn.Linear(num_features, 2)\n",
        "\n",
        "    def forward(self, x):\n",
        "        return self.model(x)\n",
        "\n",
        "\n",
        "\n",
        "# FaceMaskModel class\n",
        "model = FaceMaskModel()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 64,
      "metadata": {
        "id": "j1tvcCZ7CIlC"
      },
      "outputs": [],
      "source": [
        "# the loss function, optimizer, and learning rate scheduler\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = optim.Adam(model.parameters(), lr=0.001)\n",
        "scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=3, gamma=0.1)\n",
        "\n",
        "\n",
        "# Move the model to the device\n",
        "model = model.to(device)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 68,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "08DxA2T2CIOs",
        "outputId": "309a3aaf-0e06-4e5b-ccc9-66928cf12c36",
        "scrolled": true
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/12\n",
            "Train Loss: 0.0040 | Train Accuracy: 100.00%\n",
            "Val Loss: 0.0004 | Val Accuracy: 100.00%\n",
            "-------------------------------\n",
            "Epoch 2/12\n",
            "Train Loss: 0.0005 | Train Accuracy: 100.00%\n",
            "Val Loss: 0.0004 | Val Accuracy: 100.00%\n",
            "-------------------------------\n",
            "Epoch 3/12\n",
            "Train Loss: 0.0010 | Train Accuracy: 100.00%\n",
            "Val Loss: 0.0005 | Val Accuracy: 100.00%\n",
            "-------------------------------\n",
            "Epoch 4/12\n",
            "Train Loss: 0.4237 | Train Accuracy: 91.67%\n",
            "Val Loss: 0.0130 | Val Accuracy: 100.00%\n",
            "-------------------------------\n",
            "Epoch 5/12\n",
            "Train Loss: 0.0156 | Train Accuracy: 100.00%\n",
            "Val Loss: 0.0056 | Val Accuracy: 100.00%\n",
            "-------------------------------\n",
            "Epoch 6/12\n",
            "Train Loss: 0.0285 | Train Accuracy: 100.00%\n",
            "Val Loss: 0.0126 | Val Accuracy: 100.00%\n",
            "-------------------------------\n",
            "Epoch 7/12\n",
            "Train Loss: 0.0317 | Train Accuracy: 98.61%\n",
            "Val Loss: 0.0216 | Val Accuracy: 100.00%\n",
            "-------------------------------\n",
            "Epoch 8/12\n",
            "Train Loss: 0.0511 | Train Accuracy: 98.61%\n",
            "Val Loss: 0.1000 | Val Accuracy: 92.86%\n",
            "-------------------------------\n",
            "Epoch 9/12\n",
            "Train Loss: 0.0015 | Train Accuracy: 100.00%\n",
            "Val Loss: 0.0367 | Val Accuracy: 100.00%\n",
            "-------------------------------\n",
            "Epoch 10/12\n",
            "Train Loss: 0.0036 | Train Accuracy: 100.00%\n",
            "Val Loss: 0.0075 | Val Accuracy: 100.00%\n",
            "-------------------------------\n",
            "Epoch 11/12\n",
            "Train Loss: 0.0030 | Train Accuracy: 100.00%\n",
            "Val Loss: 0.0025 | Val Accuracy: 100.00%\n",
            "-------------------------------\n",
            "Epoch 12/12\n",
            "Train Loss: 0.0040 | Train Accuracy: 100.00%\n",
            "Val Loss: 0.0009 | Val Accuracy: 100.00%\n",
            "-------------------------------\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x400 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "# list to save the train loss and accuracy for plotting\n",
        "train_loss_values = []\n",
        "train_accuracy_values = []\n",
        "\n",
        "\n",
        "\n",
        "# Train the model\n",
        "for epoch in range(num_epochs):\n",
        "    model.train()\n",
        "    running_loss = 0.0\n",
        "    correct = 0\n",
        "    total = 0\n",
        "\n",
        "    for images, labels in train_loader:\n",
        "        images = images.to(device)\n",
        "        labels = labels.to(device)\n",
        "\n",
        "        optimizer.zero_grad()\n",
        "        outputs = model(images)\n",
        "        loss = criterion(outputs, labels)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "        total += labels.size(0)\n",
        "        correct += (predicted == labels).sum().item()\n",
        "        running_loss += loss.item()\n",
        "\n",
        "\n",
        "    train_accuracy = correct / total\n",
        "    train_loss = running_loss / len(train_loader)\n",
        "\n",
        "    train_loss_values.append(train_loss)  # Append train loss value to the list\n",
        "    train_accuracy_values.append(train_accuracy)  # Append train accuracy value to the list\n",
        "\n",
        "    # Model evaluation on the validation data\n",
        "    model.eval()\n",
        "    val_loss = 0.0\n",
        "    val_correct = 0\n",
        "    val_total = 0\n",
        "\n",
        "    with torch.no_grad():\n",
        "        for images, labels in val_loader:\n",
        "            images = images.to(device)\n",
        "            labels = labels.to(device)\n",
        "\n",
        "            outputs = model(images)\n",
        "            loss = criterion(outputs, labels)\n",
        "\n",
        "            _, predicted = torch.max(outputs.data, 1)\n",
        "            val_total += labels.size(0)\n",
        "            val_correct += (predicted == labels).sum().item()\n",
        "            val_loss += loss.item()\n",
        "\n",
        "    val_accuracy = val_correct / val_total\n",
        "    val_loss = val_loss / len(val_loader)\n",
        "\n",
        "\n",
        "    print(f\"Epoch {epoch + 1}/{num_epochs}\")\n",
        "    print(f\"Train Loss: {train_loss:.4f} | Train Accuracy: {train_accuracy*100:.2f}%\")\n",
        "    print(f\"Val Loss: {val_loss:.4f} | Val Accuracy: {val_accuracy*100:.2f}%\")\n",
        "    print(\"-------------------------------\")\n",
        "\n",
        "\n",
        "#Plotting train loss and accuracy\n",
        "\n",
        "# list of epoch numbers\n",
        "epochs = list(range(1, num_epochs + 1))\n",
        "\n",
        "plt.figure(figsize=(10, 4))\n",
        "\n",
        "\n",
        "# Plot train loss\n",
        "plt.subplot(1, 2, 1)\n",
        "plt.plot(epochs, train_loss_values, label='Train Loss', color = \"red\")\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('Loss')\n",
        "plt.title('Training Loss')\n",
        "plt.legend()\n",
        "# plt.show()\n",
        "\n",
        "# Plot train accuracy\n",
        "plt.subplot(1, 2, 2)\n",
        "plt.plot(epochs, train_accuracy_values, label='Train Accuracy', color=\"blue\")\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.title('Training Accuracy')\n",
        "plt.legend()\n",
        "# plt.show()\n",
        "\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 69,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lmGBnKUACIDy",
        "outputId": "2de31e74-70ae-4c13-b3d6-ee80fd65946c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Loss: 0.0014 | Test Accuracy: 100.00%\n"
          ]
        }
      ],
      "source": [
        " # Save the trained model\n",
        "torch.save(model.state_dict(), model_save_path)\n",
        "\n",
        "# Model evaluation on test data\n",
        "model.eval()\n",
        "test_loss = 0.0\n",
        "test_correct = 0\n",
        "test_total = 0\n",
        "\n",
        "with torch.no_grad():\n",
        "    for images, labels in test_loader:\n",
        "        images = images.to(device)\n",
        "        labels = labels.to(device)\n",
        "\n",
        "        outputs = model(images)\n",
        "        loss = criterion(outputs, labels)\n",
        "\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "        test_total += labels.size(0)\n",
        "        test_correct += (predicted == labels).sum().item()\n",
        "        test_loss += loss.item()\n",
        "\n",
        "test_accuracy = test_correct / test_total\n",
        "test_loss = test_loss / len(test_loader)\n",
        "\n",
        "print(f\"Test Loss: {test_loss:.4f} | Test Accuracy: {test_accuracy*100:.2f}%\")\n",
        "\n",
        "\n",
        "\n",
        "# save the model one more time after checking good accuracy\n",
        "torch.save(model.state_dict(), model_save_path)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l5zIDb6OJfjE"
      },
      "source": [
        "For downloading our model from google colab noteb, we will use the below codes"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "id": "Et-aV0ZNpNVm",
        "outputId": "232046ff-c534-4b13-893f-a71e721929e4"
      },
      "outputs": [
        {
          "data": {
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "application/javascript": [
              "download(\"download_45d30a17-3702-4837-979a-9efecbd1bebf\", \"Final_FaceMask_detection_model.pt\", 94375983)"
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "from google.colab import files\n",
        "\n",
        "model_path = model_save_path\n",
        "\n",
        "files.download(model_path)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k8kJYijYPNLG"
      },
      "source": [
        "#Checking our model by uploading pictures\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 71,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 91
        },
        "id": "79Ko1dWq1oj4",
        "outputId": "bf4caa60-1c5a-42ff-c17a-14345cd7c632"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-8f93f17c-1043-4f1e-b660-b9783fe042d7\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-8f93f17c-1043-4f1e-b660-b9783fe042d7\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving facemmask.jpg to facemmask.jpg\n",
            "No face mask detected with probability: 0.6588020920753479\n"
          ]
        }
      ],
      "source": [
        "import torch\n",
        "import torchvision.transforms as transforms\n",
        "from PIL import Image\n",
        "from google.colab import files\n",
        "\n",
        "\n",
        "\n",
        "class FaceMaskModel(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(FaceMaskModel, self).__init__()\n",
        "        self.model = models.resnet50(pretrained=True)\n",
        "        num_features = self.model.fc.in_features\n",
        "        self.model.fc = nn.Linear(num_features, 2)\n",
        "\n",
        "    def forward(self, x):\n",
        "        return self.model(x)\n",
        "\n",
        "\n",
        "\n",
        "# calling our model\n",
        "model = FaceMaskModel()\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "# the image transformation\n",
        "transform = transforms.Compose([\n",
        "    transforms.Resize((224, 224)), \n",
        "    transforms.ToTensor(),  \n",
        "    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) \n",
        "])\n",
        "\n",
        "\n",
        "\n",
        "uploaded = files.upload()\n",
        "\n",
        "\n",
        "\n",
        "# Getting the uploaded image file\n",
        "image_path = list(uploaded.keys())[0]\n",
        "image = Image.open(image_path)\n",
        "\n",
        "\n",
        "\n",
        "# Preprocess the image\n",
        "input_tensor = transform(image)\n",
        "input_batch = input_tensor.unsqueeze(0)  # Add a batch dimension\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "# face mask detection\n",
        "with torch.no_grad():\n",
        "    model.eval()\n",
        "    output = model(input_batch)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "class_probabilities = torch.softmax(output, dim=1)\n",
        "mask_probability = class_probabilities[0, 1].item() \n",
        "\n",
        "\n",
        "threshold = 0.5  #treshold\n",
        "if mask_probability > threshold:\n",
        "    print(\"Face mask detected with probability:\", mask_probability)\n",
        "else:\n",
        "    print(\"No face mask detected with probability:\", 1 - mask_probability)\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "cO7eXX5FgSbv"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "gpuType": "T4",
      "provenance": [],
      "include_colab_link": true
    },
    "gpuClass": "standard",
    "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.10.9"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}