Home / Tools & Plugins / 15 Efficient Face Recognition Algorithms And Techniques

15 Efficient Face Recognition Algorithms And Techniques

[Estimated read time: 7 minutes]

Identifying human faces in digital images has variety of applications, from biometrics and healthcare to video surveillance and security. In psychological terms, face identification is a process through which humans locate and attend to faces in a visual scene.

One can consider face detection as a specific case of object class detection. A reliable methodology is based on the eigen-face technique and the genetic algorithm.

Rather than just simply telling you about the basic techniques, we would like to introduce some efficient face recognition algorithms (open source) from latest researches and projects.

15. FaceMatch

This is a wrapper for the Facebook face recognition feature. It’s quite basic at the moment and requires improvements.

The program calls /photos/tagging/recognition endpoint when you upload a photo on Facebook. It uses Facebook API to uploaded a private photo, and calls the endpoint by simulating browser using uploader’s information.

14. Face Everthing

This is face detection, alignment, recognition, reconstruction based on numerous projects on Github. The author’s goal is to develop a state-of-the-art face system, but currently reconstruction is not available and code in not perfect.

13. Fisherfaces

The Eigenfaces obtained via script

Fisherfaces implements a face recognition framework for Python with preprocessing, feature extraction, classifier and cross validation. Basically, it lets you measure, save and load models for face recognition in videos (such as webcam feeds). You can also optionally validate your model to see the performance you can expect. It optionally performs a k-Fold Cross Validation to estimate the precision of the model.

However, the script does not work perfectly on not preprocessed input pictures. In order to generate more robust recognition, your input must be aligned in the exact same manner as specified in the training set.

12. Real Time Face Recognition

A real time face recognition algorithm based on TensorFlow, OpenCV, MTCNN and Facenet. Face reading depends on OpenCV2, embedding faces is based on Facenet, detection has done with the help of MTCNN, and recognition with classifier. The main idea was inspired by OpenFace. However, the author has preferred Python for writing code.

11. Android Face Recognition with Deep Learning

This is an Android library packed with numerous face recognition techniques. Its code has been derived from TensorFlow, FaceNet, LIBSVM and Caffe.

You can either train and classify by passing pictures to the library or if features are already obtained from the picture, the feature vector can be passed together with a special flag set to “true”.

10. DeepID Test

Using the webface data set (of plum team) and the DeepID network (of Tang Xiaoao team), the model parameters were trained by Caffe, and the accuracy of face detection was carried out by LFW classification.

The principle of face recognition involves extracting 6,000 pairs of images, of which 50% are same images and the rest 50% are different images, from labeled faces in the wild home. The next step is to train corresponding 2 images as a good model input, and get 2 160-bit dimensional feature vector. Finally, obtain 6,000 cosine distance or Euclidean distance, and generate higher face accuracy by selecting threshold.

9. Node FaceNet

This is TensorFlow backed FaceNet implementation for Node.js, for solving face verification, recognition and clustering problems. The script directly learns mapping from pictures to compact Euclidean space where distances correspond to a measure of facial similarity.

It optimizes the face recognition performance using only 128-bytes per face, and reaches the accuracy of 99.63% on LFW (labeled faces in the wild) dataset.

8. SphereFace

This is an implementation of SphereFace – deep hypersphere embedding for face recognition. The repository consists of entire pipeline (all preprocessings) for deep face recognition with SphereFace. The recognition pipeline contains 3 crucial steps – face detection, alignment and recognition.

This technique proposes the A-Softmax (angular softmax) loss that allows CNNs (convolution neural networks) to learn angularity discriminative features. Geometrically, angular softmax loss could be seen as imposing discriminative constraints on a hypersphere manifold, which intrinsically matches the prior that images also lie on a manifold.

It achieves state-of-the-art verification performance in MegaFace challenge under small training set protocol.

7. Deep Face Recognition with Caffe Implementation

The algorithm is developed for deep face recognition – related to discriminative feature learning approach for deep face recognition.

This model is based on a new supervision signal, known as center loss for face recognition task. The center loss learns a center for deep features of each class, and penalizes the distances between deep features and their corresponding class centers, at the same time.

The proposed center loss function is easy to optimize in convolutional neural networks. Under the supervision of both softmax loss and center loss, convolutional neural networks can be trained to obtain deep features with two key learning goals – intra-class compactness and inter-class dispersion as much as possible, which are very crucial for facial recognition.

6. FaceRecognition in ARKit

This script can detect faces using Vision API and run extracted face through a CoreML model to identify persons. To run this script, you will require Xcode 9, iPhone 6s (or newer) and a machine-learning model.

Authors have trained the model in AWS using Nvidia DIGITS, took hundreds of images of each person, and extracted the faces. There is a separate “unknown” category with different faces. A pre-trained, fine-tuned model has been used for face recognition.

5. Facial Recognition API for Python and Command Line

The model is using Dlib’s state of the art face identification developed with deep learning. It has 99.38% accuracy on the labeled faces in the Wild benchmark. A simple face_recognition command line tool allows you to perform face recognition on an image folder. Moreover, this library could be used with other Python libraries to perform realtime face recognition.

4. Face recognition using Tensorflow

This is a face identifier implementation using TensorFlow, as described in the paper FaceNet. It also uses the phenomena of a discriminative feature learning method for deep face recognition.

The source code is inspired by OpenFace implementation. Two data sets CASIA-WebFace and MS-Celeb-1M has been used for training, which yield LFW accuracy of 0.987 and 0.992 respectively.

3. Joint Face Detection and Alignment

Detecting and aligning in unconstrained environment are quite difficult due to different illuminations, poses and occlusions. However, we can achieve great results with the help of deep learning techniques.

This project uses deep cascaded multi-task framework that exploits the inherent correlation between detection and alignment to increase the performance. It utilizes the cascaded architecture with three stages of deep convolutional networks to predict face and landmark location.

Read: Best Artificial Intelligence Programming Language

Also, the authors have introduced a mining approach that further improves the performance in practice. This technique achieves superior accuracy over the state-of-the-art methodologies on challenging WIDER FACE benchmarks for face detection, and AFLW benchmark for face alignment.

2. OpenBR

This is a communal biometric framework that supports development of open (as well as closed) algorithms and reproducible evaluations. You can use this to improve existing algorithms, explore new modalities, measure recognition performance and deploy automated biometric systems.

The framework includes the algorithms for training, face recognition, gender estimation and age estimation. It’s supported on all major platforms, including Mac OSX, Windows and Linux.

1. OpenFace

OpenFace is a Torch and Python implementation of face identification with deep neural networks, and is based on FaceNet. Torch enables the network to execute on a CPU or with CUDA.

Read: 21 Artificial Intelligence Tools To Make Your Project More Effective

The workflow of a single input is as follow –

  • Detect faces using pre-trained models from OpenCV or Dlib
  • Transform the face for the neural network.
  • Use deep neural network to represent the face on 128-bit dimensional unit hypersphere.
  • Apply clustering or classification method to the complete identification task.

One comment

  1. One of the best articles about algorithms of face recognition. Keep it up.

Leave a Reply

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

*