1 Introduction
Since the success of AlexNet [15] in the ILSVRC2012 competition [19]
, more and more researchers move their focus on deep CNNs. Features learned from the neural networks significantly improve the performance of the largescale vision recognition task, and can successfully be transferred to a large variety of computer vision tasks, such as object detection
[5], pose estimation
[25] and humanobject interactions [6]. Due to the powerful transferability of CNN models, “network engineering” has attracted much research interest. This leads researchers to explore more effective and efficient network architectures.The stateoftheart CNN architectures become increasingly deeper and more complex. The VGGNet [20] extends the depth of AlexNet from eight to nineteen layers. The GoogleNet [23, 24]
designs the Inception module explicitly by incorporating the multiscale property into the architecture. ResNet
[9] proposes a residual learning framework to ease the training of networks, and can successfully train networks with more than 1000 layers. DenseNet [11] connects each layer to every other layer, which encourages feature reuse and substantially reduces the number of parameters. These different architectures share a key characteristic: they incorporate many nonlinear units, ReLU, in the networks.ReLU layers are widely used in all CNN architectures. It has also been demonstrated to be more powerful compared to other nonlinear layers in most situations, such as sigmoid and tanh [7]. ReLU can not only increase the nonlinearity but also ameliorate gradient vanish/explosion phenomenon in CNNs. Therefore, a convolution layer or a fullyconnected layer is usually accompanied with a ReLU layer by default in the stateoftheart CNN architectures. Is this design principle necessary and helpful for the classification or some other vision tasks?
We empirically find that reducing the nonlinearity in very deep CNNs eases the difficulty of neural network training. As networks go deeper, the benefits from depth and complexity become less [29]. For example, there is about 1.3% accuracy improvement from ResNet110 to ResNet164 on CIFAR10 [14]. However, six times deeper network, ResNet1001, even decreases the accuracy about 1.7%. In this way, the trained network is far from the capacity it should achieve. When we simply erase the last ReLU layer in residual blocks, the accuracy of a network with more than 1000 layers can still increase, whereas the very deep ResNet tends to decrease the accuracy.
In this work, we propose a simple but effective method to improve the performance of deep CNN architectures by erasing the ReLU layers. As shown in Figure 1, our approach erases the last ReLU layer of the basic module in the deep neural network. We thus call our approach “EraseReLU”. Our intuition is that some nonlinear layers may suppress information through the forward pass. For example, in some cases [3]
, the feature tensors after ReLU can be dominated by zero values, which harms the performance and cannot recover because the gradient of zero value is also zero. Therefore, as our approach significantly reduces the nonlinearity in CNN models, it can help the information propagation in
very deepnetworks. EraseReLU also benefits the network optimization, which usually leads the model to converge faster in the early training epochs. By investigating various factors of applying EraseReLU, we find that two key factors to improve the performance. 1) the location where ReLU should be erased; 2) the proportion of modules to erase ReLU. Moreover, we empirically demonstrate that erasing the last ReLU layer in all basic modules usually tends to result in performance improvement for various stateoftheart CNN architectures, ResNet, Preact ResNet
[10], Wide ResNet [28], InceptionV2 [13] and ResNeXt [26]. Besides, we provide the theoretical analysis of EraseReLU which proves ReLU layers suppress the gradient backprorogation in deep CNNs.In summary, this paper makes the following contributions:

We propose a simple but effective approach to improve the classification performance of very deep CNN models by erasing the last ReLU layer of a certain proportion of basic modules in CNNs. Moreover, the proposed approach can ease the difficulty of deep CNN training, which makes the CNN model converge faster.

We provide the theoretical analysis of our EraseReLU. We demonstrate gradients in very deep CNN models are suppressed by ReLU layers.

