Learning to Generate Realistic Noisy Images via Pixel-level Noise-aware Adversarial Training
Year: 2022

Abstract:
Existing deep learning real denoising methods require a large amount of noisyclean image pairs for supervision. Nonetheless, capturing a real noisy-clean dataset is an unacceptable expensive and cumbersome procedure. To alleviate this problem, this work investigates how to generate realistic noisy images. Firstly, we formulate a simple yet reasonable noise model that treats each real noisy pixel as a random variable. This model splits the noisy image generation problem into two subproblems: image domain alignment and noise domain alignment. Subsequently, we propose a novel framework, namely Pixel-level Noise-aware Generative Adversarial Network (PNGAN). PNGAN employs a pre-trained real denoiser to map the fake and real noisy images into a nearly noise-free solution space to perform image domain alignment. Simultaneously, PNGAN establishes a pixel-level adversarial training to conduct noise domain alignment. Additionally, for better noise fitting, we present an efficient architecture Simple Multi-scale Network (SMNet) as the generator. Qualitative validation shows that noise generated by PNGAN is highly similar to real noise in terms of intensity and distribution. Quantitative experiments demonstrate that a series of denoisers trained with the generated noisy images achieve state-of-the-art (SOTA) results on four real denoising benchmarks.

heading: 1 Introduction
text: Image denoising is an important yet challenging problem in low-level vision. It aims to restore a clean image from its noisy counterpart. Traditional approaches concentrate on designing a rational maximum a posteriori (MAP) model, containing regularization and fidelity terms, from a Bayesian perspective [1]. Some image priors like low-rankness [2, 3, 4], sparsity [5], and non-local similarity [6, 7] are exploited to customize a better rational MAP model. However, these hand-crafted methods are inferior in representing capacity. With the development of deep learning, image denoising has witnessed significant progress. Deep convolutional neural network (CNN) applies a powerful learning model to eliminate noise and has achieved promising performance [8, 9, 10, 11, 12, 13, 14]. These deep CNN denoisers rely on a large-scale dataset of real-world noisy-clean image pairs. Nonetheless, collecting even small datasets is extremely tedious and labor-intensive. The process of acquiring real-world noisy-clean image pairs is to take hundreds of noisy images of the same scene and average them to get the clean image. To get more image pairs, researchers try to synthesize noisy images.
In particular, there are two common settings for synthesizing noisy images. As shown in Fig. 1 (a1), setting1 directly adds the additive white Gaussian noise (AWGN) with the clean RGB image. For a long time, single image denoising [15, 16, 17, 18, 19, 10] is performed with setting1. Nevertheless, fundamentally different from AWGN, real camera noise is generally more sophisticated and signaldependent[20, 21]. The noise produced by photon sensing is further affected by the in-camera signal processing (ISP) pipeline (e.g., Gama correction, compression, and demosaicing). Models
∗Haoqian Wang is the corresponding author, email: wanghaoqian@tsinghua.edu.cn
35th Conference on Neural Information Processing Systems (NeurIPS 2021).
trained with setting1 are easily over-fitted to AWGN and fail in real noise removal. Setting2 is based on ISP-modeling CNN [22] and Poisson-Gaussian [21, 23] noise model that modeling photon sensing with Poisson and remaining stationary disturbances with Gaussian has been adopted in RAW denoising. As shown in Fig. 1 (a2), setting2 adds a Poisson-Gaussian noise with the clean RAW image and then passes the result through a pre-trained RAW2RGB CNN to obtain the RGB noisy counterpart. Notably, when the clean RAW image is unavailable, a pre-trained RGB2RAW CNN is utilized to transform the clean RGB image to its RAW counterpart [22]. However, setting2 has the following drawbacks: (i) The noise is assumed to obey a hand-crafted probability distribution. However, because of the randomness and complexity of real camera noise, it’s difficult to customize a hand-crafted probability distribution to model all the characteristics of real noise. (ii) The ISP pipeline is very sophisticated and hard to be completely modeled. The RAW2RGB branch only learns the mapping from the clean RAW domain to the clean RGB space. However, the mapping from the Poisson-Gaussian noisy RAW domain to the real noisy RGB space can not be ensured. (iii) The ISP pipelines of different devices vary significantly, which results in the poor generality and robustness of ISP modeling CNNs. Thus, whether noisy images are synthesized with setting1 or 2, there still remains a discrepancy between synthetic and real noisy datasets. We notice that GAN utilizes the internal information of the input image and external information from other images when modeling image priors. Hence, we propose to use GAN to adaptively learn the real noise distribution.
GAN is firstly introduced in [24] and has been proven successful in image synthesis [25, 26, 27] and translation [26, 27]. Subsequently, GAN is applied to image restoration and enhancement, e.g., super resolution [28, 29, 30], style transfer [27, 31], enlighten [32, 33], deraining [34], dehazing [35], image inpainting [36, 37], image editing [38, 39], and mobile photo enhancement [40, 41]. Although GAN is widely applied in low-level vision tasks, few works are dedicated to investigating the realistic noise generation problem [42]. Chen et al. [43] propose a simple GAN that takes Gaussian noise as input to generate noisy patches. However, as in general, this GAN is image-level, i.e., it treats images as samples and attempts to approximate the probability distribution of real-world noisy images. This image-level GAN neglects that each pixel of a real noisy image is a random variable and the real noise is spatio-chromatically correlated, thus results in coarse learning of the real noise distribution.
To alleviate the above problems, this work focuses on learning how to generate realistic noisy images so as to augment the training data for real denoisers. To begin with, we propose a simple yet reasonable noise model that treats each pixel of a real noisy image as a random variable. This noise model splits the noise generation problem into two sub-problems: image domain alignment and noise domain alignment. Subsequently, to tackle these two sub-problems, we propose a novel Pixel-level Noise-aware Generative Adversarial Network (PNGAN). During the training procedure of PNGAN, we employ a pre-trained real denoiser to map the generated and real noisy images into a nearly noise-free solution space to perform image domain alignment. Simultaneously, PNGAN establishes a pixel-level adversarial training that encourages the generator to adaptively simulate the real noise distribution so as to conduct the noise domain alignment. In addition, for better real noise fitting, we present a lightweight yet efficient CNN architecture, Simple Multi-scale Network (SMNet) as the generator. SMNet repeatedly aggregates multi-scale features to capture rich auto-correlation, which provides more sufficient spatial representations for noise simulating. Different from general image-level GAN, our discriminator is pixel-level. The discriminator outputs a score map. Each position on the score map indicates how realistic the corresponding noisy pixel is. With this pixellevel noise-aware adversarial training, the generator is encouraged to create solutions that are highly similar to real noisy images and thus difficult to be distinguished.
In conclusion, our contributions can be summarized into four points:
(1) We formulate a simple yet reasonable noise model. This model treats each noisy pixel as a random variable and then splits the noisy image generation into two parts: image and noise domain alignment.
(2) We propose a novel framework, PNGAN. It establishes an effective pixel-level adversarial training to encourage the generator to favor solutions that reside on the manifold of real noisy images.
(3) We customize an efficient CNN architecture, SMNet learning rich multi-scale auto-correlation for better noise fitting. SMNet serves as the generator in PNGAN costing only 0.8M parameters.
(4) Qualitative validation shows that noise generated by PNGAN is highly similar to real noise in terms of intensity and distribution. Quantitative experiments demonstrate that a series of denoisers finetuned with the generated noisy images achieve SOTA results on four real denoising benchmarks.

