Zaccharie Ramzi
email: zaccharie.ramzi@inria.fr

Kevin Michalewicz

Jean-Luc Starck

Thomas Moreau

Philippe Ciuciu

J-L Starck

Wavelets in the Deep Learning Era

Keywords: Machine Learning, Deep Learning, Neural Networks, Wavelets, Denoising, Image restoration

Sparsity based methods, such as wavelets, have been state-of-the-art for more than 20 years for inverse problems before being overtaken by neural networks. In particular, U-nets have proven to be extremely effective. Their main ingredients are a highly non-linear processing, a massive learning made possible by the flourishing of optimization algorithms with the power of computers (GPU) and the use of large available datasets for training. It is far from obvious to say which of these three ingredients has the biggest impact on the performance. While the many stages of non-linearity are intrinsic to deep learning, the usage of learning with training data could also be exploited by sparsity based approaches. The aim of our study is to push the limits of sparsity to use, similarly to U-nets, massive learning and large datasets, and then to compare the results with U-nets. We present a new network architec-

Introduction

The U-net was introduced by [START_REF] Ronneberger | U-net: Convolutional networks for biomedical image segmentation[END_REF] to perform biomedical image segmentation. It has since then been used in a wide variety of image-to-image problems, not just segmentation, either as a strong baseline or as the building block for a more complex model. In particular, the Unets have had success in image-to-image translation [START_REF] Isola | Image-to-image translation with conditional adversarial networks[END_REF], image reconstruction (in CT [START_REF] Adler | Learned primal-dual reconstruction[END_REF] or MRI [START_REF] Zbontar | fastMRI: An open dataset and benchmarks for accelerated MRI[END_REF][START_REF] Minh Quan | Compressed sensing MRI reconstruction using a generative adversarial network with a cyclic loss[END_REF][START_REF] Chul Ye | Deep convolutional framelets: A general deep learning framework for inverse problems[END_REF]) and denoising [START_REF] Chul Ye | Deep convolutional framelets: A general deep learning framework for inverse problems[END_REF].

However, like many other deep learning approaches, the reason for its success is not well understood. The ideas of the U-net come from [START_REF] Long | Fully convolutional networks for semantic segmentation[END_REF] in part. In this work, the base choices that make a U-net are grounded with intuitive explanations. To be able to distinguish between critical and legacy parts in the U-net design, it is important to understand its mechanisms.

On the other hand, wavelets-based approaches are not state-of-the-art anymore for denoising but are theoretically grounded (see for example [START_REF] David | De-noising by soft-thresholding[END_REF]). For applications where guarantees are needed -such as medical applications -this makes them ideal candidates.

Similarly to wavelets, U-nets present a multi-scale approach, which allows to analyze the signal at different resolutions. Their main difference is the non-linearity applications. Indeed, while wavelets apply only one nonlinearity when applied to denoising -a method called wavelet shrinkage -, the U-net architecture relies on several ReLUs and max-poolings. These chained nonlinearities make the analysis of the denoising in U-nets very complicated. In particular, it is difficult to see how a network trained on one type of noise can be applied to other types of noises. Some works [START_REF] Nina | The troublesome kernel: why deep learning for inverse problems is typically unstable[END_REF] even show that classical neural networks can fail to recover elements that classical methods do, suggesting a trade-off between quality and stability.

In this paper, we investigate whether using massive learning and large available datasets in a sparsity framework could allow us to achieve U-nets performance or if the chained non-linearities are equally important. We propose a new network, called Learnlets, which makes use of one of the strongest advantages of neural networks, learning via gradient descent to enhance the expressive power of wavelets, while keeping some interesting wavelet properties such as exact reconstruction. We choose to test this network on a denoising problem, a task where wavelets have historically well-performed but are now overtaken by deep learning approaches. In parallel, we also propose a new U-net denoising scheme that guarantees an exact reconstruction when the noise tends to zero.

The full implementation of our method is open source in Python 1 . Furthermore, a previous short version of this work was presented in [START_REF] Zaccharie | Wavelets in the Deep Learning Era[END_REF].

We review the main studies on wavelets and neural networks in Section 2, while the learnlets model is presented in Section 3. The implementation of the exact reconstruction property for learnlets and for a generic neural network is analyzed in Section 4. Finally, details regarding the datasets and experiments are given in Section 5, results are shown in Section 6, and conclusions in Section 7.

Related Work

