Error bounds for approximations with deep ReLU networks

Introduction

Recently, multiple successful applications of deep neural networks to pattern recognition problems (Schmidhuber , LeCun et al. ) have revived active interest in theoretical properties of such networks, in particular their expressive power. It has been argued that deep networks may be more expressive than shallow ones of comparable size (see, e.g., Delalleau and Bengio , Raghu et al. , Montufar et al. , Bianchini and Scarselli , Telgarsky ). In contrast to a shallow network, a deep one can be viewed as a long sequence of non-commutative transformations, which is a natural setting for high expressiveness (cf. the well-known Solovay-Kitaev theorem on fast approximation of arbitrary quantum operations by sequences of non-commutative gates, see Kitaev et al. , Dawson and Nielsen ).

There are various ways to characterize expressive power of networks. Delalleau and Bengio 2011 consider sum-product networks and prove for certain classes of polynomials that they are much more easily represented by deep networks than by shallow networks. Montufar et al. 2014 estimate the number of linear regions in the network’s landscape. Bianchini and Scarselli 2014 give bounds for Betti numbers characterizing topological properties of functions represented by networks. Telgarsky 2015, 2016 provides specific examples of classification problems where deep networks are provably more efficient than shallow ones.

In the context of classification problems, a general and standard approach to characterizing expressiveness is based on the notion of the Vapnik-Chervonenkis dimension (Vapnik and Chervonenkis ). There exist several bounds for VC-dimension of deep networks with piece-wise polynomial activation functions that go back to geometric techniques of Goldberg and Jerrum 1995 and earlier results of Warren 1968; see Bartlett et al. , Sakurai and the book Anthony and Bartlett . There is a related concept, the fat-shattering dimension, for real-valued approximation problems (Kearns and Schapire , Anthony and Bartlett ).

A very general approach to expressiveness in the context of approximation is the method of nonlinear widths by DeVore et al. 1989 that concerns approximation of a family of functions under assumption of a continuous dependence of the model on the approximated function.

In this paper we examine the problem of shallow-vs-deep expressiveness from the perspective of approximation theory and general spaces of functions having derivatives up to certain order (Sobolev-type spaces). In this framework, the problem of expressiveness is very well studied in the case of shallow networks with a single hidden layer, where it is known, in particular, that to approximate a $C^{n}$-function on a $d$-dimensional set with infinitesimal error $\epsilon$ one needs a network of size about $\epsilon^{-d/n}$, assuming a smooth activation function (see, e.g., Mhaskar , Pinkus for a number of related rigorous upper and lower bounds and further qualifications of this result). Much less seems to be known about deep networks in this setting, though Mhaskar et al. 2016, 2016 have recently introduced functional spaces constructed using deep dependency graphs and obtained expressiveness bounds for related deep networks.

We will focus our attention on networks with the ReLU activation function $\sigma(x)=\max(0,x)$, which, despite its utter simplicity, seems to be the most popular choice in practical applications LeCun et al. . We will consider $L^{\infty}$-error of approximation of functions belonging to the Sobolev spaces $\mathcal{W}^{n,\infty}(^{d})$ (without any assumptions of hierarchical structure). We will often consider families of approximations, as the approximated function runs over the unit ball $F_{d,n}$ in $\mathcal{W}^{n,\infty}(^{d})$. In such cases we will distinguish scenarios of fixed and adaptive network architectures. Our goal is to obtain lower and upper bounds on the expressiveness of deep and shallow networks in different scenarios. We measure complexity of networks in a conventional way, by counting the number of their weights and computation units (cf. Anthony and Bartlett ).

The main body of the paper consists of Sections 2, 3 and 4.

In Section 2 we describe our ReLU network model and show that the ReLU function is replaceable by any other continuous piece-wise linear activation function, up to constant factors in complexity asymptotics (Proposition 1).

In Section 3 we establish several upper bounds on the complexity of approximating by ReLU networks, in particular showing that deep networks are quite efficient for approximating smooth functions. Specifically:

In Subsection 3.1 we show that the function $f(x)=x^{2}$ can be $\epsilon$-approximated by a network of depth and complexity $O(\ln(1/\epsilon))$ (Proposition 2). This also leads to similar upper bounds on the depth and complexity that are sufficient to implement an approximate multiplication in a ReLU network (Proposition 3).

In Subsection 3.2 we describe a ReLU network architecture of depth $O(\ln(1/\epsilon))$ and complexity $O(\epsilon^{-d/n}\ln(1/\epsilon))$ that is capable of approximating with error $\epsilon$ any function from $F_{d,n}$ (Theorem 1).

In Subsection 3.3 we show that, even with fixed-depth networks, one can further decrease the approximation complexity if the network architecture is allowed to depend on the approximated function. Specifically, we prove that one can $\epsilon$-approximate a given Lipschitz function on the segment $$by a depth-6 ReLU network with$O(\frac{1}{\epsilon\ln(1/\epsilon)})$ connections and activation units (Theorem 2). This upper bound is of interest since it lies below the lower bound provided by the method of nonlinear widths under assumption of continuous model selection (see Subsection 4.1).

In Section 4 we obtain several lower bounds on the complexity of approximation by deep and shallow ReLU networks, using different approaches and assumptions.

In Subsection 4.1 we recall the general lower bound provided by the method of continuous nonlinear widths. This method assumes that parameters of the approximation continuously depend on the approximated function, but does not assume anything about how the approximation depends on its parameters. In this setup, at least $\sim\epsilon^{-d/n}$ connections and weights are required for an $\epsilon$-approximation on $F_{d,n}$ (Theorem 3). As already mentioned, for $d=n=1$ this lower bound is above the upper bound provided by Theorem 2.

In Subsection 4.2 we consider the setup where the same network architecture is used to approximate all functions in $F_{d,n}$, but the weights are not assumed to continuously depend on the function. In this case, application of existing results on VC-dimension of deep piece-wise polynomial networks yields a $\sim\epsilon^{d/(2n)}$ lower bound in general and a $\sim\epsilon^{-d/n}\ln^{-2p-1}(1/\epsilon)$ lower bound if the network depth grows as $O(\ln^{p}(1/\epsilon))$ (Theorem 4).

