A Deep Optimization Approach for Image Deconvolution

TL;DR

This paper introduces the Golf Optimizer, a lightweight deep learning network that learns priors for blind image deconvolution, improving stability and performance over traditional methods.

Contribution

The paper presents a novel Golf Optimizer network that effectively learns deep priors with better propagation, enhancing blind image deconvolution results.

Findings

Achieves competitive performance on GoPro dataset.

Extremely lightweight compared to state-of-the-art methods.

Improves stability of priors in deconvolution.

Abstract

In blind image deconvolution, priors are often leveraged to constrain the solution space, so as to alleviate the under-determinacy. Priors which are trained separately from the task of deconvolution tend to be instable, or ineffective. We propose the Golf Optimizer, a novel but simple form of network that learns deep priors from data with better propagation behavior. Like playing golf, our method first estimates an aggressive propagation towards optimum using one network, and recurrently applies a residual CNN to learn the gradient of prior for delicate correction on restoration. Experiments show that our network achieves competitive performance on GoPro dataset, and our model is extremely lightweight compared with the state-of-art works.

Tables

Table 1. Table 1: Implementation of Network ℱ ℱ {\mathcal{F}} and 𝒢 𝒢 {\mathcal{G}} . Layer type is followed by the filter settings of contained Conv layers formatted as (in-channels → → \rightarrow out-channels). Bottom row lists the total number of basic layers (i.e. Conv, ReLU, etc.)

$𝒢$		$ℱ$
Layer type	params	Layer type	params
${\text{Conv}}_{\left(3\to 16\right)}$	2,352	${\text{Conv}}_{\left(3\to 32\right)}$	4,704
${\text{BB}}_{\left(16\to 16\right)}\times 2$	38,016	${\text{BB}}_{\left(32\to 32\right)}\times 2$	151,808
${\text{BB}}_{\left(16\to 16\right)}\times 2$	38,016	${\text{BB}}_{\left(32\to 32\right)}\times 2$	151,808
${\text{BB}}_{\left(16\to 16\right)}\times 2$	38,016	${\text{BB}}_{\left(32\to 32\right)}\times 2$	151,808
${\text{BB}}_{\left(16\to 3\right)}\times 2$	3,347	${\text{BB}}_{\left(32\to 3\right)}\times 2$	5,779
${\text{Conv}}_{\left(3\to 3\right)}$	441	${\text{Conv}}_{\left(3\to 3\right)}$	441
50 layers	120,188	50 layers	466,348

Table 2. Table 2: Quantitative evaluations. Our method performs favorably against the following compared deblurring approaches in PSNR(dB), and is comparable to the method by [ 7 , 37 ] in SSIM.

Metric	PSNR(dB)	SSIM
[33]	24.64	0.84
[37]	25.18	0.89
[11]	23.64	0.82
[7]	27.19	0.90
Ours	28.06	0.85

Table 3. Table 3: Comparison on Model Sizes.

Part	Size (MB)
[33]	54.1
[26]	303.6
[7]	41.2
[41]	37.1
Ours ($ℱ$)	1.78
Ours ($𝒢$)	0.46
Ours (Total)	2.24

Table 4. Table 4: Run Time Analysis in Milliseconds.

Device	Year	Max	Min	Mean
Gtx 1080 Ti	2017	26.87	10.91	16.94
Gtx 1080	2016	28.52	15.83	17.30
GT 750 M	2013	106.17	35.97	40.66

Table 5. Table 5: Runtime Comparison on Single 256 × 256 256 256 256\times 256 Image.

Method	Time
[17]	24.23 s
[21]	117.06 s
[28]	134.31 s
[38]	264.78 s
[22]	109.27 s
[33]	20 min
[37]	1.11 s
[11]	1 h
[35]	0.80 s
[7]	0.72 s
[18]	0.85 s
Ours	16.94$\sim$40.66 ms

Table 6. Table 6: Network architecture of MLP

Stage	Layer	params
1	Linear	12
2	ReLU	0
3	Linear	40
4	ReLU	0
5	Linear	36
6	ReLU	0
7	Linear	8
8	Softmax	0
total parameters:		96

Table 7. Table 7: Architecture of our method to learn the gradient of prior.

Stage	Layer	params
1	Linear	12
2	ReLU	0
3	Linear	40
4	ReLU	0
5	Linear	36
6	ReLU	0
7	Linear	8
total parameters:		96

Equations

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

$$\begin{array}{rl}& \underset{x\in \mathcal{C}}{\min }\{-\log p(x|y)\}\\ & =\underset{x\in \mathcal{C}}{\min }\{-\log p(y|x)-\log p(x)\}\\ & =\underset{x\in \mathcal{C}}{\min }\{\psi (x)=\text{data}(x)+\text{prior}(x)\},\end{array}$$

$$-\nabla \text{prior}(x)=\mathcal{G}(x)-x,$$

