Non-linear aggregation of filters to improve image denoising

TL;DR

This paper presents a new non-linear filter aggregation method for image denoising that combines multiple filters based on a novel pixel proximity metric, resulting in improved denoising performance supported by theoretical and empirical evidence.

Contribution

The paper introduces a novel non-linear aggregation scheme for image denoising that outperforms individual filters and provides theoretical bounds for its effectiveness.

Findings

Aggregated filters outperform individual filters in denoising tasks.

The proposed method is supported by theoretical performance bounds.

Numerical experiments demonstrate significant denoising improvements.

Abstract

We introduce a novel aggregation method to efficiently perform image denoising. Preliminary filters are aggregated in a non-linear fashion, using a new metric of pixel proximity based on how the pool of filters reaches a consensus. We provide a theoretical bound to support our aggregation scheme, its numerical performance is illustrated and we show that the aggregate significantly outperforms each of the preliminary filters.

Equations

$$f(p)=\frac{{\sum }_{q\in x}\omega (p,q)x(q)}{{\sum }_{q\in x}\omega (p,q)},$$

$$\omega (p,q)=\text{mathds}1\left(\sum _{k=1}^M\text{mathds}1(|f_k(p)-f_k(q)|\le ϵ)\ge M\alpha \right),$$

$$\mathbb{E}{\left[\hat{f}(p)-f^{\star }(p)\right]}^2\le \underset{m=1,\dots ,M}{\min }\mathbb{E}{\left[f_m(p)-f^{\star }(p)\right]}^2+C|x{|}^{-\frac{2}{M+2}},$$

$${\Sigma }_{x=1}^N{\Sigma }_{y=1}^M\frac{|I_d(x,y)-I_o(x,y)|}{N\times M}.$$

$$\sqrt{{\Sigma }_{x=1}^N{\Sigma }_{y=1}^M\frac{(I_d(x,y)-I_o(x,y){)}^2}{N\times M}}.$$

$$10\cdot {\log }_{10}\left(\frac{d^2}{{\mathrm{RMSE}}^2}\right)$$

$$\underset{(i)}{\underbrace{\frac{cov(I_o,I_d)}{{\sigma }_o\cdot {\sigma }_d}}}\cdot \underset{(ii)}{\underbrace{\frac{2\cdot {\mu }_o\cdot {\mu }_d}{{\mu }_o^2+{\mu }_d^2}}}\cdot \underset{(iii)}{\underbrace{\frac{2\cdot {\sigma }_o\cdot {\sigma }_d}{{\sigma }_o^2+{\sigma }_d^2}}}$$

Full text

1 Introduction

Denoising is a fundamental question in image processing. It aims at improving the quality of an image by removing the parasitic information that randomly adds to the details of the scene. This noise may be due to image capture conditions (lack of light, blurring, wrong tuning of field depth, …) or to the camera itself (increase of sensor temperature, data transmission error, approximations made during digitization, …). Therefore, the challenge consists in removing the noise from the image while preserving its structure. Many methods of denoising already have been introduced in the past decades – while good performance has been achieved, denoised images still tend to be too smooth (some details are lost) and blurred (edges are less sharp). Seeking to improve the performances of these algorithms is a very active research topic.

The present paper introduces a new approach for denoising images, by bringing to the computer vision community ideas developed in the statistical learning literature. The main idea is to combine different classical denoising methods to obtain several predictions of the pixel to denoise. As each classic method has pros and cons and is more or less efficient according to the kind of noise or to the image structure, an asset of our method is that is makes the best out of each method’s strong points, pointing out the ”wisdom of the crowd”. We adapt the strategy proposed by the algorithm “COBRA - COmBined Regression Alternative” [2, 10] to the specific context of image denoising. This algorithm has been implemented in the python library pycobra, available on https://pypi.org/project/pycobra/.

