Log In Sign Up

Deep Multi-scale Convolutional Neural Network for Dynamic Scene Deblurring

by   Seungjun Nah, et al.
Seoul National University

Non-uniform blind deblurring for general dynamic scenes is a challenging computer vision problem since blurs are caused by camera shake, scene depth as well as multiple object motions. To remove these complicated motion blurs, conventional energy optimization based methods rely on simple assumptions such that blur kernel is partially uniform or locally linear. Moreover, recent machine learning based methods also depend on synthetic blur datasets generated under these assumptions. This makes conventional deblurring methods fail to remove blurs where blur kernel is difficult to approximate or parameterize (e.g. object motion boundaries). In this work, we propose a multi-scale convolutional neural network that restores blurred images caused by various sources in an end-to-end manner. Furthermore, we present multi-scale loss function that mimics conventional coarse-to-fine approaches. Moreover, we propose a new large scale dataset that provides pairs of realistic blurry image and the corresponding ground truth sharp image that are obtained by a high-speed camera. With the proposed model trained on this dataset, we demonstrate empirically that our method achieves the state-of-the-art performance in dynamic scene deblurring not only qualitatively, but also quantitatively.


page 7

page 11

page 12

page 14

page 15

page 17

page 20

page 21


Edge Heuristic GAN for Non-uniform Blind Deblurring

Non-uniform blur, mainly caused by camera shake and motions of multiple ...

Deep Motion Blur Removal Using Noisy/Blurry Image Pairs

Removing spatially variant motion blur from a blurry image is a challeng...

Deep Homography Estimation for Dynamic Scenes

Homography estimation is an important step in many computer vision probl...

Scale-recurrent Network for Deep Image Deblurring

In single image deblurring, the "coarse-to-fine" scheme, i.e. gradually ...

Dynamic Scene Deblurring using a Locally Adaptive Linear Blur Model

State-of-the-art video deblurring methods cannot handle blurry videos re...

Deep Dynamic Scene Deblurring from Optical Flow

Deblurring can not only provide visually more pleasant pictures and make...

Occlusion-Aware Video Deblurring with a New Layered Blur Model

We present a deblurring method for scenes with occluding objects using a...

1 Introduction

Motion blur is one of the most commonly arising artifact types when taking photos. Camera shaking and fast object motions degrade image quality to undesired blurry images. Furthermore, various causes such as depth variation, occlusion in motion boundaries make blurs even more complex. Single image deblurring problem is to estimate the unknown sharp image given a blurry image. Earlier studies focused on removing blurs caused by simple translational or rotational camera motions. More recent works try to handle removing general non-uniform blurs caused by depth variation, camera shakes and object motions in dynamic environments. Most of these approaches are based on following blur model  

[29, 10, 13, 11].


where B, S and n are vectorizd blurry image, latent sharp image, and noise, respectively. K is a large sparse matrix whose rows each contain a local blur kernel acting on S to generate a blurry pixel. In practice, blur kernel is unknown. Thus, blind deblurring methods try to estimate latent sharp image S and blur kernel K simultaneously, given a blurry image B.

Finding blur kernel for every pixel is severely ill-posed problem. Thus, some approaches tried to parametrize blur models with simple assumptions on the sources of blurs. In  [29, 10], they assumed that blur is caused by 3D camera motion only. However, in dynamic scenes, the kernel estimation is more challenging as there are multiple moving objects as well as camera motion. Thus, Kim et al. [14] proposed a dynamic scene deblurring method that jointly segments and deblurs a non-uniformly blurred image, allowing the estimation of complex (non-linear) kernel within a segment. In addition, Kim and Lee [15] approximated the blur kernel as locally linear and proposed an approach that estimates both the latent image and the local linear motions jointly. However, these blur kernel approximations are still inaccurate, especially in the cases of abrupt motion discontinuities and occlusions. Note that such erroneous kernel estimation directly affects to the quality of the latent image, resulting undesired ringing artifacts.

Figure 1: (a) Input blurry image. (b) Result of Sun et al. [27]. (c) Our deblurring result. Our results show clear object boundaries without artifacts.

Recently, CNNs (Convolutional Neural Networks) have been applied in numerous computer vision problems and showed promising results including deblurring problem [30, 25, 27, 1]

. Since no pairs of real blurry image and ground truth sharp image are available for supervised learning, they commonly used blurry images generated by convolving synthetic blur kernels. In  

[30, 25, 1], synthesized blur images with uniform blur kernel are used for training. And, in  [27], classification CNN is trained to estimate locally linear blur kernels. Thus, still, CNN based models are only suitable for several specific types of blurs and have limits against more general spatially varying blurs.

