Personal_Face_Mask_Detection_V3.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Personal_Face_Mask_Detection_V3.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sFoQ6OAwhb8V",
        "colab_type": "text"
      },
      "source": [
        "##### Copyright 2020 Shreyas Bhat Kera.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3X58BdNthnUH",
        "colab_type": "code",
        "colab": {},
        "cellView": "form"
      },
      "source": [
        "#@title 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",
        "# https://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."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nC1SO5hM7yUB",
        "colab_type": "text"
      },
      "source": [
        "**Notebook to make a Personalized Face Mask Detector using a 2 factor approach on augmented images of the specified user**\n",
        "\n",
        "Details:\n",
        "\n",
        "\n",
        "*   It is specific to the user so only grants access when that particular user wears a mask properly.\n",
        "*   The model only allows access if the mask is worn properly by the user, i.e. over the moth and nose.\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9_pP-GH3-wXP",
        "colab_type": "text"
      },
      "source": [
        "**IMPORTS**\n",
        "\n",
        "Download part of the dataset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RehBecmx-zJ2",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "ac017bae-4a38-415a-b954-0d5091b210d9"
      },
      "source": [
        "!pip install -q xlrd\n",
        "!git clone https://github.com/shreyas-bk/without_mask.git #dataset with 674 images of faces withput masks, which i got from https://github.com/prajnasb/observations/tree/master/experiements/data/without_mask"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Cloning into 'without_mask'...\n",
            "remote: Enumerating objects: 674, done.\u001b[K\n",
            "remote: Total 674 (delta 0), reused 0 (delta 0), pack-reused 674\u001b[K\n",
            "Receiving objects: 100% (674/674), 24.23 MiB | 42.49 MiB/s, done.\n",
            "Resolving deltas: 100% (18/18), done.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZVRhig81-4MM",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\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 imutils import paths\n",
        "import numpy as np\n",
        "import argparse\n",
        "import os"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Pb1eU0ns-r2M",
        "colab_type": "text"
      },
      "source": [
        "**SETUP**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aLjl7x8CAGXk",
        "colab_type": "text"
      },
      "source": [
        "*ENTER YOUR NAME*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u9cIjPdj-t6D",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "name = 'Shreyas' #Required to save the images properly"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zOlW4eDc_EzD",
        "colab_type": "text"
      },
      "source": [
        "*Requirement: 1 PICTURE WITH A FACEMASK AND 1 WITHOUT A FACEMASK*\n",
        "\n",
        "*Use one of the 2 methods given below*\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n7dTWyUb_tw7",
        "colab_type": "text"
      },
      "source": [
        "*Method 1 : Upload pictures from local storage.*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8o8uEgKL_O72",
        "colab_type": "code",
        "colab": {
          "resources": {
            "http://localhost:8080/nbextensions/google.colab/files.js": {
              "data": "Ly8gQ29weXJpZ2h0IDIwMTcgR29vZ2xlIExMQwovLwovLyBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgIkxpY2Vuc2UiKTsKLy8geW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLgovLyBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXQKLy8KLy8gICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjAKLy8KLy8gVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZQovLyBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiAiQVMgSVMiIEJBU0lTLAovLyBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC4KLy8gU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZAovLyBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS4KCi8qKgogKiBAZmlsZW92ZXJ2aWV3IEhlbHBlcnMgZm9yIGdvb2dsZS5jb2xhYiBQeXRob24gbW9kdWxlLgogKi8KKGZ1bmN0aW9uKHNjb3BlKSB7CmZ1bmN0aW9uIHNwYW4odGV4dCwgc3R5bGVBdHRyaWJ1dGVzID0ge30pIHsKICBjb25zdCBlbGVtZW50ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgnc3BhbicpOwogIGVsZW1lbnQudGV4dENvbnRlbnQgPSB0ZXh0OwogIGZvciAoY29uc3Qga2V5IG9mIE9iamVjdC5rZXlzKHN0eWxlQXR0cmlidXRlcykpIHsKICAgIGVsZW1lbnQuc3R5bGVba2V5XSA9IHN0eWxlQXR0cmlidXRlc1trZXldOwogIH0KICByZXR1cm4gZWxlbWVudDsKfQoKLy8gTWF4IG51bWJlciBvZiBieXRlcyB3aGljaCB3aWxsIGJlIHVwbG9hZGVkIGF0IGEgdGltZS4KY29uc3QgTUFYX1BBWUxPQURfU0laRSA9IDEwMCAqIDEwMjQ7CgpmdW5jdGlvbiBfdXBsb2FkRmlsZXMoaW5wdXRJZCwgb3V0cHV0SWQpIHsKICBjb25zdCBzdGVwcyA9IHVwbG9hZEZpbGVzU3RlcChpbnB1dElkLCBvdXRwdXRJZCk7CiAgY29uc3Qgb3V0cHV0RWxlbWVudCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKG91dHB1dElkKTsKICAvLyBDYWNoZSBzdGVwcyBvbiB0aGUgb3V0cHV0RWxlbWVudCB0byBtYWtlIGl0IGF2YWlsYWJsZSBmb3IgdGhlIG5leHQgY2FsbAogIC8vIHRvIHVwbG9hZEZpbGVzQ29udGludWUgZnJvbSBQeXRob24uCiAgb3V0cHV0RWxlbWVudC5zdGVwcyA9IHN0ZXBzOwoKICByZXR1cm4gX3VwbG9hZEZpbGVzQ29udGludWUob3V0cHV0SWQpOwp9CgovLyBUaGlzIGlzIHJvdWdobHkgYW4gYXN5bmMgZ2VuZXJhdG9yIChub3Qgc3VwcG9ydGVkIGluIHRoZSBicm93c2VyIHlldCksCi8vIHdoZXJlIHRoZXJlIGFyZSBtdWx0aXBsZSBhc3luY2hyb25vdXMgc3RlcHMgYW5kIHRoZSBQeXRob24gc2lkZSBpcyBnb2luZwovLyB0byBwb2xsIGZvciBjb21wbGV0aW9uIG9mIGVhY2ggc3RlcC4KLy8gVGhpcyB1c2VzIGEgUHJvbWlzZSB0byBibG9jayB0aGUgcHl0aG9uIHNpZGUgb24gY29tcGxldGlvbiBvZiBlYWNoIHN0ZXAsCi8vIHRoZW4gcGFzc2VzIHRoZSByZXN1bHQgb2YgdGhlIHByZXZpb3VzIHN0ZXAgYXMgdGhlIGlucHV0IHRvIHRoZSBuZXh0IHN0ZXAuCmZ1bmN0aW9uIF91cGxvYWRGaWxlc0NvbnRpbnVlKG91dHB1dElkKSB7CiAgY29uc3Qgb3V0cHV0RWxlbWVudCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKG91dHB1dElkKTsKICBjb25zdCBzdGVwcyA9IG91dHB1dEVsZW1lbnQuc3RlcHM7CgogIGNvbnN0IG5leHQgPSBzdGVwcy5uZXh0KG91dHB1dEVsZW1lbnQubGFzdFByb21pc2VWYWx1ZSk7CiAgcmV0dXJuIFByb21pc2UucmVzb2x2ZShuZXh0LnZhbHVlLnByb21pc2UpLnRoZW4oKHZhbHVlKSA9PiB7CiAgICAvLyBDYWNoZSB0aGUgbGFzdCBwcm9taXNlIHZhbHVlIHRvIG1ha2UgaXQgYXZhaWxhYmxlIHRvIHRoZSBuZXh0CiAgICAvLyBzdGVwIG9mIHRoZSBnZW5lcmF0b3IuCiAgICBvdXRwdXRFbGVtZW50Lmxhc3RQcm9taXNlVmFsdWUgPSB2YWx1ZTsKICAgIHJldHVybiBuZXh0LnZhbHVlLnJlc3BvbnNlOwogIH0pOwp9CgovKioKICogR2VuZXJhdG9yIGZ1bmN0aW9uIHdoaWNoIGlzIGNhbGxlZCBiZXR3ZWVuIGVhY2ggYXN5bmMgc3RlcCBvZiB0aGUgdXBsb2FkCiAqIHByb2Nlc3MuCiAqIEBwYXJhbSB7c3RyaW5nfSBpbnB1dElkIEVsZW1lbnQgSUQgb2YgdGhlIGlucHV0IGZpbGUgcGlja2VyIGVsZW1lbnQuCiAqIEBwYXJhbSB7c3RyaW5nfSBvdXRwdXRJZCBFbGVtZW50IElEIG9mIHRoZSBvdXRwdXQgZGlzcGxheS4KICogQHJldHVybiB7IUl0ZXJhYmxlPCFPYmplY3Q+fSBJdGVyYWJsZSBvZiBuZXh0IHN0ZXBzLgogKi8KZnVuY3Rpb24qIHVwbG9hZEZpbGVzU3RlcChpbnB1dElkLCBvdXRwdXRJZCkgewogIGNvbnN0IGlucHV0RWxlbWVudCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKGlucHV0SWQpOwogIGlucHV0RWxlbWVudC5kaXNhYmxlZCA9IGZhbHNlOwoKICBjb25zdCBvdXRwdXRFbGVtZW50ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQob3V0cHV0SWQpOwogIG91dHB1dEVsZW1lbnQuaW5uZXJIVE1MID0gJyc7CgogIGNvbnN0IHBpY2tlZFByb21pc2UgPSBuZXcgUHJvbWlzZSgocmVzb2x2ZSkgPT4gewogICAgaW5wdXRFbGVtZW50LmFkZEV2ZW50TGlzdGVuZXIoJ2NoYW5nZScsIChlKSA9PiB7CiAgICAgIHJlc29sdmUoZS50YXJnZXQuZmlsZXMpOwogICAgfSk7CiAgfSk7CgogIGNvbnN0IGNhbmNlbCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoJ2J1dHRvbicpOwogIGlucHV0RWxlbWVudC5wYXJlbnRFbGVtZW50LmFwcGVuZENoaWxkKGNhbmNlbCk7CiAgY2FuY2VsLnRleHRDb250ZW50ID0gJ0NhbmNlbCB1cGxvYWQnOwogIGNvbnN0IGNhbmNlbFByb21pc2UgPSBuZXcgUHJvbWlzZSgocmVzb2x2ZSkgPT4gewogICAgY2FuY2VsLm9uY2xpY2sgPSAoKSA9PiB7CiAgICAgIHJlc29sdmUobnVsbCk7CiAgICB9OwogIH0pOwoKICAvLyBXYWl0IGZvciB0aGUgdXNlciB0byBwaWNrIHRoZSBmaWxlcy4KICBjb25zdCBmaWxlcyA9IHlpZWxkIHsKICAgIHByb21pc2U6IFByb21pc2UucmFjZShbcGlja2VkUHJvbWlzZSwgY2FuY2VsUHJvbWlzZV0pLAogICAgcmVzcG9uc2U6IHsKICAgICAgYWN0aW9uOiAnc3RhcnRpbmcnLAogICAgfQogIH07CgogIGNhbmNlbC5yZW1vdmUoKTsKCiAgLy8gRGlzYWJsZSB0aGUgaW5wdXQgZWxlbWVudCBzaW5jZSBmdXJ0aGVyIHBpY2tzIGFyZSBub3QgYWxsb3dlZC4KICBpbnB1dEVsZW1lbnQuZGlzYWJsZWQgPSB0cnVlOwoKICBpZiAoIWZpbGVzKSB7CiAgICByZXR1cm4gewogICAgICByZXNwb25zZTogewogICAgICAgIGFjdGlvbjogJ2NvbXBsZXRlJywKICAgICAgfQogICAgfTsKICB9CgogIGZvciAoY29uc3QgZmlsZSBvZiBmaWxlcykgewogICAgY29uc3QgbGkgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCdsaScpOwogICAgbGkuYXBwZW5kKHNwYW4oZmlsZS5uYW1lLCB7Zm9udFdlaWdodDogJ2JvbGQnfSkpOwogICAgbGkuYXBwZW5kKHNwYW4oCiAgICAgICAgYCgke2ZpbGUudHlwZSB8fCAnbi9hJ30pIC0gJHtmaWxlLnNpemV9IGJ5dGVzLCBgICsKICAgICAgICBgbGFzdCBtb2RpZmllZDogJHsKICAgICAgICAgICAgZmlsZS5sYXN0TW9kaWZpZWREYXRlID8gZmlsZS5sYXN0TW9kaWZpZWREYXRlLnRvTG9jYWxlRGF0ZVN0cmluZygpIDoKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJ24vYSd9IC0gYCkpOwogICAgY29uc3QgcGVyY2VudCA9IHNwYW4oJzAlIGRvbmUnKTsKICAgIGxpLmFwcGVuZENoaWxkKHBlcmNlbnQpOwoKICAgIG91dHB1dEVsZW1lbnQuYXBwZW5kQ2hpbGQobGkpOwoKICAgIGNvbnN0IGZpbGVEYXRhUHJvbWlzZSA9IG5ldyBQcm9taXNlKChyZXNvbHZlKSA9PiB7CiAgICAgIGNvbnN0IHJlYWRlciA9IG5ldyBGaWxlUmVhZGVyKCk7CiAgICAgIHJlYWRlci5vbmxvYWQgPSAoZSkgPT4gewogICAgICAgIHJlc29sdmUoZS50YXJnZXQucmVzdWx0KTsKICAgICAgfTsKICAgICAgcmVhZGVyLnJlYWRBc0FycmF5QnVmZmVyKGZpbGUpOwogICAgfSk7CiAgICAvLyBXYWl0IGZvciB0aGUgZGF0YSB0byBiZSByZWFkeS4KICAgIGxldCBmaWxlRGF0YSA9IHlpZWxkIHsKICAgICAgcHJvbWlzZTogZmlsZURhdGFQcm9taXNlLAogICAgICByZXNwb25zZTogewogICAgICAgIGFjdGlvbjogJ2NvbnRpbnVlJywKICAgICAgfQogICAgfTsKCiAgICAvLyBVc2UgYSBjaHVua2VkIHNlbmRpbmcgdG8gYXZvaWQgbWVzc2FnZSBzaXplIGxpbWl0cy4gU2VlIGIvNjIxMTU2NjAuCiAgICBsZXQgcG9zaXRpb24gPSAwOwogICAgd2hpbGUgKHBvc2l0aW9uIDwgZmlsZURhdGEuYnl0ZUxlbmd0aCkgewogICAgICBjb25zdCBsZW5ndGggPSBNYXRoLm1pbihmaWxlRGF0YS5ieXRlTGVuZ3RoIC0gcG9zaXRpb24sIE1BWF9QQVlMT0FEX1NJWkUpOwogICAgICBjb25zdCBjaHVuayA9IG5ldyBVaW50OEFycmF5KGZpbGVEYXRhLCBwb3NpdGlvbiwgbGVuZ3RoKTsKICAgICAgcG9zaXRpb24gKz0gbGVuZ3RoOwoKICAgICAgY29uc3QgYmFzZTY0ID0gYnRvYShTdHJpbmcuZnJvbUNoYXJDb2RlLmFwcGx5KG51bGwsIGNodW5rKSk7CiAgICAgIHlpZWxkIHsKICAgICAgICByZXNwb25zZTogewogICAgICAgICAgYWN0aW9uOiAnYXBwZW5kJywKICAgICAgICAgIGZpbGU6IGZpbGUubmFtZSwKICAgICAgICAgIGRhdGE6IGJhc2U2NCwKICAgICAgICB9LAogICAgICB9OwogICAgICBwZXJjZW50LnRleHRDb250ZW50ID0KICAgICAgICAgIGAke01hdGgucm91bmQoKHBvc2l0aW9uIC8gZmlsZURhdGEuYnl0ZUxlbmd0aCkgKiAxMDApfSUgZG9uZWA7CiAgICB9CiAgfQoKICAvLyBBbGwgZG9uZS4KICB5aWVsZCB7CiAgICByZXNwb25zZTogewogICAgICBhY3Rpb246ICdjb21wbGV0ZScsCiAgICB9CiAgfTsKfQoKc2NvcGUuZ29vZ2xlID0gc2NvcGUuZ29vZ2xlIHx8IHt9OwpzY29wZS5nb29nbGUuY29sYWIgPSBzY29wZS5nb29nbGUuY29sYWIgfHwge307CnNjb3BlLmdvb2dsZS5jb2xhYi5fZmlsZXMgPSB7CiAgX3VwbG9hZEZpbGVzLAogIF91cGxvYWRGaWxlc0NvbnRpbnVlLAp9Owp9KShzZWxmKTsK",
              "ok": true,
              "headers": [
                [
                  "content-type",
                  "application/javascript"
                ]
              ],
              "status": 200,
              "status_text": ""
            }
          },
          "base_uri": "https://localhost:8080/",
          "height": 106
        },
        "outputId": "3ae0ae38-4bf8-4d69-ed54-488a21594aac"
      },
      "source": [
        "from google.colab import files\n",
        "uploaded = files.upload()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-f49dc349-7326-48b5-a365-7d343c9c04b2\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-f49dc349-7326-48b5-a365-7d343c9c04b2\">\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 src=\"/nbextensions/google.colab/files.js\"></script> "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Saving Shreyas_without_mask (1).jpg to Shreyas_without_mask (1).jpg\n",
            "Saving Shreyas_with_mask (1).jpg to Shreyas_with_mask (1).jpg\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6RT6H589_3n0",
        "colab_type": "text"
      },
      "source": [
        "*Method 2: Take pictures by running the next 2 cells*\n",
        "\n",
        "\n",
        "For best results make sure the input images are similar to these:\n",
        "\n",
        "\n",
        "*   [Without mask](https://github.com/shreyas-bk/Personal_Face_Mask_Detection_V3/blob/master/Shreyas_without_mask%20(1).jpg)\n",
        "*   [With mask](https://github.com/shreyas-bk/Personal_Face_Mask_Detection_V3/blob/master/Shreyas_with_mask%20(1).jpg)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "reNAw-MW_-FP",
        "colab_type": "text"
      },
      "source": [
        "*WITHOUT MASK*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jVHc_N6l-iIO",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 514
        },
        "outputId": "bfdd4fee-9d48-4315-d291-305ff8e81fc2"
      },
      "source": [
        "#WITHOUT MASK\n",
        "from IPython.display import display, Javascript\n",
        "from google.colab.output import eval_js\n",
        "from base64 import b64decode\n",
        "\n",
        "def take_photo(filename=name+'_without_mask.jpg', quality=0.8):\n",
        "  js = Javascript('''\n",
        "    async function takePhoto(quality) {\n",
        "      const div = document.createElement('div');\n",
        "      const capture = document.createElement('button');\n",
        "      capture.textContent = 'Take picture without mask';\n",
        "      div.appendChild(capture);\n",
        "\n",
        "      const video = document.createElement('video');\n",
        "      video.style.display = 'block';\n",
        "      const stream = await navigator.mediaDevices.getUserMedia({video: true});\n",
        "\n",
        "      document.body.appendChild(div);\n",
        "      div.appendChild(video);\n",
        "      video.srcObject = stream;\n",
        "      await video.play();\n",
        "\n",
        "      // Resize the output to fit the video element.\n",
        "      google.colab.output.setIframeHeight(document.documentElement.scrollHeight, true);\n",
        "\n",
        "      // Wait for Capture to be clicked.\n",
        "      await new Promise((resolve) => capture.onclick = resolve);\n",
        "\n",
        "      const canvas = document.createElement('canvas');\n",
        "      canvas.width = video.videoWidth;\n",
        "      canvas.height = video.videoHeight;\n",
        "      canvas.getContext('2d').drawImage(video, 0, 0);\n",
        "      stream.getVideoTracks()[0].stop();\n",
        "      div.remove();\n",
        "      return canvas.toDataURL('image/jpeg', quality);\n",
        "    }\n",
        "    ''')\n",
        "  display(js)\n",
        "  data = eval_js('takePhoto({})'.format(quality))\n",
        "  binary = b64decode(data.split(',')[1])\n",
        "  with open(filename, 'wb') as f:\n",
        "    f.write(binary)\n",
        "  return filename\n",
        "from IPython.display import Image\n",
        "try:\n",
        "  filename = take_photo()\n",
        "  print('Saved to {}'.format(filename))\n",
        "  \n",
        "  # Show the image which was just taken.\n",
        "  display(Image(filename))\n",
        "except Exception as err:\n",
        "  # Errors will be thrown if the user does not have a webcam or if they do not\n",
        "  # grant the page permission to access it.\n",
        "  print(str(err))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "application/javascript": [
              "\n",
              "    async function takePhoto(quality) {\n",
              "      const div = document.createElement('div');\n",
              "      const capture = document.createElement('button');\n",
              "      capture.textContent = 'Take picture without mask';\n",
              "      div.appendChild(capture);\n",
              "\n",
              "      const video = document.createElement('video');\n",
              "      video.style.display = 'block';\n",
              "      const stream = await navigator.mediaDevices.getUserMedia({video: true});\n",
              "\n",
              "      document.body.appendChild(div);\n",
              "      div.appendChild(video);\n",
              "      video.srcObject = stream;\n",
              "      await video.play();\n",
              "\n",
              "      // Resize the output to fit the video element.\n",
              "      google.colab.output.setIframeHeight(document.documentElement.scrollHeight, true);\n",
              "\n",
              "      // Wait for Capture to be clicked.\n",
              "      await new Promise((resolve) => capture.onclick = resolve);\n",
              "\n",
              "      const canvas = document.createElement('canvas');\n",
              "      canvas.width = video.videoWidth;\n",
              "      canvas.height = video.videoHeight;\n",
              "      canvas.getContext('2d').drawImage(video, 0, 0);\n",
              "      stream.getVideoTracks()[0].stop();\n",
              "      div.remove();\n",
              "      return canvas.toDataURL('image/jpeg', quality);\n",
              "    }\n",
              "    "
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Saved to Shreyas_without_mask.jpg\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/jpeg": "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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6dOANmeCACNQ",
        "colab_type": "text"
      },
      "source": [
        "*WITH MASK*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AAPARIwvAEZv",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 514
        },
        "outputId": "0aefc3a6-d52c-44c4-f9c3-d7b37ddcd454"
      },
      "source": [
        "#WITH MASK\n",
        "from IPython.display import display, Javascript\n",
        "from google.colab.output import eval_js\n",
        "from base64 import b64decode\n",
        "\n",
        "def take_photo(filename=name+'_with_mask.jpg', quality=0.8):\n",
        "  js = Javascript('''\n",
        "    async function takePhoto(quality) {\n",
        "      const div = document.createElement('div');\n",
        "      const capture = document.createElement('button');\n",
        "      capture.textContent = 'Take picture with mask';\n",
        "      div.appendChild(capture);\n",
        "\n",
        "      const video = document.createElement('video');\n",
        "      video.style.display = 'block';\n",
        "      const stream = await navigator.mediaDevices.getUserMedia({video: true});\n",
        "\n",
        "      document.body.appendChild(div);\n",
        "      div.appendChild(video);\n",
        "      video.srcObject = stream;\n",
        "      await video.play();\n",
        "\n",
        "      // Resize the output to fit the video element.\n",
        "      google.colab.output.setIframeHeight(document.documentElement.scrollHeight, true);\n",
        "\n",
        "      // Wait for Capture to be clicked.\n",
        "      await new Promise((resolve) => capture.onclick = resolve);\n",
        "\n",
        "      const canvas = document.createElement('canvas');\n",
        "      canvas.width = video.videoWidth;\n",
        "      canvas.height = video.videoHeight;\n",
        "      canvas.getContext('2d').drawImage(video, 0, 0);\n",
        "      stream.getVideoTracks()[0].stop();\n",
        "      div.remove();\n",
        "      return canvas.toDataURL('image/jpeg', quality);\n",
        "    }\n",
        "    ''')\n",
        "  display(js)\n",
        "  data = eval_js('takePhoto({})'.format(quality))\n",
        "  binary = b64decode(data.split(',')[1])\n",
        "  with open(filename, 'wb') as f:\n",
        "    f.write(binary)\n",
        "  return filename\n",
        "from IPython.display import Image\n",
        "try:\n",
        "  filename = take_photo()\n",
        "  print('Saved to {}'.format(filename))\n",
        "  \n",
        "  # Show the image which was just taken.\n",
        "  display(Image(filename))\n",
        "except Exception as err:\n",
        "  # Errors will be thrown if the user does not have a webcam or if they do not\n",
        "  # grant the page permission to access it.\n",
        "  print(str(err))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "application/javascript": [
              "\n",
              "    async function takePhoto(quality) {\n",
              "      const div = document.createElement('div');\n",
              "      const capture = document.createElement('button');\n",
              "      capture.textContent = 'Take picture with mask';\n",
              "      div.appendChild(capture);\n",
              "\n",
              "      const video = document.createElement('video');\n",
              "      video.style.display = 'block';\n",
              "      const stream = await navigator.mediaDevices.getUserMedia({video: true});\n",
              "\n",
              "      document.body.appendChild(div);\n",
              "      div.appendChild(video);\n",
              "      video.srcObject = stream;\n",
              "      await video.play();\n",
              "\n",
              "      // Resize the output to fit the video element.\n",
              "      google.colab.output.setIframeHeight(document.documentElement.scrollHeight, true);\n",
              "\n",
              "      // Wait for Capture to be clicked.\n",
              "      await new Promise((resolve) => capture.onclick = resolve);\n",
              "\n",
              "      const canvas = document.createElement('canvas');\n",
              "      canvas.width = video.videoWidth;\n",
              "      canvas.height = video.videoHeight;\n",
              "      canvas.getContext('2d').drawImage(video, 0, 0);\n",
              "      stream.getVideoTracks()[0].stop();\n",
              "      div.remove();\n",
              "      return canvas.toDataURL('image/jpeg', quality);\n",
              "    }\n",
              "    "
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Saved to Shreyas_with_mask.jpg\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/jpeg": "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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jdcvFJhx9tYH",
        "colab_type": "text"
      },
      "source": [
        "**Approach**\n",
        "\n",
        "*   First model works to identify if there is a mask or not. It uses the without mask dataset that was downloaded as well as augmented images of the user's without mask image for negative cases and augmented images of the user's with mask image for positive cases. However, in some cases, since the mask obscures features of the face, it may predict that someone else wearing a mask is a positive case, which shoudln't happen since it's meant to be personalized. So I made a second model which solves that. (Note: The first model is the first factor that needs to be passed in order to move to the second model.)\n",
        "\n",
        "*   The second model takes instances of the without mask dataset as negative cases and both the user's with mask and without mask images as positive cases. So once the first factor is passed, this model makes sure that it is actually the given user with a mask. If the input passes this second factor, access is granted.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mzZZfewVAOwh",
        "colab_type": "text"
      },
      "source": [
        "**MASK DETECTION**\n",
        "\n",
        "*Factor 1*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UegJ-9EIAUoG",
        "colab_type": "text"
      },
      "source": [
        "*Load data*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vHa6Fw2gAUHN",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "db8df6ec-55cb-407f-a32a-0bff3b52e78b"
      },
      "source": [
        "data = []\n",
        "labels = []\n",
        "count = 0\n",
        "for imagePath in list(paths.list_images('/content/')):\n",
        "  count+=1\n",
        "  label = imagePath.split(os.path.sep)[-2]\n",
        "  image = load_img(imagePath, target_size=(224, 224))\n",
        "  image = img_to_array(image)\n",
        "  image = preprocess_input(image)\n",
        "  if imagePath=='/content/'+name+'_without_mask.jpg':\n",
        "    datagen = ImageDataGenerator(zoom_range=0.2,height_shift_range=40)\n",
        "    i=0\n",
        "    lis = []\n",
        "    img = load_img(imagePath, target_size=(224, 224))\n",
        "    x = img_to_array(img)\n",
        "    x = x.reshape((1,) + x.shape)\n",
        "    for batch in datagen.flow(x, batch_size=1):\n",
        "      image = img_to_array(batch[0])\n",
        "      image = preprocess_input(image)\n",
        "      count+=1\n",
        "      label = 'without-mask'\n",
        "      data.append(image)\n",
        "      labels.append(label)\n",
        "      i += 1\n",
        "      if i >= 100:\n",
        "        break\n",
        "  if imagePath=='/content/'+name+'_with_mask.jpg':\n",
        "    datagen = ImageDataGenerator(zoom_range=0.4,height_shift_range=40,brightness_range=[0.5,1.5])\n",
        "    i=0\n",
        "    lis = []\n",
        "    img = load_img(imagePath, target_size=(224, 224))\n",
        "    x = img_to_array(img)\n",
        "    x = x.reshape((1,) + x.shape)\n",
        "    for batch in datagen.flow(x, batch_size=1):\n",
        "      image = img_to_array(batch[0])\n",
        "      image = preprocess_input(image)\n",
        "      count+=1\n",
        "      label = 'with-mask'\n",
        "      data.append(image)\n",
        "      labels.append(label)\n",
        "      i += 1\n",
        "      if i >= 500:\n",
        "        break\n",
        "  else:\n",
        "    data.append(image)\n",
        "    labels.append(label)\n",
        "data = np.array(data, dtype=\"float32\")\n",
        "labels = np.array(labels)\n",
        "lb = LabelBinarizer()\n",
        "labels = lb.fit_transform(labels)\n",
        "labels = to_categorical(labels)\n",
        "print('Loading complete for ',count,' images')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Loading complete for  1288  images\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4hiyjQULAZjA",
        "colab_type": "text"
      },
      "source": [
        "*Train model*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Vl8yp8g4AZJ4",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 187
        },
        "outputId": "948bb68f-f8de-4c55-d457-b0b0c8b2482b"
      },
      "source": [
        "aug = ImageDataGenerator(\n",
        "        rotation_range=40,\n",
        "        width_shift_range=0.2,\n",
        "        height_shift_range=0.2,\n",
        "        shear_range=0.2,\n",
        "        zoom_range=0.2,\n",
        "        horizontal_flip=True,\n",
        "        fill_mode='nearest')\n",
        "(trainX, testX, trainY, testY) = train_test_split(data, labels,\n",
        "\ttest_size=0.20, stratify=labels, random_state=42)\n",
        "import tensorflow as tf\n",
        "model = tf.keras.models.Sequential([\n",
        "    tf.keras.layers.Conv2D(16, (3,3), activation='relu', input_shape=(224, 224, 3)), # 5 convolutional layers\n",
        "    tf.keras.layers.MaxPooling2D(2, 2),\n",
        "    tf.keras.layers.Conv2D(32, (3,3), activation='relu'),\n",
        "    tf.keras.layers.MaxPooling2D(2,2),\n",
        "    tf.keras.layers.Conv2D(64, (3,3), activation='relu'),\n",
        "    tf.keras.layers.MaxPooling2D(2,2),\n",
        "    tf.keras.layers.Conv2D(64, (3,3), activation='relu'),\n",
        "    tf.keras.layers.MaxPooling2D(2,2),\n",
        "    tf.keras.layers.Conv2D(64, (3,3), activation='relu'),\n",
        "    tf.keras.layers.MaxPooling2D(2,2),\n",
        "    tf.keras.layers.Flatten(),\n",
        "    tf.keras.layers.Dense(512, activation='relu'),\n",
        "    tf.keras.layers.Dense(2, activation='softmax')\n",
        "])\n",
        "\n",
        "from tensorflow.keras.optimizers import RMSprop\n",
        "\n",
        "model.compile(loss='binary_crossentropy',\n",
        "              optimizer=RMSprop(lr=0.001),\n",
        "              metrics=['accuracy'])\n",
        "\n",
        "class myCallback(tf.keras.callbacks.Callback):\n",
        "  def on_epoch_end(self, epoch, logs={}):\n",
        "    if(logs.get('loss')>1):\n",
        "      print('\\nLoss too high, try rerunning cell')\n",
        "      self.model.stop_training = True\n",
        "    if(logs.get('accuracy')>0.95 and logs.get('val_accuracy')>0.95):\n",
        "      print(\"\\nStopping training with accuracy of >95%\")\n",
        "      self.model.stop_training = True\n",
        "\n",
        "BS = 32\n",
        "EPOCHS = 20\n",
        "callback = myCallback()\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,\n",
        "  callbacks = [callback])\n",
        "tf.keras.backend.clear_session()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/10\n",
            "32/32 [==============================] - 10s 326ms/step - loss: 0.4515 - accuracy: 0.7723 - val_loss: 0.0760 - val_accuracy: 0.9806\n",
            "Epoch 2/10\n",
            "32/32 [==============================] - 10s 322ms/step - loss: 0.2295 - accuracy: 0.9188 - val_loss: 0.3657 - val_accuracy: 0.8488\n",
            "Epoch 3/10\n",
            "32/32 [==============================] - 10s 320ms/step - loss: 0.1525 - accuracy: 0.9478 - val_loss: 0.0809 - val_accuracy: 0.9884\n",
            "Epoch 4/10\n",
            "32/32 [==============================] - ETA: 0s - loss: 0.1507 - accuracy: 0.9549\n",
            "Stopping training with accuracy of >95%\n",
            "32/32 [==============================] - 10s 328ms/step - loss: 0.1507 - accuracy: 0.9549 - val_loss: 0.0430 - val_accuracy: 0.9922\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tg5H44BNAhBf",
        "colab_type": "text"
      },
      "source": [
        "**PERSONAL DETECTION**\n",
        "\n",
        "*Factor 2*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4xjVI8K_Akeu",
        "colab_type": "text"
      },
      "source": [
        "*Load data*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QEwwAX-sApnG",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "4784f9f8-6cf0-4b2b-bdbe-9d4c6ecc110a"
      },
      "source": [
        "person_data = []\n",
        "person_labels = []\n",
        "count = 0\n",
        "for imagePath in list(paths.list_images('/content/')):\n",
        "  count+=1\n",
        "  label = 'not-self'\n",
        "  image = load_img(imagePath, target_size=(224, 224))\n",
        "  image = img_to_array(image)\n",
        "  image = preprocess_input(image)\n",
        "  if imagePath=='/content/'+name+'_without_mask.jpg':\n",
        "    for i in range(0,300):\n",
        "      count+=1\n",
        "      label = 'self'\n",
        "      person_data.append(image)\n",
        "      person_labels.append(label)\n",
        "  if imagePath=='/content/'+name+'_with_mask.jpg':\n",
        "    for i in range(0,300):\n",
        "      count+=1\n",
        "      label = 'self'\n",
        "      person_data.append(image)\n",
        "      person_labels.append(label)\n",
        "  else:\n",
        "    person_data.append(image)\n",
        "    person_labels.append(label)\n",
        "person_data = np.array(person_data, dtype=\"float32\")\n",
        "person_labels = np.array(person_labels)\n",
        "lb = LabelBinarizer()\n",
        "person_labels = lb.fit_transform(person_labels)\n",
        "person_labels = to_categorical(person_labels)\n",
        "print('Loading complete for ',count,' images')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Loading complete for  1288  images\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QjVb5XQCArWJ",
        "colab_type": "text"
      },
      "source": [
        "*Train model*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l3D0zmlAAs6e",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 153
        },
        "outputId": "5c389ad6-06d5-4e2b-e845-81753cdb85be"
      },
      "source": [
        "#person_model\n",
        "aug = ImageDataGenerator(\n",
        "        width_shift_range=0.1,\n",
        "        height_shift_range=0.1,\n",
        "        shear_range=0.2,\n",
        "        zoom_range=0.5,\n",
        "        horizontal_flip=True,\n",
        "        fill_mode='nearest')\n",
        "(trainX, testX, trainY, testY) = train_test_split(person_data, person_labels,\n",
        "\ttest_size=0.20, stratify=person_labels, random_state=42)\n",
        "import tensorflow as tf\n",
        "person_model = tf.keras.models.Sequential([\n",
        "    tf.keras.layers.Conv2D(16, (3,3), activation='relu', input_shape=(224, 224, 3)), # 4 convolutional layers\n",
        "    tf.keras.layers.MaxPooling2D(2, 2),\n",
        "    tf.keras.layers.Conv2D(32, (3,3), activation='relu'),\n",
        "    tf.keras.layers.MaxPooling2D(2,2),\n",
        "    tf.keras.layers.Conv2D(64, (3,3), activation='relu'),\n",
        "    tf.keras.layers.MaxPooling2D(2,2),\n",
        "    tf.keras.layers.Conv2D(64, (3,3), activation='relu'),\n",
        "    tf.keras.layers.MaxPooling2D(2,2),\n",
        "    tf.keras.layers.Flatten(),\n",
        "    tf.keras.layers.Dense(512, activation='relu'),\n",
        "    tf.keras.layers.Dense(2, activation='softmax')\n",
        "])\n",
        "\n",
        "from tensorflow.keras.optimizers import RMSprop\n",
        "\n",
        "person_model.compile(loss='binary_crossentropy',\n",
        "              optimizer=RMSprop(lr=0.001),\n",
        "              metrics=['accuracy'])\n",
        "class myCallback(tf.keras.callbacks.Callback):\n",
        "  def on_epoch_end(self, epoch, logs={}):\n",
        "    if(logs.get('loss')>1):\n",
        "      print('\\nLoss too high, try rerunning cell') # Sometimes, if intial loss is too high, it kees getting higher; running the cell again and having a smaller inital oss seems to work better\n",
        "      self.model.stop_training = True\n",
        "    if(logs.get('accuracy')>0.97 and logs.get('val_accuracy')>0.97):\n",
        "      print(\"\\nStopping training with accuracy of >97%\")\n",
        "      self.model.stop_training = True\n",
        "\n",
        "BS = 32\n",
        "EPOCHS = 20\n",
        "callback = myCallback()\n",
        "H = person_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,\n",
        "  callbacks = [callback])\n",
        "tf.keras.backend.clear_session()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/10\n",
            "32/32 [==============================] - 10s 319ms/step - loss: 0.8222 - accuracy: 0.8495 - val_loss: 0.0301 - val_accuracy: 0.9884\n",
            "Epoch 2/10\n",
            "32/32 [==============================] - 10s 313ms/step - loss: 0.0962 - accuracy: 0.9629 - val_loss: 0.0210 - val_accuracy: 0.9884\n",
            "Epoch 3/10\n",
            "32/32 [==============================] - ETA: 0s - loss: 0.0689 - accuracy: 0.9766\n",
            "Stopping training with accuracy of >97%\n",
            "32/32 [==============================] - 10s 318ms/step - loss: 0.0689 - accuracy: 0.9766 - val_loss: 0.0222 - val_accuracy: 0.9884\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jfw4RIaxsm8l",
        "colab_type": "text"
      },
      "source": [
        "*Check confidence of models*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lTscDmasziuL",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 170
        },
        "outputId": "7428a0b6-a620-4db5-8b7b-22c15de63a7b"
      },
      "source": [
        "image = load_img('/content/'+name+'_with_mask.jpg', target_size=(224, 224))\n",
        "image = img_to_array(image)\n",
        "image = preprocess_input(image)\n",
        "to_predict = []\n",
        "to_predict.append(image)\n",
        "to_predict = np.array(to_predict, dtype=\"float32\")\n",
        "print('Picture with mask')\n",
        "print('Factor 1 confidence : ',round(max(model.predict(to_predict)[0]),3))\n",
        "print('Factor 2 confidence : ',round(max(person_model.predict(to_predict)[0]),4))\n",
        "image = load_img('/content/'+name+'_without_mask.jpg', target_size=(224, 224))\n",
        "image = img_to_array(image)\n",
        "image = preprocess_input(image)\n",
        "to_predict = []\n",
        "to_predict.append(image)\n",
        "to_predict = np.array(to_predict, dtype=\"float32\")\n",
        "print('\\nPicture without mask')\n",
        "print('Factor 1 confidence : ',round(max(model.predict(to_predict)[0]),3))\n",
        "print('Factor 2 confidence : ',round(max(person_model.predict(to_predict)[0]),4))\n",
        "print('\\nFactor 1 confidences should be greater than 0.95 and Factor 2 confidences should be greater than 0.98')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Picture with mask\n",
            "Factor 1 confidence :  0.998\n",
            "Factor 2 confidence :  0.9999\n",
            "\n",
            "Picture without mask\n",
            "Factor 1 confidence :  0.979\n",
            "Factor 2 confidence :  0.9997\n",
            "\n",
            "Factor 1 confidence should be greater than 0.95 and Factor 2 confidence should be greater than 0.98\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MGypaeEgA-le",
        "colab_type": "text"
      },
      "source": [
        "**TEST THE MODELS**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bYBUSgdfJGL2",
        "colab_type": "text"
      },
      "source": [
        "*Set minimum confidence - default is 95% for first factor and 99% for second factor*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tAbhMrkwJPgc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "CONFIDENCE = 0.95\n",
        "CONFIDENCE2 = 0.99"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ht2w87GFBAqp",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 650
        },
        "outputId": "576937db-fb36-4c8e-a153-f63346035ebd"
      },
      "source": [
        "from IPython.display import display, Javascript\n",
        "from google.colab.output import eval_js\n",
        "from base64 import b64decode\n",
        "\n",
        "def take_photo(filename='photo.jpg', quality=0.8):\n",
        "  js = Javascript('''\n",
        "    async function takePhoto(quality) {\n",
        "      const div = document.createElement('div');\n",
        "      const capture = document.createElement('button');\n",
        "      capture.textContent = 'Capture';\n",
        "      div.appendChild(capture);\n",
        "\n",
        "      const video = document.createElement('video');\n",
        "      video.style.display = 'block';\n",
        "      const stream = await navigator.mediaDevices.getUserMedia({video: true});\n",
        "\n",
        "      document.body.appendChild(div);\n",
        "      div.appendChild(video);\n",
        "      video.srcObject = stream;\n",
        "      await video.play();\n",
        "\n",
        "      // Resize the output to fit the video element.\n",
        "      google.colab.output.setIframeHeight(document.documentElement.scrollHeight, true);\n",
        "\n",
        "      // Wait for Capture to be clicked.\n",
        "      await new Promise((resolve) => capture.onclick = resolve);\n",
        "      //setTimeout(() => {  console.log(\"World!\"); }, 10000);\n",
        "      //const promise = new Promise((resolve, reject) => {\n",
        "      //setTimeout(() => {\n",
        "       //resolve() // Change status to 'fulfilled'\n",
        "      //}, 5000)\n",
        "      //})\n",
        "      //await promise\n",
        "      const canvas = document.createElement('canvas');\n",
        "      canvas.width = video.videoWidth;\n",
        "      canvas.height = video.videoHeight;\n",
        "      canvas.getContext('2d').drawImage(video, 0, 0);\n",
        "      stream.getVideoTracks()[0].stop();\n",
        "      div.remove();\n",
        "      return canvas.toDataURL('image/jpeg', quality);\n",
        "    }\n",
        "    ''')\n",
        "  display(js)\n",
        "  data = eval_js('takePhoto({})'.format(quality))\n",
        "  binary = b64decode(data.split(',')[1])\n",
        "  with open(filename, 'wb') as f:\n",
        "    f.write(binary)\n",
        "  return filename\n",
        "\n",
        "\n",
        "from IPython.display import Image\n",
        "from IPython.display import clear_output\n",
        "import time\n",
        "try:\n",
        "  factor1,factor2='without mask','not self'\n",
        "  print('\\nWear your mask to access')\n",
        "  start_flag=True\n",
        "  while(factor1=='without mask' or factor2=='not self'):\n",
        "    if start_flag==False:\n",
        "      clear_output()\n",
        "      if prelim=='with mask' and factor1=='without mask':\n",
        "        print('\\nMask detected with low confidence (',round((confidence-0.5)*100,2),'%). Try coming closer to the camera and making sure the mask is covering your nose.')\n",
        "      if factor1=='without mask' and prelim=='without mask':\n",
        "        print('\\nNo mask detected - Please wear a mask over your nose and mouth.')\n",
        "      print('\\nDetails:\\nFirst factor - ','Passing' if factor1=='with mask' else 'Failing',('\\nSecond factor - ','Passing\\n' if factor2=='self' else 'Failing\\n') if factor1=='with mask' else '\\n')\n",
        "    filename = take_photo()\n",
        "    image = load_img('/content/photo.jpg', target_size=(224, 224))\n",
        "    image = img_to_array(image)\n",
        "    image = preprocess_input(image)\n",
        "    to_predict = []\n",
        "    to_predict.append(image)\n",
        "    to_predict = np.array(to_predict, dtype=\"float32\")\n",
        "    factor1 = 'without mask' if model.predict(to_predict)[0][0]<CONFIDENCE else 'with mask'\n",
        "    prelim = 'without mask' if model.predict(to_predict)[0][0]<0.5 else 'with mask'\n",
        "    confidence = max(model.predict(to_predict)[0])\n",
        "    factor2 = 'not self' if person_model.predict(to_predict)[0][1]<CONFIDENCE2 else 'self'\n",
        "    start_flag=False\n",
        "  clear_output()\n",
        "  print('\\n\\nMask detected with ',round(confidence*100,2),'% confidence.\\n\\nDetails:\\nFirst factor - Passing.\\nSecond factor - Passing.\\n')\n",
        "  display(Image(filename))\n",
        "  print('Access Granted')\n",
        "except Exception as err:\n",
        "  print(str(err))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "\n",
            "Mask detected with  97.44 % confidence.\n",
            "\n",
            "Details:\n",
            "First factor - Passing.\n",
            "Second factor - Passing.\n",
            "\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/jpeg": "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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Access Granted\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}