1903_opencv_eigenfaces.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "1903-opencv_eigenfaces.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.8.5"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/parekhakhil/pyImageSearch/blob/main/1903_opencv_eigenfaces.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kEYvcfHRB8dw"
      },
      "source": [
        "![pyimagesearch_university_logo.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j4RpK9pawQzP"
      },
      "source": [
        "# OpenCV Eigenfaces for Face Recognition\n",
        "### by [PyImageSearch.com](http://www.pyimagesearch.com)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8ntZ1AkXZIxY"
      },
      "source": [
        "## Welcome to **[PyImageSearch University](https://pyimg.co/university)** Jupyter Notebooks!\n",
        "\n",
        "This notebook is associated with the [OpenCV Eigenfaces for Face Recognition](https://www.pyimagesearch.com/2021/05/10/opencv-eigenfaces-for-face-recognition/) blog post published on 2021-05-10.\n",
        "\n",
        "Only the code for the blog post is here. Most codeblocks have a 1:1 relationship with what you find in the blog post with two exceptions: (1) Python classes are not separate files as they are typically organized with PyImageSearch projects, and (2) Command Line Argument parsing is replaced with an `args` dictionary that you can manipulate as needed.\n",
        "\n",
        "We recommend that you execute (press ▶️) the code block-by-block, as-is, before adjusting parameters and `args` inputs. Once you've verified that the code is working, you are welcome to hack with it and learn from manipulating inputs, settings, and parameters. For more information on using Jupyter and Colab, please refer to these resources:\n",
        "\n",
        "*   [Jupyter Notebook User Interface](https://jupyter-notebook.readthedocs.io/en/stable/notebook.html#notebook-user-interface)\n",
        "*   [Overview of Google Colaboratory Features](https://colab.research.google.com/notebooks/basic_features_overview.ipynb)\n",
        "\n",
        "As a reminder, these PyImageSearch University Jupyter Notebooks are not for sharing; please refer to the **Copyright** directly below and **Code License Agreement** in the last cell of this notebook. \n",
        "\n",
        "Happy hacking!\n",
        "\n",
        "*Adrian*\n",
        "\n",
        "<hr>\n",
        "\n",
        "***Copyright:*** *The contents of this Jupyter Notebook, unless otherwise indicated, are Copyright 2021 Adrian Rosebrock, PyimageSearch.com. All rights reserved. Content like this is made possible by the time invested by the authors. If you received this Jupyter Notebook and did not purchase it, please consider making future content possible by joining PyImageSearch University at https://pyimg.co/university today.*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NFhAzQB3aNMa"
      },
      "source": [
        "### Download the code zip file"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7y0LG1EuaRlB"
      },
      "source": [
        "!wget https://pyimagesearch-code-downloads.s3-us-west-2.amazonaws.com/opencv-eigenfaces/opencv-eigenfaces.zip\n",
        "!unzip -qq opencv-eigenfaces.zip\n",
        "%cd opencv-eigenfaces"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_SgTVT3HagGZ"
      },
      "source": [
        "## Blog Post Code"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wcrOk6pURp50"
      },
      "source": [
        "### Import Packages"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VJaCNlDDRz6d"
      },
      "source": [
        "# import the necessary packages\n",
        "from sklearn.preprocessing import LabelEncoder\n",
        "from sklearn.decomposition import PCA\n",
        "from sklearn.svm import SVC\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.metrics import classification_report\n",
        "from skimage.exposure import rescale_intensity\n",
        "from pyimagesearch.faces import load_face_dataset\n",
        "from matplotlib import pyplot as plt\n",
        "from imutils import build_montages\n",
        "from imutils import paths\n",
        "import numpy as np\n",
        "import argparse\n",
        "import imutils\n",
        "import time\n",
        "import cv2\n",
        "import os"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lBrLwCtN5kqy"
      },
      "source": [
        "### Function to display images in Jupyter Notebooks and Google Colab"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sYaD_Es9-8y6"
      },
      "source": [
        "def plt_imshow(title, image):\n",
        "\t# convert the image frame BGR to RGB color space and display it\n",
        "\timage = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
        "\tplt.imshow(image)\n",
        "\tplt.title(title)\n",
        "\tplt.grid(False)\n",
        "\tplt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "khdPrbuL-5xD"
      },
      "source": [
        "### Implementing face detection and CALTECH face dataset loading"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yqDCDtdS-OGF"
      },
      "source": [
        "def detect_faces(net, image, minConfidence=0.5):\n",
        "\t# grab the dimensions of the image and then construct a blob\n",
        "\t# from it\n",
        "\t(h, w) = image.shape[:2]\n",
        "\tblob = cv2.dnn.blobFromImage(image, 1.0, (300, 300),\n",
        "\t\t(104.0, 177.0, 123.0))\n",
        "\n",
        "\t# pass the blob through the network to obtain the face detections,\n",
        "\t# then initialize a list to store the predicted bounding boxes\n",
        "\tnet.setInput(blob)\n",
        "\tdetections = net.forward()\n",
        "\tboxes = []\n",
        "\n",
        "\t# loop over the detections\n",
        "\tfor i in range(0, detections.shape[2]):\n",
        "\t\t# extract the confidence (i.e., probability) associated with\n",
        "\t\t# the detection\n",
        "\t\tconfidence = detections[0, 0, i, 2]\n",
        "\n",
        "\t\t# filter out weak detections by ensuring the confidence is\n",
        "\t\t# greater than the minimum confidence\n",
        "\t\tif confidence > minConfidence:\n",
        "\t\t\t# compute the (x, y)-coordinates of the bounding box for\n",
        "\t\t\t# the object\n",
        "\t\t\tbox = detections[0, 0, i, 3:7] * np.array([w, h, w, h])\n",
        "\t\t\t(startX, startY, endX, endY) = box.astype(\"int\")\n",
        "\n",
        "\t\t\t# update our bounding box results list\n",
        "\t\t\tboxes.append((startX, startY, endX, endY))\n",
        "\n",
        "\t# return the face detection bounding boxes\n",
        "\treturn boxes"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yV-1LIUZ-UN4"
      },
      "source": [
        "def load_face_dataset(inputPath, net, minConfidence=0.5,\n",
        "\tminSamples=15):\n",
        "\t# grab the paths to all images in our input directory, extract\n",
        "\t# the name of the person (i.e., class label) from the directory\n",
        "\t# structure, and count the number of example images we have per\n",
        "\t# face\n",
        "\timagePaths = list(paths.list_images(inputPath))\n",
        "\tnames = [p.split(os.path.sep)[-2] for p in imagePaths]\n",
        "\t(names, counts) = np.unique(names, return_counts=True)\n",
        "\tnames = names.tolist()\n",
        "\n",
        "\t# initialize lists to store our extracted faces and associated\n",
        "\t# labels\n",
        "\tfaces = []\n",
        "\tlabels = []\n",
        "\n",
        "\t# loop over the image paths\n",
        "\tfor imagePath in imagePaths:\n",
        "\t\t# load the image from disk and extract the name of the person\n",
        "\t\t# from the subdirectory structure\n",
        "\t\timage = cv2.imread(imagePath)\n",
        "\t\tname = imagePath.split(os.path.sep)[-2]\n",
        "\n",
        "\t\t# only process images that have a sufficient number of\n",
        "\t\t# examples belonging to the class\n",
        "\t\tif counts[names.index(name)] < minSamples:\n",
        "\t\t\tcontinue\n",
        "\n",
        "\t\t# perform face detection\n",
        "\t\tboxes = detect_faces(net, image, minConfidence)\n",
        "\n",
        "\t\t# loop over the bounding boxes\n",
        "\t\tfor (startX, startY, endX, endY) in boxes:\n",
        "\t\t\t# extract the face ROI, resize it, and convert it to\n",
        "\t\t\t# grayscale\n",
        "\t\t\tfaceROI = image[startY:endY, startX:endX]\n",
        "\t\t\tfaceROI = cv2.resize(faceROI, (47, 62))\n",
        "\t\t\tfaceROI = cv2.cvtColor(faceROI, cv2.COLOR_BGR2GRAY)\n",
        "\n",
        "\t\t\t# update our faces and labels lists\n",
        "\t\t\tfaces.append(faceROI)\n",
        "\t\t\tlabels.append(name)\n",
        "\n",
        "\t# convert our faces and labels lists to NumPy arrays\n",
        "\tfaces = np.array(faces)\n",
        "\tlabels = np.array(labels)\n",
        "\n",
        "\t# return a 2-tuple of the faces and labels\n",
        "\treturn (faces, labels)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jppw5-Bd56H-"
      },
      "source": [
        "### Implementing Eigenfaces with OpenCV"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "okM7Bpyeq8Kc"
      },
      "source": [
        "# construct the argument parser and parse the arguments\n",
        "#ap = argparse.ArgumentParser()\n",
        "#ap.add_argument(\"-i\", \"--input\", type=str, required=True,\n",
        "#\thelp=\"path to input directory of images\")\n",
        "#ap.add_argument(\"-f\", \"--face\", type=str,\n",
        "#\tdefault=\"face_detector\",\n",
        "#\thelp=\"path to face detector model directory\")\n",
        "#ap.add_argument(\"-c\", \"--confidence\", type=float, default=0.5,\n",
        "#\thelp=\"minimum probability to filter weak detections\")\n",
        "#ap.add_argument(\"-n\", \"--num-components\", type=int, default=150,\n",
        "#\thelp=\"# of principal components\")\n",
        "#ap.add_argument(\"-v\", \"--visualize\", type=int, default=-1,\n",
        "#\thelp=\"whether or not PCA components should be visualized\")\n",
        "#args = vars(ap.parse_args())\n",
        "\n",
        "# since we are using Jupyter Notebooks we can replace our argument\n",
        "# parsing code with *hard coded* arguments and values\n",
        "args = {\n",
        "\t\"input\": \"caltech_faces\",\n",
        "    \"face\": \"face_detector\",\n",
        "    \"confidence\": 0.5,\n",
        "    \"num_components\": 150,\n",
        "    \"visualize\": 1\n",
        "}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e4w1UArZ--Is"
      },
      "source": [
        "# load our serialized face detector model from disk\n",
        "print(\"[INFO] loading face detector model...\")\n",
        "prototxtPath = os.path.sep.join([args[\"face\"], \"deploy.prototxt\"])\n",
        "weightsPath = os.path.sep.join([args[\"face\"],\n",
        "\t\"res10_300x300_ssd_iter_140000.caffemodel\"])\n",
        "net = cv2.dnn.readNet(prototxtPath, weightsPath)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I04uJjGK_ACI"
      },
      "source": [
        "# load the CALTECH faces dataset\n",
        "print(\"[INFO] loading dataset...\")\n",
        "(faces, labels) = load_face_dataset(args[\"input\"], net,\n",
        "\tminConfidence=0.5, minSamples=20)\n",
        "print(\"[INFO] {} images in dataset\".format(len(faces)))\n",
        "\n",
        "# flatten all 2D faces into a 1D list of pixel intensities\n",
        "pcaFaces = np.array([f.flatten() for f in faces])\n",
        "\n",
        "# encode the string labels as integers\n",
        "le = LabelEncoder()\n",
        "labels = le.fit_transform(labels)\n",
        "\n",
        "# construct our training and testing split\n",
        "split = train_test_split(faces, pcaFaces, labels, test_size=0.25,\n",
        "\tstratify=labels, random_state=42)\n",
        "(origTrain, origTest, trainX, testX, trainY, testY) = split"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u8jwi2Jg_B7F"
      },
      "source": [
        "# compute the PCA (eigenfaces) representation of the data, then\n",
        "# project the training data onto the eigenfaces subspace\n",
        "print(\"[INFO] creating eigenfaces...\")\n",
        "pca = PCA(\n",
        "\tsvd_solver=\"randomized\",\n",
        "\tn_components=args[\"num_components\"],\n",
        "\twhiten=True)\n",
        "start = time.time()\n",
        "trainX = pca.fit_transform(trainX)\n",
        "end = time.time()\n",
        "print(\"[INFO] computing eigenfaces took {:.4f} seconds\".format(\n",
        "\tend - start))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V8cCSeNO_GFQ"
      },
      "source": [
        "# check to see if the PCA components should be visualized\n",
        "if args[\"visualize\"] > 0:\n",
        "\t# initialize the list of images in the montage\n",
        "\timages = []\n",
        "\n",
        "\t# loop over the first 16 individual components\n",
        "\tfor (i, component) in enumerate(pca.components_[:16]):\n",
        "\t\t# reshape the component to a 2D matrix, then convert the data\n",
        "\t\t# type to an unsigned 8-bit integer so it can be displayed\n",
        "\t\t# with OpenCV\n",
        "\t\tcomponent = component.reshape((62, 47))\n",
        "\t\tcomponent = rescale_intensity(component, out_range=(0, 255))\n",
        "\t\tcomponent = np.dstack([component.astype(\"uint8\")] * 3)\n",
        "\t\timages.append(component)\n",
        "\n",
        "\t# construct the montage for the images\n",
        "\tmontage = build_montages(images, (47, 62), (4, 4))[0]\n",
        "\n",
        "\t# show the mean and principal component visualizations\n",
        "\t# show the mean image\n",
        "\tmean = pca.mean_.reshape((62, 47))\n",
        "\tmean = rescale_intensity(mean, out_range=(0, 255)).astype(\"uint8\")\n",
        "\tplt_imshow(\"Mean\", mean)\n",
        "\tplt_imshow(\"Components\", montage)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7chGsGuT_HhH"
      },
      "source": [
        "# train a classifier on the eigenfaces representation\n",
        "print(\"[INFO] training classifier...\")\n",
        "model = SVC(kernel=\"rbf\", C=10.0, gamma=0.001, random_state=42)\n",
        "model.fit(trainX, trainY)\n",
        "\n",
        "# evaluate the model\n",
        "print(\"[INFO] evaluating model...\")\n",
        "predictions = model.predict(pca.transform(testX))\n",
        "print(classification_report(testY, predictions,\n",
        "\ttarget_names=le.classes_))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yG1VHjHz_KUp"
      },
      "source": [
        "# generate a sample of testing data\n",
        "idxs = np.random.choice(range(0, len(testY)), size=10, replace=False)\n",
        "\n",
        "# loop over a sample of the testing data\n",
        "for i in idxs:\n",
        "\t# grab the predicted name and actual name\n",
        "\tpredName = le.inverse_transform([predictions[i]])[0]\n",
        "\tactualName = le.classes_[testY[i]]\n",
        "\n",
        "\t# grab the face image and resize it such that we can easily see\n",
        "\t# it on our screen\n",
        "\tface = np.dstack([origTest[i]] * 3)\n",
        "\tface = imutils.resize(face, width=250)\n",
        "\n",
        "\t# draw the predicted name and actual name on the image\n",
        "\tcv2.putText(face, \"pred: {}\".format(predName), (5, 25),\n",
        "\t\tcv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2)\n",
        "\tcv2.putText(face, \"actual: {}\".format(actualName), (5, 60),\n",
        "\t\tcv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 255), 2)\n",
        "\n",
        "\t# display the predicted name  and actual name\n",
        "\tprint(\"[INFO] prediction: {}, actual: {}\".format(\n",
        "\t\tpredName, actualName))\n",
        "\n",
        "\t# display the current face to our screen\n",
        "\tplt_imshow(\"Face\", face)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4ogkNauArL6u"
      },
      "source": [
        "For a detailed walkthrough of the concepts and code, be sure to refer to the full tutorial, [*OpenCV Eigenfaces for Face Recognition*](https://www.pyimagesearch.com/2021/05/10/opencv-eigenfaces-for-face-recognition/) published on 2021-05-10."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Sef8alx4cGYc"
      },
      "source": [
        "# Code License Agreement\n",
        "```\n",
        "Copyright (c) 2021 PyImageSearch.com\n",
        "\n",
        "SIMPLE VERSION\n",
        "Feel free to use this code for your own projects, whether they are\n",
        "purely educational, for fun, or for profit. THE EXCEPTION BEING if\n",
        "you are developing a course, book, or other educational product.\n",
        "Under *NO CIRCUMSTANCE* may you use this code for your own paid\n",
        "educational or self-promotional ventures without written consent\n",
        "from Adrian Rosebrock and PyImageSearch.com.\n",
        "\n",
        "LONGER, FORMAL VERSION\n",
        "Permission is hereby granted, free of charge, to any person obtaining\n",
        "a copy of this software and associated documentation files\n",
        "(the \"Software\"), to deal in the Software without restriction,\n",
        "including without limitation the rights to use, copy, modify, merge,\n",
        "publish, distribute, sublicense, and/or sell copies of the Software,\n",
        "and to permit persons to whom the Software is furnished to do so,\n",
        "subject to the following conditions:\n",
        "The above copyright notice and this permission notice shall be\n",
        "included in all copies or substantial portions of the Software.\n",
        "Notwithstanding the foregoing, you may not use, copy, modify, merge,\n",
        "publish, distribute, sublicense, create a derivative work, and/or\n",
        "sell copies of the Software in any work that is designed, intended,\n",
        "or marketed for pedagogical or instructional purposes related to\n",
        "programming, coding, application development, or information\n",
        "technology. Permission for such use, copying, modification, and\n",
        "merger, publication, distribution, sub-licensing, creation of\n",
        "derivative works, or sale is expressly withheld.\n",
        "THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n",
        "EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES\n",
        "OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n",
        "NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\n",
        "BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\n",
        "ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\n",
        "CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n",
        "SOFTWARE.\n",
        "```"
      ]
    }
  ]
}