In Subsection 4.3 we consider an individual approximation, without any assumptions regarding it as an element of a family as in Subsections 4.1 and 4.2. We prove that for any $d,n$ there exists a function in $\mathcal{W}^{n,\infty}(^{d})$ such that its approximation complexity is not $o(\epsilon^{-d/(9n)})$ as $\epsilon\to 0$ (Theorem 5).

In Subsection 4.4 we prove that $\epsilon$-approximation of any nonlinear $C^{2}$-function by a network of fixed depth $L$ requires at least $\sim\epsilon^{-1/(2(L-2))}$ computation units (Theorem 6). By comparison with Theorem 1, this shows that for sufficiently smooth functions approximation by fixed-depth ReLU networks is less efficient than by unbounded-depth networks.

In Section 5 we discuss the obtained bounds and summarize their implications, in particular comparing deep vs. shallow networks and fixed vs. adaptive architectures.

The arXiv preprint of the first version of the present work appeared almost simultaneously with the work of Liang and Srikant Liang and Srikant containing results partly overlapping with our results in Subsections 3.1,3.2 and 4.4. Liang and Srikant consider networks equipped with both ReLU and threshold activation functions. They prove a logarithmic upper bound for the complexity of approximating the function $f(x)=x^{2}$, which is analogous to our Proposition 2. Then, they extend this upper bound to polynomials and smooth functions. In contrast to our treatment of generic smooth functions based on standard Sobolev spaces, they impose more complex assumptions on the function (including, in particular, how many derivatives it has) that depend on the required approximation accuracy $\epsilon$. As a consequence, they obtain strong $O(\ln^{c}(1/\epsilon))$ complexity bounds rather different from our bound in Theorem 1 (in fact, our lower bound proved in Theorem 5 rules out, in general, such strong upper bounds for functions having only finitely many derivatives). Also, Liang and Srikant prove a lower bound for the complexity of approximating convex functions by shallow networks. Our version of this result, given in Subsection 4.4, is different in that we assume smoothness and nonlinearity instead of global convexity.

The ReLU network model

Throughout the paper, we consider feedforward neural networks with the ReLU (Rectified Linear Unit) activation function

The network consists of several input units, one output unit, and a number of “hidden” computation units. Each hidden unit performs an operation of the form

with some weights (adjustable parameters) $(w_{k})_{k=1}^{N}$ and $b$ depending on the unit. The output unit is also a computation unit, but without the nonlinearity, i.e., it computes $y=\sum_{k=1}^{N}w_{k}x_{k}+b$. The units are grouped in layers, and the inputs $(x_{k})_{k=1}^{N}$ of a computation unit in a certain layer are outputs of some units belonging to any of the preceding layers (see Fig. 1). Note that we allow connections between units in non-neighboring layers. Occasionally, when this cannot cause confusion, we may denote the network and the function it implements by the same symbol.

The depth of the network, the number of units and the total number of weights are standard measures of network complexity (Anthony and Bartlett ). We will use these measures throughout the paper. The number of weights is, clearly, the sum of the total number of connections and the number of computation units. We identify the depth with the number of layers (in particular, the most common type of neural networks – shallow networks having a single hidden layer – are depth-3 networks according to this convention).

We finish this subsection with a proposition showing that, given our complexity measures, using the ReLU activation function is not much different from using any other piece-wise linear activation function with finitely many breakpoints: one can replace one network by an equivalent one but having another activation function while only increasing the number of units and weights by constant factors. This justifies our restricted attention to the ReLU networks (which could otherwise have been perceived as an excessively particular example of networks).

Let $\xi$ be a network with the activation function $\rho$, having depth $L$, $W$ weights and $U$ computation units. Then there exists a ReLU network $\eta$ that has depth $L$, not more than $(M+1)^{2}W$ weights and not more than $(M+1)U$ units, and that computes the same function as $\xi$.

a) Let $a_{1}<\ldots<a_{M}$ be the breakpoints of $\rho$, i.e., the points where its derivative is discontinuous: $\rho^{\prime}(a_{k}+)\neq\rho^{\prime}(a_{k}-)$. We can then express $\rho$ via the ReLU function $\sigma$, as a linear combination

with appropriately chosen coefficients $(c_{m})_{m=0}^{M}$ and $h$. It follows that computation performed by a single $\rho$-unit,

can be equivalently represented by a linear combination of a constant function and computations of $M+1$ $\sigma$-units,

(here $m$ is the index of a $\rho$-unit). We can then replace one-by-one all the $\rho$-units in the network $\xi$ by $\sigma$-units, without changing the output of the network. Obviously, these replacements do not change the network depth. Since each hidden unit gets replaced by $M+1$ new units, the number of units in the new network is not greater than $M+1$ times their number in the original network. Note also that the number of connections in the network is multiplied, at most, by $(M+1)^{2}$. Indeed, each unit replacement entails replacing each of the incoming and outgoing connections of this unit by $M+1$ new connections, and each connection is replaced twice: as an incoming and as an outgoing one. These considerations imply the claimed complexity bounds for the resulting $\sigma$-network $\eta$.

b) Let $a$ be any breakpoint of $\rho$, so that $\rho^{\prime}(a+)\neq\rho^{\prime}(a-)$. Let $r_{0}$ be the distance separating $a$ from the nearest other breakpoint, so that $\rho$ is linear on $[a,a+r_{0}]$ and on $[a-r_{0},a]$ (if $\rho$ has only one node, any $r_{0}>0$ will do). Then, for any $r>0$, we can express the ReLU function $\sigma$ via $\rho$ in the $r$-neighborhood of 0:

It follows that a computation performed by a single $\sigma$-unit,

can be equivalently represented by a linear combination of a constant function and two $\rho$-units,

holds. Since $\mathcal{D}$ is a bounded set, we can choose $r$ at each unit of the initial network $\eta$ sufficiently large so as to satisfy condition (2) for all network inputs from $\mathcal{D}$. Then, like in a), we replace each $\sigma$-unit with two $\rho$-units, which produces the desired $\rho$-network. ∎

Upper bounds

Our first key result shows that ReLU networks with unconstrained depth can very efficiently approximate the function $f(x)=x^{2}$ (more efficiently than any fixed-depth network, as we will see in Section 4.4). Our construction uses the “sawtooth” function that has previously appeared in the paper Telgarsky .