We empirically show significant improvements on various of stateoftheart CNN architectures. We use four benchmark datasets, including the largescale dataset, ImageNet.
2 Related Work
Nonlinearity.
The nonlinear unit plays an essential role in strengthening the representation ability of a deep neural network. In early years, sigmoid or tanh are standard recipes for building shallow neural networks. Since the rise of deep learning, ReLU
[7] has been found to be more powerful in easing the training of deep architectures and contributed a lot to the success of many recordholders [15, 20, 24, 22, 9]. There exist lots of variants of ReLU nowadays, such as Leaky ReLU [17], PReLU [8], etc. The common ground shared by these units is that the computation will be linear on a subset of neurons. Models trained with such kinds of nonlinear units can be viewed as a combination of an exponential number of linear models which share parameters
[18]. This inspires us that modeling the local linearity explicitly may be useful. In this paper, we extend this linearity from the subset to the full set of neurons in some layer and empirically found that this extension effectively improves the performance of the model.Architecture. Krizhevsky won the ILSVRC2012 competition and revealed that a large and deep CNN [15] is capable of achieving benchmark results on a highly challenging dataset. [30] proposes a novel visualization technique providing insight into the CNN features as well as a new architecture ZFNet. NIN [16] leverages onebyone convolutional layers to make the network become deeper and yield better performance. VGGNet [20] further promotes the depth of CNN to 19 weighted layers resulting in a significant improvement.
Inception module is first proposed in [23], which considers the Hebbian and multiscale principle in CNN. [13]
proposes the Batch Normalization (BN) to accelerate the network training. They also applied BN to a new variant of the GoogleNet, named as BNInception.
[24] proposes several general design principles to improve Inception module which leads a new CNN architecture, Inceptionv3. [22]combines the advantages of Inception architectures with residual connections to speedup the CNN training.
Highway network [21] is designed to ease gradientbased training of very deep networks. [9] proposes the deep residual network that achieves a remarkable breakthrough in ImageNet classification and won the 1st places various of ImageNet and COCO competitions. The proposed residual learning can make the network easier to optimize and gain accuracy from considerably increased depth. Following ResNet, [10] proposes the Preactivation ResNet improving the ResNet by using preactivation block. Wide ResNet [28] decreases the depth and increases the width of residual networks. It tackles the problem of diminishing feature reuse for training very deep residual networks. ResNeXt [26] optimizes the convolution layer in ResNet by aggregating a set of transformations with the same topology.
Some researchers incorporate the stochastic procedure in the CNN models. [12] proposes stochastic depth, a training procedure enabling the seemingly contradictory setup to train short networks and use deep networks at test time. [4] proposes to use parallel branches with a stochastic affine combination in ResNet to the avoid overfitting problem. Our approach is a different way to improve CNN models compared with them, and we can complement each other. While a contemporary work [31] argues that 1:1 convolution and ReLU ratio is not the best choice to design the network architectures, we observe that only tuning the convolution and ReLU ratio may not always lead to improvement for different network structures. Instead, the location where ReLUs should be erased is the key factor, which is the focus of this paper.
3 Methodology
The mapping function between different representations can be linear or nonlinear. If the intrinsic relationship between two different representations is a linear mapping, it is hard to learn to approximate such kind of linear mapping through stacking of nonlinear transformations, especially when the architecture is quite deep and the data is scarce. For example, [9] illustrates that optimization can be difficult in approximating an identity mapping by stacking multiple layers with nonlinear activations in very deep neural networks. ReLU layers introduce linearity for the subset of neurons with positive responses. However, we find that for a subset of layers, it can be helpful to keep the linearity for the neurons with negative responses, i.e., explicitly forcing the linear mapping for a subset of layers.
3.1 EraseReLU
In most architectures, the network consists of multiple stacked core modules. Therefore, a network can be formulated ^{1}^{1}1For simplification, we ignore the fullyconnected and pooling layers. as :
(1) 
where indicates the th basic unit in the network and equals . Figure 2 illustrates five different kinds of in different typical CNN architectures. As we stack more such modules in CNN, the network tends to overfit the training set and the optimization becomes more difficult. Residual connection [9] can alleviate this phenomenon.. However, these two problems are still unsolved [29] We empirically find that reducing nonlinearities of can be helpful for ameliorating the overfitting and optimization problems in very deep neural networks.
What is the most efficient way to reduce the nonlinearities of and maintain the model capacity at the same time? There are usually three operations in CNN models: convolution, batch normalization, and ReLU. Convolution operation is a linear unit and also essential for the model capacity, we thus do not change the convolution operation. BN is not a linear unit strictly but can be approximately regarded as a linear unit. It can avoid the gradient explosion by stabilizing the distribution and reducing the internal covariate, we thus should also retain this operation. Therefore, there left two directions to reduce the nonlinearities, modifying ReLU or optimizing the module structure. The module structure has thousands of combinations of different operations, which is beyond the scope of our paper. Hereto, we eliminate all choices except modifying ReLU.
We can observe that modules in Figure 2 share a common character, i.e., the last layer is a ReLU layer:
(2) 
where most architectures also have this character. If we erase the last ReLU layer, we can preserve the overall structure. On the contrary, if we erase the middle ReLU layer of these modules, it will destroy the module structure and decrease the module capacity, thus be harmful to the performance (See discussion in Sec.3.4). We empirically observe erasing the last ReLU layer in each module is capable of easing the training difficulty and considered as a regularization to improve the final performance.
Modules in Figure 2 can be categorized as the afteractivation structure [10], where activation operations (BN & ReLU) are after the convolutional layer. Preactivation structure [10, 11, 28] is another kind of module. It moves BN+ReLU to the head of the convolution layer, and ReLU thus is not the tail of module. To apply EraseReLU to these architectures, we first transfer them into the afteractivation structure and then apply EraseReLU, because the middle ReLU layer is essential for performance as we discuss before.
Hereto, the locations where ReLU layers should be erased have been discussed. It is still not clear that EraseReLU should be applied to which module. If we arbitrarily choose the module to apply EraseReLU, there exist thousands of choice combinations and some of them are even equivalent. Therefore, we use the proportion of modules which should be applied with EraseReLU for efficiency. Given a specific proportion, we uniformly sample the locations where the module to be applied with EraseReLU. For example, if we apply EraseReLU on ResNet with the proportion of 50%, then we will erase the last ReLU of the th, th, th and etc. modules in ResNet. The location where ReLU should be erased and the proportion of modules to apply EraseReLU are two key factors for performance improvement.
3.2 Analysis of the EreaseReLU’s Effect
In this section, we analyze the effect of different factors when applying EraseReLU to improve CNN architectures. We perform two models stacked by thirty similar modules on CIFAR datasets. One model uses the VGGstyle module, and the other uses the residualstyle module as shown in Figure 2. Both of them use a 3by3 convolutional layer with 16 filters at the first layer. There are three stages following the first convolutional layer, where each stage has ten modules with the different number of output channels, i.e., 16, 32 and 64, respectively. Therefore, each of these two models has thirtyone weighted layers. Moreover, we try a multiple layer perception (MLP) network with 12 fullyconnected layers. Each fullyconnected layer in this MLP has one thousand output neurons followed by BN+ReLU+Dropout, except for the last one which maps the one thousand input neurons to ten neurons for MNIST classification. (More details can be found in supplementary materials)
Figure 3(a) shows that reducing ReLU layers in a deep VGGstyle network leads to the better performance. It achieves the highest accuracy when the proportion for EraseReLU is 20%. Figure 3(b) performs the similar experiments as in Figure 3(a), while we replace the VGGstyle network as the residualstyle network, which dramatically eases the training procedure. However, the original model is still inferior to the model with EraseReLU. For this residualstyle network, one with even a very small proportion of modules to erase ReLU (5%) can outperform the original model. Figure 3(c) demonstrates the same phenomenon in MLP, reducing the number of ReLU layers yields better performance. Figure 3(d) illustrates that the network trained with EraseReLU will gradually become better than the model without EraseReLU when the network goes deeper. The module in the networks used in Figure 3 only has one ReLU layer. If we use the proportion of 100% for EraseReLU, there will be no nonlinearity in these models, which significantly reduce the performance, and we thus do not list the proportion of 100% for EraseReLU in Figure 3.
In practice, we usually use the proportion of 100% for EraseReLU, which means that we apply EraseReLU on all modules. There will usually have more than one ReLU layers in the module of stateoftheart architectures. Therefore, even the proportion of 100% can maintain enough nonlinearity of these models.
3.3 Theoretical Analysis
Inspired by [2], we design a neural network taking scalars to scalars. It contains of modules, where the first layer and the last layer are fullyconnected layers. The middle module is similar to the simple residual module in Figure 2, whereas we replace the convolutional and BN layer with a fullyconnected layer and a LayerNorm layer [1]. Each hidden layer contains two hundred rectifier neurons. At initialization, the function takes the input in a 1dim grid of 1000 data points. We initialize the weight and bias by [8]. Figure 4 illustrates the gradient of the network for and its covariance matrix in the first two subfigures of each triplet. As the depth increases, the model using EraseReLU does not hurt the correlations between gradients. On the contrary, the original model (denoted as “With ReLU”) shows a decreased tendency of correlations between gradients. The third subfigure in each triplet of Figure 4 shows the activation distribution of the last hidden layer. If the neuron is greater than 0, it is activated; otherwise, it is deactivated. For the model with ReLU, the distribution becomes increasingly bimodal with depth. It decreases efficiency with which rectifier nonlinearities are utilized [2]. But the model with EraseReLU can maintain neurons to be utilized more efficiently even the depth becomes 300.
Depth  ResNet  PReLU  PReLU  ER*  ER  ER  SDR  ER+SDR  

