Occlusion-guided compact template learning for ensemble deep network-based pose-invariant face recognition

TL;DR

This paper introduces an occlusion-guided method for creating compact facial templates that focus on visible patches, improving face recognition performance across different views while reducing template size.

Contribution

The proposed OGCTL approach constructs occlusion-aware compact templates using only visible patches, enhancing robustness and efficiency in face recognition.

Findings

Significantly improved face verification accuracy on challenging datasets.

Template size is reduced by an order of magnitude compared to previous methods.

Enhanced robustness to occlusions and view variations in face recognition.

Abstract

Concatenation of the deep network representations extracted from different facial patches helps to improve face recognition performance. However, the concatenated facial template increases in size and contains redundant information. Previous solutions aim to reduce the dimensionality of the facial template without considering the occlusion pattern of the facial patches. In this paper, we propose an occlusion-guided compact template learning (OGCTL) approach that only uses the information from visible patches to construct the compact template. The compact face representation is not sensitive to the number of patches that are used to construct the facial template and is more suitable for incorporating the information from different view angles for image-set based face recognition. Instead of using occlusion masks in face matching (e.g., DPRFS [38]), the proposed method uses occlusion masks in template construction and achieves significantly better image-set based face verification performance on a challenging database with a template size that is an order-of-magnitude smaller than DPRFS.

Figures

Tables

Table 1. Table 1: TAR (True Accept Rate) against the FAR (False positive rate) of different methods on IJB-C database. The number of images used to train each model is presented under the “scale”. The AUC represents the Area Under the ROC. The result marked with † † \dagger are read from the ROC curve in the IJB-C benchmark [ 26 ] . An unavailable number is marked as “-”.

Method	Input	Template	Dataset	Scale	FAR=${10}^{-5}$	FAR=${10}^{-4}$	FAR=${10}^{-3}$	FAR=${10}^{-2}$	FAR=${10}^{-1}$	AUC
		Size
COTS-1 [26]]$†$	Image	-	-	-	0.090	0.160	0.320	0.620	0.800	-
FaceNet [26] $†$	Image	0.5 KB	-	-	0.330	0.490	0.660	0.820	0.920	-
VGG-CNN [26] $†$	Image	16 KB	VGGFace	2.6M	0.430	0.600	0.750	0.860	0.950	-
Cao et al. [1]	Image	2 KB	VGG2	3.3M	0.747	0.840	0.910	0.960	0.987	-
Arcface [3]	Image	2 KB	VGGFace	2.6M	0.895	0.932	0.957	0.973	0.985	0.993
DPRFS [38]	Frontalized Image	16 KB	Webface	0.5M	0.310	0.461	0.638	0.807	0.939	0.976
OGCTL	Face representation	0.5 KB	Webface	0.5M	0.608	0.737	0.839	0.918	0.975	0.989
OGCTL+	Face representation	0.5 KB	Webface + MS-Celeb + VGG2	14M	0.879	0.923	0.952	0.975	0.988	0.995

Table 2. Table 2: Performance in profile face identification. The template size marked with † † \dagger is determined by the number of visible patches (depicted in Fig. 6 ) used for matching.

Method	Gallery Patch	Probe Patch	Template	Identification
	Number	Number	Size	Accuracy
DPRFS	3	3	6.00 KB $†$	0.961
A3	3	3	0.19 KB $†$	0.779
OGCTL-S	3	3	0.50 KB	0.922
OGCTL	3	3	0.50 KB	0.935
OGCTL-S	8	3	0.50 KB	0.883
OGCTL	8	3	0.50 KB	0.974

Equations

$$s=\frac{1}{\sum ({\text{m}}^a\wedge {\text{m}}^b)}\sum _i{\Psi }_i({\text{x}}_i^a,{\text{x}}_i^b)(m_i^a\wedge m_i^b)$$

$${\hat{\text{t}}}_i={\mathbf{\varphi }}_i^N({\text{m}}_i{\mathbf{\varphi }}_i^D({\text{x}}_i;{\mathbf{\theta }}_i^D);{\mathbf{\theta }}_i^N)$$

$$\text{t}=\sum _i{\hat{\text{t}}}_i,$$

$$L=-\frac{1}{K}\sum _{j}log(\frac{e^{f_1({\text{t}}_j,{\text{w}}_{y_j},\omega )}}{e^{f_1({\text{t}}_j,{\text{w}}_{y_j},\omega )}+{\Sigma }_{c\ne y_j}{e}^{f_2({\text{t}}_j,{\text{w}}_c)}}),$$

