#  Face.evoLVe: A High-Performance Face Recognition Library

Qingzhong Wang<EMAIL_ADDRESS>Baidu ResearchBeijingChina ,  Pengfei
Zhang<EMAIL_ADDRESS>National University of Defense
TechnologyChangshaChina ,  Haoyi Xiong<EMAIL_ADDRESS>Baidu
ResearchBeijingChina and  Jian Zhao<EMAIL_ADDRESS>Institute of North
Electronic EquipmentBeijingChina

###### Abstract.

While face recognition has drawn much attention, a large number of algorithms
and models have been proposed with applications to daily life, such as
authentication for mobile payments, etc. Recently, deep learning methods have
dominated in the field of face recognition with advantages in comparisons to
conventional approaches and even the human perception. Despite the popular
adoption of deep learning-based methods to the field, researchers and
engineers frequently need to reproduce existing algorithms with unified
implementations (_i.e., the identical deep learning framework with standard
implementations of operators and trainers_) and compare the performance of
face recognition methods under fair settings (_i.e., the same set of
evaluation metrics and preparation of datasets with tricks on/off_), so as to
ensure the reproducibility of experiments.

To the end, we develop face.evoLVe — a comprehensive library that collects and
implements a wide range of popular deep learning-based methods for face
recognition. First of all, face.evoLVe is composed of key components that
cover the full process of face analytics, including face alignment, data
processing, various backbones, losses, and alternatives with bags of tricks
for improving performance. Later, face.evoLVe supports multi-GPU training on
top of different deep learning platforms, such as PyTorch and PaddlePaddle,
which facilitates researchers to work on both large-scale datasets with
millions of images and and low-shot counterparts with limited well-annotated
data. More importantly, along with face.evoLVe, images before & after
alignment in the common benchmark datasets are released with source codes and
trained models provided. All these efforts lower the technical burdens in
reproducing the existing methods for comparison, while users of our library
could focus on developing advanced approaches more efficiently. Last but not
least, face.evoLVe is well designed and vibrantly evolving, so that new face
recognition approaches can be easily plugged into our framework. Note that we
have used face.evoLVe to participate in a number of face recognition
competitions and secured the first place. The version that supports PyTorch
(Paszke et al., 2019) is publicly available at
https://github.com/ZhaoJ9014/face.evoLVe.PyTorch and the PaddlePaddle (Ma et
al., 2019) version is available at
https://github.com/ZhaoJ9014/face.evoLVe.PyTorch/tree/master/paddle.
Face.evoLVe has been widely used for face analytics, receiving 2.4K stars and
622 forks.

Face Analytics, Toolbox, Library, PyTorch, PaddlePaddle

Figure 1. Face analytics from a scene of “The Big Bang Theory” TV series.

##  1\. Introduction

As a critical research problem in multimedia computing (Zhu et al., 2011),
face recognition has drawn much attention from both academia and industry with
intensive applications to daily life, e.g., authentications for mobile payment
(Du, 2018) and the friends tagging from photos/videos (e.g., Fig. 1). A face
recognition system normally takes an image or a video as input and identifies
faces in the image or video as outputs. Recently, deep learning-based
approaches have dominated in the field of face recognition, showing incredible
superiority to conventional face recognition methods, such as EigenFace (Gupta
et al., 2010; Rizon et al., 2006; Sahoolizadeh and Ghassabeh, 2008) and
subspace-based methods (Aishwarya and Marcus, 2010). Bless by its over-
parameterization nature, deep learning-based approaches enjoy unique
advantages including (1) more powerful feature extraction for face
representation, (2) an integrated representation and discriminative learning
process in an end-to-end manner, and (3) higher capacity of memorization and
generalization with large datasets (Zhang et al., 2021).

While deep face recognition approaches have been reported to outperform
human’s perception (Sun et al., 2014, 2015), they have been concerned with
issues of reproducibility, i.e., it might be difficult to achieve the same
performance when algorithms and models were re-implemented from the details
released in the papers. Although some researchers release codes, it is still
inconvenient to reproduce the experiments for fair comparisons as they often
have been “cooked with recipes”, e.g., tricks in architectures, losses, data
processing, training and evaluation. Hence, developing a comprehensive face
recognition library, with all alternating backbones, loss functions and bag of
tricks incorporated, is vital for both researchers and engineers. To this end,
we develop a relatively comprehensive deep face recognition library named
_face.evoLVe_ to meet the goals above. In this paper, we present the features
of the developed face.evoLVe library in details. In summary, our main
contributions could be categorized in three folders as follows:

  1. (1)

We develop a comprehensive library, namely face.evoLVe, for face-related
analytics and applications, including face alignment (e.g., detection,
landmark localization, affine transformation, etc.), data processing (e.g.,
augmentation, data balancing, normalization, etc.), where various backbones
(e.g., ResNet (He et al., 2016), IR, IR-SE (Hu et al., 2018), ResNeXt (Xie et
al., 2017), SE-ResNeXt, DenseNet (Huang et al., 2017), LightCNN (Wu et al.,
2018a), MobileNet (Howard et al., 2017), ShuffleNet (Zhang et al., 2018), DPN
(Chen et al., 2017a), etc.) with alternating losses (e.g., Softmax, Focal (Lin
et al., 2017), Center (Wen et al., 2016), SphereFace (Liu et al., 2017),
CosFace (Wang et al., 2018b), AmSoftmax (Wang et al., 2018a), ArcFace (Deng et
al., 2019), Triplet (Schroff et al., 2015), etc.) and bags of tricks (e.g.,
training refinements, model tweaks, knowledge distillation (Hinton et al.,
2015), etc.) for improving performance have been provided in standard
implementations.

  2. (2)

Face.evoLVe supports multiple popular deep learning platforms including both
PaddlePaddle (Ma et al., 2019) and PyTroch (Paszke et al., 2019). On top of
the native platform, i.e., PyTorch, face.evoLVe provides necessary facilities
to support parallel training with multi-GPUs, where users could enjoy the
computation power of massive GPUs using few lines of codes/configurations.
Note that the parallel training scheme in face.evoLVe not only supports the
training of backbones (Paszke et al., 2019), but also accelerates the training
of fully-connected (softmax) layers to fully scale-up the parallel training
based on multi-GPUs and large datasets over distributed storage.

  3. (3)

Face.evoLVe can help researchers/engineers develop high-performance deep face
recognition models and algorithms quickly for practical use and deployment.
Specifically, all data before and after alignment, source codes and trained
models are provided, which reduces the efforts required for reproducing the
existing methods, facilitates the development of new advanced approach, and
provides training and evaluation environments for fair comparisons. We have
used face.evoLVe to participate in a number of face recognition competitions
and secured the first place. In addition, the library is well designed and
evolving vibrantly with a group of active contributors. New face recognition
approaches can be easily plugged into the face.evoLVe framework.

##  2\. Related Work

###  2.1. A Brief Review of Face Recognition