$${\int }_{\tilde{x}}\frac{1}{N}\sum _{i=1}^N{\Vert {\mathcal{G}}^{(i)}(x)-\tilde{x}\Vert }^{2}p(\tilde{x})\mathrm{d}\tilde{x},$$

$${\int }_{\tilde{x}}{\Vert \nabla \text{prior}(x)-(x-\tilde{x})\Vert }^{2}p(\tilde{x})\mathrm{d}\tilde{x}.$$

$$x_{\text{mid}}=x_i-\alpha \nabla \text{data}(x_i),$$

$$x_{i+1}=\arg \underset{x\in \mathcal{C}}{\min }\left\{\frac{1}{2\beta }\Vert x-x_{\text{mid}}{\Vert }^2+\text{prior}(x)\right\},$$

$${\int }_{\tilde{x}}{\Vert \mathcal{F}(y)-\tilde{x}\Vert }^{2}p(\tilde{x})\mathrm{d}\tilde{x}.$$

$$\begin{array}{rl}& \underset{x}{\max }\log p(y|x)p(x)\\ & \ge \underset{x}{\max }\left\{\log p(y|x)+\log \int p(x+ϵ)g_{\sigma }(ϵ)\mathrm{d}ϵ\right\},\end{array}$$

$$-\text{prior}(x)=\log \int p(x+ϵ)g_{\sigma }(ϵ)\mathrm{d}ϵ.$$

$${\int }_{\tilde{x}}\underset{N\to \infty }{\lim }\frac{1}{N}\sum _{i=1}^N{\Vert {\mathcal{G}}^{(i)}(x)-\tilde{x}\Vert }^{2}p(\tilde{x})\mathrm{d}\tilde{x}.$$

$${\int }_x{\mathbb{E}}_{ϵ\sim \mathcal{N}(0,{\sigma }^{2}I)}\left[{\Vert \mathcal{G}(x)-(x+ϵ)\Vert }^{2}p(x+ϵ)\right]\mathrm{d}x,$$

$$0={\mathbb{E}}_{\epsilon\sim{\mathcal{N}}(0,\sigma^{2}I)}\bigg{[}\big{(}{\mathcal{G}}^{*}(x)-(x+\epsilon)\big{)}p(x+\epsilon)\bigg{]}.$$

$${\mathcal{G}}^{\ast }(x)=\frac{{\mathbb{E}}_{ϵ\sim \mathcal{N}(0,{\sigma }^{2}I)}[p(x+ϵ)(x+ϵ)]}{{\mathbb{E}}_{ϵ\sim \mathcal{N}(0,{\sigma }^{2}I)}[p(x+ϵ)]}.$$

$$\begin{array}{rl}-\nabla \text{prior}(x)& =\nabla \log \int p(x+ϵ)g_{\sigma }(ϵ)\mathrm{d}ϵ\\ & =\frac{1}{{\sigma }^2}\left({\mathcal{G}}^{\ast }(x)-x\right).\end{array}$$

$$\Vert \mathcal{G}(x_i)-\tilde{x}{\Vert }^2\le \Vert \mathcal{G}(x_{i-1})-\tilde{x}{\Vert }^2+\eta ,$$

$$\begin{array}{rl}& \mathcal{L}(\mathcal{G},x_i,\tilde{x})=\Vert \mathcal{G}(x_i)-\tilde{x}{\Vert }^2\\ & =\Vert \mathcal{G}(x_{i-1})-\tilde{x}{\Vert }^2+2⟨(\mathcal{G}(x_{i-1})-\tilde{x}{)}^T\nabla \mathcal{G}(x_{i-1}),x_i-x_{i-1}⟩\\ & +(x_i-x_{i-1}{)}^T{\nabla }^2\mathcal{G}(x_{i-1})(x_i-x_{i-1})+o\left(\Vert x_i-x_{i-1}{\Vert }^2\right),\end{array}$$

$$\begin{array}{rl}\eta & \ge 2⟨(\mathcal{G}(x_i)-\tilde{x}{)}^T\nabla \mathcal{G}(x_i),{\Delta }_i)⟩\\ & +{\Delta }_i^T{\nabla }^2\mathcal{G}(x_i){\Delta }_i+o\left(\Vert {\Delta }_i{\Vert }^2\right).\end{array}$$

$$\begin{array}{rl}{x}_{i+1}& =x_i-\nabla \text{prior}(x_i)=\mathcal{G}(x_i)=x_i+r(x_i).\end{array}$$

$${\mathcal{L}}_c=\frac{1}{M}\Vert x-\tilde{x}{\Vert }^2,$$

$${\mathcal{L}}_p=\frac{1}{whd}\Vert \mathcal{P}(x)-\mathcal{P}(\tilde{x}){\Vert }^2,$$

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

$$p^{\ast }(u)=\frac{1}{2}(u_1+u_2{)}^2,$$

$$\frac{\partial p^{\ast }}{\partial u_1}=\frac{\partial p^{\ast }}{\partial u_2}=u_1+u_2.$$

