Effectiveness of Scaled Exponentially-Regularized Linear Units (SERLUs)
G. Zhang H. Li



Interplay between low-lying isoscalar and isovector dipole modes: 
 a comparative analysis between semi-classical and quantum approaches
    S. Burrello^1, M. Colonna^1,  G. Colò^2,3,
D. Lacroix^4, X. Roca-Maza^2,3, G. Scamps^5,6, H. Zheng^1,7
    
========================================================================================================================================




Recently, self-normalizing neural networks (SNNs) have been proposed with the intention to avoid batch or weight normalization. The key step in SNNs is to properly scale the exponential linear unit (referred to as SELU) to inherently incorporate normalization based on central limit theory. SELU is a monotonically increasing function, where it has an approximately constant negative output for large negative input. In this work, we propose a new activation function to break the monotonicity property of SELU while still preserving the self-normalizing property. Differently from SELU, the new function introduces a bump-shaped function in the region of negative input by regularizing a linear function with a scaled exponential function,  which is referred to as a scaled exponentially-regularized linear unit (SERLU). The bump-shaped function has approximately zero response to large negative input while being able to push the output of SERLU towards zero mean statistically. To effectively combat over-fitting, we develop a so-called shift-dropout for SERLU, which includes standard dropout as a special case.  Experimental results on MNIST, CIFAR10 and CIFAR100 show that SERLU-based neural networks provide consistently promising results in comparison to other 5 activation functions including ELU, SELU, Swish, Leakly ReLU and ReLU.       






§ INTRODUCTION

How to effectively train a deep neural network has been a challenging task.  The training process could be affected by various factors such as the nature of nonlinear activation functions,  weight initialization,  neural network architectures, and optimization methods like stochastic gradient descent (SGD). In the past few years, different techniques have been proposed to improve the training process from different perspectives. Considering selection of the activation function,  the rectified linear unit (ReLU) was found to be much more effective than the binary unit in feed-forward neural networks (FNNs) and convolutional neural networks (CNNs)  <cit.>. Careful weight initialization based on the properties of the activation function and layerwise nueron-number has also been found to be essential for fast training (e.g., <cit.>). Nowadays, neural networks with shortcuts (e.g., ResNet <cit.> and Unet <cit.>) become increasingly popular as introduction of the shortcuts greatly alleviates the issue of gradient vanishing or explosion, which become severe issues when training extremely deep neural networks.  From the optimization point of view, SGD is simple and effective but often needs manual tunning of its learning rate. Advanced gradient based methods (e.g., Adam <cit.>, AdaGrad <cit.>,  RMSProp <cit.>) have thus been proposed to enable both fast training speed and adaptive learning rates.   

In recent years, a family of normalization techniques have been proposed to accelerate the training process. The motivation behind these techniques is to make proper adjustment at each individual layer so that either the input or output statistics of the activation functions of the layer are unified in terms of the first and/or second moments. By doing so, the problem of internal covariance shift can be largely alleviated, thus significantly improving the efficiency of the back-propagation optimization methods. Those techniques can be roughly classified as (a): data-driven normalization, (b): weight normalization, and (c): activation-function normalization. Data-driven normalization operates directly on the  layer-wise internal features of training data, which includes for example batch normalization <cit.> and layer normalization <cit.>. This type of normalisations are shown to be remarkably effective but introduce extra computation and often have to carefully handle the inconsistency between training and inference, as the input statistics at the inference stage might be changed due to fewer number of input samples. In <cit.>, the authors consider performing weight normalization instead to indirectly regulate the statistics of the layer-wise internal features. A mixture of batch and weight normalization has recently been found to work effectively in training large-scale deep neural networks <cit.>.  
 
