Edge Heuristic GAN for Non-uniform Blind Deblurring

TL;DR

This paper introduces an edge heuristic multi-scale GAN that leverages edge information and a hierarchical loss to effectively restore sharp images from non-uniform motion blurred images, outperforming existing methods.

Contribution

It proposes a novel edge heuristic multi-scale GAN with an edge-enhanced network and hierarchical loss for improved non-uniform image deblurring.

Findings

Achieves state-of-the-art results on dynamic scene deblurring datasets.

Demonstrates superior performance over traditional kernel estimation methods.

Effectively restores details in images with complex motion blur.

Abstract

Non-uniform blur, mainly caused by camera shake and motions of multiple objects, is one of the most common causes of image quality degradation. However, the traditional blind deblurring methods based on blur kernel estimation do not perform well on complicated non-uniform motion blurs. Recent studies show that GAN-based approaches achieve impressive performance on deblurring tasks. In this letter, to further improve the performance of GAN-based methods on deblurring tasks, we propose an edge heuristic multi-scale generative adversarial network(GAN), which uses the "coarse-to-fine" scheme to restore clear images in an end-to-end manner. In particular, an edge-enhanced network is designed to generate sharp edges as auxiliary information to guide the deblurring process. Furthermore, We propose a hierarchical content loss function for deblurring tasks. Extensive experiments on different datasets show that our method achieves state-of-the-art performance in dynamic scene deblurring.

Figures

Tables

Table 1. TABLE I: Quantitative results of the baseline models

	B	BE	BC	Proposed
Edge-generated Net	$\times$	✓	$\times$	✓
Combined content loss	$\times$	$\times$	✓	✓
PSNR	28.30	28.81	28.73	29.06

Table 2. TABLE II: Quantitative results on test dataset

Methods		GoPro		Köhler		Time
		PSNR	SSIM	PSNR	MSSIM
kernel based	Xu[6]	25.18	0.896	27.47	0.811	2.87s
	Pan[7]	26.76	0.849	26.47	0.794	18min
	Sun[9]	24.64	0.843	25.22	0.774	20min
GAN based	Nah[18]	29.08	0.914	26.48	0.808	2.87s
	Ram.[20]	28.94	0.922	27.08	0.812	-
	Kupyn[19]	28.70	0.858	26.10	0.816	0.59s
	Ours	29.32	0.933	26.55	0.811	0.64s

Equations

$$I^i=G_{deblur}(B^i,I^{i-1},E;{\theta }_G)$$

$$\underset{G}{\min }\underset{D}{\max }V(D,G)=$$

$${\mathbb{E}}_{z\sim P_z(z)}[D(G(z))]$$

$${\mathbb{E}}_{\tilde{x}\sim P_g(\tilde{x})}[{\Vert {▽}_{\tilde{x}}D(\tilde{x})\Vert }_2-1]$$

$$L_{adv1}=-D(G_{edge}(E_b))$$

$$L_{adv2}=-D(G(B^i|I^{i-1},E))$$

$$L_{pixel}(y,\hat{y})=\frac{1}{CHW}{\Vert y-\hat{y})\Vert }_2^2$$

$$L_{feat}(y,\hat{y})=\frac{1}{C_j{H}_j{W}_j}{\Vert {\varphi }_j(y)-{\varphi }_j(\hat{y}))\Vert }_2^2$$

$$L_{dc}(y,\hat{y})=\frac{1}{HW}{\Vert \phi (y)-\phi (\hat{y}))\Vert }_1$$

$$L_{EG}=L_{adv1}+\lambda L_{feat}(E_s,E_r)$$

$$L_{MS}=L_{adv2}+\lambda L_{cont}$$

$$L_{cont}=L_{feat}(I_s^i,I_g^i)+L_{pixel}(I_s^i,I_g^i)+L_{dc}(I_s^i,I_g^i)$$

Full text

I Introduction