heading: 2 Proposed Method
text: As shown in Fig. 1, the pipeline of using PNGAN to perform data augmentation consists of three phases. (a) is the synthesizing phase. (a1) and (a2) are two common synthetic settings. In this phase, we produce the synthetic noisy image from its clean RGB or RAW counterpart. (b) is the training phase of PNGAN. The generator G adopts the synthetic image as input. Which synthetic setting is selected is controlled by the switch. By using a pre-trained real denoiser Dd, PNGAN establishes a pixel-level noise-aware adversarial training between the generator G and discriminator D so as to simultaneously conduct image and noise domain alignment. Dd is set as RIDNet [44] in this work. (c) is the finetuning phase. Firstly, in (c1), the generator creates extended fake noisy-clean image pairs. Secondly, in (c2), the fake and real data are jointly utilized to finetune a series of real denoisers.

heading: 2.1 Pixel-level Noise Modelling
text: Real camera noise is sophisticated and signal-dependent. Specifically, in the real camera system, the RAW noise produced by photon sensing comes from multiple sources (e.g., short noise, thermal noise, and dark current noise) and is further affected by the ISP pipeline. Besides, illumination changes and camera movement inevitably lead to spatial pixel misalignment and color or brightness deviation. Hence, hand-designed noise models based on mathematical assumptions are difficult to accurately and completely describe the properties of real noise. Different from previous methods, we don’t base our noise model on any mathematical assumptions. Instead, we use CNN to implicitly simulate the characteristics of real noise. We begin by noting that when taking multiple noisy images of the same scene, the noise intensity of the same pixel varies a lot. Simultaneously, affected by the ISP pipeline, the real noise is spatio-chromatically correlated. Thus, the correlation between different pixels of the same real noisy image should be considered. In light of these facts, we treat each pixel of a real noisy image as a random variable and formulate a simple yet reasonable noise model:
Irn[i] = Îclean[i] +N[i], Dd(Irn)[i] = Îclean[i], 1 ≤ i ≤ H ×W, (1)
where Îclean ∈ RH×W×3 is the predicted clean counterpart of Irn, it’s denoised by Dd. Each N[i] is a random noise variable with unknown probability distribution. Therefore, each Irn[i] can also be viewed as a distribution-unknown random variable. Now we aim to design a framework to generate a fake noisy image Ifn ∈ RH×W×3 such that the probability distribution of Ifn[i] and Irn[i] is as close as possible. Please note that the mapping learned by Dd is precisely from Irn to Îclean. If the constant in Eq. (1) is set as the clean image Iclean ∈ RH×W×3, the subsequent domain alignment will introduce unnecessary errors and eventually lead to inaccurate results.

