Disentangling feature and lazy training in deep neural networks

TL;DR

None

Contribution

None

Abstract

Two distinct limits for deep learning have been derived as the network width $h\rightarrow \infty$, depending on how the weights of the last layer scale with $h$. In the Neural Tangent Kernel (NTK) limit, the dynamics becomes linear in the weights and is described by a frozen kernel $\Theta$. By contrast, in the Mean-Field limit, the dynamics can be expressed in terms of the distribution of the parameters associated with a neuron, that follows a partial differential equation. In this work we consider deep networks where the weights in the last layer scale as $\alpha h^{-1/2}$ at initialization. By varying $\alpha$ and $h$, we probe the crossover between the two limits. We observe the previously identified regimes of lazy training and feature training. In the lazy-training regime, the dynamics is almost linear and the NTK barely changes after initialization. The feature-training regime includes the mean-field formulation as a limiting case and is characterized by a kernel that evolves in time, and learns some features. We perform numerical experiments on MNIST, Fashion-MNIST, EMNIST and CIFAR10 and consider various architectures. We find that (i) The two regimes are separated by an $\alpha^*$ that scales as $h^{-1/2}$. (ii) Network architecture and data structure play an important role in determining which regime is better: in our tests, fully-connected networks perform generally better in the lazy-training regime, unlike convolutional networks. (iii) In both regimes, the fluctuations $\delta F$ induced on the learned function by initial conditions decay as $\delta F\sim 1/\sqrt{h}$, leading to a performance that increases with $h$. The same improvement can also be obtained at an intermediate width by ensemble-averaging several networks. (iv) In the feature-training regime we identify a time scale $t_1\sim\sqrt{h}\alpha$, such that for $t\ll t_1$ the dynamics is linear.

Tables

Table 1. Table 1: Performance for different setups.

Architecture	Dataset (binary, 10k)	Algorithm	Regime performing better
CNN (4 hidden layers)	CIFAR10	ADAM (batch size 32)	feature training
CNN (4 hidden layers)	Fashion-MNIST	ADAM (batch size 32)	Not clear (Fig. 7(b))
FC (3 hidden layers)	CIFAR10	ADAM (batch size 32)	lazy training
FC (3,9 hidden layers)	Fashion-MNIST	Gradient flow	lazy training
FC (3 hidden layers)	MNIST	Gradient flow	lazy training
FC (3 hidden layers)	EMNIST letters	Gradient flow	lazy training
FC (3 hidden layers)	CIFAR10	Gradient flow	lazy training
FC (5 hidden layers)	MNIST 10 PCA	Gradient flow	feature training

Table 2. Table 2: Powerlaw dependence in α 𝛼 \alpha , measure and prediction (in parenthesis) of the exponent a 𝑎 a where O ∼ α − a similar-to 𝑂 superscript 𝛼 𝑎 O\sim\alpha^{-a} for α ≪ 1 much-less-than 𝛼 1 \alpha\ll 1

Observable	$L=5$	$L=2$	Prediction
$\Vert \Theta -{\Theta }_0\Vert$	$1.7\left(1.66\right)$	$1.25\left(1.33\right)$	$\frac{2}{1+1/L}$
$\Vert w-w_0\Vert$	$0.23\left(0.166\right)$	$0.35\left(0.333\right)$	$\frac{1}{1+L}$

Equations

$$f(w,x)=\frac{1}{h}\sum _{i=1}^h{c}_i\sigma (a_i\cdot x+b_i),$$

$$f(w,x)\to \int \mathrm{d}a\mathrm{d}b\mathrm{d}c\rho (a,b,c)c\sigma (a\cdot x+b),$$

$${\partial }_t{\rho }_t=2\nabla \cdot ({\rho }_t\nabla \Psi (a,b,c;{\rho }_t)),$$

$$\Psi (a,b,c;\rho )=V(a,b,c)+\int \mathrm{d}{a}^{\prime }\mathrm{d}{b}^{\prime }\mathrm{d}{c}^{\prime }\rho (a^{\prime },b^{\prime },c^{\prime })U(a,b,c;a^{\prime },b^{\prime },c^{\prime }).$$

$$\Theta (w,x_1,x_2)={\nabla }_{w}f(w,x_1)\cdot {\nabla }_{w}f(w,x_2),$$

$$F(w,x)\equiv \alpha \left[f(w,x)-f(w_0,x)\right],$$

$$\mathcal{L}(w)=\frac{1}{{\alpha }^{2}n}\sum _{(x,y)\in \mathcal{T}}\ell (\alpha (f(w,x)-f(w_0,x)),y),$$

$$\alpha \underset{x\in \mathcal{T}}{\max }|f(w_i,x)-f(w_{i+1},x)|<0.1,$$

$$\frac{\Vert {\nabla }_w{\mathcal{L}}_i-{\nabla }_w{\mathcal{L}}_{i+1}{\Vert }^2}{\Vert {\nabla }_w{\mathcal{L}}_i\Vert \Vert {\nabla }_w{\mathcal{L}}_{i+1}\Vert }<{ϵ}_{\nabla }=10^{-4}.$$

$$\sigma (x)=a{sp}_{\beta =5}(x)$$

$$z^{\ell }=\sigma ({\tilde{z}}^{\ell }),$$

$${\tilde{z}}^1=d^{-\text{nicefrac}12}{W}^{0}x,$$

$${\tilde{z}}^{\ell +1}=h^{-\text{nicefrac}12}{W}^{\ell }{z}^{\ell },$$

$$f(w,x)=h^{-\text{nicefrac}12}{W}^L{z}^L.$$

$$\bar{F}(x)\equiv \frac{\alpha }{20}\sum _{i=1}^{20}(f(w_i,x)-f(w_{i,0},x))$$

$$\mathrm{Var}F(w,x)={⟨{\left[F(w_i,x_{\mu })-\bar{F}(x_{\mu })\right]}^2⟩}_{\begin{array}{c}\mu \in \mathrm{test}\\ i\in \mathrm{ensemble}\end{array}},$$

$$\mathrm{Var}\alpha \left[f(w,x)-f(w_0,x)\right]\sim h^{-1}.$$

$$||\Theta (w)-\Theta (w_0)||/||\Theta (w_0)||\sim (\sqrt{h}\alpha {)}^{-a},$$

$$t_{\mathcal{L}/2}\sim \sqrt{h}\alpha .$$