The function $f(x)=x^{2}$ on the segment $$can be approximated with any error$\epsilon>0$by a ReLU network having the depth and the number of weights and computation units$O(\ln(1/\epsilon))$.

Consider the “tooth” (or “mirror”) function $g:\to,$

Telgarsky has shown (see Lemma 2.4 in Telgarsky ) that $g_{s}$ is a “sawtooth” function with $2^{s-1}$ uniformly distributed “teeth” (each application of $g$ doubles the number of teeth):

(see Fig. 2(a)). Our key observation now is that the function $f(x)=x^{2}$ can be approximated by linear combinations of the functions $g_{s}$. Namely, let $f_{m}$ be the piece-wise linear interpolation of $f$ with $2^{m}+1$ uniformly distributed breakpoints $\frac{k}{2^{m}},k=0,\ldots,2^{m}$:

(see Fig. 2(b)). The function $f_{m}$ approximates $f$ with the error $\epsilon_{m}=2^{-2m-2}$. Now note that refining the interpolation from $f_{m-1}$ to $f_{m}$ amounts to adjusting it by a function proportional to a sawtooth function:

Since $g$ can be implemented by a finite ReLU network (as g(x)=2\sigma(x)-4\sigma\big{(}x-\frac{1}{2}\big{)}+2\sigma(x-1)) and since construction of $f_{m}$ only involves $O(m)$ linear operations and compositions of $g$, we can implement $f_{m}$ by a ReLU network having depth and the number of weights and computation units all being $O(m)$ (see Fig. 2(c)). This implies the claim of the proposition.

we can use Proposition 2 to efficiently implement accurate multiplication in a ReLU network. The implementation will depend on the required accuracy and the magnitude of the multiplied quantities.

for any inputs $x,y$, if $|x|\leq M$ and $|y|\leq M,$ then $|\widetilde{\times}(x,y)-xy|\leq\epsilon$;

if $x=0$ or $y=0$, then $\widetilde{\times}(x,y)=0$;

the depth and the number of weights and computation units in $\eta$ is not greater than $c_{1}\ln(1/\epsilon)+c_{2}$ with an absolute constant $c_{1}$ and a constant $c_{2}=c_{2}(M)$.

2 Fast deep approximation of general smooth functions

In order to formulate our general result, Theorem 1, we consider the Sobolev spaces $\mathcal{W}^{n,\infty}(^{d})$ with $n=1,2,\ldots$ Recall that $\mathcal{W}^{n,\infty}(^{d})$ is defined as the space of functions on $^{d}$ lying in $L^{\infty}$ along with their weak derivatives up to order $n$. The norm in $\mathcal{W}^{n,\infty}(^{d})$ can be defined by

where $\mathbf{n}=(n_{1},\ldots,n_{d})\in\{0,1,\ldots\}^{d}$, $|\mathbf{n}|=n_{1}+\ldots+n_{d}$, and $D^{\mathbf{n}}f$ is the respective weak derivative. Here and in the sequel we denote vectors by boldface characters. The space $\mathcal{W}^{n,\infty}(^{d})$ can be equivalently described as consisting of the functions from $C^{n-1}(^{d})$ such that all their derivatives of order $n-1$ are Lipschitz continuous.

Throughout the paper, we denote by $F_{n,d}$ the unit ball in $\mathcal{W}^{n,\infty}(^{d})$:

Also, it will now be convenient to make a distinction between networks and network architectures: we define the latter as the former with unspecified weights. We say that a network architecture is capable of expressing any function from $F_{d,n}$ with error $\epsilon$ meaning that this can be achieved by some weight assignment.

For any $d,n$ and $\epsilon\in(0,1)$, there is a ReLU network architecture that

is capable of expressing any function from $F_{d,n}$ with error $\epsilon$;

has the depth at most $c(\ln(1/\epsilon)+1)$ and at most $c\epsilon^{-d/n}(\ln(1/\epsilon)+1)$ weights and computation units, with some constant $c=c(d,n)$.

The proof will consist of two steps. We start with approximating $f$ by a sum-product combination $f_{1}$ of local Taylor polynomials and one-dimensional piecewise-linear functions. After that, we will use results of the previous section to approximate $f_{1}$ by a neural network.

Let $N$ be a positive integer. Consider a partition of unity formed by a grid of $(N+1)^{d}$ functions $\phi_{\mathbf{m}}$ on the domain $^{d}$:

Here $\mathbf{m}=(m_{1},\ldots,m_{d})\in\{0,1,\ldots,N\}^{d},$ and the function $\phi_{\mathbf{m}}$ is defined as the product

For any $\mathbf{m}\in\{0,\ldots,N\}^{d}$, consider the degree-$(n-1)$ Taylor polynomial for the function $f$ at $\mathbf{x}=\frac{\mathbf{m}}{N}$:

with the usual conventions $\mathbf{n}!=\prod_{k=1}^{d}n_{k}!$ and $(\mathbf{x}-\frac{\mathbf{m}}{N})^{\mathbf{n}}=\prod_{k=1}^{d}(x_{k}-\frac{m_{k}}{N})^{n_{k}}$. Now define an approximation to $f$ by

We bound the approximation error using the Taylor expansion of $f$:

Here in the second step we used the support property (7) and the bound (6), in the third the observation that any $\mathbf{x}\in^{d}$ belongs to the support of at most $2^{d}$ functions $\phi_{\mathbf{m}}$, in the fourth a standard bound for the Taylor remainder, and in the fifth the property $\|f\|_{\mathcal{W}^{n,\infty}(^{d})}\leq 1.$

(where $\lceil\cdot\rceil$ is the ceiling function), then

Note that, by (8) the coefficients of the polynomials $P_{\mathbf{m}}$ are uniformly bounded for all $f\in F_{d,n}$:

We have therefore reduced our task to the following: construct a network architecture capable of approximating with uniform error $\frac{\epsilon}{2}$ any function of the form (9), assuming that $N$ is given by (10) and the polynomials $P_{\mathbf{m}}$ are of the form (12).