The concept of activation-function normalization has been introduced recently by Klambauer at al. <cit.>. The authors proposed a scaled exponential linear unit (SELU), which takes the form of 

    SELU(x) = λ_selu{[             x          x≥ 0; α_selu(e^x-1)     otherwise ].,

where α_selu≈ 1.6733 and λ_selu≈ 1.0507. Theoretical analysis is provided showing that if the input to SELU follows a Gaussian distribution with mean and variance floating around 0 and 1,  the mean and variance of the output tend to get closer to 0 and 1 under certain conditions of the weights. The above self-normalizing property simultaneously addresses the covariate shift and vanishing or exploding gradient problems across neural layers, thus making data-driven or weight normalizations unnecessary or less important. It is noted that SELU is a monotonically increasing function, and has an approximately constant response -λ_seluα_selu for large negative input. The property of negative constant response is not consistent with that of ReLU which has zero response for negative input. One natural question is if an activation function which has zero response for large negative input while keeping the self-normalizing property would make the resulting neural networks more learnable for training and more generalizable for inference.   



In this paper, we develop a new activation function termed as a scaled exponentially regularized linear unit (SERLU). The response of SERLU for negative input is designed to be a linear function regularized by an exponential function, leading to a bump-shaped function for negative input. The bump-shaped function is then properly scaled to be able to push the output of SERLU towards zero mean statistically while having an approximately zero response to large negative input. The self-normalizing property of SERLU is investigated through numerical evaluation to provide a general understanding of its normalizing behavior. The design of SERLU is partly inspired by two recent studies on activation functions <cit.> and <cit.>. In both works, the authors have attempted to develop new activation functions by either evaluating or learning different combinations of basic functions. Most discovered activation functions do not have monotonicity properties. That is those functions have local bumps, which provide supports for the newly proposed SERLU. We will evaluate the so-called Swish activation function discovered in <cit.>, which takes the form Swish(x)=x ·sigmoid(β x). In this work, we set β=1 for  Swish(x). 

Due to the special functional form of SERLU, we propose a new dropout technique for SERLU, referred to as shift-dropout. Instead of randomly setting a unit activation to zero as performed by standard dropout, shift-dropout randomly sets a unit activation to the minimum functional value of SERLU, which then undergoes an affine transformation to preserve the mean of unit activations. The above operation attempts to make the output of SERLU at each neuron have a flat distribution rather then concentrate in a small region, making the resulting neural network generalizable. Shift-dropout includes the standard dropout as a special case by setting its minimum functional value to zero.   

In the experiment, we evaluate 6 activation functions including SERLU, SELU<cit.>, ELU <cit.>, Swish <cit.>, Leakly ReLU <cit.>, and ReLU due to their similar responses to positive input (See Figure <ref>). We firstly compare SERLU and SELU for a FNN using MNIST due to the fact that both activation functions are derived based on certain properties of FNNs. It is clear from the results that SERLU outperforms SELU.  We then evaluate all the 6 activation functions for a variant of LeNet <cit.> (i.e., one type of CNNs) on MNIST, CIFAR10, and CIFAR100.  The results suggest that SERLU provides consistently promising performance while others do not always produce competitive performance over the three datasets. 



 

§ SCALED EXPONENTIALLY-REGULARIZED LINEAR UNITS (SERLUS)


   
 

 §.§ Expression of SERLU

 Formally, we define the new activation function as   

    SERLU(x) = λ_serlu{[            x         x≥ 0; α_serlu xe^x    otherwise ].,

where the two parameters λ_serlu>0 and α_serlu>0 remain to be specified.  Regardless of the two parameters, the difference between  (<ref>) and (<ref>) sits in the functional segment for negative input x< 0. Specifically, SERLU has a bump-shaped function formulated as xe^x for x< 0 while SELU has a monotonically increasing function (e^x-1) in the same support region. The bump-shaped function ensures that SERLU has a negligible response for large negative input, which is asymptotically consistent with that of ReLU. When x=-1, SERLU reaches the global minimum functional value f_min=-λ_serluα_serlue^-1. 

Next we consider the difference between SERLU and Swish(x) as introduced in <cit.>. Even though Swish(x)=x ·sigmoid(β x) also has a bump for negative input, its functional form is less flexible than SERLU(x). As will be explained later on, the two parameters λ_serlu>0 and α_serlu>0 makes it possible to freely adjust the mean and variance of the output of SERLU(x) for a random input variable x. It is this freedom that allows us to properly  scale SERLU(x) to have the  self-normalizing property. On the other hand, Swish(x) only has one free parameter β for adjustment, which is not primarily designed to gain the self-normalizing property.

We note that one can develop alternative bump-shaped functions for negative input to replace SERLU(x).  For instance, one can choose x^ne^-x^2 or x^ne^x, where n is an odd number. Another bump-shaped functional form would be to combine a shift version of -e^x and a linear functional segment. We conjecture that the above functional forms might produce similar promising experimental results as SERLU as will be demonstrated later on. In this work, we choose the form xe^x due to its simplicity. Furthermore, xe^x facilitates computation of the mean and variance of the output of SERLU for a Gaussian random input variable x.  





 §.§ Input-output statistical properties of SERLU




 We focus on the FNNs where the weights are not shared across space to facilitate the analysis. We follow a similar procedure as <cit.> for analyzing SELU. The basic idea of <cit.> is to assume both the input x and output z=f(x) for any nueron in a neural network are random variables.  Furthermore, the output random variables {z_i} from the same neural layer are to assume to be independent. If the number of nuerons at every layer is large enough, the input random variable x to a nueron in a certain layer can be assumed to approximately follow a Gaussian distribution as it is a linear combination of many random variables from the layer below. 
Since there are often many neurons per layer in a FNN,  the Gaussian distribution approximation is reasonable.    

We now consider two consecutive layers where the connections are characterized by a weight matrix W.  Suppose the lower layer has n units with random output variables {z_i,low| 1≤ i≤ n }, where we use z_low to denote its compact vector form. Following the work <cit.>, we assume all the output variables from the lower layer are independent, and have the same mean μ=E(z_i,low) and the same variance ν = Var(z_i,low), where the notations E(·) and Var(·) represent expectation and variance of a random variable, respectively. Given z_low from the lower layer, the input x_up and output z_up for a neuron at the upper layer can be represented as 

    z_up=SERLU(x_up),   where  x_up =z_low^Tw= ∑_i=1^n w_i z_i,low,

where w is one column vector of  W.  Similarly to z_i,low, we denote the mean and variance of the output variable z_up as μ̃ and ν̃. To facilitate the analysis later on, we let ω =1^Tw= ∑_i=1^n w_i  and  τ  = w^Tw= ∑_i=1^n w_i^2. Most of the above introduced notations are in line with those in <cit.> to enhance readability of the paper.   
 
Finally we would like to derive the expressions for (μ̃, ν̃) for the output z_up based on the statistics of z_low.  To do so, we first consider the input variable x_up. By using the independence assumption of z_i,low, the mean and variance of x_up are expressed as E(x_up)=μω and Var(x_up)=ντ. Similarly to <cit.>, we assume x_up has a Gaussian distribution (i.e., x_up∼𝒩(μω, √(ντ))). The central limit theorem (CLT) suggests that a large number of neuorns in the lower layer leads to an accurate Gaussian approximation. In FNNs, it is common to have hundreds of nuerons per layer. Accordingly, the expressions for (μ̃, ν̃) for the output z_up can be computed as

    μ̃   =∫_-∞^0 [λ_serluα_serlu xe^x] f_Gauss(x,μω, √(ντ))dx +∫_0^∞ [λ_serlu x] f_Gauss(x,μω, √(ντ))dx  
    ν̃   = ∫_-∞^0 [λ_serluα_serlu xe^x]^2 f_Gauss(x,μω, √(ντ))dx +∫_0^∞ [λ_serlu x]^2 f_Gauss(x,μω, √(ντ))dx -μ̃^2.

By using algebra, the expression μ̃ and ν̃ can be simplified as

    μ̃ =λ_serlu/2√(π)e^-μ ^2 ω ^2/2 ντ(e^(ντ +μω )^2/2 ντ√(π)α_serlu
     (ντ +μω)Erfc[ντ +μω/√(2)√(ντ)] +√(2)√(ντ) (1-α_serlu) 
       +e^μ ^2 ω ^2/2 ντ√(π)μω(2-Erfc[μω/√(2)√(ντ)] )), 
       ν̃  = 1/2λ_serlu ^2 ( e^-μ ^2 ω ^2/2 ντ√(2/π)√(ντ) [(1-α_serlu ^2)μω -  2α_serlu ^2 ντ ]  
    +(ντ +μ ^2 ω ^2)(2-Erfc[μω/√(2)√(ντ)]) 
       +  α_serlu ^2  e^-μ^2 ω ^2/2 ντe^(2 ντ +μω
    )^2/2 ντ(4 ν ^2 τ ^2+μ ^2 ω ^2+ν  (τ +4 μτω )) Erfc[2 ντ
    +μω/√(2)√(ντ)])- μ̃^2.

It is clear that (μ̃ ,ν̃) is a function of (μ,ν), (ω,τ) and (α_serlu,λ_serlu). 



 §.§ Determination of α_serlu and λ_serlu

So far we have characterized the relationship between (μ̃ ,ν̃) for the upper layer and  (μ ,ν) for the lower layer.  To make SERLU exhibit the self-normalizing property as SELU, the first step would be to determine α_serlu and λ_serlu so that the mean and variance of the output of SERLU are consistent across layers, i.e., (μ̃ ,ν̃) =  (μ ,ν).  In other words, α_serlu and λ_serlu should be selected to ensure that (μ ,ν) is a fixed point of the mapping g: (μ ,ν)→ (μ̃ ,ν̃) as defined by (<ref>)-(<ref>). In principle, one can specify different fixed points and then search for the corresponding solution α_serlu and λ_serlu. In this work, we set the mean μ=0 and the variance ν =1 for the fixed point, which is consistent with derivation of SELU. Furthermore, we assume w is a normalized weighting vector with ω = 0 and τ = 1. With the above parameter specification, (<ref>)-(<ref>) becomes two equations w.r.t. (α_serlu ,λ_serlu). Solving them produces 

    α_serlu≈ 2.90427    and   λ_serlu≈ 1.07862.

Algebraically speaking, the parameter α_serlu regulates the mean  unit activations to be zero while λ_serlu normalizes the variance of the unit activation. 

Next we study if (μ, ν) =(0,1) is a stable fixed point under the mapping g. It is know that if the spectral norm of the Jacobian of the mapping g is less than 1, then the fixed point is stable and g is a contraction mapping in a small region around the fixed point. By computation, the 2× 2 Jacobian 𝒥(μ,ν) at the fixed point (0,1) with the parameter setup (<ref>) is 𝒥(0,1)=((0,0.194557),(0, 0.605258)). The spectral norm of 𝒥(0,1) is thus 0.635758 <1. This implies that g is indeed a contraction mapping around (0,1). It is reported in <cit.> that the spectral norm of 𝒥(0,1) for SELU is 0.7877 (>0.635758). This suggests that SERLU has comparable convergence as SELU in the region close to (0,1). In general, the convergence rate is also affected by (ω,τ). 

We notice that batch normalization explicitly operates on the layerwise internal features of training data. As a result, backpropogation of gradient needs to take into account the operation, which introduce extra computational burden. On the other hand, both SERLU and SELU implicitly absorb the normalization operation into their functional form via two fixed scalar parameters, which is more computationally efficient.      













 §.§ On self-normalizing property of SERLU through numerical evaluation




In this subsection, we consider the cross-layer effect of SERLU in a FNN. Firstly,  we need to relax the assumption on a normalized weight vector w. Specifically, we assume the mean ω  and second moment τ of the vector w may fluctuate around  0 and 1, respectively. In practice, SGD based optimization methods deliberately introduce noise to the gradient of w via minibatches to  alleviate over-fitting, leading to disturbance of ω and τ per iteration. We are interested in if g: (μ ,ν)→ (μ̃ ,ν̃) defined in (<ref>)-(<ref>) is still an attracting mapping under the disturbance. If so, the resulting SERLU-based FNN would preserve normalization across layers, leading to a SNN.   

We first review the definition of SNNs introduced in <cit.>:

A neural network is self-normalizing if it possesses a mapping g: Ω→Ω for each activation z that maps mean and variance from one layer to the next and has a stable and attracting fixed point depending on (ω,τ) in Φ, where Φ={(ω, τ) | ω∈ [ω_min,ω_max], τ∈ [ν_min,τ_max] )}. Furthermore, the mean and variance remain in the domain Ω, that is g(Ω)⊂Ω, where Ω = {(μ, ν) | μ∈ [μ_min,μ_max], ν∈ [ν_min,ν_max] )}.