$$\frac{\partial f}{\partial W^0}=\mathcal{O}\left(\frac{1}{\sqrt{h}}\right);\frac{\partial f}{\partial W^{\ell }}=\mathcal{O}\left(\frac{1}{h}\right);\frac{\partial f}{\partial W^L}=\mathcal{O}\left(\frac{1}{\sqrt{h}}\right).$$

$${\dot{W}}^0=\mathcal{O}\left(\frac{1}{\sqrt{h}\alpha }\right);{\dot{W}}^{\ell }=\mathcal{O}\left(\frac{1}{h\alpha }\right);{\dot{W}}^L=\mathcal{O}\left(\frac{1}{\sqrt{h}\alpha }\right)$$

$${\dot{\tilde{z}}}^{\ell }=\mathcal{O}\left(\frac{1}{\sqrt{h}\alpha }\right).$$

$$\forall t\ll t_1\equiv \alpha \sqrt{h},W^L(t)-W^L(0)=o(1);{\tilde{z}}^{\ell }(t)-{\tilde{z}}^{\ell }(0)=o(1)$$

$$\Theta (t_2)-\Theta (0)\sim \Theta (t_2)\sim {\lambda }^{2L}\sim [\alpha \sqrt{h}{]}^{-\frac{2}{1+1/L}}$$

$${\tilde{f}}_{w_1}(w,x)={\nabla }_{w}f(w_1,x)\cdot w.$$

$${\dot{\tilde{f}}}_{w_1}(w)={\nabla }_{w}f(w_1)\cdot \dot{w},$$

$${\dot{\tilde{f}}}_{w_1}(w)=-{\nabla }_{w}f(w_1)\cdot \frac{1}{n}\sum _{(x,y)\in \mathcal{T}}{\ell }^{\prime }({\tilde{f}}_{w_1}(w,x),y){\nabla }_{w}f(w_1,x)$$

$${\dot{\tilde{f}}}_{w_1}(w)=-\frac{1}{n}\sum _{(x,y)\in \mathcal{T}}{\ell }^{\prime }({\tilde{f}}_{w_1}(w,x),y)\Theta (w_1,x)$$

$$\frac{||w-w_0||}{||w_0||}\sim \frac{1}{h\alpha }$$

$$\frac{||w-w_0||}{||w_0||}\sim \frac{(\sqrt{h}\alpha {)}^{-b}}{\sqrt{h}}$$

$$||f(w)||=\sqrt{⟨f(w,x_{\mu }{)}^2{⟩}_{\mu \in \mathrm{test}}}$$

$$||f(w_t)-f(w_0)||\sim \frac{t}{t_1}\sqrt{h},t\ll t_1\text{ in feature training.}$$

$$\mathrm{Var}f(w,x)={⟨{\left[f(w_i,x_{\mu })-\bar{f}(x_{\mu })\right]}^2⟩}_{\begin{array}{c}\mu \in \mathrm{test}\\ i\in \mathrm{ensemble}\end{array}}.$$

Full text

1 Introduction and related works

Deep neural networks are successful at a variety of tasks, yet understanding why they work remains a challenge. A surprising observation is that their performance on supervised tasks keeps increasing with their width $h$ in the over-parametrized regime where they already fit all the training data Neyshabur et al. (2017); Bansal et al. (2018); Advani and Saxe (2017); Spigler et al. (2018). This fact underlines the importance of describing deep learning in the limit $h\rightarrow\infty$.

The transmission of the signal through the network in the infinite-width limit is well understood at initialization. If the network weights are initialized as i.i.d. random variables with zero mean and a fixed variance of order $h^{-\nicefrac{{1}}{{2}}}$, the output function $f(x)$ is a Gaussian random processes with some covariance that can be computed Neal (1996); Williams (1997); Lee et al. (2018); de G. Matthews et al. (2018); Novak et al. (2019); Yang (2019).

Until recently much less was know about the evolution of infinitely-wide networks. It turns out that two distinct limits emerge, depending on the initialization of the last layer of weights.

Mean Field limit

A limiting behavior of neural networks, called “mean field” in the literature, has been studied in several works focusing mostly on one-hidden layer networks Mei et al. (2018); Rotskoff and Vanden-Eijnden (2018); Chizat and Bach (2018); Sirignano and Spiliopoulos (2018); Mei et al. (2019); Nguyen (2019). In this setting the output function of the network with $h$ hidden neurons corresponding to an input $x$ is

[TABLE]

where $\sigma(\cdot)$ is the non-linear activation function and $w_{i}=(a_{i},b_{i},c_{i})$ are the parameters associated with a hidden neuron. At initialization, the terms in the sum are independent random variables. We can invoke the law of large numbers: for large $h$ the average tends to the expectation value

[TABLE]

and it has been shown in the literature that the training dynamics is controlled by a differential equation for the density of parameters $\rho$:

[TABLE]

Here $\nabla$ is the gradient with respect to $(a,b,c)$ and $U,V$ are potentials defined in Mei et al. (2018). This is equivalent to the hydrodynamic (continuous) description of interacting particles in some external potential. The performance of a network is then expected to plateau on approaching this limit, as $h\to\infty$.

NTK limit

Another limit has been identified when the weights in the last layer scale as $h^{-\nicefrac{{1}}{{2}}}$, which differs from the $h^{-1}$ scaling used in the mean-field setting. This limit also applies to deep fully-connected networks and other architectures. The learning dynamics in this limit simplifies Jacot et al. (2018); Du et al. (2019); Allen-Zhu et al. (2018); Lee et al. (2019); Arora et al. (2019); Park et al. (2019) and is entirely described by the neural tangent kernel (NTK) defined as:

[TABLE]

where $x_{1},x_{2}$ are two inputs and $\nabla_{w}$ is the gradient with respect to the parameters $w$. The kernel $\Theta$ is defined at any time and typically evolves during the dynamics. As $h\to\infty$, $\Theta(w,x_{1},x_{2})\to\Theta_{\infty}(x_{1},x_{2})$ does not vary at initialization (and thus it does not depend on the specific choice of $w$) and does not evolve in time: the kernel is frozen. The dynamics is guaranteed to converge on a time independent of $h$ to a global minimum of the loss, and as for usual kernel learning the function only evolves in the space spanned by the functions $\Theta_{\infty}(x_{\mu},x)$, where $\{x_{\mu},\mu=1...n\}$ is the training set.

