Title: No title found

Abstract: No abstract found

A:

While a lot of progress has been made in recent years, the dynamics of learning in deep nonlinear neural networks remain to this day largely misunderstood. In this work, we study the case of binary classification and prove various properties of learning in such networks under strong assumptions such as linear separability of the data. Extending existing results from the linear case, we confirm empirical observations by proving that the classification error also follows a sigmoidal shape in nonlinear architectures. We show that given proper initialization, learning expounds parallel independent modes and that certain regions of parameter space might lead to failed training. We also demonstrate that input norm and features' frequency in the dataset lead to distinct convergence speeds which might shed some light on the generalization capabilities of deep neural networks. We provide a comparison between the dynamics of learning with cross-entropy and hinge losses, which could prove useful to understand recent progress in the training of generative adversarial networks. Finally, we identify a phenomenon that we baptize gradient starvation where the most frequent features in a dataset prevent the learning of other less frequent but equally informative features.

1. I:

Due to extremely complex interactions between millions of parameters, nonlinear activation functions and optimization techniques, the dynamics of learning observed in deep neural networks remain much of a mystery to this day. What principles govern the evolution of the neural network weights? Why does the training error evolve as it does? How do data and optimization techniques like stochastic gradient descent interact? Where does the implicit regularization of deep neural networks trained with stochastic gradient descent come from? Shedding some light on those questions would make training neural networks more understandable, and potentially pave the way to better techniques.

It is commonly accepted that learning is composed of alternating phases: plateaus where the error remains fairly constant and periods of fast improvement where a lot of progress is made over the course of few epochs (Saxe et al., 2013a) . Theoretic explanations of that phenomenon exist in the case of regression on linear neural networks (Saxe, 2015) but extensions to the nonlinear case (Heskes & Kappen, 1993; Raghu et al., 2017; Arora et al., 2018) fail to provide analytical solutions.

It has been observed in countless experiments that deep networks present strong generalization abilities. Those abilities are however difficult to ground in solid theoretical foundations. The fact that deep network have millions of parameters -a number sometimes orders of magnitude larger than the dataset size -contradicts the expectations set by classic statistical learning theory on the necessity of regularizers (Vapnik, 1998; Poggio et al., 2004) . This observation drove Zhang et al. (2016) to suggest the existence of an implicit regularization happening during the training of deep neural networks. Advani & Saxe (2017) show that the dynamics of gradient descent can protect against overfitting in large networks. Kleinberg et al. (2018) also offer some explanations of the phenomenon but understanding its roots remains an open problem.

In this work, we study the learning dynamics of a deep nonlinear neural network -i.e. how its weights and outputs evolve throughout learning -trained on a standard classification task using two different losses: the cross-entropy and the hinge loss. We mainly focus on binary classification, some of the results and properties can however be extended to the multi-class case. The questions we address in Sections 3, 4 and 5 respectively can be summarized as follows:

How does the confidence of a classifier evolve throughout learning?

How does the loss used during training impact its dynamics? Which properties of the features present in a dataset impact learning, and how? Independent mode learning We show that, similarly to the case of linear networks and under certain initial conditions, learning happens independently between different classes, i.e. classes induce a partition of the network activations, corresponding to orthogonal modes of the data. Learning dynamics We prove that in accordance to experimental findings, the hidden activations and the classification error of the network show a sigmoidal shape with slow learning at the beginning followed by fast saturation of the curve. We also characterize a region in the initialization space where learning is frozen or eventually dies out. Hinge loss We study how using the hinge loss impacts learning and quantitatively compare it to the classic cross-entropy loss. We show that the hinge loss allows one to solve a classification task much faster, by providing strong gradients no matter how close to convergence the neural network is. Gradient starvation Finally, we identify a phenomenon that we call gradient starvation where the most frequent features present in the dataset starve the learning of other very informative but less frequent features. Gradient starvation occurs naturally when training a neural network with gradient descent and might be part of the explanation as to why neural networks generalize so well. They intrinsically implement a variant of Occam's razor (Ariew, 1976) : the simplest explanation is the one they converge to first.

2. S:

We are interested in a simple binary classification task, solved by training a deep neural network with gradient descent. This simple setup encompasses for instance the training of generative adversarial networks discriminators. Some of our results extend to multi-class classification, but, for the sake of conciseness, that case is treated in Appendix A. We let D = {(x i , l i )} 1≤i≤n ⊂ R d × {1, 2} denote our dataset of vectors and labels. The classifier we consider is a simple neural network with one hidden layer of h neurons and a ReLU non-linearity (see Fig. 1 ).

Figure 1 : Network Architecture The output of the network is passed through a function denoted o which is either the sigmoid σ in the binary cross-entropy case or the identity in the hinge loss case. The full function can be written as

P t (x) := o(u t (x)) := o(Z T t (W t x) + ),

where W t is an h × d matrix and Z t a vector of length h. The superscript T stands for the transpose operation. In the case of cross-entropy, P t (x) represents the probability that x belongs to class 1, for the hinge loss, P t (x) is trained to reach {1, -1} for classes 1 and 2. For a given class k, we let D k denote the set of vectors belonging to it. We make the assumption (H1) For any x, x ∈ D k , x T x > 0. For any x ∈ D 1 and x ∈ D 2 , x T x ≤ 0.

It implies linear separability of the data, an assumption often necessary in theoretical studies (Soudry et al., 2017; Liao & Couillet, 2018; Nacson et al., 2018; Xu et al., 2018) and the positioning of the origin between the two sets. It is a very strong assumption which admittedly bypasses a large part of the deep learning dynamics. Nevertheless, it allows the discovery of interesting properties and is potentially a first step towards understanding behaviors observed in more general settings.

3. L -:

In this section, we focus on the case of the binary cross-entropy loss

L BCE (W t , Z t ; x) = -1 x∈D1 log(σ(Z T t (W t x) + )) -1 x∈D2 log(1 -σ(Z T t (W t x) + )),

and train our network using stochastic gradient descent to minimize L BCE .

Our first lemma states that over the course of training and under suitable initialization, the active neurons of the hidden layer remain the same for each datapoint, and the coordinates of Z t remain of the same sign. To prove it, we let w i t denote the i-th row of W t and make the additional assumptions: there exists a partition {I 1 , I 2 } of {1, . . . , h} such that with k ∈ {1, 2}

(H2) For any i ∈ I k , x ∈ D k and x / ∈ D k , w i 0 x > 0 and w i 0 x ≤ 0. (H3) The i-th coordinate of Z 0 is positive if i ∈ I 1 , negative otherwise.

Assumption (H2) states that at the beginning of training, data points from different classes do not activate the same neurons. It is an analogue to the orthogonal initialization used in Saxe et al. (2013b) . In Appendix A.8, we show that relaxing it hints towards an extended period of slow learning in the early stages of training. (H3) is introduced for Lemma 3.1 and Theorem 3.2 but will be relaxed later. Lemma 3.1. For any k ∈ {1, 2}, x ∈ D k and t ≥ 0, the only non-negative elements of W t x are the ones with an index i ∈ I k . The signs of the coordinates of Z t remain the same throughout training.

