Build Your Face Recognition System Using Python
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.
This article was published as a part of the Data Science Blogathon.
Table of contents
- Use Cases of Recognition Systems
- Traditional Face Recognition Algorithm
- Deep Learning For Face Recognition
- Steps Involved in Face Recognition
- Understand the Working of Face Recognition
- Challenges in Recognition Systems
- Frequently Asked Questions
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.
- 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.
DeepIDseries of systems,
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.
Steps Involved in Face Recognition
- Face Detection: Locate the face, note the coordinates of each face locate,d and draw a bounding box around every faces.
- Face Alignments. Normalize the faces in order to attain fast training.
- Feature Extraction. Local feature extraction from facial pictures for training, this step is performed differently by different algorithms.
- Face Recognition. Match the input face with one or more known faces in our dataset.
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.
Implementing a face recognition system using python. Implementing a Deep learning-based face recognition system using the face_recognition library.
Step 1: Setting Face Recognition Libraries
In order to install the face recognition library, we need to first install the
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
# 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 .
import cv2 import numpy as np import face_recognition
Step 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. Here is the link for the same.
face_recognition supports 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/modi.jpg') img_rgb = cv2.cvtColor(img_bgr,cv2.COLOR_BGR2RGB) cv2.imshow('bgr', img_bgr) cv2.imshow('rgb', img_rgb) cv2.waitKey
Output → BGR vs RGB
Step 3: Detecting and Locating Faces
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/modi.jpg') img_modi_rgb = cv2.cvtColor(img_modi,cv2.COLOR_BGR2RGB) #--------- Detecting Face ------- face = face_recognition.face_locations(img_modi_rgb) copy = img_modi_rgb.copy() # ------ Drawing bounding boxes around Faces------------------------ cv2.rectangle(copy, (face, face),(face, face), (255,0,255), 2) cv2.imshow('copy', copy) cv2.imshow('MODI',img_modi_rgb) cv2.waitKey(0)
Step 4: Sample Image Recognition
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/modi.jpg') img_modi = cv2.cvtColor(img_modi,cv2.COLOR_BGR2RGB) #------to find the face location face = face_recognition.face_locations(img_modi) #--Converting image into encodings train_encode = face_recognition.face_encodings(img_modi) #----- lets test an image test = face_recognition.load_image_file('student_images/modi2.jpg') test = cv2.cvtColor(test, cv2.COLOR_BGR2RGB) test_encode = face_recognition.face_encodings(test) print(face_recognition.compare_faces([train_encode],test_encode)) cv2.rectangle(img_modi, (face, face),(face, face), (255,0,255), 1) cv2.imshow('img_modi', img_modi) cv2.waitKey(0)
The above code took two pictures of the prime minister, and it returned
True because both photos were of the same person.
face_recognition.face_encodings(imgelon)→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
Trueif both test encoding has a match in train encoding; otherwise, it returns.
Understand the Working of Face Recognition
- We pass the person’s picture to the model and their name.
- 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.
- In the Prediction Phase when we pass a picture of an unknown person recognition model converts the unfamiliar person’s Image into encoding.
- 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.
- 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
Facing challenges while working on recognition systems in common, all you need to learn is how to get out of them. Here are some common challenges:
- 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. Face recognition pictures should be clear with proper brightness.
- 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.
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.
Frequently Asked Questions
A. Python is used in face recognition by utilizing libraries like OpenCV and Dlib to detect and recognize facial features, process images, and implement machine learning algorithms for identification.
A. OpenCV is one of Python’s best face recognition libraries due to its extensive functionality, real-time performance, and compatibility with various platforms and devices.
A. OpenCV is used in face recognition for its robust face detection capabilities, efficient image processing functions, and easy integration with Python, making it a popular choice for facial analysis tasks.
A. To detect face masks using Python, you can employ deep learning frameworks like TensorFlow or Keras to build a mask detection model, then use OpenCV to process video streams or images and identify faces with or without masks.
Face recognition uses algorithms like Eigenfaces, Fisherfaces, and Deep Neural Networks (DNNs). DNNs, including Convolutional Neural Networks (CNNs), are great at capturing detailed facial features.
The media shown in this article is not owned by Analytics Vidhya and are used at the Author’s discretion.