The existence of two distinct limits raises both fundamental and practical questions. First, which limit best characterizes the neural networks that are used in practice, and which one leads to a better performance? These questions are still debated. In Chizat and Bach (2019), based on teacher-student numerical experiments, it was argued that the NTK limit is unlikely to explain the success of neural networks. However, it was recently shown that the NTK limit is able to achieve good performance on real datasets Arora et al. (2019) (significantly better than alternative kernel methods). Moreover, some predictions of the NTK limit agree with observations in networks of sizes that are used in practice Lee et al. (2019). Second, it was argued that in the NTK limit the surprising improvement of performance with $h$ stems from the $h^{-\nicefrac{{1}}{{2}}}$ fluctuations of the kernel at initialization, that ultimately leads to similar fluctuations in the learned function and degrades the performance of networks of small width Geiger et al. (2019). These fluctuations can be removed by ensemble-averaging output functions obtained with different initial conditions and trained independently, leading to an excellent performance already near the underparametrized to overparametrized (or jamming) transition $h^{*}$ beyond which all the training data are correctly fitted Geiger et al. (2018). Does this line of thought hold true in the mean-field limit?

Finally, unlike in the NTK limit where preactivations vary very weakly during training, in the mean field limit feature training occurs. It is equivalent to saying that the tangent kernel (which can always be defined) evolves in time Rotskoff and Vanden-Eijnden (2018); Mei et al. (2019); Chizat and Bach (2019). What are the characteristic time scales and magnitude of this evolution?

1.1 Our contributions

In this work we answer these questions empirically by learning a model of the form:

[TABLE]

where $f(w,x)$ is a deep network and $w_{0}$ is the network parameters at initialization. This model is inspired by Chizat and Bach (2019). For $\alpha=\mathcal{O}(1)$ it falls into the framework of the NTK literature, whereas for $\alpha=\mathcal{O}(h^{-\nicefrac{{1}}{{2}}})$ it corresponds to the mean-field framework. Our strategy is to consider a specific setup that is fast to train, simple and to some extent theoretically tractable. Thus we focus on fully-connected (FC) networks with Softplus activation functions and gradient-flow dynamics. In the main body of the work we consider the Fashion-MNIST dataset, later in Section 7 we extend our study to other datasets, architectures (including CNNs) and dynamics to verify the generality and robustness of our claims. For each setting we study systematically the role of both $\alpha$ (varied on 11 orders of magnitude) and the width $h$, learning ensembles of 10 to 20 networks so as to quantify precisely the magnitude of fluctuations induced by initialization and the benefit of ensemble averaging.

Our main findings are as follows: (i) In the $(\alpha,h)$ plane two distinct regimes can be identified, separated by $\alpha^{*}=\mathcal{O}(h^{-\nicefrac{{1}}{{2}}})$, in which performance and dynamics are qualitatively different. (ii) Which regime achieves a lower generalization error depends on the data structure and the network architecture. We find that fully-connected architectures generally perform better in the lazy-training regime, while convolutional networks trained on CIFAR10 with ADAM achieves a smaller error in the feature-training regime. (iii) The fluctuations of the network output $\delta F$ decay with the width as $\delta F=\mathcal{O}(h^{-\nicefrac{{1}}{{2}}})$ in both regimes, leading to a performance that increases with the degree of overparametrization. Because of the nature of the fluctuations, a similar improvement can also be obtained at an intermediate width by ensemble-averaging several independently-trained networks. (iv) In the feature-training regime there exist a characteristic time scale $t_{1}\sim\sqrt{h}\alpha$, such that for $t\ll t_{1}$ the dynamics is linear. At $t\sim t_{1}$, the output grows by a factor $\sqrt{h}$ and the tangent kernel $|\!|\Delta\Theta|\!|$ varies significantly and can not be considered approximately constant any longer. Ultimately, it follows $|\!|\Delta\Theta|\!|\sim(\sqrt{h}\alpha)^{-a}$ for ReLU and Softplus activation functions, with $a<2$ and $a\to 2$ as depth grows. We provide scaling arguments supporting these findings.

The implications of our work are both practical (in terms of which parameters and architectures lead to improved performance) and conceptual (in quantifying the dynamics of feature training and providing informal explanations for these observations). More generally, it suggests that future empirical studies of deep learning would benefit from characterizing the regime in which they operate, since it will most likely impact their results.

The code used for this article is available online at https://github.com/mariogeiger/feature_lazy/tree/article.

1.2 Related work

Our work is most closely related to Chizat and Bach (2019) and to Chizat et al. (2019) that appeared simultaneously to ours. The scale $\alpha\gg h^{-\nicefrac{{1}}{{2}}}$ separating the lazy and feature learning regimes was justified for a one-hidden layer, in consistence with our findings that also apply to deep nets. The authors further suggest that the feature learning regime should outperform the lazy training one, as they observe in two different setups: i) a fully-connected one-hidden-layer network trained on data from a teacher network and ii) a VGG-11 deep network trained on CIFAR10 with a cross-entropy loss. Both setups achieve a smaller generalization error away from the lazy-training regime. Our empirical analysis is much more extensive both in terms of dataset and observables studied. It gives a different view, since for real data we find that for fully-connected networks lazy training tends to outperform feature learning.

2 Notations and set-up

The following setup is used for all empirical results in the article, except for those presented in Section 7, where we explore different settings.

We consider deep networks with $L$ hidden layers performing a binary classification task. We denote by $w$ the set of parameters (or weights), and by $f(w,x)$ the output of a network parametrized by $w$ corresponding to an input pattern $x$. The set of training data is $\mathcal{T}=\{(x_{\mu},y_{\mu}),\mu=1,\dots,n\}$, where $y_{\mu}=\pm 1$ is the label associated with the pattern $x_{\mu}$ and $n$ is the number of training data. In what follows $\dot{a}$ is the notation we use for the time derivative of a variable $a$ during training.

Parameter $\alpha$:

Instead of training a network $f(w,x)$, we train $F(w,x)=\alpha(f(w,x)-f(w_{0},x))$, i.e we use this quantity as our predictor and train the weights $w$ accordingly. Here $w_{0}$ is the network’s parameters at initialization. In the over-parametrized regime, this functional form ensures that for $\alpha\to\infty$, we enter in what we call the lazy-training regime, where changes of weights are small. Indeed in order to obtain a zero loss $\alpha(f(w,x)-f(w_{0},x))$ must be ${\cal O}(1)$, thus $1\sim\alpha(f(w,x)-f(w_{0},x))\sim\alpha\nabla_{w}f(w_{0},x)\cdot dw$. For large $\alpha$ then $|f(w,x)-f(w_{0},x)|$ is small: the dynamics can hence be considered linear Chizat and Bach (2019), with $f(w,x)-f(w_{0},x)\approx\nabla_{w}f(w_{0},x)\cdot(w-w_{0})$. Since the gradient of $f(w_{0},x)$ does not scale with $\alpha$, this implies that $|\!|dw|\!|\equiv|\!|w-w_{0}|\!|\sim\alpha^{-1}$.

