Does Generative Face Completion Help Face Recognition?

TL;DR

This paper investigates whether generative face completion can enhance face recognition accuracy under occlusions by restoring occluded facial regions, demonstrating partial success in improving recognition performance.

Contribution

It introduces a face completion encoder-decoder trained on occluded faces and systematically evaluates its impact on recognition with realistic occlusion simulations.

Findings

Face completion improves recognition accuracy on occluded faces.

The method performs well on LFW and LFW-BLUFR datasets.

Occlusion removal via face completion partially restores face perception.

Abstract

Face occlusions, covering either the majority or discriminative parts of the face, can break facial perception and produce a drastic loss of information. Biometric systems such as recent deep face recognition models are not immune to obstructions or other objects covering parts of the face. While most of the current face recognition methods are not optimized to handle occlusions, there have been a few attempts to improve robustness directly in the training stage. Unlike those, we propose to study the effect of generative face completion on the recognition. We offer a face completion encoder-decoder, based on a convolutional operator with a gating mechanism, trained with an ample set of face occlusions. To systematically evaluate the impact of realistic occlusions on recognition, we propose to play the occlusion game: we render 3D objects onto different face parts, providing precious knowledge of what the impact is of effectively removing those occlusions. Extensive experiments on the Labeled Faces in the Wild (LFW), and its more difficult variant LFW-BLUFR, testify that face completion is able to partially restore face perception in machine vision systems for improved recognition.

Tables

Table 1. Table 1 : Ablation study on LFW BLUFR - identification: the use of different gating mechanism along with the effect of global and local discriminator. The results are reported on the ten splits as μ − σ 𝜇 𝜎 \mu-\sigma using ResFace101  [ 28 ] .

			DIR%@
Method	Global	Local	FAR=100%	FAR=10%	FAR=1%	FAR=0.1%
Baseline	–	–	97.28	93.76	82.69	43.64
Sunglasses Occ.	–	–	84.43	67.99	41.79	17.58
U-Net	✓	–	88.85	77.39	54.37	18.12
Gated U-Net	✓	–	89.49	77.21	54.70	19.04
Partial U-Net	✓	–	89.70	78.50	57.78	23.00
Partial U-Net	✓	✓	89.68	78.33	56.48	25.16

Table 2. Table 2 : Playing the occlusion game on LFW verification. Results for different occlusions and the effect of face completion.

Method	1-EER	Acc.	AUC		1-EER	Acc.	AUC
	ResFace101 [28]			VGGFace2 [3]
Baseline	99.43$\pm$.4	99.28$\pm$.4	99.96$\pm$.1		98.37$\pm$.6	98.25$\pm$.5	99.71$\pm$.1
Microphone
Occl.	98.90$\pm$.5	98.85$\pm$.4	99.88$\pm$.1		97.63$\pm$.6	97.68$\pm$.5	99.53$\pm$.3
Compl.	98.93$\pm$.6	99.08$\pm$.5	99.88$\pm$.1		97.77$\pm$.7	97.87$\pm$.6	99.68$\pm$.2
Hands
Occl.	95.66$\pm$.9	96.05$\pm$.7	98.49$\pm$.5		92.53$\pm$1.	93.10$\pm$1.	96.94$\pm$.8
Compl.	97.00$\pm$1.	97.23$\pm$.7	99.18$\pm$.5		95.13$\pm$1.	95.53$\pm$.9	98.56$\pm$.5
Sunglasses
Occl.	96.90$\pm$.9	96.95$\pm$.9	99.19$\pm$.4		92.60$\pm$1.	92.88$\pm$.9	97.36$\pm$.4
Compl.	97.37$\pm$.7	97.47$\pm$.6	99.36$\pm$.4		94.77$\pm$1.	95.12$\pm$.7	98.63$\pm$.5
Cap
Occl.	94.93$\pm$.4	95.25$\pm$.5	98.31$\pm$.3		91.33$\pm$1.	91.82$\pm$.6	96.44$\pm$.7
Compl.	93.40$\pm$1.	93.62$\pm$1.	97.45$\pm$.7		91.70$\pm$2.	92.37$\pm$.9	96.96$\pm$.8