The expansion is a linear combination of not more than $d^{n}(N+1)^{d}$ terms $\mathbf{\phi}_{\mathbf{m}}(\mathbf{x})(\mathbf{x}-\frac{\mathbf{m}}{N})^{\mathbf{n}}$. Each of these terms is a product of at most $d+n-1$ piece-wise linear univariate factors: $d$ functions $\psi(3Nx_{k}-3m_{k})$ (see (5)) and at most $n-1$ linear expressions $x_{k}-\frac{m_{k}}{N}$. We can implement an approximation of this product by a neural network with the help of Proposition 3. Specifically, let $\widetilde{\times}$ be the approximate multiplication from Proposition 3 for $M=d+n$ and some accuracy $\delta$ to be chosen later, and consider the approximation of the product $\mathbf{\phi}_{\mathbf{m}}(\mathbf{x})(\mathbf{x}-\frac{\mathbf{m}}{N})^{\mathbf{n}}$ obtained by the chained application of $\widetilde{\times}$:

that Using statement c) of Proposition 3, we see $\widetilde{f}_{\mathbf{m},\mathbf{n}}$ can be implemented by a ReLU network with the depth and the number of weights and computation units not larger than $(d+n)c_{1}\ln(1/\delta),$ for some constant $c_{1}=c_{1}(d,n)$.

Now we estimate the error of this approximation. Note that we have $|\psi(3Nx_{k}-3m_{k})|\leq 1$ and $|x_{k}-\frac{m_{k}}{N}|\leq 1$ for all $k$ and all $\mathbf{x}\in^{d}$. By statement a) of Proposition 3, if $|a|\leq 1$ and $|b|\leq M$, then $|\widetilde{\times}(a,b)|\leq|b|+\delta$. Repeatedly applying this observation to all approximate multiplications in (14) while assuming $\delta<1$, we see that the arguments of all these multiplications are bounded by our $M$ (equal to $d+n$) and the statement a) of Proposition 3 holds for each of them. We then have

Moreover, by statement b) of Proposition 3,

We estimate the approximation error of $\widetilde{f}$:

where in the first step we use expansion (13), in the second the identity (16), in the third the bound $|a_{\mathbf{m},\mathbf{n}}|\leq 1$ and the fact that $\mathbf{x}\in\operatorname{supp}\phi_{\mathbf{m}}$ for at most $2^{d}$ functions $\phi_{\mathbf{m}},$ and in the fourth the bound (15). It follows that if we choose

then $\|\widetilde{f}-f_{1}\|_{\infty}\leq\frac{\epsilon}{2}$ and hence, by (11),

On the other hand, note that by (17), $\widetilde{f}$ can be implemented by a network consisting of parallel subnetworks that compute each of $\widetilde{f}_{\mathbf{m},\mathbf{n}}$; the final output is obtained by weighting the outputs of the subnetworks with the weights $a_{\mathbf{m},\mathbf{n}}$. The architecture of the full network does not depend on $f$; only the weights $a_{\mathbf{m},\mathbf{n}}$ do. As already shown, each of these subnetworks has not more than $c_{1}\ln(1/\delta)$ layers, weights and computation units, with some constant $c_{1}=c_{1}(d,n)$. There are not more than $d^{n}(N+1)^{d}$ such subnetworks. Therefore, the full network for $\widetilde{f}$ has not more than $c_{1}\ln(1/\delta)+1$ layers and $d^{n}(N+1)^{d}(c_{1}\ln(1/\delta)+1)$ weights and computation units. With $\delta$ given by (18) and $N$ given by (10), we obtain the claimed complexity bounds. ∎

3 Faster approximations using adaptive network architectures

Theorem 1 provides an upper bound for the approximation complexity in the case when the same network architecture is used to approximate all functions in $F_{d,n}$. We can consider an alternative, “adaptive architecture” scenario where not only the weights, but also the architecture is adjusted to the approximated function. We expect, of course, that this would decrease the complexity of the resulting architectures, in general (at the price of needing to find the appropriate architecture). In this section we show that we can indeed obtain better upper bounds in this scenario.

For simplicity, we will only consider the case $d=n=1$. Then, $\mathcal{W}^{n,\infty}(^{d})$ is the space of Lipschitz functions on the segment $$. The set$F_{1,1}$consists of functions$f$having both$\|f\|_{\infty}$and the Lipschitz constant bounded by 1. Theorem 1 provides an upper bound$O(\frac{\ln(1/\epsilon)}{\epsilon})$for the number of weights and computation units, but in this special case there is in fact a better bound$O(\frac{1}{\epsilon})$ obtained simply by piece-wise interpolation.

Namely, given $f\in F_{1,1}$ and $\epsilon>0$, set $T=\lceil\frac{1}{\epsilon}\rceil$ and let $\widetilde{f}$ be the piece-wise interpolation of $f$ with $T+1$ uniformly spaced breakpoints $(\frac{t}{T})_{t=0}^{T}$ (i.e., $\widetilde{f}(\frac{t}{T})=f(\frac{t}{T}),t=0,\ldots,T$). The function $\widetilde{f}$ is also Lipschitz with constant 1 and hence $\|f-\widetilde{f}\|_{\infty}\leq\frac{1}{T}\leq\epsilon$ (since for any $x\in$ we can find $t$ such that $|x-\frac{t}{T}|\leq\frac{1}{2T}$ and then $|f(x)-\widetilde{f}(x)|\leq|f(x)-f(\frac{t}{T})|+|\widetilde{f}(\frac{t}{T})-\widetilde{f}(x)|\leq 2\cdot\frac{1}{2T}=\frac{1}{T}$). At the same time, the function $\widetilde{f}$ can be expressed in terms of the ReLU function $\sigma$ by

with some coefficients $b$ and $(w_{t})_{t=0}^{T-1}$. This expression can be viewed as a special case of the depth-3 ReLU network with $O(\frac{1}{\epsilon})$ weights and computation units.

We show now how the bound $O(\frac{1}{\epsilon})$ can be improved by using adaptive architectures.

For any $f\in F_{1,1}$ and $\epsilon\in(0,\frac{1}{2})$, there exists a depth-6 ReLU network $\eta$ (with architecture depending on $f$) that provides an $\epsilon$-approximation of $f$ while having not more than $\frac{c}{\epsilon\ln(1/\epsilon)}$ weights, connections and computation units. Here $c$ is an absolute constant.