Different studies have attempted to work at the intersection of wavelets and neural networks. In [START_REF] Recoskie | Learning filters for the 2D wavelet transform[END_REF], the authors cast the wavelet transform as an auto-encoder where the latent representation has to be sparse and learn the filters. In this architecture only a simple highpass and low-pass filter pair is learned. Similarly, but pushing further the idea, [START_REF] Jawali | A Learning Approach for Wavelet Design[END_REF] developed a learning strategy to design new wavelet filters with certain properties 1 https://github.com/zaccharieramzi/understanding-unets imposed such as what they call perfect reconstruction (which we termed exact reconstruction) or vanishing moments. Their work was inspired by [START_REF] Pfister | Learning Filter Bank Sparsifying Transforms[END_REF] where the authors chose to use data patches to learn their transform rather than noise like in [START_REF] Jawali | A Learning Approach for Wavelet Design[END_REF].

Observing U-nets, two parts are very similar to synthesis and analysis concepts in wavelet decompositions, [START_REF] Chul Ye | Deep convolutional framelets: A general deep learning framework for inverse problems[END_REF] proposed to use the wavelet transform to perform a better pooling/unpooling strategy than simply maxpooling/bilinear upsampling. [START_REF] Fan | Soft-Autoencoder and Its Wavelet Shrinkage Interpretation[END_REF] inspired themselves from the cascading wavelet shrinkage systems to enhance denoising autoencoders. In brief, they proved that using a soft-thresholding non-linearity provided more power to the denoising autoencoders than other nonlinearities.

In these related papers, non-linearities (namely ReLU) are in majority applied to the low frequencies rather than the high frequencies, contrarily to what is common in the wavelet framework. In this work, we don't try to modify U-nets by importing wavelet ingredients, but rather try to push the limits of sparsity based approach by using learning while keeping sparsity concept unchanged. This allows us to recover the classical properties of wavelets i.e. decomposition with exact reconstruction, thresholding and reconstruction, while using a learning based approach.

3 Learnlets, the model Let x ∈ R n×n be an image. Let x = x + be the version of this image corrupted by an additive white Gaussian noise ∼ N (0, σ 2 I n×n ) whose variance σ 2 is assumed known. Let Σ be a compact set of possible values for σ, we chose to have σ ∼ U(Σ). For a given number of scales m and a given set of parameters θ = (θ S , θ T , θ A ) ∈ Θ m , we defined the learnlets as function

f θ from (R n×n × Σ) to R n×n : f θ (x, σ) = S θ S (T θ T (A θ A (x) , σ)) (1)
where we have:

1. A θ A , the analysis function defined in 3.1. 2. T θ T , the thresholding function defined in 3.2.

3. S θ S , the synthesis function defined in 3.3.

An illustration of the learnlets is given in Figure 1.

x F θ (1)

A * g * h * F θ (2) A * g * h * Aθ A ST (., .) ST (., .) σ Tθ T F θ (2) S * F θ (1) S * + + u u x Sθ S
Fig. 1 Schematic representation of the learnlets model, with m = 2 scales. The red nodes are inputs/outputs. The lightly green nodes correspond to functions whose parameters can be learned. Note that the standard deviation of the noise before thresholding is not learned but rather estimated, and is omitted in this diagram for clarity.

Analysis

Intuitively, one can see the analysis function as the equivalent of the wavelet transform with some learned filters. This linear function is defined as:

A θ A (x) = F θ (i) A * g hi-1 (x) m i=1 , hm (x) (2)
where we have:

-F θ (i)

A

, the filter bank at scale i. The convolutions are done without bias. θ (i)

A are the J i convolution kernels all of the same square size (k A , k A ) (for now J i = J m ).

h = ū • h, the low-pass filtering (h) followed by a decimation (ū). The decimation is performed by taking one line out of 2 and one row out of 2, in line with the way it is done in wavelet transforms. -g the high-pass filtering defined as: g(y) = yu( h(y)), with u the upsampling operation performed with a bicubic interpolator.

For ease of manipulation we rewrite

A θ A (x) = ((d i ) m i=1 , c), with d i ∈ R n 2 i-1 × n 2 i-1
×Ji the detail coefficients and c the coarse coefficients.