This lemma proves that updates to the parameters of our network are fully decoupled from one class to the other. An update for a data point in D k will only influence the corresponding active rows and elements of W t and Z t . This "independent mode learning" is an equivalent of the results by Saxe et al. (2013b) in a non-linear network trained on the cross entropy loss. The proof of the lemma and its extension to N -1 hidden layers and multi-class classification can be found in Appendix A.

3.2. L:

We are now interested in the actual dynamics of learning, and move from discrete updates to continuous ones by considering an infinitesimal learning rate α (Heskes & Kappen, 1993) . Lemma 3.1 can easily be extended to this setting. For simplicity we assume h = 2, but similar results hold for arbitrary h (see Appendix A.4). For the moment, we maintain the assumptions (H1-3). Theorem 3.2. Assuming that each class k contains the same vector x k repeated |D k | times, then the output of the classifier on D k verifies (with p k = |D k |/|D| the fraction of D belonging to D k ):

P t (x k ∈ D k ) = σ(u( x k p k t)),

where u is defined below. The classification curves are sigmoidal and can be found on Fig. 2 Right. Proof. To simplify the notations, we arbitrarily assume that I 1 = {1} and we write w t and z t the row and element modified by an update made using x ∈ D 1 (the case of D 2 can be treated symmetrically). By the independence above, we know that w t and z t are only affected by updates from D 1 . This greatly simplifies our evolution equations to: w t = δ f (x)z t x T and z t = δ f (x) w t x where δ f (x) is the gradient of the loss with respect to the pre-sigmoid output of the network u t (x): δ f (x) = 1 {k=1} -σ(u t (x)) and the prime indicates a time derivative. We let y t = w t x, which gives

y t = x T x z t 1 + e ytzt , z t = y t 1 + e ytzt .

(1)

Writing x 2 = x T x, we see that the quantity y 2 t -x 2 z 2 t is an invariant of the problem, so its solutions live on hyperbolas of equation y 2 -x 2 z 2 = ±c with c := |y 2 0 -x 2 z 2 0 |. We only treat the case of a degenerate hyperbola c = 0 i.e. y 2 0 = x 2 z 2 0 , and refer the interested reader to Appendix A.3 for the full derivation. In the case c = 0, we have ∀t, y t = x z t (those quantities are both positive as x ∈ D 1 and (H2-3)). u(t) := z t w t x = z t y t thus follows the equation Each couple lives on a hyperbola. The slope of the linear curves is equal ± x (set to 0.7 in this diagram). The green region represents the initializations of (y, z) where the classification task will be solved by the network. In the red region, learning does not start (the neuron is inactive at the beginning of training) or collapses as the neuron dies off when y reaches 0. The c i points show the three cases from Section 3.3. Right. y t and P t (x ∈ D 1 ) = σ(z t y t ) for different values of c and x .

u (t) = 2 x u(t)σ(-u(t)). One can see the equivalence between our evolution equation and Eq. ( 10) in Saxe et al. (2013b) . Its analytical solution is (see Appendix A.3):

EQUATION

)

where Ei is the exponential integral (Wiki., 2018) and <-1> denotes the inverse function.

We let ū denote that function for x = 1. For x ∈ D 2 , the degeneracy assumption becomes y 0 = -x z 0 . It can be shown similarly that v(t) := z t y t verifies the equation v (t) = 2 x v(t)σ(v(t)) with a negative initial condition (H2-3). In other words, u and v follow symmetric trajectories on the positive/negative real line. Below, ū (resp. v) denote those two trajectories for x = 1 and initial conditions u 0 > 0 (resp. v 0 < 0). Let us now write p 1 = |D 1 |/|D| the fraction of points belonging to D 1 . Because we sample randomly from the dataset, this amounts to sampling p 1 (resp. 1 -p 1 ) points from D 1 (resp. D 2 ) for each time unit during training, i.e. to rescaling the time axis by p 1 for D 1 and 1 -p 1 for D 2 . This allows us to quantify the network's performance at any time t:

EQUATION

In particular, the convergence of u(t) to +∞ can be bounded using our results: convergence happens at a rate slower than log(t) (Appendix A.3), a fact proved on its own by Soudry et al. (2017) .

Interpretation Fig. 2 Right. shows the learning dynamics for different values of x and c. One common characteristic between all the curves is their sigmoidal shape. Learning is slow at first, then accelerates before saturating. This is aligned with empirical results from the literature. We also see on e.g. the blue and yellow curves that a larger x (or similarly a larger p) converges much faster. The effect of c on the dynamics can mostly been seen at the beginning of training (for instance on the green and yellow curves). It fades as convergence happens, corresponding to points of the hyperbolas getting closer to the asymptote y = x z, see Fig. 2 Left. and below for more details. We can characterize the convergence speeds more quantitatively with the following corollary. Corollary 3.3. Let δ be the required accuracy on the classification task (i.e. P t (x ∈ D 1 ) ≥ 1 -δ for x ∈ D 1 ). Under certain assumptions, the times t * 1 and t * 2 required to reach that accuracy for each classifier verify

t * 2 t * 1 ≈ x1 x2 p1 1-p1 where x k is the norm of vector x k from class k.

The proof can be found in Appendix A.5. More frequent classes and larger inputs will be classified at a given level of confidence faster. The class frequency observation is fairly straightforward as updates on a more frequent class occur at a higher rate. As far as input sizes are considered, this can be seen as an analogous to the results from Saxe et al. (2013b) stating that input-output correlations drive the speed of learning. Because a sigmoid is applied on the network output, its (pre-sigmoid) targets are sent to ±∞. A larger input is more correlated with its target and converges faster.

On the assumptions:

The assumption that each class only contains one vector allows us to obtain the first closed-form solutions of the learning dynamics for the binary cross-entropy. It can be relaxed to classes containing orthogonal datapoints (see Appendix A.7) which still remains restrictive. A possible interpretation is the following: if one were to consider a deep neural network that has learnt two discriminative features for the two classes, applying classic SGD on those features would result in a learning rate proportional to the prominence of those two features in the original dataset, and to learning curves of that exact shape. It is worth noting that such shapes are regularly observed by ML practitioners (Saxe et al., 2013b) , our results reveal insights -otherwise unobtainable -into them.

3.3. P:

