{'fraction_non_alphanumeric': 0.03119439820926362, 'fraction_numerical': 0.012426103426505195, 'mean_word_length': 4.73141447368421, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 1, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Exploring Overcomplete Representations for Single Image Deraining using CNNs

Removal of rain streaks from a single image is an extremely challenging problem since the rainy images often contain rain streaks of different size, shape, direction and density. Most recent methods for deraining use a deep network following a generic"encoder-decoder"architecture which captures low-level features across the initial layers and high-level features in the deeper layers. For the task of deraining, the rain streaks which are to be removed are relatively small and focusing much on global features is not an efficient way to solve the problem. To this end, we propose using an overcomplete convolutional network architecture which gives special attention in learning local structures by restraining the receptive field of filters. We combine it with U-Net so that it does not lose out on the global structures as well while focusing more on low-level features, to compute the derained image. The proposed network called, Over-and-Under Complete Deraining Network (OUCD), consists of two branches: overcomplete branch which is confined to small receptive field size in order to focus on the local structures and an undercomplete branch that has larger receptive fields to primarily focus on global structures. Extensive experiments on synthetic and real datasets demonstrate that the proposed method achieves significant improvements over the recent state-of-the-art methods.


I. INTRODUCTION
Images taken in outdoors are more susceptible to different weather conditions which decrease the visual quality of the captured images. This results in degradation of many highlevel computer vision tasks like video surveillance, image understanding, object detection and classification. In order to improve the performance of these tasks, it is important to develop algorithms that remove artifacts and recover the cleaner version of the degraded images. Rain is one of the most common weather condition that is responsible for poor performance of high-level computer vision algorithms in video surveillance and autonomous driving [1]. Removing rain streaks from the rainy images can considerably increase the performance of these vision tasks [2].
Deep Learning methods have risen to popularity in solving most of the computer vision tasks in the last decade. They have achieved state-of-the-art performance in many tasks like image classification, object detection, semantic segmentation and image restoration. Most of these methods are based on convolutional neural networks (CNNs). AlexNet [3] in 2012 showed how a deep network consisting of convolutional, maxpooling and fully-connected layers works very well for image classification task. Most of the methods that followed [4], [5] used a similar set of layers with changes in architecture for efficient learning. Seg-Net [6], an "encoder-decoder" type of deep network was proposed for the task of semantic segmentation which gave a significant improvement in the performance over previous methods. The main idea behind an "encoder-decoder" convolutional network architecture is that at the initial convolutional layers, the receptive field size of the filters are small and so capture low-level features like edges. The deeper layers in the network work on larger receptive field and so capture high-level features of the input image. The feature maps are projected onto a lower dimension similar to an undercomplete autoencoder. The decoder takes the feature maps back to the original resolution of the input image. U-Net [7] proposed using skip connections between the encoder and decoder network which showed a significant improvement in performance for image segmentation. Following the popularity of U-Net, it was the go-to network architecture serving as the backbone for many other tasks like image-to-image translation [8], [9], [10], image synthesis [11], image segmentation [12], medical image analysis [13], [14], [15], [16] and image restoration [1], [17], [18].
The noisy element can be different in each restoration problem, it can be small streaks in case of deraining, it can be larger patches in case of shadow removal or it can be grains of speckles in case of denoising problem. Using a generic "encoder-decoder" architecture like U-Net or its variant works well in most of the restoration problems as it captures both low-level features (in initial layers) and highlevel features (in deeper layers). However, there is a difference in the features that are to be given importance according to the restoration task at hand. In tasks like deraining where most of the rain streaks in the image are small; using a filter that has a very large receptive field is not useful as it does not learn any information about the rain streaks. For example, Fig. 1 shows that existing deraining methods based on ResNet and U-Net architectures are not able to remove rain streaks completely since they are not able to focus on meaningful low-level features. [19], [21], [22] which are based on ResNet architecture, fail to remove small rain streaks and fail to capture rain streaks in the sky as seen in Fig. 1. [7], [20] Rainy Image UNet [7] DDN [19] DIDMDN [20] RESCAN [21] SPAnet [22] OUCD (ours) Clean Image which are U-Net based architectures primarily focus on global level features and fail to remove small rain streaks and also remove some texture data as explained in [22], [23]. In this paper, we focus on extracting meaningful low-level features that can capture even the tiniest rain streaks and remove them.
To this end, we propose to use an overcomplete convolutional network architecture.
Before the deep learning era, overcomplete representations [24] have been used for many tasks where a robust method that could deal with noisy input was needed. Although overcomplete architectures have been mentioned in the literature [25], overcomplete convolutional architectures have not been explored for low-level vision tasks. Unlike an undercomplete convolutional network where the receptive field enlarges as we go deeper through the network, an overcomplete architecture restricts the enlargement of receptive field in the deeper layers (the reason is discussed in section III). This helps us to force the filters in all the layers of network focus on low-level features. Moreover, the deeper layers now learn more finer edges and focus on smaller objects than the initial layers which helps us to detect and eliminate rain streaks better. Though we state that low-level features are more important for the task of deraining, it does not mean that high-level features do not carry any meaning at all for this task. High level-features are also important as they help in properly reconstructing large structures and objects in the image. Hence, we propose a novel network architecture that combines both the overcomplete and undercomplete architectures in an efficient way for image deraining. We name our network Over-and-Under Complete Deraining (OUCD) Network. The overcomplete branch of our network focuses on learning low level features in high resolution thus capturing very fine features of rain streaks, while the undercomplete branch learns global features. Some of the feature maps from our network are illustrated in Fig.  1 (a),(b),(c) and (d). From these maps, it can be clearly seen that an overcomplete convolutional network branch captures the rain streaks clearly even in their deep layers as seen in Fig.  1 (a),(b) whereas the undercomplete network branch captures the building and sky in its deep layers as can be seen in Fig. 1 (c) and (d).
To summarize, this paper makes the following contributions: • We explore overcomplete representations in deep learning network architectures for image deraining. • We show how using an overcomplete architecture helps in capturing finer details of rain streaks more effectively. • We propose a novel deep network architecture, Overand-Under Complete Deraining (OUCD) Network, which combines both overcomplete and undercomplete networks so as to learn both low-level and high-level features of the rainy image effectively. • We achieve significant improvements in performance across many real and synthetic deraining datasets over the recent state-of-the-art methods.

II. RELATED WORK
We have witnessed great progress in the literature addressing the rain removal problems using the traditional image processing methods [26], [27], [28], [29] and convolutional neural networks (CNNs) [30], [31]. These rain removal methods can be broadly divided into video rain removal methods [32], [33], [34], [35], [36], [37], and single-image rain removal methods [26], [29], [38], [39], [22], [40], [41], [42], [43], [44], [45]. In this paper, we focus on single image rain removal problem. A captured rainy image y is mathematically modeled as the addition of rain streak information r (i.e called as residual map) with the clean image x as follows y = x + r. (1) Video-based methods: Video-based deraining methods are rich in temporal information, so one can use temporal consistency to ease the deraining problem. [32], [33], [34] exploit temporal information in different ways and make use of them to remove the rain information in videos. [36] proposed a method using multi-scale convolutional sparse coding model for the video rain streak removal that takes both characteristics of rain information into account like rain streaks follows multi-scale configurations and their patterns are sparsely scattered. [37] proposed a two-step architecture where they extract reliable motion information from the initially estimated derained image to align the frames and then model the motion in the second stage.
Single-image based methods: Early methods in the literature like [26], [27], [28], [29] for the rain removal task use traditional image processing techniques. They include techniques that address the rain removal problem using low-high frequency image decomposition [26], low-rank representation based [46], dictionary learning-based [47], and Gaussian mixture model-based methods [29]. Fu et al. [19], [48] introduced CNN-based methods in an end-to-end deep learning fashion to address the rain removal problem. Zhang et al. [20] proposed density aware multi-stream CNN where first they estimate density of rainy image and use it to fuse the features from different streams in order to derain the image. Qian et al.
proposed an attention based rain drop removal network where they use recurrent network based architecture to obtain the attention map. Li et al. [21] exploits the benefits of recurrent neural networks to preserve the useful contextual information of the earlier layers. Ren et al. [38] proposed a simpler baseline network that is based on ResNet and performs deraining in a progressive manner to obtain the final derained image. [49], [50] proposed rainy datasets that considers physics of rainy images formulation. Wang et al. [22] proposed a local to global procedure to derain the image using spatially attentive blocks. Yasarla et al. [23] proposed a mutliscale deraining method by modeling uncertainity in estimating residual at low scales and using them in computing the final derained image. Wei et al. [51] proposed a semi-supervised deraining method using Gaussian mixture models. Wang et al. [39] proposed a network that learns a mapping from low-quality embedding to a latent optimal vector by formulating a residual learning branch, that is capable of adaptively adding residuals between the original low-quality embedding to the latent vector in a entanglement representation manner. Yasarla et al. [52] proposed a semisupervised method to leverage rain information from real rain images in training the network using Guassian processes. Very recent works that propose using techniques like pyramid networks, contextual deep networks for image deraining can be found in [53], [54], [55].

III. PROPOSED METHOD
As discussed earlier, most image deraining methods are based on either an "encoder-decoder" architecture (U-Net based) or a residual architecture. These architectures do not focus much on the local features as the deeper layers of these networks have large receptive fields thus extracting high-level features. Although learning global-features is one of the main reasons an encoder-decoder architecture was used in the first place, it makes sense to use it for tasks like object detection, classification and segmentation as the object of interest in the image is comparatively larger. But in the task of deraining, the rain streaks are mostly small and are better detected when we use filters of small receptive field. To this end, we force our network to learn low-level features by restricting the receptive field from enlarging in the deeper layers of the network by using an overcomplete convolutional architecture. In an overcomplete architecture, the input image is taken into a higher dimension (spatially) unlike the undercomplete architecture. This happens as the max-pooling layers in an undercomplete architecture are replaced by upsampling layers. The receptive field increases in an undercomplete architecture by using a max-pooling layer along with a convolutional layer. During feed-forward, the feature maps of size k × k that go through a pooling layer of a coefficient n become (k/n) × (k/n). However, during back propagation, the flow of gradients go from a kernel of size k × k to nk × nk. This increases the receptive field size of the filters in the deeper layers of an undercomplete network resulting in the features to learn high-level global features of the image. In an overcomplete architecture, if we use an upsampling layer instead of max-pooling layer, we get an inverse effect of what happened before. The feature maps go from a size of k × k to the size of nk × nk after every upsampling layer. Thus, during back-propagation, the flow of gradients go from k × k to (k/n) × (k/n). Although each convolutional layer causes the receptive field to enlarge (depending on the kernel size of convolutional layer), the upsampling layer subdues this effect to some extent. Overall, an overcomplete convolutional architecture forces the receptive field to not increase as much as an undercomplete architecure does; resulting in the filters across all layers to learn low-level features.
In Fig. 2, we illustrate the feature maps of the overcomplete network taken across different layers when it is trained for deraining. We can observe that all the layers of the network learn to capture low-level features of the rain streaks properly. It can also be noted here that as we go deeper in the overcomplete architecture, the features captured are more finer as the receptive field is small and acts at a higher resolution of the input. In Fig. 3, we illustrate the feature maps across different layers of an undercomplete U-Net architecture. It can be seen that the feature maps in the deeper layers focus on learning global features which are not necessarily rain streaks. So, it is evident that for tasks such as deraining, low level features are much more useful and so we give more importance to low-level feature extraction in our proposed method as explained in the next sub-section.  A. OUCD Network Fig. 4 gives an overview of the proposed OUCD network. We use two network branches: an overcomplete and an undercomplete branch. The intuition behind using both the architectures is to make use of both local and global features. Although we focus more on the local features using the overcomplete branch, we do not leave out the global features altogether as they still have some meaningful information helpful for proper restoration of the image. In the overcomplete branch, we have 3 convolutional blocks in both encoder and decoder. Each convolutional block in the encoder has a 2D convolutional layer followed by an upsampling layer and ReLU activation. All the convolutional layers in our architecture have a kernel size of 3 × 3, stride of 1 and padding of 1 unless mentioned otherwise. For upsampling, we perform bilinear upsampling with a scale factor of 2. In the decoder, each convolutional block has a 2D convolutional layer followed by max-pooling layer and ReLU activation [56]. The max-pooling layer has a pooling coefficient of 2. We also have skip connections similar to U-Net [7] from the encoder layers to the decoder layers for better localization.
The undercomplete branch is similar to the standard U-Net architecture. It has 5 convolutional blocks in both encoder and decoder. Each convolutional block in the encoder consists of a 2D convolutional layer followed by a max-pooling layer and ReLU activation. Each convolutional block in the decoder consists of a 2D convolutional layer followed by an upsampling layer and ReLU activation. Both pooling and  Fig. 4: An overview of the proposed OUCD network architecture.
upsampling layers have coefficients of two. We also have skip connections from each block of the encoder to the corresponding block in the decoder, similar to U-Net architecture. More details regarding the network architectures corresponding to the overcomplete and undercomplete branches are provided in the Appendix.
As we have established that overcomplete branch extracts useful low-level features across all its layers, we propose to use all those feature maps for a better prediction for the deraining task as most of the rain streaks are low-level features. These feature maps capture very fine details than the initial layers of an undercomplete branch (U-Net) as the resolution of the image that the overcomplete network acts on is very high when compared to the initial layer of U-Net. So, we make use of all of these feature maps from the encoder of the overcomplete branch by adding them to the output of the first layer of the undercomplete branch. This helps in the later layers of the undercomplete branch to learn better global features. Similarly, all the feature maps in the decoder of overcomplete branch are added to the features maps of the undercomplete branch's decoder just before the last block. This facilitates better restoration at the decoder part as well. Before adding the feature maps from overcomplete branch, we pass it through Multi-Scale-Feature-Fusion (MSFF) block. The details of the MSFF block are given in the next subsection. Moreover, we add the last set of feature maps from the overcomplete branch with undercomplete branch before passing it on to the last convolutional layer. The last convolutional layer has 1 × 1 kernels to convert the feature maps into a 3-channel RGB image. This prediction is then compared with ground-truth using a loss function to calculate the gradients for backpropagation.

B. MSFF Block
We propose an MSFF block to transfer feature maps from different scales of the overcomplete branch to the undercomplete branch, transform them into the similar scales while also maintaining equal number of feature maps such that they have equal weightage when they are added. Fig. 5 illustrates the network architecture of the MSFF block. We use a convolutional block that consists of a downsampling layer followed by a 1 × 1 convolutional layer across each scale. The downsampling layer is used to downsample the feature maps into a scale as that of feature maps in the undercomplete branch it is going to be added to. We use bilinear interpolation for the downsampling operation. The scale factor for each scale is equal to the ratio of the size of feature map in the undercomplete branch to the size of the feature map at that particular scale. The 1 × 1 convolution layer is used to make the number of feature maps taken across different scales of the overcomplete network to be consistent so that all the feature maps have equal weightage when they are getting added to the undercomplete branch. Then the feature maps are added and are passed on to the undercomplete branch.
Loss Function: We use the standard 2 loss calculated between the predictedx and the ground truth x. It is defined as follows We also compute a perceptual loss [  VGG-16 network. It is defined as follows where N is the number of channels of F (.), and H and W denote the height and the width of the feature maps. Here, x denotes the ground truth andx denotes the predicted derained image. We take features from relu1 2, relu2 2 and relu3 2 of VGG-16 for computing the perceptual loss. The overall loss used to train the OUCD network is, where λ is a parameter which we set equal to 0.04 in our experiments.

IV. EXPERIMENTS AND RESULTS
In this section, we conduct experiments to compare the proposed OUCD method with state-of-the-art methods quantatively and qualitatively on both synthetic rain and real-world rainy images. We also conduct extensive ablation study to show the benefits of our proposed method over the U-Net and overcomplete base networks. We use Peak-Signal-to-Noise Ratio (PSNR) and Structural Similarity index (SSIM) as the comparative measures to evaluate the performance of different methods. For qualitative comparision and analysis, we visually present the sample results of different methods. We compare OUCD against the following state-of-the-art methods, • Discriminative sparse coding (DSC) [28](ICCV'15) • Gaussian mixture model (GMM) (GMM) [29] (CVPR'16) • Joint Rain Detection and Removal (JORDER) [58] (CVPR'17) • Deep detailed Network (DDN) [19](CVPR'17) • REcurrent SE Context Aggregation Net (RESCAN) [21] (ECCV'18) • SPatial Attentive Network (SPANet) [22] Training Dataset: We train the proposed network using synthetic rain datasets [20], [2] and real rain dataset [22]. The DIDMDN synthetic rain dataset published by the authors of [20], contains 4000 low density rain, 4000 medium density rain, and 4000 high density rain images for training. The Rain800 [2] synthetic rain dataset contains 700 training images. We also train our network on the real rain dataset proposed by the authors of SPANet [22] which contains 342 real rain frames for training.
Test Dataset: We evaluate the performance of OUCD against the state-of-the-art methods on the synthetic and real rain test datasets published by the authors of [29], [20], [22], [2]. DIDMDN [20] contains two test sets. Test-1 has a total of 1200 images where it is a combination of 400 low density, 400 medium density, and 400 high density images. Test-2 has a total 1000 images where the images are randomly sampled from the synthetic test set of Fu et al. [19]. The Rain12 dataset contains 12 images shared by the authors of [29]. The Rain800 test set provided by the authors of [2] contains 101 synthetic rain images. Authors of SPANet [22] published a real-world test set which contains 1000 real rainy images for testing. In addition to these test datasets, we also perform qualitative comparsions of different methods using real-world rainy images provided by the authors of [2], [22]. Implementation Details: We train the OUCD network with pairs of rainy and the corresponding clean images {y, x}, using the loss L defined in (2). We augment the input rainy image by randomly cropping 128×128 patches for training the network. We use the Adam optimizer [59] with the batchsize of 2 for optimizing the loss. We set the learning rate equal to 0.0002 for 30 epochs and 0.0001 for the remaining epochs. We implemented our network on the PyTorch framework and perform all the experiments using two NVIDIA RTX 2080Ti GPUs.

A. Quantitative Results
We compare OUCD network quantitatively against the stateof-the-art methods using the synthetic and real test set images mentioned earlier. Table I shows the quantitative comparisons. We can clearly observe that the OUCD network outperforms the current state-of-the-art methods. On heavy rain synthetic datasets like DIDMDN (both Test-1 and Test-2) and Rain800, our OUCD Network performs approximately ∼ 1dB better than the state-of-the-art methods in terms of PSNR. For low rain synthetic datasets like Rain12, OUCD also performs better than the current methods by ∼ 1.1dB. It is interesting to observe that OUCD outperforms the state-of-the-art methods by ∼ 1.25dB on real rainy dataset SPANet [22].
Note that our work proposes an architecture change that focuses on deraining. Our network can be used in place of U-Net or residual architectures along with a confidencebased loss functions [23] or progressive deraining [38] to even further improve the performance. In this paper, we have shown that we get significant performance improvements over the recent methods with just the architecture change, while using

OUCD (ours)
Ground-Truth Image Fig. 6: Qualitative comparisons of OUCD with recent methods on deraining of the test datasets of SPANet and Rain800. In the first image, most of the other methods fail to remove small rain streaks near the roof of the image whereas our proposed method produces a very clear image without any rain streaks. In the second image, though the other methods are able to remove the rain streaks, they fail to produce a proper reconstruction of the background. It can be seen that our method's output has a clearer background and is closer to the ground truth than the others. In the third image, all the previous methods fail to remove the tiny rain drops whereas OUCD removes all the rain drops.  Fig. 7: Qualitative comparisons of OUCD with recent methods on deraining for real-world rainy images. In both of the illustrated examples, it can be seen that OUCD gives better derained images than the other methods. In the first image, even though the other methods remove the dense streaks present in the top-right part of the image, they fail to remove the rain streaks of different patterns found near the roof. Our method removes rain streak of any pattern effectively. Also in the second image all the other methods remove the rain streaks which are far off effectively but fail to remove the rain streaks which are closer to the camera. As OUCD has two encoders, where one works on local features and another on global features, it can be seen that OUCD removes the rain streaks which are far away (small drops) and which are closer to camera (large drops) from the camera efficiently. Note that these are real images and do not come with ground truths.
only generic loss functions such as L2-loss and the perceptual loss.

B. Qualitative Results
We compare OUCD qualitatively against state-of-the-art methods using the SPANet and Rain800 test sets, and real rainy images shared by the authors of [22], [20]. It can be clearly observed from the Fig. 6 that OUCD performs visually better than the state-of-the-art methods on the SPANet and Rain800 test sets. From Fig. 6, we clearly see that the stateof-the-art methods which are based on Res-Net or U-Net architectures are not able remove the rain streaks on the tiles of the roof in the first image, and rain streaks on the tower and the house roof top in the second image. For example, DIDMDN [20], which is based on U-Net architecture, is not able to remove streaks from tiles on the roof in the first image, and rain streaks on clouds, roof tops and tower in the second image. This is due to the fact that U-Net based architectures do not focus much on local features as much as it should. DDN [19], RESCAN [21], SPANet [22], which are based on Res-Net, show a similar performance as they are not able to remove rain streaks where the removal of rain streaks is hard around the textured regions like tiles on the roof, near clouds and top of the tower. On the other hand, our OUCD network which focuses on features both locally and globally while deraining the image, produces sharp and visually pleasing derained images.
We observe similar trend in visual quality of these state-ofthe-art methods on real rainy images provided by the authors of [22], [20]. From Fig. 7 we can clearly observe that deraining

Rainy Image
Under-complete Over-complete Combined at last OUCD (ours) Ground-Truth Fig. 8: Qualitative comparisons corresponding to ablation study. The undercomplete network essentially removes relatively larger rain streaks and the overcomplete network removes smaller streaks. When the features from both the networks are combined in a conventional way (at last), they produce a better derained image when compared to separate networks. Our proposed method OUCD which combines the features using MSFF produces a better derained image compared to conventional fusion. methods [19], [20], [21] are not able remove rain streaks on the roof in the first image, and rain streaks on the tree in the second image. Even though SPANet [22] addresses the deraining problem using spatially attentive modules, the predicted derained image has small rain streaks present on the roof tile in the first image, and leaves of the tree in the second image of Fig. 7. Our method produces sharper derained images even on the real rainy images as shown in the Fig. 7. For example, tiles of the roof are more clear and sharp in the first derained image, and there are no rain streaks on the leaves of the tree in the second derained image of OUCD in Fig. 7.

C. Ablation Study
We perform an ablation study to show the impact of each block in our proposed method. We start our experiment with just a generic undercomplete architecture which is basically a U-Net. Then we test with an overcomplete architecture which focuses heavily on local features. From Table II, it can be seen that the overcomplete architecture gives a better performance than the undercomplete network. It can be noted here that the number of blocks and parameters used in the overcomplete architecture is relatively lesser. We then check the performance when both the overcomplete and undercomplete networks are trained in parallel and fused at the last layer (OUCD w/o MSFF block). This gives a boost in performance as the fused network has two branches where one solely focuses on lowlevel features while the other branch captures both low and high-level features thus the overall network does not lose out on global features altogether unlike the overcomplete architecture. Next, we experiment OUCD network while using our proposed MSFF block. Using the MSFF block to transfer the feature maps from the overcomplete branch to the undercomplete branch helps the undercomplete branch to train better as they now have better quality feature maps in the early layers which can facilitate better feature capturing in the deeper layers. This can be seen from Table II as we get a significant improvements when compared to just fusing the networks at the last layer. Figure 8 illustrates qualitative results corresponding to the ablation study.
V. CONCLUSION We propose using overcomplete convolutional deep networks for the task of image deraining. We showed that using overcomplete architectures help to restrict the receptive field size of the filters in the deeper layers. This helps the filters in deep layers to capture more low-level information and finer details than the generic "encoder-decoder" architectures or residual networks. Focussing on low-level features makes much more sense in the task of deraining as the rain streaks are generally of a small size in the rainy image. We proposed an Over-and-Under Complete Derain (OUCD) Network which takes advantage of both local and global features extracted from its overcomplete and undercomplete branches, respectively. We use a special Multi Scale Feature Fusion (MSFF) block to efficiently transfer feature maps from the overcomplete branch to the undercomplete branch so as to aid the undercomplete network's training with better low-level feature maps extracted in the overcomplete branch. We show that the filters in the overcomplete branch of our proposed network captures even the tiniest streaks of the rain precisely aiding in deraining, and the undercomplete branch captures objects and other structures in the image aiding in proper reconstruction. We tested our method on both real and synthetic rain datasets availble in the literature where we achieve better performance than many recent state-of-the-art methods. We achieve a significant performance boost with just an architecture change while using generic loss functions like L2 loss and the perceptual loss. We also perform an ablation study to show the impact of each block that we propose in this work.

APPENDIX A NETWORK ARCHITECTURE
Tables III and IV show the configuration of the undercomplete and overcomplete branches of our OUCD Network. Table  V shows the average inference time comparison between our proposed methods other state of the art methods. Total number of parameters in OCUD network are 1.1 × 10 7 .
APPENDIX B RECEPTIVE FIELD SIZE Fig. 9: Explanation for receptive field change difference between undercomplete network and overcomplete network.
Let I be the input image, F 1 and F 2 be the feature maps extracted from the conv blocks 1 and 2, respectively. The max-pooling layer present in these conv blocks of the U-Net is the main reason why receptive field is large in the successive layers. Let the initial receptive field of the conv filter be k×k on the image. The receptive field size change due to max-pooling layer is dependent on two variables-pooling coefficient and stride of the pooling filter. For convenience, the pooling coefficient and stride is both set as 2 in UNet. Considering this configuration, the receptive field of conv block 2 (to which F 1 is forwarded) on the input image would be 2 × k × 2 × k. Similarly, the receptive field of conv block 3 (to which F 2 is forwarded) would be 4 × k × 4 × k. This increase in receptive field can be generalized for i th layer in the UNet as follows: Now for our proposed overcomplete network, we have upsampling layer of coefficient 2 in our conv blocks replacing the max-pooling layer. As the upsampling layer actually works exactly opposite to that of max-pooling layer, the receptive field of conv bock 2 on the input image now would be Similarly, the receptive field of conv block 3 now would be 1 4 × k × 1 4 × k. This increase in receptive field can be generalized for i th layer in the overcomplete branch as follows: Note that the above calculations are based on a couple of assumptions. We assume that the pooling coefficient and stride is both set as 2 in both overcomplete and undercomplete network. Also we consider that the receptive field change caused by the conv layer in both undercomplete and overcomplete networks would be the same and do not consider in our calculations. This can be justified as we have maintained the conv kernel size to 3 × 3 with stride 1 and padding 1 throughout our network and this setting does not actually affect the receptive as much as max-pooling or upsampling layer does. The above explanations are illustrated in