Deblurring Face Images using Uncertainty Guided Multi-Stream Semantic Networks

TL;DR

This paper introduces a multi-stream neural network that leverages semantic face labels and confidence measures to improve the quality of deblurred face images, outperforming existing methods.

Contribution

The novel Uncertainty Guided Multi-Stream Semantic Network (UMSN) utilizes semantic segmentation and confidence-guided training for enhanced face deblurring.

Findings

Significant improvements over state-of-the-art face deblurring methods.

Effective handling of challenging facial regions like eyes and nose.

End-to-end training framework for semantic-guided deblurring.

Abstract

We propose a novel multi-stream architecture and training methodology that exploits semantic labels for facial image deblurring. The proposed Uncertainty Guided Multi- Stream Semantic Network (UMSN) processes regions belonging to each semantic class independently and learns to combine their outputs into the final deblurred result. Pixel-wise semantic labels are obtained using a segmentation network. A predicted confidence measure is used during training to guide the network towards the challenging regions of the human face such as the eyes and nose. The entire network is trained in an end- to-end fashion. Comprehensive experiments on three different face datasets demonstrate that the proposed method achieves significant improvements over the recent state-of-the-art face deblurring methods. Code is available at: https://github.com/ rajeevyasarla/UMSN-Face-Deblurring

Tables

Table 1. TABLE I: PSNR and SSIM values for each deblurred semantic class on the CelebA dataset (C) and Hellen dataset (H).

	Method	class-1		class-2		class-3		class-4
		PSNR	SSIM	PSNR	SSIM	PSNR	SSIM	PSNR	SSIM
C	Shen et al.	27.86	0.88	30.27	0.93	33.33	0.92	31.79	0.91
	UMSN	29.27	0.91	30.75	0.95	33.83	0.96	33.10	0.94
H	Shen et al.	29.13	0.85	31.20	0.88	35.13	0.92	33.96	0.88
	UMSN	30.83	0.87	31.76	0.90	35.67	0.93	34.81	0.91

Table 2. TABLE II: F-score values of semantic masks for clean and blurry images from the Helen dataset.

Class	Clean Images	Blurry Images
	S-Net trained on clean images	S-Net trained on clean images	S-Net fine-tuned w/ blurry images
class-1	0.910	0.889	0.901
class-2	0.903	0.877	0.884
class-3	0.856	0.775	0.814
class-4	0.625	0.538	0.566

Table 3. TABLE III: PSNR and SSIM comparision of UMSN against state-of-the-art methods.

Deblurring Method	Helen		CelebA
	PSNR	SSIM	PSNR	SSIM
Krishnan et al.[16] (CVPR’11)	19.30	0.670	18.38	0.672
Pan et al.[30] (ECCV 2014)	20.93	0.727	18.59	0.677
Shan et al.[48] (SIGGRAPH’08)	19.57	0.670	18.43	0.644
Xu et al.[15] (CVPR’13)	20.11	0.711	18.93	0.685
Cho et al.[49] (SIGGRAPH’09)	16.82	0.574	13.03	0.445
Zhong et al.[50] (CVPR’13)	16.41	0.614	17.26	0.695
Nah et al.[9] (CVPR’17)	24.12	0.823	22.43	0.832
Shen et al.[11] (CVPR’18) w/GAN	25.58	0.861	24.34	0.860
Shen et al.[11] (CVPR’18)	25.99	0.871	25.05	0.879
Kupyn et al.[24] (ICCV’19)	26.45	0.880	25.42	0.884
UMSN (ours w/${ℒ}_{total}$)	27.75	0.897	26.62	0.908

Table 4. TABLE IV: comparision of UMSN against state-of-the-art methods using distance of feature from VGG-Face(  d V ​ G ​ G subscript 𝑑 𝑉 𝐺 𝐺 d_{VGG} ), lower is better

Deblurring Method	Helen	CelebA
	$d_{VGG}$	$d_{VGG}$