In this section, we build the phase diagram of Fig. 2 Left. The notations follow Theorem 3.2, in particular y t = w t x. So far, we have considered points in the top-right quadrant. In that region, the couple (z t , y t ) lives on a hyperbola of equation y 2 -x 2 z 2 = ±c where c ≥ 0. The sign in the equation is defined by the position of (z 0 , y 0 ) relative to the function y = x z (positive if above, negative otherwise). If (z 0 , y 0 ) is originally on that line, it will remain there throughout training. We now explore the rest of the parameter space by relaxing some of our assumptions. We still consider a point x ∈ D 1 , the diagram for D 2 can be obtained by mirroring the z axis. Assumption (H2). Let us first consider the simple case of w 0 x = y 0 < 0. The neuron is initially inactive because of the ReLU. No updates will ever be made to w t during training. This corresponds to the bottom half of the phase diagram, the parameters are frozen (also see Advani & Saxe (2017) ). Assumption (H3). We now assume that z 0 ≤ 0. In that case, a simple extension of Lemma 3.1 shows that learning still happens independently on each row of w t . The outcome from Theorem 3.2 is still valid: the couple (z t , y t ) lives on a hyperbola. It is however not guaranteed anymore that y t shall remain positive throughout training. There are three possible situations (numbered 1 to 3), each represented by the corresponding point on the diagram. 1) If y 0 = -x z 0 , then the points (z t , y t ) are stuck in the top-left quadrant and converge to zero. The equation verified by the logit u(t) is u (t) = -2 x u(t)σ(-u(t)) (see Appendix A.6).

2) If y 0 > -x z 0 , the points (z t , y t ) move on the hyperbola towards the top-right quadrant, at which point z t becomes positive and y t starts increasing again.

3) If y 0 < -x z 0 , the points (z t , y t ) move on the hyperbola towards the bottom-left quadrant, at which point y t becomes negative. When that happens, the neuron dies out, learning stops.

Only in the second case will the classifier end up solving the task: random initialization only functions in certain parts of the (y t , z t ) space. Those findings are summarized in the phase diagram Fig. 2 Left. The red region represents the initialization where the network will not be able to solve the task.

Failure modes Assumption (H2) essentially means that the network's first layer is able to separate the data at t = 0. It is remarkable that even under (H2) the model fails on a non-zero measure set of the initialization space (top-left red region of Fig. 2 Left): in that region, it converges to a classifier assigning a probability of 0.5 to the true class (dash-dotted curves in Fig. 3 Right).

3.4. R A (H2):

Assumption (H2) states that for any i ∈ I k , x ∈ D k and x / ∈ D k , w i 0 x > 0 and w i 0 x ≤ 0. We now relax it by assuming that a point x 2 in D 2 verifies w 1 0 x 2 > 0 and we study the evolution of w 1 t . We consider updates coming from sampling equally x 1 from D 1 and x 2 from D 2 . To simplify the analysis, we assume that x T 1 x 2 = 0 and write α t = w 1 t x 1 (equivalent to y t above) and β t = w 1 t x 2 . The triplet (α t , β t , z t ) satisfies the following system of ODEs (see Appendix A.8 for the derivation):

α t = x 1 2 z t 1 + e ztαt , β t = - x 2 2 z t 1 + e -ztβt , z t = α t 1 + e ztαt - β t 1 + e -ztβt .

(4)

From our relaxation of (H2), we have α 0 , β 0 > 0. Since the system is symmetric under the transformation (α t , β t , z t ) → (β t , α t , -z t ), we can assume z 0 ≥ 0. Due to the ReLU activations The "full" curves correspond to (α 0 , β 0 , z 0 ) = (0.1, 0.1, 0.1) i.e. a trajectory in the green region where β t reaches 0 (orange curve). The confidence on class D 1 tends to 1 (green curve). The "dashed" curves correspond to (α 0 , β 0 , z 0 ) = (0.2, 0.9, 0.2) i.e. a trajectory in the yellow region, corresponding to α t reaching 0 (red curve). The confidence on D 1 goes to 0.5 in that case (brown curve), and the confidence on class D 2 goes to 1 (not shown). The "dash-dotted" curves correspond to (α 0 , β 0 , z 0 ) = (1, 0, -1.1) and are an instance of the aforementioned failure mode: α t (or equivalently y t ) tends to 0 (pink curve), β t (not shown) remains 0 and P t tends to 0.5 (grey curve).

of the network, whenever α t or β t reaches zero, it becomes constant and its contribution to z t disappears: the model reaches the independent modes of learning regime from Section 3.1 and evolves according to the results above (e.g. green hyperbolas in the plane β = 0 on Fig. 3 Left). If β t (resp. α t ) reaches 0 at some point, D 1 (resp. D 2 ) becomes the only class activating the neuron. Let us now characterize how the initialization of the network influences the outcome of learning. Theorem 3.4. Letting c := α 2 0 / x 1 2 + β 2 0 / x 2 2 -z 2 0 , the solutions of ( 4) verify for all t ≥ 0,

α 2 t / x 1 2 + β 2 t / x 2 2 -z 2 t = c.

In other terms, they live on hyperboloids (see Fig. 3 Left). If c ≤ 0, β t reaches 0 at some point during training (Fig. 6 of the Appendix). If c > 0, there exists a curve C c (shown in black on Fig. 3 Left) such that as t → +∞, for any initialization (α 0 , β 0 , z 0 ) ∈ C c :

α t → ( 1 x 1 2 + 1 x 2 2 ) -1/2 √ c , β t → ( 1 x 1 2 + 1 x 2 2 ) -1/2 √ c , z t → 0 .

That curve defines two regions of the initialization space. In one, colored yellow on Fig. 3 Left, the trajectories verify α t = 0 for some t. In the other, colored green, β t reaches 0 at some point.

Interpretation:

The proof of the theorem can be found in Appendix A.8. Fig. 3 Left shows some solutions of (4). Concretely, we see from the equations that the sign of z t determines whether α t and β t increase or decrease, and how fast they do so. z t 's evolution on the other hand is the result of a competition between α t and β t . If z 0 and/or α 0 are sufficiently large, β t will decrease fast and long enough to reach 0 at some point (green curves). Conversely, for a large β 0 , z t can reach 0 before β t . When that is the case, α t then decreases until it reaches 0 (yellow curves). We plot examples of those behaviors in Fig. 3 Right. We notice in particular the classic sigmoidal shape appearing, even when Assumption (H2) is violated. This can be explained as follows. In the regime of small initializations (customary in deep learning), the competition between α t , β t and z t happens in a part of parameter space where all the weights are small (i.e. where the confidence of the network is close to 0.5). When one class finally prevails over the other, e.g. β t reaching 0 (orange curve in the plot), the analytical solutions from previous sections apply and the sigmoidal shape arises.

4. O:

Recent results in the field of generative adversarial networks have resurrected the hinge loss (Miyato et al., 2018) . While its exact impact on performance is unclear, we run a small experiment to show its ability to generate better samples than the customary cross-entropy (see Fig. 4 and Appendix E).

In order to perhaps uncover reasons behind its efficiency, we extend our results to the hinge loss: The hinge loss is non differentiable, but one can simply consider that learning stops as soon as the output of the network reaches 1 (resp. -1) for class D 1 (resp. D 2 ). Under the same assumptions than in Theorem 3.2 (some of which can be relaxed, see Appendix C), we have the following result: Theorem 4.1. For x ∈ D 1 (for D 2 it is simply the opposite), the output u(t) of the network verifies

