CT-SRCNN: Cascade Trained and Trimmed Deep Convolutional Neural Networks for Image Super Resolution
We propose methodologies to train highly accurate and efficient deep convolutional neural networks (CNNs) for image super resolution (SR). A cascade training approach to deep learning is proposed to improve the accuracy of the neural networks while gradually increasing the number of network layers. Next, we explore how to improve the SR efficiency by making the network slimmer. Two methodologies, the one-shot trimming and the cascade trimming, are proposed. With the cascade trimming, the network’s size is gradually reduced layer by layer, without significant loss on its discriminative ability. Experiments on benchmark image datasets show that our proposed SR network achieves the state-of-the-art super resolution accuracy, while being more than 4 times faster compared to existing deep super resolution networks.
Super resolution (SR) aims to retrieve a high resolution (HR) image from a given low resolution (LR) image. SR is widely used in many computer vision applications such as surveillance, face and iris recognition, and medical image processing. There have been many SR algorithms proposed recently [1, 2]. Some early methods referred to interpolations, statistical image priors [3, 4] or contour features . Later, the example-based methods were proposed based on learning a dictionary of patch correspondences, such as neighbor embedding [7, 8] and sparse coding [9, 10, 11, 12]. Recently, convolutional neural networks (CNNs) have been widely used due to their significant improvement of the accuracy.
The pioneering work SRCNN  introduced CNN as a solution to the SR problem. The accuracy of SRCNN is limited due to the 3-layer structure and its small context receptive field. To improve the accuracy, some researchers propose to use more layers , deep recursive structure [15, 37], or other network architectures such as ResNet [16, 17]. However, most state of art methods could not be executed in real-time using practical hardware due to their large network size. In addition, with deeper networks, it becomes more difficult to tune the training parameters, such as the weight initialization, the learning rate, and the weight decay rate. As a result, the training can be stuck into a local minimum or does not converge at all. Hence, increasing depth might lead to accuracy saturation  or degradation for image classification .
In this paper, we propose the Cascade Trained Super Resolution Convolutional Neural Network (CT-SRCNN) as a solution to the above problem. Different from existing approaches that train all the layers at once with unsupervised weight initialization, we start by training a small network of 3 layers. When the rate of decrease in the training loss diminishes, newly initialized layers are gradually inserted into the trained network to make it deeper, and the training is continued. With this cascade training strategy, the convergence is improved, and the accuracy could be consistently increased with more layers. So it is ‘the deeper the better’. In addition, all the weights of the new layers in the CT-SRCNN are randomly initialized, and the learning rate is fixed. This is a great advantage compared to existing approaches [14, 16, 17], which need much time spent on tuning the parameters. When the CT-SRCNN depth becomes 19 layers, the accuracy is competitive compared to the state-of-the-art image SR networks, while using only of the parameters. The speed is also more than 4 times faster.
Next, we explore how to remove the redundant filters from the SR network to improve the efficiency. We first discuss a one-shot trimming scheme, where all layers are made slimmer by removing filters with less importance. Then a cascade trimming method is proposed, which results in the same slim network but less accuracy loss compared to the one-shot trimming. Similar to cascade training, cascade trimming also consists of several stages. At each trimming stage, some layers are made slimmer by removing some of their filters, while keeping the other layers intact, and is followed by fine-tuning the network. Different layers are trimmed at different stages in a cascade manner. Our trimming strategy is different and much simpler than training a whole newly initialized thin network as in FitNets . Our cascade trimming methodology is also very different from existing pruning algorithms [19, 20], where some parameters are set to zero but keeping layer sizes the same. For the same number of non-zero parameters, trimmed networks have lower computational complexity, compressed network size, and are more hardware friendly than pruned networks which tend to have random pruning patterns. We show that by using cascade trimming together with cascade training we can train an SR network with concurrently high accuracy, good computational efficiency, and significantly smaller size.
As summary, our contributions are two folds:
1. A cascade training strategy is utilized. Cascade training does not need much work on parameter tuning. The resulting CT-SRCNN can achieve the state-of-the-art accuracy at 19 layers, with more than 4 times less complexity compared to existing deep CNN models;
2. A network trimming scheme to reduce the SR network size is proposed. The trade-off between network size and accuracy is explored by the proposed cascade trimming. The redundant filters could be removed with minor loss on the accuracy;
2 Advances in Super Resolution
Numerous research addressed the image super resolution problem [1, 2]. Some early SR algorithms refer to filtering approaches, such as bilinear, bicubic, and Lanczos filtering. These filtering algorithms may generate smooth outputs without recovering any high-frequency information. To solve this issue, some researchers utilize edge features. Allebach et al.  generated a high resolution edge map by first filtering with a rectangular center-on-surround-off filter and then performing piecewise linear interpolation between the zero crossings in the filter output. Li et al.  applied the interpolation constrained by the geometric duality between the low-resolution covariance and the high-resolution covariance. These approaches are computationally efficient, but the accuracy is limited because they oversimplify the SR problem.
Other approaches assumed a kind of mapping between the LR space and the HR space. Such mapping could be learned from a large number of LR-HR pairs. Early methods refer to Markov network or neighbor search strategies [21, 7]. The sparse coding dictionary-based image representation  became popular, where a sparse vector is shared between the LR space and the HR space. Zhang et al.  designed a multi-scale dictionary to capture redundancies of similar image patches at different scales to enhance visual effects. Timofte et al.  anchored the neighborhood embedding of a low resolution patch to the nearest atom in the dictionary and precomputed the corresponding embedding matrix. This approach was further enhanced by utilizing the training data in the testing procedure . Kim and Kwon  learned a general mapping between the LR and HR spaces from example pairs using kernel ridge regression. Such regression was also solved by random forests . In consideration of the self-similarity, Glasner et al.  unified the example-based SR and classic multi-image SR by exploiting patch redundancies across scales. Huang et al.  expanded the internal patch search space by allowing geometric variations, explicitly localizing planes in the scene, and using the detected perspective geometry to guide the patch search process.
Recently, CNNs have been widely adopted for image SR. Dong et al.  trained a 3-layer CNN from the bicubic upsampled LR image to the HR image. Some researchers propose to use more complicated networks. Wang et al.  integrated a sparse representation prior with a feed-forward network based on the learned iterative shrinkage and thresholding algorithm. Kim et al.  increased the number of layers to 20 and used small filters with a high learning rate and an adjustable gradient-clipping. The performance of deeper CNN has been further enhanced by using recursive structures and skip connections [15, 37]. Dahl et al.  combined the ResNet with a pixel recursive super resolution architecture, which showed promising results on face and bed SR. Lim et al.  removed unnecessary modules in conventional residual networks, and expanded the model size while stabilizing the training procedure. Others prefer to use perception loss instead of the Mean Square Error (MSE), which is claimed to be closer to natural texture and human vision. Sonderby et al.  introduced a method for amortized MAP inference, which calculated the MAP estimation directly using CNN. Johnson et al.  proposed the use of perceptual loss functions for training feed-forward networks for image transformation tasks. Ledig et al.  employed a very deep residual network (ResNet), and further presented the Super Resolution Generative Adversarial Network (SRGAN) to obtain HR images with texture similar to natural texture. These works improve the accuracy of the SR system, at the cost of more layers and parameters and with more difficult hyper-parameter tuning. Other works addressed different strategies for fusion of multiple SR-CNNs to get a fused SR-CNN with superior performance .
Other researchers focused on improving the efficiency by extracting the feature maps in LR space and learning the upscaling filters. Shi et al.  introduced an efficient sub-pixel convolutional layer which learned an array of upscaling filters to upscale the LR feature maps into the HR output. Dong et al.  re-designed the SRCNN by adding smaller filters, deconvolution layers, and feature space shrinkage to accelerate the speed without losing the accuracy. Lai et al.  proposed the Laplacian pyramid super resolution network (LapSRN) to progressively reconstruct the sub-band residuals of high-resolution images. The deconvolution layers are utilized to upscale the feature maps between different scales. These methods use the upscaling layer instead of initial bicubic upsampling, so the patch size and context receptive field will be small. As a result, the accuracy is relatively lower compared to the methods extracting feature maps from the upsampled LR space.
Most of the above SR networks apply the one-shot training with careful tuning of the network learning hyper-parameters on specific datasets. In contrast, our CT-SRCNN could be trained deeper to achieve a higher accuracy without specific parameter tuning. This is an advantage when generalizing to other datasets. In addition, this is the first paper which discusses network trimming and its application to super resolution. The proposed cascade trimming technique is also novel and is more desirable to existing network pruning strategies.
3.1 Cascade training methodology
Our SR network takes an interpolated LR image (to the desired size) as input and predicts an HR image as its output. The training and the hyper-parameter tuning become more difficult for deeper networks. A feasible way is to separate the whole training into several cascaded stages, and proceed one by one. This is inspired by the stage-by-stage strategy in conventional machine learning algorithms. For example, in AdaBoost, after each strong classifier is learned, more difficult negative samples are bootstrapped to train the next strong classifier.
We utilize the cascade strategy in training CNN for super resolution, which is called cascade-trained super resolution convolutional neural network (CT-SRCNN). The first stage of the training starts from 3 layers. When the training error of the network at current stage stops decreasing significantly, we pause the training and insert new randomly initialized layer(s) into the network as intermediate layers, while inheriting weights of other layers from previous stage. Then the training resumes at next stage. This procedure is recursively applied to make the network deeper and deeper. Since most of the weights are inherited from the previous stage, the convergence will be relatively easy without need for further hyper-parameter tuning.
3.2 Cascade training implementation
Let denote a LR image and denote its corresponding HR image. Given a training set with samples, our goal is to learn a model that predicts the HR output . The training aims to minimize the mean square error (MSE) over the training set.
We start the training from a 3-layer model. The first layer consists of 64 filters. The second and the third layer consist of 32 filters. All convolutions have stride one, and all weights are randomly initialized from a Gaussian distribution with standard deviation . When the training MSE of current stage stops decreasing significantly, e.g., the error decreases less than 3% in an epoch, the network will be cascaded to a deeper network, and the training goes to the next stage. To accelerate this procedure, we insert two new layers into the network at each stage. As shown in Fig. 1, the CT-SRCNN training starts from 3 layers, and proceeds to 5 layers, 7 layers, etc.. Each new layer consists of 32 filters. The small filter size of the cascaded layers is to maintain the network computation efficiency while going deeper. The new layers are inserted just before the last layer. Hence, the weights of pre-existing layers could be inherited from the previous stage, and the weights of the two new layers are randomly initialized (Gaussian with ). We pad two zeros to each new layer to make the size of the feature map consistent. As a result, all the stages in the cascade training have the same output size, so the training samples could be shared.
When the network goes deeper, it is difficult for the training to converge. SRCNN  concluded that deeper is not better as it does not show better performance with more than three layers. In VDSR , a high initial learning rate is tuned and then gradually decreased. But when using a large diverse training set (e.g., more than 30 million patches from 160,000 images), we found that a high learning rate will not work well. A potential reason is that a high learning rate will lead to vanishing or exploding gradients. In CT-SRCNN, only a few weights are randomly initialized at each stage, so the convergence will be easy. We find that using a fixed learning rate 0.0001 without any decay for all layers is feasible.
The trained CT-SRCNN is shown in Fig. 2, with the kernel size ‘9-5-3-…-3-5’. One main advantage of the deeper network is the increased receptive field which increases awareness of the context. In our implementation, the 19-layer CT-SRCNN achieves the state-of-the-art accuracy, while using much less parameters compared to other deep networks, such as VDSR  or DRRN . We implemented the CT-SRCNN using the Caffe package.
4 Improving the efficiency of the CT-SRCNN
4.1 One-shot trimming
Most of the neural networks have redundancy. Removing such redundancy will clearly improve the efficiency. Given a -layer network, assume the th layer consists of input channels, convolution kernel, and filters. The input feature map is , and the output feature map is , where and are the width and height of the feature map. Then the weights in this layer are . There will be multiplications when doing the convolution.
Since the major computational cost is decided by the number of the multiplications, a straightforward way to improve the efficiency is to reduce the number of the multiplications, e.g., network pruning by setting some weights in to 0. Although such weight pruning may reduce the compressed network size [19, 20], it is hard to take advantage of it in reducing computational complexity with hardware implementations by zero skipping due to the typical random pruning patterns. Another way to improve the CNN’s computational efficiency is to train a slimmer network which is totally randomly initialized as in FitNets . But it will require the guidance from original network with heavy parameter tuning.
Instead, we propose to transform the original network to the slim network by trimming whole filters from the layers. This will reduce the network size and computational cost at the same time. Once a filter is trimmed, the adjacent layer will also be influenced, as shown in Fig. 3. If we trim a filter (red block) from the th layer, , some weights in the th layer (red segments) will also be trimmed, resulting in kernels with reduced depth at the th layer. So trimming the filter in the th layer will reduce the computational cost for both the th and the th layer. In the straightforward approach, one-shot trimming, the filters from all the layers are trimmed based on the trimming rate at once. Then, the trimmed network will be fine-tuned until convergence.
To decide which filter will be trimmed, we define the relative importance of the th filter in the th layer as the square sum of all the weights in this filter. As in equation (1), the is the weights in the th filter of the th layer
Then we may trim the filters with small for each layer . We know that if we trim a filter from the th layer, the corresponding weights in the th layer will also be trimmed, which results in . So when calculating , we may either refer to the non-trimmed weights of the original network, which is called ‘independent trimming’, or the reduced-depth kernels which are partially trimmed as a result of trimming the previous layer, as in equation (2), which is called ‘greedy trimming’ .
The flowchart of applying one-shot trimming to CT-SRCNN is illustrated in Fig. 4. In the implementation, we set for all layers. The output trimmed CT-SRCNN will have ‘32-16-16-…-16-1’ filters in each layer.
4.2 Cascade trimming
The network size versus the accuracy is a trade-off problem. Although the one-shot trimming may reduce the network size, the accuracy loss is also significant (0.3-0.4dB, as shown in Table 5). One reason of this loss is that for deep networks, one-shot trimming will change the network capability a lot. So it will be very difficult to retrieve the accuracy by fine-tuning the trimmed network.
Inspired by the cascade training, we proposed the cascade trimming method. Cascade trimming also consists of several stages. In each stage, we trim the filters from a few layers only. The filters in other layers are inherited from previous stage. Then the whole network is fine-tuned until convergence, without any frozen weights. Similar to cascade training, when the MSE of current stage stops decreasing significantly, e.g., the error decreases less than 3% in an epoch, the trimming will move to the next stage.
We apply the cascade trimming on the CT-SRCNNs. Two adjacent layers are trimmed in each stage for acceleration. CT-SRCNN has ‘64-32-32-…-32-1’ filters per layer. The cascade trimming starts from the last two layers with 32 filters since there is only one filter in the final layer. Since trimming the filters in one layer will also influence the kernels at the next layer by reducing their depths, the filters are actually trimmed from 3 adjacent layers at each stage, as shown in Fig. 4. Suppose we have a -layer CT-SRCNN, the first trimming stage will trim the th and the th layers, but also influence the last layer. The second trimming stage will focus on the th and th layers, but also influence the th layer, etc… The cascade trimming will terminate when all the layers are trimmed. In each trimmed layer, half of the filters will be removed. These filters are randomly selected instead of calculating small in the one-shot trimming. The reason is that the network capability will not be hurt much in each stage of the cascade trimming, so fine-tuning is relatively easy even with random selection. If we apply such random selection in the one-shot trimming, the fine-tuning will not converge.
During the fine-tuning, the learning rate is fixed to 0.0001. Since the cascade trimming did not change the size of the convolution kernels and feature maps, we may use the same training samples as cascade training.
The output trimmed CT-SRCNN has the same ‘32-16-16-…-16-1’ architecture as the one-shot trimming. This framework is called ‘train-trim’. Another way to train such a network is starting by trimming and then train a deeper network. For example, trimming a 3-layer network to ‘32-16-1’ filters, and inserting two filters by cascade training to make it deeper and deeper. The final network which is denoted as ‘trim-train’ will have the same architecture as the ‘train-trim’ network. We compare these two methodologies in section 5.3. As expected, we show that the ‘train-trim’ performs better compared to ‘trim-train’. This can be attributed to the fact that in ‘train-trim’ deeper fatter network can learn better representations due to more degrees of freedom, and then the network is made slimmer by trimming away the redundant filters.
|Dataset||Scale||bicubic||A+ ||SRCNN ||VDSR ||DRCN ||DRRN ||CT-SRCNN|
We use the Open Image Dataset  to generate the training LR and HR patches. This dataset consists of 9 million URLs to HD images that have been annotated with labels spanning over 6,000 categories. Instead of the overlarge whole dataset, we use the Thumbnail300KURL of the validation set, which consists of about 160,000 images with resolution around . These images are first bicubic downsampled to generate the LR images and then upsampled to the desire size. LR patches and the corresponding HR patches are cropped. With stride, we sample more than 30 million patches for training. Other SR networks (e.g., VDSR, DRCN, DRRN) are retrained on this dataset during the evaluation.
5.2 Experimental results of CT-SRCNN
In Table 1, we show the PSNR/SSIM of the CT-SRCNN from 3 layers to 19 layers. It can be seen that the accuracy consistently increases along with using more layers. Although we show 19-layer CT-SRCNN at most, the accuracy could still be further improved by cascading more layers. This is consistent with ‘the deeper, the better’. Next, we compare CT-SRCNN-19 with other SR algorithms A+ , SRCNN , VDSR , DRCN , and DRRN-B1U25 . For fair comparison, we retrain VDSR, DRCN, and DRRN-B1U25 using Open Image Dataset. Since this dataset has more diversity compared to the 291 images, training these networks from scratch will decrease the performance around 0.4dB compared to their published results. Instead, we initalize the weights of these networks by the released pre-trained official model, and then fine-tune on Open Image Dataset. In Table 2, we observe that CT-SRCNN shows competitive accuracy. It achieves either the best or the second best in all the tests. Fig. 6 visualizes the output HR images of different SR methods. We can find that CT-SRCNN-19 is able to get sharper edge and less noise compared to VDSR, DRCN, and DRRN. The output is closer to the ground-truth.
The 19-layer CT-SRCNN only consists of 200K parameters. The network size is much smaller compared to VDSR (20 layers, 650K+ parameters), DRCN (1000K+ parameters), and DRRN (1000K+ parameters). We test all the above methods in Titan X GPU. In Table 2, it takes about 0.03ms-0.05ms per image for 19-layer CT-SRCNN, which is 4 times faster compared to VDSR, and more than 15 times faster than DRCN and DRRN. It is slower than 3-layer SRCNN because SRCNN only has 57K parameters. These results show that the cascade training is able to train deep CNNs with both high accuracy and relatively fast speed.
Moreover, we give the comparison between the CT-SRCNN and the non-cascade (one-shot) trained SRCNN with the same network architecture. For the one-shot trained SRCNN, the weight initialization and learning rate follow the method in . In Table 3, we use the 5-layer and 7-layer SRCNNs as example. It can be seen that the CT-SRCNN significantly outperforms the one-shot trained networks with the same architecture. For 7 layer, the gap is about 0.2-0.3dB. We also observe that this gap will be larger when using more layers. In Table 2, we have shown that 19-layer CT-SRCNN is clearly better than 20-layer one-shot-trained network (VDSR), while using less filters. This is due to the fact that the cascade training can be considered as a ‘partial-supervised initialization’. So the convergence will be easier compared to unsupervised initialization in one-shot training. Fig. 7 gives the PSNR on Set14 versus the training epochs. We find that the PSNR of CT-SRCNN increases from 3 layers to 19 layers. When the cascade training goes to the next stage, the PSNR will drop due to the random initialization of the new layers. The convergence of CT-SRCNN is better compared to one-shot trained networks.
5.3 Experimental results of cascade trimming
In Table 4, we give the experimental results of the cascade trimming. We use the 13-layer CT-SRCNN as the baseline network. Since 2 layers will be trimmed in each stage, there will be 6 trimming stages to trim the whole network. It can be seen that the first 3 trimming stages (Trim-S1 to Trim-S3) will not decrease the PSNR and SSIM very much compared to the non-trimmed model, but the network size has been reduced around 30%. When all the 13 layers are trimmed after 6 stages (Trim-S6), the PSNR decreases only 0.15dB. At the same time, the network size is reduced to one third of the original network, and the inference time is significantly reduced. This indicates that the cascade trimming is an effective way to deal with the efficiency-accuracy trade-off. We notice that the trimmed models consists of only 58K parameters, the accuracy is much better compared to a non-trimmed model with similar network size (3-layer SRCNN has 57K parameters). This implies that the performance of a trimmed deep network outperforms a non-trimmed network with similar size.
In Table 5, we compare the cascade trimming with the one-shot trimming discussed in section 4.l. Due to the difference in selecting filters to be trimmed, we have two different ways, ‘one-shot-independent’ (independent trimming) and ‘one-shot-greedy’ (greedy trimming). It can been seen that the one-shot trimming is worse compared to cascade trimming. But it is still better than 3-layer SRCNN. So we can get the conclusion that trimming from a deeper model is always helpful, and the cascade trimming is clearly better compared to the one-shot trimming. In addition, we notice that the independent trimming achieves similar accuracy compared to the greedy trimming. We also give the comparison between the ‘train-trim’ (Cascade Trimming) and ‘trim-train’ (the last column), as discussed in Section 4.2. We observe that the ‘trim-train’ is better than one-shot trimming, but worse compared to cascade trimming. This result makes sense because there will be more flexibility when learning the trimming of a cascade trained ‘fatter network’, compared to cascade training a thinner network only.
As summary, using the proposed cascade training and cascade trimming, we are able to train a SR network with both high accuracy and considerable efficiency.
In this paper, we presented cascade methods to train deep CNNs for super resolution achieving both high accuracy and efficiency. The cascade training ensures that the network might consistently go deeper with a relatively smaller size. The cascade trimming further reduces the network complexity, with minor loss on the discriminative power. The experimental results on benchmark image datasets show that the proposed method achieves competitive performance compared to the state-of-the-arts, but the speed is much faster. Although SRCNN has been adopted as our base SR network in this paper, we have also observed similar conclusions when applying the cascade methodologies to improve the accuracy and efficiency of other base SR networks, such as SRResNet , FSRCNN , and ESPCN . Our method could also be generalized to the CNNs for other applications, such as denoising, or image restoration.
-  Nasrollahi, Kamal and Moeslund, Thomas. Super-resolution: a comprehensive survey. Machine vision and applications, 25:1423–1468, 2014.
-  Yang, Chih-Yuan and Ma, Chao and Yang, Ming-Hsuan. Single-image super-resolution: A benchmark. ECCV, 372–386, 2014.
-  Glasner, Daniel and Bagon, Shai and Irani, Michal. Image Super-resolution from a single image. CVPR, 349–356, 2009.
-  Kim, Kwang In and Kwon, Younghee. Single-image super-resolution using sparse regression and natural image prior. TPAMI, 32:1127–1133, 2010.
-  Allebach, Jan and Wong, Ping Wah. Edge-directed interpolation. ICIP, 707–710, 1996.
-  Li, Xin and Orchard, Michael. New edge-directed interpolation. TIP, 10:1521–1527, 2001.
-  Chang, Hong and Yeung, Dit-Yan and Xiong, Yimin. Super-resolution through neighbor embedding. CVPR, 2004.
-  Bevilacqua, Marco et al. Low-complexity single-image super-resolution based on nonnegative neighbor embedding. BMVC, 2012.
-  Timofte, Radu and De Smet, Vincent and Van Gool, Luc. Anchored neighborhood regression for fast example-based super-resolution. ICCV, 2013.
-  Timofte, Radu and De Smet, Vincent and Van Gool, Luc. Anchored neighborhood regression for fast example-based super-resolution. ACCV, 2014.
-  Yang, Jianchao and Wright, John and Huang, Thomas and Ma, Yi. Image super-resolution via sparse representation. TIP, 19:2861-2873, 2010.
-  Timofte, Radu and Rothe, Rasmus and Van Gool, Luc. Seven ways to improve example-based single image super resolution. CVPR, 1865-1873, 2016.
-  Dong, Chao et al. Image super-resolution using deep convolutional networks. TPAMI, 38:295-307, 2016.
-  Kim, Jiwon and Kwon Lee, Jung and Mu Lee, Kyoung. Accurate image super-resolution using very deep convolutional networks. CVPR, 1646-1654, 2016.
-  Kim, Jiwon and Kwon Lee, Jung and Mu Lee, Kyoung. Deeply-recursive convolutional network for image super-resolution. CVPR, 1637-1645, 2016.
-  Ledig, Christian et al. Photo-realistic single image super-resolution using a generative adversarial network. Arxiv, 1609.04802, 2016.
-  Dahl, Ryan and Norouzi, Mohammad and Shlens, Jonathon. Pixel Recursive Super Resolution. Arxiv, 1702.00783, 2017.
-  Romero, A. and Ballas, N. and Kahou, S. E. and Chassang, A. and Gatta, C. and Bengio, Y. Fitnets: Hints for thin deep nets ICLR, 2015.
-  Han, Song, Huizi Mao, and Dally, William. Deep compression: Compressing deep neural networks with pruning, trained quantization and Huffman coding ICLR, 2016.
-  Choi, Yoojin and El-Khamy, Mostafa and Lee, Jungwon. Towards the Limit of Network Quantization ICLR, 2017.
-  Freeman, William and Jones, Thouis and Pasztor, Egon. Example-based super-resolution. IEEE Computer graphics and Applications, 22:56–65, 2002.
-  Huang, Jia-Bin and Singh, Abhishek and Ahuja, Narendra. Single image super-resolution from transformed self-exemplars. CVPR, 5197–5206, 2015.
-  Tai, Yu-Wing and Liu, Shuaicheng and Brown, Michael and Lin, Stephen. Super resolution using edge prior and single image detail synthesis. CVPR, 2400–2407, 2010.
-  Zhang, Kaibing and Gao, Xinbo and Tao, Dacheng and Li, Xuelong. Multi-scale dictionary for single image super-resolution. CVPR, 1114–1121, 2012.
-  Schulter, Samuel and Leistner, Christian and Bischof, Horst. Fast and accurate image upscaling with super-resolution forests. CVPR, 3791–3799, 2015.
-  Wang, Zhaowen and Liu, Ding and Yang, Jianchao and Han, Wei and Huang, Thomas. Deep networks for image super-resolution with sparse prior. ICCV, 370–378, 2015.
-  Ren, Haoyu and El-Khamy, Mostafa and Lee, Jungwon. Image Super Resolution Based on Fusing Multiple Convolution Neural Networks. CVPRW, 2017.
-  Shi, Wenzhe et al. Real-time single image and video super-resolution using an efficient sub-pixel convolutional neural network. CVPR, 1874–1883, 2016.
-  Dong, Chao and Loy, Chen Change and Tang, Xiaoou. Accelerating the super-resolution convolutional neural network. ECCV, 391–407, 2016.
-  Sønderby, Casper et al. Amortised MAP Inference for Image Super-resolution. ArXiv, 1610.04490, 2016.
-  Johnson, Justin and Alahi, Alexandre and Fei-Fei, Li. Perceptual losses for real-time style transfer and super-resolution. ECCV, 694–711, 2016.
-  Hao, Li, and Asim, Kadav, and Igor, Durdanovic, and Hanan, Samet and Hans, Graf. Pruning filters for efficienct convnets. ICLR, 2017.
-  Zeyde, Roman and Elad, Michael and Protter, Matan. On single image scale-up using sparse-representations. International conference on curves and surfaces, 711–730, 2010.
-  Martin, David et al. A database of human segmented natural images and its application to evaluating segmentation algorithms and measuring ecological statistics. ICCV, 416–423, 2001.
-  https://github.com/openimages/dataset
-  Lai, Wei-Sheng et al. Deep Laplacian Pyramid Networks for Fast and Accurate Super-Resolution. CVPR, 2017.
-  Tai, Ying, Jian Yang, and Xiaoming Liu. Image Super-Resolution via Deep Recursive Residual Network. CVPR, 2017.
-  Lim, Bee et al. Enhanced deep residual networks for single image super-resolution. CVPRW, 2017.