20  12.46 0.32  11.180.17  12.160.18  21.340.34  12.470.21  5.380.20  22.510.30  24.090.09  
Train  56  2.38 0.22  1.70 0.24  0.89 0.13  13.280.79  0.86 0.08  0.090.02  4.91 0.12  4.950.03 
ing  110  0.34 0.05  0.21 0.04  0.33 0.01  9.76 0.04  0.16 0.10  0.290.01  0.56 0.02  0.500.04 
20  32.85 0.48  33.40 0.59  32.950.30  35.150.36  32.290.33  31.820.30  32.870.15  33.240.36  
Test  56  30.86 0.81  30.60 0.84  29.940.73  33.640.33  28.560.17  27.230.01  25.600.36  25.010.22 
ing  110  28.21 0.46  28.20 0.98  27.450.46  33.550.44  26.050.44  25.010.09  24.010.14  22.890.17 
3.4 Connection with other nonlinear activations
There exist many variants of ReLU, e.g., Leaky ReLU and PReLU. They aim to alleviate the gradient vanishing problem. While these variants may benefit the training of deep neural networks compared to ReLU, the performance improvement is negligible [27]. EraseReLU can be considered as a variant of ReLU. It extends identity mapping from positive domain to the whole domain, but leads to a significant improvement compared to other ReLU variants. Table 1 compares our EraseReLU with other variants of ReLU and stochastic depth ResNet [12] (denoted as SDR). We can find that PReLU achieves a much lower error on the training data, yet obtains a higher testing error compared with EraseReLU. Given enough training data, PReLU can theoretically learn an identity mapping if our EraseReLU is an optimal solution. But in practical, EraseReLU always yield a much better performance than PReLU.
ER* in Table 1 indicates erasing the middle ReLU layer in residual blocks. The middle ReLU layer is essential for as well as the final accuracy. ER* destroys the overall structure of the basic module, and it thus significantly reduces the performance compared to the original model. Instead, ER, which erases the last ReLU layer, yields the consistent performance improvement. SDR is a technique to boost the CNN training when the network is deep, which can complement our EraseReLU. By combining the mutual benefits from SDR and EraseReLU, we achieve 22.89 error rate on ResNet110, which improves the SDR by about relative 5% and ResNet by about 19%.
4 Experiments
4.1 Datasets
SVHN. The Street View House Numbers (SVHN) dataset is obtained from house numbers in Google Street View images. This dataset contains ten classes, from digit 0 to digit 9. There are 73257 color digit images in the training set, as well as the 26032 images in the testing set. It also has 531131 additional, somewhat less difficult samples, to use as extra training data. Following the common experiment setting on SVHN, such as [28, 11], we only use the official training and testing data. When training models, we only divide the pixel values by 255 to range into [0,1] without any data augmentation.
CIFAR. The CIFAR10 dataset consists of 60000 images categorized into ten classes. There are 50000 training images with 5000 images per class, and 10000 testing images with 1000 images per class. The CIFAR100 dataset is similar as CIFAR10 but contains 100 classes. We use the official training and testing sets of these two datasets. Following the common practice [9, 26, 11]
, we normalize the data using the means and standard deviations of RGB channels. We also adopt the random horizontal flip and random crop
^{2}^{2}2Pad 4 pixels on each border and randomly crop a 32x32 region data argumentations.ImageNet. The ILSVRC classification dataset contains 1000 classes. There are about 1.2 million images for training, and 50000 for validation. We use the same data argumentation as in [26, 11] for training. For evaluation, we only use the singlecrop with input image size of . We also generate three subsets of ImageNet for empirical studies. These three subsets randomly sample 10%, 20% and 30% images from the ImageNet dataset. Therefore, all of them have 1000 classes for training and testing images, but the number of images is different. We refer these three datasets as ImageNet10%, ImageNet20% and ImageNet30%. To be noticed, ImageNet10% is a subset of ImageNet20%, and ImageNet20% is a subset of ImageNet30%.
4.2 Experiments on SVHN and CIFAR
In this section, we apply our approach to improve five different architectures, ResNet, Preact ResNet, Wide ResNet, ResNeXt and InceptionV2. We demonstrate the comparison on SVHN, CIFAR10, and CIFAR100.
Experiment settings. The proportion for EraseReLU is a hyperparameter, which is selected from {25%, 50%, 75%, 100%} according to validation sets. As the InceptionV2 was designed for the ImageNet with the input image size of , we design a special InceptionV2 model for CIFAR datasets. It is shown as modules in Figure 2, where the convolutional layer is replaced by two convolutional layers. The proportions of output channels from the , , convolution branches and the pooling branch are in one Inception module. Our InceptionV2 on CIFAR has a convolutional layer with 64 output channels at first, followed by three Inception stages. Each stage contains ten Inception modules, where the base output channels are 16, 32 and 64, respectively.
According to the validation, we use the proportion of 100% for EraseReLU on ResNet, Preact ResNet, Wide ResNet and ResNeXt. For InceptionV2, we use the proportion of 50% for EraseReLU. We the InceptionV2 model following the same training and testing strategies as in [28]. For all other networks, we follow the same training and testing strategies as in their official papers [9, 10, 28, 26]. We run each model five times and report the mean error.
Architecture  Setting  CIFAR10  CIFAR100  SVHN  