Equations

$$\mathop{\mathbb{E}}_{\tilde{{y}}\sim\mathbb{P}_{g}}[\phi_{D}\big{(}\tilde{\mathbf{y}}\big{)}]-\mathop{\mathbb{E}}_{y\sim\mathbb{P}_{r}}[\phi_{D}\big{(}\mathbf{y}\big{)}]+\\ +\lambda\mathop{\mathbb{E}}_{\hat{{y}}\sim\mathbb{P}_{\hat{{y}}}}[\big{(}\parallel\Delta_{\hat{\mathbf{y}}}\phi_{D}\big{(}\hat{\mathbf{y}}\big{)}\parallel_{2}-1\big{)}^{2}]$$

$$\mathbf{x}^{\prime}=\mathbf{w}_{f}~{}\mathbf{x}^{T}\odot\sigma\big{(}\mathbf{w}_{g}~{}\mathbf{x}^{T}\big{)}~{}~{}\text{with}~{}~{}\sigma\in[0..1]$$

Full text

††footnotetext: * indicates equal contribution

1 Introduction

Facial occlusions, whether for the majority of the face or only a few discriminative regions, alter the perception of the face and cause a drastic loss of information. Biometric systems, such as presentation attack detection (i.e. anti-spoofing) methods [26, 20] and face recognition systems  [37, 3] are not immune to those occlusions. Common objects, such as sunglasses, hands, microphones, scarves, and hats could be purposely placed onto the face by a malicious attacker, producing occlusions with the intent of impairing the biometric system, possibly leading to significant performance degradation, unwanted authentications or spoofing attacks.

The biometrics and vision communities have made significant efforts to develop robust occlusion-resistant face analysis algorithms such as landmark detectors resilient to partial occlusions [2, 10, 47], or face detection networks with occlusion-aware loss functions [30]. However, less emphasis has been given to studying the impact of occlusions on recognition systems. Similarly, face occlusions, and their ultimate effect on face recognition, are often unexplored in the biometric community. This issue calls for biometric methods that are in principle robust to occlusions, or at least aware of malicious occlusions, when they happen. In light of this, there have been a few attempts to directly improve face recognition robustness — either by designing hand-crafted features that inhibit the occlusions in the feature space [19, 27] or by using attention mechanisms to guide the training of convolutional neural networks to avoid occlusions  [41]. Other attempts employed stacked denoising autoencoders for restoring the masked face parts [48, 7].

Unlike previously mentioned methods, we take an orthogonal approach to handle face occlusions: instead of optimizing a face recognition network for occlusion robustness, we leverage deep face completion networks  [22, 16], and conduct a novel study on the effect of generative face completion — also known as face inpainting — on the performance of state-of-the-art face recognition systems, as illustrated in Figure 1. In doing so, we attempt answering the following questions: (1) how does a generative face completion result interact with the performance of a deep face recognition pipeline? (2) Referring to Figure 1, does the scenario (b) provide substantial improvement over (a)? (3) What is the quantitative performance difference of diverse occluding objects and by how much is the inpainter able to cope with them? Furthermore, unlike previous work, we make an effort to factor out the impact of occlusions produced by a diverse set of realistic objects, without just using rectangles unrealistically synthesized on the face. We argue that this latter form of occlusion (i.e. rectangular occlusions) is rather too simple to find in real scenarios, and hence, studies conducted on this type of occlusions might be too unrealistic for drawing conclusions. Finally, we provide a systematic and rigorous evaluation pipeline tested on public benchmarks of face recognition in the wild. Since it has recently been demonstrated that Labeled Faces in the Wild (LFW) verification performance has been saturated [37], we further extend our study to the more difficult variant, LFW Benchmark of Large-scale Unconstrained Face Recognition (BLUFR) [23]. Experimental evaluation verifies that face completion partially restores face perception of machine vision systems for improved recognition under mild occlusions, though exhibits less benefits for strong occlusions on the image boundary. Technically we focus on an effective face completion network and novel evaluation framework to study the impact of occlusions on faces in-the-wild.