$$\begin{array}{rl}{u}^{\prime }& =u-{\nabla }_u{p}^{\ast }=(u_1,u_2)-(u_1+u_2,u_1+u_2)\\ & =(-u_2,-u_1)=\tilde{u}.\end{array}$$

Full text

11footnotetext: $\dagger$ equal contribution

1 Introduction

Blind image deconvolution, which restores an unknown latent image from blurry degeneration, is a fundamental task in image processing and computer vision. The most commonly used formulation of blur degeneration $y$ is modeled as the convolution of the latent image $x$ and the kernel $k$:

[TABLE]

where $\ast$ denotes the convolution operator and $n$ is i.i.d Gaussian noise. Blind image deconvolution aims to estimate the latent image $x$ given a blurry image $y$, and it is highly ill-posed since both $k$ and $n$ are unknown. To tackle this problem, prior knowledge is required to constrain the solution space. Recently, deep convolutional neural networks (CNNs) have been applied to image deconvolution and achieved significant improvements. Due to its powerful approximation capability, such networks can implicitly incorporates image prior information[30, 26, 34, 27]. Besides, many CNN-based methods directly estimate sharp images with trainable networks which introduce explicit deep generative priors [29, 22, 25, 18].

In this paper, we present a novel way for blind deconvolution with a general and tidy framework. The proposed method learns data-driven priors using an optimizer, which is separated into two task-dependent networks. Figure 1 provides the illustration of our proposed framework. The first network shown in red block tries to estimate an aggressive propagation towards the optimum by a vanilla residual CNN; while the second network shown in blue block employs recurrent residual unit of ResNet [10] and behaves like an iterative optimizer for delicate correction on the restored image. The behavior of our framework is similar to an expert golf player, who tries to get the ball near to the hole at first shot. Then, to get the ball close to, or even in the hole, the player taps the ball towards the optimum with delicate adjustments. Hence, we refer to the optimizer as Golf Optimizer.

It is obvious that trivially applying iterative optimizer for blind image deconvolution would lead to multi-tasking, since the image restored by the optimizer after every iteration would not still follow the physical model of blur degradation. This changes the data distribution and forces the deconvolution optimizer to accommodate new knowledge, which could lead to multi-tasking and cause catastrophic forgetting [16, 31, 20]. We are aware of this phenomenon in the training of iterative optimizer network for blind deconvolution, and to the best of our knowledge it is the first time this phenomenon is addressed in image deconvolution. To alleviate this phenomenon, we employ a vanilla residual CNN as our first part of network to preprocess images, in which the update is performed with an aggressive propagation.

The key insight of our optimizer lies on the asymptotical learning of the gradient of prior. Unlike previous works concentrated on learning image prior with a deconvolution irrelevant objective (e.g. classification error or denoising error) [22, 40], the Golf Optimizer learns the image priors within the deconvolution task. Furthermore, the largest challenge in prior learning is the instability of network when employing discriminative/qualitative criterion on restoration quality [18, 29, 25]. In practice, these priors may be incapable of providing optimal information for deconvolution [25].To eliminate this instability, instead of learning image prior itself, our optimizer asymptotically learns the gradient of prior via training recurrent residual unit of ResNet [10].

In this paper, we test our proposed Golf Optimizer network on the benchmark dataset GoPro [26]. In Figure 2, experimental results demonstrate that our deep optimizer achieves appealing performance.

2 Related Work

Due to the highly ill-posed nature, the image prior modeling plays important role in blind image deconvolution. Without explicit assumptions on image prior, CNNs are trained with large amount of image pairs, owing to their ability to represent realistic image priors. However, it’s non-trivial to directly use end-to-end CNNs to perform image deconvolution [36]. With the variable splitting technique, several approaches [40, 6, 43, 4] train deep CNNs as image prior or denoiser in a plug-and-play strategy. In these methods, pretrained deep CNNs are integrated as the proximal projector into model-based optimization. Particularly, in [4], instead of learning image priors, the propagation of prior is learned by a denoising autoencoder. However, these priors are usually learned independently from the task of deconvolution.

Some works [22, 25] learn deep image priors based on generative models, such as generative adversarial networks (GAN) [9] and variational auto-encoders (VAE) [15] which are successful in modelling the complex data distribution of realistic images. In [29], a deep densely connected generative network is trained with a Markovian patch discriminator. DeblurGAN is proposed in [18] where Wasserstein loss is used to circumvent the problems such as model collapse and gradient vanishing.

To handle degenerated images with different levels, a line of works [8, 24, 23] learn CNN optimizers to mimic the propagation of image update in conventional gradient-based optimization. Particularly, in [8], all main operations of image propagation using gradient descent, including the gradient of image prior, are parameterized with a trainable network for non-blind deconvolution. With given fixed kernel, the iterative gradient descent update is estimated by the network based only on the last update. Hence for the recurrent network each estimation remains to be the same task, which limits this architecture to non-blind deconvolution. In [24, 23], the propagations of image updates are performed by pretrained CNNs which is irrelevant to deconvolution task, and the prior is corrected by optimization-based projection.