Xu et al.[15] (CVPR’13)	10.15	11.38
Zhong et al.[50] (CVPR’13)	12.28	14.72
Nah et al.[9] (CVPR’17)	7.46	8.92
Shen et al.[11] (CVPR’18)	5.87	6.49
Kupyn et al.[24] (ICCV’19)	4.91	5.84
UMSN (ours w/${ℒ}_{total}$)	2.69	2.85

Table 5. TABLE V: Top-1, Top-3 and Top-5 face recognition accuracies on the CelebA dataset.

Deblurring Method	Top-1	Top-3	Top-5
Clear images	71%	84%	89%
Blurred images	31%	46%	53%
Pan et al.[30] (ECCV 2014)	44%	57%	64%
Xu et al.[15] (CVPR’13)	43%	57%	64%
Zhong et al.[50] (CVPR’13)	30%	44%	51%
Nah et al.[9] (CVPR’17)	42%	59%	65%
Shen et al.[11] (CVPR’18)	54%	68%	74%
Kupyn et al.[24] (ICCV’19)	58%	70%	77%
UMSN (ours w/${ℒ}_{total}$)	64%	75%	83%

Table 6. TABLE VI: PSNR and SSIM results of the ablation study.

Deblurring Method	Helen		CelebA
	PSNR	SSIM	PSNR	SSIM
baseline (B-Net)	25.12	0.82	24.38	0.81
+ semantic maps	25.55	0.84	24.72	0.82
+ nested residuals	26.08	0.85	25.26	0.84
UMSN without ${ℒ}_c$	26.96	0.87	25.90	0.87
UMSN	27.75	0.90	26.62	0.91

Table 7. TABLE VII: Confidence values corresponding to Image1 and Image2 in first row and second row images in Fig.  15 , respectively.

Blurry Image	Iteration	$C_1$	$C_2$	$C_3$	$C_4$
Image1	3000	0.573	0.576	0.610	0.584
	50000	0.676	0.902	0.789	0.847
	100000	0.858	0.917	0.989	0.962
Image2	3000	0.519	0.528	0.493	0.611
	50000	0.728	0.883	0.817	0.872
	100000	0.896	0.919	0.966	0.944

Table 8. TABLE VIII: Confidence values for the blurry images generated using Identity1 and Identity2 corresponding to first row and second row images in Fig.  16 , respectively.

Clean image Identity	kernel	$C_1$	$C_2$	$C_3$	$C_4$
Identity1	$17\times 17$	0.923	0.948	0.913	0.973
	$27\times 27$	0.871	0.832	0.848	0.945
Identity2	$17\times 17$	0.874	0.931	0.942	0.945
	$27\times 27$	0.817	0.844	0.869	0.880

Equations

$$y=k\ast x+\eta ,$$

$$\hat{\Theta }=\underset{\Theta }{\mathrm{argmin}}\mathcal{L}(f_{\Theta }(y,\hat{m}),x)=\underset{\Theta }{\mathrm{argmin}}\mathcal{L}(\hat{x},x),$$

$$x=\sum _{i=1}^M{m}_i\odot x,$$

$$\hat{\Theta }=\underset{\Theta }{\mathrm{argmin}}\sum _{i=1}^M\mathcal{L}(m_i\odot \hat{x},m_i\odot x).$$

$$\mathcal{L}(\hat{x},x)=\sum _{i=1}^M\mathcal{L}(m_i\odot \hat{x},m_i\odot x).$$

$${\mathcal{L}}_c(\hat{x},x)=\sum _{i=1}^M{C}_i\mathcal{L}(m_i\odot \hat{x},m_i\odot x)-\lambda \log (C_i),$$

$${\mathcal{L}}_p=\Vert \Phi (\hat{x})-\Phi (x){\Vert }_2^2.$$

$${\mathcal{L}}_{total}={\mathcal{L}}_c+{\lambda }_1{\mathcal{L}}_p,$$

Full text

I Introduction