Learning is achieved via the minimization of the loss function

[TABLE]

where $\ell$ is the loss per pattern, $\mathcal{T}$ is the training set and $n=|\mathcal{T}|$. The prefactor $\alpha^{-2}$ ensures that the convergence time does not depend on $\alpha$ as $\alpha\rightarrow\infty$, since for that choice we have $\alpha\dot{f}(w_{0})={\cal O}(\alpha^{0})$ (i.e. does not scale with $\alpha$ for large $\alpha$).

Note that if we train directly $\alpha f(w,x)$ without removing its value at initialization, we expect no difference with the present setting for $\alpha$ of order one or much smaller. This statement is confirmed numerically in Appendix I. For $\alpha\gg 1$ however, we find empirically that the learning dynamics does not converge.

Dynamics

Since our goal is to build a connection between empirical and theoretical approaches, we focus on a discrete version of continuous dynamics obeying simple differential equation. The simplest is the vanilla gradient descent which reads $\dot{w}=-\nabla_{w}\mathcal{L}$ and does not depend on any hyper-parameters. This dynamics is run in a discretized form, with a time step that is adapted at each step to ensure that

[TABLE]

In Appendix G we checked that our results are independent of $\epsilon_{\nabla}$ for $\epsilon_{\nabla}\leq 10^{-4}$.

Activation function

The Softplus activation function is defined as $\mathit{sp}_{\beta}(x)=\frac{1}{\beta}\ln(1+e^{\beta x})$. The larger the parameter $\beta$, the sharper is the Softplus, and as $\beta\to\infty$ it tends to a ReLU activation function. In our experiments we take $\beta=5$. In order to have preactivations of unit variance at initialization we also multiply the Softplus by a prefactor $a\approx 1.404$. The activation function that we use at all hidden neurons is then

[TABLE]

Non-smooth activation functions like ReLU can introduce additional phenomena; for instance, we quantify its impact on the evolution of the neural tangent kernel in Appendix F.

Loss function

For the loss-per-pattern $\ell(f,y)$ we use the soft-hinge loss $\ell(f,y)=\mathit{sp}_{\beta}(1-fy)$, where $\mathit{sp_{\beta}}$ is again a Softplus function. This function is a smoothed version of the hinge loss, to which it tends as $\beta\to\infty$. We use the value $\beta=20$ as a compromise between smoothness and being similar to the hinge loss, see Fig. 1. The stopping criterion to end the learning dynamics is met when all patterns are classified within a sufficient margin, that is when $\alpha\left[f(w,x_{\mu})-f(w_{0},x_{\mu})\right]y_{\mu}>1$ for all $\mu=1,\dots,n$. Keep in mind that this criterion makes sense only in the overparametrized phase (as it will be the case in what follows), where networks manage to fit all the training set Spigler et al. (2018). The hinge loss results in essentially identical performance to the commonly used cross-entropy in state-of-the-art architectures, but leads to a dynamics that stops in a finite time in the over-parametrized regime considered here, removing the need to introduce an arbitrary temporal cut-off Spigler et al. (2018).

Architecture

We use a constant-width fully-connected architecture based on Jacot et al. (2018). Given an input pattern $x\in\mathbb{R}^{d}$, we denote by $\tilde{z}^{\ell}$ the vector of preactivations at each hidden layer and by $z^{\ell}$ the corresponding activations. The flow of signals through the network can be written iteratively as

[TABLE]

The matrices $W^{\ell}$ contain the parameters of the $\ell$-th hidden layer, and the (vectorized) set of all these matrices has been previously denoted as $w$. The width and depth of the network are $h$ and $L$; in our simulations we vary $h$ but we mostly keep the depth $L=3$ constant. The input patterns live a $d$-dimensional space. Fig. 2 illustrates the architecture and explains our notation. In order to have preactivations of order $\mathcal{O}(1)$ at initialization, all the weights are initialized as standard Gaussian random variables, $W^{\ell}_{ij}\sim\mathcal{N}(0,1)$. Note that there is no bias, we discuss it in Appendix J.

Dataset

We train our network to classify $28\times 28$ grayscale images of clothes from the Fashion-MNIST database Xiao et al. (2017). For simplicity we split the original 10 classes in two sets and we perform binary classification. For $(x,y)\in\mathcal{T}$ we have $x\in\mathbb{R}^{28\times 28}$ ($d=784$) and $y=\pm 1$. The input is normalized on the sphere, $\sum_{i}x_{i}^{2}=d$ such that each component $x_{i}$ has unit variance. We took 1000 images of each class (10000 in total) to make our train set and 5000 of each class (50000 in total) to make our test set. The train set is smaller than usual (10000 instead of 50000) in order to shorten the training time.

3 Disentangling feature training and lazy training according to performance

To argue the existence of two distinct regimes in deep neural networks, we evaluate their performance in the $(\alpha,h)$ plane. How we vary parameters to probe this plane is represented in Fig. 3 (a). We consider plots obtained at fixed $h$ and varying $\alpha$ (Fig. 3 (c,d)) as well as fixed $\sqrt{h}\alpha$ (Fig. 3 (b)).

Fig. 3 (b) shows the test error as a function of the width $h$, for different values of $\sqrt{h}\alpha$. For large $h$, we observe that as $\sqrt{h}\alpha$ is increased the performance also increases, up to a point where it converges to a limiting curve (for $\sqrt{h}\alpha\geq 10^{3}$ in the figures). This limiting curve coincides with the test error found if the NTK is frozen at initialization (see Appendix A for a description of our dynamics in that case), represented by a black solid line. Following Chizat and Bach (2019), we refer to this limiting behavior as lazy training.

There is a value of $\alpha$ for which we leave the lazy-training regime and enter a nonlinear regime that we call feature training.111In our parlance, the NTK and mean-field limits correspond respectively to the lazy-training and feature-training regimes in the $h\to\infty$ limit. To identify this regime, in Fig. 3 (c) we show the test error as a function of $\alpha$ for several widths $h$, and the rescaled test error (in such a way that it takes values between [math] and $1$) as a function of $\sqrt{h}\alpha$ in Fig. 3 (d). The curves collapse, supporting that in the $(\alpha,h)$ plane the boundary between the two regimes lies at a scale $\alpha^{*}=\mathcal{O}(h^{-\nicefrac{{1}}{{2}}})$. It is precisely the scaling used in Mean Field.