3 Proposed Method

As mentioned at previous sections, our Golf Optimizer is separated into two sub-modules, in which the first network denoted as ${\mathcal{F}}$ makes an aggressive propagation towards optimum, and the second network referred to as the deep-optimizer ${\mathcal{G}}$ employs recurrent structure to iteratively correct our estimation. Given blurry input $y$, the network ${\mathcal{F}}$ and ${\mathcal{G}}$ are performed as $x_{0}={\mathcal{F}}(y),~{}~{}~{}x_{i}={\mathcal{G}}(x_{i-1}),~{}~{}~{}i=1,...,N$. Figure 3 provides brief description of our optimizer, and the architectural details will be given latter.

Before proceeding, we first define some notations that appear throughout this paper. We use $\|\cdot\|$ to denote the Euclidean $L_{2}$ norm, and let the random variable $\epsilon$ follows zero-mean Gaussian distribution with deviation level $\sigma$, i.e., $\epsilon\sim{\mathcal{N}}(0,\sigma^{2}I)$, where $I$ is the identity matrix. We let $\tilde{x}$ be the sharp image, and $x_{0}={\mathcal{F}}(y)$ be the the output of the first network w.r.t blurry input $y$, and $x_{i}={\mathcal{G}}(x_{i-1})$ be the output of iterative optimizer ${\mathcal{G}}$ for $i=1,...,N$ for some $N\geq 1$.

3.1 Problem Formulation

We start the image deconvolution problem with the MAP estimate where the posterior distribution of restored image $x$ given the blur degradation $y$, is formed as $p(x|y)\propto p(y|x)p(x)$. The target of image deconvolution is to minimize the negative of the logarithm of the posterior distribution over image space ${\mathcal{C}}$, formally:

[TABLE]

where the negative of the logarithm of the likelihood often refers to the data fidelity term, and $-\log p(x)$ referred as prior is the regularization term of model to constrain the deconvolution solution within ${\mathcal{C}}$.

3.2 Instability of Priors Learning

The prior learning is the central component in many image restoration tasks due to their ill-conditional properties. Though generative models with discriminative supervision has achieved significant improvement in image deconvolution [22, 25, 29, 18], there still are some problems in prior learning. On one hand, if the discriminator behaves badly, then the generator cannot receive any accurate feedback to model image prior. While the discriminator is expert, the gradient of loss would tend to zero and the prior learning will become slow even jammed. This phenomenon is known as gradient vanishing in GAN [2]. On the other hand, true solution may be far away from the range of the generators, and the pretrained generators may not precisely model the distribution of realistic images [25, 5].

Instead of learning prior by generative models, we employ a residual unit (i.e., identity shortcut) as our deep-optimizer ${\mathcal{G}}$ to learn the gradient of prior. Since that in the formulation the residual unit coincides with the gradient descent method, we asymptotically learn the descent direction of prior as deep-prior via residual learning from identity shortcut as,

[TABLE]

which will be stated formally in section 4.

Analogous works [4, 12, 3] build on denoising autoencoders (DAE) to learn the gradient of prior, which is referred to as deep mean-shift prior. The pretrained DAE is integrated into the optimization as the regularization term in a plug-and-play strategy, which is limited to non-blind deconvolution. Moreover, regarding to the generalization of prior learning, the distribution of images which is trained to build DAE in denoising may not coincide with that of images in deconvolution.

Unlike these methods, we train our deep-optimizer to capture the prior within the blind deconvolution task, to make sure the optimizer learn deconvolution related priors. Formally, for each pair of $(x,\tilde{x})$ we train our optimizer ${\mathcal{G}}$ by minimizing

[TABLE]

where $x$ is the degraded image and $N$ is the total iteration of optimizer ${\mathcal{G}}$. In Eq.4, ${\mathcal{G}}^{(i)}(\cdot)={\mathcal{G}}\circ\cdots\circ{\mathcal{G}}(\cdot)$ denotes the $i$-fold composition of ${\mathcal{G}}(\cdot)$ where $\circ$ denotes the composition operator.

The most significant superiority of learning the gradient of prior is that it can eliminate the instability of training with discriminative criterion. The instability lies on the improper evaluation metric ${\mathcal{L}}$ on the performance of restoration, which propagates unstable gradient $\frac{\partial{\mathcal{L}}}{\partial x}$ of prior back to generator. Figure 4(a) gives an simple example to demonstrate gradient vanishing with pretrained prior. To address this instability, we train ${\mathcal{G}}$ with Eq.3 to learn the gradient of prior by minimizing Eq.4, which reveals that learning prior is equivalent to the minimization of

[TABLE]

