DeepFace

DeepFace is a hybrid face recognition framework that wraps several state-of-the-art models, including:

• VGG-Face
• FaceNet
• OpenFace
• DeepFace
• DeepID
• ArcFace
• Dlib
• SFace
• GhostFaceNet
• Buffalo_L

It provides high-level functions for:

1. Face Recognition: Verifying identities or finding faces in a database.
2. Facial Attribute Analysis: Predicting age, gender, emotion, and race.

The framework automates the standard face recognition pipeline (detect, align, normalize, represent, and verify) so you can perform complex tasks with single-line function calls.

DeepFace's accuracy is significantly influenced by the combination of four main configuration parameters. When choosing a configuration for your application, consider how these interact:

• Facial Recognition Model: The core model used for feature extraction (e.g., Facenet512, VGG-Face, ArcFace, Dlib, SFace).
• Face Detector Model: The model used to locate faces in an image (e.g., retinaface, mtcnn, yolov8, mediapipe, opencv).
• Distance Metric: The mathematical method used to compare face embeddings (e.g., euclidean, euclidean_l2, cosine).
• Alignment Mode: Whether or not to perform facial alignment (True/False).

DeepFace wraps several external face recognition models, face detectors, and anti-spoofing tools. Because DeepFace inherits the licenses of these underlying models, you must check the specific license for each model you intend to use for production purposes.

Face Recognition Models wrapped by DeepFace:

• VGG-Face
• Facenet (128d and 512d)
• OpenFace
• DeepFace
• DeepID
• ArcFace
• Dlib
• SFace
• GhostFaceNet
• Buffalo_L

Face Detectors wrapped by DeepFace:

• OpenCv
• Ssd
• Dlib
• MtCnn
• Fast MtCnn
• RetinaFace
• MediaPipe
• YuNet
• Yolo
• CenterFace

Other features:

• Age, gender, and race/ethnicity models (trained on VGG-Face backbone).
• Face anti-spoofing (optional).

You can install DeepFace using pip to automatically handle the library and its prerequisites. Alternatively, you can install from source to access new features not yet published on PyPI.

Using pip:

$ pip install deepface

From source:

$ git clone https://github.com/serengil/deepface.git
$ cd deepface
$ pip install -e .

Once installed, import the main class:

from deepface import DeepFace

You can reproduce the benchmark experiments conducted on the LFW dataset by executing the following Jupyter notebooks in the repository:

1. Perform-Experiments.ipynb: Used to run the actual experiments.
2. Evaluate-Results.ipynb: Used to evaluate the outcomes of the experiments.

You can run DeepFace as a standalone service using Gunicorn. This allows external systems (mobile apps, web apps) to call the functionality via HTTP.

Start the service:

# Running the service directly
cd scripts && ./service.sh

# Running the service via docker
cd scripts && ./dockerize.sh

Example API calls using curl:

• Represent: POST /represent
• Verify: POST /verify
• Analyze: POST /analyze
• Register: POST /register
• Search: POST /search

Example curl command for verification:

$ curl -X POST http://localhost:5005/verify \
   -d '{"img1":"img1.jpg", "img2":"img3.jpg"}'

You can install DeepFace using pip. It is a lightweight framework for face recognition and facial attribute analysis in Python.

pip install deepface

The benchmark logic allows you to quantify how much performance changes based on two factors:

1. Alignment Impact: Calculated by subtracting the performance of unaligned images from aligned images (df_aligned - df_unaligned).
2. Detection Impact: Calculated by comparing the performance of specific detectors against the performance when detection is skipped (ref_df where index is skip).

These metrics help identify which detectors or alignment steps are most critical for specific models and distance metrics.

If you encounter issues with CUDA or want to force CPU execution during experiments, you can set the CUDA_VISIBLE_DEVICES environment variable to -1 before importing dependencies.

import os
os.environ['CUDA_VISIBLE_DEVICES'] = '-1'

This notebook provides methods to evaluate DeepFace performance across different models, detectors, distance metrics, and alignment settings. It uses pre-generated CSV files located in results/ and outputs/test/ to visualize accuracy, alignment impact, and detection impact.

Key components for evaluation include:

• Models: Facenet512, Facenet, VGG-Face, ArcFace, Dlib, GhostFaceNet, SFace, OpenFace, DeepFace, DeepID.
• Detectors: retinaface, mtcnn, fastmtcnn, dlib, yolov8, yunet, centerface, mediapipe, ssd, opencv, skip.
• Distance Metrics: euclidean, euclidean_l2, cosine.
• Alignment: True or False.

To perform large-scale experiments (e.g., on the LFW dataset), you can iterate through different combinations of model_name, detector_backend, distance_metric, and align.

When running batch experiments, it is recommended to set enforce_detection=False in DeepFace.verify() to prevent the execution from crashing if a face is not detected in one of the images. You can also use expand_percentage to adjust the detection area.

from deepface import DeepFace

result = DeepFace.verify(
    img1_path="path_to_image1.jpg",
    img2_path="path_to_image2.jpg",
    model_name="Facenet",
    detector_backend="retinaface",
    distance_metric="euclidean_l2",
    align=True,
    enforce_detection=False,
    expand_percentage=0
)

distance = result["distance"]