Aggregation strategies may be rephrased as collaborative filtering, since information is filtered by using a collaboration among multiple viewpoints. Collaborative filters have already been exploited in image denoising. [8] used them to create one of the most performing denoising algorithm: the block-matching and 3D collaborative filtering (BM3D). It puts together similar patches (2D fragments of the image) into 3D data arrays (called “groups”). It then produces a 3D estimate by jointly filtering grouped image blocks. The filtered blocks are placed again in their original positions, providing several estimations for each pixel. The information is aggregated to produce the final denoised image. This method is praised to well preserve fine details. Moreover, [13] proved that the visual quality of denoised images can be increased by adapting the denoising treatment to the local structures. They proposed an algorithm, based on BM3D, that uses different non-local filtering models in edge or smooth regions. Collaborative filters have also been associated to neural network architectures, by [18], to create new denoising solutions.

When several denoising algorithms are available, finding the relevant aggregation has been addressed by several works. [16] focused on the analysis of patch-based denoising methods and shed light on their connection with statistical aggregation techniques. [6] proposed a patch-based Wiener filter which exploits patch redundancy. Their denoising approach is designed for near-optimal performance and reaches high denoising quality. Furthermore, [17] showed that usual patch-based denoising methods are less efficient on edge structures.

The COBRA algorithm differs from the aforecited techniques, as it combines preliminary filters in a non-linear way. COBRA has been introduced and analysed by [2].

The paper is organised as follows. We present our aggregation method, based on the COBRA algorithm in section 2. We then provide a thorough numerical experiments section (section 3) to assess the performance of our method along with an automatic tuning procedure of preliminary filters as a byproduct.

2 The method

We now present an image denoising version of the COBRA algorithm [2, 10]. For each pixel $p$ of the noisy image $x$, we may call on $M$ different estimators $(f_{1}...f_{M})$. We aggregate these estimators by doing a weighted average on the intensities :

[TABLE]

and we define the weights as

[TABLE]

where $\epsilon$ is a confidence parameter and $\alpha\in(0,1)$ a proportion parameter. Note that while $f$ is linear with respect to the intensity $x$, it is non-linear with respect to each of the preliminary estimators $f_{1},\dots,f_{M}$.

These weights mean that, to denoise a pixel $p$, we average the intensities of pixels $q$ such as a proportion at least $\alpha$, of the preliminary estimators $f_{1},\dots,f_{M}$ have the same value in $p$ and in $q$, up to a confidence level $\epsilon$.

Let us emphasize here that our procedure averages the pixels’ intensities based on the weights (which involve this consensus metric). The intensity predicted for each pixel $p$ of the image is $f(p)$ and the COBRA-denoised image is the collection of pixels $\{f(p),p\in x\}$.

This aggregation strategy is implemented in the python library pycobra [10]. The general scheme is presented in Figure 1, and the pseudo-code in Algorithm 1. Users can control the number of used features thanks to the parameter “$patch\_size$”. For each pixel $p$ to denoise, we consider the image patch, centred on $p$, of size $(2\cdot patch\_size+1)\times(2\cdot patch\_size+1)$. In the experiments section, $patch\_size=2$ is usually a satisfying value. Thus, for each pixel, we construct a vector of nine features.

The COBRA aggregation method has been introduced by [2] in a generic statistical learning framework, and is supported by a sharp oracle bound. For the sake of completeness, we reproduce here one of the key theorems.

Theorem 2.1** (adapted from Theorem 2.1 in [2]).**

Assume we have $M$ preliminary denoising methods. Let $|x|$ denote the total number of pixels in image $x$. Let $\epsilon\propto|x|^{-\frac{1}{M+2}}$. Let $f^{\star}$ denote the perfectly denoised image and $\widehat{f}$ denote the COBRA aggregate defined in (1), then we have

[TABLE]

where $C$ is a constant and the expectations are taken with respect to the pixels.