Note that low and high pass filters (h, g) are fixed, and only F (i) θ A filters are learned. As g has a zero mean, all coefficients d i have by construction a zero mean. This wavelet property is fundamental to model the noise on the coefficients. Indeed, in the absence of signal, the coefficients follow a Gaussian distribution with a zero mean, and a standard kσ thresholding can be applied, σ being the noise standard deviation. With wavelets, k would be chosen between 3 and 5, and would be a user parameter. In this setting, this k value can be learned, and can be different at each scale.

Thresholding

The non-linearity function used for wavelet shrinkage is typically either a hard-thresholding or a soft-thresholding [START_REF] David | De-noising by soft-thresholding[END_REF]. The soft-thresholding offers more stability and therefore we made this choice for our architecture. The thresholding function, in the case of a white Gaussian noise of variance σ 2 , is defined as:

T θ T (((d i ) m i=1 , c) , σ) = (t ij (d ij , σ)) Ji i=1 m i=1 , c (3)
where

t ij (d, σ) = σij ST 1 σij d ij , θ (ij)
T σ , with:

-d ij ∈ R n 2 i-1 × n 2 i-1
the output of the j-th filter of i-th scale.

-σij the estimated standard deviation of d ij when the input of the transform is set to be a white Gaussian noise of variance 1. This ensures the noise coming just before the thresholding is of variance approximately σ. The threshold is therefore truly θ

(ij) T σ. -θ (ij) T
is the thresholding level applied at scale i on the j-th analysis filter.

-ST (d, s) is the soft-thresholding function applied point-wise on d with threshold s:

ST (d, s) = sign(d) max(|d| -s, 0).
It is important to notice that, thanks to linearity of the analysis operator, the thresholding strategy can be very easily adapted to non-stationary Gaussian noise or to any other kind of noise, such as Poisson noise or a mixture of Gaussian and Poisson noise.

Synthesis

Intuitively, one can see the synthesis function as the equivalent of the wavelet reconstruction operator, with learned filters. It is important to note that the synthesis function is linear. The synthesis function is defined recurrently as:

S θS ((d i ) m i=1 , c) = S (m-1) θS (d i ) m-1 i=1 , u(c) + F θ (m) S * d m (4)
where S ∅ (∅, c) = c and:

-F θ (i)

S

, the filter bank at scale i, used for regrouping. The convolutions are done without bias and added all together. θ (i) S are the J i convolution kernels all of the same square size (k S , k S ).

u, the upsampling operation performed with a bicubic interpolator.

Constraints

Some constraints are used on the parameters of the learnlets to make them as close as possible to the wavelets and therefore make them understandable:

-The analysis filters are forced to have a unit norm.

-The thresholding levels are in [0, 5].

Learning

The optimization problem is given as:

argmin θ∈Θ E x,σ [L f (θ)] ( 5
)
where

L f (θ) = x -f θ (x, σ) 2 2
and the expected value is computed empirically, via the empirical mean over a batch.

Learnlets as the bridge between Sparsity and U-nets

The learnlet transform is very similar in its spirit to the curvelet transform. Indeed, in both transforms the image is first decomposed into a set of wavelet scales, and filters are applied on each scale. In a curvelet decomposition, it would be directional and fixed filters, while filters are learned in our proposed scheme. Obtained coefficients can be manipulated exactly the same way as wavelets or curvelets coefficients.

It is interesting to notice that after training, the pixels of the learnlets' (with exact reconstruction) analysis filters constitute meaningful designs. This can be observed in Figure 2: lines with different slopes are displayed in scale-zero filters (details about the data and the training are given in the section 5).

On the other hand, learnlets share very similar properties with U-nets. For example they make use of gradientbased learning, but they also feature a multi-scale analysis along with the use of non-linearities.

Exact reconstruction

Learnlets

Exact reconstruction guarantees that if no noise is present, the signal will be perfectly reconstructed, without any error. This can be achieved using the analysis filter previously fixed as identity. In particular, let's consider a single scale i, after the application of the g filter. The operation carried out by the network, without thresholding can be written as:

x out (i) = N j=1 F θ (i,j) S * F θ (i,j) A * x in ( 6
)
where N is the number of filters at that scale. Since we have F θ (i,1)

A

= Id, we can also fix the corresponding synthesis filter F θ (i,1)

S = Id - N j=2 F θ (i,j) S * F θ (i,j)

A

. This trivially gives without thresholding, x out = x in . We implemented this constraint in the network, allowing to learn a different thresholding level for this filter.

The general case