4 Fluctuations of the output function and the effect of ensemble averaging

As shown in Fig. 3, performance increases with $h$: adding more trainable parameters leads to better predictability and deep networks do not overfit. This surprising behavior was related to the fluctuations of the output function induced by initial conditions, observed to decrease with $h$ Neal et al. (2019); Geiger et al. (2019). To quantify the fluctuations in both regimes we train an ensemble of 20 identical functions $F(w_{i},x)=\alpha\left[f(w_{i},x)-f(w_{i,0},x)\right]$ starting from different initial conditions, and then we measure the ensemble average $\bar{F}(x)$:

[TABLE]

A single trained realization of the network fluctuates around the ensemble average $\bar{F}(x)$, and therefore $\delta F(w,x)\equiv F(w,x)-\bar{F}(x)$ is a random function, whose fluctuations are quantified by the variance:

[TABLE]

where the average is both over the 20 output functions and over all points $x_{\mu}$ in a test set. Other norms can be used to quantify this variance, all yielding the same picture. In Fig. 4 (a-b) we compute these fluctuations either in the feature-training or in the lazy-training regimes. In both cases we find the same decay with the network width:

[TABLE]

In the feature-training regime, this observation is consistent with the predictions from Rotskoff and Vanden-Eijnden (2018) (obtained for a one-hidden layer performing regression). Since $\delta F$ is a random function with zero expectation value and finite variance $\mathrm{Var}\,F\sim h^{-1}$ we will write that $\delta F\sim h^{-\nicefrac{{1}}{{2}}}$.

In Fig. 4 (b), in the lazy-training regime, the curves do not overlap. This is a preasymptotic effect. In Appendix H we show that the asymptotic power law is reached for smaller dataset sizes.

It was argued in Geiger et al. (2019) that in the lazy-training regime this scaling simply stems from the fluctuations of the NTK at initialization, that go as $|\!|\delta\Theta|\!|\sim 1/\sqrt{h}$ and lead to similar fluctuations in $\delta F$. These fluctuations were argued to lead to an asymptotic decrease of test error as $1/h$, consistent with observations. Interestingly, the same scaling for the fluctuations holds in the feature-training regime, presumably reflecting the approximations expected from the Central Limit Theorem (CLT) when Eq. (1) is replaced by an integral.

As a consequence of these fluctuations, ensemble averaging output functions leads to an enhanced performance in both regimes, as shown in Fig. 4 (c-d). We remark that:

(i) In each regime, the test error of the ensemble average is essentially independent of $h$. It implies that the variation of performance with $h$ is only a matter of diminishing fluctuations in the over-parametrized case considered here (as shown below, we always fit all training data in these runs). It also supports that the plateau value of the ensemble-average performance we observe corresponds to the performance of single network in the $h\rightarrow\infty$ limit.

(ii) Interestingly, it is reported in Geiger et al. (2019) that for a fixed $\alpha$, the smallest test error of the ensemble average is obtained at some finite $h_{\min{}}$ beyond $h^{*}$ implying that past $h_{\min{}}$ performance is decreasing with growing $h$. It can now be simply explained: at fixed $\alpha$ one goes from feature to lazy training as $h$ increases, since $\sqrt{h}\alpha$ also increases and must eventually become much larger than one, leading to a change in performance.

(iii) For small values of $\sqrt{h}\alpha$ (smaller than $10^{-4}$) the variance blows up. We leave the study of this regime for future works. Since we observe that the test error also greatly increases for these values of $\sqrt{h}\alpha$, this regime is of less interest.

5 Training dynamics differs in the two regimes

The network is able to learn features in the feature-training regime, while it cannot in the lazy-training regime because the NTK is frozen. To quantify feature training we measure the total relative variation of the kernel at the end of training: $|\!|\Theta(w)-\Theta(w_{0})|\!|/|\!|\Theta(w_{0})|\!|$, where the norm of a kernel is defined as $|\!|\Theta(w)|\!|^{2}=\sum_{\mu,\nu\in\mathrm{test\ set}}\Theta(w,x_{\mu},x_{\nu})^{2}$. This quantity is plotted in Fig. 5 (a, left) versus $\alpha$ for several widths $h$, and versus $\sqrt{h}\alpha$ in Fig. 5 (a, right). The fact that the curves collapse indicates that $\alpha\sqrt{h}$ is the parameter that controls feature training. In particular, the crossover $\alpha^{*}\sim h^{-\nicefrac{{1}}{{2}}}$ precisely corresponds to the point where the change of the kernel is of the order of the norm of the kernel at initialization. Moreover, in the feature-training regime we find:

[TABLE]

with an exponent $a\approx 1.3$. By contrast in the lazy-training regime $|\!|\Theta(w)-\Theta(w_{0})|\!|/|\!|\Theta(w_{0})|\!|\sim 1/(\sqrt{h}\alpha)$, as expected for what concerns the dependency in $h$ Jacot et al. (2019); Geiger et al. (2019); Lee et al. (2019). In Appendix F, we show that for a non-smooth activation function like the ReLU there is a third intermediary regime where $|\!|\Theta(w)-\Theta(w_{0})|\!|/|\!|\Theta(w_{0})|\!|\sim\alpha^{-1/2}$.

In Appendix A, we show in Fig. 8 an example of the evolution of the kernel (represented by its Gram matrix). We also present an interesting discovery: once the network has been trained, performing kernel learning with the NTK obtained at the end essentially leads to the same generalization error.

We finally investigate the temporal evolution of learning, known to be characterized by several time scales Baity-Jesi et al. (2018). The rescaled loss $\alpha^{2}{\cal L}$ is shown in Fig. 5 (b). As expected Jacot et al. (2018); Chizat and Bach (2019), in the lazy-training regime $\alpha^{2}{\cal L}(t)$ depends neither on $\alpha$ nor $h$. This is not true in feature training however. We define $t_{\mathcal{L}/2}$ as the time for which the loss reduced by a half. Our key finding, visible in Fig. 5 (b), is that the learning curves are very sharp in the feature-training regime and they overlap when we rescale the time axis properly. Fig. 5 (b,c) show that in the feature-training regime:

[TABLE]

In Section 6 we show that there is a time $t_{1}$ that marks the timescale below which the dynamics remains linear. In the feature-training regime we explain that $t_{\mathcal{L}/2}$ correspond to $t_{1}$ due to the nonlinearity that makes the dynamics evolve rapidly near $t_{1}$.

