Title: Regularization for Deep Learning: A Taxonomy

Abstract: Regularization is one of the crucial ingredients of deep learning, yet the term regularization has various definitions, and regularization methods are often studied separately from each other. In our work we present a novel, systematic, unifying taxonomy to categorize existing methods. We distinguish methods that affect data, network architectures, error terms, regularization terms, and optimization procedures. We identify the atomic building blocks of existing methods, and decouple the assumptions they enforce from the mathematical tools they rely on. We do not provide all details about the listed methods; instead, we present an overview of how the methods can be sorted into meaningful categories and sub-categories. This helps revealing links and fundamental similarities between them. Finally, we include practical recommendations both for users and for developers of new regularization methods.

1. Introduction:

Regularization is one of the key elements of machine learning, particularly of deep learning (Goodfellow et al., 2016) , allowing to generalize well to unseen data even when training on a finite training set or with an imperfect optimization procedure. In the traditional sense of optimization and also in older neural networks literature, the term "regularization" is reserved solely for a penalty term in the loss function (Bishop, 1995a) . Recently, the term has adopted a broader meaning: Goodfellow et al. (2016, Chap. 5 ) loosely define it as "any modification we make to a learning algorithm that is intended to reduce its test error but not its training error". We find this definition slightly restrictive and present our working definition of regularization, since many techniques considered as regularization do reduce the training error (e.g. weight decay in AlexNet (Krizhevsky et al., 2012) ). Definition 1. Regularization is any supplementary technique that aims at making the model generalize better, i.e. produce better results on the test set. This can include various properties of the loss function, the loss optimization algorithm, or other techniques. Note that this definition is more in line with machine learning literature than with inverse problems literature, the latter using a more restrictive definition.

In this work, we create a novel, systematic, unifying taxonomy of regularization methods for deep learning. We analyze existing methods and identify their atomic building blocks. This leads to decoupling of two important concepts: Which assumptions the methods rely on (and try to enforce), and which mathematical and algorithmic tools they use. In turn, this enables better understanding of existing methods and speeds up development of new ones: The researchers can focus either on finding new, better ways of enforcing existing assumptions, or focus on discovery of new assumptions that can be enforced in some existing way.

Before we proceed to the presentation of our taxonomy, we revisit some basic machine learning theory in Section 2. This will provide a justification of the top level of the taxonomy. In Sections 3-7, we continue with a finer division of the individual classes of the regularization techniques, aiming at separating as many clearly separable concepts as possible and isolating atomic building blocks of individual methods. Finally, in Section 8 we present our practical recommendations for using existing methods and designing new methods. We are aware that the many research works discussed in this taxonomy cannot be summarized in a single sentence. For the sake of structuring the multitude of papers, we decided to merely describe a certain subset of their properties according to the focus of our taxonomy.

2. Theoretical framework:

The central task of our interest is model fitting: finding a function 𝑓 that can well approximate a desired mapping from inputs 𝑥 to desired outputs 𝑓 (𝑥). A given input 𝑥 can have an associated target 𝑡 which dictates the desired output 𝑓 (𝑥) directly (or in some applications indirectly (Ulyanov et al., 2016; Johnson et al., 2016)) . A typical example of having available targets 𝑡 is supervised learning. Data samples (𝑥, 𝑡) then follow a ground truth probability distribution 𝑃 .

In many applications, neural networks have proven to be a good family of functions to choose 𝑓 from. A neural network is a function 𝑓 𝑤 : 𝑥 ↦ → 𝑦 with trainable weights 𝑤 ∈ 𝑊 . Training the network means finding a weight configuration 𝑤 * , which is a result of performing a minimization procedure of a loss function ℒ : 𝑊 → R as follows:

𝑤 * = minimize ℒ(𝑤).

(1)

Usually the loss function takes the form of expected risk :

EQUATION

where we identify two parts, an error function 𝐸 and a regularization term 𝑅. The error function depends on the targets and assigns a penalty to model predictions according to their consistency with the targets. The regularization term assigns a penalty to the model based on other criteria. It may depend on anything except the targets, for example on the weights (see Section 6).

The expected risk cannot be minimized directly since the data distribution 𝑃 is unknown. Instead, a training set 𝒟 sampled from the distribution is given. The minimization of the expected risk can be then approximated by (approximately) minimizing the empirical risk L: 

where (𝑥 𝑖 , 𝑡 𝑖 ) are samples from 𝒟.

Now we have the minimal background to formalize the division of regularization methods into a systematic taxonomy. In the minimization of the empirical risk, Eq. (3), we can identify the following elements that are responsible for the value of the learned weights, and thus can contribute to regularization:

• 𝒟: The training set, discussed in Section 3

• 𝑓 : The selected model family, discussed in Section 4

• 𝐸: The error function, briefly discussed in Section 5

• 𝑅: The regularization term, discussed in Section 6

• The optimization procedure itself, discussed in Section 7

Ambiguity regarding the splitting of methods into these categories and their subcategories is discussed in Appendix A using notation from Section 3.

3. Regularization via data:

The quality of a trained model depends largely on the training data. Apart from acquisition/selection of appropriate training data, it is possible to employ regularization via data. This is done by applying some transformation to the training set 𝒟, resulting in a new set 𝒟 𝑅 . Some transformations perform feature extraction or pre-processing, modifying the feature space or the distribution of the data to some representation simplifying the learning task. Other methods allow generating new samples to create a larger, possibly infinite, augmented dataset. These two principles are somewhat independent and may be combined.

The goal of regularization via data is either one of them, or the other, or both. They both rely on transformations with (stochastic) parameters: Definition 2. Transformation with stochastic parameters is a function 𝜏 𝜃 with parameters 𝜃 which follow some probability distribution.

In this context we consider 𝜏 𝜃 which can operate on network inputs, activations in hidden layers, or targets. An example of a transformation with stochastic parameters is the corruption of inputs by Gaussian noise (Bishop, 1995b; An, 1996) :

EQUATION

)

The stochasticity of the transformation parameters is responsible for generating new samples, i.e. data augmentation. Note that the term data augmentation often refers specifically to transformations of inputs or hidden activations, but here we also list transformations of targets for completeness. The exception to the stochasticity is when 𝜃 follows a delta distribution, in which case the transformation parameters become deterministic and the dataset size is not augmented.

We can categorize the data-based methods according to the properties of the used transformation and of the distribution of its parameters. We identify the following criteria for categorization (some of them later serve as columns in Tables 1 2 ):

Stochasticity of the transformation parameters 𝜃

• Deterministic parameters: Parameters 𝜃 follow a delta distribution, size of the dataset remains unchanged • Stochastic parameters: Allow generation of a larger, possibly infinite, dataset. Various strategies for sampling of 𝜃 exist:

-Random: Draw a random 𝜃 from the specified distribution -Adaptive: Value of 𝜃 is the result of an optimization procedure, usually with the objective of maximizing the network error on the transformed sample (such "challenging" sample is considered to be the most informative one at current training stage), or minimizing the difference between the network prediction and a predefined fake target 𝑡 ′ * Constrained optimization: 𝜃 found by maximizing error under hard constraints (support of the distribution of 𝜃 controls the strongest allowed transformation) * Unconstrained optimization: 𝜃 found by maximizing modified error function, using the distribution of 𝜃 as weighting (proposed herein for completeness, not yet tested) * Stochastic: 𝜃 found by taking a fixed number of samples of 𝜃 and using the one yielding the highest error