This paper has three main contributions. First, we offer an effective face completion encoder-decoder that inpaints real object occlusions (not just rectangles) and deals with holes on discriminative parts of the face. The encoder-decoder is trained with an abundant set of diverse masks based on both regular and irregular occlusions, tailored to the face domain. To propagate the semantics of the generated masks to the entire network all the way down to the final loss, we study the effects of convolutions along with a gating mechanism [25, 9, 46]. Second, we propose to “play the occlusion game,” which means to realistically cover discriminative parts of the face with synthetic yet realistic objects through a rendering mechanism and register recognition performance before and after face completion. Third, despite recent work on deep face inpainting [22, 6, 50, 44], to the best of our knowledge we are the first to quantitatively test its role in a biometric system. To enable reproducibility of our results,we publicly release our code and models111Available at github.com/isi-vista/face-completion.

The paper is organized as follows. In Section 2 we review recent work on face completion, general-purpose inpainting, and finally occlusion-robust face recognition. Section 3 introduces our encoder-decoder for face completion in-the-wild. We explain the evaluation framework along with gained insights from the results in Section 4. We draw conclusions and discuss future work in Section 5.

2 Related Work

Face Completion — Generally speaking, to solve the face completion task, a generative network is trained with paired occluded and unoccluded faces. Previous face completion methods include an encoder-decoder architecture to hallucinate the occluded face part [22]. The system is trained with naïve synthetic occlusions (square masks), and uses global and local adversarial losses [16] along with a face-parsing loss to enforce face symmetry in the reconstruction. While the previous method works with tiny input faces (64 or 128 pixels), a recent method applied progressive growing GAN for high-resolution face completion [6] showing stunning high-resolution results. Zhao et al. [50] fills occluded parts under large occlusions and pose variations, often occurring when wearing VR/AR devices. The system uses an identity loss for preserving characteristic traits of the individual in the reconstructed face. Song et al. [35] designed a network to estimate the coarse geometry of the face, which is then used to condition the generator, which in turn disentangles the mask from the completed face image.

Inpainting — Iizuka et al. [16] proposed both local and global adversarial loss function for effective scene inpainting. These two losses ensure local and global realism of the reconstructed image. Liu et al. [25] uses partial convolutions for the inpainting problem to handle irregular masks. Though partial convolutions were first introduced in [24], and also used as attention masks in [14], they propose a novel update scheme for the mask that is partially reduced and propagated in subsequent deeper layers. While learning-based methods need information about the mask at training time, it is noteworthy to mention the work in [44], which first trains a GAN to learn to generate from the real, unoccluded face appearance distribution. Then, given the learned manifold embedding, the method searches for the closest encoding given the corrupted input, using context and prior losses. The retrieved encoding is then passed through the decoder to recover the occluded content.

Face Recognition — Face analysis is an essential branch of computer vision, with different tasks falling under its broad scope, with work dating back to the sixties [1]. Recently, face recognition made a performance leap through the application of deep convolutional neural networks trained on huge, labeled training sets [31] or with unique models that bundle all the face-related tasks into a single solution using multi-task learning [33]. In recent years, while a plethora of advanced methods has been proposed to push the frontiers of recognition, much less attention has been given to particular face pairs that can fool machines [21] or to understanding which type of occlusions negatively affect a system. Despite over half a decade of deep face recognition [36, 37], there are still efforts to unravel how and why these models perform predictions, thereby understanding which visual facial cues stimulate certain activations in a neural network [4]. Previous work attempted to directly improve face recognition robustness to occlusions by designing hand-crafted features (such as local binary patterns) that inhibit the non-face part in the feature space [19, 27]. The same concept is later used for designing a convolutional network that learns attention masks to avoid computing convolution responses under the occluded parts [41, 39]. Other approaches have employed stacked denoising autoencoders for restoring the masked face parts [17, 48, 7].

3 Encoder-Decoder for Face Completion