heading: 2.2 Pixel-level Noise-aware Adversarial Training
text: Our goal is to generate realistic noisy images. According to the noise model in Eq. (1), we split this problem into two sub-problems: (i) Image domain alignment aims to align Îclean[i]. (ii) Noise domain alignment targets at modeling the distribution of N[i]. To handle the sub-problems, PNGAN establishes a novel pixel-level noise-aware adversarial training between G and D in Fig. 1 (b).
Image Domain Alignment. A very naive strategy to construct both image and noise domain alignment is to directly minimize the distance of Ifn and Irn. However, due to the intrinsic randomness, complexity, and irregularity of real noise, directly deploying L1 loss between Ifn and Irn is unreasonable and drastically damages the quality of Ifn. Besides, as analyzed in Sec. 2.1, each pixel of Irn is a distribution-unknown random variable. This indicates that such a naive strategy challenges the training and may easily cause the non-convergence issue. Therefore, the noise interference should be eliminated while constructing the image domain alignment. To this end, we feed Ifn and Irn into Dd to obtain their denoised versions and then perform L1 loss between Ifn and Irn:
L1 = H×W∑ i=1 ∣∣∣∣Dd(Ifn)[i]−Dd(Irn)[i]∣∣∣∣1 = H×W∑ i=1 ∣∣∣∣Dd(Ifn)[i]− Îclean[i]∣∣∣∣1. (2) By using Dd, we can transfer Irn and Ifn into a nearly noise-free solution space. The value of Îclean is relatively stable. Therefore, minimizing L1 can encourage G to favor solutions that after being denoised by Dd converge to Îclean. In this way, the image domain alignment is constructed.
Noise Domain Alignment. Becasue of the complexity and variability of real noise, it’s hard to completely seperate N[i] from Irn[i] in Eq (1). Fortunately, we note that on the basis of constructing the image domain alignment of Îclean[i], the noise domain alignment of N[i] is equivalent to the distribution estimation of Irn[i]. Additionally, as the real noise is signaldependent, the alignment between Ifn[i] and Irn[i] is more beneficial to capture the correlation between noise and scene. We denote the
distribution of Irn[i] as Pdata(xi), some real noisy pixel samples of Irn[i] as {x1i , x2i , ..., xmi } such that xki ∼ Pdata(xi), and the distribution of Ifn[i] as PG(xi; θG). Here θG is the parameter of G. Then we formulate the noise domain aligment into a maximum likelihood estimation problem:
θ∗G = arg max θG H×W∑ i=1 m∑ k=1 logPG(x k i ; θG) = arg max θG Ei [ Exki [ logPG(x k i ; θG) ] ] , (3)
where E means taking the average value. To approach this upper bound as close as possible, we present D and establish the pixel-level adversarial traininig between G and D. The architecture of D is shown in Fig. 2. D consists of 4 convolutional (conv) layers and utilizes LeakyReLU activation (α = 0.2). General discriminator treats a image as a sample and outputs a score indicating how realistic the image is. Instead, D is a pixel-level classifier. D adopts the fake and real noisy images as input in a mini-batch and outputs a score map P ∈ RH×W for each image. Specifically, the information of P[i] ∈ [0, 1] is the probability value indicating how realistic PG(xi; θG) is. G aims to generate more realistic Ifn[i] to fool D while D targets at distinguishing Ifn[i] from Irn[i]. According to Eq .(3), we formulate the adversarial training between G and D as a min-max problem:
min θG max θD
Ei [ EIrn [log(D(Irn; θD)[i])] ] + Ei [ EIfn [log(1−D(Ifn; θD)[i])] ] , (4)
where EIrn and EIfn respectively represent the operation of taking the average for all fake and real data in the mini-batch. As analyzed in [45], to make GANs analogous to divergence minimization and produce sensible predictions based on the a priori knowledge that half of the samples in the mini-batch are fake, we utilize the recently proposed relativistic discriminator [45] as follow:
D(Irn; θD) = σ(CD(Irn)), DRa(Irn, Ifn) = σ(CD(Irn)− EIfn(CD(Ifn))), D(Ifn; θD) = σ(CD(Ifn)), DRa(Ifn, Irn) = σ(CD(Ifn)− EIrn(CD(Irn))),
(5)
where DRa denotes the relativistic discriminator, σ means the Sigmoid activation, and CD represents the non-transformed discriminator output. DRa estimates the probability that real data is more realistic than fake data and also directs the generator to create a fake image that is more realistic than real images. The loss functions of D and G are then defined in a symmetrical form:
LD = −Ei [ EIrn [log(DRa(Irn, Ifn)[i])] + EIfn [log(1−DRa(Ifn, Irn)[i])] ] ,
LG = −Ei [ EIrn [log(1−DRa(Irn, Ifn)[i])] + EIfn [log(DRa(Ifn, Irn)[i])] ] .
(6)
During the training procedure, we fix D to train G and fix G to train D iteratively. Minimizing LG and LD alternately allows us to train a generative model G with the goal of fooling the pixel-level discriminator D that is trained to distinguish fake noisy images from real noisy images. This pixellevel noise-aware adversarial training scheme encourages G to favor perceptually natural solutions that reside on the manifold of real noisy images so as to construct the noise domain alignment.