original  [31]  EraseReLU  original  [31]  EraseReLU  original  EraseReLU  
ResNet[9]  56  6.97    6.23 0.21  30.60    28.56 0.17     
110  6.43    5.78 0.10  28.21    26.05 0.44      
1202  7.93    4.96            
Preact ResNet[10]  62  6.98  6.030.23  6.070.06  29.44  27.810.18  27.54 0.04     
110  6.37    5.72 0.04  27.20  26.590.10  25.76 0.07      
164  5.46    4.65  24.33  25.88  22.41      
1001  4.92    4.10  22.71    20.63      
Wide ResNet[28]  404  4.97    4.27  22.89    20.07     
2810  4.00    3.78  19.25    19.10      
2810D  3.89    3.88  18.85    18.60      
521  6.43    5.37  29.89    26.45  2.08  1.87  
521D  6.28    5.65  29.78    25.00  1.70  1.54  
5210  3.69    3.69  19.19    18.19  1.81  1.64  
ResNeXt[26]  298X64  3.65    3.57  17.77    17.23     
2916X64  3.58    3.56  17.31    16.53      
InceptionV2  30  5.45    5.29  28.29    24.34     
Experimental Analysis. Figure 5 illustrates the accuracy and loss curves of the original ResNet110/ResNet164 and the models using EraseReLU. We can find that erasing ReLU layers in such deep neural networks can not only achieve higher accuracies but also reduce the overfitting of the training data. When the learning rate reduces from 0.1 to 0.01, the training loss goes down, but the testing loss goes up. The phenomenon is caused by overfitting. The loss of original ResNet110 rises from 1.2 to 1.5, while the model using EraseReLU just rises from 1.1 to 1.3. For the ResNet164 model, by using EraseReLU the loss just rises about 0.01, but the original model raises more than 0.1. Therefore, the model using EraseReLU results in a much smaller loss increase than the original model. Moreover, with the network going deeper, we can obtain more benefits from EraseReLU. For example, the improvement of EraseReLU on ResNet164 is much more than ResNet110.
We demonstrate comparisons on SVHN and CIFAR in Table 2. For ResNet, EraseReLU improves the accuracy compared to the original architectures. The ResNet with 1202 layers achieves a worse performance than the network with 110 layers, but ours can still maintain the accuracy improvement even when the depth becomes very deep. For Preact ResNet, we use both afteractivation and EraseReLU. For Preact ResNet with 1001 layers on CIFAR100, the error drops from 22.71% to 20.07% by our EraseReLU. We can observe more than 2% accuracy gain on Preact ResNet with 1001 layers. As shown in [10], the afteractivation style does not improve the performance. Thus the main contribution of the accuracy improvement is from EraseReLU. For ResNeXt, the last ReLU of all residual blocks are removed, and we obtain about 0.8% improvement for ResNeXt2916x64 on CIFAR100. The previous stateoftheart result on CIFAR100 is DenseNetBC19040, 17.18% error rate. We achieve a better result by applying EraseReLU on a model, which performs worse than DenseNetBC19040. On SVHN, EraseReLU improves the Wide ResNet by about 10% relative accuracy. On CIFAR10, we can observe general improvements on various kinds of networks. The Wide ResNet5210 with EraseReLU does not improve the performance, because our model may be close to the lower bound for the CIFAR10 dataset. Compared to [31], we achieve more superior performance on CIFAR, and they lack the exploration on other different kinds of CNN architectures rather than ResNet. Moreover, we will show the results on the largescale dataset in the following section, whereas they only experiment on smallscale datasets.
4.3 Experiments on ImageNet
In this section, we first experiment on the ImageNet subsets to analyze the effect of model complexity and data scale for our EraseReLU. We then evaluate our approach on the full ImageNet set to demonstrate the effectiveness. For all experiments in this section, we use the official training code provided by PyTorch
^{3}^{3}3https://github.com/pytorch/examples/blob/master/imagenet/main.py and train each network with 120 epochs with the learning rate initialized by 0.1. The learning rate is divided by 10 every 30 epochs.Figure 6(a) compares ResNet50 and ResNet50 using EraseReLU with the proportion of 100% on ImageNet10%. Our EraseReLU outperforms the original model by about 3% top1 accuracy. Figure 6(b) illustrates the results of ResNeXt152 (32x4) using EraseReLU with the proportion of 50%. EraseReLU obtains a comparable result compared to the original model.
Table 3 shows the comparison of the original ResNet50 and the model using EraseReLU with the proportion of 100%. EraseReLU improves the performance of ResNet50 on ImageNet10% about 1.4% absolute top1 accuracy. When the numbers of training and validation images increase to ImageNet20%, the performance improvement goes down to 0.24%. On ImageNet30%, we also achieve a comparable results by using EraseReLU with the proportion of 25%. This indicates that the proportion is a key factor on largescale dataset, which is not much sensitive on smallscale datasets.
On the ImageNet full set, we apply EraseReLU to two models, ResNet152 and ResNet200. To ensure a fair comparison, we adopt the public Torch implementation for ResNet
^{4}^{4}4https://github.com/facebook/fb.resnet.torch and only replace the model definition by the model applying our EraseReLU. Therefore, all other factors are eliminated, such as data preprocess and data argumentations. We keep all the experiment settings the same as those used for ResNet. For both ResNet152 and ResNet200, we use the EraseReLU with the proportion of 50%. EraseReLU improves the ResNet152 on ImageNet dataset by 0.6% top1 accuracy. For ResNet200, we achieve 21.4% top1 accuracy outperforming the original one about 0.4%. The ResNet200 with EraseReLU also outperforms than the Preact ResNet200, which is an improved version of ResNet.We demonstrate EraseReLU can improve deep models in the largescale dataset. We do not apply EraseReLU to more sophisticated models on ImageNet because it needs much more hardware resources, which is unaffordable for us. All the compared models in experiments are the stateoftheart CNN architectures, which have been optimized by many researchers and validated by many systems/papers. It is not easy to remove their components. If one removes a layer or a component arbitrarily, the performance will drop significantly.
Sample Ratio  10%  20%  30%  

