Face Recognition.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Face Recognition System\n",
    "\n",
    "> __The system is designed in a way the you can train a model on multiple faces and can register each face with a name and id. Hence forth system can later be used to recognize multiple faces at a time.__\n",
    "\n",
    "![FR_gif](https://i.pinimg.com/originals/2e/16/a8/2e16a81155d82049a213a3bc0c7ce1bc.gif)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dependencies:-\n",
    "1. os :- for navigation through directories and file saving purposes\\\n",
    "2. cv2 :- for computer vision and machine learning\n",
    "3. numpy:- to handle encoded image data inform of arrays\n",
    "4. PIL.image :- handling images for opening, manipulating, saving\n",
    "5. pickle :- file handling for saving names corresponding to face"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# install dependencies:-\n",
    "!pip uninstall opencv-python\n",
    "!pip install opencv-contrib-python\n",
    "!pip install Pillow\n",
    "\n",
    "#!pip install opencv-contrib-python --upgrade  if you are faci9ng module import errors!!."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "from PIL import Image \n",
    "import pickle\n",
    "import os"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Please make the directories for storing sample face images \"dataset\" in the root folder and \"trainer\" directory for storing model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# creating pickle file for name list.\n",
    "'''DO NOT RUN THESE LINES TWICE'''\n",
    "\n",
    "names = []\n",
    "filename = \"names.pkl\"\n",
    "f = open(filename, 'wb')\n",
    "pickle.dump(names,f)\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Face Registration\n",
    "---\n",
    "## Face Sampling\n",
    "\n",
    "Used __Haarcascade__ for detecting facial features and detecting a face. [Link to download](http://alereimondo.no-ip.org/OpenCV/uploads/34/frontalFace10.zip) \n",
    "\n",
    "[Github](https://github.com/RitvikDayal/Face-Recognition-LPBH)\n",
    "\n",
    "__Reason__ :- Its is efficient and fast method with high accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def faceSampling():\n",
    "    cam = cv2.VideoCapture('http://192.168.43.1:8080/video')\n",
    "    cam.set(3, 640) # set video width\n",
    "    cam.set(4, 480) # set video height\n",
    "\n",
    "    face_detector = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')\n",
    "\n",
    "    with open('names.pkl', 'rb') as f:\n",
    "        names = pickle.load(f)\n",
    "\n",
    "    name = input('Enter name for the Face: ')\n",
    "    names.append(name)\n",
    "    id = names.index(name)\n",
    "\n",
    "    print('''\\n\n",
    "    Look in the camera Face Sampling has started!.\n",
    "    Try to move your face and change expression for better face memory registration.\\n\n",
    "    ''')\n",
    "    # Initialize individual sampling face count\n",
    "    count = 0\n",
    "\n",
    "    while(True):\n",
    "\n",
    "        ret, img = cam.read()\n",
    "        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n",
    "        faces = face_detector.detectMultiScale(gray, 1.3, 5)\n",
    "\n",
    "        for (x,y,w,h) in faces:\n",
    "\n",
    "            cv2.rectangle(img, (x,y), (x+w,y+h), (255,0,0), 2)     \n",
    "            count += 1\n",
    "\n",
    "            # Save the captured image into the datasets folder\n",
    "            cv2.imwrite(\"dataset/\"+name+\".\" + str(id) + '.' + str(count) + \".jpg\", gray[y:y+h,x:x+w])\n",
    "\n",
    "            cv2.imshow('image', img)\n",
    "\n",
    "        k = cv2.waitKey(100) & 0xff # Press 'ESC' for exiting video\n",
    "        if k == 27:\n",
    "            break\n",
    "        elif count >= 80: # Take 80 face sample and stop video\n",
    "             break\n",
    "\n",
    "    with open('names.pkl', 'wb') as f:\n",
    "        pickle.dump(names, f)\n",
    "\n",
    "    # Do a bit of cleanup\n",
    "    print(\"Your Face has been registered as {}\\n\\nExiting Sampling Program\".format(name.upper()))\n",
    "    cam.release()\n",
    "    cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Face Training\n",
    "\n",
    "Used LBPH Algorithm from opencv library for training and modelling purpose to avoid illumination differences in image.\n",
    "\n",
    "The below function gets all the sample images and then filter them on face id bases and train the model using LBPH.\n",
    "\n",
    "<img src=\"data:image/jpeg;base64,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\" width=400 height=200>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def faceLearning():\n",
    "    # Path for face image database\n",
    "    path = 'dataset'\n",
    "\n",
    "    recognizer = cv2.face.LBPHFaceRecognizer_create() \n",
    "    detector = cv2.CascadeClassifier(\"haarcascade_frontalface_default.xml\")\n",
    "\n",
    "    # function to get the images and label data\n",
    "    def getImagesAndLabels(path):\n",
    "\n",
    "        imagePaths = [os.path.join(path,f) for f in os.listdir(path)]     \n",
    "        faceSamples=[]\n",
    "        ids = []\n",
    "\n",
    "        for imagePath in imagePaths:\n",
    "\n",
    "            PIL_img = Image.open(imagePath).convert('L') # convert it to grayscale\n",
    "            img_numpy = np.array(PIL_img,'uint8')\n",
    "\n",
    "            id = int(os.path.split(imagePath)[-1].split(\".\")[1])\n",
    "            faces = detector.detectMultiScale(img_numpy)\n",
    "\n",
    "            for (x,y,w,h) in faces:\n",
    "                faceSamples.append(img_numpy[y:y+h,x:x+w])\n",
    "                ids.append(id)\n",
    "\n",
    "        return faceSamples,ids\n",
    "\n",
    "    print (\"\\nTraining for the faces has been started. It might take a while.\\n\")\n",
    "    faces,ids = getImagesAndLabels(path)\n",
    "    recognizer.train(faces, np.array(ids))\n",
    "\n",
    "    # Save the model into trainer/trainer.yml\n",
    "    recognizer.write('trainer/trainer.yml') \n",
    "\n",
    "    # Print the numer of faces trained and end program\n",
    "    print(\"{0} faces trained. Exiting Training Program\".format(len(np.unique(ids))))    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Face Recognition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def faceRecognition():\n",
    "    print('\\nStarting Recognizer....')\n",
    "    recognizer = cv2.face.LBPHFaceRecognizer_create()\n",
    "    recognizer.read('trainer/trainer.yml')\n",
    "    cascadePath = \"haarcascade_frontalface_default.xml\"\n",
    "    faceCascade = cv2.CascadeClassifier(cascadePath);\n",
    "\n",
    "    font = cv2.FONT_HERSHEY_SIMPLEX\n",
    "\n",
    "    # Starting realtime video capture\n",
    "    cam = cv2.VideoCapture('http://192.168.43.1:8080/video')\n",
    "    cam.set(3, 640) # set video widht\n",
    "    cam.set(4, 480) # set video height\n",
    "\n",
    "    # Define min window size to be recognized as a face\n",
    "    minW = 0.1*cam.get(3)\n",
    "    minH = 0.1*cam.get(4)\n",
    "\n",
    "    with open('names.pkl', 'rb') as f:\n",
    "        names = pickle.load(f)\n",
    "\n",
    "    while True:\n",
    "\n",
    "        ret, img =cam.read()\n",
    "\n",
    "        gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)\n",
    "\n",
    "        faces = faceCascade.detectMultiScale( \n",
    "            gray,\n",
    "            scaleFactor = 1.2,\n",
    "            minNeighbors = 5,\n",
    "            minSize = (int(minW), int(minH)),\n",
    "           )\n",
    "\n",
    "        for(x,y,w,h) in faces:\n",
    "\n",
    "            cv2.rectangle(img, (x,y), (x+w,y+h), (0,255,0), 2)\n",
    "\n",
    "            id, confidence = recognizer.predict(gray[y:y+h,x:x+w])\n",
    "\n",
    "            # Check if confidence is less them 100 ==> \"0\" is perfect match \n",
    "            if (confidence < 100):\n",
    "                id = names[id]\n",
    "                confidence = \"  {0}%\".format(round(100 - confidence))\n",
    "            else:\n",
    "                id = \"unknown\"\n",
    "                confidence = \"  {0}%\".format(round(100 - confidence))\n",
    "\n",
    "            cv2.putText(img, str(id), (x+5,y-5), font, 1, (255,255,255), 2)\n",
    "            cv2.putText(img, str(confidence), (x+5,y+h-5), font, 1, (255,255,0), 1)  \n",
    "\n",
    "        cv2.imshow('camera',img) \n",
    "\n",
    "        k = cv2.waitKey(10) & 0xff # Press 'ESC' for exiting video\n",
    "        if k == 27:\n",
    "            break\n",
    "\n",
    "    # Do a bit of cleanup\n",
    "    print(\"\\nExiting Recognizer.\")\n",
    "    cam.release()\n",
    "    cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    while True:\n",
    "        choice = int(input('''\n",
    "        ###################################################################\n",
    "        1 --> Register New Face.\n",
    "        2 --> Face Recognization.\n",
    "        3 --> Exit.\n",
    "        Your Choice: \n",
    "        '''))\n",
    "        \n",
    "        if choice == 1:\n",
    "            faceSampling()\n",
    "            faceLearning()\n",
    "        elif choice == 2:\n",
    "            faceRecognition()\n",
    "        elif choice == 3:\n",
    "            print('\\nExiting Program.')\n",
    "            break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "        ###################################################################\n",
      "        1 --> Register New Face.\n",
      "        2 --> Face Recognization.\n",
      "        3 --> Exit.\n",
      "        Your Choice: \n",
      "        2\n",
      "\n",
      "Starting Recognizer....\n",
      "\n",
      "Exiting Recognizer.\n",
      "\n",
      "        ###################################################################\n",
      "        1 --> Register New Face.\n",
      "        2 --> Face Recognization.\n",
      "        3 --> Exit.\n",
      "        Your Choice: \n",
      "        3\n",
      "\n",
      "Exiting Program.\n"
     ]
    }
   ],
   "source": [
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Note:-\n",
    "> Did not used global variables as using a single variable for multiple functions during same run will results in errors as in reading and writting files and models."
   ]
  }
 ],
 "metadata": {
  "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}