A key component for developing an effective face inpainter relies on having a clean (i.e. unoccluded) face dataset that can be used as a basis set for generating synthetic face occlusions for learning the face completion task. However, harvesting faces in the wild does not satisfy this requirement since those could be contaminated by occlusions and other obstructions. In order to properly supervise the proposed face completion encoder-decoder, we leverage large face collections borrowed from the face recognition community, where data is abundant. We used images from CASIA WebFaces [45], VGG Faces [31] and MS-Celeb-1M [13] datasets for training the encoder-decoder inpainter. To mitigate the presence of occlusions, we initially run a face detector [43] and retain a face image for training if and only if the face detector is highly confident of its prediction (confidence $\geq 0.985$). This process leads to a training data of 197,081 clean images, while maintaining most of the tough variability present in the original data sets. Another 21,121 validation images are used for hyperparameter tuning. Faces are aligned by expanding the detector box into a square from its center to compensate for scale and translation.

3.1 Occlusion Mask Synthesis

The encoder-decoder is trained with different masks covering the face, of both regular and irregular shapes. We tailored the training occlusion masks to the face domain by proposing different occlusions: given a 128$\times$128 input face image, it is obstructed by regular square crops of 50 pixels expanded from a fiducial point randomly sampled from detected landmarks on the face, as shown in Figure 2 (2(a)); irregular landmark-based masks defined by connecting different landmarks. These masks are sampled from a pool of predefined combinations of landmarks, often occluding sensible parts of the face — eyes, nose, mouth as reported in Figure 2 (2(b)); random-walk masks usually used in face editing applications [25] — less relevant here but still useful for providing irregular patterns, see Figure 2 (2(c)); masks on the boundaries as depicted in Figure 2 (2(d)); holes and eroded crops depicted respectively in Figure 2 (2(e)) and Figure 2 (2(f)). Landmarks are generated following the head pose estimation method [5], projecting 3D landmarks of a generic model onto the face image. Though these landmarks are not extremely accurate, they are much more robust than landmark detectors, and their accuracy is enough to effectively generate the occlusions in the wild, shown in Figure 2.

3.2 Inpainting Network and Gated Convolution

We used an encoder-decoder based on the U-Net architecture [18], but without using skip connections, and using convolutions with a gating mechanism along with substantial modification described below. In particular, we experiment with two different ways to implement gated convolutions — hard gating mechanism, also known as partial convolution [25], and the soft version based on a sigmoid function  [9, 46]. Our architecture consists of a generator $\phi_{G}$ and two discriminators: a patch-based local discriminator $\phi_{D_{l}}$ and a global, holistic $\phi_{D_{g}}$. The discriminators are only used at training time to enforce realism of the generated data, and are discarded at test time.

Encoder-Decoder Architecture: The encoder consists of four blocks of convolutions with a gating mechanism, increasing the feature depth up to 256. After that, we have another four encoding blocks but with dilation equal to two. We do not use any pooling layers, and the spatial dimensionality of feature maps is reduced by striding. The decoder has the inverse structure of the encoder but uses nearest neighbour interpolation layers to up-sample the feature maps. We use upsampling instead of deconvolution to prevent checkerboard artifacts. A regular convolutional layer and hyperbolic tangent operator are used to synthesize the completed face image.

Training: We train all our models with $\ell_{1}$ reconstruction loss along with two adversarial losses using two discriminators $\phi_{D_{l}}$ and $\phi_{D_{g}}$. The global adversarial loss used is the improved Wasserstein loss [12] with gradient penalty, as shown in Equation (1):

[TABLE]

where $\tilde{\mathbf{y}}\doteq\phi_{G}(\mathbf{x})$ is a generated sample, $\mathbf{y}$ indicates a real image, and $\hat{\mathbf{y}}$ is an interpolated sample between generated and real as mentioned in [12]. The patch-based discriminator follows [18] which restricts the attention to the structure in local image patches and classifies each patch as real or fake. Empirically, we have found that a patch discriminator with receptive field size of 50$\times$50 pixels in the input image produces realistic facial features. To stabilize the training of the discriminators along with the generator, we increase the learning rate of the generator more than that of the discriminators. This is different than the regular policy that updates the generator more than the discriminator. The learning rate schedule follows roughly the cycle learning rate process mentioned in [34].

3.2.1 Gating Mechanism

To shed some light on the the idea of conditioning the convolutional operator to avoid the occluded area, we perform ablations for different convolutional gating mechanisms. In particular, we implemented the state-of-the-art hard gating mechanism based on partial convolution [25]. Additionally, we compare it against its softer version that uses a sigmoid function to dynamically avoid the masked region.