heading: 2.3 Noisy Image Generating
text: In Sec. 2.1, we denote the probability distribution of Ifn[i] as PG(xi; θG). Now we customize a light-weight yet efficient CNN architecture, SMNet as G to generate PG(xi; θG). In this section, we firstly introduce the input setting of G and subsequently detail the architecture of SMNet.
Input Setting. We aim to generate a realistic noisy image from its clean counterpart. A naive setting is to directly adopt the clean image as the input to generate the noisy image. However, this naive setting is not in line with the fact. When we repeatedly feed the same clean image to a pre-trained G, G outputs completely the same noisy images. In contrast, when taking multiple pictures in the real world, the real noisy images vary a lot in the intensity of each pixel. This is caused by many factors (e.g., photon sensing noise, ISP pipelines, and illumination conditions). Hence, the naive input setting containing no distribution is unreasonable. We review that the general GANs sample from an initial random distribution (usually Gaussian) to generate a fake image. Hence, the input of G should contain a random distribution so as to generate multiple noisy images of the same scene. We note that the two common synthetic settings meet this condition. Therefore, we utilize the two common settings to produce the synthetic image and then adopt the synthetic image as the input of G. Subsequently, we propose a light-weight yet efficient architecture, SMNet for better real noise fitting.
SMNet Architecture. The architecture of SMNet is shown in Fig. 3 (a). SMNet involves t Simple Residual Groups (SRG) and each SRG contains nMulti-scale Attention Blocks (MAB). The synthetic input Isyn ∈ RH×W×3 continuously undergoes a conv layer f1, t SRGs, and a conv layer f2, then adds with a long identity mapping for efficient residual learning to eventually generate the fake noisy counterpart Ifn ∈ RH×W×3. This process can be formulated as:
Ifn = Isyn + f2(St(FSt)), FSj+1 = Sj(FSj ), FS1 = f1(Ifn), (7)
where Sj denotes the jth SRG, 1 ≤ j ≤ t−1. The components of SRG are depicted in Fig. 3 (b). We define the input feature of the jth SRG as FSj ∈ RH×W×C and its channel as C. FSj continuously undergoes a conv layer, n MABs, and a conv layer to add with an identity mapping:
FSj+1 = FSj +M j n(FMjn), FMjk+1 =M jk(FMjk ), FMj1 = FSj , (8)
where M jk denotes the kth MAB of the jth SRG, 1 ≤ k ≤ n − 1. MAB is the basic building block and the most significant component of SMNet. The details of MAB are depicted in Fig. 3 (c). We customize MAB with the following motivations: (i) Multi-scale feature fusion can increase the receptive field and multi-resolution contextual information can cover rich auto-correlation, which provides more sufficient spatial representations for noise fitting. (ii) The noise level decreases as the scale increases and nonlinear sampling operations can increase the richness of the mapping in the potential space of real noise. Therefore, we exploit parallel multi-resolution branch aggregation from top to bottom and bottom to top to facilitate the learning of complex real noise. (iii) Specifically, during the feature downsampling, general downsample operation damages the image information, resulting in pixel discontinuity and jagged artifact. To alleviate these issues, we exploit ShiftInvariant Downsample [46] that copes with the discontinuity by using continuous pooling and
filtering operation, preserving rich cross-correlation information between original and downsampled images. (iv) To efficiently capture continuous channel correlation and avoid information loss, we use the 1D channel attention module, Fast Channel Attention (FCA) instead of the general 2D convolution attention module. The input feature, FMjk ∈ R H×W×C is fed into three parallel multi-scale paths:
F1 Mjk = FCA(FMjk ), F2 Mjk = f2up(FCA(f 2 sid(FMjk ))), F4 Mjk = f4up(FCA(f 4 sid(FMjk ))), (9)
where FCA denotes Fast Channel Attention. f2up denotes a conv layer after bilinear interpolation upsampling, 2 is the scale factor. f4up is similarly defined. f 2 sid means Shift-Invariant Downsample [46], 2 is also the scale factor. f4sid is similarly defined. Subsequently, the output feature is derived by:
M jk(FMjk ) = FMjk + f([F1 Mjk ,F2 Mjk ,F4 Mjk ]), (10)
where f represents the last conv layer, [·, ·, ·] denotes the concatenating operation. The architecture of FCA is shown in Fig. 3 (d). We define the input feature as Fd, then FCA can be formulated as:
FCA(Fd) = Fd · ( 1 + σ ( f1DC(GAP (Fd)) )) , (11)
where σ represents the Sigmoid activation function, GAP means global average pooling along the spatial wise, f1DC denotes 1-Dimension Convolution. In this work, we set t = 3, n = 2, and C = 64.