ResNet50  top1  47.60  36.76  31.11 
top5  23.68  15.65  11.65  
ResNet50 with ER  top1  46.18  36.42  31.10 
top5  23.20  14.99  11.64 
ModelError  top1(%)  top5(%) 

ResNet152  22.2  6.2 
ResNet152 with ER  21.6  5.8 
ResNet200  21.8  6.1 
Preact ResNet200  21.7  5.8 
ResNet200 with ER  21.4  5.8 
5 Conclusion
In this paper, we investigate the effect of erasing ReLUs in deep CNN architectures following deterministic rules. We find two key factors to performance improvement: 1) the location where the ReLU should be erased inside the basic module; 2) the proportion of modules to erase ReLU. By leveraging these two factors, we propose a simple but effective approach to improve CNN models, named “EraseReLU”. It can lead to a nonnegligible improvement of classification performance because its effectiveness in easing the optimization and regularizing the training of deep neural networks. Our approach improves the classification performance beyond various CNN architectures, such as ResNet, Preact ResNet, Wide ResNet and ResNeXt. Most of them achieve a much higher performance while having the same computation cost compared to the original models. We obtain more than 2% absolute accuracy improvement on CIFAR100 compared to the Preact ResNet1001. Our approach also leads 0.6% accuracy improvement on the largescale dataset ImageNet compared to ResNet152.
References
 [1] J. L. Ba, J. R. Kiros, and G. E. Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016.
 [2] D. Balduzzi, M. Frean, L. Leary, J. Lewis, K. W.D. Ma, and B. McWilliams. The shattered gradients problem: If resnets are the answer, then what is the question? In ICML, 2017.
 [3] X. Dong, J. Huang, Y. Yang, and S. Yan. More is less: A more complicated network with less inference complexity. In CVPR, 2017.
 [4] X. Gastaldi. Shakeshake regularization. In ICLRW, 2017.
 [5] R. Girshick, J. Donahue, T. Darrell, and J. Malik. Rich feature hierarchies for accurate object detection and semantic segmentation. In CVPR, 2014.
 [6] G. Gkioxari, R. Girshick, P. Dollár, and K. He. Detecting and recognizing humanobject intaractions. arXiv preprint arXiv:1704.07333, 2017.
 [7] X. Glorot, A. Bordes, and Y. Bengio. Deep sparse rectifier neural networks. In ICAIS, 2011.
 [8] K. He, X. Zhang, S. Ren, and J. Sun. Delving deep into rectifiers: Surpassing humanlevel performance on imagenet classification. In ICCV, 2015.
 [9] K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In CVPR, 2016.
 [10] K. He, X. Zhang, S. Ren, and J. Sun. Identity mappings in deep residual networks. In ECCV, 2016.
 [11] G. Huang, Z. Liu, K. Q. Weinberger, and L. van der Maaten. Densely connected convolutional networks. In CVPR, 2017.
 [12] G. Huang, Y. Sun, Z. Liu, D. Sedra, and K. Q. Weinberger. Deep networks with stochastic depth. In ECCV, 2016.
 [13] S. Ioffe and C. Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, 2015.
 [14] A. Krizhevsky and G. Hinton. Learning multiple layers of features from tiny images. 2009.
 [15] A. Krizhevsky, I. Sutskever, and G. E. Hinton. Imagenet classification with deep convolutional neural networks. In NIPS, 2012.
 [16] M. Lin, Q. Chen, and S. Yan. Network in network. arXiv preprint arXiv:1312.4400, 2013.
 [17] A. L. Maas, A. Y. Hannun, and A. Y. Ng. Rectifier nonlinearities improve neural network acoustic models. In ICML, 2013.