Image deblurring entails the recovery of an unknown true image from a blurry image. Similar to the other image enhancement tasks, image deblurring is experiencing a renaissance as a result of convolutional networks (CNNs) establishing themselves as powerful generative models. Image deblurring is an ill-posed problem and therefore it is crucial to leverage additional properties of the data to successfully recover the lost facial details in the deblurred image. Priors such as sparsity [1, 2, 3], manifold [4], low-rank [5] and patch similarity [6] have been used in the literature to obtain a regularized solution. In recent years, deep learning-based methods have also gained some traction [7, 8, 9, 10].

The inherent semantic structure of natural images such as faces is an important information that can be exploited to improve the deblurring results. Few techniques [12, 11] make use of such prior information in the form of semantic labels. These methods do not account for the class imbalance of semantic maps corresponding to faces. Interior parts of a face like eyes, nose, and mouth are less represented as compared to face skin, hair and background labels. Depending on the pose of the face, some of the interior parts may even disappear. Without re-weighting the importance of less represented semantic regions, the method proposed by Shen et al.[11] fails to reconstruct the eyes and the mouth regions as shown in Fig. 1. Similar observations can also be made regarding the method proposed in [12] (Fig.  1) which uses semantic priors to obtain the intermediate outputs and then performs post-processing using k-nearest neighbor algorithm.

To address the imbalance of different semantic classes, we propose a novel CNN architecture, called Uncertainty guided Multi-stream Semantic Networks (UMSN), which learns class-specific features independently and combine them to deblur the whole face image. Class-specific features are learned by sub-networks trained to reconstruct a single semantic class. We use nested residual learning paths to improve the propagation of semantic features. Additionally, we propose a class-based confidence measure to train the network. The confidence measure describes how well the network is likely to deblur each semantic class. This measure is incorporated in the loss to train the network. We evaluate the proposed network by conducting experiments on three face datasets - Helen [13], CelebA [14] and PuBFig [12]. Extensive experiments demonstrate the effectiveness of our approach compared to a number of well established face deblurring methods as well as other competitive approaches. Fig. 1 shows sample results from our UMSN network, where one can clearly see that UMSN is able to provide better results as compared to the state-of-the-art techniques [11, 12]. An ablation study is also conducted to demonstrate the effectiveness of different parts of the proposed network. To summarize, this paper makes the following contributions:

• •

A novel multi-stream architecture called, Uncertainty Guided Multi-Stream Semantic (UMSN), is proposed which learns class-specific features and uses them to reconstruct the final deblurred image.

• •

We propose a novel method of computing confidence measure for the reconstruction of every class in the deblurred image, which is to rebalance the importance of semantic classes during training.

Rest of the paper is organized as follows. In Section II, we review a few related works. Details of the proposed method are given in Section III. Experimental results are presented in Section IV, and finally, Section V concludes the paper with a brief summary.

II Background and Related Work

Single image deblurring techniques can be divided into two main categories - blind and non-blind. In the non-blind deblurring problem, the blur kernel is assumed to be known while in the blind deblurring problem, the blur kernel needs to be estimated. Since the proposed approach does not assume any knowledge of the blur kernel, it is a blind image deblurring approach. Hence, in this section, we review some recent blind image deblurring techniques proposed in the literature.

Classical image deblurring methods estimate the blur kernel given a blurry image and then apply deconvolution to get the deblurred image. To calculate the blur kernel some techniques assume prior information about the image, and formulate maximum a-posertior (MAP) to obtain the deblurred image. Different priors such sparsity, $L_{0}$ gradient prior, patch prior, manifold Prior, and low-rank have been proposed to obtain regularized reconstructions [15, 1, 16, 5, 2, 17, 6, 4, 3]. Chakrabarti et al.[8] estimate the Fourier coefficients of the blur kernel to deblur the image. Nimisha et al.[7] learn the latent features of the blurry images using the latent features of the clean images to estimate the deblurred image. These CNN-based methods do not perform well compared to the state-of-the-art MAP-based methods for large motion kernels. Recent non-blind image deblurring methods like [18, 19, 2, 20, 21] assume and use some knowledge about the blur kernel. Given the latent blurry input, Subeesh et al.[21] estimate multiple latent images corresponding to different prior strengths to estimate the final deblurred image. CNN-based techniques like [22] and [23] estimate the blur kernel and address dynamic deblurring. Another recent image deblurring method based on Feature Pyramid Network and conditional generative adversarial network (GAN) was recently proposed by Kupyn *et al.*in [24].