Motion blur is one of the most common problems in computer vision. Camera shake and fast objects motions will cause non-uniform blurring, resulting in degraded image quality. How to effectively estimate unknown sharp image from given blurred image has always been one of the hotspots of researchers. Early studies mostly dealt with simple blurring caused by camera motions such as translation or rotation. Recent works have focused on handling non-uniform dynamic blurs caused by object motions and camera shakes.

Most of the deblurring methods use the physical model to generate clear images by estimating the blur kernel and latent images. However, it is worth noting that finding a blur kernel for each pixel is an ill-posed problem. Numerous methods [1, 2, 3, 4, 5, 6] use different statistical priors to help estimate blur kernels and latent images. For example, Xu et al. [6] proposed an L0 sparse expression as a prior to jointly estimate sharp image and blur kernels.The dark channel is also used as a prior to capture intermediate latent image to aid in blur kernel estimation[7]. Some recent work has applied CNN to image blind deblurring[8, 9, 10, 11, 12, 13]. These methods all perform kernel estimation steps through CNN for restoring the latent sharp image. Sun et al. [9] proposed an energy model consisting of CNN probability prior and smoothing prior, to estimate a smooth variable blur kernel. Extensive experiments show that both optimization-based and learning-based approaches have poor performance when dealing with non-uniform blurred images, and the operation speed is slow, which cannot meet the real-time requirements.

In recent years, generative adversarial network(GAN)[14] has achieved excellent performance in a variety of computer vision tasks[15, 16, 17]. GAN is also applied to image blind deblurring tasks due to the advantages in fitting data distribution[18, 19, 20]. A kernel-free method proposed by Nah et al.[18] uses the GAN framework to directly blur images and has good performance. Ramakrishnan et al. [20] use the combination of pix2pix framework [21] and densely connected convolutional networks [22] to restore latent sharp images from blurred images. In addition, Kupyn et al.[19] proposed an end-to-end learned method for motion deblurring which is based on a conditional GAN and perceptual loss[23]. These GAN-based methods have achieved good results in non-uniform blurred scenes, but there are still some problems to be solved, such as image details being over-smoothed, and artifacts still exist when dealing with violent blurring.

In this letter, we propose an edge heuristic multi-scale GAN to achieve non-uniform blind deblurring. The proposed network consists of two stages and does not involve blur kernel estimation. In the first stage, a lightweight conditional GAN called Edge-generated Net receives blurred edge and generates corresponding sharp edge. Then, the sharp edge is input as auxiliary information together with the corresponding blurred image into a multi-scale network. In addition, we have designed a new combined content loss to ensure that the network can achieve the desired results. Extensive experiments on challenging datasets show that our method has good performance in dynamic scene deblurring.

II approach

The overall framework of the proposed GAN is illustrated in Fig.1. The network uses the ”coarse-to-fine” scheme to generate refined images with coarse images and generated edges as auxiliary information.

II-A Edge-generated Net

The blurring process weakens the high-frequency part of images to a certain extent, which mainly represents the edge of images. Besides, the widely used multi-scale network[18] is also proved to weaken edge information during downsampling. However, strong edges play an important role in subjective image quality evaluation. Just as heuristic edge selection steps are often required in the MAP framework, the sharp image edge can be used as strong supervised information to assist image deblurring while preventing high-frequency information from being over-smoothed. So we carefully design a lightweight GAN to generate sharp edges which we call heuristic edges.

Due to the excellent performance of the encoder-decoder network architecture in a variety of computer vision tasks[24, 25, 26], we adopt a similar network architecture as a generator, but with some modifications to meet the task requirements. To ensure that the network can handle complicated motion blur, we add ResBlocks[27] behind each convolutional layer and in front of the deconvolution layer to enhance the learning ability of the network. Each ResBlock contains two convolution operations, which provide a larger receptive field and prevent the vanishing gradient problem. For the deblurring task, the generated result mainly depends on the image instance currently input, therefore, the BN layer is not suitable for this task. Instead, the BN layer in the ResBlock is replaced by the instance normalization(IN)[28] layer, which not only speeds up model convergence but also maintains independence between each image instance. In addition, like U-Net[29], we retain the skip connection between the corresponding feature maps, which benefits more information about the original image texture to propagate in high-resolution layers. The discriminator architecture is the same as that used in deblurGAN. The edge extracted from the blurred image acts as generator input, and the output is corresponding sharp edge.