This shows the gradient of prior learns the difference between the degeneration and sharp image, which essentially eliminates the instability of learning prior gradient. Figure 4(b) provides the advantage of learning gradient of priors.

3.3 Catastrophic Forgetting in Iterative Blind Deconvolution

Another important issue in blind deconvolution with recurrent network involves the catastrophic forgetting problem when trivially applying optimizer iteratively for image restoration. Considering the optimization with gradient descent as minimization of the objective $\psi(x)$ in Eq.2, the restored solution is iteratively updated as

[TABLE]

where Eq.5 typically refers to proximal operation of $\text{prior}(x)$ with controlling factor $\beta$. And it is identical to $x-\beta\nabla\text{prior}(x)$ when $\text{prior}(x)$ is differential to $x$. This update form includes two modules on image $x$, gradient descent module and prior projection module respectively.

For non-blind image deconvolution with end-to-end network, RGDN [8] integrates these two modules into a recurrent convolutional network, where the gradient of image prior unit is replaced by a common CNN block. Given fixed kernel, the iterative update of restoration is performed as $x_{i+1}={\mathcal{F}}(x_{i};\theta)$ with network ${\mathcal{F}}$ parameterized by $\theta$. And the update on $x_{i+1}$ with ${\mathcal{F}}$ remains the same task. However, this particular recurrent architecture is limited to non-blind deconvolution, in which the updates share the same ${\mathcal{F}}$.

For blind image deconvolution, considered at single update on blurry image $x_{i}$ as $x_{i+1}={\mathcal{F}}(x_{i};\theta)$ with some unknown kernel $k$, the restored image $x_{i+1}$ would follow some other unknown degeneration which may even not be accordant with physical process of degradation. In this situation, those intermediate data $\{x_{i}|x_{i}={\mathcal{F}}(x_{i-1})\}$ estimated by network ${\mathcal{F}}$ would change the distribution of image degeneration, and this would lead network ${\mathcal{F}}$ to multitasking, which would cause catastrophic forgetting [16, 31, 20]. It is not pleasing to train deconvolution network ${\mathcal{F}}$ to accommodate new knowledge, which makes the training of network more tough. Figure 5 demonstrates the difficulties of training network for blind image deconvolution.

To address the issue of catastrophic forgetting, we simply adopt an vanilla residual CNN ${\mathcal{F}}$ to make an aggressive propagation towards the optimum, and fed the output to ${\mathcal{G}}$ for further delicate adjustment. Intuitively we need to ensure that, for $i,j\geq 0$ and $i\neq j$, the distribution of $x_{i}$ and that of $x_{j}$ should follow same distribution by slightly different distribution parameters. According to Eq.4, we have for each $x_{i}$, $x_{i+1}={\mathcal{G}}(x_{i})$ follow identical distribution with $x_{i}$. Hence, we only need to ensure $x_{0}$ follows same distribution with $\{x_{i}|i>0\}$. To achieve this, we train ${\mathcal{F}}$ using a similar target to ${\mathcal{G}}$:

[TABLE]

4 Learning Deep Priors via Optimizer

The aim of our deep-optimizer is to utilize deep-priors to make adjustment to the restored images. To achieve this, we adopt residual structure for the proposed optimizer. In this section, we will show that the deep-optimizer is capable of learning the gradient of prior terms. Also, we will elaborate our choice of residual architectures via formal deductions.

4.1 Learning Gradient of Prior

We first denote $g_{\sigma}(\cdot)$ as the zero-mean Gaussian distribution with deviation level $\sigma$. Our formulation is low-bounded by the logarithm of the MAP estimator [12, 4] as

[TABLE]

where the prior is expressed as the logarithm of the Gaussian-smoothed distribution $p(x)$ as:

[TABLE]

As in many low-level image enhancements e.g., JPEG deblocking, super-resolution, denoising, we model image degradation with the difference $\epsilon$ between the ground-truth $\tilde{x}$ and the observed degradation $x$ [42, 26], i.e., $x=\tilde{x}-\epsilon$. For the sake of analytical convenience, we further assume that the difference $\epsilon$ follows Gaussian distribution with unknown deviation level $\sigma$ as $\epsilon\sim{\mathcal{N}}(0,\sigma^{2}I)$. Ideally, we rewrite Eq. 4 to minimize the following objective

[TABLE]

Replacing the operation of averaging on composition by taking expectation w.r.t random variable $\epsilon$ and using $\tilde{x}=x+\epsilon$, we can rewrite Eq.8 as

[TABLE]

which can be differentiated w.r.t ${\mathcal{G}}$ and set to be equal to [math]. By denoting the optimum as ${\mathcal{G}}^{*}(x)$, we obtain

[TABLE]

This leads to our final optimizer ${\mathcal{G}}^{*}(x)$ as

[TABLE]

Following [4, 1], the gradient of prior can be learned by ${\mathcal{G}}$ with

[TABLE]