Therefore, all the existing methods still have many problems before they could be generalized and used in practice. These are mainly due to the use of simple and unrealistic blur kernel models. Thus, to solve those problems, in this work, we propose a novel end-to-end learning approach for dynamic scene deblurring.

First, we propose a multi-scale CNN that directly restores latent images without assuming any restricted blur kernel model. Unlike other approaches, our method does not estimate explicit blur kernels. Accordingly, our method is free from artifacts that arise from kernel estimation errors. Especially, the multi-scale architecture is designed to mimic conventional coarse-to-fine optimization methods. Second, we train the proposed model with multi-scale loss that is appropriate for coarse-to-fine architecture, and enhances convergence greatly. In addition, we further improve the results by employing adversarial loss [9]. Third, we propose a new realistic blurry image dataset with ground truth sharp images. To obtain kernel model-free dataset for training, we employ the dataset acquisition method introduced in [17]. As the blurring process can be modeled by the integration of sharp images during shutter time [17, 21, 16], we captured a sequence of sharp frames of a dynamic scene with a high-speed camera, and averaged them to generate blurry image by considering gamma correction.

By training with the proposed dataset and adding proper augmentation, our model can handle general local blur kernel implicitly. As the loss term optimizes the result to resemble the ground truth, it even restores occluded regions where blur kernel is extremely complex as shown in Fig. 1. We trained our model with millions of pairs of image patches, and achieved significant improvements in dynamic scene deblurring. Extensive experimental results demonstrate that the performance of the proposed method is far superior to those of the state-of-the-art dynamic scene deblurring methods in both qualitative and quantitative evaluations.

1.1 Related Works

There are several approaches that employed learning CNN for deblurring [30, 27, 25, 1].

Xu et al. [30] proposed an image deconvolution CNN to deblur a blurry image in a non-blind setting. They built a network based on the separable kernel property that the (inverse) blur kernel can be decomposed into a small number of significant filters. Additionally, they incorporated the denoising network [6] to reduce visual artifacts such as noise and color saturation by concatenating the module at the end of their proposed network.

On the other hand, Schuler et al. [25]

proposed a blind deblurring method with CNN. The proposed network mimics conventional optimization-based deblurring methods and iterates the feature extraction, kernel estimation, and the latent image estimation steps in a coarse-to-fine manner. To obtain pairs of sharp and blurry images for network training, they generated uniform blur kernels using a Gaussian Process and synthesized lots of blurry images by convolving them to the sharp images collected from the ImageNet dataset 

[3]. However, they reported performance limits for large blurs due to their suboptimal architecture.

Similarly to the work of Couzinie-Devy et al. [2], Sun et al. [27] proposed a sequential deblurring approach. First, they generated pairs of blurry and sharp patches with 73 candidate blur kernels. Next, they trained classification CNN to measure the local likelihood of a specific blur kernel of local patch. And then smoothly varying blur kernel is obtained by optimizing an energy model that is composed of the CNN likelihoods and smoothness priors. Final latent image estimation is performed with conventional optimization method [31].

Note that all these methods require an accurate kernel estimation step for restoring the latent sharp image. In contrast, our proposed system is learned to produce the latent image directly without estimating blur kernels.

Figure 2: (a) Ground truth sharp image. (b) Blurry image generated by convolving an uniform blur kernel. (c) Blurry image by averaging sharp frames. In this case, blur is mostly caused by person motion, leaving background as it is. The blur kernel is non-uniform, complex shaped. However, when blurry image is synthesized by convolution with uniform kernel, background also gets blurred as if blur was caused by camera shake. To model dynamic scene blur, our kernel-free method is required.

In other computer vision tasks, several forms of coarse-to-fine architecture or multi-scale architecture were applied [7, 5, 4, 23, 8]. However, not all multi-scale CNNs are designed to produce optimal results similarly to  [25]. In depth estimation, optical flow estimation, etc., networks usually produce outputs having smaller resolution compared to input image resolution [7, 5, 8]. These methods have difficulties in handling long-range dependency even if multi-scale architecture is used.

Therefore, we make a multi-scale architecture that preserves fine-grained detail information as well as long-range dependency from coarser scales. Furthermore, we make sure intermediate level networks help the final stage in an explicit way by training network with multi-scale losses.

1.2 Kernel-Free Learning for Dynamic Scene Deblurring