We first explain the idea of the proof. We start with interpolating $f$ by a piece-wise linear function, but not on the length scale $\epsilon$ – instead, we do it on a coarser length scale $m\epsilon$, with some $m=m(\epsilon)>1$. We then create a “cache” of auxiliary subnetworks that we use to fill in the details and go down to the scale $\epsilon$, in each of the $m\epsilon$-subintervals. This allows us to reduce the amount of computations for small $\epsilon$ because the complexity of the cache only depends on $m$. The assignment of cached subnetworks to the subintervals is encoded in the network architecture and depends on the function $f$. We optimize $m$ by balancing the complexity of the cache with that of the initial coarse approximation. This leads to $m\sim\ln(1/\epsilon)$ and hence to the reduction of the total complexity of the network by a factor $\sim\ln(1/\epsilon)$ compared to the simple piece-wise linear approximation on the scale $\epsilon$. This construction is inspired by a similar argument used to prove the $O(2^{n}/n)$ upper bound for the complexity of Boolean circuits implementing $n$-ary functions Shannon .

The proof becomes simpler if, in addition to the ReLU function $\sigma$, we are allowed to use the activation function

in our neural network. Since $\rho$ is discontinuous, we cannot just use Proposition 1 to replace $\rho$-units by $\sigma$-units. We will first prove the analog of the claimed result for the model including $\rho$-units, and then we will show how to construct a purely ReLU nework.

For any $f\in F_{1,1}$ and $\epsilon\in(0,\frac{1}{2})$, there exists a depth-5 network including $\sigma$-units and $\rho$-units, that provides an $\epsilon$-approximation of $f$ while having not more than $\frac{c}{\epsilon\ln(1/\epsilon)}$ weights, where $c$ is an absolute constant.

Given $f\in F_{1,1}$, we will construct an approximation $\widetilde{f}$ to $f$ in the form

Here, $\widetilde{f}_{1}$ is the piece-wise linear interpolation of $f$ with the breakpoints $\{\frac{t}{T}\}_{t=0}^{T}$, for some positive integer $T$ to be chosen later. Since $f$ is Lipschitz with constant 1, $\widetilde{f}_{1}$ is also Lipschitz with constant 1. We will denote by $I_{t}$ the intervals between the breakpoints:

We will now construct $\widetilde{f}_{2}$ as an approximation to the difference

Note that $f_{2}$ vanishes at the endpoints of the intervals $I_{t}$:

and $f_{2}$ is Lipschitz with constant 2:

since $f$ and $\widetilde{f}_{1}$ are Lipschitz with constant 1.

Note that the size $|\Gamma|$ of $\Gamma$ is not larger than $3^{m}$.

Moreover, if $f_{2}$ is defined by (20), then, using (21), (22), on each interval $I_{t}$ the function $f_{2}$ can be approximated with error not larger than $\frac{2}{Tm}$ by a properly rescaled function $\gamma\in\Gamma$. Namely, for each $t=0,\ldots,T-1$ we can define the function $g$ by $g(y)=Tf_{2}(\frac{t+y}{T})$. Then it is Lipschitz with constant 2 and $g(0)=g(1)=0$, so we can find $\gamma_{t}\in\Gamma$ such that

Note that the obtained assignment $t\mapsto\gamma_{t}$ is not injective, in general ($T$ will be much larger than $|\Gamma|$).

We can then define $\widetilde{f}_{2}$ on the whole $[0,1)$ by

This $\widetilde{f}_{2}$ approximates $f_{2}$ with error $\frac{2}{Tm}$ on $[0,1)$:

and hence, by (20), for the full approximation $\widetilde{f}=\widetilde{f}_{1}+\widetilde{f}_{2}$ we will also have

Note that the approximation $\widetilde{f}_{2}$ has properties analogous to (21), (22):

in particular, $\widetilde{f}_{2}$ is continuous on $[0,1)$.

We will now rewrite $\widetilde{f}_{2}$ in a different form interpretable as a computation by a neural network. Specifically, using our additional activation function $\rho$ given by (19), we can express $\widetilde{f}_{2}$ as

Indeed, given $x\in[0,1)$, observe that all the terms in the inner sum vanish except for the one corresponding to the $t$ determined by the condition $x\in I_{t}$. For this particular $t$ we have $\rho(Tx-t)=Tx-t$. Since $\gamma(0)=0$, we conclude that (28) agrees with (23).

Let us also expand $\gamma\in\Gamma$ over the basis of shifted ReLU functions:

Substituting this expansion in (28), we finally obtain

The first layer contains the single input unit $Q^{(1)}$.

The second layer contains $T$ units $(Q^{(2)}_{t})_{t=1}^{T}$ computing $Q^{(2)}_{t}=\rho(TQ^{(1)}-t).$

The third layer contains $|\Gamma|$ units $(Q^{(3)}_{\gamma})_{\gamma\in\Gamma}$ computing $Q^{(3)}_{\gamma}=\sigma(\sum_{t:\gamma_{t}=\gamma}Q^{(2)}_{t})$. This is equivalent to $Q^{(3)}_{\gamma}=\sum_{t:\gamma_{t}=\gamma}Q^{(2)}_{t}$, because $Q^{(2)}_{t}\geq 0$.

The fourth layer contains $m|\Gamma|$ units $(Q^{(4)}_{\gamma,r})_{\stackrel{{\scriptstyle\gamma\in\Gamma}}{{r=0,\ldots,m-1}}}$ computing $Q^{(4)}_{\gamma,r}=\sigma(Q^{(3)}_{\gamma}-\frac{r}{m}).$

The final layer consists of a single output unit $Q^{(5)}=\sum_{\gamma\in\Gamma}\sum_{r=0}^{m-1}\frac{c_{\gamma,r}}{T}Q^{(4)}_{\gamma,r}.$

Examining this network, we see that the total number of connections and units in it is $O(T+m|\Gamma|)$ and hence is $O(T+m3^{m})$. This also holds for the full network implementing $\widetilde{f}=\widetilde{f}_{1}+\widetilde{f}_{2}$, since the term $\widetilde{f}_{1}$ requires even fewer layers, connections and units. The output units of the subnetworks for $\widetilde{f}_{1}$ and $\widetilde{f}_{2}$ can be merged into the output unit for $\widetilde{f}_{1}+\widetilde{f}_{2}$, so the depth of the full network is the maximum of the depths of the networks implementing $\widetilde{f}_{1}$ and $\widetilde{f}_{2}$, i.e., is 5 (see Fig. 4).