L H (W t , Z t ; x) = max(0, 1 -Z T t (W t x) + • (1 x∈D1 -1 x∈D2 )) .

EQUATION

)

where θ 0 = cosh -1 (

y 2 0 + x 2 z 2 0 c

) and the left and right equations correspond to c = 0 and c = 0.

Proof. Simple computations show that the dynamics of the system are governed by y t = x T x z t and z t = y t . Following the method from Section 3, we see that u (t) = 2 x u(t) in the case where c = 0, leading to to the result. When c = 0, a classic hyperbolic change of variables allows to find the solution. Its full derivation is presented in Appendix C.

The learning curves are plotted in Fig. 4 Right. We notice a hard sigmoidal shape corresponding to learning stopping when u t reaches 1. Confidence increases exponentially in t, much faster than for binary cross-entropy (all other parameters kept equal) where u(t) ∼ log(t). With δ the required confidence for our classifier, the time t * required to reach δ can easily be computed. We plot it in Fig. 4 Right which confirms visually that the hinge loss converges much faster. We also notice the expected divergence of t * for the binary cross entropy as δ reaches 1 (training never converges in that case). We refer the interested reader to Appendix C for a more general treatment of the Hinge loss, which fully relaxes the assumption on the number of points in the classes.

5. G S:

In this section, we attempt to quantify the impact of feature frequency inside a given class. We keep our simplified framework and consider that the input x to our network is composed of two underlying features x 1 ∈ R d1 and x 2 ∈ R d2 with d = d 1 + d 2 . We let (x 1 , x 2 ) ∈ R d denote the concatenation of the vectors x 1 and x 2 . We assume that all the points in class D 1 contain the feature x 1 but only a fraction λ of them contains the feature x 2 . This is equivalent to making continuous gradient updates using the vector (x 1 , x 2 ) with a rate λ and the vector (x 1 , 0) with a rate 1 -λ. We also assume that those features are fully informative for D 1 -i.e. are absent from class D 2 . A network trained using gradient descent on the dataset we just described has the following property

Even though the feature represented by x 2 is fully informative of the class, the network will not classify a sample containing only x 2 with high confidence.

It is the result of a phenomenon we coin gradient starvation where the most frequent features starve the gradient for the least frequent ones, resulting in a slower learning of those: Theorem 5.1. Let δ be our confidence requirement on class D 1 i.e. training stops as soon as ∀x ∈ D 1 , P t (x ∈ D 1 ) ≥ 1 -δ, and let t * denote that instant. Then, under some mild assumptions,

EQUATION

)

Proof. From Lemma 3.1, assumptions (H2-3) are sufficient to guarantee independent mode learning as well as positiveness of z t . We decompose

w t = (α t x 1 , β t x 2 )+(x ⊥ 1 , x ⊥ 2 ) where x T 1 x ⊥ 1 = x T 2

x ⊥ 2 = 0, and assume that α 0 ≥ β 0 /λ > 0 (in App. D, we relax some of those assumptions and prove an equivalent result). The evolution equation for w t is w t = ztx 1+e z t w t x with x = (x 1 , x 2 ) (resp. (x 1 , 0)) at an λ (resp. 1 -λ) rate. Projecting on x 1 and x 2 gives

EQUATION

)

From z t > 0, we see that β t is an increasing function of time, which guarantees β t > 0, and

α t ≥ β t + (1 -λ) z t 1 + e zt(αt+βt) = (1 + 1 -λ λ )β t = β t λ .

This proves that ∀t ≥ 0, α t ≥ β t /λ. We now consider t * such that z t * α t * = log( 1-δ δ ). It is the smallest t such that P t ((x 1 , x 2 ) ∈ D 1 ) ≥ P t ((x 1 , 0) ∈ D 1 ) = 1 -δ, its existence is guaranteed by z t and α t being increasing (we also assume that t = 0 does not verify those (in)equalities). We get

P t * ((0, x 2 ) ∈ D 1 ) = 1 1 + e -z t * β t * ≤ 1 1 + e -λz t * α t * = 1 1 + e -λ log( 1-δ δ )

.

As can be seen in Eq. 7, the presence of α t -which detects feature x 1 -in the denominator of β t greatly reduces its value, thus preventing the network from learning x 2 properly. In Fig. 5 Left., we plot for different values of λ the confidence of the network when classifying x 2 as a function of its confidence on x 1 (see App. D. for more details). The gap between the two is very significant: with e.g. λ = 0.1 and δ = 10 -4 (Table 1 ), P t * ((0, x 2 ) ∈ D 1 ) ≤ 72%! Even though x 2 is exclusively present in D 1 , and is thus extremely informative, the network is unable to classify it. Experiment To validate those findings empirically, we design an artificial experiment based on the cats and dogs dataset (Kaggle, 2018) . We create a very strong, perfectly discriminative feature by making the dog pictures brighter, and the cat pictures darker. We then train a standard deep neural network to classify the modified images and measure its performance on the untouched testing set.

Results:

The results can be seen in Table 2 . The network perfectly learns to classify both the train and test modified set, but utterly fails on the real test data. This proves that the handcrafted light feature was learnt by the network, and is used exclusively to classify images. All the features allowing to recognize a cat from a dog are still present in the data, but the low level features (e.g. the presence of whiskers, how edges combine to form the shape of the animals and so on) are far less frequent than the light intensity, and thus were not learnt. The most frequent feature starved all the others.

6. R:

The learning dynamics of neural networks have been explored for decades. Baldi & Hornik (1989) studied the energy landscape of linear networks and the fixed point structure of gradient descent learning in that context. Heskes & Kappen (1993) developed a theory encompassing stochastic gradient descent and parameter dynamics and wrote down their evolution equations in on-line learning. However, those equations are heavily nonlinear and do not have closed-form solutions in the general case. Saxe et al. (2013b) study the case of deep linear networks trained with regression. They prove the existence of nonlinear learning phenomena similar to those seen in simulations of nonlinear networks and provide exact solutions to the dynamics of learning in the linear case. Some of our results are an extension of theirs to nonlinear networks. Recent work in the domain of generative adversarial networks (Goodfellow et al., 2014) has shown the resurgence of the hinge loss (Rosasco et al., 2004) . In particular, part of the success encountered by Miyato et al. ( 2018) is due to their use of that specific loss function. Their main contribution however is a spectral normalization technique that produces state-of-the-art results on image generation. Their paper is part of a larger trend focusing on the spectra of neural network weight matrices and their evolution during learning (Vorontsov et al., 2017; Odena et al., 2018; Pennington et al., 2017) . It, nevertheless, remains a poorly understood subject. Zhang et al. (2016) performed some experiments proving that deep neural networks expound a socalled implicit regularization. Even though they have the ability to entirely memorize the dataset, they still converge to solutions that generalize well. A variety of explanations for that phenomenon have been advanced: correlation between flatness of minima and generalization (Hochreiter & Schmidhuber, 1997) , natural convergence of stochastic gradient descent towards such minima (Kleinberg et al., 2018) , built-in hierarchical representations (LeCun et al., 2015) , gradient descent naturally protecting against overfitting (Advani & Saxe, 2017), and structure of deep networks biasing learning towards simpler functions (Neyshabur et al., 2014; Perez et al., 2018) . Our results from Section 5 suggest that gradient descent indeed has a beneficial effect, but can also hurt in some situations.