The above definition implies that if the disturbance to the weight vectors are uniformly bounded (w.r.t.  the mean μ and second moment τ) across neural layers, the mean and variance of the unit activations stay in the predefined intervals when propagating them from the bottom layer towards the top one in the network. Furthermore, if the mean and second moments of the weight vectors converge over iterations, the mean and variance of the unit activations at every layer converge to their respective fixed points. In practice, weight normalization is one solution to make the weight vectors free of disturbance over iterations. Differently from batch normalization,  weight normalization only requires a small amount of computational resource. 

We now study the properties of the mapping g for SERLU by numerical evaluation. We let the two domains Ω and Φ to be  Ω = {μ∈ [μ_min,μ_max]=[-0.2,0.2], ν∈ [ν_min, ν_max]=[0.8, 1.5] } and Φ = {ω∈ [ω_min, ω_max]= [-0.1, 0.1], τ∈ [τ_min,τ_max]=[0.9,1.2]}. Our primary interest is the maximum spectral norm of the Jacabian of g and the domain g(Ω) after mapping.  To achieve the goal, we first generate a dense sampling grid of  (μ,ω,ν,τ) in Ω and Φ and then numerically evaluate the output (μ̃,ν̃) for each sampling point from the grid.  The sampling interval is set as 0.02 for each variable.  The results are summarized in Table <ref>.  It is found that the maximum spectral norm over all the grid points is 0.7837<1, implying that the mapping g is attractive around each evaluated point. In addition, the bounds for μ̃ and ν̃ are within the domain Ω for all the tested grid points. The above results suggest that the response of the mapping g at those grid points is controllable.  
            
      
      