$$f_1({\text{t}}_j,{\text{w}}_{y_j},\omega )=||{\text{t}}_j||cos(\omega {\theta }_{j,y_j}),$$

$$f_2({\text{t}}_j,{\text{w}}_c)=||{\text{t}}_j||cos({\theta }_{j,c}),$$

Full text

1 Introduction

The problem of template learning in face recognition is to map a single facial image into a vector representation so that the distance between these representations reflects the actual similarity between facial images (or videos). In recent work, researchers have focused more on improving the discriminative capability of the template, and paid relatively less attention to the size of the template. The size of the template becomes important for large-scale face retrieval when the gallery database contains millions of images [34]. A real-world surveillance scenario becomes infeasible to compute the similarity scores between one probe and all images in the gallery when it takes minutes to process a single video frame. Another application scenario is biometric credit cards, where the size of the template is limited by the memory of the chip inside it. In this work, we focus on learning a compact floating point template whose vector length should be as small as possible while preserving its discriminative capability.

Learning a compact but highly discriminative template is challenging; the recent research Gong et al. [9] indicates that template length directly impacts the discriminative capability of the template. To gather as much discriminative information as possible in the template, our starting point is based on an ensemble deep neural network model named DPRFS presented by Xiang et al. [38]. Like other ensemble deep neural network models [32, 30, 31, 13, 24, 4], DPRFS concatenates facial representations from multiple facial patches, but uses an occlusion vector to indicate which facial patch was occluded. It was demonstrated that the template generated by DPRFS achieves state-of-the-art results for single image based face matching under large head pose variation [38]. However, it has the following limitations: (i) the template size is large (16K bytes), (ii) face matching speed is limited by selecting non-occluded face representations for similarity computations, (iii) it is hard to generate a single template that takes into account all the occlusion patterns of images in an image set.

To address the aforementioned limitations of the ensemble model, we invented an occlusion-guided compact template learning method to encourage the information integration between the face representations that are generated by each individual deep network. This operation preserves the discriminative co-occurrence pattern between multiple facial regions and significantly improves the performance of a compact template. The main contributions of this paper are: (i) we invented an occlusion-guided neural network architecture to learn a compact facial template from the face representations and occlusion masks generated by an ensemble model, (ii) we invented a method to generate a compact template from different number of visible facial patches.

2 Related work

In the literature on facial template learning, researchers have paid more attention to the performance of the templates rather than the template size. To the best of our knowledge, the size of the smallest template that achieves more than 99.5% verification rate on LFW database [14] is 0.5 KB [24, 29] (The data type of the template is assumed to be 32-bit single precision floating point as used in standard convolutional neural networks (CNN) [10]). Although most of the selected algorithms reported near saturated verification performance on LFW database, their performances degrade in the databases that contain large head pose variations (e.g., UHDB31 database [22]).

Many of the recent face recognition systems employ ensemble models [32, 30, 31, 13, 24, 4, 2], where face representations of multiple convolutional neural networks are concatenated together as the final facial template to enrich the template’s representation capability. Hu et al. [13] used extensive experiments to demonsrate that the concatenated representation consistently outperforms the output of a stand-alone CNN model. To learn diverse facial representation for concatenation, a common solution is to divide the facial image into multiple patches [32, 30, 31, 13, 24, 4], and for each patch learn a separate CNN. However, these methods do not take into account the occlusion of patches under large head-pose variations. Some of the patches should be de-activated on-line due to facial occlusion because their corresponding features in the facial template are no longer informative. Using these non-discriminative face representations in face matching is detrimental to the final face recognition performance.

A compact template can be further compressed by principal component analysis (PCA) [17], product quantization [16], or hashing-based binarization approaches [5, 23]. PCA is a well-known dimensionality reduction approach which has been applied in [32, 30] to reduce the facial template size from 76.8 KB to 0.625 KB. Wang [34] employs Product Quantization [16] to convert a 1.25 KB into a binary 64 Bytes template for large-scale face retrieval. Recently, deep hashing-based approaches were used to generate a binary template from the output of CNN with hashing layers [5, 23]. The common point of all these approaches is that they require a floating point face representation as the starting point to derive a compact facial template. The contribution of our approach is to provide a method to generate a compact face representation (0.5 KB to 1 KB) as a good candidate for the aforementioned studies [17, 16, 5, 23]. This template is robust to facial self-occlusion caused by large head pose variations.

3 Method

3.1 Template and occlusion mask