7. D:

In order to obtain closed form solutions for the learning dynamics, we made the extremely simplifying assumption that each class only contains one point. We leave overcoming that limitation to future work. In the spirit of the proof in Section 5 where we considered two datapoints, we might be able to obtain upper and lower bounds on the learning dynamics.

Our comparison between the cross-entropy and the hinge losses reveals fundamental differences.

It is noteworthy that the hinge loss is an important ingredient of the recently introduced spectral normalization (Miyato et al., 2018) . The fast convergence of networks trained with the hinge loss might in part explain its beneficial impact. A deeper analysis of the connections between the two would lead to a better understanding of the performance of the algorithm.

In this paper, we introduce the concept of gradient starvation and suggest that it might be a plausible explanation for the generalization abilities of deep neural networks. By focusing most of the learning on the frequent features of the dataset, it makes the network ignore the idiosyncrasies of individual datapoints. That rather desirable property has a downside however: very informative but rare features will not be learnt during training. This strongly limits the ability of the network to transfer to different data distributions where e.g. the rare feature exists on its own. A A.

A.1 P L 3.1

In this section, we prove the following lemma: Lemma 3.1 For any k ∈ {1, 2}, x ∈ D k and t ≥ 0, the only non-negative elements of W t x are the ones with an index i ∈ I k . The signs of the coordinates of Z t remain the same throughout training.

Proof. We prove this with a simple induction. The claim is true at t = 0 from assumptions (H1-3). Let us assume that at time set t, the different parts of the lemma are true. The SGD updates to the weights stemming from a single observation x ∈ D k (the extension to a mini-batch is straightforward) with a learning rate α are:

EQUATION

)

where ⊗ denotes the element-wise product of two vectors and e k ∈ R h is the binary vector with ones on the indices from I k . δ f (x) is the gradient of the loss with respect to the pre-sigmoid output of the network F t (x):

δ f (x) = 1 {k=1} -σ(F t (x)

). The updates to Z t are positive on its indices belonging to I 1 , and negative otherwise, proving the second claim of the lemma. Moving to W t , only its rows and hidden neurons with indices i ∈ I k are modified. For an element x ∈ D,

W t+1 x = W t x + αδ f (x)( i∈I k z i )

x where z i is the i-th element of Z t . By induction, i∈I k z i has the same sign as δ f (x) (positive on D 1 , negative on D 2 ). From (H1), x is positive (resp. negative) if x is in D k (resp. otherwise). The update keeps the k-th neuron active (resp. inactive).

A.2 E L 3.1 - Let us consider a simple C-classification task. D = {(x i , y i )} 1≤i≤n ⊂ R d × C

is our dataset of vectors/labels where C denotes both the set of possible labels and its cardinal depending on the context. The classifier we are training is a simple neural network with one hidden layer of C neurons, a ReLU non-linearity and a softmax σ. The full function is written as

EQUATION

)

where W t (resp. Z t ) is a C ×d (resp. C ×C) weight matrix and σ the softmax function. The subscript + denotes the positive part of a real number. P t (x) is a C-vector representing the probability that x belongs to each class. The subscript t denotes the state of the element at time step t of training.

For a given class k, we let D k be the set of vectors belonging to class k. We make the following assumptions, with k = k ∈ C two arbitrary classes

(H4) For any x, x ∈ D k , x T x > 0. For any x ∈ D k and x ∈ D k , x T x ≤ 0.

(H5) For any x ∈ D k and x ∈ D \ D k , w k 0 x > 0 and w k 0 x ≤ 0, where w k 0 is the k-th row of W 0 . (H6) Z 0 is initialized randomly to positive numbers on the diagonal, and non-positive elsewhere.

Those assumptions are straightforward extensions of the ones from the main text. We train the classifier using stochastic gradient descent on the cross-entropy loss of our problem. F t+1 is the state of the neural network after one SGD update to F t . Our first lemma states that over the course of training, the active neurons of the hidden layer remain the same for each element of the dataset, and the elements of Z t remain of the same sign. Lemma A.1. For any k ∈ C, x ∈ D k and t ≥ 0, the only non-negative element of W t x is its k-th element and all diagonal (resp. non-diagonal) elements of Z t are positive (resp. negative).

Proof. We prove this with a simple induction. The claim is true at t = 0 from assumptions (H4-6). Let us assume that at time set t, the different parts of the lemma are true. The SGD updates to the weight matrices stemming from a single observation x ∈ D k * (the extension to a mini-batch is straightforward) and a learning rate α are:

EQUATION

the degeneracy assumption becomes y 0 = -x z 0 (we know from (H2) that y 0 > 0 and from (H3) that z 0 < 0). It can be shown similarly that v(t) := z t y t verifies the equation v (t) = 2 x v(t)σ(v(t)) with a negative initial condition. In other words, u and v follow symmetric trajectories on the positive/negative real line. Below, ū and v denote those two trajectories for x = 1 and initial conditions u 0 > 0 and v 0 < 0.

Let us now write p 1 = |D 1 |/|D| the fraction of points in the dataset belonging to D 1 . Because we sample randomly from the dataset, this amounts to sampling p 1 (resp. 1 -p 1 ) points from D 1 (resp. D 2 ) for each time unit during training, ie to rescaling the time axis by p 1 for D 1 and 1 -p 1 for D 2 . Formally, this allows us to quantify the performance of the network at any time t

EQUATION

which concludes the proof for c = 0.

From Eq. 14, we also see that

EQUATION

where we used the inequality ∀y ≥ 0, e y 2 > y. It eventually gives us

EQUATION

a result in line with convergence rates obtained in Soudry et al. (2017) .

Let us now study the non-degenerate case. We apply the classic change of coordinates

EQUATION

EQUATION

Since y 2 t + x 2 z 2 t = c cosh(θ) and y t z t = c 2 x sinh(θ), we see that

EQUATION

where the first equality used the system of equations Eq. 11. This gives us the dynamics of θ as

θ = 2 x 1 + e c sinh(θ)/2 x , with an initial condition θ 0 = cosh -1 ( y 2 0 + x 2 z 2 0 c

). For any θ f ≥ θ 0 , we see that

t = θ <-1> (θ f ) verifies t = θ f θ0 1 + e c sinh(θ)/2 x 2 x dθ .