Now, given $\epsilon\in(0,\frac{1}{2})$, take $m=\lceil\frac{1}{2}\log_{3}(1/\epsilon)\rceil$ and $T=\lceil\frac{2}{m\epsilon}\rceil.$ Then, by (25), the approximation error $\max_{x\in}|f(x)-\widetilde{f}(x)|\leq\frac{2}{Tm}\leq\epsilon$, while $T+m3^{m}=O(\frac{1}{\epsilon\ln(1/\epsilon)})$, which implies the claimed complexity bound. ∎

We show now how to modify the constructed network so as to remove $\rho$-units. We only need to modify the $\widetilde{f}_{2}$ part of the network. We will show that for any $\delta>0$ we can replace $\widetilde{f}_{2}$ with a function $\widetilde{f}_{3,\delta}$ (defined below) that

obeys the following analog of approximation bound (24):

and is implementable by a depth-6 ReLU network having complexity $c(T+m3^{m})$ with an absolute constant $c$ independent of $\delta$.

Since $\delta$ can be taken arbitrarily small, the Theorem then follows by arguing as in Lemma 1, only with $\widetilde{f}_{2}$ replaced by $\widetilde{f}_{3,\delta}$.

As a first step, we approximate $\rho$ by a continuous piece-wise linear function $\rho_{\delta}$, with a small $\delta>0$:

Let $\widetilde{f}_{2,\delta}$ be defined as $\widetilde{f}_{2}$ in (29), but with $\rho$ replaced by $\rho_{\delta}$:

Since $\rho_{\delta}$ is a continuous piece-wise linear function with three breakpoints, we can express it via the ReLU function, and hence implement $\widetilde{f}_{2,\delta}$ by a purely ReLU network, as in Proposition 1, and the complexity of the implementation does not depend on $\delta$. However, replacing $\rho$ with $\rho_{\delta}$ affects the function $\widetilde{f}_{2}$ on the intervals $(\frac{t-\delta}{T},\frac{t}{T}],t=1,\ldots,T$, introducing there a large error (of magnitude $O(\frac{1}{T})$). But recall that both $f_{2}$ and $\widetilde{f}_{2}$ vanish at the points $\frac{t}{T},t=0,\ldots,T,$ by (21), (26). We can then largely remove this newly introduced error by simply suppressing $\widetilde{f}_{2,\delta}$ near the points $\frac{t}{T}$.

Precisely, consider the continuous piece-wise linear function

and the full comb-like filtering function

Note that $\Phi_{\delta}$ is continuous piece-wise linear with $4T$ breakpoints, and $0\leq\Phi_{\delta}(x)\leq 1$. We then define our final modification of $\widetilde{f}_{2}$ as

The function $\widetilde{f}_{3,\delta}$ obeys the bound (30).

Given $x\in[0,1)$, let $t\in\{0,\ldots,T-1\}$ and $y\in[0,1)$ be determined from the representation $x=\frac{t+y}{T}$ (i.e., $y$ is the relative position of $x$ in the respective interval $I_{t}$). Consider several possibilities for $y$:

$y\in[1-\delta,1]$. In this case $\Phi_{\delta}(x)=0$. Note that

because, by construction, $\sup_{x\in}|\widetilde{f}_{2,\delta}(x)|\leq\sup_{x\in}|\widetilde{f}_{2}(x)|$, and $\sup_{x\in}|\widetilde{f}_{2}(x)|\leq 1$ by (26), (27). It follows that both terms in (31) vanish, i.e., $\widetilde{f}_{3,\delta}(x)=0$. But, since $f_{2}$ is Lipschitz with constant 2 by (22) and $f_{2}(\frac{t+1}{T})=0$, we have $|f_{2}(x)|\leq|f_{2}(x)-f_{2}(\frac{t+1}{T})|\leq\frac{2|y-1|}{T}\leq\frac{2\delta}{T}$. This implies $|f_{2}(x)-\widetilde{f}_{3,\delta}(x)|\leq\frac{2\delta}{T}$.

$y\in[\delta,1-2\delta]$. In this case $\Phi_{\delta}(x)=1$ and $\widetilde{f}_{2,\delta}(x)=\widetilde{f}_{2}(x)$. Using (32), we find that $\widetilde{f}_{3,\delta}(x)=\widetilde{f}_{2,\delta}(x)=\widetilde{f}_{2}(x)$. It follows that $|f_{2}(x)-\widetilde{f}_{3,\delta}(x)|=|f_{2}(x)-\widetilde{f}_{2}(x)|\leq\frac{2}{Tm}$.

$y\in[0,\delta]\cup[1-2\delta,1-\delta]$. In this case $\widetilde{f}_{2,\delta}(x)=\widetilde{f}_{2}(x)$. Since $\sigma$ is Lipschitz with constant 1, $|\widetilde{f}_{3,\delta}(x)|\leq|\widetilde{f}_{2,\delta}(x)|=|\widetilde{f}_{2}(x)|$. Both $f_{2}$ and $\widetilde{f}_{2}$ are Lipschitz with constant 2 (by (22), (27)) and vanish at $\frac{t}{T}$ and $\frac{t+1}{T}$ (by (21), (26)). It follows that

It remains to verify the complexity property b) of the function $\widetilde{f}_{3,\delta}$. As already mentioned, $\widetilde{f}_{2,\delta}$ can be implemented by a depth-5 purely ReLU network with not more than $c(T+m3^{m})$ weights, connections and computation units, where $c$ is an absolute constant independent of $\delta$. The function $\Phi_{\delta}$ can be implemented by a shallow, depth-3 network with $O(T)$ units and connection. Then, computation of $\widetilde{f}_{3,\delta}$ can be implemented by a network including two subnetworks for computing $\widetilde{f}_{2,\delta}$ and $\Psi_{\delta}$, and an additional layer containing two $\sigma$-units as written in (31). We thus obtain 6 layers in the resulting full network and, choosing $T$ and $m$ in the same way as in Lemma 1, obtain the bound $\frac{c}{\epsilon\ln(1/\epsilon)}$ for the number of its connections, weights, and computation units. ∎

Lower bounds

