Python OpenCV Face Detection and Recognition Tutorial

By /

Okay, here’s a comprehensive article on Python OpenCV Face Detection and Recognition, aiming for approximately 5000 words. I’ll cover the concepts, code, explanations, and various advanced techniques.

Python OpenCV Face Detection and Recognition: A Comprehensive Tutorial

This tutorial provides a deep dive into face detection and recognition using Python and the OpenCV library (cv2). We’ll cover everything from the fundamental concepts to practical implementation, including various techniques, optimization strategies, and considerations for real-world applications.

Table of Contents

  1. Introduction

    • What is Face Detection and Recognition?
    • Why OpenCV?
    • Applications
    • Prerequisites

  2. Setting Up Your Environment

    • Installing Python
    • Installing OpenCV
    • Installing Other Necessary Libraries (NumPy, Matplotlib)
    • Verifying Installation

  3. Fundamentals of Face Detection

    • Haar Cascades
      • Features
      • Integral Image
      • AdaBoost
      • Cascading Classifiers
      • Advantages and Disadvantages
    • Loading Haar Cascade Classifiers in OpenCV
    • Basic Face Detection from an Image
    • Face Detection from a Video Stream (Webcam)
    • Improving Detection Accuracy (Parameter Tuning)
      • scaleFactor
      • minNeighbors
      • minSize
      • maxSize
    • Detecting Multiple Faces

  4. Advanced Face Detection Techniques

    • HOG (Histogram of Oriented Gradients) + Linear SVM
      • How HOG Works
      • Advantages and Disadvantages
      • Implementation in OpenCV (using dlib)
    • Deep Learning-Based Face Detectors
      • Single Shot MultiBox Detector (SSD)
      • Multi-task Cascaded Convolutional Networks (MTCNN)
      • Advantages and Disadvantages
      • Implementation using pre-trained models (OpenCV DNN module)

  5. Face Recognition: The Basics

    • Understanding Face Recognition vs. Detection
    • The Face Recognition Pipeline
      • Face Detection
      • Face Alignment (Preprocessing)
      • Feature Extraction
      • Feature Matching (Classification)
    • Common Face Recognition Algorithms
      • Eigenfaces
      • Fisherfaces
      • Local Binary Patterns Histograms (LBPH)

  6. Building a Face Recognition System with LBPH

    • Preparing the Dataset
      • Collecting Images
      • Organizing the Dataset (Directory Structure)
      • Data Augmentation (Optional but Recommended)
    • Training the LBPH Recognizer
      • Loading Images and Labels
      • Creating and Training the Recognizer
    • Face Recognition in Action
      • Detecting Faces
      • Predicting Identity
      • Displaying Results
    • Evaluating Performance (Accuracy, Precision, Recall)

  7. Face Recognition with Deep Learning (FaceNet)

    • Introduction to FaceNet
    • Triplet Loss
    • Implementing face recognition with a pre-trained FaceNet model.
    • Comparing Performance with LBPH

  8. Real-World Considerations and Optimization

    • Lighting Conditions
    • Occlusions (Glasses, Masks, etc.)
    • Pose Variations
    • Image Quality
    • Computational Cost (Speed and Memory)
    • Strategies for Optimization
      • Resizing Images
      • Using a Region of Interest (ROI)
      • Choosing the Right Algorithm
      • Hardware Acceleration (GPU)

  9. Building a Complete Application (Example)

    • Creating a GUI (Optional – using Tkinter)
    • Integrating Face Detection and Recognition
    • Adding Features (e.g., Adding New Faces, Deleting Faces)
    • Database Integration (Optional – using SQLite)

  10. Conclusion and Future Directions

    • Recap of Key Concepts
    • Emerging Trends in Face Recognition
    • Ethical Considerations

1. Introduction

What is Face Detection and Recognition?

  • Face Detection: The process of identifying the presence and location of human faces within an image or video frame. It answers the question: “Is there a face, and if so, where is it?” The output is typically a bounding box around each detected face.

  • Face Recognition: The process of identifying who a particular face belongs to. It goes beyond detection and answers the question: “Whose face is this?” It involves comparing the detected face to a database of known faces.

Why OpenCV?

OpenCV (Open Source Computer Vision Library) is a powerful, open-source library widely used for computer vision tasks. It provides:

  • Efficiency: Optimized C++ code for fast processing.
  • Cross-Platform: Works on Windows, macOS, Linux, Android, and iOS.
  • Rich Functionality: Includes a wide range of algorithms for image and video processing, including face detection and recognition.
  • Python Bindings: Easy-to-use Python API (cv2).
  • Large Community: Extensive documentation, tutorials, and community support.