There is no closed-form solution for that integral (that we know of). It can however be computed numerically. On Fig. 2 Right of the main text, we plot the curves for y t and σ(z t y t ) for different values of c and x . We obtain a sigmoidal shape similar to previously made empirical observations. We notice in particular that for larger values of x the function converges faster.

A.4 E:

We now extend the result from Theorem 3.2 to the case with h hidden neurons. Let us still consider an update made on x ∈ D 1 . We know from assumptions and by Lemma 3.1 that the only active neurons in the network are indexed by I 1 . The network weights follow the evolution equations:

(w i t ) = x T z i t 1 + e j∈I 1 z j t w j t x , (z i t ) = w i t x e j∈I 1 z j t w j t x .

We similarly define y i t = w i t x which brings

(y i t ) = x T x z i t 1 + e j∈I 1 z j t y j t , (z i t ) = y i t e j∈I 1 z j t y j t .

The couple (y i t , z i t ) follows the same hyperbolic invariance, defined by a constant c i . In the case where ∀i ∈ I 1 , c i = 0, we see that u i t := z i t y i t verifies

(u i t ) = 2 x u i t 1 + e j∈I 1 u j t

, and a simple summation on i shows that u t := i∈I1 u i t follows Eq. 13. The dynamics of the logit in this case are identical to the single active neuron case, the only difference is potentially its initial value.

A.5 P C 3.3

Corollary 3.3 Let δ be the required accuracy on the classification task (i.e. P t (x ∈ D 1 ) ≥ 1 -δ for x ∈ D 1 ). Under certain assumptions, the times t * 1 and t * 2 required to reach that accuracy for each classifier verify Proof. We consider the case c = 0. The classification error drops at a rate proportional to x 1 p for D 1 and to x 2 (1 -p) for D 2 . More precisely, let us assume that u 0 ≤ |v 0 | and look for a classification confidence of 1 -δ. We write

u f = σ <-1> (1 -δ) = log(1/δ -1), t v = ū<-1> (|v 0 |) and t * = ū<-1> (u f ) = 1 2 (log( log(1/δ -1) u 0 ) + Ei(log(1/δ -1)) -Ei(u 0 )) ,

t * represents the time taken to reach confidence δ with an initialization u 0 , and t v the time to reach v 0 starting in u 0 . We see that

P (x ∈ D 1 ) ≥ 1 -δ ⇐⇒ t ≥ t * 1 = t * x 1 p if x ∈ D 1 , P (x ∈ D 2 ) ≥ 1 -δ ⇐⇒ t ≥ t * 2 = t * -t v x 2 (1 -p) if x ∈ D 2 .

The ratio between the convergence times reads

t * 2 t * 1 = x1 x2 p 1-p (1 -tv t * ).

One sees that if the weight initializations u 0 and v 0 are close (i.e. t v is small) and the confidence requirement large (i.e. t * is large), the ratio is approximately x1 x2 p 1-p .

A.6 T -:

When the initial conditions of the network verify y 0 = -x z 0 , then at all time t, y t = -x z t . Plugging that equality in Eq. 11 results in t) where again u(t) = z t y t . This means that the logit is negative and increasing. Let u 0 < u f < 0, we see that the time at which u reaches u f verifies

u (t) = -2 x u(t) 1 + e u(

EQUATION

)

t diverges to +∞ as u f tends to 0 from below. The logit converges to 0 without ever reaching it.

A.7 R One of the major assumptions made in the main text is the fact that each class contains a single element. In this section, we slightly relax it to the case where the points ({x i } 1≤i≤m ⊂ R d ) in a class are all orthogonal to one another1 (while still verifying Assumption (H1)). In that case, each presentation of a training vector will only affect w t in the direction of that specific vector. Let y i t denote w t x i , the unnormalized component of w t along x i . We consider a batch update on the weights of the neural network. In that case:

(y i t ) = x i 2 z t 1 + e zty i t , (z t ) = m i=1 y i t 1 + e zty i t .

Assuming that the vectors all have the same norm (denoted x below) and that the y i 0 are all equal, then that equality remains true at all time (they follow the same update equation). We let y t denote that value:

(y t ) = x 2 z t 1 + e ztyt , (z t ) = my t 1 + e ztyt .

A new invariant appears in those equations: c := |my 2 0 -x 2 z 2 0 |. In the case c = 0 (the other case can be treated as above), we obtain the following evolution equation for the logit of any point in the class: t) .

u (t) = 2 √ m x u(t) 1 + e u(

We end up with a similar equation than before except for the √ m factor, which boosts the convergence speed. However, one should not forget that we are now training on a full batch (i.e. on m points) during each unit of time. Performing the same number of updates for the single point class would generate a m factor in the convergence speed of u (one √ m factor for each y and z functions). The slower convergence for the more general case can be explained by the fact that each point is making an update on w t in its own direction. That direction being orthogonal to all others points makes it useless for their classification.

A.8 R (H2):

Let us first recall that the assumption states:

(H2) For any i ∈ I k , x ∈ D k and x / ∈ D k , w i 0 x > 0 and w i 0 x ≤ 0. We now assume that h = 2 and study the evolution of the first row w 1 t of matrix W t , written w t in the following. We relax assumption (H2) by assuming that there is a point x 2 in D 2 such that w 0 x > 0. And we consider updates to w t coming from sampling equally x 1 from D 1 and x 2 from D 2 . The evolution equations can be written as

w t = x T 1 z t 1 + e ztwtx1 - x T 2 z t 1 + e -ztwtx2 , z t = w t x 1 1 + e ztwtx1 - w t x 2 1 + e -ztwtx2 .

In order to make the analysis simpler, we assume that x T 1 x 2 = 0. We write α t = w t x 1 and β t = w t x 2 . Any component of w 0 orthogonal to both x 1 and x 2 will be untouched by the updates, and does not affect the classification performance of the network. This gives us

EQUATION

)

By assumption, we know that α 0 , β 0 > 0. The system of ODEs ( 23) is invariant through the transformation (α t , β t , z t ) → (β t , α t , -z t ) so it is sufficient to study the case z 0 ≥ 0. Let us now state the theorem from the main text. Theorem 3.4. Letting c := α 2 0 / x 1 2 + β 2 0 / x 2 2 -z 2 0 , the solutions of ( 23) verify for all t ≥ 0,

α 2 t / x 1 2 + β 2 t / x 2 2 -z 2 t = c.

In other terms, they live on hyperboloids (see Fig. 3 from the main text and Fig. 6 ).

1This implies in particular m ≤ d. Figure 6 : Solutions of the ODE system for different initializations and c = -1. Trajectories live on a hyperboloid of two sheets. Any initialization on that surface will result in β t reaching 0, or in other terms in D 1 prevailing. This curve and Fig. 3 from the main text are plotted with

x 1 = x 2 = 1.

If c ≤ 0, β t reaches 0 at some point during training (see Fig. 6 ). If c > 0, there exists a curve C c on the hyperboloid such that as t → +∞, for any initialization (α 0 , β 0 , z 0 ) ∈ C c :