Effect on the data representation:

• Representation-preserving transformations: Preserve the feature space and attempt to preserve the data distribution • Representation-modifying transformations: Map the data to a different representation (different distribution or even new feature space) that may disentangle the underlying factors of the original representation and make the learning problem easier

Transformation space:

• Input: Transformation is applied to 𝑥

• Hidden-feature space: Transformation is applied to some deep-layer representation of samples (this also uses parts of 𝑓 and 𝑤 to map the input into the hidden-feature space; such transformations act inside the network 𝑓 𝑤 and thus can be considered part of the architecture, additionally fitting Section 4)

• Target: Transformation is applied to 𝑡 (can only be used during the training phase since labels are not shown to the model at test time)

Universality:

• Generic: Applicable to all data domains

• Domain-specific: Specific (handcrafted) for the problem at hand, for example image rotations

Dependence of the distribution of 𝜃

• 𝑝(𝜃): distribution of 𝜃 is the same for all samples

• 𝑝(𝜃|𝑡): distribution of 𝜃 can be different for each target (class)

• 𝑝(𝜃|𝑡 ′ ): distribution of 𝜃 depends on desired (fake) target 𝑡 ′

• 𝑝(𝜃|𝑥): distribution of 𝜃 can be different for each input vector (with implicit dependence on 𝑓 and 𝑤 if the transformation is in hidden-feature space)

• 𝑝(𝜃|𝒟): distribution of 𝜃 depends on the whole training dataset

• 𝑝(𝜃|x): distribution of 𝜃 depends on a batch of training inputs (for example (parts of) the current mini-batch, or also previous mini-batches)

• 𝑝(𝜃|time): distribution of 𝜃 depends on time (current training iteration)

• 𝑝(𝜃|𝜋): distribution of 𝜃 depends on some trainable parameters 𝜋 subject to loss minimization (i.e. the parameters 𝜋 evolve during training along with the network weights 𝑤)

• Combinations of the above, e.g. 𝑝(𝜃|𝑥, 𝑡), 𝑝(𝜃|𝑥, 𝜋), 𝑝(𝜃|𝑥, 𝑡 ′ ), 𝑝(𝜃|𝑥, 𝒟), 𝑝(𝜃|𝑡, 𝒟), 𝑝(𝜃|𝑥, 𝑡, 𝒟)

Phase:

• Training: Transformation of training samples

• Test: Transformation of test samples, for example multiple augmented variants of a sample are classified and the result is aggregated over them A review of existing methods that use generic transformations can be found in Table 1 . Dropout in its original form (Hinton et al., 2012; Srivastava et al., 2014) is one of the most popular methods from the generic group, but also several variants of Dropout have been proposed that provide additional theoretical motivation and improved empirical results (Standout (Ba and Frey, 2013) , Random dropout probability (Bouthillier et al., 2015) , Bayesian dropout (Maeda, 2014) , Test-time dropout (Gal and Ghahramani, 2016) ).

Table 2 contains a list of some domain-specific methods focused especially on the image domain. Here the most used method is rigid and elastic image deformation.

Target-preserving data augmentation In the following, we discuss an important group of methods: target-preserving data augmentation. These methods use stochastic transformations in input and hidden-feature spaces, while preserving the original target 𝑡. As can be seen in the respective two columns in Tables 1-2, most of the listed methods have exactly these properties. Label smoothing (Szegedy et al., 2016, Sec. 7; Goodfellow et al., 2016, Chap. 7 )

𝑝(𝜃) Target Deterministic Training

Model compression (mimic models, distilled models) (Bucilă et al., 2006; Ba and Caruana, 2014; Hinton et al., 2015) 𝑝(𝜃|𝑥, 𝒟)

Target Deterministic Training:

Table 1 : Existing generic data-based methods classified according to our taxonomy. 