The method of continuous nonlinear widths (DeVore et al. ) is a very general approach to the analysis of parameterized nonlinear approximations, based on the assumption of continuous selection of their parameters. We are interested in the following lower bound for the complexity of approximations in $\mathcal{W}^{n,\infty}(^{d}).$

The hypothesis of continuous weight selection is crucial in Theorem 3. By examining our proof of the counterpart upper bound $O(\epsilon^{-d/n}\ln(1/\epsilon))$ in Theorem 1, the weights are selected there in a continuous manner, so this upper bound asymptotically lies above $c\epsilon^{-d/n}$ in agreement with Theorem 3. We remark, however, that the optimal choice of the network weights (minimizing the error) is known to be discontinuous in general, even for shallow networks (Kainen et al. ).

We also compare the bounds of Theorems 3 and 2. In the case $d=n=1$, Theorem 3 provides a lower bound $\frac{c}{\epsilon}$ for the number of weights and connections. On the other hand, in the adaptive architecture scenario, Theorem 2 provides the upper bound $\frac{c}{\epsilon\ln(1/\epsilon)}$ for the number of weights, connections and computation units. The fact that this latter bound is asymptotically below the bound of Theorem 3 reflects the extra expressiveness associated with variable network architecture.

2 Bounds based on VC-dimension

In this section we consider the setup where the same network architecture is used to approximate all functions $f\in F_{d,n}$, but the dependence of the weights on $f$ is not assumed to be necessarily continuous. In this setup, some lower bounds on the network complexity can be obtained as a consequence of existing upper bounds on VC-dimension of networks with piece-wise polynomial activation functions and Boolean outputs (Anthony and Bartlett ). In the next theorem, part a) is a more general but weaker bound, while part b) is a stronger bound assuming a constrained growth of the network depth.

For any $\epsilon\in(0,1)$, a ReLU network architecture capable of approximating any function $f\in F_{d,n}$ with error $\epsilon$ must have at least $c\epsilon^{-d/(2n)}$ weights, with some constant $c=c(d,n)>0$.

Let $p\geq 0,c_{1}>0$ be some constants. For any $\epsilon\in(0,\frac{1}{2})$, if a ReLU network architecture of depth $L\leq c_{1}\ln^{p}(1/\epsilon)$ is capable of approximating any function $f\in F_{d,n}$ with error $\epsilon$, then the network must have at least $c_{2}\epsilon^{-d/n}\ln^{-2p-1}(1/\epsilon)$ weights, with some constant $c_{2}=c_{2}(d,n,p,c_{1})>0$.The author thanks Matus Telgarsky for suggesting this part of the theorem.

where $W$ is the number of weights, $L$ is the network depth, and $c_{3}$ is an absolute constant.

Let us obtain a condition ensuring that such $f\in F_{d,n}$. For any multi-index $\mathbf{n}$,

with the constant $c_{4}=(\max_{\mathbf{n}:|\mathbf{n}|\leq n}\max_{\mathbf{x}}|D^{\mathbf{n}}\phi(\mathbf{x})|)^{-1}$, then $f\in F_{d,n}$.

Suppose that there is a ReLU network architecture $\eta$ that can approximate, by adjusting its weights, any $f\in F_{d,n}$ with error less than $\epsilon$. Denote by $\eta(\mathbf{x},\mathbf{w})$ the output of the network for the input vector $\mathbf{x}$ and the vector of weights $\mathbf{w}$.

Consider any assignment $\mathbf{z}$ of Boolean values $z_{1},\ldots,z_{N^{d}}\in\{0,1\}$. Set

and let $f$ be given by (35) (see Fig. 5); then (36) holds and hence $f\in F_{d,n}$.

By assumption, there is then a vector of weights, $\mathbf{w}=\mathbf{w}_{\mathbf{z}}$, such that for all $m$ we have $|\eta(\mathbf{x}_{m},\mathbf{w}_{\mathbf{z}})-y_{m}|\leq\epsilon,$ and in particular

Since the Boolean values $z_{m}$ were arbitrary, we conclude that the subset $S$ is shattered and hence

Expressing $N$ through $\epsilon$ with (37), we obtain

To establish part a) of the Theorem, we apply bound (33) to the network $\eta_{1}$:

where $W$ is the number of weights in $\eta_{1}$, which is the same as in $\eta$ if we do not count the threshold parameter. Combining (38) with (39), we obtain the desired lower bound $W\geq c\epsilon^{-d/(2n)}$ with $c=(c_{4}/3)^{d/(2n)}c_{3}^{-1/2}$.

To establish part b) of the Theorem, we use bound (34) and the hypothesis $L\leq c_{1}\ln^{p}(1/\epsilon)$:

Trying a $W$ of the form $W_{c_{2}}=c_{2}\epsilon^{-d/n}\ln^{-2p-1}(1/\epsilon)$ with a constant $c_{2}$, we get

Comparing this with (41), we see that if we choose $c_{2}<(c_{4}/3)^{d/n}n/(dc_{3}c_{1}^{2})$, then for sufficiently small $\epsilon$ we have $W\ln W\geq W_{c_{2}}\ln W_{c_{2}}$ and hence $W\geq W_{c_{2}}$, as claimed. We can ensure that $W\geq W_{c_{2}}$ for all $\epsilon\in(0,\frac{1}{2})$ by further decreasing $c_{2}$. ∎

We remark that the constrained depth hypothesis of part b) is satisfied, with $p=1$, by the architecture used for the upper bound in Theorem 1. The bound stated in part b) of Theorem 4 matches the upper bound of Theorem 1 and the lower bound of Theorem 3 up to a power of $\ln(1/\epsilon)$.

3 Adaptive network architectures

Our goal in this section is to obtain a lower bound for the approximation complexity in the scenario where the network architecture may depend on the approximated function. This lower bound is thus a counterpart to the upper bound of Section 3.3.

To state this result we define the complexity $\mathcal{N}(f,\epsilon)$ of approximating the function $f$ with error $\epsilon$ as the minimal number of hidden computation units in a ReLU network that provides such an approximation.

For any $d,n$, there exists $f\in\mathcal{W}^{n,\infty}(^{d})$ such that $\mathcal{N}(f,\epsilon)$ is not $o(\epsilon^{-d/(9n)})$ as $\epsilon\to 0$.

