Face Recognition System Using Python
C O M PUT E R VI S I O N I M A G E A NA LYS I S I NT E RM E D I AT E PYT HO N
This article was published as a part of the Data Science Blogathon.
Introduction
Face recognition is different from face detection. In face detection, we had only detected the location of
human faces, and we recognized the identity of faces in the face recognition task.
In this article, we are going to build a face recognition system using python with the help of face
recognition library .
There are many algorithms available in the market for face recognition. This broad computer vision
challenge is detecting faces from videos and pictures. Many applications can be built on top of recognition
systems. Many big companies are adopting recognition systems for their security and authentication
purposes.
Use Cases of Recognition Systems
Face recognition systems are widely used in the modern era, and many new innovative systems are built on
top of recognition systems.
There are a few used cases :
Finding Missing Person
Identifying accounts on social media
Recognizing Drivers in Cars
School Attendance System
Several methods and algorithms implement facial recognition systems depending on the performance and
accuracy.
Traditional Face Recognition Algorithm
Traditional face recognition algorithms don’t meet modern-day’s facial recognition standards. They were
designed to recognize faces using old conventional algorithms.
OpenCV provides some traditional facial Recognition Algorithms.
Eigenfaces
Scale Invariant Feature Transform (SIFT)
Fisher faces
Local Binary Patterns Histograms (LBPH)
These methods differ in the way they extract image information and match input and output images.
LBPH algorithm is a simple yet very efficient method still in use but it’s slow compared to modern days
algorithms.
Deep Learning For Face Recognition
There are various deep learning-based facial recognition algorithms available.
DeepFace
DeepID series of systems,
FaceNet
VGGFace
Generally, face recognizers that are based on landmarks take face images and try to find essential feature
points such as eyebrows, corners of the mouth, eyes, nose, lips, etc. There are more than 60 points.
Source: [Link]
Steps Involved in Face Recognition
1. Face Detection: Locate the face, note the coordinates of each face locate,d and draw a bounding box
around every faces.
2. Face Alignments. Normalize the faces in order to attain fast training.
3. Feature Extraction. Local feature extraction from facial pictures for training, this step is performed
differently by different algorithms.
4. Face Recognition. Match the input face with one or more known faces in our dataset.
Source: [Link]
This article focuses on implementing face recognition using the library face_recognition, built on deep
learning techniques and promises accuracy greater than 96% using a single training image.
Implementation
Implementing a face recognition system using python. Implementing a Deep learning-based face
recognition system using the face_recognition library.
1. Setting face recognition libraries:
In order to install the face recognition library, we need to first install the dlib.
dlib : It is a modern C++ toolkit that contains ML-related algorithms and tools.
# installing dlib pip install dlib
face recognition The actual face recognition library can be installed after dlib.
# installing face recognition pip install face recognition
Opencv for some image pre-processing
# installing opencv pip install opencv Note: Sometimes installing dlib throws error in that case install install the C++ development toolkit
using vs_code community .
Impor ting Libraries
import cv2 import numpy as np import face_recognition
2. Loading Image:
We are done with installing and importing the libraries. It’s time to load some sample images to the
face_recognition library.
The library face_recognitionsupports only the BGR format of images. While printing the output image
we should convert it into RGB using OpenCV.
Face_recognition Loads images only in BGR format.
import cv2 import numpy as np import face_recognition img_bgr =
face_recognition.load_image_file('student_images/[Link]') img_rgb = [Link](img_bgr,cv2.COLOR_BGR2RGB)
[Link]('bgr', img_bgr) [Link]('rgb', img_rgb) [Link]
Output → BGR vs RGB
3. Detecting and Locating Faces:
The library face_recognitioncan quickly locate faces on its own, we don’t need to use haar_cascade
and other techniques.
img_modi=face_recognition.load_image_file('student_images/[Link]') img_modi_rgb =
[Link](img_modi,cv2.COLOR_BGR2RGB) #--------- Detecting Face ------- face =
face_recognition.face_locations(img_modi_rgb)[0] copy = img_modi_rgb.copy() # ------ Drawing bounding boxes
around Faces------------------------ [Link](copy, (face[3], face[0]),(face[1], face[2]), (255,0,255),
2) [Link]('copy', copy) [Link]('MODI',img_modi_rgb) [Link](0)
4. Sample Image Recognition:
The library face_recognition is based on deep learning, it supports single-shot learning which means it
needs a single picture to train itself to detect a person.
img_modi = face_recognition.load_image_file('student_images/[Link]') img_modi =
[Link](img_modi,cv2.COLOR_BGR2RGB)
#------to find the face location face = face_recognition.face_locations(img_modi)[0]
#--Converting image into encodings train_encode = face_recognition.face_encodings(img_modi)[0]
#----- lets test an image test = face_recognition.load_image_file('student_images/[Link]') test =
[Link](test, cv2.COLOR_BGR2RGB) test_encode = face_recognition.face_encodings(test)[0]
print(face_recognition.compare_faces([train_encode],test_encode)) [Link](img_modi, (face[3], face[0]),
(face[1], face[2]), (255,0,255), 1) [Link]('img_modi', img_modi) [Link](0)
The above code took two pictures of the prime minister, and it returnedTrue because both photos were of
the same person.
face_recognition.face_encodings(imgelon)[0] →Returns encoding of passed Image.
face_recognition.compare_faces([train_encode],test_encode) → Takes a list of trained
encodings and a test encoding of the unknown Image. It returns True if both test encoding has a
match in train encoding; otherwise, it returns. False.
Understand the Working of Face Recognition
1. We pass the person’s picture to the model and their name.
2. The model takes every picture, converts them into some numerical encoding, and stores them in a list
and all the labels(names of persons) in another list.
3. In the Prediction Phase when we pass a picture of an unknown person recognition model converts the
unfamiliar person’s Image into encoding.
4. After converting an unknown person’s Image into encoding, it tries to find the most similar encoding
based on the distance parameter. The store encoding with the least distance from the encoding of an
unknown person will be the closest match.
5. After getting the closest match encoding, we take the index of that encoding from that list and use
indexing. We find the detected person’s name.
Challenges in Recognition Systems
These are significant challenges faced by recognition systems and need to be resolved.
Pose: Recognition systems are susceptible to the human pose. Facial recognition systems will not be
able to predict if the person’s face is not visible.
Illumination: Illumination changes the face contours drastically. Pictures for face recognition should
be taken in proper lighting conditions.
Facial Expressions: Different facial expressions can result in different predictions of the same person’s
Image.
Low Resolution: Low-resolution pictures contain less information, hence not good for face recognition
training.
Conclusion
This article discussed how to implement a face recognition system using python with a single-shot image
training technique. You can further use GUI like python Tkinter to design a GUI-based attendance system.
We saw various challenges that affect a recognition system and how to solve them.
In the next article, we will create a face recognition attendance system using the same concepts which we
have discussed today.
The media shown in this ar ticle is not owned by Analytics Vidhya and are used at the Author’s discretion.
Article Url - [Link]
Abhishek Jaiswal