We point out that the numerical evaluation is mainly for drawing a general picture of the response of the mapping function g over the considered domains Ω and Φ.  It is not a proof for showing that g is an attractive mapping.  We conjecture that a similar theoretical analysis as that of SELU exists for SERLU. This is because the two activation functions only involve three basic functions x, e^x and xe^x, which can be nicely combined with the functional form e^-x^2/2 of Gaussian distribution in computing the mean and variance of two unit activations. 




 
 
 



§ SPECIALIZED DROPOUT TECHNIQUE FOR SERLU
 




It is well known that dropout plays an important role to avoid or alleviate the overfitting problem.  Since the pioneering work by Srivastava et al. <cit.>, the standard dropout operation has been modified or adjusted in different ways for training special types of neural networks. One typical example is to redesign dropout for training LSTM-based neural networks where the recurrent connection makes training considerably challenging (e.g., <cit.>).  In <cit.>, the authors propose a so-called alphaDropout for SNNs to improve the performance, which we will briefly discuss later on.  

In this work, we propose a variant of the standard dropout for SERLU-based neural networks. Let us first revisit the standard dropout. The basic idea is to randomly set an activation z to zero during training with probability 1-q where 0<q≤ 1. To compensate for the dropout effect, the activation is then scaled by 1/q. By doing so, the mean of the activations would be preserved, ensuring consistency over iterations. The above statement can be easily justified mathematically. Suppose the activation z has mean E(z)=μ, and the dropout variable d follows a binomial distribution B(1,q). It is immediate that the mean E(d*z/q)=μ.  The dropout operation allows to train an ensemble of all sub-networks seamlessly and effectively.  