Normally, a face recognition system consists of face detection, facial
landmark localization, face alignment, feature extraction and matching (Wang
and Deng, 2018; Jian, 2018). Each part of the face recognition system can be
an individual research area and recently, a wide range of approaches have been
proposed not only for the feature extraction module to obtain better
representations of faces but also for other modules, such as loss functions.
Deepface (Taigman et al., 2014) employs deep neural networks (DNNs), such as
Alexnet (Krizhevsky et al., 2012) to extract face features, which is much more
powerful than using Eigenface (Gupta et al., 2010; Rizon et al., 2006;
Sahoolizadeh and Ghassabeh, 2008). A marginalized CNN is proposed by Zhao et
al.(Zhao et al., 2017a) to achieve more robust face representations. In terms
of the loss function, Deepface (Taigman et al., 2014) adopts softmax, which is
widely used for classification (Krizhevsky et al., 2012; Simonyan and
Zisserman, 2014; He et al., 2016). In contrast, Sun et al.employ contrastive
loss (Sun et al., 2015). However, either softmax loss or contrastive loss is
not sufficient to learn discriminative features for face recognition. Also,
Alexnet cannot obtain satisfactory representations of faces, hence triplet
loss is applied in (Schroff et al., 2015; Liu et al., 2015; Parkhi et al.,
2015) to learn more discriminative features. GoogleNet (Szegedy et al., 2015)
and VGGNet (Simonyan and Zisserman, 2014) are then adopted to learn better
representations. The problem of using triplet loss is that the training
process is not stable. To mitigate this problem, Wen et al.(Wen et al., 2016)
propose a center loss function, which learns a center for each class and
penalizes the distances between the deep features and their corresponding
class centers. More recently, angular loss functions (Wang et al., 2018b; Deng
et al., 2019) and ResNet (He et al., 2016) dominate face recognition.
Researchers have realized that to accurately classify the queries, a face
recognition model should strictly separate faces in the feature space. A
number of approaches based on angular distance are proposed to achieve the
goal, such as Cosface (Wang et al., 2018b), Arcface (Deng et al., 2019),
Regularface (Zhao et al., 2019b), Adaptiveface (Liu et al., 2019b) and Adacos
(Zhang et al., 2019).

Another challenging direction is age-invariant face recognition (Zheng et al.,
2017; Park et al., 2010; Zhao et al., 2020), i.e., to learn representations of
faces that is robust to appearance changes caused by facial aging. However, it
is difficult to obtain sufficient well-annotated facial images with different
age ranges, Zhao et al.(Zhao et al., 2019a) propose an age-invariant model to
learn disentangled representations while synthesizing photorealistic cross-age
faces for age-invariant face recognition. Pose variants are also challenging
for robust face recognition in the wild. 3D vision techniques have been used
to estimate the pose and aid face recognition (Zhao et al., 2018) under such
settings.

In this paper, the developed face recognition library covers most state-of-
the-art loss functions and backbones to achieve discriminative yet generative
face representations for high-performance face recognition, which is also
flexible for users to design their own loss function and backbone.

###  2.2. Face Recognition Toolboxes

Library | # backbones | # heads | Platforms
---|---|---|---
InsightFace (Guo et al., 2019) | - | 4 | Pytorch (Paszke et al., 2019), MxNet (Chen et al., 2015)
FaceX-zoo (Wang et al., 2021) | 8 | 8 | Pytorch (Paszke et al., 2019)
Face.evoLVe | 13 | 16 | Pytorch (Paszke et al., 2019), PaddlePaddle (Ma et al., 2019)

Table 1. Comparison between face.evoLVe and other libraries. InsightFace (Guo
et al., 2019) is the official implementation of Arcface (Deng et al., 2019).

Many widely used face recognition approaches have released their source codes,
however, the platforms are different and the data processing method varies,
which is inconvenient for the community of face recognition, resulting in
unfair comparison. Therefore, using the same pipeline can be more convenient
and flexible for face recognition. Guo et al.(Guo et al., 2019) develop a
toolbox named InsightFace for 2D and 3D face analysis, which supports two
platforms: PyTorch (Paszke et al., 2019) and MxNet (Chen et al., 2015).
However, InsightFace only implements a few popular deep face recognition
models, such as Arcface (Deng et al., 2019) and Subcenter Arcface (Deng et
al., 2020). FaceX-Zoo (Wang et al., 2021) is a relatively comprehensive face
recognition library, however, it only supports PyTorch platform (Paszke et
al., 2019), which is inconvenient for the users that use other platforms, such
as Tensorflow (Abadi et al., 2016) and PaddlePaddle (Ma et al., 2019). By
contrast, the proposed face.evoLVe library is highly flexible and scalable,
which implements the complete face recognition pipeline, most face recognition
models and supports both PyTorch and PaddlePaddle platforms. In addition,
distributed training is well supported in face.evoLVe, which can be easily
applied to large-scale datasets composed of millions of images. Tab. 1
presents the comparison among different libraries, we can see that face.evoLVe
is more comprehensive and supports more platforms. Another feature of
face.evoLVe is that few-shot learning is supported.

##  3\. Face.evoLVe Library

Figure 2. An overview of the face.evoLVe pipeline. The input data can be
images or videos. Face.evoLVe first detects faces in images or videos and then
localizes the facial landmarks for alignment. The backbone network takes the
processed data as input and outputs the representations of faces. Finally, the
head blocks are used for compute the loss. Note that face.evoLVe supports
distributed training to accelerate the training process.

In this section, we present the developed face.evoLVe library.

###  3.1. Pipeline

To be convenient and flexible, face.evoLVe library is well designed. We split
the face recognition pipeline into four modules: face detection & alignment,
data processing, feature extraction and the loss head. Fig. 2 demonstrates the
pipeline of the developed face.evoLVe library. face.evoLVe first detects faces
in images and localize the facial landmarks for alignment, where MTCNN (Zhang
et al., 2016) is adopted. The aligned faces are fed into the backbone networks
to extract features, in face.evoLVe library, we implement a large number of
backbones. Finally, face representations are used to compute the loss in the
head block, where various loss function are implemented in the library. More
details can be found in the following sections.

###  3.2. Data Processing

Given a dataset composed of $N$ images of $m$ classes, to balance the
distribution of classes, face.evoLVe library first removes the low-shot
classes that occurs less than num_min times in the training dataset. It is
easy for users to define their own num_min for a specific dataset.

Apart from removing low-shot classes, face.evoLVe library also provides data
augmentation approaches, e.g., flip horizontally, scale
hue/satuation/brightness with coefficients uniformly drawn from $[0.6,1.4]$,
add PCA noise with a coefficient sampled from a normal distribution
$\mathcal{N}(0,0.1)$, etc.. Moreover, to alleviate the problem of long-tailed
distribution, we also implement weighted random sampling in face.evoLVe
library, which is user-friendly, i.e., users can also define a specific
sampler instead of using the original weighted sampling implementation during
training.

###  3.3. Implemented Models

One of the advantages of face.evoLVe library is that face.evoLVe contains many
existing deep face recognition models. Generally, a model can be separated
into two parts: (1) backbone – to extract face features and (2) loss function
– to train a model and learn better representations of faces. Face.evoLVe
library also designed in a highly-modular manner, i.e., backbones and loss
heads are separately implemented.

####  3.3.1. Backbone

We implement many popular backbones in face.evoLVe library and users can
easily change the configuration of backbones to specify the architecture of
the backbone. In addition, the highly-modular design allows users to
conveniently plug their own backbone networks into the library.

The implemented backbones in face.evoLVe library are as follows:

  * •

ResNet (He et al., 2016) – a deep convolutional neural network with residual
connections, which has various versions, e.g., ResNet18, ResNet34, ResNet50,
ResNet101 and ResNet152. ResNet has been widely applied to many vision tasks,
such as classification (He et al., 2016), segmentation (He et al., 2017) and
object detection (Ren et al., 2015), achieving state-of-the-art performance.

  * •