Rigid and elastic image transformation (Baird, 1990; Yaegger et al., 1996; Simard et al., 2003; Ciresan et al., bridge the limited-data gap between the expected and the empirical risk, Eqs. ( 2)-( 3). While unlimited sampling from 𝑄 provides more data than the original dataset 𝒟, both of them usually are merely approximations of the ground truth data distribution or of an ideal training dataset; both 𝒟 and 𝑄 have their own distinct biases, advantages and disadvantages. For example, elastic image deformations result in images that are not perfectly realistic; this is not necessarily a disadvantage, but it is a bias compared to the ground truth data distribution; in any case, the advantages (having more training data) often prevail. In some cases, it may be even desired for 𝑄 to be deliberately different from the ground truth data distribution. For example, in case of class imbalance (unbalanced abundance or importance of classes), a common regularization strategy is to undersample or oversample the data, sometimes leading to a less realistic 𝑄 but better models. This is how an ideal training dataset may be different from the ground truth data distribution.

If the transformation is additionally representation-preserving, then the distribution 𝑄 created by the transformation 𝜏 𝜃 attempts to mimic the ground truth data distribution 𝑃 . Otherwise, the notion of a "ground truth data distribution" in the modified representation may be vague. We provide more details about the transition from 𝒟 to 𝑄 in Appendix B.

Summary of data-based methods:

Data-based regularization is a popular and very useful way to improve the results of deep learning. In this section we formalized this group of methods and showed that seemingly unrelated techniques such as Target-preserving data augmentation, Dropout, or Batch normalization are methodologically surprisingly close to each other. In Section 8 we discuss future directions that we find promising.

4. Regularization via the network architecture:

A network architecture 𝑓 can be selected to have certain properties or match certain assumptions in order to have a regularizing effect.1 

Method Method class:

Assumptions about an appropriate learnable input-output mapping Any chosen (not overly complex) architecture * Mapping can be well approximated by functions from the chosen family which are easily accessible by optimization.

Small network * Mapping is simple (complexity of the mapping depends on the number of network units and layers).

Deep network * The mapping is complex, but can be decomposed into a composition (or generally into a directed acyclic graph) of simple nonlinear transformations, e.g. affine transformation followed by simple nonlinearity (fully-connected layer), "multi-channel convolution" followed by simple nonlinearity (convolutional layer), etc.

Hard bottleneck (layer with few neurons); soft bottleneck (e.g. Jacobian penalty (Rifai et al., 2011c) , see Section 6)

Layer operation Data concentrates around a lower-dimensional manifold; has few factors of variation.

Convolutional networks (Fukushima and Miyake, 1982; Rumelhart et al., 1986, pp. 348-352; LeCun et al., 1989; Simard et al., 2003) Layer operation Spatially local and shift-equivariant feature extraction is all we need.

Dilated convolutions (Yu and Koltun, 2015) Layer operation Like convolutional networks. Additionally: Sparse sampling of wide local neighborhoods provides relevant information, and better preserves relevant high-resolution information than architectures with downscaling and upsampling.

Strided convolutions (see Dumoulin and Visin, 2016) Layer operation The mapping is reliable at reacting to features that do not vary too abruptly in space, i.e. which are present in several neighboring pixels and can be detected even if the filter center skips some of the pixels. The output is robust towards slight changes of the location of features, and changes of strength/presence of spatially strongly varying features.

Pooling:

Layer operation The output is invariant to slight spatial distortions of the input (slight changes of the location of (deep) features). Features that are sensitive to such distortions can be discarded.

Stochastic pooling (Zeiler and Fergus, 2013) Layer operation The output is robust towards slight changes of the location (like pooling) but also of the strength/presence of (deep) features.

Training with different kinds of noise (including Dropout; see Section 3)

Noise:

The mapping is robust to noise: the given class of perturbations of the input or deep features should not affect the output too much.

Dropout (Hinton et al., 2012; Srivastava et al., 2014) , DropConnect (Wan et al., 2013) , and related methods

Extracting complementary (non-coadapted) features is helpful. Noncoadapted features are more informative, better disentangle factors of variation. (We want to disentangle factors of variation because they are entangled in different ways in inputs vs. in outputs.) When interpreted as ensemble learning: usual assumptions of ensemble learning (predictions of weak learners have complementary info and can be combined to strong prediction).

Maxout units (Goodfellow et al., 2013) Layer operation Assumptions similar to Dropout, with more accurate approximation of model averaging (when interpreted as ensemble learning)

Skip-connections (Long et al., 2015; Huang et al., 2016a) Connections between layers

Certain lower-level features can directly be reused in a meaningful way at (several) higher levels of abstraction Mollifying networks (Gülçehre et al., 2016b) 

Connections between layers; noise:

The mapping can be easier approximated by estimating its decreasingly linear simplified version Network information criterion (Murata et al., 1994) , Network growing and network pruning (see Bishop, 1995a, Sec. 9.5) Model selection Optimal generalization is reached by a network that has the right number of units (not too few, not too many)

Multi-task learning (see Caruana, 1998; Ruder, 2017) * Several tasks can help each other to learn mutually useful feature extractors, as long as the tasks do not compete for resources (network capacity) Assumptions about the mapping An input-output mapping 𝑓 𝑤 must have certain properties in order to fit the data 𝑃 well. Although it may be intractable to enforce the precise properties of an ideal mapping, it may be possible to approximate them by simplified assumptions about the mapping. These properties and assumptions can then be imposed upon model fitting in a hard or soft manner. This limits the search space of models and allows finding better solutions. An example is the decision about the number of layers and units, which allows the mapping to be neither too simple nor too complex (thus avoiding underfitting and overfitting). Another example are certain invariances of the mapping, such as locality and shift-equivariance of feature extraction hardwired in convolutional layers.

Overall, the approach of imposing assumptions about the input-output mapping discussed in this section is the selection of the network architecture 𝑓 . The choice of architecture 𝑓 on the one hand hardwires certain properties of the mapping; additionally, in an interplay between 𝑓 and the optimization algorithm (Section 7), certain weight configurations are more likely accessible by optimization than others, further limiting the likely search space in a soft way. A complementary way of imposing certain assumptions about the mapping are regularization terms (Section 6), as well as invariances present in the (augmented) data set (Section 3).

Assumptions can be hardwired into the definition of the operation performed by certain layers, and/or into the connections between layers. This distinction is made in Table 3 , where these and other methods are listed.

In Section 3 about data, we mentioned regularization methods that transform data in the hidden-feature space. They can be considered part of the architecture. In other words, they fit both Sections 3 (data) and 4 (architecture). These methods are listed in Table 1 with hidden features as their transformation space.

Weight sharing Reusing a certain trainable parameter in several parts of the network is referred to as weight sharing. This usually makes the model less complex than using separately trainable parameters. An example are convolutional networks (LeCun et al., 1989) . Here the weight sharing does not merely reduce the number of weights that need to be learned; it also encodes the prior knowledge about the shift-equivariance and locality of feature extraction. Another example is weight sharing in autoencoders.

Activation functions Choosing the right activation function is quite important; for example, using Rectified linear units (ReLUs) improved the performance of many deep architectures both in the sense of training times and accuracy as well as overcoming the need for greedy layer-wise pre-training (Hahnloser et al., 2000; Jarrett et al., 2009; Nair and Hinton, 2010; Glorot et al., 2011) . The success of ReLUs can be partially attributed to the fact that they provide more expressive families of mappings compared to sigmoid activations (in the sense that the classical sigmoid nonlinearity can be approximated very well2 with only two ReLUs, but it takes an infinite number of sigmoid units to approximate a ReLU) and their affine extrapolation to unknown regions of data space seems to provide better generalization in practice than the "stagnating" extrapolation of sigmoid units. However, their hard negative cut-off and unbounded positive part are not always desired properties. Some activation functions were designed explicitly for regularization. For Dropout, Maxout units (Goodfellow et al., 2013) allow a more precise approximation of the geometric mean of the model ensemble predictions at test time. Stochastic pooling (Zeiler and Fergus, 2013) , on the other hand, is a noisy version of max-pooling. The authors claim that this allows modelling distributions of activations instead of taking just the maximum.

Noisy models Stochastic pooling was one example of a stochastic generalization of a deterministic model. Some models are stochastic by injecting random noise into various parts of the model. The most frequently used noisy model is Dropout (Hinton et al., 2012; Srivastava et al., 2014) .

Multi-task learning A special type of regularization is multi-task learning (see Caruana, 1998; Ruder, 2017) , where the network is modified to predict targets for several tasks at once. It can be combined with semi-supervised learning to utilize unlabeled data on an auxiliary task (Rasmus et al., 2015) . A similar concept of sharing knowledge between tasks is also utilized in meta-learning, where multiple tasks from the same domain are learned sequentially, using previously gained knowledge as bias for new tasks (Baxter, 2000) ; and transfer learning, where knowledge from one domain is transferred into another domain (Pan and Yang, 2010) . These approaches differ from other methods in the sense that they require some additional target data, which are not always available.

Model selection:

The best among several trained models (e.g. with different architectures) can be selected by evaluating the predictions on a validation set. It should be noted that this holds for selecting the best combination of all techniques (Sections 3-7), not just architecture; and that the validation set used for model selection in the "outer loop" should be different from the validation set used e.g. for Early stopping (Section 7), and different from the test set (Cawley and Talbot, 2010) . However, there are also model selection methods that specifically target the selection of the number of units in a specific network architecture, e.g. using network growing and network pruning (see Bishop, 1995a , Sec. 9.5), or additionally do not require a validation set, e.g. the Network information criterion to compare models based on the training error and second derivatives of the loss function (Murata et al., 1994) .

5. Regularization via the error function:

Ideally, the error function 𝐸 reflects an appropriate notion of quality, and in some cases some assumptions about the data distribution. Typical examples are mean squared error or cross-entropy. The error function 𝐸 can also have a regularizing effect. An example is Dice coefficient optimization (Milletari et al., 2016) which is robust to class imbalance. Moreover, the overall form of the loss function can be different than Eq. (3). For example, in certain loss functions that are robust to class imbalance, the sum is taken over pairwise combinations 𝒟×𝒟 of training samples (Yan et al., 2003) , rather than over training samples. But such alternatives to Eq. ( 3) are rather rare, and similar principles apply. If additional tasks are added for a regularizing effect (multi-task learning (see Caruana, 1998; Ruder, 2017) ), then targets 𝑡 are modified to consist of several tasks, the mapping 𝑓 𝑤 is modified to produce an according output 𝑦, and 𝐸 is modified to account for the modified 𝑡 and 𝑦.

Besides, there are regularization terms that depend on 𝜕𝐸/𝜕𝑥. They depend on 𝑡 and thus in our definition are considered part of 𝐸 rather than of 𝑅, but they are listed in Section 6 among 𝑅 (rather than here) for a better overview.

6. Regularization via the regularization term:

Regularization can be achieved by adding a regularizer 𝑅 into the loss function. Unlike the error function 𝐸 (which expresses consistency of outputs with targets), the regularization term is independent of the targets. Instead, it is used to encode other properties of the desired model, to provide inductive bias (i.e. assumptions about the mapping other than consistency of outputs with targets). The value of 𝑅 can thus be computed for an unlabeled test sample, whereas the value of 𝐸 cannot.

The independence of 𝑅 from 𝑡 has an important implication: it allows additionally using unlabeled samples (semi-supervised learning) to improve the learned model based on its compliance with some desired properties (Sajjadi et al., 2016) . For example, semi-supervised learning with ladder networks (Rasmus et al., 2015) combines a supervised task with an unsupervised auxiliary denoising task in a "multi-task" learning fashion. (For alternative interpretations, see Appendix A.) Unlabeled samples are extremely useful when labeled samples are scarce. A Bayesian perspective on the combination of labeled and unlabeled data in a semi-supervised manner is offered by Lasserre et al. (2006) .

A classical regularizer is weight decay (see Plaut et al., 1986; Lang and Hinton, 1990; Goodfellow et al., 2016, Chap. 7) :

EQUATION

)