II-B Multi-scale Deblurred Net

Multi-scale network architecture has proved its effectiveness in many image enhancement tasks[18][30]. In particular, it has been observed that a sufficiently low-resolution downsampled image of a blurred image approximates a sharp image of the corresponding resolution. Here, we design a multi-scale network as GAN generator for image deblurring. The input of each scale of the multi-scale generator is the downsampled blurred image, corresponding sharp edge and the output of the coarser scale. So the output of the generator can be expressed as

[TABLE]

where $B^{i}$, $I^{i}$, and $E$ denote the blurred image , latent sharp image, and edge image at the i-th scale, respectively. $G_{deblur}$ is the generator with training parameters denoted as $\theta_{G}$. Since each scale generator is designed to generate a sharp image, the discriminator is parameter-shared for generators of different scales, which can effectively improve the training speed.

Here are details of the network. We use convolution/deconvolution-IN-ReLu modules as ConvBlock and DeconvBlock[29]. An InBlock transforms the input image into 64-channel feature map and two ConvBlocks stacked followed by input block that transforms the feature map into 256-channel feature map. Then, the feature map is input into 6 Resblocks to increase the receptive field. Finally, 2 DeconvBlock and 1 OutBlock transforms the feature map to the original input size. The kernel size of convolutional layer in ConvBlock is 5, and the stride size is 2. However, in order to overcome the checkerboard effect and improve the image quality, similar to sub-pixel convolution[31], the kernel size of deconvolutional layer in DeconvBlock is 4, and the stride size is still 2. The generator structure of each scale is the same

II-C Loss

We train our GANs through two loss functions: content loss and adversarial loss.

II-C1 Adversarial loss

For GAN, discriminator and generator play the following two-player minimax game with value function V (G; D). Arjovsky et al. [32] discuss the difficulties in GAN training caused by JS divergence approximation and propose WGAN using Wasserstein-1 distance：

[TABLE]

where $p_{data}$ and $p_{z}$ denote the real data distribution and the noise distribution, respectively. And adding gradient penalty[33] terms can enforce Lipschitz constraint in WGAN:

[TABLE]

where $P_{g}$ is the generated data distribution, defined by $\tilde{x}=G(z)$, $z\sim P_{z}(z)$.

We use WGAN-GP as the critic function which converges quickly and has high hyperparameter sensitivity. And for the sake of description, we use $G$ to represent $G_{deblur}$. Hence, the adversarial loss for edge generation network is defined as:

[TABLE]

where $E_{b}$ represents the edge extracted from the blurred image. And we use $E$ to represent the edge image generated by pre-trained $G_{edge}$, so the adversarial loss for the i-th scale of multi-scale network can be defined as:

[TABLE]

II-C2 Hierarchical content loss

Hierarchical content loss can be decomposed into three parts: general content loss, texture loss, and dark channel loss. First, we use MSE loss to ensure general content consistency.

[TABLE]

where $y$ is the input image, $\hat{y}$ is the generated image, and their shape is $C\times H\times W$. However, the MSE loss smooths the image and is not sufficient to handle the artifacts caused by large-motion blur. Hence, we add Perceptual loss[23] to the loss function. Perceptual loss is the Euclidean distance between feature maps extracted by pre-trained CNN of target images and generated images:

[TABLE]

where $\phi_{j}(y)$ is the feature map of shape $C_{j}\times H_{j}\times W_{j}$ for the input $y$, which is obtained by the j-th convolution block within the pretrained VGG-19 network. We extracted the feature map of the conv3_3 layer so that the perceptual loss takes into account both general content and texture details.

The pixel value of the dark channel increases due to the motion blur averaging of dark pixels and adjacent pixels, hence, the sparse difference of the dark channel reflects the severity of the blur. Unlike the processing in[7], MAE loss is used to measure the difference of dark channel map between ground truth and deblurred image