Considering SERLU(x), its minimum functional value f_min=-λ_serluα_serlue^-1 is achieved only at a single point x=-1. This suggests that the minimum value would not be frequently visited during training. As a result, it might be a bit difficult for points at the two sides of x=-1 jump to the opposite side to fully explore the functional properties of SERLU in the whole negative input region x<0. Based on the above analysis, we extend the standard dropout in a following manner. Instead of zero, we randomly set an activation z to the minimum functional value f_min with probability 1-q.  We use z̃ to denote the modified activation. The mean of z̃ is thus given by E(z̃)=E(d*z + (1-d)*f_min) = qμ+(1-q)f_min, which is not equal to μ. To be able to preserve the mean μ of the activation, one simple solution is to perform an affine transformation to z̃, which can be mathematically expressed as 

    ẑ = 1/q[ z̃-(1-q)f_min ].

It is not  difficult to show that the final activation ẑ indeed preserves the mean μ as the original activation z. We refer to the new dropout technique as shift-dropout. 

We point out that alphaDropout in <cit.> also randomly sets an activation z to the minimum functional value of SELU.  One major difference from shift-dropout is that alphaDropout adjusts the activation to follow a predefined mean μ=0 and variance ν=1 to be in line with the normalization properties of SELU. We think that in practice, the input-output statistics of either SELU or SERLU may break the assumption of predefined mean μ=0 and variance ν=1 due to, for example, rough Gaussian distribution approximation or the statistical bias introduced by minibatches.  
Shift-dropout is motivated to preserve the mean E(z)=μ of the real training data, which may bring robustness when training a SERLU-based neural network. 
  
  
From a high level perspective, shift-dropout includes standard dropout as a special case by setting f_min =0 in (<ref>). Application of standard dropout to ReLU and Sigmoid can be interpreted as performing shift-dropout to ReLU and Sigmoid as their minimum functional value is zero. 







§ EXPERIMENTAL RESULTS