DPRFS [38] is designed to cope with the large head pose variation problem in face recognition. The algorithm is depicted in Fig. 2. Before computing the face representations, a frontalized facial texture V needs to be generated from the input image to normalize the pose variations [19, 38]. Let I be an input image. A personalized facial model with the name AFM proposed by Kakadiaris et al. [18] is initially estimated based on the method proposed by Dou et al. [6]. The model is then fit onto I based on the landmarks detected by Wu et al. [37]. Then, a frontalized facial texture V (UV image) is generated through the texture lifting process proposed by Toderici et al. [33]. Along with V, a binary self-occlusion map O is generated based on the z-buffer as in [7], where each pixel in O indicates whether the corresponding pixel of V in I is occluded or not. In DPRFS, V is divided into $n$ semi-overlapped patches as depicted in Fig. 2. Let the set $\mathbb{P}=\{\textbf{P}_{1},\textbf{P}_{2},\textbf{P}_{3}...\textbf{P}_{n}\}$ denote the patches in V. For each $\textbf{P}_{i}$ a separate residual network $\bm{\phi}^{R}_{i}$ is learned to map $\textbf{P}_{i}$ to a face representation $\textbf{x}_{i}$, where $\textbf{x}_{i}=\bm{\phi}^{R}_{i}(\textbf{P}_{i})$. Correspondingly, O is also divided into equal sized patches as $\textbf{P}_{i}$, denoted by $\textbf{M}_{i}$. A binary value $m_{i}$ is used to summarize the occlusion status of $\textbf{M}_{i}$. In DPRFS, if the number of visible pixel in $\textbf{M}_{i}$ is smaller than a threshold $\epsilon$, the whole patch is regarded as occluded so that $m_{i}=0$. The final output of DPRFS is a concatenated face representation $\textbf{x}=[\textbf{x}_{1},\textbf{x}_{2},...,\textbf{x}_{n}]$ along with the corresponding occlusion vector $\textbf{m}=[m_{1},m_{2},..,m_{n}]$.

3.2 Occlusion-guided compact template learning

To obtain a compact template t from the face representations x, where the length of t is at least a magnitude smaller than x, a mapping $\bm{\phi}_{C}$ from the face representations to the low dimensional template space has to be created so that $\textbf{t}=\bm{\phi}^{C}(\textbf{x})$. Some of the previous solutions map x to a low dimensional space with fully connected layers [4], PCA [32, 30, 31] or metric learning [2]. The architecture of these works is summarized in Fig. 3(L). Another solution [24] generates a compact representation $\textbf{t}_{i}$ for each individual $\textbf{x}_{i}$ with individual fully connected layers $\textbf{t}_{i}=\bm{\phi}_{i}^{C}(\textbf{x}_{i})$ and then concatenate them as $\textbf{t}=[\textbf{t}_{1},\textbf{t}_{2}...,\textbf{t}_{n}]$. This architecture is depicted in Fig. 3(R). Assuming a facial representation $\textbf{x}_{i+n}$ is generated from an occluded facial patch which contains identity-irrelevant information, the corresponding template t will be contaminated by the identity-irrelevant information and result in a less discriminative template. Our experiments indicate that the compact templates generated from these architectures are suboptimal for face recognition under large head pose variations.

The role of the occlusion mask: When a facial patch is occluded, it should have zero contribution to the final compact template. One straightforward solution to enforce this constraint is to directly convert the corresponding entries in the compact template space to zero. However, this will increase the intra-class variation when matching a frontal face to a profile face, because the distance between a zero-valued face representation generated from a profile face and a real-valued face representation from a frontal face does not reflect the actual similarity of the two faces. A possible solution proposed in DPRFS is to use m in template matching. The distance $s$ between facial image $a$ and $b$ in DPRFS can be computed as:

[TABLE]

where $\Psi_{i}(\textbf{x}_{i}^{a},\textbf{x}_{i}^{b})$ represents the cosine distance between two face representations $\textbf{x}_{i}^{a}$ and $\textbf{x}_{i}^{b}$. The score $s$ records the average cosine distance of all face representations computed from visible patches. The symbol $\land$ represents the logical conjunction operation.