heading: 2.4 Overall Training Objective
text: In addition to the aforementioned losses, we employ a perceptual loss function that assesses a solution with respect to perceptually relevant characteristics (e.g., the structural contents and detailed textures):
Lp = ∣∣∣∣V GG(Ifd)− V GG(Ird)∣∣∣∣22, Ifd = Dd(Ifn), Ird = Dd(Irn), (12)
where V GG denotes the last feature map of VGG16 [56]. Eventually, the training objective is:
L = L1 + λp · Lp + λRa · (LD + LG), (13)
where λp and λRa are two hyper-parameters controlling the importance balance. The proposed PNGAN framework is end-to-end trained by minimizing L. Note that the parameters in Dd and VGG16 are fixed. Each mini-batch training procedure is divided into two steps: (i) Fix D and train G. (ii) Fix G and train D. This pixel-level adversarial training scheme promotes D the ability to distinguish fake noisy images from real noisy images and allows G to learn to create the solutions that are highly similar to real camera noisy images and thus difficult to be classified by D.

heading: 3 Experiment

heading: 3.1 Experiment Setup
text: Datasets. We first use SIDD [47] train set to train Dd. Then we fix Dd to train G on the same set. Subsequently, G uses clean images from DIV2K [57], Flickr2K [58], BSD68 [59], Kodak24 [60], and Urban100 [61] to generate realistic noisy-clean image pairs. We use the generated data and SIDD train set jointly to finetune real denoisers and evaluate them on four real denoising benchmarks: SIDD [47], DND [48], PolyU [40], and Nam [49]. The images in SIDD [47] are collected using five smartphone cameras in 10 static scenes. There are 320 image pairs for training and 1,280 image patch pairs for validation. DND [48] composes 50 noisy-clean image pairs captured by 4 consumer
cameras. 1,000 patches at size 512×512 are cropped from the collected images. PolyU [40] consists of 40 real camera noisy images. Nam [49] is composed of real noisy images of 11 static scenes.
Implementation Details. We set the hyper-parameter λp = 6×10−3, λRa = 8×10−4. For synthetic setting1, we set the noise intensity, σn = 50. For synthetic setting2, we directly exploit CycleISP to generate the synthetic noisy input. All the sub-modules (Dd, G, and D) are trained with the Adam [62] optimizer (β1 = 0.9 and β1 = 0.9999) for 7×105 iterations. The initial learning rate is set to 2×10−4. The cosine annealing strategy [63] is employed to steadily decrease the learning rate from the initial value to 10−6 during the training procedure. Patches at size 128×128 cropped from training images are fed into the models. The batch size is set as 8. The horizontal and vertical flips are performed for data augmentation. All the models are trained on RTX8000 GPUs. In the finetuning phase, the learning rate is set to 1×10−6, other settings remain unchanged.

