![Face Detection Project in Python [In 5 Easy Steps]](/__khugblog-next/image/?url=https%3A%2F%2Fd14b9ctw0m6fid.cloudfront.net%2Fugblog%2Fwp-content%2Fuploads%2F2020%2F09%2F931.png&w=1920&q=75)
Object identification and face detection are probably the most popular applications of computer vision. This technology finds applications in various industries, such as security and social media. So we’re building a face detection project through Python.
Note that you should be familiar with programming in Python, OpenCV, and NumPy. It will ensure that you don’t get confused while working on this project. Let’s get started.
We’ve shared two methods to perform face recognition. The first uses Python’s face recognition library, while the other one uses OpenCV and NumPy. Check out our data science programs to learn more.
Learn Machine Learning Courses from the World’s top Universities. Earn Masters, Executive PGP, or Advanced Certificate Programs to fast-track your career.
Face Recognition with Python’s ‘Face Recognition’
Probably the easiest method to detect faces is to use the face recognition library in Python. It had 99.38% accuracy in the LFW database. Using it is quite simple and doesn’t require much effort. Moreover, the library has a dedicated ‘face_recognition’ command for identifying faces in images.
How to Use Face Recognition
You can distinguish faces in images by using the ‘face_locations’ command:
import face_recognition
image = face_recognition.load_image_file(“your_file.jpg”)
face_locations = face_recognition.face_locations(image)
It can also recognize faces and associate them with their names:
import face_recognition
known_image = face_recognition.load_image_file(“modi.jpg”)
unknown_image = face_recognition.load_image_file(“unknown.jpg”)
modi_encoding = face_recognition.face_encodings(known_image)[0]
unknown_encoding = face_recognition.face_encodings(unknown_image)[0]
results = face_recognition.compare_faces([modi_encoding], unknown_encoding)
Picture Contains “Narendra Modi”
There are many other things you can perform with this library by combining it with others. We’ll now discuss performing face recognition with other prominent libraries in Python, particularly OpenCV and NumPy.
Read more: Python NumPy Tutorial: Learn Python Numpy With Examples
Face Detection Project in Python
In this project, we’ve performed face detection and recognition by using OpenCV and NumPy. We’ve used Raspberry Pi, but you can also use it with other systems. You’ll only have to modify the code slightly to use it on some other device (such as a Mac or a Windows PC).
Some credit for this project goes to Marcelo Rovai.
Step #1: Install Libraries
First, you should install the required libraries, OpenCV, and NumPy. You can install it easily through:
pip install opencv-python
pip install opencv-contrib-python
For installing NumPy in your system, use the same command as above and replace ‘opencv-python’ with ‘numpy’:
pip install numpy
Step #2: Detect Faces
Now, you must configure your camera and connect it to your system. The camera should work properly to avoid any issues in face detection.
Before our camera recognizes us, it first has to detect faces. We’ll use the Haar Cascade classifier for face detection. It is primarily an object detection method where you train a cascade function through negative and positive images, after which it becomes able to detect objects in other photos.
In our case, we want our model to detect faces. OpenCV comes with a trainer and a detector, so using the Haar Cascade classifier is relatively more comfortable with this library. You can create your classifier to detect other images as well.
Here’s the code:
import numpy as np
import cv2
faceCascade = cv2.CascadeClassifier(‘Cascades/haarcascade_frontalface_default.xml’)
cap = cv2.VideoCapture(0)
cap.set(3,640) # set Width
cap.set(4,480) # set Height
while True:
ret, img = cap.read()
img = cv2.flip(img, -1)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
faces = faceCascade.detectMultiScale(
gray,
scaleFactor=1.2,
minNeighbors=5,
minSize=(20, 20)
)
for (x,y,w,h) in faces:
cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)
roi_gray = gray[y:y+h, x:x+w]
roi_color = img[y:y+h, x:x+w]
cv2.imshow(‘video’,img)
k = cv2.waitKey(30) & 0xff
if k == 27: # press ‘ESC’ to quit
break
cap.release()
cv2.destroyAllWindows()
FYI: Free nlp course!
Also, Check out all Trending Python Tutorial Concepts in 2024.
Step #3: Gather Data
Now that your model can identify faces, you can train it so it would start recognizing whose face is in the picture. To do that, you must provide it with multiple photos of the faces you want it to remember.
That’s why we’ll start with creating our dataset by gathering photos. After collecting the necessary images, add IDs for every person, so the model knows what face to associate with what ID. Start with the images of one person and add at least 10-20. Use different expressions to get the most effective results.
Create a script for adding user IDs to images, so you don’t have to do it manually every time. The script is vital in case you want to use your model for multiple faces.
Learn: TensorFlow Object Detection Tutorial For Beginners
In-demand Machine Learning Skills
Step #4: Train
After creating the dataset of the person’s images, you’d have to train the model. You’d feed the pictures to your OpenCV recognizer, and it will create a file named ‘trainer.yml’ in the end.
In this stage, you only have to provide the model with images and their IDs so the model can get familiar with the ID of every image. After we finish training the model, we can test it.
Here’s the code:
import cv2
import numpy as np
from PIL import Image
import os
# Path for face image database
path = ‘dataset’
recognizer = cv2.face.LBPHFaceRecognizer_create()
detector = cv2.CascadeClassifier(“haarcascade_frontalface_default.xml”);
# function to get the images and label data
def getImagesAndLabels(path):
imagePaths = [os.path.join(path,f) for f in os.listdir(path)]
faceSamples=[]
ids = []
for imagePath in imagePaths:
PIL_img = Image.open(imagePath).convert(‘L’) # grayscale
img_numpy = np.array(PIL_img,’uint8′)
id = int(os.path.split(imagePath)[-1].split(“.”)[1])
faces = detector.detectMultiScale(img_numpy)
for (x,y,w,h) in faces:
faceSamples.append(img_numpy[y:y+h,x:x+w])
ids.append(id)
return faceSamples,ids
print (“\n [INFO] Training faces. It will take a few seconds. Wait …”)
faces,ids = getImagesAndLabels(path)
recognizer.train(faces, np.array(ids))
# Save the model into trainer/trainer.yml
recognizer.write(‘trainer/trainer.yml’)
# Print the number of faces trained and end program
print(“\n [INFO] {0} faces trained. Exiting Program”.format(len(np.unique(ids))))
Learn: MATLAB Application in Face Recognition: Code, Description & Syntax
Step#5: Start Recognition
Now that you have trained the model, we can start testing the model. In this section, we have added names to the IDs so the model can display the names of the respective users it recognizes.
The model doesn’t recognize a person. It predicts whether the face it detects matches to the face present in its database. Our model displays a percentage of how much the face matches the face present in its database. Its accuracy will depend heavily on the image you’re testing and the pictures you’ve added to your database (the images you trained the model with).
Here’s the code:
import cv2
import numpy as np
import os
recognizer = cv2.face.LBPHFaceRecognizer_create()
recognizer.read(‘trainer/trainer.yml’)
cascadePath = “haarcascade_frontalface_default.xml”
faceCascade = cv2.CascadeClassifier(cascadePath);
font = cv2.FONT_HERSHEY_SIMPLEX
#initiate id counter
id = 0
# names related to ids: example ==> upGrad: id=1, etc
names = [‘None’, upGrad’, Me’, ‘Friend’, ‘Y’, ‘X’]
# Initialize and start realtime video capture
cam = cv2.VideoCapture(0)
cam.set(3, 640) # set video width
cam.set(4, 480) # set video height
# Define min window size to be recognized as a face
minW = 0.1*cam.get(3)
minH = 0.1*cam.get(4)
while True:
ret, img =cam.read()
img = cv2.flip(img, -1) # Flip vertically
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
faces = faceCascade.detectMultiScale(
gray,
scaleFactor = 1.2,
minNeighbors = 5,
minSize = (int(minW), int(minH)),
)
for(x,y,w,h) in faces:
cv2.rectangle(img, (x,y), (x+w,y+h), (0,255,0), 2)
id, confidence = recognizer.predict(gray[y:y+h,x:x+w])
# If confidence is less than 100 ==> “0” : perfect match
if (confidence < 100):
id = names[id]
confidence = ” {0}%”.format(round(100 – confidence))
else:
id = “unknown”
confidence = ” {0}%”.format(round(100 – confidence))
cv2.putText(
img,
str(id),
(x+5,y-5),
font,
1,
(255,255,255),
2
)
cv2.putText(
img,
str(confidence),
(x+5,y+h-5),
font,
1,
(255,255,0),
1
)
cv2.imshow(‘camera’,img)
k = cv2.waitKey(10) & 0xff # Press ‘ESC’ for exiting video
if k == 27:
break
# Do a cleanup
print(“\n [INFO] Exiting Program and doing cleanup”)
cam.release()
cv2.destroyAllWindows()
We have reached the end of our face detection project in Python. You now know how to create a machine learning model that detects and recognizes faces. Make sure to share your results with us!
Popular AI and ML Blogs & Free Courses
Learn More About Machine Learning
We hope you liked this face detection project. If you want to make it more challenging, you can add multiple faces in your dataset and train your model accordingly. You can also combine it with other libraries and extend the project into something else, such as a face detection security system for a program!
If you’re interested to learn more about machine learning, check out IIIT-B & upGrad’s Executive PG Programme in Machine Learning & AI which is designed for working professionals and offers 450+ hours of rigorous training, 30+ case studies & assignments, IIIT-B Alumni status, 5+ practical hands-on capstone projects & job assistance with top firms.
![Artificial Intelligence Salary in India [For Beginners & Experienced] in 2024](/__khugblog-next/image/?url=https%3A%2F%2Fd14b9ctw0m6fid.cloudfront.net%2Fugblog%2Fwp-content%2Fuploads%2F2019%2F11%2F06-banner.png&w=3840&q=75)
![24 Exciting IoT Project Ideas & Topics For Beginners 2024 [Latest]](/__khugblog-next/image/?url=https%3A%2F%2Fd14b9ctw0m6fid.cloudfront.net%2Fugblog%2Fwp-content%2Fuploads%2F2020%2F04%2F280.png&w=3840&q=75)
![Natural Language Processing (NLP) Projects & Topics For Beginners [2023]](/__khugblog-next/image/?url=https%3A%2F%2Fd14b9ctw0m6fid.cloudfront.net%2Fugblog%2Fwp-content%2Fuploads%2F2020%2F05%2F513.png&w=3840&q=75)
![45+ Interesting Machine Learning Project Ideas For Beginners [2024]](/__khugblog-next/image/?url=https%3A%2F%2Fd14b9ctw0m6fid.cloudfront.net%2Fugblog%2Fwp-content%2Fuploads%2F2019%2F07%2FBlog_FI_Machine_Learning_Project_Ideas.png&w=3840&q=75)