Despite its robustness to facial occlusion, this method has two limitations: (i) the face retrieval speed is significantly reduced by computing $n$ times the patch-wise distance (once for every pair of patches: $\Psi_{i}(\textbf{x}_{i}^{a},\textbf{x}_{i}^{b})({m_{i}^{a}\land m_{i}^{b}})$). (ii) the templates generated from an image-set are hard to be matched with m because every individual sample in an image set may have a different m. To improve the matching speed and at the same time preserve the discriminative capability of the template in matching two image-sets, it is important to incorporate the occlusion mask in learning the compact template as $\textbf{t}=\bm{\phi}^{C}(\textbf{x},\textbf{m})$, and the distance between image $a$ and $b$ can be computed simply by $s=\Psi(\textbf{t}^{a},\textbf{t}^{b})$.

Co-occurrence information in template learning: To learn a robust and discriminative feature representation for object recognition, encoding of the spatial co-occurrence among features increases the discriminative power of the final feature representation [27]. The term “contextual” is used in [8, 28] to describe the co-occurrence pattern between neighboring features and the authors claim that the contextual information encoded in facial patches enhances the robustness and stableness of face representation. In this paper, we present an approach that encodes the discriminative co-occurrence information in the space of t using the face representations from visible patches.

It is assumed that the $\textbf{x}_{i}$ can be mapped into a co-occurrence space using non-linear projection $\bm{\phi}^{D}_{i}$ with parameters $\bm{\theta}^{D}_{i}$ so that the face representations can be added together and create the t. The reason we employ the addition operation to generate the co-occurrence information is because such an operation will use relatively smaller space than a concatenation operation but is also able to encode the co-occurence information from all the facial representations. To incorporate the information from the occlusion mask, $m_{i}$ is extended to be a vector that has the same length as x, denoted as $\textbf{m}_{i}$. Element values in $\textbf{m}_{i}$ simply repeat the value of $m_{i}$. Here are the equations to compute t:

[TABLE]

where the non-linear mapping $\bm{\phi}^{D}_{i}$ transforms a face representation to a compact space. The mapping $\bm{\phi}^{N}_{i}$ indicates a normalization function to improve the convergence during optimization. The parameters optimized in training are $(\bm{\theta}^{D}_{i},\bm{\theta}^{N}_{i})$. By using occlusion masks in template construction, the impact of an occluded patch to the output template would be a constant vector. The constant vector is invariant to the non-discriminative information encoded in the occluded patch since the information flow from the occluded patch is completely blocked in OGCTL. As a result, the identity irrelevant variations caused by the occluded patches are controlled and upper bounded. In the implementation, a two-layer fully connected network is employed with a bottleneck hidden layer and PreLU [11] activation function to be the non-linear mapping $\bm{\phi}^{D}_{i}$. Batch normalization [15] is employed to be $\bm{\phi}^{N}_{i}$. The network architecture is depicted in Fig. 4.

A local to global mapping controlled by occlusion mask: In Eq. 2, the mapping $\bm{\phi}^{D}_{i}$ maps a local representation $\textbf{x}_{i}$ to a global representation $\hat{\textbf{t}}_{i}$ so that it can be aggregated with other global representations. Thus, $\hat{\textbf{t}}_{i}$ can be treated as a global guess towards t that is generated from local representation $\textbf{x}_{i}$, and each $\textbf{x}_{i}$ creates an independent guess towards t. When the $i^{th}$ patch is occluded, $\textbf{m}_{i}$ will mask out the invalid information coming from $\bm{\phi}^{D}_{i}(\textbf{x}_{i})$ and block its impact to t.

Magnitude invariant loss function: Because t is a summation over $\hat{\textbf{t}}_{i}$ that come from both visible and occluded patches, the number of occluded patches in Eq. 3 may affect the magnitude of t, denoted as $|\textbf{t}|$. Hence, a loss function that is insensitive to $|\textbf{t}|$ is required because we don’t want the similarity of two samples to depend on the number of patches that are visible. In this work, we select the recently proposed angular softmax loss (A-Softmax) [25] to learn the template embedding t. Let $j$ denote the index of an image, and $y_{j}$ be the ground-truth label of the image. The loss on a training set $\{(\textbf{t}_{j},y_{j})|j\in[1,K]\}$ that contains $K$ samples is defined as:

[TABLE]

where the symbol $\theta_{j,y_{j}}$ denotes the angle between template $\textbf{t}_{j}$ and the projection vector $\textbf{w}_{y_{j}}$ from the $y_{j}$ class. The projection vector w is learned for each class in training, and the projection vectors compose a projection matrix W. The parameter $\omega$ controls the angular margin between classes. Because the decision boundary between class $y_{j}$ and class $c(c\neq y_{j})$ is only determined by $cos(\omega\theta_{j,y_{j}})-cos(\theta_{j,c})$, the decision boundary of A-softmax loss is not sensitive to the magnitude of t.