heading: 3.2 Quantitative Results
text: Domain Discrepancy Validation. We use the widely applied metric, Maximum Mean Discrepancy (MMD) [64] to measure the domain discrepancy between synthetic and real-world noisy images, PNGAN generating, and real noisy images on four real noisy benchmarks. For DND, we derive a pseudo clean version by denoising the real noisy counterparts with a pre-trained MIRNet [55]. Then we use the pseudo clean version to synthesize noisy images. The results are depicted as a histogram in Fig. 4. For setting1, the domain discrepancy decreases by 74%, 75%, 44%, and 43% on SIDD, DND, PolyU, and Nam when PNGAN is exploited. For setting2, the discrepancy decreases by 64%, 67%, 46%, and 44%. These results demonstrate that PNGAN can narrow the discrepancy between synthetic and real noisy datasets. Please refer to the supplementary for detailed calculation process.
Comparison with SOTA Methods. We use the generated noisy-clean image pairs (setting2) to finetune a series of denoisers. We compare our models with SOTA algorithms on four real denoising datasets: SIDD, DND, PolyU, and Nam. The results are reported in Tab. 1. * denotes denoisers finetuned with image pairs generated by PNGAN. We have the following observations: (i) Our denoisers outperform SOTA methods by a large margin. Specifically, MPRNet* and MIRNet* exceed the recent best method MIRNet by 0.34 and 0.35 dB on SIDD, 0.30 and 0.37 dB on DND. RIDNet*, MPRNet*, and MIRNet* surpass the best performers by 0.36, 1.30, and 1.37 dB on PolyU and 0.01, 1.04, and 1.10 dB on Nam. (ii) Compared with the counterparts that are not finetuned, our models achieve a significant promotion. In particular, RIDNet* is 0.54, 0.29, 0.68, and 0.49 dB higher than RIDNet on SIDD, DND, PolyU, and Nam. MPRNet* achieves 0.35, 0.38, 1.41, and 1.31 dB gain than MPRNet on SIDD, DND, PolyU, and Nam. MIRNet* is improved by 0.35, 0.37, 1.37, and 1.21 dB. This evidence clearly suggests the high similarity between PNGAN generating and real noisy images. Denoisers adapted with our fake image pairs generalize better across different benchmarks.
Train from Scratch. For more strong comparisons, we use the fake noisy images generated from clean SIDD train and DF2K (DIV2K+Flicker2K) respectively to train denoisers from scratch. The PSNR results evaluated on SIDD test are listed in Tab. 2. All models are trained with the same experiment schedule except the training data. It can be observed: (i) On SIDD train, when PNGAN is applied to setting1, denoisers are promoted by ∼ 15.65 dB and only ∼ 0.84 dB lower than those
trained with real data (SIDD train set). While applying PNGAN to setting2 (CycleISP), denoisers are improved by∼ 2.87 dB. Surprisingly, in this case, denoisers achieve almost the same performance as those trained with real data. The relative error is 0.2%. (ii) To validate the generality of PNGAN, we also adopt synthetic DF2K noisy-clean image pairs to train denoisers. As shown in the right part of Tab. 2, when PNGAN is applied to setting1, denoisers are promoted by ∼ 9.59 dB. While applying PNGAN to setting2, denoisers are improved by ∼ 4.35 dB and only ∼ 0.75 dB lower than those trained with SIDD real train set. These results convincingly demonstrate: (i) The generated noise is highly similar to the real noise especially when PNGAN is applied to synthetic setting2. (ii) PNGAN can significantly narrow the domain discrepancy between synthetic and real-world noise.