The usage of semantic information for image restoration is relatively unexplored. While semantic information has been used for different object classes [25, 26, 27, 28], a substantial body of literature has focused their attention to human faces [29, 11, 30, 31]. Pan et al.[30] extract the edges of face parts and estimate exemplar face images, which are further used as the global prior to estimate the blur kernel. This approach is complex and computationally expensive in estimating the blur kernel. Recently, Shen et al.[11] proposed to use the semantic maps of a face to deblur the image. Furthermore, they introduced the content loss to improve the quality of eyes, nose and mouth regions of the face. Bulat et al. [32] proposed Super-FAN architecture which is an end-to-end network that outputs high-resolution of face, along with heatmap for face alignment. Chen et al. [33] proposed FSRGAN architecture which consists of coarse and fine Super-Resolution (SR) networks where they estimate coarse estimate of high-resolution output image, follwed by fine estimate using Fine SR Network. Yu et al. [34] propose a multi-task network to upsample LR image where they predict face structure along with super-resolving LR face image. Ren et al. [35] proposed a face video deblurring method by predicting facial structure and identity from the blurry face using a deep network that generates a textured 3D face from the video. Textured 3D face mask can be generated accurately only from videos. This method is not beneficial if we have a single face image to deblur. Lu et al. [36] proposed a domain-specific single face image deblurring method by disentangling the content information in an unsupervised fashion using the KL-divergence. In contrast to these methods, we learn a multi-stream network which reconstructs the deblurred images corresponding to different classes in a facial semantic map. Furthermore, we propose a new loss to train the network.

III Proposed Method

A blurry face image $y$ can be modeled as the convolution of a clean image $x$ with a blur kernel $k$, as

[TABLE]

where $*$ denotes the convolution operation and $\eta$ is noise. Given $y$, in blind deblurring, our objective is to estimate the underlying clean face image $x$. We group 11 semantic face labels into 4 classes as follows: $m_{1}=\{background\}$, $m_{2}=\{face\;skin\}$, $m_{3}=\{left\;eyebrow,\;right\,\>eyebrow,\;left\;eye,\;right\;eye,\newline \;nose,\;upper\;lip,\;lower\;lip,\;teeth\}$ and $m_{4}=\{hair\}$. Thus, the semantic class mask of a clean image $x$ is the union $m=m_{1}\cup m_{2}\cup m_{3}\cup m_{4}$. Similarly we define the semantic class masks of a blurry image $\hat{m}$.

Semantic class masks for blurry image, $\hat{m}$ are generated using the semantic segmentation network (S-Net) (Fig. 3), and given together with the blurry image as input to the deblurring network, UMSN. This is important in face deblurring as some parts like face skin and hair are easy to reconstruct, while face parts like eyes, nose, and mouth are difficult to reconstruct and require special attention while deblurring a face image. This is mainly due to the fact that parts like eyes, nose and mouth are small in size and contain high frequency elements compared to the other components. Different from [30] that uses edge information and [11] that feed the semantic map to a single-stream deblurring network, we address this problem by proposing a multi-stream semantic network, in which individual branches F-net-$i$ learn to reconstruct different parts of the face image separately. Fig. 2 gives an overview of the proposed UMSN method.

As can be seen from Fig. 2, the proposed UMSN network consists of two stages. We generate the semantic class maps, $\hat{m}$, of a blurry face image using the S-Net network. The semantic maps are used as the global masks to guide each stream of the first stage network. These semantic class maps $\hat{m}$ are further used to learn class specific residual feature maps with nested residual learning paths (NRL). In the first stage of our network, the weights are learned to deblur the corresponding class of the face image. In the second stage of the network, the outputs from the first stage are fused to learn the residual maps that are added to the blurry image to obtain the final deblurred image. We train the proposed network with a confidence guided class-based loss.

III-A Semantic Segmentation Network (S-Net)