In order to better understand the properties of exact reconstruction in the learnlets, we can study whether it is possible to enforce it as well for black-box residual neural networks. A simple solution, given a known noise level σ is to use the following general expression:

g θ (x, σ) = x -σf θ (x) (7)
where f θ is the output of the network without exact reconstruction. It can be noted that when σ tends to zero, then g θ (x, σ) → x and we can assure that the output will retrieve the input signal. It should be noted that this formulation might be unstable as it can amplify errors at high noise levels. This aspect will be analyzed in the next section.

Data and Experiments

The implementation was done in Python 3.6, using the TensorFlow 2.1 framework [START_REF] Abadi | TensorFlow: Large-Scale Machine Learning on Heterogeneous Systems[END_REF] for model design. The training was done on the Jean Zay public supercomputer, using for each job a single GPU Nvidia Tesla V100 SXM2 with 32GB of RAM.

Data

The data used was the BSD500 dataset [START_REF] Arbelaez | Contour Detection and Hierarchical Image Segmentation[END_REF]. This data consists of natural images of sizes 481 × 321 and 321 × 481. The train and tests subsets of BSD500 were used as the training dataset. The validation subset of BSD500, containing the BSD68 [START_REF] Martin | A Database of Human Segmented Natural Images and its Application to Evaluating Segmentation Algorithms and Measuring Ecological Statistics[END_REF] images was left out. We used BSD68 as the test dataset. This choice is motivated by the fact that many other denoising studies [START_REF] Zhang | Beyond a Gaussian denoiser: Residual learning of deep CNN for image denoising[END_REF], [START_REF] Lefkimmiatis | Universal denoising networks: a novel CNN architecture for image denoising[END_REF] use this dataset for comparison.

Pre-processing

For training, patches of size 256×256 were randomly extracted on-the-fly. The images were then linearly mapped from [0, 255] to the [-0.5, 0.5] interval and converted from RGB to grayscale using the function provided by TensorFlow2 . In addition, data augmentation techniques such as random flipping and random θ-degree (θ = 90°, 180°, 270°) rotations were applied. Noise was then added by first drawing uniformly at random in the specified interval Σ a noise level σ, then generating a 256 × 256 white Gaussian noise patch with this standard deviation. It is to note that during training, a single batch can feature different noise standard deviations.

At test time, the images were mirror-padded to a 352×512 size (or 512×352), in order to avoid shape mismatches when downsampling and upsampling, and the image quality metric was computed only on the original image shape. The test images were also corrupted by an additive white Gaussian noise for various standard deviations σ: {0.0001, 5, 15, 20, 25, 30, 50, 55, 60, 75, 85, 95, 100}. This allowed us to test the performance of our method in different noise level settings.

Model and training

Models design

We compare the learnets with the U-net for the task of denoising. For the U-net, we used the architecture described in [START_REF] Chul Ye | Deep convolutional framelets: A general deep learning framework for inverse problems[END_REF]Fig.10.(a)] which contains 124 million parameters for the case of a network with 128 base filters.

Unless specified otherwise, the learnlets parameters were chosen as:

-m = 5 scales.

-256 learnable analysis filters + 1 fixed analysis filters being just the identity, F θ (i)

A

, of size 11 × 11.

-257 learnable synthesis filters, F θ (i)

S

, of size 13 × 13.

-the thresholding levels only depend on the scale, θ

(ij) T = θ (i)
T . This amounts to 372k trainable parameters, only three hundredths of the size of the U-net.

Training parameters

The networks were both trained on the mean squared error in line with [START_REF] Minh Quan | Compressed sensing MRI reconstruction using a generative adversarial network with a cyclic loss[END_REF]. Each epoch consisted of 200 batches of 8 extracted patches, and their respective noise level in the case of the learnlets. The training noise standard deviation range was chosen as Σ = [0; 55]. The networks were trained with an Adam optimizer [START_REF] Diederik | Adam: A Method for Stochastic Optimization[END_REF]. The learning rate was set at 10 -3 , then decreased by half every 25 epochs, until it reached a minimum of 10 -5 . The trainings took about 8 hours for 500 epochs each.

Evaluation

Evaluation metric

For the evaluation of the performance of the different models we used the Peak Signal to Noise Ratio (PSNR) metric. It is defined image-wise as the following (with images taken in the [-0.5; 0.5] range):

P SN R(x, x) = -10 log 10 x -x 2 2 (8)
For each test noise standard deviation σ, we compute the mean of the PSNR of the denoised images, for all BSD68 images.