Missing $\sigma^{2}$: When the value of $\sigma$ is unknown, we can modify Eq.9 by dropping $\sigma^{2}$. For a trained optimizer ${\mathcal{G}}$, we just take the quantity ${\mathcal{G}}^{*}(x)-x$ and the gradient of prior should approximately be the score up to a multiplicative constant [1]. Together with the assumption on $\epsilon$, the gradient of prior can be asymptotically learned from ${\mathcal{G}}$, which forms our core ingredient in deep-prior learning for blind image deconvolution.

4.2 The Choice on Architecture of Optimizer

The deep-optimizer $x_{i}={\mathcal{G}}(x_{i-1})$ aims at achieving descent objective of the difference between current estimate and optimal, formally

[TABLE]

where $\eta\geq 0$ is a small non-negative constant. We denote the objective as ${\mathcal{L}}({\mathcal{G}},x_{i},\tilde{x})$, and take a second-order Taylor expansion on ${\mathcal{L}}({\mathcal{G}},x_{i},\tilde{x})$ around $x_{i-1}$:

[TABLE]

where $o(\cdot)$ denotes the remainder term. Combing above with Eq.10 and letting $\Delta_{i}={\mathcal{G}}(x_{i-1})-x_{i-1}$, we obtain:

[TABLE]

This shows the term $\|\Delta_{i}\|$ tends to be $o(\|\eta\|)$, which motivates us to pick up residual learning [10]. Unlike the deep residual network [10] consisting of residual units in which identity shortcuts is used only inside the units, the iterative network ${\mathcal{G}}$ employs a single residual unit to learn the residual mapping from current estimate to next one, i.e. ${\mathcal{G}}(x)=x+r(x)$, where $r(\cdot)$ is the residual mapping of ${\mathcal{G}}$. With missing term $\sigma^{2}$ in Eq. 9, the optimization with gradient descent as minimization the objective $\psi(x)$ is

[TABLE]

Hence, the gradient of prior can be learned from the residual mapping by applying recurrent optimizer.

5 Implementations

5.1 Architecture

Here we give our network architectures of Golf Optimizer. ${\mathcal{F}}$ and ${\mathcal{G}}$ have identical network architecture but different configurations. The architecture is shown in Figure 6. In the network, there are four Layers, each consisting of two Basic-Block (BB) units. Inside BB is the residual structure, where residual mapping is stacked by six basic layers shown in white rectangles. Except for the first/last layers whose input/output channels are 3, all the other convolution layers have identical in/out channels, thus having same number of filters $\mathfrak{f}$. We set $\mathfrak{f}=32$ for ${\mathcal{F}}$, and $\mathfrak{f}=16$ for ${\mathcal{G}}$. All the Conv layers have stride $=1$, making feature-maps the same spatial size as input. Table 1 provides the details of the network.

5.2 Training

Our model is trained on the GoPro dataset [26]. There are 3214 pairs of images in the dataset. Each pair contains a sharp ground truth image and a motion-blurred image. The size of the raw images in the dataset is $720\times 1280\times 3$. Among the 3214 pairs, 2103 pairs are selected for training purpose. The training set is generated by randomly cropping $256\times 256$ patches from those images. Routinely, we applied data augmentation procedures to the training set. The procedures are geometric transformations, including randomized vertical flipping and horizontal flipping.

As for the parameter optimization of the model, we adopted two loss metrics: content loss and perceptual loss.

Content loss: MSE loss is widely applied in optimization objectives for image restoration. Using MSE, content loss function in our objective is defined as

[TABLE]

where the pixel-wise errors between estimated image $x$ and ground truth image $\tilde{x}$ is computed, divided by the number of pixels $M$.

Perceptual loss: It has been shown that using MSE content loss as sole objective would lead to blurry artifacts due to the pixel-wise average of possible solutions in the solution space [19], and could potentially cause the distortion or loss of details [39]. To alleviate this problem, we utilize another loss metric perceptual loss [13]. Given a trained neural network ${\mathcal{P}}$, the perceptual loss between $x$ and $\tilde{x}$ is defined as

[TABLE]

where $w,h$ and $d$ are the width, height and depth of the feature map. In our implementation, ${\mathcal{P}}$ is set to VGG [32] network. The output ${\mathcal{P}}(\cdot)$ is defined to be the 5-th maxpooled feature map of VGG-11 model with batch normalization.

Overall Loss Function: In the training process, content loss and perceptual loss are combined to form an overall loss function as

[TABLE]

where $\lambda$ is the hyper-parameter controlling the balance between two loss terms. The same overall loss function is used in the training of both network ${\mathcal{F}}$ and ${\mathcal{G}}$.

6 Experimental Results

We evaluate the performance of our model quantitatively on GoPro dataset with visual examples. We also provide details of our experiment with analysis.

6.1 Details of The Experiment

We train the networks using GTX 1080 Ti graphic card with 11-GB memory. The computer has two Xeon Gold 5118 CPUs and 64 GB RAM.