The semantic class maps $\hat{m}_{i}$ of a face, are extracted using the S-Net network as shown in Fig. 3. We use residual blocks (ResBlock) as our building module for the segmentation network. A ResBlock consist of a $1\times 1$ convolution layer, a $3\times 3$ convolution layer and two $3\times 3$ convolution layers with dilation factor of 2 as shown in Fig. 4.

III-B Base Network (B-Net)

We construct our base network using a combination of UNet [38] and DenseNet [39] architectures with the ResBlock as our basic building block. To increase the receptive field size, we introduce smoothed dilation convolutions in the ResBlock as shown in Fig. 4. B-Net is a sequence of eight ResBlocks similar to the first stage semantic network as shown in Fig. 5. Note that all convolutional layers are densely connected [39]. We follow residual-based learning in estimating the deblurred image for our base network as shown in Fig. 5.

III-C UMSN Network

The UMSN network is a two-stage network. The first stage network is designed to obtain deblurred outputs from the semantic class-wise blurry inputs. These outputs are further processed by the second stage network to obtain the final deblurred image. The first stage semantic network contains a sequence of five ResBlocks with residual connections, as shown in Fig. 5. We call the set of all convolution layers of the first stage network excluding the last ResBlock and Conv$3\times 3$ as F-Net.

The blurry image $y$ and the semantic masks $\hat{m}_{i}$ are fed to F-Net-$i$ to obtain the corresponding class-specific deblurred features which are concatenated with the output of the first layer (ResBlock-Avgpool) in Base Network(B-Net) for constructing the UMSN network. We also use the Nested Residual Learning (NRL) in UMSN network where class specific residual feature maps are learned and further used in estimating the residual feature maps that are added to the blurry image for obtaining the final output. For example, we can observe a residual connection between the last layer of UMSN and class-specific feature maps obtained from Conv $1\times 1$ using $y$ and $\hat{m}$. Output of this residual connection is further processed as the input to the residual connection with the input blurry image, $y$. In this way, we define our NRL and obtain the final deblurred image. We propose a class-based loss function to train the UMSN network.

III-D Loss for UMSN

The network parameters $\Theta$ are learned by minimizing a loss $\mathcal{L}$ as follows,

[TABLE]

where $f_{\Theta}(.)$ represents the UMSN network, $\hat{x}$ is the deblurred result, $\hat{m}$ is the semantic map obtained from S-Net. We define the reconstruction loss as $\mathcal{L}=\|x-\hat{x}\|_{1}$. A face image can be expressed as the sum of masked images using the semantic maps as

[TABLE]

where $\odot$ is the element-wise multiplication and $M$ is the total number of semantic maps. As the masks are independent of one another, Eq. (1) can be re-written as,

[TABLE]

In other words, the loss is calculated for every class independently and summed up in order to obtain the overall loss as follows,

[TABLE]

III-E Uncertainty Guidance

We introduce a confidence measure for every class and use it to re-weight the contribution of the loss from each class to the total loss. By introducing a confidence measure and re-weighting the loss, we benefit in two ways. If the network is giving less importance to a particular class by not learning appropriate features of it, then the Confidence Network (CN) helps UMSN to learn those class specific features by estimating low confidence values and higher gradients for those classes through the CN network. Additionally, by re-weighting the contribution of loss from each class, it counters for the imbalances in the error estimation from different classes. The loss function can be written as,

[TABLE]

where $\log(C_{i})$ acts as a regularizer that prevents the value of $C_{i}$ going to zero and $\lambda$ is a constant. We estimate the confidence measure $C_{i}$ for each class by passing $m_{i}\odot\hat{x},m_{i}\odot x$ as inputs to CN as shown in Fig. 6. $C_{i}$ represents how confident UMSN is in deblurring the $i^{th}$ class components of the face image. Note that, $C_{i}$($\in[0,1]$), confidence measure is used only in the loss function while training the weights of UMSN, and it is not used (or estimated) during inference.