Testing

In addition, the networks were compared to wavelets denoising [START_REF] Mallat | A wavelet tour of signal processing[END_REF], which was implemented by using the code of PySAP [START_REF] Farrens | PySAP: Python Sparse Data Analysis Package for Multidisciplinary Image Processing[END_REF]. The wavelets family was the Biorthogonal 7.9, 5 scales were used, a hard-thresholding was used with a thresholding level of 3 (except for the first scale where it was 4). Table 1 Runtimes of the different models for the denoising of one image. Parameters used are the same as Figure 3.

Results

Quantitative results

Comparison with other methods

We compared the U-net and learnlets with exact reconstruction against algorithms not involving learning, namely wavelets shrinkage. Figure 3 shows that for a large part of the band [5; 55], where they have been trained, the wavelets have a performance that is degraded compared to the learnlets. Using learning, the learnlets enhance their decomposition power compare to the original wavelet model with no learning. For small noise level, the U-net gets degraded performances compared with learnlets with exact reconstruction and wavelets. In this setting, the denoiser must act as the identity. Finally, we can see that for unseen test noise levels (i.e. 95), the performance of U-net drops slightly while the learnlets keep relatively good performances. This suggests that the learnlets generalize better than U-nets on unseen noise levels.

In addition, we can see in Table 6.1.1 that the learnlets benefit from their GPU implementation and run faster than both the wavelets and U-net 128. We saw in Figure 3 that learnlets with exact reconstruction compete with classical methods for a wide range of noise standard deviations. Figure 4 shows that the performance of the network with forced exact reconstruction is almost the same as the one without forced exact reconstruction (we only lose 0.1dB at σ = 30 for example) on the majority of the test noise standard deviations. However, for low noise standard deviations, the network with forced exact reconstruction completely overpowers the other one. This is due to the fact that, at low noise standard deviations, for the i-th scale, the term x (i) out is practically the same as its thresholded version, because the thresholds θ

Learnlets with exact reconstruction

(ij)
T σ are going to be low. Therefore, it is compensated in the corresponding synthesis filter used for exact reconstruction at that scale, F θ (i,1)

A

. This allows to guarantee, in this case, no loss of information in the signal if it is clearly present.

U-nets of different sizes

Due to their reduced number of parameters, overfitting is a priori less likely to occur in small neural networks than in larger ones. Therefore, we studied whether the generalization to high noise levels would be better with small-sized U-nets. To do this, the number of base filters (see Appendix A) was modified with respect to the original case, obtaining Figure 5. We can see that deeper networks perform better for seen and unseen noise levels. In terms of generalization, the PSNR difference between U-nets with a low quantity of filters (4 or 8) and those with a larger amount (64 or 128) is amplified for the range [55; 100]. It was of interest to know if the exact reconstruction could be implemented in U-nets so as to avoid a large drop in performance for low noise levels. Figure 6 shows that the application of the general case equation (7) yields a PSNR ratio of approximately 1 when σ → 0. Apart from that, the PSNR remains similar for higher, but seen, noise standard deviations values (for instance, there is a loss of only 0.03dB at σ = 30). However, the exact reconstruction is incompatible with generalization at high noise levels in the case of U-nets, as can be observed from the low performance in the interval [55; 100]. Another interesting test to evaluate how a network generalizes consists in denoising images that are different from the training dataset. This is for instance similar to what was done in [START_REF] Nina | The troublesome kernel: why deep learning for inverse problems is typically unstable[END_REF], where letters were added in the test image, while no image contains letters in the training data set. Here we applied our trained neural networks on a simulated astronomical image, contaminated with noise of a standard deviation σ = 50. This experience complements the previous generalization ones where the test images belong to the same class of natural images, but some noise levels where higher than those in the training data.

U-net with exact reconstruction

Generalization test: Denoising astrophysical images

The astronomical image was firstly normalized such that every pixel had a value in the [-0.5; 0.5] interval and it was fed to pre-trained U-net and learnlet models. The noisy, original and denoised versions, as well as the subtraction of the latter to the original image are presented in Figure 7. Using the Mean Squared Error (MSE) metric, learnlets (MSE of 20.83) perform almost twice as well as U-nets (MSE of 41.25).

Hence, similarly to the previous experiment, the generalization is much better for learnlets than for U-nets.