IR – an improved version of ResNet. Similar to ResNet, IR also has various
versions with different numbers of layers.

  * •

IR-SE – applies squeeze-and-excitation (SE) blocks (Hu et al., 2018) to
improve IR.

  * •

ResNeXt (Xie et al., 2017) – similar to ResNet, but splits channels into
different paths, which achieves better performance on most vision tasks.

  * •

SE-ResNeXt – uses squeeze-and-excitation (SE) blocks (Hu et al., 2018) to
improve ResNeXt.

  * •

DenseNet (Huang et al., 2017) – a deep convolutional neural network (CNN) with
dense residual connections, i.e., a deep layer takes the outputs of all
previous shallow layers as input, which takes more time.

  * •

LightCNN (Wu et al., 2018a) – adopts a Max-Feature-Map (MFM) for face
recognition with noisy labels. It has 3 variants: LightCNN9, LightCNN29 and
LightCNN29-V2, which is able to balance the performance and computational
complexity.

  * •

MobileNet (Howard et al., 2017) – a CNN with fewer parameters but achieves
competitive performance compared with VGG16 (Simonyan and Zisserman, 2014)
that is 30 times larger.

  * •

ShuffleNet (Zhang et al., 2018) – a very small CNN that uses pointwise group
convolution, channel shuffle and depthwise separable convolution.

  * •

DPN (Chen et al., 2017a) – a simple, highly efficient and modularized network.
A shallow DPN surpasses the best ResNeXt101 (Xie et al., 2017) with smaller
model size, less computational cost and lower memory consumption.

  * •

AttentionNet (Yoo et al., 2015) – introduces attention mechanism (Bahdanau et
al., 2014; Vaswani et al., 2017) into ResNet (He et al., 2016) to learn the
attention-aware features.

  * •

EfficientNet (Tan and Le, 2019) – a series of models that consider width
scaling, depth scaling, resolution scaling and compound scaling, resulting in
lower volume size but comparable performance compared to the counterparts.

  * •

GhostNet (Han et al., 2020) – a model that uses cheap operators to generate
more features.

####  3.3.2. Head and Loss Function

A large number of heads and loss functions are implemented in face.evoLVe
library, which covers most published works.

  * •

Softmax – a simple and naive loss function for face recognition, which is
popular in the earlier works.

  * •

Focal (Lin et al., 2017) – is used to alleviate the problem of class
imbalance, which is first applied to object detection.

  * •

Center (Wen et al., 2016) – introduces intra-class distance into softmax,
which forces the samples have the same class label are more close to each
other.

  * •

SphereFace (Liu et al., 2017) – an angular softmax function. Compared to the
original softmax function, Sphereface loss is more strict, hence the learned
feature are more separable.

  * •

CosFace (Wang et al., 2018b) – cosine function and a large margin are applied
to the original softmax function, therefore the samples are separated in the
angular space.

  * •

AmSoftmax (Wang et al., 2018a) – introduces a margin into angular softmax
function to force the face recognition model to learn separable
representations of faces.

  * •

ArcFace (Deng et al., 2019) – directly adds a margin to the angle, yielding a
additive angular margin loss.

  * •

Triplet (Schroff et al., 2015) – considers the relative difference of the
distances among the triplet composed of an anchor image, a positive image and
a negative image, which requires a triplet and how to select the negative
images could be tricky.

  * •

AdaCos (Zhang et al., 2019) – introduces dynamic scaling mechanism to adjust
the margin and scale factor.

  * •

AdaMSoftmax (Liu et al., 2019b) – adopts learnable margins and the average
margin of all classes should be large.

  * •

ArcNegFace (Liu et al., 2019a) – takes the distance between anchors into
consideration to utilize hard negative mining and weaken the influence of the
error labeling.

  * •

CircleLoss (Sun et al., 2020) – a general loss function, which is able to
deduce other loss functions, such as triplet loss and AmSoftmax.

  * •

CurricularFace (Huang et al., 2020) – applies curriculum learning to face
recognition and dynamically ranks the samples based on the hardness.

  * •

MagFace (Meng et al., 2021) – learns a universal feature embedding whose
magnitude can measure the quality of the given face.

  * •

NPCFace (Zeng et al., 2020) – adopts both hard negatives and positives to
improve learning better representations.

  * •

MVSoftmax (Wang et al., 2020b) – adaptively emphasizes the mis-classified
feature vectors to guide the discriminative feature learning.

Note that focal loss (Lin et al., 2017) can be applied to all softmax-like
functions, such as softmax, Arcface, and Cosface, which is able to mitigate
the problem of class imbalance.

###  3.4. Bag of Tricks

Instead of implementing the existing works, such as backbones and loss
functions, we also implement a bag of tricks for face recognition, which can
be helpful for both researchers and engineers.

Learning rate adjustment – at the beginning of the training process, all
parameters are typically random values, therefore they are far away from the
optimal. Using a large learning rate normally results in an unstable training
process. One solution is using warmup (Gotmare et al., 2018). In the warmup
stage, we use a small learning rate in the beginning and then switch it to the
initial learning rate when the training process is stable (Goyal et al.,
2017). After warmup, we use learning rate decay – the learning rate gradually
decreases from the initial value. Cosine annealing strategy (Loshchilov and
Hutter, 2016) is also implemented in the library. An simplified version is
reducing the learning rate from the initial value to 0 by following the cosine
function. The cosine decay reduces the learning rate slowly in the beginning,
and then becomes almost linear decreasing in the middle, and slows down again
at the end. Compared to the step decay function, cosine decay is much more
smooth and the learning rate is larger than using step decay in the middle
training stage, resulting in faster convergence, which potentially improves
the final performance.

Label Smoothing – label smoothing was first proposed to train Inception-v2
(Szegedy et al., 2016), which changes the labels from one-hot vectors to some
distributions. We empirically compare the outputs of two ResNet50 models that
are trained with and without label smoothing respectively and calculate the
gap between the maximum output value and the average of the rest values. Under
$\epsilon=0.1$ and $K=1000$, the theoretical gap is around 9.1 and using label
smoothing, the output distribution center is close to the theoretical value
and has fewer extreme values.

Model tweak – a model tweak is a minor adjustment to the network architecture,
such as changing the stride of a particular convolution layer. Model tweaks
highly depend on the experience and knowledge of researchers. Generally, a
tweak barely changes the computational complexity but might have a non-
negligible effect on the model accuracy. Many works have been done on ResNet
tweak (Zhao et al., 2017b; Goyal et al., 2017). E.g., changing the
downsampling block of ResNet. Some tweaks (Hu et al., 2018; Ma et al., 2018;
Chen et al., 2017b) replace the $7\times 7$ convolutional kernel in the input
stem with stacking three conventional $3\times 3$ convolutional kernels.