What Theorem 2.1 tells us is that on average on all the image’s pixels, the quadratic error between the COBRA denoised image and the perfectly denoised image is upper bounded by the best (i.e., minimal) same error from the preliminary pool of $M$ denoising methods, up to a term which decays to zero as the number of pixels to the $-1/M$. As highlighted in the numerical experiments reported in the next section, $M$ is of the order of 5-10 machines and this remainder term is therefore expected to be small in most useful cases for COBRA. Note that in (3), the leading constant (in front of the minimum) is 1: the oracle inequality is said to be sharp. Note also that contrary to more classical aggregation or model selection methods, COBRA mactches or outperforms the best preliminary filter’s performance, even though it does not need to identify this champion filter. As a matter of fact, COBRA is adaptive to the pool of filters as the champion is not needed in (1). More comments on this result, and proofs are presented in [2].

3 Numerical experiments

This section illustrates the behaviour of COBRA. All code material (in Python) to replicate the experiments presented in this paper are available at https://github.com/bguedj/cobra˙denoising.

3.1 Noise settings

We artificially add some disturbances to good quality images (i.e. without noise). We focus on five classical settings: the Gaussian noise, the salt-and-pepper noise, the Poisson noise, the speckle noise and the random suppression of patches (summarised in Figure 2).

3.2 Preliminary denoising algorithms

We focus on ten classical denoising methods: the Gaussian filter, the median filter, the bilateral filter, Chambolle’s method [5], non-local means [3, 4], the Richardson-Lucy deconvolution [15, 14], the Lee filter [12], K-SVD [1], BM3D [8] and the inpainting method [9, 7]. This way, we intend to capture different regimes of performance (Gaussian filters are known to yield blurry edges, the median filter is known to be efficient against salt-and-pepper noise, the bilateral filter well preserves the edges, non-local means are praised to better preserve the details of the image, Lee filers are designed to address Synthetic Aperture Radar (SAR) image despeckling problems, K-SVD and BM3D are state-of-the-art approaches, inpainting is designed to reconstruct lost part, etc.), as the COBRA aggregation scheme is designed to blend together machines with various levels of performance and adaptively use the best local method.

3.3 Model training

We start with $25$ images $(y_{1}...y_{25})$, assumed not to be noisy, that we use as “ground truth”. We artificially add noise as described above, yielding $125$ noisy images $(x_{1}...x_{125})$. Then two independent copies of each noisy image are created by adding a normal noise: one goes to the data pool to train the preliminary filters, the other one to the data pool to compute the weights defined in (2) and perform aggregation. This separation is intended to avoid over-fitting issues [as discussed in 2]. The whole dataset creation process is illustrated in Figure 3.

3.4 Parameters optimisation

The meta-parameters for COBRA are $\alpha$ (how many preliminary filters must agree to retain the pixel) and $\epsilon$ (the confidence level with which we declare two pixels identities similar). For example, choosing $\alpha=1$ and $\epsilon=0.1$ means that we impose that all the machines must agree on pixels whose predicted intensities are at most different by a $0.1$ margin.

The python library pycobra ships with a dedicated class to derive the optimal values using cross-validation [10]. Optimal values are $\alpha=4/7$ and $\epsilon=0.2$ in our setting.

3.5 Assessing the performance

We evaluate the quality of the denoised image $I_{d}$ (whose mean is denoted $\mu_{d}$ and standard deviation $\sigma_{d}$) with respect to the original image $I_{o}$ (whose mean is denoted $\mu_{o}$ and standard deviation $\sigma_{o}$) with four different metrics.

• •

Mean Absolute Error (MAE - the closer to zero the better) given by

[TABLE]

• •

Root Mean Square Error (RMSE - the closer to zero the better) given by

[TABLE]

• •

Peak Signal to Noise Ratio (PSNR - the larger the better) given by

[TABLE]

with $d$ the signal dynamic (maximal possible value for a pixel intensity).

• •

Universal image Quality Index (UQI - the closer to one the better) given by

[TABLE]

where term $(i)$ is the correlation, $(ii)$ is the mean luminance similarity, and $(iii)$ is the contrast similarity [19, Eq. 2].

3.6 Results