In summary, A-softmax loss enforces that templates t originated from from the same class have small angular distance, while templates t originated from different classes have large angular distance, regardless the number of visible patches that contribute to t. In testing, since the cosine distance is employed to compute the distance between templates, the magnitude of t will have no impact in face matching. We name this algorithm Occlusion-Guided Compact Template Learning (OGCTL). The training portion is summarized in Alg. 1.

4 Experiments

The proposed algorithms are evaluated on the UHDB31 [22] and IJB-C [26] databases. We selected these databases because they contain large head pose variations and are still considered as challenging face recognition databases. In DPRFS, the threshold of occlusion $\epsilon$ is set to be 0.7. The eight ($n$=8) face representations generated from DPRFS are employed as the input of OGCTL. The number of hidden units in the two fully connected layers $\bm{\phi}^{D}_{i}$ is set to be 64. The $\omega$ in loss functions of OGCTL is set to be four as mentioned in the A-softmax loss paper [25]. ADAM optimizer [20] is used for optimizing the parameters in the networks, it takes 30 epochs to train the network in OGCTL.

UHDB31 database [22]: This database contains 24,255 images from 77 subjects, captured under three illumination and 21 pose variations. The yaw angle variation is up to [math] and the pitch angle variation is up to [math]. In experiments, algorithms are evaluated under all three illuminations (I03, I01, and I05) with image resolution 128 $\times$ 153. Abbreviation “I01” is used to denote the data partition with illumination 01. Partition “I03” is employed for evaluating the baseline models; the best-performing models are selected based on this partition to show the results and are used for the other experiments. The 1:N face identification protocol proposed by Wu et al. [36] is employed for evaluating algorithms on this database. Under this protocol, 77 frontal view images from each subject are selected to be the gallery, other images under different head pose variations are selected to be the probe images.

IJB-C database [26]: This recently released IARPA Janus Benchmarks database is a super-set of IJB-A [21] and IJB-B [35] database where all images and videos were captured from unconstrained environments. It contains 3,531 subjects with 31.3 K still images and 117.5 K frames from 11,779 videos. Models are evaluated on the standard 1:1 verification protocol, where a facial template is generated from a variable number of face images and video frames from different sources. In total, there are 23,124 templates with 19,557 genuine matches and 15.6 M impostor matches.

4.1 Template size in face identification

The objective of the first experiment is to test OGCTL’s performance under different sizes of output template. We change the embedding layers of deep neural networks so that the rank-1 identification performance of each method can be reported with respect to a various sizes of output templates. Multiple template generation algorithms are also compared in this experiment, which are illustrated below.

DPRFS: This baseline is the original implementation of DPRFS [38]. It employs eight ResNet-24 [12] for face recognition. As a reference, the template size of DPRFS is fixed to be the same as in the original implementations [38], which is 16 KB.

A1: This baseline employs one ResNet-24 (has the same number of layers as DPRFS) to directly extract the facial template from an aligned image as [25]. A-Softmax loss (AS) is employed to train the network.

A2: This baseline use the same network as A1 but uses softmax as the loss function.

A3: This baseline first converts face representation of DPRFS to a compact face representation with two fully connected layers (with PreLU activation function), and then concatenates them to be the final template, as depicted in Fig. 3(R). It resembles the network architecture used in [24] but uses AS in learning.

A4: This baseline employs two fully-connected layers to transform the concatenated face representation generated by DPRFS into a compact template, as depicted in Fig. 3(L). It resembles the architecture used in [4].

In Fig. 5(T), it can be observed that OGCTL significantly outperforms architectures A1-A4 in all template size variations, which demonstrates the advantages of OGCTL over other baseline models. Its performance saturates after the template size reaches 1 KB (128 dimensions floating point). Since there is only slight performance difference between the 0.5 KB and 1 KB template, in the following experiments, the 0.5 KB template generated by OGCTL is employed as the standard output of OGCTL.

Template matching speed: With a Intel 6700K CPU, the template matching speed of DPRFS is below 50 K templates per second, the actual matching speed depends on the occlusion pattern of the probe image. The matching speed of OGCTL is more than 1 M templates per second, it is independent from the occlusion pattern of the probe image.

4.2 Test under pose and illumination variations

