In this tutorial, you will learn how to build a face recognition system using computer vision in Python. Face recognition is an image classification problem and is a step further to face detection. In face detection, we only detect the location of the human face in an image, but in the face recognition classifier, we make a system that can identify humans.
In this article, you will understand the face recognition attendance system using Python. This project uses facial recognition technology to track attendance. You will also find the source code for this attendance system project.
“Face recognition is a broad challenge of verifying or identifying people in pictures or videos. Big tech giants are still working to make a faster and more accurate face recognition model.”
Learning Objectives
This article was published as a part of the Data Science Blogathon
A Face Recognition Attendance System is a new way for companies to keep track of when their employees come to work and when they leave. It uses cameras to take pictures of employees’ faces and then compares those pictures to a list of approved faces. If the system recognizes the employee’s face, it automatically marks them as present.This system works like this:
This new system has some advantages:
Face recognition is currently being used to make the world safer, smarter, and more convenient.
Some of its most common use cases include finding missing persons, solving retail crime, security identification, identifying accounts on social media, school attendance systems, and recognizing drivers in cars.
There are several methods to perform facial recognition depending on the performance and complexity.
During the 1990s, holistic approaches were used for face recognition. Handcrafted local descriptors became popular In the early 1920s, and then the local feature learning approaches were followed in the late 2000s. Nowadays, face recognition and face detection algorithms that are widely used and are implemented in OpenCV are as follows:
Each method follows a different approach to extracting and matching the image information with the input image.
Fischer-faces and Eigenfaces have almost similar approaches as well as SURF and SIFT.
LBPH is a simple yet very efficient method but is slow compared to modern face recognizers.
These algorithms are not faster compared to modern days face-recognition algorithms. Traditional algorithms can’t be trained only by taking a single picture of a person.
Some of the widely used Deep Learning-based face recognition systems are:
Face recognizers generally take face images and find the important points such as the corner of the mouth, an eyebrow, eyes, nose, lips, etc. The coordinates of these points are called facial feature points. There are 66 such points. In this way, a different technique for finding feature
points give different results.
In the traditional method of face recognition, we had separate modules to perform these 4 steps, which was painful. -In this article, you will see a library that combines all these 4 steps in a single step.
Step 1: Install libraries
We need to install 2 libraries in order to implement face recognition.
dlib: Dlib is a modern C++ toolkit containing machine learning algorithms and tools for creating complex software in C++ to solve real-world problems.
# installing dlib
pip install dlib
face recognition: The face_recognition library, created and maintained by Adam Geitgey, wraps around dlib facial recognition functionality.
# installing face recognition
pip install face recognition
Opencv for some image pre-processing.
# installing opencv
pip install opencv
Note: if in case you encounter any error while installing dlib, i would recommend you to install the C++ development toolkit using vs_code community
Step 2: Import libraries
Now that you have downloaded all the important libraries, let’s import them to build the system.
import cv2
import numpy as np
import face_recognition
Step 3: Load images
After importing libraries you need to load an image.
face_recognition library loads images in the form of BGR, in order to
print the image you should convert it into RGB using OpenCV.
imgelon_bgr = face_recognition.load_image_file('elon.jpg')
imgelon_rgb = cv2.cvtColor(imgelon_bgr,cv2.COLOR_BGR2RGB)
cv2.imshow('bgr', imgelon_bgr)
cv2.imshow('rgb', imgelon_rgb)
cv2.waitKey(0)
As you see, RGB looks natural, so you will always change the channel to RGB.
Step 4: Find the face location and draw bounding boxes
You need to draw a bounding box around the faces in order to show if the human face has been detected or not.
imgelon =face_recognition.load_image_file('elon.jpg')
imgelon = cv2.cvtColor(imgelon,cv2.COLOR_BGR2RGB)
#----------Finding face Location for drawing bounding boxes-------
face = face_recognition.face_locations(imgelon_rgb)[0]
copy = imgelon.copy()
#-------------------Drawing the Rectangle-------------------------
cv2.rectangle(copy, (face[3], face[0]),(face[1], face[2]), (255,0,255), 2)
cv2.imshow('copy', copy)
cv2.imshow('elon',imgelon)
cv2.waitKey(0)
Step 5: Train an image for face recognition
This library is made in such a way that it automatically finds the face and works on only faces, so you don’t need to crop the face out of pictures.
Training:
At this stage, we convert the train image into some encodings and store the encodings with the given name of the person for that image.
train_elon_encodings = face_recognition.face_encodings(imgelon)[0]
Testing:
For testing, we load an image and convert it into encodings, and now match encodings with the stored encodings during training. This matching is based on finding maximum similarity. When you find the encoding matching the test image, you get the name associated with train encodings.
# lets test an image
test = face_recognition.load_image_file('elon_2.jpg')
test = cv2.cvtColor(test, cv2.COLOR_BGR2RGB)
test_encode = face_recognition.face_encodings(test)[0]
print(face_recognition.compare_faces([train_encode],test_encode))
face_recognition.compare_faces returns True if the person in both images is the same, otherwise, it returns False.
Step 1: Import the necessary libraries.
import cv2
import face_recognition
import os
import numpy as np
from datetime import datetime
import pickle
Step 2: Define a folder path where your training image dataset will be stored.
path = 'student_images'
Note: for training, we only need to drop the training images in the path directory and the image name must be person_name.jpg/jpeg format.
For example: as you see in my student_images path, I have 6 persons. hence our model can recognize only these 6 persons. you can add more pictures in this directory for more people to be recognized.
Step 3: Now, create a list to store person_name and image array.
Traverse all image files present in the path directory, read images, and append the image array to the image list and file name to classNames.
images = []
classNames = []mylist = os.listdir(path)
for cl in mylist:
curImg = cv2.imread(f'{path}/{cl}')
images.append(curImg)
classNames.append(os.path.splitext(cl)[0])
Step 4: Create a function to encode all the train images and store them in a variable encoded_face_train.
def findEncodings(images):
encodeList = []
for img in images:
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
encoded_face = face_recognition.face_encodings(img)[0]
encodeList.append(encoded_face)
return encodeList
encoded_face_train = findEncodings(images)
Step 5: Create a function that will create aAttendance.csv file to store the attendance with time.
Note: here you need to create Attendance.csv file manually and give the path in the function
def markAttendance(name):
with open('Attendance.csv','r+') as f:
myDataList = f.readlines()
nameList = []
for line in myDataList:
entry = line.split(',')
nameList.append(entry[0])
if name not in nameList:
now = datetime.now()
time = now.strftime('%I:%M:%S:%p')
date = now.strftime('%d-%B-%Y')
f.writelines(f'n{name}, {time}, {date}')
Step 6: With open(“filename.csv”,’r+’) create a file, and ‘r+’ mode is used to open a file for reading and writing.
We first check if the name of the attendee is already available in attendance.csv. We won’t write attendance again. If the attendee’s name is not available in attendance.csv we will write the attendee’s name with a time of function call.
# take pictures from webcam
cap = cv2.VideoCapture(0)while True:
success, img = cap.read()
imgS = cv2.resize(img, (0,0), None, 0.25,0.25)
imgS = cv2.cvtColor(imgS, cv2.COLOR_BGR2RGB)
faces_in_frame = face_recognition.face_locations(imgS)
encoded_faces = face_recognition.face_encodings(imgS, faces_in_frame)for encode_face, faceloc in zip(encoded_faces,faces_in_frame):
matches = face_recognition.compare_faces(encoded_face_train, encode_face)
faceDist = face_recognition.face_distance(encoded_face_train, encode_face)
matchIndex = np.argmin(faceDist)
print(matchIndex)
if matches[matchIndex]:
name = classNames[matchIndex].upper().lower()
y1,x2,y2,x1 = faceloc
# since we scaled down by 4 times
y1, x2,y2,x1 = y1*4,x2*4,y2*4,x1*4
cv2.rectangle(img,(x1,y1),(x2,y2),(0,255,0),2)
cv2.rectangle(img, (x1,y2-35),(x2,y2), (0,255,0), cv2.FILLED)
cv2.putText(img,name, (x1+6,y2-5), cv2.FONT_HERSHEY_COMPLEX,1,(255,255,255),2)
markAttendance(name)
cv2.imshow('webcam', img)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
Although building facial recognition seems easy, it is not as easy in real-world images that are being taken without any constraints. There are several challenges that are faced by the Facial Recognitions System, as follows:
You can find the source code for a face recognition attendance system on platforms like GitHub. Here’s a basic guide on how to set it up.
Step-by-Step Instructions
Patelrahul4884
. You can search for “face recognition attendance system GitHub” to find it.pip install -r requirements.txt
TrainingImage
. This is where you will store the images of the people whose attendance you want to track.attendance.py
and automaticAttendance.py
in a text editor.attendance.py
file. This will let you register new students, take their pictures, and automatically mark their attendance.In this article, we discussed how to create a face recognition system using the face_recognition library and made an attendance system. The face recognition model can be trained using a dataset of labeled face images, and the model accuracy can be improved by using techniques such as face alignment and data augmentation. You can further design GUI using Tkinter or Pyqt for the face recognition attendance system.
Hope you like this article! You will gain an understanding of the face recognition attendance system using Python. We’ll explore the face recognition based attendance system project source code and its applications in creating an efficient facial recognition attendance system. This face recognition attendance system project showcases innovative technology for accurate attendance tracking.
Key Takeaways
A. Haar cascade algorithm is an open-source machine learning-based approach used for object detection in images, commonly used for face detection in Python. It works by training a classifier using positive and negative samples of the object of interest (in this case, faces) and then applying the classifier to new images to detect the object. The algorithm uses a series of features known as Haar features to distinguish between the object and the background. The algorithm is efficient and can detect faces in real-time video streams, making it a popular choice for face detection applications.
A. A generic classifier is useful for detecting a wide range of objects but may not be as accurate for detecting specific objects. A specific classifier, on the other hand, is more accurate for detecting its designated object but may not be useful for detecting other types of objects.
A. A Convolutional Neural Network (CNN) is a type of neural network commonly used for image classification and object recognition. In facial recognition, a CNN can be trained on large datasets of facial images to learn how to identify and recognize different faces.
Python excels at face recognition. It has powerful libraries like OpenCV, Dlib, and Face Recognition for tasks like detection, recognition, and analysis. Its clear syntax and large community make it a popular choice for building face recognition systems.
The media shown in this article is not owned by Analytics Vidhya and are used at the Author’s discretion