where 𝜆 is a weighting term controlling the importance of the regularization over the consistency. From the Bayesian perspective, weight decay corresponds to using a symmetric multivariate normal distribution as prior for the weights: 𝑝(𝑤) = 𝒩 (𝑤|0, 𝜆 -1 I) (Nowlan and Hinton, 1992) . Indeed, -log 𝒩 (𝑤|0, 𝜆 -1 I) ∝ -log exp

(︀ -𝜆 2 ‖𝑤‖ 2 2 )︀ = 𝜆 2 ‖𝑤‖ 2 2 = 𝑅(𝑤)

. Weight decay has gained big popularity, and it is being successfully used; Krizhevsky et al. (2012) even observe reduction of the error on the training set.

Another common prior assumption that can be expressed via the regularization term is "smoothness" of the learned mapping (see Bengio et al., 2013 , Section 3.2): if 𝑥 1 ≈ 𝑥 2 , then 𝑓 𝑤 (𝑥 1 ) ≈ 𝑓 𝑤 (𝑥 2 ). It can be expressed by the following loss term:

EQUATION

where ‖•‖ 𝐹 denotes the Frobenius norm, and 𝐽 𝑓𝑤 (𝑥) is the Jacobian of the neural network input-to-output mapping 𝑓 𝑤 for some fixed network weights 𝑤. This term penalizes mappings with large derivatives, and is used in contractive autoencoders (Rifai et al., 2011c) .

The domain of loss regularizers is very heterogeneous. We propose a natural way to categorize them by their dependence. We saw in Eq. ( 5) that weight decay depends on 𝑤 only, whereas the Jacobian penalty in Eq. ( 6) depends on 𝑤, 𝑓 , and 𝑥. More precisely, the Jacobian penalty uses the derivative 𝜕𝑦/𝜕𝑥 of output 𝑦 = 𝑓 𝑤 (𝑥) w.r.t. input 𝑥. (We use vector-by-vector derivative notation from matrix calculus, i.e. 𝜕𝑦/𝜕𝑥 = 𝜕𝑓 𝑤 (𝑥)/𝜕𝑥 = 𝐽 𝑓𝑤 is the Jacobian of 𝑓 𝑤 with fixed weights 𝑤.) We identify the following dependencies of 𝑅:

• A review of existing methods can be found in Table 4 . Weight decay seems to be still the most popular of the regularization terms. Some of the methods are equivalent or nearly equivalent to other methods from different taxonomy branches. For example, Tangent prop simulates minimal data augmentation (Simard et al., 1992) ; Injection of small-variance Gaussian noise (Bishop, 1995b; An, 1996) is an approximation of Jacobian penalty (Rifai et al., 2011c) ; and Fast dropout (Wang and Manning, 2013) is (in shallow networks) a deterministic approximation of Dropout. This is indicated in the Equivalence column in Table 4 .

7. Regularization via optimization:

The last class of the regularization methods according to our taxonomy is the regularization through optimization. While this may sound unusual, optimization and regularization cannot be clearly separated in the context of deep learning where it is not so crucial what the optimum of the empirical risk is (because it cannot be found exactly, and the ultimate goal is minimizing the expected risk anyway). Instead, the shape of the loss function and the optimization procedure play together to dictate how the training proceeds in the weight space and where it ends up. To demonstrate the overlap of regularization and optimization, we show in Figure 1 how one of the most prominent regularization methods, Dropout, can be seen as a modification of the optimization procedure.

Stochastic gradient descent (SGD) (see Bottou, 1998) (along with its derivations) is the most frequently used optimization algorithm in the context of deep neural networks and is the center of our attention. We also list some alternative methods below. 

Equivalence:

Weight decay (see Plaut et al., 1986; Lang and Hinton, 1990; Goodfellow et al., 2016, Chap. 7 )

𝐿 2 norm on network weights (not biases). Favors smaller weights, thus for usual architectures tends to make the mapping less "extreme", more robust to noise in the input.

Early stopping (see Collobert and Bengio, 2004; Goodfellow et al., 2016, Chap. 7) Weight smoothing (Lang and Hinton, 1990) Penalizes 𝐿 2 norm of gradients of learned filters, making them smooth. Not beneficial in practice.

Weight elimination (Weigend et al., 1991) Similar to weight decay but favors few stronger connections over many weak ones.

Goal similar to Narrow and broad Gaussians:

Soft weight-sharing (Nowlan and Hinton, 1992) Mixture-of-Gaussians prior on weights. Generalization of weight decay. Weights are pushed to form a predefined number of groups with similar values.

Narrow and broad Gaussians (Nowlan and Hinton, 1992; Blundell et al., 2015) Weights come from two Gaussians, a narrow and a broad one. Special case of Soft weight-sharing.

Goal similar to Weight elimination:

Fast dropout approximation (Wang and Manning, 2013) Approximates the loss that dropout minimizes.

Weighted 𝐿 2 weight penalty. Only for shallow networks.

Dropout:

Mutual exclusivity (Sajjadi et al., 2016) Unlabeled samples push decision boundaries to low-density regions in input space, promoting sharp (confident) predictions.

Segmentation with binary potentials (BenTaieb and Hamarneh, 2016) Penalty on anatomically implausible image segmentations.

Flat minima search (Hochreiter and Schmidhuber, 1995) Penalty for sharp minima, i.e. for weight configurations where small weight perturbation leads to high error increase. Flat minima have low Minimum description length (i.e. exhibit ideal balance between training error and model complexity) and thus should generalize better (Rissanen, 1986) .