Conventionally, it was essential to find blur kernel before estimating latent image. CNN based approaches are not exception [25, 26]. However, estimating kernel involves several problems. First, assuming simple kernel convolution cannot model several challenging cases such as occluded regions or depth variations. Second, kernel estimation process is subtle and sensitive to noise and saturations, unless blur model is carefully designed. Furthermore, incorrectly estimated kernels give rise to artifacts in latent images. Third, finding spatially varying kernel for every pixel in dynamic scene requires huge amount of memory and computation.

Therefore, we adopt kernel-free methods in both blur dataset generation and latent image estimation. In blur image generation, we follow to approximate camera imaging process, rather than assuming specific motions, instead of finding or designing complex blur kernel. We capture successive sharp frames and integrate to simulate blurring process. The detailed procedure is described in section  2. Note that our dataset is composed of blurry and sharp image pairs only, and that the local kernel information is implicitly embedded in it. In Fig. 2, our kernel-free blurry image is compared with a conventional synthesized image with uniform blur kernel. Notably, the blur image generated by our method exhibits realistic and spatially varying blurs caused by the moving person and the static background, while the blur image synthesized by conventional method does not. For latent image estimation, we do not assume blur sources, and train the model solely on our blurry and sharp image pairs. Thus, our proposed method does not suffer from kernel-related problems in deblurring.

2 Blur Dataset

Instead of modeling a kernel to convolve on a sharp image, we choose to record the sharp information to be integrated over time for blur image generation. As camera sensor receives light during exposure, sharp image stimulation at every time is accumulated, generating blurry image [13]. The integrated signal is then transformed into pixel value by nonlinear CRF (Camera Response Function). Thus, the process could be approximated by accumulating signals from high-speed video frames.

Blur accumulation process can be modeled as follows.


where and denote the exposure time and the sensor signal of a sharp image at time , respectively. Similarly, , are the number of sampled frames and the -th sharp frame captured during the exposure time, respectively. is the CRF that maps a sharp latent image into an observed image such that , or In practice, we only have observed video frames while the original signal and the CRF is unknown.

It is known that non-uniform deblurring becomes significantly difficult when nonlinear CRF is involved, and nonlinearity should be taken into account. However, currently, there are no CRF estimation techniques available for an image with spatially varying blur [28]. When the ground truth CRF is not given, a common practical method is to approximate CRF as a gamma curve with as follows, since it is known as an aproximated average of known CRFs [28].


Thus, by correcting the gamma function, we obtain the sharp latent frame from the observed image by , and then synthesize the corresponding blur image by using (2).

We used GOPRO4 Hero Black camera to generate our dataset. We took 240 fps videos with GOPRO camera and then averaged varying number (7 - 13) of successive latent frames to produce blurs of different strengths. For example, averaging 15 frames simulates a photo taken at 1/16 shutter speed, while corresponding sharp image shutter speed is 1/240. Notably, the sharp latent image corresponding to each blurry one is defined as the mid-frame among the sharp frames that are used to make the blurry image. Finally, our dataset is composed of 3214 pairs of blurry and sharp images at 1280x720 resolution. The proposed GOPRO dataset is publicly available on our website 111

3 Proposed Method

In our model, finer scale image deblurring is aided by coarser scale features. To exploit coarse and middle level information while preserving fine level information at the same time, input and output to our network take form of Gaussian pyramids. Note that most other coarse-to-fine networks takes single input and single output.

3.1 Model Architecture

Figure 3:

(a) Original residual network building block. (b) Modified building block of our network. We did not use batch normalization layers since we trained model with mini-batch of size 4, which is smaller than usual for batch normalization. We found removing rectified linear unit just before the block output is beneficial in terms of performance empirically.

In addition to the multi-scale architecture, we employ slightly modified version of residual network structure [12] as a building block of our model. Using residual network structure enables deeper architecture compared to a plain CNN. Also, as blurry and sharp image pairs are similar in values, it is efficient to let parameters learn the difference only. We found that removing the rectified linear unit after the shortcut connection of the original residual building block boosts the convergence speed at training time. We denote the modified building block as ResBlock. The original and our modified building block is compared in Fig. 3.

By stacking enough number of convolution layers with ResBlocks, the receptive field at each scale is expanded. Details are described in the following paragraphs. For sake of consistency, we define scale levels in the order of decreasing resolution (i.e. level 1 for finest scale). Unless denoted otherwise, we use total scales. At training time, we set the resolution of the input and output Gaussian pyramid patches to be . The scale ratio between consecutive scales is 0.5. For all convolution layers, we set the filter size to be . As our model is fully convolutional, at test time, the patch size may vary as the GPU memory allows. The overall architecture is shown in Fig. 4.