Applications

Face detection and recognition have numerous applications, including:

  • Security and Surveillance: Access control, identifying suspects.
  • Biometric Authentication: Unlocking devices, verifying identity.
  • Social Media: Tagging friends in photos, auto-generating captions.
  • Human-Computer Interaction: Emotion recognition, gaze tracking.
  • Robotics: Enabling robots to interact with humans.
  • Healthcare: Patient identification, monitoring facial expressions.
  • Retail: Customer analytics, targeted advertising.

Prerequisites

  • Basic understanding of Python programming.
  • Familiarity with image processing concepts (pixels, channels, etc.) is helpful but not strictly required.

2. Setting Up Your Environment

Installing Python

  1. Download: Go to the official Python website (https://www.python.org/downloads/) and download the latest version of Python for your operating system.
  2. Installation: Run the installer and follow the on-screen instructions. Make sure to check the box that says “Add Python to PATH” (or a similar option) during the installation process. This makes it easier to run Python from the command line.

Installing OpenCV

The easiest way to install OpenCV is using pip, Python’s package installer:

bash
pip install opencv-python
For contrib modules (which include some face recognition algorithms like LBPH), install:
bash
pip install opencv-contrib-python

Installing Other Necessary Libraries

  • NumPy: For numerical operations.
    bash
    pip install numpy

  • Matplotlib: For visualizing images (optional, but helpful).
    bash
    pip install matplotlib

  • dlib: For advanced face detection and alignment
    bash
    pip install dlib
  • face_recognition: A higher level library built on top of dlib for face recognition.
    bash
    pip install face_recognition

Verifying Installation

Open a Python interpreter or a new Python script and try importing the libraries:

“`python
import cv2
import numpy as np
import matplotlib.pyplot as plt
import dlib
import face_recognition

print(cv2.version)
print(dlib.version)
“`

If no errors occur and the version numbers are printed, your installation is successful.

3. Fundamentals of Face Detection

Haar Cascades

Haar Cascades are a classic and efficient object detection method, particularly effective for faces. They are based on the concept of Haar-like features.

  • Features: Haar-like features are simple rectangular patterns that capture differences in intensity between adjacent regions of an image. They look for edges, lines, and other basic shapes. Examples include:

    • Edge features (dark rectangle next to a light rectangle).
    • Line features (light rectangle between two dark rectangles).
    • Four-rectangle features.

  • Integral Image: To quickly calculate the sum of pixel intensities within a rectangle, the concept of an “integral image” is used. The integral image at a point (x, y) is the sum of all pixels above and to the left of (x, y). This allows for the calculation of the sum of any rectangular region using only four array lookups, regardless of the rectangle’s size. This dramatically speeds up feature computation.

  • AdaBoost: AdaBoost (Adaptive Boosting) is a machine learning algorithm used to select the most relevant Haar-like features and combine them into a strong classifier. It works by:

    1. Assigning equal weights to all training examples (images).
    2. Iteratively training “weak classifiers” (each based on a single Haar-like feature).
    3. Increasing the weights of misclassified examples.
    4. Combining the weak classifiers into a weighted sum, where the weights are determined by their accuracy. This creates a “strong classifier.”

  • Cascading Classifiers: To further improve speed and efficiency, Haar Cascades use a “cascade” of classifiers. This is a series of increasingly complex classifiers.

    1. Early stages of the cascade use simple, fast classifiers to quickly reject non-face regions.
    2. Later stages use more complex classifiers, but only on regions that have passed the earlier stages.
    3. If a region fails at any stage, it is immediately rejected. This “cascade” structure significantly reduces the computational cost, as most regions are rejected early on.

  • Advantages:

    • Fast and efficient, especially for real-time applications.
    • Relatively simple to implement.
    • Pre-trained classifiers are readily available.

  • Disadvantages:

    • Can be sensitive to lighting variations, pose, and occlusions.
    • May produce false positives (detecting non-faces as faces).
    • Requires a large amount of training data.

Loading Haar Cascade Classifiers in OpenCV

OpenCV provides pre-trained Haar Cascade classifiers for various objects, including faces. These are stored in XML files. The most common one for face detection is haarcascade_frontalface_default.xml. You can usually find these files in the data/haarcascades/ directory within your OpenCV installation.

“`python
import cv2

Load the Haar Cascade classifier

face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + ‘haarcascade_frontalface_default.xml’)

Check if the classifier was loaded successfully

if face_cascade.empty():
print(“Error: Could not load Haar Cascade classifier.”)
exit()
“`

Basic Face Detection from an Image

“`python
import cv2

Load the Haar Cascade classifier

face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + ‘haarcascade_frontalface_default.xml’)

Load the image

img = cv2.imread(‘image.jpg’) # Replace ‘image.jpg’ with your image path

Convert the image to grayscale (Haar Cascades work on grayscale images)

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

Detect faces

faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))

Draw rectangles around the detected faces

for (x, y, w, h) in faces:
cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), 2) # (0, 255, 0) is green, 2 is the thickness

Display the image with detected faces

cv2.imshow(‘Face Detection’, img)
cv2.waitKey(0) # Wait for a key press
cv2.destroyAllWindows()
“`

Face Detection from a Video Stream (Webcam)

“`python
import cv2

Load the Haar Cascade classifier

face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + ‘haarcascade_frontalface_default.xml’)

Open the webcam (0 is usually the default webcam)

cap = cv2.VideoCapture(0)

if not cap.isOpened():
print(“Error: Could not open webcam.”)
exit()

while True:
# Read a frame from the webcam
ret, frame = cap.read()

if not ret:
    print("Error: Could not read frame.")
    break

# Convert the frame to grayscale
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

# Detect faces
faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))

# Draw rectangles around the detected faces
for (x, y, w, h) in faces:
    cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)

# Display the frame with detected faces
cv2.imshow('Face Detection', frame)

# Exit if the 'q' key is pressed
if cv2.waitKey(1) & 0xFF == ord('q'):
    break

Release the webcam and close windows

cap.release()
cv2.destroyAllWindows()

“`

Improving Detection Accuracy (Parameter Tuning)

The detectMultiScale function has several parameters that can be tuned to improve detection accuracy:

  • scaleFactor: Specifies how much the image size is reduced at each image scale. A smaller value (e.g., 1.05) is more computationally expensive but can detect smaller faces. A larger value (e.g., 1.3) is faster but may miss smaller faces. A good starting point is 1.1.

  • minNeighbors: Specifies how many neighbors each candidate rectangle should have to retain it. A higher value results in fewer detections but with higher quality. A lower value may result in more false positives. A good starting point is 3-6.

  • minSize: Minimum possible object size. Objects smaller than this are ignored. This helps to avoid detecting very small, irrelevant objects as faces. The size should be adjusted based on the expected size of faces in your images/video. (30, 30) is a reasonable starting point.

  • maxSize: Maximum possible object size. Objects larger than this are ignored. This can be used if you are only interested in detecting faces within a certain distance range.

Detecting Multiple Faces

The detectMultiScale function automatically detects multiple faces. The faces variable will contain a list of tuples, where each tuple represents a detected face: (x, y, w, h). x and y are the top-left coordinates of the bounding box, and w and h are the width and height. The code examples above already handle multiple faces.

4. Advanced Face Detection Techniques

While Haar Cascades are a good starting point, more advanced techniques offer improved accuracy and robustness.

HOG (Histogram of Oriented Gradients) + Linear SVM

  • How HOG Works:

    1. Gradient Computation: The image is divided into small cells, and the gradient magnitude and orientation are calculated for each pixel within each cell.
    2. Orientation Binning: A histogram of gradient orientations is created for each cell. Each pixel’s gradient contributes to the histogram bin corresponding to its orientation.
    3. Block Normalization: The cells are grouped into larger, overlapping blocks. The histograms within each block are normalized to reduce the effects of lighting variations.
    4. Feature Vector: The normalized histograms from all blocks are concatenated to form a feature vector representing the image.

  • Advantages:

    • More robust to lighting variations and small pose changes compared to Haar Cascades.
    • Good balance between accuracy and speed.

  • Disadvantages:

    • Can be computationally more expensive than Haar Cascades.
    • Still sensitive to significant pose variations and occlusions.

  • Implementation in OpenCV (using dlib):

“`python
import cv2
import dlib

Initialize dlib’s face detector (HOG-based)

detector = dlib.get_frontal_face_detector()

Load the image

img = cv2.imread(‘image.jpg’)

Convert the image to grayscale

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

Detect faces

faces = detector(gray) # Note: No need for detectMultiScale here

Draw rectangles around the detected faces

for face in faces:
x1 = face.left()
y1 = face.top()
x2 = face.right()
y2 = face.bottom()
cv2.rectangle(img, (x1, y1), (x2, y2), (0, 255, 0), 2)

Display the image

cv2.imshow(‘Face Detection (HOG)’, img)
cv2.waitKey(0)
cv2.destroyAllWindows()

“`

Deep Learning-Based Face Detectors

Deep learning has revolutionized face detection, leading to significantly more accurate and robust methods. Two popular approaches are:

  • Single Shot MultiBox Detector (SSD): A single neural network predicts bounding boxes and class probabilities (face/non-face) directly from feature maps at multiple scales. It’s known for its speed and accuracy.

  • Multi-task Cascaded Convolutional Networks (MTCNN): A cascade of three convolutional neural networks (P-Net, R-Net, O-Net) that progressively refine the bounding box predictions and also detect facial landmarks (eyes, nose, mouth). It’s highly accurate but can be slower than SSD.

  • Advantages:

    • State-of-the-art accuracy.
    • Highly robust to variations in lighting, pose, and occlusions.
    • Can detect faces at various scales and orientations.

  • Disadvantages:

    • Computationally more expensive than Haar Cascades and HOG.
    • Requires more memory.
    • May require a GPU for real-time performance.

  • Implementation using pre-trained models (OpenCV DNN module):

SSD Example (using OpenCV’s DNN module):

“`python
import cv2
import numpy as np

Load the pre-trained SSD model

net = cv2.dnn.readNetFromCaffe(‘deploy.prototxt’, ‘res10_300x300_ssd_iter_140000.caffemodel’) # Replace with your model paths

Load the image

img = cv2.imread(‘image.jpg’)
(h, w) = img.shape[:2]

Preprocess the image (blobFromImage handles resizing, mean subtraction, and scaling)

blob = cv2.dnn.blobFromImage(cv2.resize(img, (300, 300)), 1.0, (300, 300), (104.0, 177.0, 123.0))

Pass the blob through the network

net.setInput(blob)
detections = net.forward()

Loop over the detections

for i in range(0, detections.shape[2]):
confidence = detections[0, 0, i, 2]

# Filter out weak detections
if confidence > 0.5:  # Confidence threshold
    box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
    (startX, startY, endX, endY) = box.astype("int")

    # Draw the bounding box and confidence
    text = "{:.2f}%".format(confidence * 100)
    y = startY - 10 if startY - 10 > 10 else startY + 10
    cv2.rectangle(img, (startX, startY), (endX, endY), (0, 255, 0), 2)
    cv2.putText(img, text, (startX, y), cv2.FONT_HERSHEY_SIMPLEX, 0.45, (0, 255, 0), 2)

Display the image

cv2.imshow(‘Face Detection (SSD)’, img)
cv2.waitKey(0)
cv2.destroyAllWindows()
``
**Important Notes for SSD Example:**
* You need to download thedeploy.prototxtandres10_300x300_ssd_iter_140000.caffemodelfiles. These are the model definition and weights, respectively. Search online for "opencv ssd face detection model download".
* The(104.0, 177.0, 123.0)` values are the mean values for the ImageNet dataset, used for preprocessing.
* The confidence threshold (0.5 in this example) can be adjusted.

5. Face Recognition: The Basics

Understanding Face Recognition vs. Detection

  • Detection: Finding faces (where they are).
  • Recognition: Identifying faces (whose face it is).

The Face Recognition Pipeline

A typical face recognition system involves the following steps:

  1. Face Detection: Locate faces in the input image or video frame (using any of the methods discussed earlier).

  2. Face Alignment (Preprocessing): Transform the detected face to a standard format. This often involves:

    • Geometric Normalization: Rotating, scaling, and translating the face to a canonical position and size. This helps to reduce variations due to pose and distance. Facial landmark detection (using dlib or MTCNN) is crucial for accurate alignment.
    • Photometric Normalization: Adjusting the lighting and contrast of the face image to reduce the effects of illumination variations. Techniques include histogram equalization and contrast stretching.

  3. Feature Extraction: Extract a set of features (a “feature vector” or “embedding”) that represent the unique characteristics of the face. This is the most critical step in face recognition. The features should be:

    • Discriminative: Distinguish between different individuals.
    • Robust: Invariant to variations in lighting, pose, expression, and occlusions.

  4. Feature Matching (Classification): Compare the extracted feature vector to a database of known faces (also represented by feature vectors). The closest match (or matches) is identified. Common distance metrics include:

    • Euclidean Distance: Measures the straight-line distance between two feature vectors.
    • Cosine Similarity: Measures the angle between two feature vectors (more robust to magnitude differences).
      A threshold is usually set on the distance/similarity. If the distance is below the threshold (or similarity above), the face is considered a match; otherwise, it’s considered an “unknown” face.

Common Face Recognition Algorithms

  • Eigenfaces: One of the earliest and simplest face recognition algorithms. It uses Principal Component Analysis (PCA) to reduce the dimensionality of the face images and find the principal components (“eigenfaces”) that represent the most significant variations in the dataset. Faces are then represented as linear combinations of these eigenfaces.

    • Advantages: Simple and relatively fast.
    • Disadvantages: Sensitive to lighting, pose, and expression changes. Not very robust.

  • Fisherfaces: An improvement over Eigenfaces. It uses Linear Discriminant Analysis (LDA) to find the features that best separate different classes (individuals) while minimizing the variation within each class.

    • Advantages: More robust to lighting and expression variations than Eigenfaces.
    • Disadvantages: Still sensitive to pose changes. Assumes a linear relationship between features.

  • Local Binary Patterns Histograms (LBPH): A texture-based approach that is relatively robust to lighting variations.

    1. LBP Operator: For each pixel in the face image, the LBP operator compares the pixel’s intensity to its neighboring pixels. A binary code is generated based on whether the neighbors are brighter or darker than the central pixel.
    2. Histograms: The image is divided into regions, and a histogram of the LBP codes is computed for each region.
    3. Feature Vector: The histograms from all regions are concatenated to form a feature vector.
    4. Advantages: Simple, fast, and relatively robust to lighting variations.
    5. Disadvantages: Can be sensitive to pose and expression changes. Less accurate than deep learning-based methods.
    6. This is a great option for a first face recognition project due to its balance of simplicity and effectiveness.

6. Building a Face Recognition System with LBPH

Preparing the Dataset

  1. Collecting Images: Gather images of the individuals you want to recognize. Aim for:

    • Multiple images per person (at least 10-20 is recommended, more is better).
    • Variations in lighting, expression, and pose (but within reasonable limits).
    • Good image quality (clear, well-lit faces).

  2. Organizing the Dataset (Directory Structure): Create a directory structure like this:

    dataset/
    person1/
    image1.jpg
    image2.jpg
    ...
    person2/
    image1.jpg
    image2.jpg
    ...
    ...
    Each person’s images should be in a separate subdirectory, and the subdirectory name should be the person’s name (or a unique ID).

  3. Data Augmentation (Optional but Recommended): To improve the robustness of your recognizer, you can artificially increase the size of your dataset by applying transformations to the existing images. Common techniques include:

    • Rotation: Rotate the images by small angles.
    • Scaling: Slightly zoom in or out.
    • Translation: Shift the image horizontally or vertically.
    • Flipping: Create horizontally flipped versions.
    • Adding Noise: Add small amounts of random noise.
      OpenCV and libraries like imgaug can be used for data augmentation.

Training the LBPH Recognizer

“`python
import cv2
import os
import numpy as np

def train_lbph_recognizer(dataset_path):
“””Trains an LBPH face recognizer.”””

# Lists to store the face samples and their corresponding labels
faces = []
labels = []
label_map = {}  # Dictionary to map label names to integer IDs
label_id = 0

# Iterate through the dataset directories
for person_name in os.listdir(dataset_path):
    person_path = os.path.join(dataset_path, person_name)

    # Check if it's a directory
    if os.path.isdir(person_path):
        label_map[label_id] = person_name  # Store the person's name
        print(f"Processing: {person_name} (ID: {label_id})")

        # Iterate through the images in the person's directory
        for image_name in os.listdir(person_path):
            image_path = os.path.join(person_path, image_name)

            # Load the image and convert it to grayscale
            img = cv2.imread(image_path)
            if img is None:
                print(f"Warning: Could not read image: {image_path}")
                continue

            gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

            # Detect faces (using Haar Cascade for simplicity, could use a better detector)
            face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
            detected_faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5)

            #If no faces or more than one face is found, continue with the next image
            if len(detected_faces) != 1:
                print(f"Warning: Skipping image {image_path} due to {len(detected_faces)} faces detected.")
                continue
            # Extract the face region
            for (x, y, w, h) in detected_faces:
                face_roi = gray[y:y+h, x:x+w]
                faces.append(face_roi)
                labels.append(label_id)

        label_id += 1

# Create the LBPH face recognizer
recognizer = cv2.face.LBPHFaceRecognizer_create()

# Train the recognizer
print("Training LBPH recognizer...")
recognizer.train(faces, np.array(labels))
print("Training complete.")

return recognizer, label_map

Example usage:

dataset_path = ‘dataset’ # Replace with the path to your dataset directory
recognizer, label_map = train_lbph_recognizer(dataset_path)

Save the trained model and label map (optional, but recommended)

recognizer.save(‘lbph_model.yml’)

import pickle # Use pickle to save the label map
with open(‘label_map.pkl’, ‘wb’) as f:
pickle.dump(label_map, f)
“`

Face Recognition in Action

“`python
import cv2
import pickle
import numpy as np # Ensure numpy is imported

def recognize_faces(image_path, recognizer, label_map):
“””Recognizes faces in an image.”””

# Load the image and convert it to grayscale
img = cv2.imread(image_path)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Detect faces (using Haar Cascade)
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5)

# Iterate through the detected faces
for (x, y, w, h) in faces:
    # Extract the face region
    face_roi = gray[y:y+h, x:x+w]

    # Predict the label and confidence
    label_id, confidence = recognizer.predict(face_roi)

    # Get the person's name from the label map
    if label_id in label_map:
        person_name = label_map[label_id]
    else:
        person_name = "Unknown"


    # Display the results (draw rectangle, name, and confidence)
    cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), 2)
    text = f"{person_name} ({confidence:.2f})"  # Display name and confidence
    cv2.putText(img, text, (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)

# Display the image with results
cv2.imshow('Face Recognition', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

Load the trained model and label map

recognizer = cv2.face.LBPHFaceRecognizer_create()
recognizer.read(‘lbph_model.yml’)

with open(‘label_map.pkl’, ‘rb’) as f:
label_map = pickle.load(f)

Example Usage:

recognize_faces(‘test_image.jpg’, recognizer, label_map) # Replace with your test image path

“`

Evaluating Performance (Accuracy, Precision, Recall)

To evaluate the performance of your face recognition system, you need a separate test set (images not used for training). You can then calculate metrics like:

  • Accuracy: The overall percentage of correctly classified faces.
  • Precision: The percentage of correctly identified faces out of all faces identified as a particular person. (True Positives / (True Positives + False Positives))
  • Recall: The percentage of correctly identified faces out of all faces that should have been identified as a particular person. (True Positives / (True Positives + False Negatives))

A confusion matrix is also a valuable tool for visualizing the performance of a multi-class classifier (like a face recognizer). It shows the number of correct and incorrect predictions for each class.

Example evaluation (you’ll need to adapt this to your specific dataset and split):
“`python

Assuming you have lists of test images, true labels, and predicted labels:

test_images: A list of paths to your test images

true_labels: A list of the actual person IDs for those images

predicted_labels: A list of the person IDs predicted by your recognizer

from sklearn.metrics import accuracy_score, precision_score, recall_score, confusion_matrix

… (load your trained model and label map as before) …

— Example of creating test data and getting predictions (replace with your actual test data) —

test_images = [] # List of paths to test images
true_labels = [] # List of corresponding true labels (person IDs as integers)
test_dataset_path = ‘test_dataset’ # Example path

for person_name in os.listdir(test_dataset_path):
person_path = os.path.join(test_dataset_path, person_name)
if os.path.isdir(person_path):
for label_id, name in label_map.items():
if name == person_name:
true_label_id = label_id
break
else:
print(f”Warning: Could not find label ID for {person_name}”)
continue

    for image_name in os.listdir(person_path):
        image_path = os.path.join(person_path, image_name)
        test_images.append(image_path)
        true_labels.append(true_label_id)

predicted_labels = []
for image_path in test_images:
img = cv2.imread(image_path)
if img is None:
print(f”Warning: Could not read image {image_path}”)
predicted_labels.append(-1) # Append a dummy value
continue
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + ‘haarcascade_frontalface_default.xml’)
faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5)
if len(faces) != 1:
print(f”Warning: Skipping image {image_path} due to {len(faces)} faces”)
predicted_labels.append(-1) # Or some other placeholder value.
continue

x, y, w, h = faces[0] # Take the first detected face.
face_roi = gray[y:y + h, x:x + w]

label_id, _ = recognizer.predict(face_roi) # We don't need confidence here
predicted_labels.append(label_id)

— Calculate Metrics —

accuracy = accuracy_score(true_labels, predicted

Leave a Comment

Your email address will not be published. Required fields are marked *

Scroll to Top