Tangent prop (Simard et al., 1992) 𝐿 2 penalty on directional derivative of mapping in the predefined tangent directions that correspond to known input-space transformations.

Simple data augmentation:

Jacobian penalty (Rifai et al., 2011c) 𝐿 2 penalty on the Jacobian of (parts of) the network mappingsmoothness prior.

Noise on inputs injection (not exact (see An, 1996) ) Manifold tangent classifier (Rifai et al., 2011a) Like tangent prop, but the input "tangent" directions are extracted from manifold learned by a stack of contractive autoencoders and then performing SVD of the Jacobian at each input sample.

Hessian penalty (Rifai et al., 2011b) Fast way to approximate 𝐿 2 penalty of the Hessian of 𝑓 by penalizing Jacobian with noisy input.

Tikhonov regularizers (Bishop, 1995b) 𝐿 2 penalty on (up to) 𝑛-th derivative of the learned mapping w.r.t. input.

For penalty on first derivative: noise on inputs injection (not exact (see An, 1996) )

Loss-invariant backpropagation (Demyanov et al., 2015, Sec. 3.1; Lyu et al., 2015) (𝐿 2 ) norm of gradient of loss w.r.t. input. Changes the mapping such that the loss becomes rather invariant to changes of the input.

Adversarial training:

Prediction-invariant backpropagation (Demyanov et al., 2015, Sec. 3.2) (𝐿 2 ) norm of directional derivative of mapping w.r.t. input in the direction of 𝑥 causing the largest increase in loss.

Table 4: Regularization terms, with dependencies marked by . Methods that depend on 𝜕𝐸/𝜕𝑥 implicitly depend on targets 𝑡 and thus can be considered part of the error function (Section 5) rather than regularization term (Section 6).

Stochastic gradient descent is an iterative optimization algorithm using the following update rule:

EQUATION

where ∇ℒ(𝑤 𝑡 , 𝑑 𝑡 ) is the gradient of the loss ℒ evaluated on a mini-batch 𝑑 𝑡 from the training set 𝒟. It is frequently used in combination with momentum and other tweaks improving the convergence speed (see Wilson et al., 2017) . Moreover, the noise induced by the varying mini-batches helps the algorithm escape saddle points (Ge et al., 2015) ; this can be further reinforced by adding supplementary gradient noise (Neelakantan et al., 2015; Chaudhari and Soatto, 2015) .

If the algorithm reaches a low training error in a reasonable time (linear in the size of the training set, allowing multiple passes through 𝒟), the solution generalizes well under certain mild assumptions; in that sense SGD works as an implicit regularizer : a short training time prevents overfitting even without any additional regularizer used (Hardt et al., 2016) . This is in line with (Zhang et al., 2017) who find in a series of experiments that regularization (such as Dropout, data augmentation, and weight decay) is by itself neither necessary nor sufficient for good generalization.

We divide the methods into three groups: initialization/warm-start methods, update methods, and termination methods, discussed in the following.

Initialization and warm-start methods These methods affect the initial selection of the model weights. Currently the most frequently used method is sampling the initial weights from a carefully tuned distribution. There are multiple strategies based on the architecture choice, aiming at keeping the variance of activations in all layers around 1, thus preventing vanishing or exploding activations (and gradients) in deeper layers (Glorot and Bengio, 2010, Sec. 4.2; He et al., 2015) .

Another (complementary) option is pre-training on different data, or with a different objective, or with partially different architecture. This can prime the learning algorithm towards a good solution before the fine-tuning on the actual objective starts. Pre-training the model on a different task in the same domain may lead to learning useful features, making the primary task easier. However, pre-trained models are also often misused as a lazy approach to problems where training from scratch or using thorough domain adaptation, transfer learning, or multi-task learning methods would be worth trying. On the other hand, pre-training or similar techniques may be a useful part of such methods.

Finally, with some methods such as Curriculum learning (Bengio et al., 2009) , the transition between pre-training and fine-tuning is smooth. We refer to them as warm-start methods.

• Initialization without pre-training -Random weight initialization (Rumelhart et al., 1986, p. 330; Glorot and Bengio, 2010; He et al., 2015; Hendrycks and Gimpel, 2016 ) -Orthogonal weight matrices (Saxe et al., 2013) -Data-dependent weight initialization (Krähenbühl et al., 2015) • Initialization with pre-training -Greedy layer-wise pre-training (Hinton et al., 2006; Bengio et al., 2007; Erhan et al., 2010) (has become less important due to advances (e.g. ReLUs) in effective end-to-end training that optimizes all parameters simultaneously) -Curriculum learning (Bengio et al., 2009) -Spatial contrasting (Hoffer et al., 2016) -Subtask splitting (Gülçehre and Bengio, 2016) Update methods This class of methods affects individual weight updates. There are two complementary subgroups: Update rules modify the form of the update formula; Weight and gradient filters are methods that affect the value of the gradient or weights, which are used in the update formula, e.g. by injecting noise into the gradient (Neelakantan et al., 2015) . Again, it is not entirely clear which of the methods only speed up the optimization and which actually help the generalization. Wilson et al. (2017) show that some of the methods such as AdaGrad or Adam even lose the regularization abilities of SGD.

• Update rules -Momentum, Nesterov's accelerated gradient method, AdaGrad, AdaDelta, RMSProp, Adam-overview in (Wilson et al., 2017 ) -Learning rate schedules (Girosi et al., 1995; Hoffer et al., 2017) -Online batch selection (Loshchilov and Hutter, 2015) -SGD alternatives: L-BFGS (Liu and Nocedal, 1989; Le et al., 2011) , Hessianfree methods (Martens, 2010) , Sum-of-functions optimizer (Sohl-Dickstein et al., 2014) , ProxProp (Frerix et al., 2017) • Gradient and weight filters -Annealed Langevin noise (Neelakantan et al., 2015) -AnnealSGD (Chaudhari and Soatto, 2015) -Dropout (Hinton et al., 2012; Srivastava et al., 2014) corresponds to optimization steps in subspaces of weight space, see Figure 1 -Annealed noise on targets (Wang and Principe, 1999 ) (works as noise on gradient, but belongs rather to data-based methods, Section 3) Termination methods There are numerous possible stopping criteria and selecting the right moment to stop the optimization procedure may improve the generalization by reducing the error caused by the discrepancy between the minimizers of expected and empirical risk:

The network first learns general concepts that work for all samples from the ground truth distribution 𝑃 before fitting the specific sample 𝒟 and its noise (Krueger et al., 2017) .

The most successful and popular termination methods put a portion of the labeled data aside as a validation set and use it to evaluate performance (validation error ). The most prominent example is Early stopping (see Prechelt, 1998) . Collobert and Bengio (2004) show that Early stopping has the same effect as Weight decay regularization penalty term in multi-layered perceptrons with linear output units; however, its hyperparameters are easier to tune.

In scenarios where the training data are scarce it is possible to resort to termination methods that do not use a validation set. The simplest case is fixing the number of passes through the training set.

• Termination using a validation set -Early stopping (see Morgan and Bourlard, 1990; Prechelt, 1998) -Choice of validation set size based on test set size (Amari et al., 1997) • Termination without using a validation set -Fixed number of iterations -Optimized approximation algorithm (Liu et al., 2008) 8 Recommendations, discussion, conclusions