6 Arguments on kernel dynamics and regimes’ boundary

The arguments proposed in this section do not have the status of mathematical proofs. They provide heuristic explanations for the scaling $t_{1}\sim\alpha\sqrt{h}$ and $\alpha^{*}\sim 1/\sqrt{h}$, and support that the output function grows by a factor $\sqrt{h}$ before the dynamics become highly non-linear. A simple assumption on the nature of the ensuing non-linear dynamics leads to the prediction Eq. (18) with $a=2/(1+1/L)$, which we view as a good approximation (not necessarily exact) of our observations.

Our starting point is that for the NTK initialization, we have at $t=0$ that $\tilde{z}_{\alpha}={\cal O}(1)$ and $\partial f/\partial\tilde{z}_{\alpha}={\cal O}(1/\sqrt{h})$, where $\tilde{z}_{\alpha}$ is the preactivation of a hidden neuron. The second point can be derived iteratively starting from the last hidden layer. Denote by $W^{0}$ the weight matrix connected to the input, and $W^{\ell}$ the weight matrix connecting two hidden neurons in the $\ell-1$ and $\ell$ hidden layers respectively, and $W^{L}$ the weight vector connected to the output. It is then straightforward to show using the chain rule and $\sigma^{\prime}(\tilde{z})={\cal O}(1)$ that (see also Arora et al. (2019)):

[TABLE]

From which we deduce that:

[TABLE]

by using the gradient-descent formula (i.e. $\dot{w}=-\nabla\mathcal{L}$).

Next, we consider how the neurons’ preactivations evolve in time. From the composition of derivatives, one obtains $\dot{\tilde{z}}^{\ell+1}=h^{-\nicefrac{{1}}{{2}}}(\dot{W}^{\ell}z^{\ell}+W^{\ell}\dot{z}^{\ell})$. It is clear from Eq. (21) that $h^{-\nicefrac{{1}}{{2}}}\dot{W}^{\ell}z^{\ell}={\mathcal{O}}\left(\frac{1}{\sqrt{h}\alpha}\right)$. Concerning the product $W^{\ell}\dot{z}^{\ell}$, in the large-width limit it can be proven to be correctly estimated by considering that $W^{\ell}$ and $\dot{z}^{\ell}$ are independent Dyer and Gur-Ari (2019). (This result simply stems from the fact that the time-derivative of the preactivation of one neuron depends on all its $h$ outgoing weights, and is therefore weakly correlated to any of them). From the central limit theorem, the vector $W^{\ell}\dot{z}^{\ell}$ is thus of order $\sqrt{h}\dot{z}^{\ell}$. Proceeding recursively from the input to the output we obtain:

[TABLE]

We checked Eq. (22) numerically in Appendix D.

From Eq. (21) and Eq. (22) we expect that:

[TABLE]

Thus for $t\ll t_{1}$, we are in the lazy-training regime where preactivations and weights did not have time to evolve, and we expect the kernel variations to be small (see Mei et al. (2019) for a related discussion). Since the lazy-training regime finds a zero loss solution and stops in a time ${\cal O}(1)$ (see Section 2), if $t_{1}=\alpha\sqrt{h}\gg 1$ the network remains in it throughout learning. Thus $\alpha^{*}\sim 1/\sqrt{h}$, as proposed for a single layer in Chizat and Bach (2019).

By contrast, if $\alpha\sqrt{h}\ll 1$ the dynamics has not stopped at times $t\sim t_{1}$, for which we have $W^{L}(t_{1})-W^{L}(0)={\cal O}(1)$ and $\tilde{z}(t_{1})-\tilde{z}(0)={\cal O}(1)$: both the preactivations and the weights of the last layer have changed significantly, leading to significant changes of $\nabla_{w}f$ and $\Theta$. It is important to note that at $t\sim t_{1}$, the scale of the output function is expected to change. Indeed at initialization the output function, which is a sum made on the last layer of hidden neurons $f(w,x)=\frac{1}{\sqrt{h}}\sum_{i=1}^{h}W^{L}_{i}\sigma(\tilde{z}^{L}_{i})$, is ${\cal O}(1)$ as expected from the CLT applied to $h$ uncorrelated terms Neal (1996). However, for $t\sim t_{1}$ this independence does not hold anymore, since the terms $W^{L}_{i}\sigma(\tilde{z}^{L}_{i})$ have evolved by ${\cal O}(1)$ to change the function $f(w,x)$ in a specific direction. We thus expect these correlations to build up linearly in time for $t\in[0,t_{1}]$ and to ultimately increase the output by a factor $\sqrt{h}$ at $t\sim t_{1}$, as confirmed in Appendix C. Note that this effect does not appear at intermediate layers in the network, because the weights evolve much more slowly there as follows from Eq. (21).

Still, such an increase in the output is insufficient to find solutions deep in the feature-training regime, since $\alpha[f(w(t_{1}))-f(w(0))]\sim\alpha\sqrt{h}\ll 1$. We propose that for activation functions that increase linearly at large arguments as those we use, the dynamics for $t\approx t_{1}$ approximately corresponds to an inflation of the weights along the direction $\dot{w}(t_{1})$. Specifically, we define an amplification factor $\lambda(t)=|\!|w(t)-w(0)|\!|/|\!|w(t_{1})-w(0)|\!|$, and assume for simplicity that this amplification is identical in each of the $L+1$ layers of weights (we disregard in particular the fact that the last and first layer may behave differently, as discussed in Arora et al. (2019)). By definition, $\lambda(t_{1})=1$. At the end $t_{2}$ of training, for activation functions that increase linearly at large arguments, we expect to have $\lambda(t_{2})\sim[\alpha\sqrt{h}]^{-1/(L+1)}$ to ensure that $\alpha[f(w(t_{2}))-f(w(0))]={\cal O}(1)$. Gradient with respect to weights are increased by $\lambda^{L}$, leading to an overall inflation of the kernel:

[TABLE]

leading to $a=1.66$ consistent with Eq. (18). We have checked this prediction with success for shallow networks with $L=2$, as shown in Appendix E.

7 Other experiments

We now check that our conclusions extend to other data sets, architectures and learning dynamics. In particular we consider under which circumstances feature training outperforms lazy training. Table 1 summarizes our results. The key observation is that which regime works best depends on the architecture and on the data. In particular, for the training set size $10^{4}$ we focus on in this study (as it allows to study gradient descent in a reasonable time), we generally find that FC performs better under the lazy training regime. For the CNN architectures that we study, feature training tends to perform better.