Influence of the number of samples

In a lot of Computer Vision problems, training data is scarce. It is reasonable to think that a small network (i.e. low quantity of parameters) would start performing better than a deeper one as fewer samples become available. To test this, three models were examined: two U-nets of different sizes (8 and 64) and learnlets without exact reconstruction. The first aspect that can be mentioned about Figure 8 is that for the three networks the PSNR does not vary significantly when reducing the original number of samples all the way down to 50. Despite learnlets overcoming U-nets with 64 base filters for the lowest number of samples considered, they fail to outperform a U-net model with 8 base filters. It can be inferred that a reduced number of parameters tends to improve the robustness of a given neural network to the number of samples. In other words, relatively few samples are required to obtain top performance.

6.2 Qualitative results

Comparison with other methods

The Figure 9 shows that the learnlets suffer from some of the drawbacks of the wavelets like the creation of artifacts in the high frequency parts of the image. However the results are less blurred in comparison. Compared to the U-net, the learnlets are clearly suffering visually from a loss of contrast. This is a known effect of the soft thresholding which inherently biases the results. This could be improved by the use of reweighting [START_REF] Emmanuel | Enhancing sparsity by reweighted l1 minimization[END_REF] to further approach the hard-thresholding, which does not bias the results.

Conclusions

Pushing the limits of sparsity using massive learning and training data, we have proposed a novel neural net- work architecture -named Learnlets -with the following properties:

-Although their performances are inferior to U-nets, learnlets generalize better on noise levels that were not present in the training data and in the exact reconstruction domain. They also do better on the astronomical image which is different than the images present in the training dataset. In this case, the U-net's result is very poor. -Learnlets can be forced to guarantee exact reconstruction when no thresholding is applied. This allows an embedding of the learnlets in applications where there is a need for guarantees of retrieval like in medical imaging. By contrast, U-nets suffer from a loss of performance at high noise levels.

Learnlets therefore bridge the gap between parsimony and neural networks, by combining massive learning and the computing power of GPUs as in neural networks, but keeping a perfect understanding of how results are obtained, with all the theoretical guarantees existing in the area of parsimony. Learnlets do clearly not outperform U-nets in denoising images compatible with the training dataset, which would indicate that massive learning and large datasets are not enough to explain the difference between sparse techniques and neural networks. The highly non-linear processing in U-nets brings certainly a critical aspect in achieving high quality results.

Our main message is that we have clearly identified in this study a trade-off to be made in any application between performance and generalization. For performance, standard U-nets should clearly be chosen, while if the generalization is important, learnlets give the security of sparse techniques, with however using as well massive learning and GPU tools.

The future directions of this work are to try to adapt what has been successful in the sparse domain to this network. For example, reweighting [START_REF] Emmanuel | Enhancing sparsity by reweighted l1 minimization[END_REF] could help us to get rid of the loss of contrast. Curvelet filters [START_REF] Starck | The curvelet transform for image denois[END_REF] could also be used as a good initialisation or as complementary filters for the analysis. Apart from that, just like with the wavelets, many different types of noisesuch as Poisson or spatially non-uniform white Gaussian noise -could be taken into account with a single model when implemented in an undecimated way, by adapting the thresholding function to the noise. Finally, it would be interesting to study the impact of incorporating learnlets as building blocks of the DIDN architecture [25]. 3 and the original noisy images.

A U-net architecture Fig. 10 The U-net architecture. The amount of channels of each feature map is indicated on the top of the blue rectangles. In this case, the number of base filters is 64. Figure from [START_REF] Ronneberger | U-net: Convolutional networks for biomedical image segmentation[END_REF].

The Figure 10 shows the U-net architecture. It consists of:

-A contracting path that allows to capture context by applying convolutions, non-linearities (ReLU) and max pooling for downsampling. -An expanding path that contains upsampling and convolution operations.

B Values of figures

In Tables 2, 3, 4 and 5 there can be found all the PSNR values as a function of σ for each model in Figures 3,4, 5 and 6 respectively. Conversely,

Fig. 2

 2 Fig. 2 Visualization of learnlet analysis filters for four different scales.

Fig. 3

 3 Fig. 3 Ratio of the denoised image PSNR compared to the original noisy image PSNR for different standard deviations of the noise added to the test images for all considered models. The train noise standard deviation range was [0; 55].