Fix $d,n$. For any sufficiently small $\epsilon>0$ there exists $f_{\epsilon}\in F_{d,n}$ such that $\mathcal{N}(f_{\epsilon},\epsilon)\geq c_{1}\epsilon^{-d/(8n)}$, with some constant $c_{1}=c_{1}(d,n)>0$.

Observe that all the networks with not more than $m$ hidden computation units can be embedded in the single “enveloping” network that has $m$ hidden layers, each consisting of $m$ units, and that includes all the connections between units not in the same layer (see Fig. 6(a)). The number of weights in this enveloping network is $O(m^{4})$. On the other hand, Theorem 4a) states that at least $c\epsilon^{-d/(2n)}$ weights are needed for an architecture capable of $\epsilon$-approximating any function in $F_{d,n}$. It follows that there is a function $f_{\epsilon}\in F_{d,n}$ that cannot be $\epsilon$-approximated by networks with fewer than $c_{1}\epsilon^{-d/(8n)}$ computation units. ∎

Before proceeding to the proof of Theorem 5, note that $\mathcal{N}(f,\epsilon)$ is a monotone decreasing function of $\epsilon$ with a few obvious properties:

(follows by multiplying the weights of the output unit of the approximating network by a constant);

(follows by approximating $f\pm g$ by an approximation of $f$);

(follows by combining approximating networks for $f_{1}$ and $f_{2}$ as in Fig. 6(b)).

The claim of Theorem 5 is similar to the claim of Lemma 3, but is about a single function $f$ satisfying a slightly weaker complexity bound at multiple values of $\epsilon\to 0$. We will assume that Theorem 5 is false, i.e.,

for all $f\in\mathcal{W}^{n,\infty}(^{d}),$ and we will reach contradiction by presenting $f$ violating this assumption. Specifically, we construct this $f$ as

We determine $a_{k},f_{k},\epsilon_{k}$ sequentially. Suppose we have already found $\{a_{s},f_{s},\epsilon_{s}\}_{s=1}^{k-1}$; let us describe how we define $a_{k},f_{k},\epsilon_{k}$.

so that the function $f$ defined by the series (46) will be in $\mathcal{W}^{n,\infty}(^{d})$, because $\|f_{k}\|_{\mathcal{W}^{n,\infty}(^{d})}\leq 1$.

Next, using Lemma 3 and Eq. (42), observe that if $\epsilon_{k}$ is sufficiently small, then we can find $f_{k}\in F_{d,n}$ such that

In addition, by assumption (45), if $\epsilon_{k}$ is small enough then

Let us choose $\epsilon_{k}$ and $f_{k}$ so that both (49) and (50) hold. Obviously, we can also make sure that $\epsilon_{k}\to 0$ as $k\to\infty$.

Let us check that the above choice of $\{a_{k},f_{k},\epsilon_{k}\}_{k=1}^{\infty}$ ensures that inequality (47) holds for all $k$:

Here in the first step we use inequality (43), in the second the monotonicity of $\mathcal{N}(f,\epsilon)$, in the third the monotonicity of $\mathcal{N}(f,\epsilon)$ and the setting (48), in the fourth the inequality (44), and in the fifth the conditions (49) and (50). ∎

4 Slow approximation of smooth functions by shallow networks

In this section we show that, in contrast to deep ReLU networks, shallow ReLU networks relatively inefficiently approximate sufficiently smooth ($C^{2}$) nonlinear functions. We remark that Liang and Srikant 2016 prove a similar result assuming global convexity instead of smoothness and nonlinearity.

Let $f\in C^{2}(^{d})$ be a nonlinear function (i.e., not of the form $f(x_{1},\ldots,x_{d})\equiv a_{0}+\sum_{k=1}^{d}a_{k}x_{k}$ on the whole $^{d}$). Then, for any fixed $L$, a depth-$L$ ReLU network approximating $f$ with error $\epsilon\in(0,1)$ must have at least $c\epsilon^{-1/(2(L-2))}$ weights and computation units, with some constant $c=c(f,L)>0.$

Suppose that $\widetilde{f}$ is an $\epsilon$-approximation of function $f$, and let $\widetilde{f}$ be implemented by a ReLU network $\eta$ of depth $L$. Let $\widetilde{f}_{1}:x\mapsto\widetilde{f}(\mathbf{x}_{0}+x\mathbf{v})$. Then $\widetilde{f}_{1}$ also approximates $f_{1}$ with error not larger than $\epsilon$. Moreover, since $\widetilde{f}_{1}$ is obtained from $\widetilde{f}$ by a linear substitution $\mathbf{x}=\mathbf{x}_{0}+x\mathbf{v}$, $\widetilde{f}_{1}$ can be implemented by a ReLU network $\eta_{1}$ of the same depth $L$ and with the number of units and weights not larger than in $\eta$ (we can obtain $\eta_{1}$ from $\eta$ by replacing the input layer in $\eta$ with a single unit, accordingly modifying the input connections, and adjusting the weights associated with these connections). It is thus sufficient to establish the claimed bounds for $\eta_{1}$.

By construction, $\widetilde{f}_{1}$ is a continuous piece-wise linear function of $x$. Denote by $M$ the number of linear pieces in $\widetilde{f}_{1}$. We will use the following counting lemma.

$M\leq(2U)^{L-2}$, where $U$ is the number of computation units in $\eta_{1}$.

This bound, up to minor details, is proved in Lemma 2.1 of Telgarsky . Precisely, Telgarsky’s lemma states that if a network has a single input, connections only between neighboring layers, at most $m$ units in a layer, and a piece-wise linear activation function with $t$ pieces, then the number of linear pieces in the output of the network is not greater than $(tm)^{L}$. By examining the proof of the lemma we see that it will remain valid for networks with connections not necessarily between neighboring layers, if we replace $m$ by $U$ in the expression $(tm)^{L}$. Moreover, we can slightly strengthen the bound by noting that in the present paper the input and output units are counted as separate layers, only units of layers 3 to $L$ have multiple incoming connections, and the activation function is applied only in layers 2 to $L-1$. By following Telgarsky’s arguments, this gives the slightly more accurate bound $(tU)^{L-2}$ (i.e., with the power $L-2$ instead of $L$). It remains to note that the ReLU activation function corresponds to $t=2$. ∎