We see the main benefits of our taxonomy to be two-fold: Firstly, it provides an overview of the existing techniques to the users of regularization methods and gives them a better idea of how to choose the ideal combination of regularization techniques for their problem. Secondly, it is useful for development of new methods, as it gives a comprehensive overview of the main principles that can be exploited to regularize the models. We summarize our recommendations3 in the following paragraphs:

Recommendations for users of existing regularization methods Overall, using the information contained in data as well as prior knowledge as much as possible, and primarily starting with popular methods, the following procedure can be helpful:

• Common recommendations for the first steps:

-Deep learning is about disentangling the factors of variation. An appropriate data representation should be chosen; known meaningful data transformations should not be outsourced to the learning. Redundantly providing the same information in several representations is okay. -Output nonlinearity and error function should reflect the learning goals.

-A good starting point are techniques that usually work well (e.g. ReLU, successful architectures). Hyperparameters (and architecture) can be tuned jointly, but "lazily" (interpolating/extrapolating from experience instead of trying too many combinations). -Often it is helpful to start with a simplified dataset (e.g. fewer and/or easier samples) and a simple network, and after obtaining promising results gradually increasing the complexity of both data and network while tuning hyperparameters and trying regularization methods. • Regularization via data:

-When not working with nearly infinite/abundant data: * Gathering more real data (and using methods that take its properties into account) is advisable if possible:

• Labeled samples are best, but unlabeled ones can also be helpful (compatible with semi-supervised learning). • Samples from the same domain are best, but samples from similar domains can also be helpful (compatible with domain adaptation and transfer learning). • Reliable high-quality samples are best, but lower-quality ones can also be helpful (their confidence/importance can be adjusted accordingly). • Labels for an additional task can be helpful (compatible with multi-task learning). • Additional input features (from additional information sources) and/or data preprocessing (i.e. domain-specific data transformations) can be helpful (the network architecture needs to be adjusted accordingly). * Data augmentation (e.g. target-preserving handcrafted domain-specific transformations) can well compensate for limited data. If natural ways to augment data (to mimic natural transformations sufficiently well) are known, they can be tried (and combined) . * If natural ways to augment data are unknown or turn out to be insufficient, it may be possible to infer the transformation from data (e.g. learning imagedeformation fields) if a sufficient amount of data is available for that. -Popular generic methods (e.g. advanced variants of Dropout) often also help.

• Architecture and regularization terms:

-Knowledge about possible meaningful properties of the mapping can be used to e.g. hardwire invariances (to certain transformations) into the architecture, or be formulated as regularization terms. -Popular methods may help as well (see Tables 3 4 ), but should be chosen to match the assumptions about the mapping (e.g. convolutional layers are fully appropriate only if local and shift-equivariant feature extraction on regular-grid data is desired).

• Optimization:

-Initialization: Even though pre-trained ready-made models greatly speed up prototyping, training from a good random initialization should also be considered.

-Optimizers: Trying a few different ones, including advanced ones (e.g. Nesterov momentum, Adam, ProxProp), may lead to improved results. Correctly chosen parameters, such as learning rate, usually make a big difference.

Recommendations for developers of novel regularization methods Getting an overview and understanding the reasons for the success of the best methods is a great foundation. Promising empty niches (certain combinations of taxonomy properties) exist that can be addressed. The assumptions to be imposed upon the model can have a strong impact on most elements of the taxonomy. Data augmentation is more expressive than loss terms (loss terms enforce properties only in infinitesimally small neighborhood of the training samples; data augmentation can use rich transformation parameter distributions). Data and loss terms impose assumptions and invariances in a rather soft manner, and their influence can be tuned, whereas hardwiring the network architecture is a harsher way to impose assumptions. Different assumptions and options to impose them have different advantages and disadvantages.

Future directions for data-based methods There are several promising directions that in our opinion require more investigation: Adaptive sampling of 𝜃 might lead to lower errors and shorter training times (Fawzi et al., 2016) (in turn, shorter training times may additionally work as implicit regularization (Hardt et al., 2016) , see also Section 7). Secondly, learning class-dependent transformations (i.e. 𝑝(𝜃|𝑡)) in our opinion might lead to more plausible samples. Furthermore, the field of adversarial examples (and network robustness to them) is gaining increased attention after the recently sparked discussion on real-world adversarial examples and their robustness/invariance to transformations such as the change of camera position (Lu et al., 2017; Athalye and Sutskever, 2017) . Countering strong adversarial examples may require better regularization techniques.

Summary In this work we proposed a broad definition of regularization for deep learning, identified five main elements of neural network training (data, architecture, error term, regularization term, optimization procedure), described regularization via each of them, including a further, finer taxonomy for each, and presented example methods from these subcategories. Instead of attempting to explain referenced works in detail, we merely pinpointed their properties relevant to our categorization. Our work demonstrates some links between existing methods. Moreover, our systematic approach enables the discovery of new, improved regularization methods by combining the best properties of the existing ones.

A Ambiguities in the taxonomy:

Although our proposed taxonomy seems intuitive, there are some ambiguities: Certain methods have multiple interpretations matching various categories. Viewed from the exterior, a neural network maps inputs 𝑥 to outputs 𝑦. We formulate this as 𝑦 = 𝑓 𝑤 (𝜏 𝜃 (𝑥)) for transformations 𝜏 𝜃 in input space (and similarly for hidden-feature space, where 𝜏 𝜃 is applied in between layers of the network 𝑓 𝑤 ). However, how to split this 𝑥-to-𝑦 mapping into "the 𝜏 𝜃 part" and "the 𝑓 𝑤 part", and thus into Section 3 vs. Section 4, is ambiguous and up to one's taste and goals. In our choices (marked with " " below), we attempt to use common notions and Occam's razor.

• Ambiguity of attributing noise to 𝑓 , or to 𝑤, or to data transformations 𝜏 𝜃 :

-Stochastic methods such as Stochastic depth (Huang et al., 2016b) can have several interpretations if stochastic transformations are allowed for 𝑓 or 𝑤: Stochastic transformation of the architecture 𝑓 (randomly dropping some connections), Table 3 Stochastic transformation of the weights 𝑤 (setting some weights to 0 in a certain random pattern) Stochastic transformation 𝜏 𝜃 of data in hidden-feature space; dependence is 𝑝(𝜃), described in Table 1 for completeness

• Ambiguity of splitting 𝜏 𝜃 into 𝜏 and 𝜃:

-Dropout: Parameters 𝜃 are the dropout mask; dependence is 𝑝(𝜃); transformation 𝜏 applies the dropout mask to the hidden features Parameters 𝜃 are the seed state of a pseudorandom number generator; dependence is 𝑝(𝜃); transformation 𝜏 internally generates the random dropout mask from the random seed and applies it to the hidden features -Projecting dropout noise into input space (Bouthillier et al., 2015, Sec. 3) can fit our taxonomy in different ways by defining 𝜏 and 𝜃 accordingly. It can have similar interpretations as Dropout above (if 𝜏 is generalized to allow for dependence on 𝑥, 𝑓, 𝑤), but we prefer the third interpretation without such generalizations:

Parameters 𝜃 are the dropout mask (to be applied in a hidden layer); dependence is 𝑝(𝜃); transformation 𝜏 transforms the input to mimic the effect of the mask Parameters 𝜃 are the seed state of a pseudorandom number generator; dependence is 𝑝(𝜃); transformation 𝜏 internally generates the random dropout mask from the random seed and transforms the input to mimic the effect of the mask Parameters 𝜃 describe the transformation of the input in any formulation; dependence is 𝑝(𝜃|𝑥, 𝑓, 𝑤); transformation 𝜏 merely applies the transformation in input space

• Ambiguity of splitting the network operation 𝑓 𝑤 into layers: There are several possibilities to represent a function (neural network) as a composition (or directed acyclic graph) of functions (layers).

• Many of the input and hidden-feature transformations (Section 3) can be considered layers of the network (Section 4). In fact, the term "layer" is not uncommon for Dropout or Batch normalization.

• The usage of a trainable parameter in several parts of the network is called weight sharing. However, some mappings can be expressed with two equivalent formulas such that a parameter appears only once in one formulation, and several times in the other.

• Ambiguity of 𝐸 vs. 𝑅: Auxiliary denoising task in ladder networks (Rasmus et al., 2015) and similar autoencoder-style loss terms can be interpreted in different ways:

Regularization term 𝑅 without given auxiliary targets 𝑡

The ideal reconstructions can be considered as targets 𝑡 (if the definition of "targets" is slightly modified) and thus the denoising task becomes part of the error term 𝐸 The difference between ℒ and L𝐴 is the re-weighting term 𝑝(𝑥, 𝑡)/𝑞(𝑥, 𝑡) identical to the one known from importance sampling (see Bishop, 1995a) . The more similar 𝑄 is to 𝑃 (i.e. the closer 𝑄 models the ground truth distribution 𝑃 ), the more similar the augmented-data loss L𝐴 is to the expected loss ℒ. We see that data augmentation tries to simulate the real distribution 𝑃 by creating new samples from the training set 𝒟, bridging the gap between the expected and the empirical risk.

B Data-augmented loss function:



:

The network architecture is represented by a function 𝑓 : (𝑤, 𝑥) ↦ → 𝑦, and together with the set 𝑊 of all its possible weight configurations defines a set of mappings that this particular architecture can realize: {𝑓𝑤 : 𝑥 ↦ → 𝑦 | ∀𝑤 ∈ 𝑊 }.

Small integrated squared error, small integrated absolute error. A simple example is sigm(𝑥) ≈ ReLU(𝑥 + 0.5) -ReLU(𝑥 -0.5).

Note that these recommendations are neither the only nor the best way; every dataset may require a slightly different approach. Our recommendations are a summary of what we found to work well, and what seems to be common themes and "written between the lines" in many stateof-the-art works.

Figures and Tables:

𝑤 (𝑥 𝑖 ), 𝑡 𝑖 )︀ + 𝑅(. . .)

Dependence on the weights 𝑤 • Dependence on the network output 𝑦 = 𝑓 𝑤 (𝑥) • Dependence on the derivative 𝜕𝑦/𝜕𝑤 of the output 𝑦 = 𝑓 𝑤 (𝑥) w.r.t. the weights 𝑤 • Dependence on the derivative 𝜕𝑦/𝜕𝑥 of the output 𝑦 = 𝑓 𝑤 (𝑥) w.r.t. the input 𝑥 • Dependence on the derivative 𝜕𝐸/𝜕𝑥 of the error term 𝐸 w.r.t. the input 𝑥 (𝐸 depends on 𝑡, and according to our definition such methods belong to Section 5, but they are listed here for overview)

Figure 1: Effect of Dropout on weight optimization. Starting from the current weight configuration (red dot), all weights of certain neurons are set to zero (black arrow), descent step is performed in that subspace (teal arrow), and then the discarded weight-space coordinates are restored (blue arrow).

To understand the success of target-preserving data augmentation methods, we consider the data-augmented loss function, which we obtain by replacing the training samples (𝑥 𝑖 , 𝑡 𝑖 ) ∈ 𝒟 in the empirical risk loss function (Eq. (3)) by augmented training samples(𝜏 𝜃 (𝑥 𝑖 ), 𝑡 𝑖 ): 𝜃 (𝑥 𝑖 ), 𝑡 𝑖 )𝜃 (𝑥 𝑖 ), 𝑡 𝑖 )︀ )︁ 𝑝(𝜃) d𝜃,(8)where we have replaced the inner part (𝐸 and 𝑅) of the loss function by ℓ to simplify the notation. Moreover, L𝐴 can be rewritten as 𝑥) is the Dirac delta function: 𝛿(𝑥) = 0 ∀ 𝑥 ̸ = 0 and ∫︀ 𝛿(𝑥) d𝑥 = 1; and 𝑞(𝑥, 𝑡)-𝜏 𝜃 (𝑥 𝑖 ) )︀ 𝛿(𝑡 -𝑡 𝑖 ) 𝑝(𝜃) d𝜃. (10)Since 𝑞 is non-negative and ∫︀∫︀ 𝑞(𝑥, 𝑡) d𝑥 d𝑡 = 1, it is a valid probability density function inducing the distribution 𝑄 of augmented data. Therefore,L𝐴 = E (𝑥,𝑡)∼𝑄 [︀ ℓ(𝑥, 𝑡) ]︀ .(11)When 𝑄 = 𝑃 , Eq. (11) becomes the expected risk (2). We can show how this is related to importance sampling:

These methods transform the training set to a distribution 𝑄, which is used for training instead. In other words, the training samples (𝑥 𝑖 , 𝑡 𝑖 ) ∈ 𝒟 are replaced in the empirical risk loss function (Eq. (3)) by augmented training samples (𝜏 𝜃 (𝑥 𝑖 ), 𝑡 𝑖 ) ∼ 𝑄. By randomly sampling the transformation parameters 𝜃 and thus creating many new samples (𝜏 𝜃 (𝑥 𝑖 ), 𝑡 𝑖 ) from each original training sample (𝑥 𝑖 , 𝑡 𝑖 ), data augmentation attempts to