α t → ( 1 x 1 2 + 1 x 2 2 ) -1/2 √ c , β t → ( 1 x 1 2 + 1 x 2 2 ) -1/2 √ c , z t → 0 .

That curve defines two regions of the initialization space. In one (colored yellow on Fig. 3 Left), trajectories verify α t = 0 for some t, in the other (colored green) β t reaches 0 at some point.

Proof. It is easy to see from the system of ODEs ( 23) that (α 2 t ) / x 1 2 + (β 2 t ) / x 2 2 -(z 2 t ) = 0, which directly gives the invariance of α 2 t / x 1 2 + β 2 t / x 2 2 -z 2 t . This implies that the trajectories (α t , β t , z t ) live on hyperboloids.

If c < 0, the hyperboloid has two sheets (see Fig. 6 ). In particular, the trajectories verify:

z 2 t = α 2 t / x 1 2 + β 2 t / x 2 2 -c ≥ -c

, which means that z t is bounded away from 0. As long as β t ≥ 0,

we have β t = -x2 2 zt 1+e -z t β t ≤ x2 2 c 2

. This implies that β t will reach 0 in a finite time since it decreases at a rate larger than a strictly positive number. At that point, the ReLU ensures that β t does not evolve anymore, and that β t 's contribution to z t disappears. The evolution equations turn into the ones studied in the previous paragraphs, plotted as the green hyperbola in the plane β = 0 in Fig. 6 .

EQUATION

α t increases as long as z t is positive), so the same argument about β t holds.

If c > 0, let us first note that the point ((

1 x1 2 + 1 x2 2 ) -1/2 √ c, ( 1 x1 2 + 1 x2 2 ) -1/2 √ c, 0) belongs to

the hyperboloid and is stationary (the three derivatives are 0). Classic results on ordinary differential equations (Tenenbaum & Pollard, 1985) then give the result. Finding a closed-form solution to the shape of C c is to the best of our knowledge impossible. One can however obtain an approximation by considering a point ((

1 x1 2 + 1 x2 2 ) -1/2 √ c -, ( 1 x1 2 + 1 x2 2 ) -1/2 √ c + , 0) for a small

and applying finite difference methods to the evolution equations ( 23) to build the trajectory.

A B: D N N:

In this section we study the case of a deeper network with N -1 hidden layers. Similarly to above, we can prove the existence of independent modes of learning. To that end, neurons need to be activated in a disjoint manner from one class to the other. Due to the growing complexity of the interactions between the parameters of the network, this requires very strong assumptions on the initialization of

The same relation between y t and z t appears in those equations than in the cross-entropy case. Defining c similarly, we have u (t) = 2 x u(t) in the case where c = 0, leading to u(t) = u 0 e 2 x t . When c = 0, the same change of variables can be applied and leads to

EQUATION

with θ 0 = cosh -1 (

y 2 0 + x 2 z 2 0 c

). Those equations are only valid until u t reaches 12. At that point learning stops, the network has converged. If the initialization is such that that condition is already verified, then the weights will not change as they already solve the task. The learning curves along with the initialization diagram can be found in Fig. 8 . We notice a hard sigmoidal shape, corresponding to learning stopping when u t reaches 1.

C.2 G:

Let us now consider the general case of a class containing an arbitrary number of points D 1 = {x i } 1≤i≤m ⊂ R d . We consider the case of updates done in full batches (standard gradient descent in other words). In that case, we see that the network obeys the following dynamics:

w t = z t m i=1 x T i , z t = w t m i=1 x T i . Letting X = m i=1

x i denote the sum of all the datapoints in that class, we see that those dynamics boil down to our previous treatment for a single point. The same cases appear, depending on the value of c := |(w 0 X) 2 -X 2 z 2 0 |. We explicitly treat the c > 0 case. Following the methods above, we see that: w t = y t X T X 2 + w ⊥ 0 where y t = √ c cosh( θ0 2 + X t) and w T 0 is the component of w 0 orthogonal to X (and thus unchanged during training). With z t and u t defined as above (with X instead of x), an arbitrary example x is then classified as P (x ∈ D 1 ) = z t y t X T x X 2 + z t w ⊥ 0 x = u t X T x X 2 + z t w ⊥ 0 x .

A D: G S:

In this section, we prove a relaxed version of Theorem 5.1 from the main text: Theorem D.2. Let δ be our confidence requirement on class D 1 i.e. the training stops as soon as ∀x ∈ D 1 , P t (x ∈ D 1 ) ≥ 1 -δ. Let t * denote that instant i.e. z t * α t * = log( 1-δ δ ). If β 0 < 0, the inequality (9) from the main text is valid. Otherwise, with w 0 = (α 0 x 1 , β 0 x 2 ) + (x ⊥ 1 , x ⊥ 2 ), we have P t * ((0, x 2 ) ∈ D 1 ) ≤ 1

1 + e -λ log( 1-δ δ )-z t * (β0-αα0)

.

Proof. We start with the β 0 < 0 case. If β t * is negative, the result from the main text clearly holds. Otherwise, there exists t < t * such that β t = 0 (β t is increasing). The proof of Theorem 5.1 from the main text can then directly be applied to [ t, t * ]. If β 0 > 0, the inequality on α t and β t holds and gives β t ≤ β 0 + (α t -α 0 )λ. Plugging it into P t * ((0, x 2 ) ∈ D 1 ) concludes our proof.

In the main text, we assume that β 0 -αα 0 < 0 and obtain a bound on the confidence which is independent from α 0 and β 0 . Using that bound allows to obtain Fig. 9 , but is partly unfair as the initialization of the network is already favoring the strong feature.

However, we note that under small random initialization z t * and α t * are of the same order of magnitude and (β 0 -αα 0 ) is very small compared to log( 1-δ δ ). The additional term in the denominator thus has a limited effect on the exponential, gradient starvation is still happening (a fact confirmed by the experiment on the cats and dogs dataset). In the main text, Fig. 5 plots the upper bound for a fair initialization α 0 = β 0 = 0.1 (in that case, we need to assume that z t * = α t * ). 

A E: E D E.1 M G:

In this experiment, the data is constructed using eight independent Gaussian distributions around a unit circle. The variance of each Gaussian is chosen such that all eight modes of the data are separated by regions of low data probability, but still contain a reasonable amount of variance. This simple experiment resembles multi-modal datasets. Although this task might seem simple, in practice many generative adversarial networks fail to capture all the modes. This problem is generally known as mode collapse.

As shown in the main text, using the hinge loss instead of the common binary cross-entropy loss alleviates the problem significantly. The architectures used for the generator and discriminator both consist of four hidden layers where each layer has 256 hidden units. As a common choice, a ReLU is used as the non-linearity function for hidden units. The length of the noise input vector is 128. The Adam optimizer (Kingma & Ba, 2014) was applied during training with α = 10 -4 , β 1 = 0.5 and β 2 = 0.9. The PyTorch framework (Paszke et al., 2017) was used to conduct the experiment.