Knowledge distillation – existing models suffer from noisy identity labels,
such as outliers and label flips. It is beneficial to automatically reduce the
label noise for improving recognition accuracy. Self-training is a standard
approach in semi-supervised learning, which is explored to significantly boost
the performance on image classification (Wu et al., 2018b; Tai et al., 2021).
Based on our estimation, there are more than 30% and 50% noisy labels in
MegaFace2 (Kemelmacher-Shlizerman et al., 2016; Nech and Kemelmacher-
Shlizerman, 2017) and MS-celeb-1M (Guo et al., 2016). Since the datasets are
relatively large and to reduce label noise and learning better representations
of faces, we can apply self-training and knowledge distillation (Hinton et
al., 2015; Kim et al., 2020), i.e., learning the knowledge of the previous
trained model.In Fig. 3, we use T-SNE (Van der Maaten and Hinton, 2008) to
visualize the distribution of the learned features with and without using
knowledge distillation. Obviously, using knowledge distillation learns better
representations since the features are more discriminative, i.e., it is much
easier to classify the faces.

Figure 3. T-SNE visualization of 10 classes randomly selected from MS-
Celeb-1M. Left: without using knowledge distillation. Right: using knowledge
distillation.

###  3.5. Training and Evaluation

Dataset | # identities | # images | # videos
---|---|---|---
LFW (Huang et al., 2008) | 5,749 | 13,233 | -
CALFW (Zheng et al., 2017) | 4,025 | 12,174 | -
CASIA-WebFace (Yi et al., 2014) | 10,575 | 494,414 | -
MS-Celeb-1M (Guo et al., 2016) | 100,000 | 5.08M | -
Vggface2 (Cao et al., 2018) | 8,631 | 3.09M | -
AgeDB (Moschoglou et al., 2017) | 570 | 16,488 | -
IJB-A (Klare et al., 2015) | 500 | 5,396 | 2,085
IJB-B (Whitelam et al., 2017) | 1,845 | 21,798 | 7,011
CFP (Sengupta et al., 2016) | 500 | 7,000 | -
Umdfaces (Bansal et al., 2017) | 8,277 | 367,888 | -
CelebA (Liu et al., 2018) | 10,177 | 202,599 | -
CACD-VS (Chen et al., 2014) | 2,000 | 163,446 | -
YTF (Wolf et al., 2011) | 1,595 | - | 621,127
DeepGlint (dee, [n.d.]) | 180,855 | 6.75M | -
UTKFace (Zhang and Qi, 2017) | - | 23,708 | -
BUAA-VisNir (Huang et al., 2012) | 150 | 5,952 | -
CASIA NIR-VIS (Li et al., 2013) 2.0 | 725 | 17,580 | -
Oulu-CASIA (Zhao et al., 2011) | 80 | 65,000 | -
NUAA-ImposterDB (Tan et al., 2010) | 15 | 12,614 | -
CASIA-SURF (Zhang et al., 2020) | 1,000 | - | 21,000
CASIA-FASD (Zhang et al., 2012) | 50 | - | 600
CASIA-MFSD (Zhang et al., 2012) | 50 | - | 600
Replay-Attack (Chingovska et al., 2012) | 50 | - | 1200
WebFace260M (Zhu et al., 2021) | 2M | 42M | -
Table 2. Datasets supported by face.evoLVe library. All datasets are publicly
available. And we also provide the pre-processed datasets.

Face.evoLVe supports most public datasets and users can directly download the
datasets from the links provided in the library. Tab. 2 presents the
statistics of the datasets that supported by face.evoLVe library. For most
datasets, we provide multiple versions, including the raw version and aligned
version.

Note that large-scale datasets are more popular in recent years, hence
distributed training is vital. Fortunately, face.evoLVe library well supports
distributed training, thus users are able to train the model using relatively
large datasets, such as MS-Celeb-1M (Guo et al., 2016) and WebFace260M (Zhu et
al., 2021).

In terms of evaluation, we provide many trained models, so that researchers
can easily evaluate the models for comparison and engineers can also quickly
deploy a face recognition model.

##  4\. Performance

Backbone | Head | Loss | Testing Dataset
---|---|---|---
LFW (Huang et al., 2008) | CFP_FF (Sengupta et al., 2016) | CFP_FP (Sengupta et al., 2016) | AgeDB (Moschoglou et al., 2017) | CALFW (Zheng et al., 2017) | CPLFW (Zheng and Deng, 2018) | Vggface2_FP (Cao et al., 2018)
IR50 | Arcface (Deng et al., 2019) | Focal | 99.78 | 99.69 | 98.14 | 97.53 | 95.87 | 92.45 | 95.22
IR101 | Arcface (Deng et al., 2019) | Focal | 99.81 | 99.74 | 98.25 | 97.77 | 95.93 | 92.74 | 95.44
IR152 | Arcface (Deng et al., 2019) | Focal | 99.82 | 99.83 | 98.37 | 98.07 | 96.03 | 93.05 | 95.50
IR50 | AdaCos (Zhang et al., 2019) | Focal | 99.75 | 99.53 | 98.39 | 97.25 | 95.55 | 92.25 | 95.27
IR101 | AdaCos (Zhang et al., 2019) | Focal | 99.78 | 99.59 | 98.41 | 97.33 | 95.68 | 92.41 | 95.35
IR152 | AdaCos (Zhang et al., 2019) | Focal | 99.81 | 99.65 | 98.42 | 98.47 | 95.74 | 92.57 | 95.43
IR50 | AM-Softmax (Wang et al., 2018a) | Focal | 99.59 | 99.59 | 98.23 | 97.37 | 95.23 | 92.37 | 95.35
IR101 | AM-Softmax (Wang et al., 2018a) | Focal | 99.65 | 99.62 | 98.31 | 97.42 | 95.38 | 92.46 | 95.47
IR152 | AM-Softmax (Wang et al., 2018a) | Focal | 99.72 | 99.71 | 98.45 | 97.49 | 95.50 | 92.52 | 95.55
LightCNN-9 | Arcface (Deng et al., 2019) | Focal | 98.75 | 98.14 | 92.57 | 88.51 | 89.23 | 82.88 | 92.14
LightCNN-29 | Arcface (Deng et al., 2019) | Focal | 99.02 | 98.57 | 94.25 | 90.85 | 91.87 | 85.78 | 94.16
LightCNN-29v2 | Arcface (Deng et al., 2019) | Focal | 99.23 | 98.47 | 94.35 | 91.49 | 91.72 | 85.78 | 94.06

Table 3. The performance of the implemented models in face.evoLVe library on
different Head and Backbone. We train the models using Ms-Celeb-1M dataset
(Guo et al., 2016).

Backbone | Head | Loss | Testing Dataset
---|---|---|---
LFW (Huang et al., 2008) | CFP_FF (Sengupta et al., 2016) | CFP_FP (Sengupta et al., 2016) | AgeDB (Moschoglou et al., 2017) | CALFW (Zheng et al., 2017) | CPLFW (Zheng and Deng, 2018) | Vggface2_FP (Cao et al., 2018)
IR152 | AdaCos (Zhang et al., 2019) | Focal | 99.82 | 99.84 | 98.37 | 98.07 | 96.03 | 93.05 | 95.50
HRnet (Wang et al., 2020a) | MV-Softmax (Wang et al., 2020b) | Focal | 99.82 | 99.51 | 98.41 | 97.88 | 95.43 | 88.95 | 94.70
TF-NAS-A (Hu et al., 2020) | AM-Softmax (Wang et al., 2018a) | Focal | 99.82 | 99.47 | 98.33 | 96.65 | 94.32 | 84.88 | 91.38
GhostNet (Han et al., 2020) | ArcFace (Deng et al., 2019) | Focal | 99.69 | 99.52 | 98.48 | 97.29 | 94.92 | 85.25 | 90.88
AttentionNet (Yoo et al., 2015) | AdaCos (Zhang et al., 2019) | Focal | 99.82 | 99.47 | 98.52 | 96.89 | 95.12 | 87.23 | 94.23
MobileFaceNet (Howard et al., 2017) | AdaCos (Zhang et al., 2019) | Focal | 99.73 | 99.84 | 97.75 | 95.87 | 94.87 | 89.29 | 93.20