Our experiments run on the gray-scale “lena” reference image (range 0 - 255). In all tables, experiments have been repeated 100 times to compute descriptive statistics. The green line (respectively, red) identifies the best (respectively, worst) performance. The yellow line identifies the best performance among the preliminary denoising algorithms if COBRA achieves the best performance. The first image is noisy, the second is what COBRA outputs, and the third is the difference between the ideal image (with no noise) and the COBRA denoised image.

Results – Gaussian noise (Figure 4).

We add to the reference image “lena” a Gaussian noise of mean $\mu=127.5$ and of standard deviation $\sigma=25.5$. Unsurprisingly, the best filter is the Gaussian filter, and the performance of the COBRA aggregate is tailing when the noise level is unknown. When the noise level is known, COBRA outperforms all preliminary filters. Note that the bilateral filter gives better results than non-local means. This is not surprising: [11] reaches the same conclusion for high noise levels.

Results – salt-and-pepper noise (Figure 5).

The proportion of white to black pixels is set to $sp\_ratio=0.2$ and such that the proportion of pixels to replace is $sp\_amount=0.1$. Even if the noise level is unknown, COBRA outperforms all filters, even the champion BM3D.

Results – Poisson noise (Figure 6).

COBRA outperforms all preliminary filters.

Results – speckle noise (Figure 7).

When confronted with a speckle noise, COBRA outperforms all preliminary filters. Note that this is a difficult task and most filters have a hard time denoising the image. The message of aggregation is that even in adversarial situations, the aggregate (strictly) improves on the performance of the preliminary pool of methods.

Results – random patches suppression (Figure 8).

We randomly suppress 20 patches of size $(4\times 4)$ pixels from the original image. These pixels become white. Unsurprisingly, the best filter is the inpainting method – as a matter of fact this is the only filter which succeeds in denoising the image, as it is quite a specific noise.

Results – images containing several kinds of noise (Figure 9).

On all previous examples, COBRA matches or outperforms the performance of the best filter for each kind of noise (to the notable exception of missing patches, where inpainting methods are superior). Finally, as the type of noise is usually unknown and even hard to infer from images, we are interested in putting all filters and COBRA to test when facing multiple types of noise levels. We apply a Gaussian noise in the upper left-hand corner, a salt-and-pepper noise in the upper right-hand corner a noise of Poisson in the lower left-hand corner and a speckle noise in the lower right-hand corner. In addition, we randomly suppress small patchs on the whole image (see Figure 9(a)).

In this now much more adversarial situation, none of the preliminary filters can achieve proper denoising. This is the kind of setting where aggregation is the most interesting, as it will make the best of each filter’s abilities. As a matter of fact, COBRA significantly outperforms all preliminary filters.

3.7 Automatic tuning of filters

Clearly, internal parameters for the classical preliminary filters may have a crucial impact. For example, the median filter is particularly well suited for salt-and-pepper noise, although the filter size has to be chosen carefully as it should grow with the noise level (which is unknown in practice). A nice byproduct of our aggregated scheme is that we can also perform automatic and adaptive tuning of those parameters, by feeding COBRA with as many machines as possible values for these parameters. Let us illustrate this on a simple example: we train our model with only one classical method but with several values of the parameter to tune. For example, we can define three machines applying median filters with different filter sizes : 3, 5 or 10. Whatever the noise level our approach achieves the best performance (Figure 10). This casts our approach onto the adaptive setting where we can efficiently denoise an image regardless of its (unknown) noise level.

4 Conclusion

We have presented a generic aggregated denoising method—called COBRA—which improves on the performance of preliminary filters, makes the most of their abilities (e.g., adaptation to a particular kind of noise) and automatically adapts to the unknown noise level. COBRA is supported by a sharp oracle inequality demonstrating its optimality, up to an explicit remainder term which quickly goes to zero. Numerical experiment suggests that our method achieves the best performance when dealing with several types of noise. Let us conclude by stressing that our approach is generic in the sense that any preliminary filters could be aggregated, regardless of their nature and specific abilities.