MNIST and CIFAR10:

We train the FC network defined in Section 2 on the MNIST and CIFAR10 datasets. CIFAR10 dataset contains $50000+10000$ $32\times 32$ images in the trainset and testset, which are split into 10 classes. We reduced the trainset to 10000 images split into 2 classes (5 classes merges into 1) and the images are flatten into a vector of size 1024. In Fig. 6 we show the results. The picture is qualitatively similar to what we see for Fashion-MNIST.

First ten principal components of MNIST PCA:

As dataset we consider the projection of the handwritten digits in the MNIST dataset onto their first 10 principal components, obtained via principal-component analysis (PCA). This dataset is harder to fit than the original MNIST. Using the FC network defined in Section 2, we observe (see Fig. 7 (a)) that the test error for a single network as well as the ensemble-averaged test error are nearly identical, even somewhat smaller in the feature-training regime than in the lazy-training regime, contrarily to what was observed for the full MNIST dataset.

EMNIST:

Using again the FC network defined in Section 2, we consider the pictures of handwritten letters in the EMNIST dataset. Fig. 7 (c) shows that the results are similar to what observed for Fashion-MNIST and MNIST. Here two setups are compared, the current setup (described in Section 2) and an alternative setup with $\beta=10$ for the loss function and a value of $\tau$ proportional to the time.

CNN for CIFAR 10 and Fashion-MNIST:

We train a convolutional neural network (CNN) with 4 hidden layers (with stride and padding). It has Softplus activation function and no biases. We initialize the parameters of the convolutional networks as standard Gaussians in such a way that the preactivations are of order unity. Our architecture has 4 hidden layers, and we use a stride of /2 before the first layer and in the middle of the network. After the convolutions we average the spatial dimensions, and the last layer is a simple perceptron. The code is available on the repository. It is trained to classify images of the CIFAR10 dataset ($32\times 32$ images). Our trainset contains 10000 images split into 2 classes. Learning is achieved with the ADAM dynamics Kingma and Ba (2015). We observe, see Fig. 7 (b), that individual and ensemble-averaged performance is better in the feature-training regime. For Fashion-MNIST, the optimal performance occurs in a narrow range of intermediate $\alpha$.

Effect of Depth:

In Fig. 7 (d) we compare networks with different depths, $L=3$ with $L=9$. The setup is defined in Section 2. We find that increasing depth does not change qualitatively the dependence of the test error with $\sqrt{h}\alpha$. Quantitatively, depth has a very limited effect on the ensemble average performance, but does decrease the performance of individual networks — presumably indicating that depth increases fluctuations of the output function induced by random initialization.

8 Conclusion

We have shown that as the width $h$ and the output scale $\alpha$ at initialization are varied, two regimes appear depending on the value of $\alpha\sqrt{h}$. In the feature-training regime features are learned (in the sense that the tangent kernel evolves during training), whereas in the lazy-training regime the dynamics is controlled by a frozen kernel. Our key findings are that: (i) In both regimes, fluctuations induced by initialization decrease with $h$, explaining why performance increases with the width. (ii) In feature training, the learning dynamics is linear for $t\ll t_{1}\sim\sqrt{h}\alpha$, time at which the output of the model becomes of order $\sqrt{h}\alpha$. If $\sqrt{h}\alpha\ll 1$, in order to fit the data the dynamics enters a non-linear regime for $t\sim t_{1}$ that affects the magnitude of the kernel.

In treating these data sets, we have separated classes randomly into two groups. In the future, it would be interesting to test performance with a binary classification where the categories are intuitively meaningful. We have focused our comparison between these two learning regimes on a fixed data set size $p$, comparable in order of magnitude but smaller than the full data set. In a recent workPaccolat et al. (2020) we performed that comparison as $p$ varies for a CNN trained on MNIST. In that case, we found that for all $p$ considered, feature learning outperforms lazy training in terms of generalization error $\epsilon$. For the training curve $\epsilon\sim p^{-\beta}$ with $\beta_{\text{lazy}}=1/3$ and $\beta_{\text{feature}}=1/2$, indicting that the feature learning regime was improving faster with growing $p$ than lazy training in relative terms.

On the empirical side, our work supports that studies of deep learning (e.g. on the role of regularization) should specify in which regime their networks operate, since it is very likely that it affects their results. On the theoretical side, there is little quantitative understanding on how much the performance should differ in two regimes. The results that we presented in Section 7 show that it depends on both the structure of the data and on the architecture of the network. Answering this point appears necessary to ultimately understand why deep learning works.

Acknowledgements