Evaluation of SERLU and SELU over a FNN: In the first experiment, we investigated the performance of the two functions over a FNN of 4 hidden layers with 200 neurons per layer  for the handwritten digital classification task from MNIST.  We motivation is that since both SERLU and SELU are designed based on the assumption of many neurons per layer to allow for the application of the central limit theory, it is interesting to find out their performance on a FNN. In the implementation, dropout with 10% rate was introduced at every hidden layer. SELU used alphaDropout while SERLU used shift-dropout to fully explore their capability.  The network was trained using RMSProp <cit.> with a learning rate of 10^-4 and  a decay of 10^-6.  Figure <ref> displays their convergence rates for the validation dataset. It is clear that SERLU exhibits faster convergence speed, which might be due to the effect of the  bump-shaped functional segment of SERLU for negative input.   

Evalution of 6 activation functions over a CNN: In the 2nd experiment, we evaluated 6 activation functions: namely SERLU, SELU, ELU, Swish, Leaky-ReLU, and ReLU. All the six functions have similar responses to positive input while their responses to negative input are designed by following different methodologies (see Figure <ref>:(a) for their respective response curves).  It is therefore of great interest to evaluate their performance within a unified framework.   
 
We consider the classification problem over three datasets: MNIST,  CIFAR10 and CIFAR100. The tested neural network for CIFAR10 and CIFAR100 is a variant of LeNet <cit.> as illustrated in Table <ref> while the network for MNIST is obtained by removing Layer 1 and Layer 3 in the table.  Ideally, different datasets should employ specialized neural network architectures to optimally capture the input-output relationship of each dataset. In our experiment, the architecture of the tested CNN is not optimized to promote the classification accuracy for the three datasets but rather to provide a unified framework to investigate the behaviours of the 6 activation functions. 

Similarly to the first experiment, we trained the network using RMSProp <cit.> with a learning rate of 10^-4 and  a decay of 10^-6. To alleviate overfitting, each of the three datasets was augmented with additional training data (e.g., by shifting images vertically and/or horizontally).  SERLU used shift-dropout as proposed in Section <ref> while all other activation functions used the standard dropout  [alphaDropout was found to work only for small dropout rate for SELU, which is consistent with the findings in  <cit.>. ]. The dropout rate for each layer is the same across all the 6 activation functions. 





 

The performance results w.r.t. validation data are demonstrated in Figure <ref>. it is seen that SERLU provides consistently promising performance for the three datasets. In all the three experiments, no noticable overfitting is observed over the tested number of epochs for the new activation function. Furthermore, SERLU provides the best performance for CIFAR100 and the second-best performance for CIFAR10, and performs equally well as Swish for MNIST w.r.t. validation loss. Even though Leaky ReLU converges the fastest for CIFAR10, its performance for the other two datasets is not competitive. SELU and ELU exhibit similar convergence behaviours, which is reasonable given that they have similar activation responses to input. The two activation functions exhibit over-fitting for CIFAR100 which might be because the LeNet is not suitable for CIFAR100, which explains why the overall performance of the 6 activation functions is not promising. 

Finally we note that Swish demonstrates roughly the same fast convergence speed as SERLU for MINST w.r.t. validation loss.  We recall that Swish has a small flat bump for negative input while SERLU has a relatively large sharp bump. The different performance of the two activation functions for CIFAR10 and CIFAR100 suggests that a large bump might be generally favourable when constructing a neural network.   





§ CONCLUSIONS


In this paper we have introduced a new activation function termed as SERLU together with a new dropout technique termed as shift-dropout. SERLU is designed to have a large sharp bump in the negative input region which pushes the mean of unit activation to zero. This is fundamentally different from ELU and SELU which are monotonically increasing functions, and have approximately constant negative response for large negative input.  Numerical evaluations on a dense sampling grid suggest that SERLU exhibits the self normalising properties as SELU at those tested points. Further theoretical analysis is required to show that SERLU has the self normalising properties over a continuous region. 

Experiments on MNIST, CIFAR10 and CIFAR100 were conducted showing that SERLU has consistently promising results over the three datasets in comparison to other 5 activation functions (ELU, SELU, Swish, Leaky ReLU and ReLU). We believe that the bump-shaped functional segment of SERLU together with the coupled shift-dropout plays a key role in its promising performance. 

As mentioned in Subsection 2.1, there are different ways to introduce bumps to activation functions.  We hope our work could bring insights for interested researchers to design more effective bump-shaped activation functions to benefit the whole deep learning community.   








10