Table 4. The performance of the implemented models in face.evoLVe library on
different Head and Backbone. We train the models using Web260M dataset (Zhu et
al., 2021). Figure 4. The visualization of the training process. We train the
model on MS-Celeb-1M (Guo et al., 2016), using IR152 as the backbone, Arcface
(Deng et al., 2019) as the head and focal loss. We validate the model on seven
datasets and present the accuracy.

We presents the performances of the implemented models in Tab. 3 and Tab. 4.
We train the models using MS-Celeb-1M (Guo et al., 2016) dataset (Tab. 3) and
Web260M (Zhu et al., 2021) (Tab. 4), then test them on different datasets.
Compared with the state-of-the-art performance, the implemented models in
face.evoLVe achieve competitive results, e.g., the original Arcface (Deng et
al., 2019) model with ResNet100 achieves 99.82 on LFW, 95.45 on CALFW and
92.08 on CPLFW, in contrast, using face.evoLVe with IR50 achieves 99.78 on
LFW, 95.87 on CALFW and 92.45 on CPLFW (see tabel 3), performing even better
than the original Arcface. In addition, using deeper backbones like IR101 and
IR152 are able to obtaining better performance. Compared to other
implementations such as FaceX-zoo (Wang et al., 2021), face.evoLVe is also
competitive, e.g., using IR50+Arcface face.evoLVe and faceX-zoo achieve the
same accuracy (99.78) on LFW, while face.evoLVe outperforms faceX-zoo on CALFW
(95.87 vs. 95.47).

Interestingly, looking at Tab. 4 where the models are trained on a relatively
large dataset – Web260M (Zhu et al., 2021), the performance could be further
improved. E.g., IR152+AdaCos trained on Web260M obtains 99.82, 96.03, 93.05 on
LFW, CALFW and CPLFW, respectively, while the same model trained on MS-
Celeb-1M achieves 99.81, 95.74 and 92.57.

Apart from presenting the accuracy, we also visualize the training process in
Fig. 4 to help users analyse the model behaviors during training, such as
stability and overfitting. E.g., we can easily find than overfitting occurs on
LFW dataset during training, hence training more iterations does not improve
the final performance but takes more time, in this case, early stop can be
applied.

Moreover, we use face.evoLVe library to participate in many face recognition
competitions, achieving the fist place and SoTA performance. E.g., we achieve
the fist place on ICCV 2017 MS-Celeb-1M Large-Scale Face Recognition Hard
Set/Random Set/Low-Shot Learning Challenges by using the face.evoLVe library
and No.1 on National Institute of Standards and Technology (NIST) IARPA Janus
Benchmark A (IJB-A) Unconstrained Face Verification challenge and
Identification challenge in 2017. In addition, face.evoLVe also achieves SoTA
performance on other datasets, e.g., on MS-Celeb-1M hard set, using
face.evoLVe obtains 79.10% of coverage at precision=95% and 87.50% of coverage
at precision=95% on the random set.

##  5\. Using Customized Datasets and Models

As we have mentioned, it is relatively easy and convenient to use the
developed face.evoLVe library for both training and evaluation. Generally,
researchers also requires the modularity of a toolbox, thus they are able to
easily plug their proposed models into the toolbox with changing only a few
codes. Fortunately, face.evoLVe is a highly modular library.

Apart from the datasets provided by the library, users can also their own
datasets. Face.evoLVe provides data pre-processing SDK, including face
detection and alignment, so that users can first use the pre-processing SDK to
obtain the images of faces, which is relatively convenient.

In terms of the model, which is designed in a modular and extensible manner,
e.g., the backbones and heads are independent to each other, thus, users can
easily plug either customized backbones or heads without changing the
architecture of the library. Also, during training users can easily change the
hyper-parameters, such as learning rate, batch size and momentum.

##  6\. Conclusion

In this paper, we have presented a comprehensive face recognition library –
face.evoLVe, which is composed of necessary components covering the full
pipeline of face recognition practices, including the alternating backbones
and loss functions for face detection, alignment, feature extraction and
matching. The goal of face.evoLVe is to lower the technical burden for
researchers in the community to reproduce existing algorithms and models for
comparisons and benchmark. In addition, face.evoLVe is designed in a highly
modular and extensible manner, where users could easily implement and plug
their own models into the library for potential extension and contribution.
Also, the developed library provides a bag of tricks to improve the
performance and stabilize the training process. Note that we have used
face.evoLVe to achieve SoTA performance and secured the first place for a
series of open competitions. Currently, face.evoLVe is still evolving with a
group of active contributors. Commitments with novel models, tricks and
datasets are welcome.

##  7\. Acknowledgement

This work was partially supported by the National Science Foundation of China
62006244.