We thank Levent Sagun, Clément Hongler, Franck Gabriel, Giulio Biroli, Stéphane d’Ascoli for helpful discussions. We thank Riccardo Ravasio and Jonas Paccolat for proofreading. This work was partially supported by the grant from the Simons Foundation (#454953 Matthieu Wyart). M.W. thanks the Swiss National Science Foundation for support under Grant No. 200021-165509.

Appendix A Frozen NTK dynamics

Let us consider the first order approximation $\tilde{f}_{w_{1}}(w,x)$ of a model $f(w,x)$ around $w=w_{1}$,

[TABLE]

For instance, $w_{1}$ can be the value at initialization or at the end of another dynamics. We can then train this linearized model keeping the gradients fixed:

[TABLE]

where $\dot{w}$ depends on the gradient descent procedure. Using gradient descent,

[TABLE]

By introducing the kernel we can rewrite the previous equation as

[TABLE]

where $\Theta$ is the neural tangent kernel defined in Eq. (5). We call these equations the frozen kernel dynamics.

The results presented in Fig. 5 state that the network learns a kernel during the training dynamics, and that this learned kernel coincides with the frozen kernel in the lazy-training regime as $\sqrt{h}\alpha\to\infty$. Another way to see that the kernel changes during training is to plot the so-called Gram matrix of the frozen kernel, namely the matrix $(\Theta(w,x_{\mu},x_{\nu}))_{\mu,\nu\in\mathrm{test\ set}}$: in Fig. 8 (a-b) we show the Gram matrix of the neural tangent kernel evaluated before and after training, where it is clear that there is an emergent structure that depends on the dataset.

The architecture used in in Fig. 5 is a resnet based on Zagoruyko and Komodakis (2016). We use no batch normalization and initialization is as in our fully-connected networks. The code describing the architecture is available in the supplementary material.

It is interesting to test if the performance of deep networks after learning is entirely encapsulated in the kernel it has learned. We argue that indeed this is the case, and to make our point, we proceed as follows. At any time $t$ during training, we can compute the instantaneous neural tangent kernel $\Theta(w(t))$ as in Eq. (5); then, we perform a frozen kernel dynamics using that instantaneous kernel, and we evaluate its performance on the test set. In Fig. 8 (c-d) we plot the test error of a network with $\alpha=1$ (referred to as “vanilla”) and compare it to the test error of the frozen kernel, both at initialization ($t=0$) and at the end of training. Quite remarkably $\tilde{f}_{w(t_{2})}$ achieves the full performance of $f$.

Appendix B Dynamics of the Weights

In Fig. 9 we plot the rescaled evolution of the parameters $\sqrt{h}|\!|w-w_{0}|\!|/|\!|w_{0}|\!|$ versus $\alpha$ (left) and versus $\sqrt{h}\alpha$ (right) showing that the curves collapse. We find:

[TABLE]

in the lazy-training regime. It is expected from Eq. (21), and the fact that the dynamics lasts ${\cal O}(1)$ in this regime, jointly implying that the ${\cal O}(h^{2})$ internal weights evolve by ${\cal O}(1/(h\alpha))$. Finally

[TABLE]

in the feature-training regime, where $b\approx 0.23$ is compatible with $1/(L+1)\approx 0.17$ as proposed in Section 6. Note that the denominator $\sqrt{h}$ is also expected from Section 6, where it corresponds to the term $|\!|w(t_{1})-w(0)|\!|$ entering in the definition of $\lambda$. It comes from the fact that $|\!|w(t_{1})-w(0)|\!|\sim\sqrt{h}$, as follows from the ${\cal O}(h^{2})$ internal weights evolving by ${\cal O}(1/\sqrt{h})$ on the time scale $t_{1}$, as can be deduced from Eq. (21).

Appendix C Dynamics of the Output function

To measure the amplitude of the output of a network $f$ we define its norm as follow

[TABLE]

In Section 6 we argued that the dynamics is linear for $t\ll t_{1}\sim\alpha\sqrt{h}$. Fig. 10 (a,c,d) confirms that the dynamics, characterized by $|\!|f(w_{t})-f(w_{0})|\!|$, is indeed linear on a time scale of order $t_{1}$, independently of the value of $\alpha$ as shown in Fig. 10 (a) or $h$ as shown in Fig. 10 (c,d).

Another important result of Section 6 is that at the end of the linear regime, the output has increased by a relative amount $\sim\sqrt{h}$. This result is confirmed in Fig. 10(b) showing that $\frac{1}{\sqrt{h}}|\!|f(w_{t})|\!|$ is independent of $h$ for $t\sim t_{1}$.

These two facts taken together imply:

[TABLE]

This prediction is confirmed in Fig. 10 (d) showing $\alpha|\!|f(w_{t})-f(w_{0})|\!|\sim t/t_{1}(\sqrt{h}\alpha)$ which must behave as $t/t_{1}$ if $(\sqrt{h}\alpha)$ is hold fixed, as is the case in this figure.

Appendix D Preactivation evolution

Fig. 11 shows the amplitude of $\dot{\tilde{z}}$ at initialization. We measured it using finite-difference method by applying a single gradient descent step.

Appendix E Shallow network

In order to verify the depth dependence of our heuristic predictions about the powerlaw in $\alpha$ of the quantities $|\!|\Theta-\Theta_{0}|\!|$ and $|\!|w-w_{0}|\!|$, we reran the experiment with 2 hidden layers ($L=2$) with the fully-connected network and Softplus. In Table 2 we summarize the exponent found numerically, they are compatible the our predictions.

Appendix F ReLU activation function

Fig. 12 shows the evolution of the kernel as a function of $\sqrt{h}\alpha$ for a network with ReLU activation function. Differently from the Softplus case (see Fig. 5 (a)), here we observe the existence of three regimes, each characterized by a different power law. The intermediate regime with slope $-1/2$ is not present for Softplus, and it is compatible with the following explanation. The ReLU function $x\mapsto\max(0,x)$ is non differentiable in $x=0$. It implies that $w\mapsto f(w)$ is not differentiable. For a finite dataset, $w\mapsto\{f(w,x_{\mu})\}_{\mu}$ is differentiable only on small patches. As we can see in Fig. 12 for large enough $\alpha$, $w$ evolution is so small that $f$ remains in a differentiable patch and we get the predicted result of slope $-1$. But for intermediate values of $\alpha$, the network change patches a number of times proportional to $\alpha^{-1}$ and assuming that each changes in the kernel induced by these changes of patch are not correlated, their sum scales with $\alpha^{-\nicefrac{{1}}{{2}}}$.

Appendix G Gradient flow verification

As we can see in Fig. 13, the constraint we put on the relative difference of gradients for the dynamics ensure that the relative difference of the output is smaller than $10^{-3}$ when the constraint is divided by 100. Also we see that the time of convergence is roughly doubled when the constraint is divided by 100.

Appendix H Variance and the size of the dataset in the lazy-training regime

In Fig. 14 the variance is shown as a function of the width, for different sizes of dataset $n$. (i) We see the variance reaching the asymptotic behavior of $h^{-1}$ when $n$ is small enough. (ii) The data also suggest that the variance grows with the size of the trainset like $\sqrt{n}$.

[TABLE]

Appendix I $f-f_{0}$ versus $f$

Fig. 15 shows the difference between the model $F(w,x)=\alpha f(w,x)$ and $F(w,x)=\alpha(f(w,x)-f(w_{0},x))$. Notice that removing the value of the output function at initialization drastically improves the performance of the network for large values of $\alpha$. The generalization error is the same for small $\alpha$.

Appendix J Effect of biases

In Fig. 16 we test the helpfulness of introducing biases in hidden layers, by comparing the test error and the variance of the output function in networks that have or have no biases. It turns out that biases are negligible in the present setting. The setup is described in Section 2. A possible reason to use biases would be that ReLU networks without biases are homogeneous functions. This mean that two data $x_{\mu},x_{\nu}$ that are aligned, in the sense that $x_{\mu}=|\lambda|x_{\nu}$, cannot have different labels. This problem can often be neglected for two reasons: first, in practice the datasets are normalized, so that two points are aligned only if they are identical; second, the pictures in some datasets typically have constant pixels. For instance, in MNIST the top-left pixel in every picture is black. Constant pixels behave effectively as a bias in any hidden neuron.