The objective of the second experiment is to evaluate algorithms’ performance under pose and illumination variations. We employ all three partitions of UHDB31 database, with the notation “I03”, “I01”, and “I05”. Each partition has its own illumination condition. For each partition, the database is further divided into two sub-partitions: C15 and S6. In C15, the yaw angles of facial images are equal or below [math]. C15 contains 15 pose variations. In S6, the yaw angles of facial images are equal to [math]. Thus, S6 contains six pose variations. The average rank-1 identification rate of every pose in each sub-partition is reported in Fig. 5(B). It is observed that the merits of DPRFS over OGCTL manifest themselves in the normal illumination condition (I03). In addition, we report the performance of Arcface [3] in Fig. 5(B), which uses a single ResNet-50 network to generate 2 KB template. It can be observed that Arcface performs better than DPRFS in C15 partition but outperforms by DPRFS in S9 partition (except I05). This experiment demonstrated that the ensemble network-based model (DPRFS) holds its merit when the pose variation is large.

To boost the performance of OGCTL further under challenging illumination and pose variations, we merge the template of DPRFS and Arcface but preserving the output template size. Specifically, every face representation $\textbf{x}_{i}$ of DPRFS is concatenated with the template of Arcface and then feed into the network of OGCTL. This method is named OGCTL+. From Fig 5(B), it is observed that OGCTL+ performs significantly better than OGCTL under large head pose variations with challenging illumination conditions. This experimental result demonstrated that the OGCTL is able to take advantage of the templates from both ensemble network model and a well-trained single network to generate a compact template for unconstrained face recognition.

4.3 Image-set based face verification

The objective of the third experiment is to further examine the performance of OGCTL and its generalization in compact template construction. In this experiment, we evaluated the algorithms presented under the challenging IJB-C database. The widely adopted average pooling operation [34, 38, 26] is used to merge the templates from different persons into a single template for verification. The result is shown in Table 1. Baselines were cited from the original IJB-C benchmark [26]. It can be observed from Table 1 that with a relatively small template size and a small training database, OGCTL is able to achieve improved performance than baselines that trained with a larger database with increased template size. Compared to DPRFS, because the occlusion mask is encoded in the template construction process of OGCTL, the average pooling operation only work on the discriminative co-occurrence information encoded in the visible patches, which results in a more discriminative template. Compared to OGCTL, the template of OGCTL+ are constructed based on both DPRFS and Arcface. It outperforms Arcface in terms of AUC, achieves new state-of-the-art performance, but with only 0.5 KB template size.

4.4 Ablation study

The objective of the fourth experiment is to analyze the usefulness of each proposed module in OGCTL and examine the unique properties of the template generated by OGCTL. The experiment is conducted on the UHDB31 database “I03” partition. We select the Pose #20 to report the face identification performance. The probe images in Pose #20 contain profile faces whose yaw variation is equal to [math]. Gallery images are all frontal faces. The template generated by OGCTL is compared to DPRFS and A3. The A3 is selected because it can be regarded as an learning algorithm without using the occlusion mask. We also compare an application of OGCTL without A-softmax loss but using softmax loss in learning. This baseline is denoted as OGCTL-S. The results are depicted in Table 2.

The methods are compared under two experimental settings. In the first setting, the facial templates of both gallery and probe are constructed from the three visible patches as probe. In the second setting, the templates of gallery are constructed from all the eight visible patches but the templates of probe are constructed from three visible patches. The comparison between A3 and OGCTL highlights that the occlusion-guided element adding operation in OGCTL significantly improves the discriminative capability of the face template. The comparison between OGCTL-AS and OGCTL highlights that the A-softmax loss is essential in preserving the cosine distance after element adding operation. The comparison between DPRFS and OGCTL demonstrated that OGCTL is able to generate a template from different number of facial patches, taking into account the co-occurrence information between patches but preserving the compactness of the output template.

5 Conclusion

We presented OGCTL - an algorithm to construct a compact facial template based on the output of ensemble deep network models for efficient storage and fast face retrieval. The compact template integrates the face representations of visible facial patches through the proposed occlusion-guided compact template learning approach. The proposed algorithm provides a solution to generate reduced sized template with similar or better face recognition performance from ensemble networks.

6 Acknowledgment

This material is based upon work supported by the U.S. Department of Homeland Security under Grant Award Number 2017-ST-BTI-0001-0201. This grant is awarded to the Borders, Trade, and Immigration (BTI) Institute: A DHS Center of Excellence led by the University of Houston, and includes support for the project “EDGE” awarded to the University of Houston. The views and conclusions contained in this document are those of the authors and should not be interpreted as necessarily representing the official policies, either expressed or implied, of the U.S. Department of Homeland Security.