user: text: Write a concise one-sentence TLDR summary of the scientific paper content below.

Title: Gradients explode - Deep Networks are shallow - ResNet explained

Paper content:
Whereas it is believed that techniques such as Adam, batch normalization and, more recently, SeLU nonlinearities ``solve'' the exploding gradient problem, we show that this is not the case and that in a range of popular MLP architectures, exploding gradients exist and that they limit the depth to which networks can be effectively trained, both in theory and in practice.
We explain why exploding gradients occur and highlight the {\it collapsing domain problem}, which can arise in architectures that avoid exploding gradients.
ResNets have significantly lower gradients and thus can circumvent the exploding gradient problem, enabling the effective training of much deeper networks, which we show is a consequence of a surprising mathematical property.
By noticing that {\it any neural network is a residual network}, we devise the {\it residual trick}, which reveals that introducing skip connections simplifies the network mathematically, and that this simplicity may be the major cause for their success.
Arguably, the primary reason for the recent success of neural networks is their "depth", i.e. their ability to compose and jointly train nonlinear functions so that they co-adapt.
A large body of work has detailed the benefits of depth (e.g. Montafur et al. (2014) ; BID13 Martens et al. (2013) ; BID9 ; Shamir & Eldan (2015) ; Telgarsky (2015) ; Mhaskar & Shamir (2016) ).The
exploding gradient problem has been a major challenge for training very deep feedforward neural networks at least since the advent of gradient-based parameter learning (Hochreiter, 1991) . In
a nutshell, it describes the phenomenon that as the gradient is backpropagated through the network, it may grow exponentially from layer to layer. This
can, for example, make the application of vanilla SGD impossible for networks beyond a certain depth. Either
the step size is too large for updates to lower layers to be useful or it is too small for updates to higher layers to be useful. While
this intuitive notion is widely understood, there are important gaps in the foundational understanding of this phenomenon. In this
paper, we take a significant step towards closing those gaps.To begin with, there is no well-accepted metric for determining the presence of pathological exploding gradients. Should
we care about the length of the gradient vector? Should
we care about the size of individual components of the gradient vector? Should
we care about the eigenvalues of the Jacobians of individual layers? Depending
on the metric used, different strategies arise for combating exploding gradients. For example
, manipulating the width of layers a suggested by e.g. BID3 ; Han et al. (2017) can greatly impact the size of gradient vector components but leaves the length of the gradient vector relatively unchanged.The underlying problem is that it is unknown whether exploding gradients according to any of these metrics necessarily lead to training difficulties. There is a
large body of evidence that gradient explosion defined by some metric when paired with some optimization algorithm on some architectures and datasets is associated with poor results (e.g. Schoenholz et al. (2017) ; Yang & Schoenholz (2017) ). But, can we
make general statements about entire classes of algorithms and architectures?Algorithms such
as RMSprop (Tieleman & Hinton, 2012) , Adam (Kingma & Ba, 2015) or vSGD (Schaul et al., 2013) are light modifications of SGD that rescale different parts of the gradient vector and are known to be able to lead to improved training outcomes. This raises an
another important unanswered question. Are exploding
gradients merely a numerical quirk to be overcome by simply rescaling different parts of the gradient vector or are they reflective of an inherently difficult optimization problem that cannot be easily tackled by simple modifications to a stock algorithm?It has become
a common notion that techniques such as introducing normalization layers (e.g. Ioffe & Szegedy (2015) , BID6 , BID12 , Salimans & Kingma (2016) ) or careful initial scaling of weights (e.g. He et al. (2015) , BID14 , Saxe et al. (2014) , Mishking & Matas (2016) ) largely eliminate exploding gradients by stabilizing forward activations. This notion was
espoused in landmark papers. The paper that
introduced batch normalization (Ioffe & Szegedy, 2015) states:In traditional deep networks, too-high learning rate may result in the gradients that explode or vanish, as well as getting stuck in poor local minima. Batch Normalization
helps address these issues.The paper that introduced ResNet (He et al., 2016b) states:Is learning better networks as easy as stacking more layers? An obstacle to answering
this question was the notorious problem of vanishing/exploding gradients, which hamper convergence from the beginning. This problem, however, has
been largely addressed by normalized initialization and intermediate normalization layers, ...We argue that these claims are overly optimistic. While scaling weights or normalizing
forward activations can reduce gradient growth defined according to certain metrics in certain situations, these techniques are not effective in general and can cause other problems even when they are effective. We intend to add nuance to these ideas
which have been widely adopted by the community (e.g. BID12 ; BID7 ). In particular, we intend to correct the
misconception that stabilizing forward activations is sufficient for avoiding exploding gradients (e.g. Klambauer et al. (2017) ).ResNet (He et al., 2016b) and other neural
network architectures utilizing skip connections (e.g. Huang et al. (2017) , Szegedy et al. (2016) ) have been highly successful recently. While the performance of networks without
skip connections starts to degrade when depth is increased beyond a certain point, the performance of ResNet continues to improve until a much greater depth is reached. While favorable changes to properties of
the gradient brought about by the introduction of skip connections have been demonstrated for specific architectures (e.g. Yang & Schoenholz (2017) ; BID7 ), a general explanation for the power of skip connections has not been given.Our contributions are as follows:1. We introduce the 'gradient scale coefficient
' (GSC), a novel measurement for assessing the presence of pathological exploding gradients (section 2). It is robust to confounders such as network
scaling (section 2) and layer width (section 3) and can be used
directly to show that training
is difficult (section 4). Therefore, we propose the unification of research
on the exploding gradient problem under this metric.2. We demonstrate that exploding gradients are in fact
present in a variety of popular MLP architectures, including architectures utilizing techniques that supposedly combat exploding gradients. We show that introducing normalization layers may even
exacerbate the exploding gradient problem (section 3).3. We show that exploding gradients as defined by the GSC
are not a numerical quirk to be overcome by rescaling different parts of the gradient vector, but are indicative of an inherently complex optimization problem and that they limit the depth to which MLP archi-tectures can be effectively trained, rendering very deep MLPs effectively much shallower (section 4). To our knowledge, this is the first time such a link has
been established.4. For the first time, we show why exploding gradients are
likely to occur in deep networks even when the forward activations do not explode (section 5). We argue that this is a fundamental reason for the difficulty
of constructing very deep trainable networks.5. For the first time, we define the 'collapsing domain problem'
for training very deep feedforward networks. We show how this problem can arise precisely in architectures
that avoid exploding gradients via careful initial scaling of weights and that it can be at least as damaging to the training process (section 6).6. For the first time, we show that the introduction of skip connections
has a strong gradientreducing effect on deep network architectures in general. We detail the surprising mathematical relationship that makes this possible
(section 7).7. We introduce the 'residual trick' (section 4), which reveals that ResNets are
a mathematically simpler version of networks without skip connections and thus approximately achieve what we term the 'orthogonal initial state'. This provides, we argue, the major reason for their superior performance at great
depths as well as an important criterion for neural network design in general (section 7).In section 8, we conclude and derive practical recommendations for designing and training
deep networks as well as key implications of our work for deep learning research.In the appendix in section B, we provide further high-level discussion. In section B.1, we discuss related work including the relationship of exploding gradients
with other measures of network trainability, such as eigenspectrum analysis (Saxe et al., 2014) , shattering gradients BID7 , trajectory lengths (Raghu et al., 2017) , covariate shift (e.g. (Ioffe & Szegedy, 2015) ) and Hessian conditioning (e.g. BID12 ). Recently, the behavior of neural networks at great depth was analyzed using mean field theory
(Poole et al., 2016; Schoenholz et al., 2017; Yang & Schoenholz, 2017; BID3 and dynamical systems theory BID10 BID0 . We discuss these lines of work in relation to this paper in sections B.1.1 and B.1.2 respectively
. We discuss the implications of our work for the vanishing gradient problem in section B.2. We compare
the exploding gradient problem as it occurs in feedforward networks to the exploding and vanishing
gradient problems in RNNs (e.g. Pascanu et al. (2013) ) in section B.3. In section B.4, we highlight open research questions and potential future work.
Summary In this paper, we demonstrate that contrary to popular belief, many MLP architectures composed of popular layer types exhibit exploding gradients, and those that do not exhibit collapsing domains (section 3).
This tradeoff is caused by the discrepancy between absolute determinants and qm norms of layer-wise Jacobians (section 5).
Both sides of this tradeoff cause pathologies.
Exploding gradients, when defined by the GSC (section 2) cause low effective depth (section 4).
Collapsing domains cause pseudo-linearity and can also cause low effective depth (section 6).
However, both pathologies are caused to a surprisingly large degree by untrainable, and thus potentially unnecessary non-orthogonality contained in the initial functions.
Making the initial functions more orthogonal via e.g. skip connections leads to improved outcomes (section 7).
The effective depth measure has several limitations.One can train a linear MLP to have effective depth much larger than 1, but the result will still be equivalent to a depth 1 network.Consider the following training algorithm: first randomly re-sample the weights, then apply gradient descent.
Clearly, this algorithm is equivalent to just running gradient descent in any meaningful sense.
The re-sampling step nonetheless blows up the residual functions so as to significantly increase effective depth.The effective depth measure is very susceptible to the initial step size.
In our experiments, we found that starting off with unnecessarily large step sizes, even if those step sizes were later reduced, lead to worse outcomes.
However, because of the inflating impact on the residual function, the effective depth would be much higher nonetheless.Effective depth may change depending on how layers are defined.
In a ReLU MLP, for example, instead of considering a linear transformation and the following ReLU operation as different layers, we may define them to be part of the same layer.
While the function computed by the network and the course of gradient-based training do not depend on such redefinition, effective depth can be susceptible to such changes.

assistant: text: We show that in contras to popular wisdom, the exploding gradient problem has not been solved and that it limits the depth to which MLPs can be effectively trained. We show why gradients explode and how ResNet handles them.