Clevert16ELU
D.-A. Clevert, T. Unterthiner, and S. Hochreiter.
Fast and accurate deep network learning by exponential linear units
  (elus).
arXiv:1511.07289 [cs.LG], 2016.

Duchi11AdaGrad
J. Duchi, E. Hazan, and Y. Singer.
Adaptive Subgradient Methods for Online Learning and Stochastic
  Optimization.
Journal of Machine Learning Research, 12:2121–2159, 2011.

Gal16Dropout
Y. Gal and Z. Ghahramani.
A theoretically grounded application of dropout in recurrent neural
  networks.
arXiv:1512.05287v5 [stat.ML], 2016.

He15ResNet
K. He, X. Zhang, S. Ren, and J. Sun.
Deep residual learning for image recognition.
In IEEE conference on Computer Vision and Pattern Recognition
  (CVPR), 2015.

He15WeiInti
K. He, X. Zhang, S. Ren, and J. Sun.
Delving deep into rectifiers: Surpassing human-level performance on
  imagenet classification.
In Proceedings of the IEEE international conference on computer
  vision, pages 1026–1034, 2015.

Hoffer18N
E. Hoffer, R. Banner, I. Golan, and D. Soudry.
Norm matters: efficient and accurate normalization schemes in deep
  networks.
arXiv:1803.01814 [stat.ML], 2018.

Ioffe15BN
S. Ioffe and C. Szegedy.
Batch normalization: Accelerating deep network training by reducing
  internal covariate shift.
volume 37 of JMLR Proceedings, pages 448–456, 2015.

Ba16LN
G. E. H. J. L. Ba, J. R. Kiros.
Layer Normalization.
arXiv:1607.06450 [stat.ML], 2016.

Kingma17
D. P. Kingma and J. L. Ba.
Adam: A method for Stochastic Optimization.
arXiv preprint arXiv:1412.6980v9, 2017.

Klambauer17SNN
G. Klambauer, T. Unterthiner, A. Mayr, and S. Hochreiter.
Self-Normalizing Neural Networks.
In 31st Conference on Nueral Information Processing Systems
  (NIPS), 2017.

Krueger17ZoneOut
D. Krueger, T. Maharaj, J. Kramar, M. Pezeshki, N. Ballas, N. R. Ke, A. Goyal,
  Y. Bengio, A. Courville, and C. Pal.
Zoneout: Regularing rnns by randomly preserving hidden activations.
arXiv:1606.01305v4 [cs.NE], 2017.

Maas13Leaky
A. L. Maas, A. Y. Hannun, and A. Y. Ng.
Rectifier Nonlinearities Improve Neural Network Acoustic Models.
In Proceedings of the 30th International Conference on Ma- chine
  Learning, 2013.

Manessi18SAF
F. Manessi and A. Rozza.
Learning combinations of activation functions.
arXiv:1801.09403 [cs.LG], 2018.

Nair10ReLU
V. Nair and G. E. Hinton.
Rectified Linear Units Improve Restricted Boltzmann Machines.
In Proceedings of the 27th International Conference on Machine
  Learning,, 2010.

Ramachandran17Swiss
P. Ramachandran, B. Zoph, and Q. V. Le.
Searching for activation functions.
arXiv:1710.05941v2 [cs.NE], 2017.

Ronneberger15Unet
O. Ronneberger, P. Fischer, and T. Brox.
U-Net: Convolutional Networks for Biomedical Image Segmentation.
arXiv:1505.04597 [cs.CV], 2015.

Srivastava14Dropout
N. Srivastava, G. Hinton, A. Krizhevsky, I. Sutskever, and R. Salakhutdinov.
Dropout: A Simple Way to Prevent Neural Networks from Overfitting.
Journal of Machine Learning Research, pages 1929–1958, 2014.

Salimans16WN
D. P. K. T. Salimans.
Weight Normalization: A Simple Reparameterization to Accelerate
  Training of Deep Neural Networks.
arXiv:1602.07868 [cs.LG], 2016.

Tieleman12RMSProp
T. Tieleman and G. Hinton.
Lecture 6.5-rmsprop: Divide the gradient by a running average of its
  recent magnitude.
COURSERA: Neural networks for machine learning, 2012.

LeCun98LeNet
L. B. Y. LeCun, Y. Bengio, and P. Haffner.
Gradient-Based Learning Spplied to Document Recognition.
Proc. of the IEEE, 1998.