Optimization Setting: ADAM [14] optimizer is used with $\beta_{1}=0.9,\beta_{2}=0.999$ and a mini-batch of size 4. The learning rate is $10^{-3}$ and will exponentially decay to $\gamma^{-11}$ with $\gamma=0.3$. The ${\mathcal{F}}$ network is trained for $500,000$ iterations. Then with ${\mathcal{F}}$ fixed, ${\mathcal{G}}$ network is trained to convergence which takes $200,000$ s.pdf.

Ideally, the iteration depth $N$ is unlimited. However, in practice we found using large $N$ would significantly challenge our hardware capacity. Finally, we set $N=5$ in the experiment.

Balance of Loss Functions: We find that the careful setting of factor $\lambda$ is required because the pixels and feature maps have different value range, and the imbalance may possibly nullify one of the metrics. Figure 8 shows such phenomenons encountered during model adjusting. Eventually we balance the value of ${\mathcal{L}}_{c}$ and ${\mathcal{L}}_{p}$ to be close to each other. $\lambda$ is set to $5e^{-6}$ which scale both ${\mathcal{L}}_{c}$ and ${\mathcal{L}}_{p}$ into the range $[1e^{-1},1e^{-2}]$.

Testing settings: The GoPro testing-set consists of 1111 pairs of images.The performance is calculated by averaging the evaluation values of all the testing samples. During the training phase, we found that the inference process of network ${\mathcal{G}}$ would usually converge after 2-4 iterations. Therefore we set the iteration number to 3 as stop criterion in the testing phase, in order to evaluate the average performance under a unified setting.

6.2 Quantitative Evaluations

Excluding the methods that involve much more data augmentation techniques, or extended training-data sources, we compare the results with those of the state-of-the-art methods including optimization based methods: TV-$l_{1}$ model aided by motion flow estimation [11] and $L_{0}$ sparsity prior based model by [37]; learning based methods: MBMF by [7] and CNN model predicting the distribution of motion blur by [33].

Figure 7 shows some example outputs of our method. It can be seen that our method can deal with heterogeneous motion blur as well as homogeneous motion blur, and the sharp edges and texture details are properly recovered. The average PSNR(dB) and SSIM results of different approaches on the GoPro dataset are shown in Table 2. For fairness, we use the well-recognized evaluation results on GoPro dataset collected from [34, 26, 18]. As one can see, our method yields the best PSNR(dB) and competitive SSIM.

6.2.1 Runtime and Model Size

The model size of our method is significantly smaller than many of the well-known approaches, as shown in Table 3

We evaluate our method on three GPU models with different target platforms. The edition of the GTX1080Ti is for deep learning servers and the GTX1080 is for personal computers while the GT750M is for portable devices. The results of the time-efficiency evaluation is shown in Table 4. The results of runtime comparison with other methods is shown in Table 5. Our method has the lowest inference time consumption.

6.3 Limitations

Removing severe motion blur is a challenge of image deconvolution. There are occasions under which our method cannot completely remove the blurring. As shown in Figure 9, our network converges with remaining ghost artifacts. This is usually because network ${\mathcal{F}}$ cannot project the input image into the domain that ${\mathcal{G}}$ accepts. Actually, in theory our framework can be applied again to further decouple the more difficult deblur task from ${\mathcal{F}}$, and that could be the future work of this method.

7 Conclusion

In this paper, we have proposed Golf Optimizer, a simple but novel framework to address blind image deconvolution. The optimizer is separated into two task-dependent CNNs: one network estimates an aggressive propagation to eliminate catastrophic forgetting; while the other learns the gradient of priors from data as deep-priors to avoid the instability of prior learning. Essentially, the optimizer can learn a good propagation for delicate correction, which is not limited to image deconvolution problem. We have shown that training of iterative network with residual structure can asymptotically learn the gradient, and residual CNN is a reasonable architecture for the optimizer. The network is trained and evaluated on a challenging dataset GoPro, yielding competitive performance of deconvolution. Also, the advantages of the lightweight and runtime efficiency of the model enable it to be easily applied on portable platforms.

Appendix

Gradient problems of priors

To better understand the results of Figure 4 in our manuscript, we provide the details of experimental settings and further analysis.

We build on a simple setting to experimentally validate the advantage of gradient learning for prior . Suppose we are to restore image $u$ consisting of only $2$ pixels: $u=(u_{1},u_{2})$. An image is said to be sharp if $u_{1}+u_{2}>0$, otherwise blur. The ground truth $\tilde{u}$ of a blur image $u$ is defined as the symmetric point w.r.t line $u_{1}+u_{2}=0$.

Discriminative Prior with MLP:

We train an MLP classifier $p$ to distinguish blurry/sharp images with $p(u)=1$ if $u$ is blurry and $p(u)=0$ if $u$ is sharp. The architecture of MLP is given in Table 6.