Hard Gating: Partial convolutions have been recently used in editing application for face completion in [25]. Here we test their effect in biometrics, where it is usually tougher for face completion since the inpainter needs to deal with low resolution images or images with harsh image quality. The idea is that the mask, fed as input to the network, is used to hardly gate the response of the convolutional operator, so that this latter does not take into account occluded pixels. Further details are given in [25]. Partial U-Net is the model using partial convolutions.

Soft Gating: Extending the previous concept, we changed the gating mechanism from a hard decision [25] to a soft gating function [9, 46]. This acts as a softer version of the partial convolution to learn rich features optimized for face completion. The idea behind soft gating is that the input tensor $~{}\mathbf{x}$ — which can be in the first layer the input image alone or concatenated with the mask — is processed by two sets of convolutional filters: regular filters $\mathbf{w}_{f}$ and gating filters $\mathbf{w}_{g}$; the latter are learned with a sigmoid function, acting as a soft-mask gating function. As described in Equation (2), the output feature map $\mathbf{x}^{\prime}$ is then obtained as

[TABLE]

where $\odot$ represents the Hadamard product. Nonlinear activations based on Elu [8] are used after convolution $\mathbf{w}_{g}$. The output feature map $\mathbf{x}^{\prime}$ is normalized using instance normalization [40]. Gated U-Net uses gated convolutions of Equation (2) in all the layers222Gated convolutions by definition of Equation (2) double the number of parameters in a model since they require twice of convolutional filters..

4 Experimental Evaluation

In this section we show what the effect is of meaningful occlusions with common objects that an intruder could use to fool a biometric system. We quantitatively asses the effect that generative face completion has on the recognition module to check at what extent it is possible to recover the lost information. To this end, we used face imagery from Labeled Faces in the Wild (LFW [15]) and evaluate this on the standard 6,000 LFW verification pairs; we further test it on its much harder variant LFW-BLUFR [23] for open-set identification, testifying that face completion is able to partially restore face perception in machine vision systems under mild occlusions.

4.1 Occlusion Testing Pipeline

In order to quantitatively measure the effect of face completion on recognition and control the side effects of face obstruction, we employed a synthetic yet realistic data rendering mechanism to add occlusions to an input face image. In contrast to previous work [41] that evaluates the effect of occlusion only with square masks or that synthesize occlusions in 2D on frontal faces [49], we offer a broader study with semantic occlusions of common obstructing objects properly places on the face (sunglasses, eyeglasses, microphones, etc.) through a robust 3D rendering mechanism described below. Note that all the introduced occlusions are rendered on top of the occlusion naturally contained in the set. We defer the detection of those natural occlusions as an immediate future work (more on this in Section 5).

Realistic Occlusion Synthesis: Inspired by domain randomization [38], we use a pool of 3D models along with their texture to render different objects onto a subject’s face to measure their disruptive effect. Figure 3 shows a few examples without their texture along with the generic model, that is instead not rendered on the image. The same figure presents a few occlusions transferred onto the face images. In contrast to simply covering the face with square crops, our mechanism challenges the biometric recognition system by injecting occlusions similar to those of real scenarios. Our occlusions are rendered following the natural expected depth of objects—e.g. hands are farthest from the face, followed by caps, sunglasses and so on. In total we used twelve models of sunglasses, eyeglasses, microphone, hands, and cap or hats. This initial seed set is further expanded similarly to data augmentation but randomly sampling for plausible 3D variations in scale $s$, 3D rotation $R\in\mathbb{R}^{3}$, and translation $t\in\mathbb{R}^{3}$. The texture of the objects is also randomly changed. Finally, the 3D pose of the 3D generic model respect to the face image is estimated using [5] and then used to render the object and register its occlusion mask.

Face Recognition Engine: We employ two state-of-the-art face recognition engines as a proxy to measure the impact of face completion to the final recognition accuracy. We use two engines  [28, 3] to minimize the bias towards a particular recognition method. We emphasize that we used on purpose off-the-shelf recognition networks trained for the generic face recognition task, not explicitly optimized to deal with occlusions. This better motivates our work and put all the burden on our face completion network, better isolating its impact. The first recognition network is a ResNet-101 trained with face-specific data augmentation [28]; we further experiment with the very recent VGGFace2 [3].