Figure 4: Multi-scale network architecture. , , denote blurry and latent, and ground truth sharp images, respectively. Subscript denotes th scale level in the Gaussian pyramid, which is downsampled to scale. Our model takes a blurry image pyramid as the input, and outputs an estimated latent image pyramid. Every intermediate scale output is trained to be sharp. At test time, original scale image is chosen as the final result.

Coarsest level network

At the front of the network locates the coarsest level network. The first convolution layer transforms 1/4 resolution,

size input to 64 feature maps. Then, 19 ResBlocks are stacked followed by last convolution layer that transforms the feature map into input dimension. Every convolution layer preserves dimensions with zero padding. In total, there are 40 convolution layers. The number of convolution layer at each scale level is determined so that total model should have 120 convolution layers. Thus, the coarsest-scale network has receptive field large enough to ‘see’ the whole patch. At the end of the stage, a coarsest level latent sharp image is generated. Moreover, information from the coarsest level output is delivered to the next stage where finer scale network is. To convert a coarsest output to fit the input size of the next finer scale, the output patch passes an upconvolution 

[22] layer, while other multi-scale methods uses reshaping [7] or upsampling [4, 5, 23]. Since the sharp and blurry patches share low frequency information, learning suitable feature with upconvolution helps to remove redundancy. In our experiment, using upconvolution showed better performance than upsampling. Then, the upconvolution feature is concatenated with the finer scale blurry patch as an input.

Finer level network

Finer level networks basically have the same structure as in the coarsest scale network. However, the first convolution layer takes sharp feature from previous stage as well as its own blurry input image, in a concatenated form. Every convolution filter size is with the same number of feature maps as in the coarsest scale. Except for the last finest scale, there is an upconvolution layer before the next stage. At the finest scale, the original resolution sharp image is restored.

3.2 Training

Our model is trained on the proposed GOPRO dataset. Among 3214 pairs, 2103 pairs were used for training and remainings were used for the test. To prevent our network from overfitting, several data augmentation techniques are involved. In terms of geometric transformations, patches are flipped horizontally/vertically, rotated at random degrees. For color, RGB channels are randomly permuted. To take image degradations into account, saturation in HSV colorspace is multiplied by random number within

. Also, Gaussian random noise is added to blurry images. To make our network be robust against different strengths of noise, standard deviation of noise is also randomly sampled from Gaussian distribution,

. Finally, augmented image values are clipped in range of .

In optimizing the network parameters, we trained the model in the combination of two losses, multi-scale content loss and adversarial loss.

Multi-scale content loss

Basically, the coarse-to-fine approach desires that every mid-level outputs are the sharp images of the corresponding scales. Thus, we train our network so that every intermediate latent images should form Gaussian pyramid of sharp image. MSE criterion is applied to every level of pyramids. Hence, the loss function is defined as follows:


where denote the model output and ground truth image at scale level , respectively. The loss at each scale is normalized by the number of channels , width , and the height (i.e. the total number of elements).

Adversarial loss

Recently, adversarial networks are reported to generate sharp realistic images [9, 4, 24]. Following the architecture introduced in  [24], we build discriminator as in Table 1

. Discriminator takes the output of the finest scale or the ground truth sharp image as input and classifies whether it is network output or not.

The adversarial loss is defined as follows.


where G and D denote the generator, that is our multi-scale deblurring network in Fig. 4 and the discriminator (classifier), respectively.

Layer Weight dimension Stride
 1 conv 2
 2 conv 1
 3 conv 2
 4 conv 1
 5 conv 2
 6 conv 1
 7 conv 4
 8 conv 1
 9 conv 4
 10 conv 2
 11 fc -
 12 sigmoid - -

Table 1: Model parameters of discriminator. Every convolution layers are activated with LeakyReLU layer.

Finally, by combining the multi-scale content loss and adversarial loss, the generator network and discriminator network is jointly trained. Thus, our final loss term is


where the weight constant .

We used ADAM [18] optimizer with a mini-batch size 4 for training. The learning rate is adaptively tuned beginning from . After iterations, learning rate is decreased to 1/10 of the previous learning rate. Total training takes iterations to converge.

4 Experimental Results

4.1 GOPRO Dataset

We evaluate the performance of our model on the proposed GOPRO dataset. Our test dataset consists of 1111 pairs, which is approximately of the total dataset. We compare the results with those of the state-of-the art methods [16, 27] in both qualitative and quantitative ways. Our results show significant improvement in terms of image quality. Some deblurring results are shown in Fig. 5. We notice from the results of Sun et al. [27], deblurring is not successful on the regions where blurs are nonlinearly shaped or located at the boundary of motion. Kim and Lee  [16]’s results also fail in cases where strong edges are not found. In contrast, our results are free from those kernel-estimation related problems. Table 2, shows the quantitative evaluation results of the competing methods and ours with different scale level in terms of PSNR, SSIM over the test data.