## References

  * (1)
  * dee ([n.d.]) [n.d.].  Ms-celeb-1m challenge 3. In _http://trillionpairs.deepglint.com/overview_.
  * Abadi et al. (2016) Martín Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Geoffrey Irving, Michael Isard, et al. 2016\.  Tensorflow: A system for large-scale machine learning. In _OSDI_. 265–283.
  * Aishwarya and Marcus (2010) P Aishwarya and Karnan Marcus. 2010.  Face recognition using multiple eigenface subspaces.  _Journal of Engineering and Technology Research_ 2, 8 (2010), 139–143.
  * Bahdanau et al. (2014) Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. 2014\.  Neural machine translation by jointly learning to align and translate.  _arXiv preprint arXiv:1409.0473_ (2014).
  * Bansal et al. (2017) Ankan Bansal, Anirudh Nanduri, Carlos D Castillo, Rajeev Ranjan, and Rama Chellappa. 2017\.  Umdfaces: An annotated face dataset for training deep networks. In _IJCB_. 464–473.
  * Cao et al. (2018) Qiong Cao, Li Shen, Weidi Xie, Omkar M Parkhi, and Andrew Zisserman. 2018.  Vggface2: A dataset for recognising faces across pose and age. In _FG_. 67–74.
  * Chen et al. (2014) Bor-Chun Chen, Chu-Song Chen, and Winston H Hsu. 2014\.  Cross-age reference coding for age-invariant face recognition and retrieval. In _ECCV_. 768–783.
  * Chen et al. (2017b) Liang-Chieh Chen, George Papandreou, Florian Schroff, and Hartwig Adam. 2017b.  Rethinking atrous convolution for semantic image segmentation.  _arXiv preprint arXiv:1706.05587_ (2017).
  * Chen et al. (2015) Tianqi Chen, Mu Li, Yutian Li, Min Lin, Naiyan Wang, Minjie Wang, Tianjun Xiao, Bing Xu, Chiyuan Zhang, and Zheng Zhang. 2015\.  Mxnet: A flexible and efficient machine learning library for heterogeneous distributed systems.  _arXiv preprint arXiv:1512.01274_ (2015).
  * Chen et al. (2017a) Yunpeng Chen, Jianan Li, Huaxin Xiao, Xiaojie Jin, Shuicheng Yan, and Jiashi Feng. 2017a.  Dual path networks.  _arXiv preprint arXiv:1707.01629_ (2017).
  * Chingovska et al. (2012) Ivana Chingovska, André Anjos, and Sébastien Marcel. 2012.  On the effectiveness of local binary patterns in face anti-spoofing. In _BIOSIG_. 1–7.
  * Deng et al. (2020) Jiankang Deng, Jia Guo, Tongliang Liu, Mingming Gong, and Stefanos Zafeiriou. 2020.  Sub-center arcface: Boosting face recognition by large-scale noisy web faces. In _ECCV_. 741–757.
  * Deng et al. (2019) Jiankang Deng, Jia Guo, Niannan Xue, and Stefanos Zafeiriou. 2019\.  Arcface: Additive angular margin loss for deep face recognition. In _CVPR_. 4690–4699.
  * Du (2018) Meiyan Du. 2018\.  Mobile payment recognition technology based on face detection algorithm.  _Concurrency and Computation: Practice and Experience_ 30, 22 (2018), e4655.
  * Gotmare et al. (2018) Akhilesh Gotmare, Nitish Shirish Keskar, Caiming Xiong, and Richard Socher. 2018.  A closer look at deep learning heuristics: Learning rate restarts, warmup and distillation.  _arXiv preprint arXiv:1810.13243_ (2018).
  * Goyal et al. (2017) Priya Goyal, Piotr Dollár, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, Andrew Tulloch, Yangqing Jia, and Kaiming He. 2017.  Accurate, large minibatch sgd: Training imagenet in 1 hour.  _arXiv preprint arXiv:1706.02677_ (2017).
  * Guo et al. (2019) Jia Guo, Jiankang Deng, Xiang An, and Jack Yu. 2019\.  InsightFace.  https://github.com/deepinsight/insightface.git.
  * Guo et al. (2016) Yandong Guo, Lei Zhang, Yuxiao Hu, Xiaodong He, and Jianfeng Gao. 2016.  Ms-celeb-1m: A dataset and benchmark for large-scale face recognition. In _ECCV_. 87–102.
  * Gupta et al. (2010) Sheifali Gupta, OP Sahoo, Ajay Goel, and Rupesh Gupta. 2010\.  A new optimized approach to face recognition using eigenfaces.  _Global Journal of Computer Science and Technology_ (2010).
  * Han et al. (2020) Kai Han, Yunhe Wang, Qi Tian, Jianyuan Guo, Chunjing Xu, and Chang Xu. 2020\.  Ghostnet: More features from cheap operations. In _CVPR_. 1580–1589.
  * He et al. (2017) Kaiming He, Georgia Gkioxari, Piotr Dollár, and Ross Girshick. 2017.  Mask r-cnn. In _ICCV_. 2961–2969.
  * He et al. (2016) Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. 2016\.  Deep residual learning for image recognition. In _CVPR_. 770–778.
  * Hinton et al. (2015) Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. 2015\.  Distilling the knowledge in a neural network.  _arXiv preprint arXiv:1503.02531_ (2015).
  * Howard et al. (2017) Andrew G Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. 2017\.  Mobilenets: Efficient convolutional neural networks for mobile vision applications.  _arXiv preprint arXiv:1704.04861_ (2017).
  * Hu et al. (2018) Jie Hu, Li Shen, and Gang Sun. 2018.  Squeeze-and-excitation networks. In _CVPR_. 7132–7141.
  * Hu et al. (2020) Yibo Hu, Xiang Wu, and Ran He. 2020.  TF-NAS: Rethinking Three Search Freedoms of Latency-Constrained Differentiable Neural Architecture Search. In _ECCV_.
  * Huang et al. (2012) D Huang, J Sun, and Y Wang. 2012.  The BUAA-VisNir face database instructions.  _School Comput. Sci. Eng., Beihang Univ., Beijing, China, Tech. Rep. IRIP-TR-12-FR-001_ 3 (2012).
  * Huang et al. (2017) Gao Huang, Zhuang Liu, Laurens Van Der Maaten, and Kilian Q Weinberger. 2017.  Densely connected convolutional networks. In _CVPR_. 4700–4708.
  * Huang et al. (2008) Gary B Huang, Marwan Mattar, Tamara Berg, and Eric Learned-Miller. 2008.  Labeled faces in the wild: A database forstudying face recognition in unconstrained environments. In _Workshop on Faces in ’Real-Life’ Images: Detection, Alignment, and Recognition_.
  * Huang et al. (2020) Yuge Huang, Yuhan Wang, Ying Tai, Xiaoming Liu, Pengcheng Shen, Shaoxin Li, Jilin Li, and Feiyue Huang. 2020\.  Curricularface: adaptive curriculum learning loss for deep face recognition. In _CVPR_. 5901–5910.
  * Jian (2018) Zhao Jian. 2018\.  Deep learning for human-centric image analysis.  (2018).
  * Kemelmacher-Shlizerman et al. (2016) Ira Kemelmacher-Shlizerman, Steven M Seitz, Daniel Miller, and Evan Brossard. 2016.  The megaface benchmark: 1 million faces for recognition at scale. In _CVPR_.
  * Kim et al. (2020) Kyungyul Kim, ByeongMoon Ji, Doyoung Yoon, and Sangheum Hwang. 2020\.  Self-knowledge distillation: A simple way for better generalization.  _arXiv preprint arXiv:2006.12000_ (2020).
  * Klare et al. (2015) Brendan F Klare, Ben Klein, Emma Taborsky, Austin Blanton, Jordan Cheney, Kristen Allen, Patrick Grother, Alan Mah, and Anil K Jain. 2015.  Pushing the frontiers of unconstrained face detection and recognition: Iarpa janus benchmark a. In _CVPR_. 1931–1939.
  * Krizhevsky et al. (2012) Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. 2012\.  Imagenet classification with deep convolutional neural networks.  _NeurIPS_ 25 (2012), 1097–1105.
  * Li et al. (2013) Stan Li, Dong Yi, Zhen Lei, and Shengcai Liao. 2013\.  The casia nir-vis 2.0 face database. In _CVPRW_. 348–353.
  * Lin et al. (2017) Tsung-Yi Lin, Priya Goyal, Ross Girshick, Kaiming He, and Piotr Dollár. 2017.  Focal loss for dense object detection. In _ICCV_. 2980–2988.
  * Liu et al. (2019b) Hao Liu, Xiangyu Zhu, Zhen Lei, and Stan Z Li. 2019b.  Adaptiveface: Adaptive margin and sampling for face recognition. In _CVPR_. 11947–11956.
  * Liu et al. (2015) Jingtuo Liu, Yafeng Deng, Tao Bai, Zhengping Wei, and Chang Huang. 2015.  Targeting ultimate accuracy: Face recognition via deep embedding.  _arXiv preprint arXiv:1506.07310_ (2015).
  * Liu et al. (2017) Weiyang Liu, Yandong Wen, Zhiding Yu, Ming Li, Bhiksha Raj, and Le Song. 2017\.  Sphereface: Deep hypersphere embedding for face recognition. In _CVPR_. 212–220.
  * Liu et al. (2019a) Yu Liu et al. 2019a.  Towards flops-constrained face recognition. In _ICCVW_. 0–0.
  * Liu et al. (2018) Ziwei Liu, Ping Luo, Xiaogang Wang, and Xiaoou Tang. 2018\.  Large-scale celebfaces attributes (celeba) dataset.  _Retrieved August_ 15, 2018 (2018), 11.
  * Loshchilov and Hutter (2016) Ilya Loshchilov and Frank Hutter. 2016.  Sgdr: Stochastic gradient descent with warm restarts.  _arXiv preprint arXiv:1608.03983_ (2016).
  * Ma et al. (2018) Ningning Ma, Xiangyu Zhang, Hai-Tao Zheng, and Jian Sun. 2018\.  Shufflenet v2: Practical guidelines for efficient cnn architecture design. In _ECCV_. 116–131.
  * Ma et al. (2019) Yanjun Ma, Dianhai Yu, Tian Wu, and Haifeng Wang. 2019\.  PaddlePaddle: An open-source deep learning platform from industrial practice.  _Frontiers of Data and Computing_ 1, 1 (2019), 105–115.
  * Meng et al. (2021) Qiang Meng, Shichao Zhao, Zhida Huang, and Feng Zhou. 2021\.  Magface: A universal representation for face recognition and quality assessment. In _CVPR_. 14225–14234.
  * Moschoglou et al. (2017) Stylianos Moschoglou, Athanasios Papaioannou, Christos Sagonas, Jiankang Deng, Irene Kotsia, and Stefanos Zafeiriou. 2017.  Agedb: the first manually collected, in-the-wild age database. In _CVPRW_.
  * Nech and Kemelmacher-Shlizerman (2017) Aaron Nech and Ira Kemelmacher-Shlizerman. 2017.  Level Playing Field For Million Scale Face Recognition. In _CVPR_.
  * Park et al. (2010) Unsang Park, Yiying Tong, and Anil K Jain. 2010.  Age-invariant face recognition.  _T-PAMI_ 32, 5 (2010), 947–954.
  * Parkhi et al. (2015) Omkar M Parkhi, Andrea Vedaldi, and Andrew Zisserman. 2015\.  Deep face recognition.  (2015).
  * Paszke et al. (2019) Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, et al. 2019\.  Pytorch: An imperative style, high-performance deep learning library.  _NeurIPS_ 32 (2019), 8026–8037.
  * Ren et al. (2015) Shaoqing Ren, Kaiming He, Ross Girshick, and Jian Sun. 2015\.  Faster r-cnn: Towards real-time object detection with region proposal networks.  _NeurIPS_ 28 (2015), 91–99.
  * Rizon et al. (2006) Mohamed Rizon, Hashim Muhammad Firdaus, Saad Puteh, Yaacob Sazali, Mamat Mohd Rozailan, Ali Yeon, Md Shakaff, Saad Abdul Rahman, Desa Hazri, and M Karthigayan. 2006\.  Face recognition using eigenfaces and neural networks.  (2006).
  * Sahoolizadeh and Ghassabeh (2008) Hossein Sahoolizadeh and Youness Aliyari Ghassabeh. 2008\.  Face recognition using eigen-faces, fisher-faces and neural networks. In _2008 7th IEEE International Conference on Cybernetic Intelligent Systems_. 1–6.
  * Schroff et al. (2015) Florian Schroff, Dmitry Kalenichenko, and James Philbin. 2015\.  Facenet: A unified embedding for face recognition and clustering. In _CVPR_. 815–823.
  * Sengupta et al. (2016) Soumyadip Sengupta, Jun-Cheng Chen, Carlos Castillo, Vishal M Patel, Rama Chellappa, and David W Jacobs. 2016.  Frontal to profile face verification in the wild. In _WACV_. 1–9.
  * Simonyan and Zisserman (2014) Karen Simonyan and Andrew Zisserman. 2014.  Very deep convolutional networks for large-scale image recognition.  _arXiv preprint arXiv:1409.1556_ (2014).
  * Sun et al. (2020) Yifan Sun, Changmao Cheng, Yuhan Zhang, Chi Zhang, Liang Zheng, Zhongdao Wang, and Yichen Wei. 2020.  Circle loss: A unified perspective of pair similarity optimization. In _CVPR_. 6398–6407.
  * Sun et al. (2015) Yi Sun, Ding Liang, Xiaogang Wang, and Xiaoou Tang. 2015\.  Deepid3: Face recognition with very deep neural networks.  _arXiv preprint arXiv:1502.00873_ (2015).
  * Sun et al. (2014) Yi Sun, Xiaogang Wang, and Xiaoou Tang. 2014.  Deep learning face representation from predicting 10,000 classes. In _CVPR_. 1891–1898.
  * Szegedy et al. (2015) Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. 2015.  Going deeper with convolutions. In _CVPR_. 1–9.
  * Szegedy et al. (2016) Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. 2016.  Rethinking the inception architecture for computer vision. In _CVPR_. 2818–2826.
  * Tai et al. (2021) Kai Sheng Tai, Peter Bailis, and Gregory Valiant. 2021\.  Sinkhorn Label Allocation: Semi-Supervised Classification via Annealed Self-Training.  _arXiv preprint arXiv:2102.08622_ (2021).
  * Taigman et al. (2014) Yaniv Taigman, Ming Yang, Marc’Aurelio Ranzato, and Lior Wolf. 2014\.  Deepface: Closing the gap to human-level performance in face verification. In _CVPR_. 1701–1708.
  * Tan and Le (2019) Mingxing Tan and Quoc Le. 2019.  Efficientnet: Rethinking model scaling for convolutional neural networks. In _ICML_. 6105–6114.
  * Tan et al. (2010) Xiaoyang Tan, Yi Li, Jun Liu, and Lin Jiang. 2010\.  Face liveness detection from a single image with sparse low rank bilinear discriminative model. In _ECCV_. 504–517.
  * Van der Maaten and Hinton (2008) Laurens Van der Maaten and Geoffrey Hinton. 2008.  Visualizing data using t-SNE.  _JMLR_ 9, 11 (2008).
  * Vaswani et al. (2017) Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. 2017.  Attention is all you need. In _NeurIPS_. 5998–6008.
  * Wang et al. (2018a) Feng Wang, Jian Cheng, Weiyang Liu, and Haijun Liu. 2018a.  Additive margin softmax for face verification.  _IEEE Signal Processing Letters_ 25, 7 (2018), 926–930.
  * Wang et al. (2018b) Hao Wang, Yitong Wang, Zheng Zhou, Xing Ji, Dihong Gong, Jingchao Zhou, Zhifeng Li, and Wei Liu. 2018b.  Cosface: Large margin cosine loss for deep face recognition. In _CVPR_. 5265–5274.
  * Wang et al. (2021) Jun Wang, Yinglu Liu, Yibo Hu, Hailin Shi, and Tao Mei. 2021.  FaceX-Zoo: A PyTorh Toolbox for Face Recognition.  _arXiv preprint arXiv:2101.04407_ (2021).
  * Wang et al. (2020a) Jingdong Wang, Ke Sun, Tianheng Cheng, Borui Jiang, Chaorui Deng, Yang Zhao, Dong Liu, Yadong Mu, Mingkui Tan, Xinggang Wang, et al. 2020a.  Deep high-resolution representation learning for visual recognition.  _T-PAMI_ (2020).
  * Wang and Deng (2018) Mei Wang and Weihong Deng. 2018.  Deep face recognition: A survey.  _arXiv preprint arXiv:1804.06655_ (2018).
  * Wang et al. (2020b) Xiaobo Wang, Shifeng Zhang, Shuo Wang, Tianyu Fu, Hailin Shi, and Tao Mei. 2020b.  Mis-classified vector guided softmax loss for face recognition. In _AAAI_ , Vol. 34. 12241–12248.
  * Wen et al. (2016) Yandong Wen, Kaipeng Zhang, Zhifeng Li, and Yu Qiao. 2016\.  A discriminative feature learning approach for deep face recognition. In _ECCV_. 499–515.
  * Whitelam et al. (2017) Cameron Whitelam, Emma Taborsky, Austin Blanton, Brianna Maze, Jocelyn Adams, Tim Miller, Nathan Kalka, Anil K Jain, James A Duncan, Kristen Allen, et al. 2017\.  Iarpa janus benchmark-b face dataset. In _CVPRW_. 90–98.
  * Wolf et al. (2011) Lior Wolf, Tal Hassner, and Itay Maoz. 2011.  Face recognition in unconstrained videos with matched background similarity. In _CVPR_. 529–534.
  * Wu et al. (2018b) Di Wu, Mingsheng Shang, Xin Luo, Ji Xu, Huyong Yan, Weihui Deng, and Guoyin Wang. 2018b.  Self-training semi-supervised classification based on density peaks of data.  _Neurocomputing_ 275 (2018), 180–191.
  * Wu et al. (2018a) Xiang Wu, Ran He, Zhenan Sun, and Tieniu Tan. 2018a.  A light cnn for deep face representation with noisy labels.  _TIFS_ 13, 11 (2018), 2884–2896.
  * Xie et al. (2017) Saining Xie, Ross Girshick, Piotr Dollár, Zhuowen Tu, and Kaiming He. 2017.  Aggregated residual transformations for deep neural networks. In _CVPR_. 1492–1500.
  * Yi et al. (2014) Dong Yi, Zhen Lei, Shengcai Liao, and Stan Z Li. 2014\.  Learning face representation from scratch.  _arXiv preprint arXiv:1411.7923_ (2014).
  * Yoo et al. (2015) Donggeun Yoo, Sunggyun Park, Joon-Young Lee, Anthony S Paek, and In So Kweon. 2015.  Attentionnet: Aggregating weak directions for accurate object detection. In _ICCV_. 2659–2667.
  * Zeng et al. (2020) Dan Zeng, Hailin Shi, Hang Du, Jun Wang, Zhen Lei, and Tao Mei. 2020.  NPCFace: A Negative-Positive Cooperation Supervision for Training Large-scale Face Recognition.  _arXiv preprint arXiv:2007.10172_ (2020).
  * Zhang et al. (2016) Kaipeng Zhang, Zhanpeng Zhang, Zhifeng Li, and Yu Qiao. 2016\.  Joint face detection and alignment using multitask cascaded convolutional networks.  _IEEE Signal Processing Letters_ 23, 10 (2016), 1499–1503.
  * Zhang et al. (2020) Shifeng Zhang, Ajian Liu, Jun Wan, Yanyan Liang, Guodong Guo, Sergio Escalera, Hugo Jair Escalante, and Stan Z Li. 2020\.  Casia-surf: A large-scale multi-modal benchmark for face anti-spoofing.  _IEEE Transactions on Biometrics, Behavior, and Identity Science_ 2, 2 (2020), 182–193.
  * Zhang and Qi (2017) Song Yang Zhang, Zhifei and Hairong Qi. 2017.  Age Progression/Regression by Conditional Adversarial Autoencoder. In _CVPR_.
  * Zhang et al. (2021) Xiao Zhang, Haoyi Xiong, and Dongrui Wu. 2021.  Rethink the Connections among Generalization, Memorization and the Spectral Bias of DNNs.  _IJCAI_ (2021).
  * Zhang et al. (2019) Xiao Zhang, Rui Zhao, Yu Qiao, Xiaogang Wang, and Hongsheng Li. 2019.  Adacos: Adaptively scaling cosine logits for effectively learning deep face representations. In _CVPR_. 10823–10832.
  * Zhang et al. (2018) Xiangyu Zhang, Xinyu Zhou, Mengxiao Lin, and Jian Sun. 2018\.  Shufflenet: An extremely efficient convolutional neural network for mobile devices. In _CVPR_. 6848–6856.
  * Zhang et al. (2012) Zhiwei Zhang, Junjie Yan, Sifei Liu, Zhen Lei, Dong Yi, and Stan Z Li. 2012\.  A face antispoofing database with diverse attacks. In _ICB_. 26–31.
  * Zhao et al. (2011) Guoying Zhao, Xiaohua Huang, Matti Taini, Stan Z Li, and Matti PietikäInen. 2011.  Facial expression recognition from near-infrared videos.  _Image and Vision Computing_ 29, 9 (2011), 607–619.
  * Zhao et al. (2017b) Hengshuang Zhao, Jianping Shi, Xiaojuan Qi, Xiaogang Wang, and Jiaya Jia. 2017b.  Pyramid scene parsing network. In _CVPR_. 2881–2890.
  * Zhao et al. (2019a) Jian Zhao, Yu Cheng, Yi Cheng, Yang Yang, Fang Zhao, Jianshu Li, Hengzhu Liu, Shuicheng Yan, and Jiashi Feng. 2019a.  Look across elapse: Disentangled representation learning and photorealistic cross-age face synthesis for age-invariant face recognition. In _AAAI_ , Vol. 33. 9251–9258.
  * Zhao et al. (2017a) Jian Zhao, Jianshu Li, Fang Zhao, Shuicheng Yan, and Jiashi Feng. 2017a.  Marginalized cnn: Learning deep invariant representations. In _BMVC_.
  * Zhao et al. (2018) Jian Zhao, Lin Xiong, Yu Cheng, Yi Cheng, Jianshu Li, Li Zhou, Yan Xu, Jayashree Karlekar, Sugiri Pranata, Shengmei Shen, et al. 2018\.  3D-Aided Deep Pose-Invariant Face Recognition.. In _IJCAI_ , Vol. 2. 11\.
  * Zhao et al. (2020) Jian Zhao, Shuicheng Yan, and Jiashi Feng. 2020.  Towards age-invariant face recognition.  _T-PAMI_ (2020).
  * Zhao et al. (2019b) Kai Zhao, Jingyi Xu, and Ming-Ming Cheng. 2019b.  Regularface: Deep face recognition via exclusive regularization. In _CVPR_. 1136–1144.
  * Zheng and Deng (2018) Tianyue Zheng and Weihong Deng. 2018.  Cross-pose lfw: A database for studying cross-pose face recognition in unconstrained environments.  _Technical Report_ (2018).
  * Zheng et al. (2017) Tianyue Zheng, Weihong Deng, and Jiani Hu. 2017.  Cross-age lfw: A database for studying cross-age face recognition in unconstrained environments.  _arXiv:1708.08197_ (2017).
  * Zhu et al. (2011) Wenwu Zhu, Chong Luo, Jianfeng Wang, and Shipeng Li. 2011\.  Multimedia cloud computing.  _IEEE Signal Processing Magazine_ 28, 3 (2011), 59–69.
  * Zhu et al. (2021) Zheng Zhu, Guan Huang, Jiankang Deng, Yun Ye, Junjie Huang, Xinze Chen, Jiagang Zhu, Tian Yang, Jiwen Lu, Dalong Du, and Jie Zhou. 2021.  WebFace260M: A Benchmark Unveiling the Power of Million-scale Deep Face Recognition. In _CVPR_.