Face Recognition Pipeline: Faces are detected following [43]. We also used FacePoseNet (FPN) [5] to compute the 3D pose of each face yet aligning the faces with a simple 2D similarity transform to a reference face template. To deal with profile faces, we used a different coordinate system for frontal faces and profile faces. We should note that we apply the same preprocessing to both encoders, thus VGGFace2 is not optimized to this preprocessing step. For both of the two encoders, faces are represented using the response of the layer prior the classification layer. The learned embedding is refined using principal component analysis (PCA) learned on each training split of the tested benchmarks. Power normalization is applied to the feature after projecting them with PCA. Given an input face, the final representation is the result of average-pooling the 2D aligned face and its horizontal flip. Face encodings are compared with cosine similarity.

4.2 Ablation Study

We conducted an ablation study using different gating mechanisms compared to classic convolutions. To the best of our knowledge, convolutions with soft gating are not popular for inpainting with the only exception of [46]. Though  [46] reports improvement over classic convolution, it is instructive to study their generalization ability in the wild and compare it with the hard gating of [25].

In order to marginalize out the effect of gating on the results, we also trained another model with the same architecture of the Gated U-Net yet with classic convolutions. In addition, we used the same encoder-decoder but replaced soft gating with partial convolution. We strove to deliver a fair comparison and trained the model for the same amount of time. Note that all the models tested are not trained with the occlusions simulated at test time.

Is gating necessary for training? Figure 4 shows an ablation study from our validation set with multiple masks unseen in training. At a glance it can be noticed that Equation (2) helps the face completion task especially for difficult parts such as the eyes and the eyebrows as evident from Figure 4, when compared with simple convolutions. Interestingly, though the Gated U-Net contains more parameters, Partial U-Net delivers the best result. This supports our choice for involving a gating mechanism in the convolutional operator, with hard gating preferable over soft gating. The results with gating are in general overwhelmingly better than regular convolutions. We do observe a reduction on the amount of artifacts in the generated image that better restores the face manifold. Additionally, in Figure 4, all models use $\phi_{D_{g}}$. A marginal improvement is noticeable with the use of a local discriminator $\phi_{D_{l}}$. Importantly, although here we show occlusion masks marked with white, the face recognition system is actually tested with realistic occlusions, as shown in Figure 3.

We conclude that, in general, we can see that the gating mechanism helps the inpainting task better — soft gating is better than simple convolution, though better results can be obtained with the hard gating implemented through partial convolution. Table 1 further supports this claim. We conducted a face recognition experiment on LFW-BLUFR identification protocol injecting realistic sunglasses occlusions following Section 4.1. We performed this test with this type of occlusion since we know from recent studies [4], aimed at understanding deep face recognition, that these models are very sensitive about the eye region. Our baseline recognition system obtains numbers near those of recently published systems [42]. Table 1 too proves the effectiveness of gating. The table shows the DIR (Detection and Identification Rate) at multiple False Positive Rates (FAR) [32]: though occlusions cause a drop in recognition, the encoder-decoder trained with the gating mechanism better restores the missing content, thereby improving face recognition accuracy. The recognition accuracy at rank-1, that in this case corresponds to DIR@FAR=100%, is increased by 5%. Significant improvement at very low FAR is provided by Partial U-Net. Performance is further increased with the local discriminator.

4.3 Playing the Occlusion Game