The hardware and platforms for training networks are same to those for training Golf Optimizer in our manuscript. The dataset used also consists of image pairs like $(u,\tilde{u})$ in which $u_{1}=-\tilde{u}_{2},u_{2}=-\tilde{u}_{1}$. We randomly generate 16,000 samples for training. We train the discriminative MLP network with cross-entropy loss. Adam optimizer is adopted to train the network, with $\beta_{1}=0.9$, $\beta_{2}=0.999$ and a mini-batch of size $4$. The network is trained for 4,000 iterations with learning rate $=10^{-3}$. After the training completes, we evaluate the classification performance of discriminative MLP on 1,000 randomly sampled testing data, and the trained network achieves $99\%$ classification accuracy.

To simulate the estimation of image with the discriminative prior, we plot the output of MLP $p(u)$ in the region $\{(u_{1},u_{2})|-1\leq u_{1}\leq 1,-1\leq u_{2}\leq 1\}$. Figure 10 which is same as Figure 4(a) in our manuscript, shows that when using the discriminative network $p$ as prior to deblur image $u$, the response of $p$ w.r.t $u$ is $1$ with large probability in the red flat areas. This discriminative gives high response of blurry image but zero gradient w.r.t image, which shows that discriminative MLP network has difficulty in giving effective feedbacks to aid the estimation of sharp images. This phenomenon of gradient vanishing mostly lies on the improper evaluation metric on prior. In this simple situation, when the blurry image $u$ is far away from the decision line $u_{1}+u_{2}=0$, the classifier prior only produces response with $1$, and the update for deblur expects a large step but gets almost [math]. While the image $u$ is close to the line, the update for deblur excepts a small step but gets large one.

Moreover, we take only the logits from the last hidden layer, (i.e., we remove the softmax layer), of the discriminative prior for analysis, the plotted surface would takes the appearance shown in Figure 12. As the figure shows, the gradients become large when the blurry images approach the decision line, which contradicts with the desired behaviour. Using such a prior, if we update a blur image $u$ by applying $u^{\prime}=u-\nabla p$ and compute the loss by $\mathrm{MSE}=\|\tilde{u}-u^{\prime}\|^{2}$, the loss value comes out to be 0.4849 which is quite large.

Besides, even if the general descent trend of the discriminative prior seems to be roughly similar to the desired form, if we precisely compare the descent trend of the discriminative prior in Figure 12 and the analytic solution in Figure 14, it could be very obvious to see that the discriminative prior doesn’t perform well, as shown in Figure 11.

This experiment shows that, without careful design and improvement, prior learning with discriminative criterion could be problematic and not optimal.

Prior learning with gradient constraint:

In contrast to the priors designed or learnt with other targets in which the gradient is rarely constrained, we instead apply our gradient learning framework to the task.

Since we are to update the image $u$ so that it falls near its ground truth $\tilde{u}$ on the other side of the decision line $u_{1}+u_{2}=0$ , we learn the desired prior by learning the negative of its gradient: $f(u)=\tilde{u}-u=-\nabla p$. By doing this, $f$ learns both the descent direction $(\tilde{u}-u)/\|\tilde{u}-u\|$ and the optimal descent step size $\|\tilde{u}-u\|$. Formally, we train the network $f$ by minimizing $\|f(u)-(\tilde{u}-u)\|^{2}$. The network architecture is shown in Table 7.

For better interpretability, we construct the prior $p$ from its negative gradient $f$ which is what we have learnt. We use numerical integration to do the reconstruction and the result is shown in 13. The negative of gradient of the plotted surface is the output of $f$.

Compared with the discriminative prior whose testing loss is $0.4849$ in terms of MSE, the prior that learns the gradient of prior achieves MSE $=2e^{-3}$ on 1000 randomly sampled testing pairs. Similar to the previous experiment, this result of MSE is computed as follow. Given a pairs of testing sample $(u,\tilde{u})$, the update is performed by gradient descent method as $u^{\prime}=u+f(u)$, and the MSE is computed by $\|\tilde{u}-u^{\prime}\|^{2}$.

Furthermore, we construct the optimal solution as

[TABLE]

and the plotted surface is shown in Figure 14. The optimal solution $p^{*}$ is constructed with the objective that its negative of gradient is equivalent to the difference of $\tilde{u}$ and $u$, that is $-\nabla_{u}p^{*}=\tilde{u}-u$. According to our setting, with $u=(u_{1},u_{2})$, we have $\tilde{u}=(-u_{2},-u_{1})$. The derivative of $p^{*}$ w.r.t $u_{1}$ and $u_{2}$ is

[TABLE]

The update of $u$ with gradient descent is performed as

[TABLE]

Hence, the construction of optimal solution is reasonable. From Figure 14, it can be seen that it is coincident to the prior obtained by learning the gradient. In fact, formally the MSE between this analytical solution and the prior is the same as the MSE between the prior and ground truth data, which is also $2e^{-3}$.

More experimental results

Shown in left is the input blur image, while the output and ground-truth are in middle and right respectively.