Table content: <table><tr><td>Method</td><td colspan="2">Dependence Transformation</td><td>Stochasticity</td><td>Phase</td></tr><tr><td/><td/><td>space</td><td>(𝜃 sampling)</td><td/></tr><tr><td>Gaussian noise on input</td><td>𝑝(𝜃)</td><td>Input</td><td>Random</td><td>Training</td></tr><tr><td>(Bishop, 1995a; An, 1996)</td><td/><td/><td/><td/></tr><tr><td>Gaussian noise on hidden units</td><td>𝑝(𝜃)</td><td colspan="2">Hidden features Random</td><td>Training</td></tr><tr><td>(DeVries and Taylor, 2017)</td><td/><td/><td/><td/></tr><tr><td>Dropout (Hinton et al., 2012; Srivastava</td><td>𝑝(𝜃)</td><td>Input and</td><td>Random</td><td>Training</td></tr><tr><td>et al., 2014)</td><td/><td>hidden features</td><td/><td/></tr><tr><td>Random dropout probability</td><td>𝑝(𝜃)</td><td>Input and</td><td>Random</td><td>Training</td></tr><tr><td>(Bouthillier et al., 2015, Sec. 4)</td><td/><td>hidden features</td><td/><td/></tr><tr><td>Curriculum dropout</td><td>𝑝(𝜃|time)</td><td>Input and</td><td>Random</td><td>Training</td></tr><tr><td>(Morerio et al., 2017)</td><td/><td>hidden features</td><td/><td/></tr><tr><td>Bayesian dropout</td><td>𝑝(𝜃|𝜋)</td><td>Input and</td><td>Random</td><td>Training</td></tr><tr><td>(Maeda, 2014)</td><td/><td>hidden features</td><td/><td/></tr><tr><td>Standout (adaptive dropout)</td><td>𝑝(𝜃|𝑥, 𝜋)</td><td>Input and</td><td>Random</td><td>Training</td></tr><tr><td>(Ba and Frey, 2013)</td><td/><td>hidden features</td><td/><td/></tr><tr><td>"Projection" of dropout noise into input</td><td colspan="2">𝑝(𝜃|𝑥, 𝑓, 𝑤) Input</td><td>Random</td><td>Training</td></tr><tr><td>space (Bouthillier et al., 2015, Sec. 3)</td><td/><td>Uses auxiliary 𝜏</td><td/><td/></tr><tr><td/><td/><td>in hidden-feature</td><td/><td/></tr><tr><td/><td/><td>space.</td><td/><td/></tr><tr><td>Approximation of Gaussian process by</td><td>𝑝(𝜃)</td><td>Input and</td><td>Random</td><td>Test</td></tr><tr><td>test-time dropout</td><td/><td>hidden features</td><td/><td/></tr><tr><td>(Gal and Ghahramani, 2016)</td><td/><td/><td/><td/></tr><tr><td>Stochastic depth (Huang et al., 2016b)</td><td>𝑝(𝜃)</td><td colspan="2">Hidden features Random</td><td>Training</td></tr><tr><td>Noisy activation functions</td><td>𝑝(𝜃|𝑥)</td><td colspan="2">Hidden features Random</td><td>Training</td></tr><tr><td>(Nair and Hinton, 2010; Xu et al., 2015;</td><td/><td/><td/><td/></tr><tr><td>Gülçehre et al., 2016a)</td><td/><td/><td/><td/></tr><tr><td>Training with adversarial examples</td><td>𝑝(𝜃|𝑥, 𝑡 ′ )</td><td>Input</td><td>Adaptive</td><td>Training</td></tr><tr><td>(Szegedy et al., 2014)</td><td/><td/><td>Constrained</td><td/></tr><tr><td>Network fooling (adversarial examples)</td><td>𝑝(𝜃|𝑥, 𝑡 ′ )</td><td>Input</td><td>Adaptive</td><td>Test</td></tr><tr><td>(Szegedy et al., 2014)</td><td/><td/><td>Constrained</td><td/></tr><tr><td>(Not for regularization)</td><td/><td/><td/><td/></tr><tr><td>Synthetic minority oversampling in</td><td colspan="3">𝑝(𝜃|𝑥, 𝑡, 𝒟) Hidden features Random</td><td>Training</td></tr><tr><td>hidden-feature space (Wong et al., 2016)</td><td/><td/><td/><td/></tr><tr><td>Inter-and extrapolation in hidden-feature</td><td colspan="3">𝑝(𝜃|𝑥, 𝑡, 𝒟) Hidden features Random</td><td>Training</td></tr><tr><td>space (DeVries and Taylor, 2017)</td><td/><td/><td/><td/></tr><tr><td>Batch normalization (Ioffe and Szegedy,</td><td>𝑝(𝜃|x)</td><td colspan="3">Hidden features Deterministic Training</td></tr><tr><td>2015), Ghost batch normalization (Hoffer</td><td/><td/><td/><td>and test</td></tr><tr><td>et al., 2017)</td><td/><td/><td/><td/></tr><tr><td>Layer normalization</td><td>𝑝(𝜃|𝑥)</td><td colspan="3">Hidden features Deterministic Training</td></tr><tr><td>(Ba et al., 2016)</td><td/><td/><td/><td>and test</td></tr><tr><td>Annealed noise on targets</td><td>𝑝(𝜃|time)</td><td>Target</td><td>Random</td><td>Training</td></tr><tr><td>(Wang and Principe, 1999)</td><td/><td/><td/><td/></tr></table>

Table columns are described in Section 3.

Table content: <table><tr><td>Method</td><td>Dependence Transformation</td><td>Stochasticity</td></tr><tr><td/><td>space</td><td>(𝜃 sampling)</td></tr></table>



Table content: <table/>



Table content: <table/>

Peer review (iclr2018):
 This paper is unusual in that it is more of a review than contributing novel knowledge. It considers a taxonomy of all the ways that machine learning (mostly deep learning) methods can achieve a form of regularization. Unfortunately, it starts with a definition of regularization (*making the model generalize better*) which I believe misses the point which was made in Goodfellow et al 2016 (*intend to improve test error but not necessarily training error*), i.e., that we would like to separate as much as possible the regularization effects from the optimization effect. Indeed, under the definition proposed here, any improvement in the optimizer could be considered like a regularizer, so long as we are not in the overfitting regime. That does not sound right to me. There are several places where the authors make TOO STRONG STATEMENTS, taking for truth what are simply beliefs with no strong supporting evidence (at least published). This is not good for a review and when making recommendations. The other weakness I estimate in this paper is that I did not get a sense that the taxonomy really helped us (me at least) to get insight into the different mentions being cited. Besides the obvious proposal to combine ideas to write new papers (but we did not need that paper to figure that out) I did not find much meat in the *future directions* section. However, I that except in a few places the understand of the field displayed by the authors is pretty good and, with correction, could serve as a useful reference for students of deep learning. The recommendations were reasonable although lacking empirical support (or pointers to the literature), so I would take them somewhat carefully, more as the current *group think* than ground truth. Finally, here a few minor points which could be fixed. Eq. 1: in typical DL, minimization is approximate, not exact, so the proposed formalism does not reflect reality. Eq. 4: in many cases, the noise is not added (e.g. dropout), so that should be clarified there. page 3, first bullet of *Effect on the data representation*: not clear, may want to give translations as an example of such transformations,. page 8, activation functions: the ReLU is actually older than the cited papers, it was used by computational neuroscientists a long time ago. Jarrett 2009 did not use the ReLU but an absolute-value rectifier and it was Glorot 2011 who showed that the ReLU really kicked ass for deeper networks. Nair 2010 used the ReLU in a very different context (RBMs), not really feedforward multi-layer networks where it shines now. In that same section (and probably elsewhere) there are TOO STRONG STATEMENTS, e.g., the "facts" mentioned are not facts but merely folk belief, as far as I know, and I would like to see well-done supporting evidence before treating those as facts. Note that approximating the sigmoid precisely would require many ReLUs! page 8: it is not clear how multi-task learning fits under the *architecture* formalism provided at the beginning of section 4. section 7 (page 10): there is earlier work on the connection between early stopping and L2 regularization, at least dating back to Ronan Collobert*s PhD thesis (with neural nets), probably earlier for linear systems.