[18]
V. Nair and G. E. Hinton.
Rectified linear units improve restricted boltzmann machines.
In ICML, 2010.  [19] O. Russakovsky, J. Deng, H. Su, J. Krause, S. Satheesh, S. Ma, Z. Huang, A. Karpathy, A. Khosla, M. Bernstein, et al. Imagenet large scale visual recognition challenge. International Journal of Computer Vision, 115(3):211–252, 2015.
 [20] K. Simonyan and A. Zisserman. Very deep convolutional networks for largescale image recognition. arXiv preprint arXiv:1409.1556, 2014.
 [21] R. K. Srivastava, K. Greff, and J. Schmidhuber. Training very deep networks. In NIPS, 2015.
 [22] C. Szegedy, S. Ioffe, V. Vanhoucke, and A. A. Alemi. Inceptionv4, inceptionresnet and the impact of residual connections on learning. In AAAI, 2017.
 [23] C. Szegedy, W. Liu, Y. Jia, P. Sermanet, S. Reed, D. Anguelov, D. Erhan, V. Vanhoucke, and A. Rabinovich. Going deeper with convolutions. In CVPR, 2015.
 [24] C. Szegedy, V. Vanhoucke, S. Ioffe, J. Shlens, and Z. Wojna. Rethinking the inception architecture for computer vision. In CVPR, 2016.
 [25] S.E. Wei, V. Ramakrishna, T. Kanade, and Y. Sheikh. Convolutional pose machines. In CVPR, 2016.
 [26] S. Xie, R. Girshick, P. Dollár, Z. Tu, and K. He. Aggregated residual transformations for deep neural networks. In CVPR, 2017.
 [27] B. Xu, N. Wang, T. Chen, and M. Li. Empirical evaluation of rectified activations in convolutional network. arXiv preprint arXiv:1505.00853, 2015.
 [28] S. Zagoruyko and N. Komodakis. Wide residual networks. In BMVC, 2016.
 [29] S. Zagoruyko and N. Komodakis. Diracnets: Training very deep neural networks without skipconnections. arXiv preprint arXiv:1706.00388, 2017.
 [30] M. D. Zeiler and R. Fergus. Visualizing and understanding convolutional networks. In ECCV, 2014.
 [31] G. Zhao, Z. Zhang, J. Wang, and H. Guan. Training better cnns requires to rethink relu. arXiv preprint arXiv:1709.06247, 2017.
Comments
There are no comments yet.