heading: 3.3 Qualitative Results
text: Visual Examinations of Noisy Images. To intuitively evaluate the generated noisy images, we provide visual comparisons of noisy images on the four real noisy datasets, as shown in Fig. 5. Note that the clean image of DND is pseudo, denoised from its noisy version by a MIRNet. The left part depicts noisy images from SIDD, DND, PolyU, and Nam (top to down). The right part exhibits the patches cropped by the yellow bboxes, from left to right: clean, synthetic setting1, setting2 (CycleISP), PNGAN generating, and real noisy images. As can be seen from the zoom-in patches: (i) Noisy images synthesized by setting1 is signal-independent. The distribution and intensity remain unchanged across diverse scenes, indicating the characteristics of AWGN fundamentally differ from those of the real noise. (ii) Noisy images generated by PNGAN are closer to the real noise than those synthesized by setting2 visually. Noise synthesized by setting2 shows randomness that is obviously inconsistent with the real noise in terms of intensity and distribution. While PNGAN can model spatio-chromatically correlated and non-Gaussian noise more accurately. (iii) Even if passing through the same camera pipeline, different shooting conditions lead to the diversity of real noise. It’s unreasonable for the noise synthesized by CycleISP to show nearly uniform fitting to different input images. In contrast, PNGAN can adaptively simulate more sophisticated and photo-realistic models. This adaptability allows PNGAN to show robust performance across different real noisy datasets.
Visual Comparison of Denoised Images. We compare the visual results of denoisers before and after being finetuned (denoted with *) with the generated data in Fig. 4. We observe that models finetuned with the generated data are more effective in real noise removal. Furthermore, they are capable of preserving the structural content, textural details, and spatial smoothness of the homogeneous regions. In contrast, original models either yield over-smooth images sacrificing fine textural details and structural content or introduce redundant blotchy texture and chroma artifacts.