Inspired by the benefits of the perceptual loss in style transfer [41, 42] and image super-resolution [43], we use it to train our network. Let $\Phi(.)$ denote the features obtained using the VGG-Face model [44], then the perceptual loss is defined as follows,

[TABLE]

The features from layer $relu1\_2$ of a pretrained VGG-Face network [44] are used to compute the perceptual loss. The total loss used to train UMSN is as follows,

[TABLE]

where $\lambda_{1}$ is a constant.

IV Experimental Results

We evaluate the results using the images provided by the authors of [11] which consists of $8000$ blurry images generated using the Helen dataset [13], and $8000$ blurry images generated using the CelebA dataset [14]111We follow the same training and testing protocols defined by [11].. Furthermore, we test our network on a test dataset called PubFig, provided by the authors of [12] which contains 192 blurry images. We quantitatively evaluate the results using the Peak-Signal-to-Noise Ratio (PSNR) and the Structural Similarity index (SSIM) [45].

IV-A Implementation Details

IV-A1 Segmentation Network

We initially train the S-Net network using the Helen dataset [13] which contains $2000$ clean images with corresponding semantic labels provided by Smith et al.[46]. S-Net is trained using the cross entropy loss with the Adam optimizer and the learning rate is set equal to $0.0002$. We train S-Net for $60000$ iterations on clean images. As can be seen from Fig. 7 and Table II, S-Net trained on clean images only is not able to produce good results on the blurry images. Thus, we fine-tune S-Net using the blurry images and the corresponding semantic maps generated using the Helen dataset [13]. In this case, S-Net is fine-tuned for $30000$ iterations with the learning rate of $0.00001$. We test our S-Net network on $330$ clean Test images provided by the Helen dataset as well as $8000$ blurry images. Results are shown in Fig. 7 and Table II in terms of F-scores. As can be seen from these results, our method is able to produce reasonable segmentation results from blurry images.

IV-A2 UMSN Network

Training images for UMSN are generated using $2000$ images from the Helen dataset [13], and randomly selected $25000$ images from the CelebA dataset [14]. We generate $25000$ blur kernels sizes ranging from $13\times 13$ to $29\times 29$, using 3D camera trajectories [47]. Patches of size $128\times 128$ are exacted from those images and convolved with $25000$ blur kernels randomly to generated about 1.7 million pairs of clean-blurry data. We added Gaussian noise with $\sigma=0.03$ to the blurry images.

First Stage Semantic Network

Every first stage semantic network is trained with clean-blurry paired data where only the corresponding class components of the face images are blurred. The first stage semantic network is trained with a combination of the L1-norm and the perceptual losses using the Adam optimizer with learning rate of $0.0002$. The first stage network is trained for $50,000$ iterations. To illustrate what kind of outputs are observed from the first stage semantic networks, in Fig. 8 we display semantic masks (first row), the corresponding blurry images (second row) and the final estimated deblurred outputs from first stage semantic networks (last row). As it can be seen from the last row, first stage semantic networks are able to remove most of the blur from corresponding class in the image. Note that, F-Net-$i$’s from these first stage semantic networks are used along with B-Net to construct UMSN, and trained to perform deblurring face image.

Overall UMSN Network

UMSN is trained using $\mathcal{L}_{total}$ with the Adam optimizer and batchsize of 16. The learning rate is set equal to $0.0002$. Note that, semantic maps $\{{m_{i}}\}_{i=1}^{4}$ of the ground truth clean images in $\mathcal{L}_{total}$ are generated using S-Net, since we do not have the actual semantic maps for them. $\lambda$ and $\lambda_{1}$ values are set equal to $0.01$ and $0.0002$, respectively. UMSN is trained for $0.1$ million iterations.

IV-B Evaluation

PSNR and SSIM