Figure 5: Test results on the GOPRO dataset. From top to bottom: Blurry images, results of Sun et al. [27], results of Kim and Lee [15], and results of the proposed method.

[27] [15] Ours
=1 =2 =3

24.68 23.70 28.24 28.41 28.45
 SSIM 0.8557 0.8295 0.9062 0.9096 0.9170

Table 2: Quantitative deblurring performance comparison on the GOPRO dataset. denotes the scale level.
Figure 6: Deblurring results on the dataset  [20]. Top rows are results of results of Sun et al. [27], bottom rows are our results.

4.2 Köhler Dataset

Köhler dataset  [19] consists of 4 latent images and 12 differently blurred images for each of them. The blurs are caused by replaying recorded 6D camera motion. We report the quantitative results on this dataset in Table 3.

[27] [15] Ours
=1 =2 =3

25.22 24.68 25.74 26.02 26.48
 MSSIM 0.7735 0.7937 0.8042 0.8116 0.8079

Table 3: Quantitative comparison on the Köhler dataset. The dataset has its own evaluation code, thus we report multi-scale SSIM instead of SSIM.

4.3 Dataset of Lai et al.

Lai et al.  [20] generated synthetic dataset by convolving nonuniform blur kernels and imposing several common degradations. They also recorded 6D camera trajectories to generate blur kernels. However, their blurry images and sharp images are not aligned in the way of our dataset, making simple image quality measures such as PSNR and SSIM less correlated with perceptual quality. Thus, we show qualitative comparisons in Fig. 6. Clearly, our results avoid ringing artifacts while preserving details such as wave ripple.

5 Conclusion

In this paper, we proposed blind deblurring neural networks for sharp image estimation. Contrary to existing works, our model avoids kernel estimation related problems. The proposed model follows coarse-to-fine approach and also trained in multi-scale spaces. Furthermore, we generated realistic blur dataset with ground truth, enabling efficient supervised learning and rigorous evaluation. Experimental results show that our approach outperforms the state-of-the-art methods in both qualitative and quantitative ways.


A Appendix

In this appendix, we present more comparative experimental results to demonstrate the effectiveness of our proposed deblurring method.

a.1 Comparison of loss function

In section 3.2, we employed a loss function that combines both the multi-scale content loss (MSE) and the adversarial loss for training our network. We examine the effect of the adversarial loss term quantitatively and qualitatively. The PSNR and SSIM results are shown in table A.1. From this results, we observe that adding adversarial loss does not increases PSNR, but increase SSIM, which means that it encourages to generate more natural and structure preserving images.

 PSNR 28.62 28.45
 SSIM 0.9094 0.9170

Table A.1: Quantitative deblurring performance comparison of loss used to optimize our model  (). Evaluated on the GOPRO test dataset.

Fig. A.1 and A.2 show some qualitative comparisons between the results of our network trained with and .

Figure A.1: Visual comparison of results from our model trained with different loss functions. The blurry image is from our proposed dataset.
Figure A.2: Visual comparison of results from our model trained with different loss functions. The blurry image is from our proposed dataset.

a.2 Comparison on GOPRO dataset

We provide qualitative results on our GOPRO test dataset. Fig. A.3 and A.4 shows the deblurring results of Kim and Lee [15], Sun et al. [27], and ours.

Figure A.3: Visual comparison with other methods. The blurry image is from our proposed dataset.
Figure A.4: Visual comparison with other methods. The blurry image is from our proposed dataset.

a.3 Comparison on Lai et al. [20] dataset

We provide qualitative results on the dataset of Lai et al. [20]. The Lai et al. dataset is composed of synthetic and real blurry images, and we showed the deblurring result of a synthetically generated blurry image in section 4.3. We present the qualitative deblurring results of competing methods on real images in Fig. A.5 and A.6.

Figure A.5: Visual comparison with other methods. The blurry image is a real image in Lai et al. [20]
Figure A.6: Visual comparison with other methods. The blurry image is a real image in Lai et al. [20]

a.4 Comparison on real dynamic scenes

Finally, we further present deblurring results on real dynamic scenes. The blurry scenes are captured by a SONY RX100 M4 camera. The qualitative deblurring results of Kim and Lee [15], Sun et al. [27] and ours are compared in Fig. A.7 and A.8.

Figure A.7: Visual comparison with other methods. The blurry image is a real dynamic scene.
Figure A.8: Visual comparison with other methods. The blurry image is a real dynamic scene.