heading: 3.4 Ablation Study
text: Break-down Ablations. We perform break-down ablations to evaluate the effects of PNGAN components and SMNet architecture. We select setting1 to synthesize the noisy input from SIDD train set. Then we use the generated data only to train the denoisers from scratch and evaluate them on SIDD test. The PSNR results are reported in Tab. 3. (i) Firstly, G is set as SMNet to validate the effects of PNGAN components. We start from Baseline1, no discriminator is used and the L1 loss is
(dB)
(×𝟏𝟎#𝟑)
PSNR
Analysis of Parameter 𝝀𝒑
PSNR
(×𝟏𝟎#𝟑)
(dB)
Analysis of Parameter 𝝀𝑹𝒂 PSNR(dB) Analysis of Parameter 𝝈𝒏
Figure 7: Parameter analysis of λp, λRa, and σn.
directly performed between Ifn and Irn in Eq. (2). Denoisers trained with the generated data collapse dramatically, implying the naive strategy mentioned in Sec. 2.2 is unfeasible. When Dd is applied, the denoisers are promoted by 21.81 dB on average. In addition, the PSNR and SSIM between the denoised counterparts of generated and real noisy images are 39.14 dB and 0.928 on average respectively. This evidence indicates that Dd successfully conducts the image domain alignment as mentioned in Sec. 2.2. Subsequently, we use an image-level D with stride conv layers to classify whether the whole generated image is real. Nonetheless, the performance of denoisers remains almost unchanged. After deploying D, the models are improved by ∼2.09 dB, suggesting that the pixel-level noise model is more in line with real noise scenes and benefits generating more realistic noisy images. When Lp is used, the denoisers gain a slight improvement by about 0.39 dB, indicating Lp facilitates yielding more vivid results. (ii) Secondly, we only change the architecture of G to study the effects of its components. We start from Baseline2 that doesn’t exploit multi-scale feature fusion, SID, and FCA. When we add two different scale branches and use bilinear interpolation to downsample and upsample, denoisers trained with the generated images are promoted by about 1.28 dB. After applying SID and FCA, the denoisers further gain 0.28 and 0.74 dB improvement on average. These results convincingly demonstrate the superiority of the proposed SMNet in real-world noise fitting.
Parameter Analysis. We adopt RIDNet as the baseline to perform parameter analysis. We firstly validate the effects of λp , λRa in Eq. (13), and the noise intensity of setting1, i.e., σn. We change the parameters, train G, use G to generate realistic noisy images from clean images of SIDD train set, train RIDNet with the generated data, and evaluate its performance on SIDD test set. When analyzing one parameter, we fix the others at their optimal values. The PSNR results are shown in Fig. 7. The optimal setting is λp = 6×10−3, λRa = 8×10−4, and σn = 40 or 50. Secondly, we evaluate the effect of the ratio of finetuning data. We denote the ratio of extended training data (setting2) to SIDD real noisy training data as q. We change the value of q, finetuned the original RIDNet, and test on three real denoising datasets: SIDD, PolyU, and Nam. The results are listed in Tab. 4. When q = 0, all the finetuning data comes from SIDD train set, RIDNet achieves the best performance on SIDD. However, its performance on PolyU and Nam degrades drastically due to the domain discrepancy between different real noisy datasets. We gradually increase the value of q to study its effects. The average performance on the three datasets yields the maximum when q = 60%.

heading: 4 Conclusion
text: Too much research focuses on designing a CNN architecture for real noise removal. In contrast, this work investigates how to generate more realistic noisy images so as to boom the denoising performance. We first formulate a noise model that treats each noisy pixel as a random variable. Then we propose a novel framework PNGAN to perform the image and noise domain alignment. For better noise fitting, we customize an efficient architecture, SMNet as the generator. Experiments show that noise generated by PNGAN is highly similar to real noise in terms of intensity and distribution. Denoisers finetuned with the generated data outperform SOTA methods on real denoising datasets.

heading: Acknowledgement
text: This work is jointly supported by the NSFC fund (61831014), in part by the Shenzhen Science and Technology Project under Grant (ZDYBH201900000002, JCYJ20180508152042002, CJGJZD20200617102601004).

Review summaries:
The authors propose a pixel-level noise-aware generative adversarial network (PNGAN). They improve the denoising performance by generating more realistic noisy images.  Quantitative experiments prove that the performance of the existing denoising model can be significantly improved after being trained with the synthetic realistic noisy images.

This paper proposes a new method to simulate the real-world noisy images, which seems further improve the performance of current deep denoiser. A slight and effective generator is elaborately designed, and may facilitates the research of noise generation. Besides, the proposed method combines lots of existing deep learning technologies, and surpasses the current SoTA by a large margin.