We compare the performance of our method with the following state-of-the-art algorithms: MAP-based methods [16, 15, 48, 49, 50], face deblurring exemplar-based method [30], and CNN-based methods [9, 11, 24]. Results are shown in Table III. As can be seen from this table, UMSN outperforms state-of-the-art methods including the methods that make use of semantic maps for image deblurring [11]. Furthermore, we evaluate UMSN’s performance in reconstructing individual semantic classes against [11]. As it can be seen from the Table I, our method’s performance in reconstructing individual classes is better than the sate-of-the-art method [11]. In addition, we compare the performance of our method against CNN-based face deblurring method that uses post processing [12] on the PubFig dataset consisting of 192 images released by the authors of [12]. The PSNR and SSIM values achieved by [12] are $30.21$ and $0.84$, whereas our method achieved $30.95$ and $0.87$, respectively.

VGG-Face distance

We compare the performance of our method with the following state-of-the-art algorithms using feature distance ( i.e, $L2-$norm distance between output feature map from network) between deblurred image and the ground truth image. We use the outputs of pool5 layer from the VGG-Face [44] to compute the VGG-Face distance ( $d_{VGG}$). $d_{VGG}$ is a better perceptual metric to compare as it computes the $L2-$norm distance in the feature space using VGG-Face [44] network. Table IV clearly shows that our method UMSN outperforms the existing state of the art methods using the perceptual measures like $d_{VGG}$.

Face recognition

In order to show the significance of different face deblurring methods, we perform face recognition on the deblurred images. We use the CelebA dataset to perform this comparison, where we use $100$ different identities as the probe set, and for each identity we select 9 additional clean face images as the gallery set. $8000$ blurry images are generated using the 100 images in the probe set. Given a blurry image, the deblurred image is computed using the corresponding deblurring algorithm. The most similar face for this deblurred image is selected from the gallery set to check whether they belong to same identity or not.

To perform face recognition we use OpenFace toolbox [51] to compute the similarity distance between the deblurred image and all the gallery images. We select the Top-K nearest matches for each deblurred image to compute the accuracy of the deblurring method. Table V clearly shows that the deblurred images by our method have better recognition accuracies than the other state-of-the-art methods. This experiment clearly shows that our method is able to retain the important parts of a face while performing deblurring. This in turn helps in achieving better face recognition compared to the other methods.

Qualitative Results

The qualitative performance of different methods on several images from the Helen and CelebA test images are shown in Fig. 9. We can clearly observe that UMSN produces sharp images without any artifacts when compared to the other methods [15, 11, 50].

In addition, we conducted experiments on 100 real blurry images provided by the authors of [15, 11, 50]. Results corresponding to different methods are shown in Fig. 10. As can be seen from this figure, UMSN produces sharper and clear images when compared to the state-of-the-art methods. For example, methods [15, 50] produce results which contain artifacts or blurry images. Shen et al.[11], Kupyn et al.[24] are not able reconstruct eyes, nose and mouth as shown in the fourth and fifth columns of Fig. 10, respectively. On the other hand, eyes, nose, and mouth regions are clearly visible in the images corresponding to the UMSN method.

IV-C Ablation Study

We conduct experiments on two datasets to study the performance contribution of each component in UMSN. We start with the base network (B-Net) and progressively add components to establish their significance to estimate the final deblurred image. The corresponding results are shown in Table VI. It is important to note that B-Net and UMSN are configured to have the same number of learnable parameters by setting appropriate number of output channels in the intermediate convolutional layers of the ResBlock. The ablation study demonstrates that each of the components improve the quality of the deblurred image. In particular, the introduction of the multi-stream architecture improved the performance by $0.6$dB. When UMSN is trained using $\mathcal{L}_{total}$ the performance improved by an additional $0.75$dB. Finally, the combination of all the components of UMSN produce the best results with $2.5$dB gain compared to B-Net.

Sample reconstructions corresponding to the ablation study using the Helen and CelebA datasets are shown in Fig. 11. As can be seen from this figure, B-Net and B-Net+semantic maps produce reconstructions that are still blurry and they fail to reconstruct the facial parts like eyes, nose and mouth well. On the other hand, B-Net+semantic maps+ NRL is able to improve the reconstruction quality but visually it is still not comparable to the state-of-the-art method. As shown in Fig. 12, NRL is able to estimate the class-specific residual feature maps, which are further used for estimating the final deblurred image. From Fig. 12 we can see what different residual feature maps are learning for different classes. In particular, the use of F-Nets helps UMSN to produce qualitatively good results, where all the parts of a face are clearly visible. Furthermore, training UMSN using $\mathcal{L}_{total}$ results in sharper images.