Following the takeaways of Section 4.2, we quantitatively assess the effect of occlusions on a biometric face recognition system. We test if our best inpainter (Partial U-Net trained with two discriminators) can aid the recognition under occlusions. The bottom line idea is to simulate an intruder with the intent of fooling a recognition system so to avoid being recognized. This could be common in scenarios in which a system keeps a watch-list of people to be monitored; the attacker may try to pass through the identification system occluding his face with multiple objects. To perform a constructive study and control possible side effects, we propose “to play the occlusion game” which means realistically synthesizing plausible objects onto the face (Section 4.1) and observing the expected drop in recognition. This quantifies which parts of the face are more important for recognition and then evaluates if and how a generative face completion method helps to restore the lost information, thereby improving over possible obfuscations. We report results of verification performance of the two different recognition engines (Section 4.1). Although we used different recognition systems, the takeaways from our study are consistent: in general, face completion helps restoring the lost information thereby improving recognition under mild occlusions; nevertheless the improvement is drastically reduced for boundary occlusions caused by hats or caps. The reason for this could be related to how the face completion system is trained with synthetic occlusion masks or simply because the majority of the face content is lost. Table 2 reports the results for LFW verification, supporting our findings. In order to challenge our experimental evaluation even more, we also offer the same study on the much harder LFW-BLUFR protocol for open-set identification, occluding only the probe set: this protocol fits best our setting since half of the probes is contained in the gallery (watch-list) while the other half is not: thus it provides a more general experimentation typically found in real scenarios. Table 1 and Figure 5 show the DIR versus FAR [32] following the evaluation protocol for open-set recognition [23]. Figure 5 supports the fact that generative face completion is beneficial for recognition for mild occlusions, such as those caused by sunglasses and eyeglasses; a small improvement at low FAR is reported for microphones, hands and hats.

5 Conclusion and Future Work

In this paper we shed some light on the interactions between occlusions, inpainting and a biometric recognition system. We answered the questions that were raised in the title and Section 1. Face completion seems beneficial for a biometric system, assuming that the occlusion can be detected effectively. On the other hand, for boundary occlusions, its contribution is minimal. As future work we will seek for a complete system to jointly detect and complete occlusions. We will train the inpainter with occlusion masks transferred from a face segmentation method [29] and apply the latter to detect occlusions. Another interesting piece of future work is to employ a face verification loss to preserve the identity of the subject and to perform a thorough evaluation of completion algorithms.

6 Appendix

Inpainter Network Architecture Details (addendum to Section 3.2)

Encoder-Decoder: Our base encoder-decoder is inspired by U-Net from [18] but without skip connections. The input to the network is a 128$\times$128$\times$3 image concatenated with the mask along the channel dimension. Depending on the model type, we replace regular convolution (U-Net) with partial convolution (Partial U-Net) or gated convolution (Gated U-Net). The feature map size is decreased only using striding (i.e., without pooling layers). The architecture of the encoder-decoder is shown in Figure 6. Each convolutional layer is followed by Exponential Linear Unit (ELUs) activations. The output feature map is normalized using instance normalization [40]. The convolutional filters are initialized with the method [11]; biases are initialized with a constant value of 0.0. Finally, the last decoding block has a regular convolutional layer and a hyperbolic tangent layer that map back to an output of dimension 128$\times$128$\times$3. We used the same architecture for all the ablation study with the exception of replacing regular convolution with partial or gated convolution. In Figure 6, “X-Conv” indicates a placeholder for one among the three convolutions $\mathtt{\{regular,partial,gated\}}$. The legend for the blocks in Figure 6 is as follows: $\mathtt{X-Conv3x3,256,1}$ indicates convolutional filters with kernel 3x3, an output with 256 channels and stride equal to 1.

Discriminators: The discriminators used in training are shown in Figure 7. Unlike the generator, these two discriminators use always regular convolutions. After convolutions, LeakyReLU is used as activation. The patch-based discriminator is designed to yield a 50x50 receptive field in the input image. The legend for the blocks in Figure 7 is as follows: $\mathtt{Conv3x3,521,2,1}$ indicates convolutional filters with kernel 3x3, an output with 512 channels, stride equal to 2, and a padding of 1.

Acknowledgements:

This research is based upon work supported by the Office of the Director of National Intelligence (ODNI), Intelligence Advanced Research Projects Activity (IARPA), via IARPA R&D Contract No. 2017-17020200005. The views and conclusions contained herein are those of the authors and should not be interpreted as necessarily representing the official policies or endorsements, either expressed or implied, of the ODNI, IARPA, or the U.S. Government. The U.S. Government is authorized to reproduce and distribute reprints for Governmental purposes notwithstanding any copyright annotation thereon.