E.2 D . C:

For the purpose of highlighting the fact that the most frequent feature starved all the others, we conducted an experiment on a classification task. We modified the cats and dogs dataset (Kaggle, 2018) by setting the cats images to be lighter than the dogs images. To do so, each pixel in a cat image is scaled to be between 0 and 127 while each pixel in a dog image is scaled to be between 128 and 255. The dataset consists of 12500 images of each class. The classifier has an architecture similar to VGG16 (Simonyan & Zisserman, 2014) . In order to isolate the effect of the induced bias, no regularization was applied. The Adam optimizer was applied here as well during training with α = 10 -4 , β 1 = 0.9 and β 2 = 0.99. The PyTorch framework was used to conduct the experiment.

:

2We are considering class {1} here, but the equivalent can be proven for class {-1}.

Figures and Tables:

Figure 2: Left. Phase diagram representing the dynamics of learning for the couple (z t , y t ) depending on its initialization. y t is the value for the class considered, in which all examples have lined up.Each couple lives on a hyperbola. The slope of the linear curves is equal ± x (set to 0.7 in this diagram). The green region represents the initializations of (y, z) where the classification task will be solved by the network. In the red region, learning does not start (the neuron is inactive at the beginning of training) or collapses as the neuron dies off when y reaches 0. The c i points show the three cases from Section 3.3. Right. y t and P t (x ∈ D 1 ) = σ(z t y t ) for different values of c and x .

Figure 3: Left. Solutions of (4) for different initializations and c = 1. Right. Values of α t , β t and P t the confidence of the classifier on an example from class D 1 for three different initializations.The "full" curves correspond to (α 0 , β 0 , z 0 ) = (0.1, 0.1, 0.1) i.e. a trajectory in the green region where β t reaches 0 (orange curve). The confidence on class D 1 tends to 1 (green curve). The "dashed" curves correspond to (α 0 , β 0 , z 0 ) = (0.2, 0.9, 0.2) i.e. a trajectory in the yellow region, corresponding to α t reaching 0 (red curve). The confidence on D 1 goes to 0.5 in that case (brown curve), and the confidence on class D 2 goes to 1 (not shown). The "dash-dotted" curves correspond to (α 0 , β 0 , z 0 ) = (1, 0, -1.1) and are an instance of the aforementioned failure mode: α t (or equivalently y t ) tends to 0 (pink curve), β t (not shown) remains 0 and P t tends to 0.5 (grey curve).

Figure 4: Left. The three figures on the left are the result of training a generative adversarial network on 8 Gaussians (see Appendix E for details on the experiment). The samples from the hinge loss are incomparably better. Right. Comparison between hinge loss and binary cross-entropy: training time required to reach a confidence δ on the classification problem. Subplot: Solutions of Eqs. 3 and 5.

Figure 5: Upper bound on P t * ((0, x 2 ) ∈ D 1 ) as a function of 1 -δ for different values of λ.

where x k is the norm of vector x k from class k.

Figure 8: Solution of Eq.26.



Table content: <table><tr><td/><td colspan="3">: Gradient starvation</td><td/></tr><tr><td/><td/><td>λ</td><td/><td/></tr><tr><td>δ</td><td>0.5</td><td>0.2</td><td>0.1</td><td>0.01</td></tr><tr><td>99%</td><td colspan="4">91% 71% 61% 51%</td></tr><tr><td colspan="5">99.99% 99% 86% 72% 52%</td></tr><tr><td colspan="5">Table 2: Accuracy on the cats and dogs</td></tr><tr><td colspan="5">dataset (Real means the untouched test set)</td></tr><tr><td colspan="5">Training Testing Testing (Real)</td></tr><tr><td>100%</td><td colspan="2">100%</td><td>43.2%</td><td/></tr></table>

Peer review (iclr2019):
 The authors study properties of the learning behavior of non-linear (ReLu) neural networks. In particular, their main focus is on binary classification for the linear-separable case, when optimization is done using gradient descent minimizing either binary entropy or hinge loss. There are 3 main results in the paper: 1) During learning, each neuron only activates on data points of one class: hence (due to ReLu), each neuron only updates its weights when seeing data points from that class. The authors refer to this property as "Independent modes of learning", suggesting that the learning of parameters of the network is decoupled between the two classes. 2) The classification error, with respect to the number of iterations of gradient descent, exhibits a sigmoidal shape: slow improvement at the beginning, followed by a period of fast improvement, followed by another plateau. 3) Most frequent features, if discriminative, can prevent learning of other, less frequent, features. Apart from the assumption H1 of linear separability of the data (which I don*t mind), the results require very strong assumptions, in particular hypothesis H2 stating "at the beginning of training data points from different classes do not activate the same neurons". Even for a shallow net, the authors are essentially assuming that the first layer of weights W is such that each row w is already a hyperplane separating the two classes after initialization (wx > 0 for all x belonging to one class and wx* < 0 for x* in the other class). In other words, at initialization, the first layer is already correctly classifying all data points. This is of course an extremely stringent assumption that doesn*t hold in practice (eg, the probability of such an initialization shrinks to zero exponentially in the number of dimensions and in the number of neurons). Because of this concern, I believe the results in the paper can only really characterize the learning close to convergence, since the network is already able to provide correct classification. Pros: - Authors consider a non-linear (ReLu) neural network, as opposed to the analysis of Save et al which only considers linear nets. - The fundamentally different behavior between Hinge and binary entropy loss is interesting, and worth analyzing further. - Sigmoidal shape of classification error as a function of number of iterations is inline with what is seen in practice. However, I believe the assumptions needed to show this point force the analysis to only characterize learning close to convergence. Minor Cons (apart from major concern above): - Theorem 3.2: "[...] converges at a speed proportional to [...]". Isn*t .bar{u}_t logarithmic (non-linear) in t? - Theorem 3.2: Even if strong, I don*t mind the assumption on a dataset merely consisting of two (weighted) data points. I would suggest to simulate this case without putting any condition on the initialization of the weights (ie, without assumptions H1-H2), and compare the empirical shape of the classification error with the one you obtain analytically in Figure 2 Right. - Theorem 3.2 Interpretation: unfinished sentence "We can characterize the convergence speeds more quantitatively with the" - Theorem 4.1: Can you give an intuition or lower/upper bounds for u(t) for the Hinge case, to make evident its difference from the binary entropy case (where u(t) ~ log(t)) - Gradient starvation, Kaggle experiment: I*m not too convinced about the novelty/usefulness of this result. In the end, even a decision tree stump would stop growing after learning the dark/light feature as a discriminator. What I*m trying to say is that "gradient starvation" is a more general problem that really doesn*t have to do with gradient descent. Also, the fact that the accuracy on the Kaggle non-doctored test set is low is simply because the test set is not coming from the same distribution of the training set.