Fig. 4

 4 Fig. 4 Ratio of the denoised image PSNR compared to the original noisy image PSNR for different standard deviations of the noise added to the test images for learnlets with and without forcing exact reconstruction. The train noise standard deviation range was [0; 55]. The number of filters used was 64.

Fig. 5

 5 Fig. 5 PSNR difference (in dB) with respect to wavelets denoising for different standard deviations of the noise added to the test images for U-nets of various sizes. The striped bars correspond to negative differences. The train noise standard deviation range was [0; 55].

Fig. 6

 6 Fig. 6 Ratio of the denoised image PSNR compared to the original noisy image PSNR for different standard deviations of the noise added to the test images for U-net with and without exact reconstruction. The train noise standard deviation range was [0; 55].

Fig. 7

 7 Fig. 7 Denoising results for an astrophysical image contaminated with a noise of σ = 50. The last two images correspond to the subtraction of the original image to its denoised version.

Fig. 8

 8 Fig. 8 The PSNR of the denoised image at σ = 25 added to the test images as a function of the number of samples used during training. The train noise standard deviation range was [0; 55].

Fig. 9

 9 Fig. 9 Denoising results for a specific image in the BSD68 dataset. The noise standard deviation used was of 30. Parameters used for the methods are the same as for Figure 3.

Table 2

 2 PSNR for different standard deviations of the noise added to the test images for every model in Figure

Table 3

 3 Table 6 corresponds to the information presented in Figure8. PSNR for different standard deviations of the noise added to the test images for both models in Figure4and the original noisy images.

	σ	Original Learnlets	Learnlets No exact recon.
	0.0001	128.13	124.69		43.56
	5.0		34.15	36.51		36.32
	15.0		24.61	30.87		30.81
	20.0		22.11	29.55		29.46
	25.0		20.17	28.54		28.44
	30.0		18.59	27.74		27.63
	50.0		14.15	25.58		25.45
	75.0		10.63	23.90		23.76
	85.0		9.54	23.38		23.21
	95.0		8.58	22.93		22.71
	100.0		8.13	22.71		22.50
	σ	Original U-net 4 U-net 8 U-net 64 U-net 128 Wavelets
	0.0001	128.13	39.89	43.67	52.60	53.29	127.30
	5.0	34.15	35.58	36.65	37.73	37.76	35.76
	15.0	24.61	30.53	31.06	31.65	31.67	29.56
	20.0	22.11	29.23	29.72	30.24	30.27	28.25
	25.0	20.17	28.26	28.73	29.21	29.24	27.32
	30.0	18.59	27.50	27.94	28.41	28.43	26.61
	50.0	14.15	25.49	25.88	26.30	26.31	24.79
	75.0	10.63	17.86	18.74	24.55	24.71	23.46
	85.0	9.54	14.93	15.74	23.52	23.74	23.06
	95.0	8.58	13.25	13.70	22.25	22.59	22.71
	100.0	8.13	12.60	12.94	21.65	22.14	22.56

Table 4

 4 PSNR for different standard deviations of the noise added to the test images for all the models in Figure5and the original noisy images.

	σ	Original U-net 64	U-net 64 Exact recon.
	0.0001	128.13	52.60	127.73
	5.0	34.15	37.73	37.77
	15.0	24.61	31.65	31.63
	20.0	22.11	30.24	30.22
	25.0	20.17	29.21	29.18
	30.0	18.59	28.41	28.38
	50.0	14.15	26.30	26.30
	75.0	10.63	24.55	22.64
	85.0	9.54	23.52	19.61
	95.0	8.58	22.25	16.53
	100.0	8.13	21.65	15.11

Table 5

 5 PSNR for different standard deviations of the noise added to the test images for both models in Figure6and the original noisy images.

	Samples U-net 8 U-net 64	Learnlets No exact recon.
	1	28.47	28.09	28.27
	5	28.72	29.19	28.42
	10	28.69	29.15	28.42
	50	28.74	29.23	28.44
	100	28.72	29.20	28.44
	200	28.71	29.22	28.44
	400	28.73	29.21	28.44

Table 6

 6 PSNR at σ = 25 added to the test images as a function of the number of samples used during training for the three models in Figure8.

https://www.tensorflow.org/api_docs/python/tf/ image/rgb_to_grayscale; TensorFlow Documentation for RGB to grayscale

Acknowledgements This work was granted access to the HPC resources of IDRIS under the allocation 2021-AD011011554 made by GENCI.