We also compare our method qualitatively with post processing-based method [12] on the PubFig dataset. As can be seen from the results shown in Fig. 13, even after applying some post processing, [12] tends to produce results that are smooth. In comparison, UMSN is able to produce sharper and high-quality images without any post-processing.

V Conclusion

We proposed a new method, called Uncertainty guided Multi-stream Semantic Network (UMSN), to address the single image blind deblurring of face image problem that entails the use of facial sementic information. In our approach, we introduced a different way to use the ouput features from the sub-networks which are trained for the individual semantic class-wise deblurring. Additionally, we introduced novel techniques such as nested residual learning, and class-based confidence loss to improve the performance of UMSN. In comparison to the state-of-the-art single image blind deblurring methods, the proposed approach is able to achieve significant improvements when evaluated on three popular face datasets.

Appendix A UMSN network sequence

The BaseNetwork is similar to the first stage semantic network as shown in Fig. 5 with the following sequence of layers,

ResBlock(3,64)-Avgpool-ResBlock(64,64)-ResBlock(64,64)-ResBlock(64,64)-ResBlock(64,64)-ResBlock(64,64)-ResBlock(64,64)-Upsample-ResBlock(64,16)-Conv$~{}3\times~{}3$(16,3).

F-Net-$i$ is a a sequence of five ResBlocks with dense connections,

ResBlock(3,16)-Avgpool-ResBlock(16,16)-ResBlock(16,16)-ResBlock(16,16)-ResBlock(16,8)

where ResBlock$(m,n)$ indicates $m$ input channels and $n$ output channels for ResBlock.

F-Net-$i$’s are joined to form the first stage of UMSN, further these outputs re concatenated to output of first layer of Base Network(B-Net) for constructing the UMSN network. Thus UMSN is constructed by combining F-Net-$i$’s and B-Net, where F-Net-$i$’s acts as first stage of UMSN, and B-Net acts as second stage of UMSN.

Appendix B Confidence scores

In this section, we show some example test outputs of UMSN (trained with $\mathcal{L}_{total}$) at different time instances of training, and their corresponding confidence values to show how confidence measure is helping the network. Confidence measure helps the UMSN in deblurring different parts of the face. For example, as shown in the Fig. 15 and Table VII, the outputs of UMSN after 50,000 iterations are blurry around eyes, nose, and mouth regions which is reflected in low confidence scores for $C_{3}$ when compared to the other classes. Eventually, UMSN learns to reconstruct eyes, nose and mouth regions which is reflected in high confidence scores for $C_{3}$. This can be seen from Figure 15 where the output deblurred images are sharp with eyes, nose and mouth regions reconstructed perfectly. Table VIII and Fig. 16 show the confidence scores for different classes and outputs of UMSN for two different identities from the test dataset blurred with kernel sizes of $17\times 17$ and $27\times 27$.

Appendix C Additional results

Extreme blur and occlusions by object like sun glasses or other body parts such as hands can cause S-Net to produce poor quality segmentations as shown in the second row of Fig. 14. Even when the S-Net fails to produce accurate segmentation masks, UMSN is able to produce visually pleasing results as shown in the third row of Fig. 14. This is mainly due to the concatenation of features from F-Net-$i$ with the feature from the first layer of B-Net. By doing this, features extracted and reconstructed for each class in corresponding F-Net helps the UMSN to deblur the face image even if the face parsing does not work well. Note that the first stage semantic networks are initially trained on the images where only the corresponding class is blurred and remaining are clean. Thus even if the class mask is extremely corrupted, the F-Net can extract the corresponding class features and helps the UMSN to produce visually pleasing images as shown in Fig. 14.

Figure 17 and Figure 18 show cases in which the face images are occluded and taken in low-light conditions, respectively. In such conditions, the proposed method fails to produce better quality images.

Acknowledgment

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. 2019-19022600002. 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.