[TABLE]

Finally, the generator network and discriminator network is jointly trained by combining the content loss and adversarial loss. for the $G_{edge}$, final loss term is

[TABLE]

And for the $G_{deblur}$, final loss term is

[TABLE]

where $E_{s}$ and $E_{r}$ denote edge extracted from ground truth and generated edge image, respectively. The weight constant $\lambda=100$.

III experiment

Our experiments are conducted on a PC with Intel Xeon E5 CPU and an NVIDIA GTX 1080Ti GPU and the network is implemented on the Tensorflow platform.

III-A Data Preparation

The GoPro dataset was used for training and testing, and the Kohler benchmark was also used to assess the generalization capabilities of the model.

III-A1 GoPro dataset

Nah et al.[18] created the GoPro dataset that generates blurred images by averaging successive short exposure frames to approximate long exposure blurred frames. It simulates complex camera shake and object motion, and is more suitable for blurry images in real scenes. Following the same strategy as in [18], we use 2,103 pairs for training and the remaining 1,111 pairs for evaluation.

III-A2 Köhler benchmark

Köhler benchmark[34] is a standard benchmark for evaluation of blind deblurring, consists of 4 latent images and corresponding 48 blurred images which blurs are caused by replaying recorded 6D camera motion. We also used the Köhler benchmark as a test set for model performance evaluation.

III-B Training details

We follow the training strategy in WGAN-GP, using Adam as the optimizer with β1 = 0.9, β2 = 0.999, and perform 5 gradient descent steps on $D$, then one step on $G$. The learning rate is set initially to 10−4 and decayed to 10-6 at 600 epochs for both generator and critic of Edge-generated Net and Multi-scale deblurred Net. Similar to various CGANs, all the models were trained with a batch size = 1. Since the models are fully convolutional, they can be applied to images of arbitrary size. Unless otherwise stated, all of our experiments were trained on GoPro training set with the same PC configuration.

III-C Ablation Study

Unlike conventional data expansion, high frequency information of the image and images of different scales are introduced into the proposed frame to assist in image deblurring. Here, we design three baseline models to verify the effectiveness of edge constraint and combined content loss. Table I shows the investigation on the effects of edge constraint and combined content loss. Model B that trained by adversarial loss and perceptual loss use the same architecture as our proposed one, but it doesn’t have restored edge as auxiliary information. After adding the edge generation network to the model B, the PSNR performance of the model BE is improved to 28.81 and when we replaced the simple perceptual loss with the combined content loss, the PSNR performance of the model BC is improved to 28.73. We trained the four networks with the same training configuration and hyperparameter, which shows that these two parts can effectively improve model performance.

III-D Comparisons with State-of-the-art Methods

Since the problem of our model processing is dynamic deblurring caused by camera shake and object motion, this is different from the application scenario of the traditional uniform deblurring model. We evaluated the performance of our model in the GoPro dataset and Köhler benchmark[34], mainly compared to the kernel-based and GAN-based deblurring method.

We first evaluated the model using the 1111 test image pairs provided by the GoPro dataset. Sun et al. used CNN to estimate blur kernels and used traditional deconvolution methods to recover sharp images. However, in most real-world scenarios, blur kernels are complex and difficult to predict, so they do not perform well on some nonlinear blurred images of the dataset. The model proposed by Nah et al. has good performance on the dataset, but there are still artifacts in some images. In addition, we also evaluated the performance of deblurGAN on this dataset. Deblured result from test on GoPro dataset are shown in Fig.2(f) and quantitative results are shown in the Table II.

IV Conclusion

In this letter, we introduce high frequency information of images and images of different scales to improve the quality of deblurred images. The proposed network uses the “coarse-to-fine” scheme to restore sharp images in an end-to-end manner which does not involve blur kernel estimation and therefore has a faster running speed. We also design a new content loss that takes into account both the overall quality and local details of the restored image. Experimental results show that the proposed network has excellent performance in deblurring tasks.