Optimal approximation of continuous functions by very deep ReLU networks

Introduction

Expressiveness of deep neural networks with piecewise-linear (in particular, ReLU) activation functions has been a topic of much theoretical research in recent years. The topic has many aspects, with connections to combinatorics (Montufar et al., 2014; Telgarsky, 2016), topology (Bianchini and Scarselli, 2014), Vapnik-Chervonenkis dimension (Bartlett et al., 1998; Sakurai, 1999) and fat-shattering dimension (Kearns and Schapire, 1990; Anthony and Bartlett, 2009), hierarchical decompositions of functions (Mhaskar et al., 2016), information theory (Petersen and Voigtlaender, 2017), etc.

Here we adopt the perspective of classical approximation theory, in which the problem of expressiveness can be basically described as follows. Suppose that $f$ is a multivariate function, say on the cube $^{\nu}$, and has some prescribed regularity properties; how efficiently can one approximate $f$ by deep neural networks? The question has been studied in several recent publications. Depth-separation results for some explicit families of functions have been obtained in Safran and Shamir (2016); Telgarsky (2016). General upper and lower bounds on approximation rates for functions characterized by their degree of smoothness have been obtained in Liang and Srikant (2016); Yarotsky (2017). Hanin and Sellke (2017); Lu et al. (2017) establish the universal approximation property and convergence rates for deep and “narrow” (fixed-width) networks. Petersen and Voigtlaender (2017) establish convergence rates for approximations of discontinuous functions. Generalization capabilities of deep ReLU networks trained on finite noisy samples are studied in Schmidt-Hieber (2017).

In the slightly different but closely related context of approximation on balls in Sobolev spaces $\mathcal{W}^{d,\infty}(^{\nu}),$ this question of optimal convergence rate has been studied in Yarotsky (2017). That paper described ReLU network architectures with $W$ weights ensuring approximation with error $O(W^{-d/\nu}\ln^{d/\nu}W)$ (Theorem 1). The construction was linear in the sense that the network weights depended on the approximated function linearly. Up to the logarithmic factor, this approximation rate matches the optimal rate over all parametric models under assumption of continuous parameter selection (DeVore et al. (1989)). It was also shown in Theorem 2 of Yarotsky (2017) that one can slightly (by a logarithmic factor) improve over this conditionally optimal rate by adjusting network architectures to the approximated function.

On the other hand, it was proved in Theorem 4 of Yarotsky (2017) that ReLU networks generally cannot provide approximation with accuracy better than $O(W^{-2d/\nu})$ – a bound with the power $\frac{2d}{\nu}$ twice as big as in the previously mentioned existence result. As was shown in the same theorem, this bound can be strengthened for shallow networks. However, without imposing depth constraints, there was a serious gap between the powers $\frac{2d}{\nu}$ and $\frac{d}{\nu}$ in the lower and upper accuracy bounds that was left open in that paper.

In the present paper we bridge this gap in the setting of continuous functions (which is slightly more general than the setting of the Sobolev space of Lipschitz functions, $\mathcal{W}^{1,\infty}(^{\nu})$, i.e. the case $d=1$). Our key insight is the close connection between approximation theory and VC dimension bounds. The lower bound on the approximation accuracy in Theorem 4 of Yarotsky (2017) was derived using the upper VCdim bound $O(W^{2})$ from Goldberg and Jerrum (1995). More accurate upper and lower bounds involving the network depth $L$ have been given in Bartlett et al. (1998); Sakurai (1999). The recent paper Bartlett et al. (2017) establishes nearly tight lower and upper VCdim bounds: $cWL\ln(W/L)\leq\operatorname{VCdim}(W,L)\leq CWL\ln W$, where $\operatorname{VCdim}(W,L)$ is the largest VC dimension of a piecewise linear network with $W$ weights and $L$ layers. The key element in the proof of the lower bound is the “bit extraction technique” (Bartlett et al. (1998)) providing a way to compress significant expressiveness in a single network weight. In the present paper we adapt this technique to the approximation theory setting.

Our main result is the complete phase diagram for the parameterized family of approximation rates involving the modulus of continuity $\omega_{f}$ of the function $f$ and the number of weights $W$. We prove that using very deep networks one can approximate function $f$ with error $O(\omega_{f}(O(W^{-2/\nu})))$, and this rate is optimal up to a logarithmic factor. In fact, the depth of the networks must necessarily grow almost linearly with $W$ to achieve this rate, in sharp contrast to shallow networks that can provide approximation with error $O(\omega_{f}(O(W^{-1/\nu})))$. Moreover, whereas the slower rate $O(\omega_{f}(O(W^{-1/\nu})))$ can be achieved using a continuous weight assignment in the network, the optimal $O(\omega_{f}(O(W^{-2/\nu})))$ rate necessarily requires a discontinuous weight assignment. All this allows us to regard these two kinds of approximations as being in different “phases”. In addition, we explore the intermediate rates $O(\omega_{f}(O(W^{-p})))$ with $p\in(\frac{1}{\nu},\frac{2}{\nu})$ and show that they are also in the discontinuous phase and require network depths $\sim W^{p\nu-1}.$ We show that the optimal rate $O(\omega_{f}(O(W^{-2/\nu})))$ can be achieved with a deep constant-width fully-connected architecture, whereas the rates $O(\omega_{f}(O(W^{-p})))$ with $p\in(\frac{1}{\nu},\frac{2}{\nu})$ and depth $O(W^{p\nu-1})$ can be achieved by stacking the deep constant-width architecture with a shallow parallel architecture. Apart from the bit extraction technique, we use the idea of the two-scales expansion from Theorem 2 in Yarotsky (2017) as an essential tool in the proofs of our results.

We formulate precisely the results in Section 2, discuss them in Section 3, and give the proofs in Sections 4, 5.

The results

where $|\mathbf{x}|$ is the euclidean norm of $\mathbf{x}$.

The network is determined by its architecture and weights. Clearly, the total number of weights, denoted by $W$, is equal to the total number of connections and computation units (not counting the input units). We don’t impose any constraints on the network architecture (see Fig. 1 for an example of a valid architecture).

Throughout the paper, we consider the input dimension $\nu$ as fixed. Accordingly, by constants we will generally mean values that may depend on $\nu$.

We are interested in relating the approximation errors to the complexity of the function $f$, measured by its modulus of continuity $\omega_{f}$, and to the complexity of the approximating network, measured by its total number of weights $W$. More precisely, we consider approximation rates in terms of the following procedure.

with some constants $a,c$ possibly depending on $\nu$ and $p$ but not on $W$ or $f$?

Clearly, if inequality (2) holds for some $p$, then it also holds for any smaller $p$. However, we expect that for smaller $p$ the inequality can be in some sense easier to satisfy. In this paper we show that there is in fact a qualitative difference between different regions of $p$’s.

Our findings are best summarized by the phase diagram shown in Fig. 2. We give an informal overview of the diagram before moving on to precise statements. The region of generally feasible rates is $p\leq\frac{2}{\nu}.$ This region includes two qualitatively distinct phases corresponding to $p=\frac{1}{\nu}$ and $p\in(\frac{1}{\nu},\frac{2}{\nu}]$. At $p=\frac{1}{\nu},$ the rate (2) can be achieved by fixed-depth networks whose weights depend linearly on the approximated function $f$. In contrast, at $p\in(\frac{1}{\nu},\frac{2}{\nu}]$ the rate can only be achieved by networks with growing depths $L\sim W^{p\nu-1}$ and whose weights depend discontinuously on the approximated function. In particular, at the rightmost feasible point $p=\frac{2}{\nu}$ the approximating architectures have $L\sim W$ and are thus necessarily extremely deep and narrow.

There exist network architectures $\eta_{W}$ with $W$ weights and, for each $W$, a weight assignment linear in $f$ such that Eq. (2) is satisfied with $p=\frac{1}{\nu}.$ The network architectures can be chosen as consisting of $O(W)$ parallel blocks each having the same architecture that only depends on $\nu$ (see Fig. 4). In particular, the depths of the networks depend on $\nu$ but not on $W$.

The detailed proof is given in Section 4.2; we explain now the idea. The approximating function $\widetilde{f}$ is constructed as a linear combination of “spike” functions sitting at the knots of the regular grid in $^{\nu}$, with coefficients given by the values of $f$ at these knots (see Fig. 4). For a grid of spacing $\frac{1}{N}$ with an appropriate $N$, the number of knots is $\sim N^{\nu}$ while the approximation error is $O(\omega_{f}(O(\frac{1}{N}))).$ We implement each spike by a block in the network, and implement the whole approximation by summing blocks connected in parallel and weighted. Then the whole network has $O(N^{\nu})$ weights and, by expressing $N$ as $\sim W^{1/\nu}$, the approximation error is $O(\omega_{f}(O(W^{-1/\nu}))$, i.e. we obtain the rate (2) with $p=\frac{1}{\nu}$.

We note that the weights of the resulting network either do not depend on $f$ at all or are given by $w=f(\mathbf{x})$ with some $\mathbf{x}\in^{\nu}.$ In particular, the weight assignment is continuous in $f$ with respect to the standard topology of $C(^{\nu})$.

We turn now to the region $p>\frac{1}{\nu}.$ Several properties of this region are either direct consequences or slight modifications of existing results, and it is convenient to combine them in a single theorem.

(Feasibility) Approximation rate (2) cannot be achieved with $p>\frac{2}{\nu}$.

(Inherent discontinuity) Approximation rate (2) cannot be achieved with $p>\frac{1}{\nu}$ if the weights of $\widetilde{f}$ are required to depend on $f$ continuously with respect to the standard topology of $C(^{\nu})$.

(Inherent depth) If approximation rate (2) is achieved with a particular $p\in(\frac{1}{\nu},\frac{2}{\nu}]$, then the architectures $\eta_{W}$ must have depths $L\geq dW^{p\nu-1}/\ln W$ with some possibly $\nu$- and $p$-dependent constant $d>0.$

The proofs of these statements have the common element of considering the approximation for functions from the unit ball $F_{\nu,1}$ in the Sobolev space $\mathcal{W}^{1,\infty}(^{\nu})$ of Lipschitz functions. Namely, suppose that the approximation rate (2) holds with some $p$. Then all $f\in F_{\nu,1}$ can be approximated by architectures $\eta_{W}$ with accuracy

with some constant $c_{1}$ independent of $W$. The three statements of the theorem are then obtained as follows.

a) This statement is a consequence of Theorem 4a) of Yarotsky (2017), which is in turn a consequence of the upper bound $O(W^{2})$ for the VC dimension of a ReLU network (Goldberg and Jerrum (1995)). Precisely, Theorem 4a) implies that if an architecture $\eta_{W}$ allows to approximate all $f\in F_{\nu,1}$ with accuracy $\epsilon_{W}$, then $W\geq c_{2}\epsilon_{W}^{-\nu/2}$ with some $c_{2}$. Comparing this with Eq. (3), we get $p\leq\frac{2}{\nu}.$

b) This statement is a consequence of the general bound of DeVore et al. (1989) on the efficiency of approximation of Sobolev balls with parametric models having parameters continuously depending on the approximated function. Namely, if the weights of the networks $\eta_{W}$ depend on $f\in F_{\nu,1}$ continuously, then Theorem 4.2 of DeVore et al. (1989) implies that $\epsilon_{W}\geq c_{2}W^{-1/\nu}$ with some constant $c_{2}$, which implies that $p\leq\frac{1}{\nu}.$

c) This statement can be obtained by combining arguments of Theorem 4 of Yarotsky (2017) with the recently established tight upper bound for the VC dimension of ReLU networks (Bartlett et al. (2017), Theorem 6) with given depth $L$ and the number of weights $W$:

Theorem 1 suggests the existence of an approximation phase drastically different from the phase $p=\frac{1}{\nu}$. This new phase would provide better approximation rates, up to $p=\frac{2}{\nu}$, at the cost of deeper networks and some complex, discontinuous weight assignment. The main contribution of the present paper is the proof that this phase indeed exists.

We describe some architectures that, as we will show, correspond to this phase. First we describe the architecture for $p=\frac{2}{\nu},$ i.e. for the fastest possible approximation rate. Consider the usual fully-connected architecture connecting neighboring layers and having a constant number of neurons in each layer, see Fig. 6. We refer to this constant number of neurons as the “width” $H$ of the network. Such a network of width $H$ and depth $L$ has $W=L(H^{2}+H)+H^{2}+(\nu+1)H+1$ weights in total. We will be interested in the scenario of “narrow” networks where $H$ is fixed and the network grows by increasing $L$; then $W$ grows linearly with $L$. Below we will refer to the “narrow fully-connected architecture of width $H$ having $W$ weights”: the depth $L$ is supposed in this case to be determined from the above equality; we will assume without loss of generality that the equality is satisfied with an integer $L$. We will show that these narrow architectures provide the $p=\frac{2}{\nu}$ approximation rate if the width $H$ is large enough (say, $H=2\nu+10$).

In the case $p\in(\frac{1}{\nu},\frac{2}{\nu})$ we consider another kind of architectures obtained by stacking parallel shallow architectures (akin to those of Proposition 1) with the above narrow fully-connected architectures, see Fig. 6. The first, parallelized part of these architectures consists of blocks that only depend on $\nu$ (but not on $W$ or $p$). The second, narrow fully-connected part will again have a fixed width, and we will take its depth to be $\sim W^{p\nu-1}$. All the remaining weights then go into the first parallel subnetwork, which in particular determines the number of blocks in it. Since the blocks are parallel and their architectures do not depend on $W$, the overall depth of the network is determined by the second, deep subnetwork and is $O(W^{p\nu-1})$. On the other hand, in terms of the number of weights, for $p<\frac{2}{\nu}$ most computation is performed by the first, parallel subnetwork (the deep subnetwork has $O(W^{p\nu-1})$ weights while the parallel one has an asymptotically larger number of weights, $W-O(W^{p\nu-1})$).

Clearly, these stacked architectures can be said to “interpolate” between the purely parallel architectures for $p=\frac{1}{\nu}$ and the purely serial architectures for $p=\frac{2}{\nu}$. Note that a parallel computation can be converted into a serial one at the cost of increasing the depth of the network. For $p<\frac{2}{\nu}$, rearranging the parallel subnetwork of the stacked architecture into a serial one would destroy the $O(W^{p\nu-1})$ bound on the depth of the full network, since the parallel subnetwork has $\sim W$ weights. However, for $p=\frac{2}{\nu}$ this rearrangement does not affect the $L\sim W$ asymptotic of the depth more than by a constant factor – that’s why we don’t include the parallel subnetwork into the full network in this case.

We state now our main result as the following theorem.

For any $p\in(\frac{1}{\nu},\frac{2}{\nu}]$, there exist a sequence of architectures $\eta_{W}$ with depths $L=O(W^{p\nu-1})$ and respective weight assignments such that inequality (2) holds with this $p$.

For $p=\frac{2}{\nu}$, an example of such architectures is the narrow fully-connected architectures of constant width $2\nu+10$.

For $p\in(\frac{1}{\nu},\frac{2}{\nu})$, an example of such architectures are stacked architectures described above, with the narrow fully-connected subnetwork having width $3^{\nu}(2\nu+10)$ and depth $W^{p\nu-1}$.

Comparing this theorem with Theorem 1a) we see that the narrow fully-connected architectures provide the best possible approximation in the sense of Eq. (2). Moreover, for $p\in(\frac{1}{\nu},\frac{2}{\nu})$ the upper bound on the network depth in Theorem 2c) matches the lower bound in Theorem 1c) up to a logarithmic factor. This proves that for $p\in(\frac{1}{\nu},\frac{2}{\nu})$ our stacked architectures are also optimal (up to a logarithmic correction) if we additionally impose the asymptotic constraint $L=O(W^{p\nu-1})$ on the network depth.

The full proof of Theorem 2 is given in Section 5; we explain now its main idea. Given a function $f$ and some $W$, we first proceed as in Proposition 1 and construct its piecewise linear interpolation $\widetilde{f}_{1}$ on the length scale $\frac{1}{N}$ with $N\sim W^{1/\nu}$. This approximation has uniform error $O(\omega_{f}(O(W^{-1/\nu})))$. Then, we improve this approximation by constructing an additional approximation $\widetilde{f}_{2}$ for the discrepancy $f-\widetilde{f}_{1}$. This second approximation lives on a smaller length scale $\frac{1}{M}$ with $M\sim W^{p}$. In contrast to $\widetilde{f}_{1}$, the second approximation is inherently discrete: we consider a finite set of possible shapes of $f-\widetilde{f}_{1}$ in patches of linear size $\sim\frac{1}{N}$, and in each patch we use a special single network weight to encode the shape closest to $f-\widetilde{f}_{1}$. The second approximation is then fully determined by the collection of these special encoding weights found for all patches. We make the parallel subnetwork of the full network serve two purposes: in addition to computing the initial approximation $\widetilde{f}_{1}(\mathbf{x})$ as in Proposition 1, the subnetwork returns the position of $\mathbf{x}$ within its patch along with the weight that encodes the second approximation $\widetilde{f}_{2}$ within this patch. The remaining, deep narrow part of the network then serves to decode the second approximation within this patch from the special weight and compute the value $\widetilde{f}_{2}(\mathbf{x})$. Since the second approximation lives on the smaller length scale $\frac{1}{M}$, there are $Z=\exp(O((M/N)^{\nu}))$ possible approximations $\widetilde{f}_{2}$ within the patch that might need to be encoded in the special weight. It then takes a narrow network of depth $L\sim\ln Z$ to reconstruct the approximation from the special weight using the bit extraction technique of Bartlett et al. (1998). As $M\sim W^{p}$, we get $L\sim W^{p\nu-1}$. At the same time, the second approximation allows us to effectively improve the overall approximation scale from $\sim\frac{1}{N}$ down to $\sim\frac{1}{M}$, i.e. to $\sim W^{-p}$, while keeping the total number of weights in the network. This gives us the desired error bound $O(\omega_{f}(O(W^{-p}))).$

Discussion

We discuss now our result in the context of general approximation theory and practical machine learning. First, a theorem of Kainen et al. (1999) shows that in the optimal approximations by neural networks the weights generally discontinuously depend on the approximated function, so the discontinuity property that we have established is not surprizing. However, this theorem of Kainen et al. (1999) does not in any way quantify the accuracy gain that can be acquired by giving up the continuity of the weights. Our result does this in the practically important case of deep ReLU networks, and explicitly describes a relevant mechanism.

In general, many nonlinear approximation schemes involve some form of discontinuity, often explicit (e.g., using different expansion bases for different approximated functions (DeVore (1998)). At the same time, discontinuous selection of parameters in parametric models is often perceived as an undesirable phenomenon associated with unreliable approximation (DeVore et al. (1989); DeVore (1998)). We point out, however, that deep architectures considered in the present paper resemble some popular state-of-the-art practical networks for highly accurate image recognition – residual networks (He et al., 2016) and highway networks (Srivastava et al., 2015) that may have dozens or even hundreds of layers. While our model does not explicitly include shortcut connections as in ResNets, a very similar element is effectively present in the proof of Theorem 2 (in the form of channels reserved for passing forward the data). We expect, therefore, that our result may help better understand the properties of ResNet-like networks.

Quantized network weights have been previously considered from the information-theoretic point of view in Bölcskei et al. (2017); Petersen and Voigtlaender (2017). In the present paper we do not use quantized weights in the statement of the approximation problem, but they appear in the solution (namely, we use them to store small-scale descriptions of the approximated function). One can expect that weight quantization may play an important role in the future development of the theory of deep networks.

Preliminaries and proof of Proposition 1

The modulus of continuity defined by (1) is monotone nondecreasing in $r$. By the convexity of the cube $^{\nu},$ for any integer $n$ we have $\omega_{f}(r)\leq n\omega_{f}(\frac{r}{n}).$ More generally, for any $\alpha\in(0,1)$ we can write

The ReLU function $x\mapsto x_{+}$ allows us to implement the binary $\max$ operation as $\max(a,b)=a+(b-a)_{+}$ and the binary min operation as $\min(a,b)=a-(a-b)_{+}$. The maximum or minimum of any $n$ numbers can then be implemented by chaining $n-1$ binary $\max$’s or $\min$’s. Computation of the absolute value can be implemented by $|x|=2x_{+}-x.$

Without loss of generality, we can assume that hidden units in the ReLU network may not include the ReLU nonlinearity (i.e., may compute just a linear combination of the input values). Indeed, we can simulate nonlinearity-free units just by increasing the weight $h$ in the formula $x_{1},\ldots,x_{s}\mapsto(\sum_{k=1}^{s}w_{k}x_{k}+h)_{+}$, so that $\sum_{k=1}^{s}w_{k}x_{k}+h$ is always nonnegative (this is possible since the network inputs are from a compact set and the network implements a continuous function), and then compensating the shift by subtracting appropriate amounts in the units receiving input from the unit in question. In particular, we can simulate in this way trivial “pass forward” (identity) units that simply deliver given values to some later layers of the network.

In the context of deep networks of width $H$ considered in Section 5, it will be occasionally convenient to think of the network as consisting of $H$ “channels”, i.e. sequences of units with one unit per layer. Channels can be used to pass forward values or to perform computations. For example, suppose that we already have $n$ channels that pass forward $n$ numbers. If we also need to compute the maximum of these numbers, then, by chaining binary $\max$’s, this can be done in a subnetwork including one additional channel that spans $n$ layers.

We denote vectors by boldface characters; the scalar components of a vector $\mathbf{x}$ are denoted $x_{1},x_{2},\ldots$

2 Proof of Proposition 1

Indeed, if $\mathbf{x}\notin\cup_{\Delta\in R}\Delta,$ then it is easy to see that we can find some $\Delta\in R$ such that $l_{\Delta}(\mathbf{x})<0$, hence $\phi$ vanishes outside $\cup_{\Delta\in R}\Delta$, as required. On the other hand, consider the restriction of $\phi$ to $\cup_{\Delta\in R}\Delta$. Each $l_{\Delta}$ is nonnegative on this set. For each $\Delta_{1}$ and $\mathbf{x}\in\cup_{\Delta\in R}\Delta$, the value $l_{\Delta_{1}}(\mathbf{x})$ is a convex combination of the values of $l_{\Delta_{1}}$ at the vertices of the simplex $\Delta_{\mathbf{x}}$ that $\mathbf{x}$ belongs to. Since $l_{\Delta}$ is nonnegative and $l_{\Delta}(\mathbf{0})=1$ for all $\Delta$, the minimum in (6) is attained at $\Delta$ such that $l_{\Delta}$ vanishes at all vertices of $\Delta_{\mathbf{x}}$ other than $\mathbf{0}$, i.e. at $\Delta=\Delta_{\mathbf{x}}$.

Note that each map $l_{\Delta}$ in (6) is either of the form $1+x_{k}-x_{s}$ or $1\pm x_{k}$ (different simplexes may share the same map $l_{\Delta}$), so the minimum actually needs to be taken only over $\nu(\nu+1)$ different $l_{\Delta}(\mathbf{x})$: \phi(\mathbf{x})=\big{(}\min(\min_{k\neq s}(1+x_{k}-x_{s}),\min_{k}(1+x_{k}),\min_{k}(1-x_{k}))\big{)}_{+}.

We define now the piecewise linear interpolation $\widetilde{f}_{1}$ by

We can bound the modulus of continuity of $f_{2}$ by $\omega_{f_{2}}(r)\leq\omega_{f}(r)+\omega_{\widetilde{f}_{1}}(r)\leq(2\sqrt{\nu}+1)\omega_{f}(r)$ for $r\in[0,\frac{2}{N}].$ Since any point $\mathbf{x}\in^{\nu}$ is within the distance $\tfrac{\sqrt{\nu}}{2N}$ of one of the interpolation knots $\tfrac{\mathbf{n}}{N}$ where $f_{2}$ vanishes, we can also write

where in the second inequality we again used Eq.(5).

We observe now that formula (7) can be represented by a parallel network shown in Fig. 4 in which the blocks compute the values $\phi(N\mathbf{x}-\mathbf{n})$ and their output connections carry the weights $f(\tfrac{\mathbf{n}}{N})$. Since the blocks have the same architecture only depending on $\nu$, for a network with $n$ blocks the total number of weights is $O(n)$. It follows that the number of weights will not exceed $W$ if we take $N=cW^{1/\nu}$ with a suficiently small constant $c$. Then, the error bound (8) ensures the desired approximation rate (2) with $p=\frac{1}{\nu}$.

Proof of Theorem 2

We divide the proof into three parts. In Section 5.1 we construct the “two-scales” approximation $\widetilde{f}$ for the given function $f$ and estimate its accuracy. In Section 5.2 we describe an efficient way to store and evaluate the refined approximation using the bit extraction technique. Finally, in Section 5.3 we describe the neural network implementations of $\widetilde{f}$ and verify the network size constraints.

We follow the outline of the proof given after the statement of Theorem 2 and start by constructing the initial interpolating approximation $\widetilde{f}_{1}$ to $f$ using Proposition 1. We may assume without loss of generality that $\widetilde{f}_{1}$ must be implemented by a network with not more than $W/2$ weights, reserving the remaining $W/2$ weights for the second approximation. Then $\widetilde{f}_{1}$ is given by Eq. (7), where

with a sufficiently small constant $c_{1}$. The error of the approximation $\widetilde{f}_{1}$ is given by Eq. (8). We turn now to approximating the discrepancy $f_{2}=f-\widetilde{f}_{1}.$

It is convenient to represent $f_{2}$ as a finite sum of functions with supports consisting of disjoint “patches” of linear size $\sim\tfrac{1}{N}.$ Precisely, let $S=\{0,1,2\}^{\nu}$ and consider the partition of unity on the cube $^{\nu}$

Since $\|g_{\mathbf{q}}\|_{\infty}\leq 1,$ we have $\|f_{2,\mathbf{q}}\|_{\infty}\leq\|f_{2}\|_{\infty}\leq 3\nu\omega_{f}(\frac{1}{N})$ by Eq. (8). Also, if $r\in[0,\frac{2}{N}]$ then

where in the last step we used inequality (5).

1.2 The second (discrete) approximation.

We will construct the full approximation $\widetilde{f}$ in the form

where $\widetilde{f}_{2,\mathbf{q}}$ are approximations to $f_{2,\mathbf{q}}$ on a smaller length scale $\frac{1}{M}$. We set

Here the discretization parameter $\lambda$ is given by

1.3 Accuracy of the full approximation.

Summing the errors over all $\mathbf{q}\in S$, we can bound the error of the full approximation using representations (11), (13) and the above bound:

Observe that, by Eq.(14), this yields the desired approximation rate (2) provided we can indeed implement $\widetilde{f}$ with not more than $W$ weights:

2 Storing and decoding the refined approximation

We have reduced our task to implementing the functions $\widetilde{f}_{2,\mathbf{q}}$ subject to the network size and depth constraints. We describe now an efficient way to compute these functions using a version of the bit extraction technique.

Since $B_{\mathbf{q},\mathbf{n}}(\mathbf{m})\in\{-1,0,1\},$ we can encode all the $(2M/N-1)^{\nu}$ values $B_{\mathbf{q},\mathbf{n}}(\mathbf{m})$ by a single ternary number

where $t\mapsto\mathbf{m}_{t}$ is some enumeration of the multi-indices $\mathbf{m}$. The values $b_{\mathbf{q},\mathbf{n}}$ for all $\mathbf{q}$ and $\mathbf{n}$ will be stored as weights in the network and encode the approximation $\widetilde{f}_{2}$ in all the patches.

Such a function can be implemented by $\chi_{\epsilon}(x)=\frac{1}{\epsilon}(x-(1-\epsilon))_{+}-\frac{1}{\epsilon}(x-1)_{+}+\frac{1}{\epsilon}(x-(2-\epsilon))_{+}-\frac{1}{\epsilon}(x-2)_{+}.$ Observe that if $\epsilon<3^{-(2M/N-1)^{\nu}}$, then for all $t$ the number $3z_{t}$ belongs to one of the three intervals in the r.h.s. of Eq.(21) and hence $\chi_{\epsilon}(3z_{t})=\lfloor 3z_{t}\rfloor$. Thus, we can reconstruct the values $B_{\mathbf{q},\mathbf{n}}(\mathbf{m})$ for all $\mathbf{m}$ by a ReLU network with $O((M/N)^{\nu})$ layers and weights.

On the patch $Q_{\mathbf{n}}$, the function $\widetilde{f}_{2,\mathbf{q}}$ can be expanded over the spike functions as

It is convenient to rewrite this computation in terms of the numbers $B_{\mathbf{q},\mathbf{n}}(\mathbf{m})$ and the expressions

using summation by parts in the direction $x_{1}$:

where we used the identities $A_{\mathbf{q},\mathbf{n}}(-M/N,\overline{\mathbf{m}})=A_{\mathbf{q},\mathbf{n}}(M/N,\overline{\mathbf{m}})=0$.

The above representation involves products $\Phi_{\mathbf{n},\overline{\mathbf{m}}}(m_{1},\mathbf{x})B_{\mathbf{q},\mathbf{n}}(m_{1},\overline{\mathbf{m}}),$ and we show now how to implement them by a ReLU network. Note that $\Phi_{\mathbf{n},\overline{\mathbf{m}}}(m_{1},\mathbf{x})\in$ and $B_{\mathbf{q},\mathbf{n}}(m_{1},\overline{\mathbf{m}})\in\{-1,0,1\}$. But for any $x\in,y\in\{-1,0,1\}$ we can write

2.4 Mapping 𝐱𝐱\mathbf{x} to the respective patch.

We will use the obtained formula (23) as a basis for computing $\widetilde{f}_{2,\mathbf{q}}(\mathbf{x})$. But the formula is dependent on the patch the input $\mathbf{x}$ belongs to: the value $\Phi_{\mathbf{n},\overline{\mathbf{m}}}(m_{1},\mathbf{x})$ depends on the patch index $\mathbf{n}$ by Eq.(22), and the values $B_{\mathbf{q},\mathbf{n}}(m_{1},\overline{\mathbf{m}})$ must be recovered from the patch-specific encoding weight $b_{\mathbf{q},\mathbf{n}}$.

Given $\mathbf{x}$, the relevant value of $b_{\mathbf{q},\mathbf{n}}$ can be selected among the values for all patches by the ReLU network computing

If $\mathbf{x}$ belongs to some patch $Q_{\mathbf{n}},$ then $b_{\mathbf{q}}(\mathbf{x})=b_{\mathbf{q},\mathbf{n}}$, as required. If $\mathbf{x}$ does not belong to any patch, then $b_{\mathbf{q}}(\mathbf{x})$ computes some garbage value which will be unimportant because we will ensure that all the factors $\Phi$ appearing in the sum (23) will vanish for such $\mathbf{x}$.

Now we show how to perform a properly adjusted computation of $\Phi_{\mathbf{n},\overline{\mathbf{m}}}(m_{1},\mathbf{x})$. Namely, we will compute the function $\widetilde{\Phi}_{\overline{\mathbf{m}},\mathbf{q}}(m_{1},\mathbf{x})$ such that

Now if we try to define $\widetilde{\Phi}_{\overline{\mathbf{m}},\mathbf{q}}(m_{1},\mathbf{x})$ just by replacing $\frac{\mathbf{n}}{N}$ with $\Psi_{\mathbf{q}}(\mathbf{x})$ in the definition (22), then we fulfill the requirement (26), but not (27). To also fulfill (27), consider the auxiliary “suppressing” function

then this $\widetilde{\Phi}_{\overline{\mathbf{m}},\mathbf{q}}(m_{1},\mathbf{x})$ satisfies both (26) and (27). Then, based on (23), we can write the final formula for $\widetilde{f}_{2,\mathbf{q}}(\mathbf{x})$ as

We summarize now how $\widetilde{f}_{2,\mathbf{q}}(\mathbf{x})$ is computed by the ReLU network.

The patch-encoding number $b_{\mathbf{q}}(\mathbf{x})$ and the auxiliary functions $\Psi_{\mathbf{q}}(\mathbf{x}),\theta_{\mathbf{q}}(\mathbf{x})$ are computed by Eqs.(25), (28)-(30), (31), respectively.

The numbers $B_{\mathbf{q},\mathbf{n}}(\mathbf{m})$ that describe the patch containing $\mathbf{x}$ are decoded from $b_{\mathbf{q}}(\mathbf{x})$ by a deep network with $O((M/N)^{\nu})$ layers and weights as detailed in Section 5.2.2. We choose the enumeration $t\mapsto\mathbf{m}_{t}$ so that same-$\overline{\mathbf{m}}$ multi-indices $\mathbf{m}$ form contiguous blocks of length $2M/N-1$ corresponding to summation over $m_{1}$ in (33); the ordering of the multi-indices $\overline{\mathbf{m}}$ is arbitrary.

The values $\widetilde{\Phi}_{\overline{\mathbf{m}},\mathbf{q}}(m_{1},\mathbf{x})$ are computed iteratively in parallel to the respective $B_{\mathbf{q},\mathbf{n}}(\mathbf{m})$, using Eq.(32). For $m_{1}>-M/N+1$, the sum $\sum_{s=-M/N+1}^{m_{1}}\phi(\ldots)$ is computed by adding the next term to the sum $\sum_{s=-M/N+1}^{m_{1}-1}\phi(\ldots)$ retained from the previous step. This shows that all the values $\widetilde{\Phi}_{\overline{\mathbf{m}},\mathbf{q}}(m_{1},\mathbf{x})$ can be computed with $O((M/N)^{\nu})$ linear and ReLU operations.

The sum (33) is computed with the help of multiplication formula (24).

3 Network implementations

We can now establish statement a) of Theorem 2. Recall that we have already established the approximation rate in Eq. (20), but still need to show that the total number of weights is bounded by $W$. The initial approximation $\widetilde{f}_{1}$ was constructed so as to be implementable by a network architecture with $W/2$ weights, and we need to show now that the second approximation $\widetilde{f}_{2}$ can also be implemented by an architecture with not more than $W/2$ weights.

By Eq. (13), computation of $\widetilde{f}_{2}$ amounts to $3^{\nu}$ computations of the terms $\widetilde{f}_{2,\mathbf{q}}$. These latter computations are detailed in stages 1–4 in Section 5.2.5. Stage 1 can be performed by a parallellized ReLU network of depth $O(1)$ with $O(N^{\nu})$ elementary operations. If the constant $c_{1}$ in our choice (9) of $N$ is small enough, then the total number of weights required for stage 1 does not exceed $W/4$. Next, stages 2–4 require a deep network that has $O((M/N)^{\nu})$ layers and weights. By our choice of $N,M$ in Eqs. (9), (14) we can write $O((M/N)^{\nu})$ as $O((c_{2}/c_{1})^{\nu}W^{p\nu-1})$. Assuming $c_{2}$ is small enough, the number of weights for stages 2–4 does not exceed $W/4$ as well, and so the total number of weights required for $\widetilde{f}$ does not exceed $W$, as desired. In addition, the depth of the network implementation of $\widetilde{f}$ is determined by the depth of stages 2–4, i.e. is $O(W^{p\nu-1}),$ also as claimed in Theorem 2a).

We describe now in more detail the implementation of $\widetilde{f}$ by the narrow fully-connected or by the stacked architectures as stated in parts b) and c) of Theorem 2.

3.2 Implementation of f~~𝑓\widetilde{f} in the case p=2ν𝑝2𝜈p=\frac{2}{\nu}.

In this case we implement $\widetilde{f}$ by a narrow fully-connected network and estimate now its sufficient width. We reserve $\nu$ channels to pass forward the $\nu$ components of the input $\mathbf{x}$ and one channel to store partial results of the sum $\widetilde{f}(\mathbf{x})=\widetilde{f}_{1}(\mathbf{x})+\sum_{\mathbf{q}\in\{0,1,2\}^{\nu}}\widetilde{f}_{2,\mathbf{q}}(\mathbf{x}).$ The terms in this sum can be computed in a serial way, so we only need to estimate the network width sufficient for implementing $\widetilde{f}_{1}$ and any $\widetilde{f}_{2,\mathbf{q}}$.

Given $\mathbf{x}$, the value $\phi(\mathbf{x})$ or, more generally, $\phi(N\mathbf{x}-\mathbf{n})$, can be computed by (6) using chained binary $\min$’s and just one additional channel. Therefore, by (7), $\widetilde{f}_{1}$ can be implemented with the standard network of width $\nu+2$.

Now consider implementation of $\widetilde{f}_{2,\mathbf{q}}$ as detailed in Section 5.2.5. In stage 1, we compute the numbers $b_{\mathbf{q}}(\mathbf{x}),\theta_{\mathbf{q}}(\mathbf{x})$ and the $\nu$-dimensional vector $\Psi_{\mathbf{q}}(\mathbf{x})$. This can be done with $\nu+3$ channels (one extra channel is reserved for storing partial sums). We reserve $\nu+1$ channels for the next stages to pass forward the values $\Psi_{\mathbf{q}}(\mathbf{x}),\theta_{\mathbf{q}}(\mathbf{x})$. In stage 2, we decode the numbers $B_{\mathbf{q},\mathbf{n}}(\mathbf{m})$ from $b_{q}(\mathbf{x}).$ This can be done with 4 channels: one is used to store and refresh the values $z_{t}$, another to output the sequence $B_{\mathbf{q},\mathbf{n}}(\mathbf{m}_{t})$, and two more channels to compute $\chi_{\epsilon}(3z_{t})$. In stage 3, we compute the numbers $\widetilde{\Phi}_{\overline{\mathbf{m}},\mathbf{q}}(m_{1},\mathbf{x})$. This can be done with 3 channels: one is used to keep partial sums $\sum_{s=-M/N+1}^{m_{1}}\phi(\ldots)$, another to compute current $\phi(\ldots)$, and the third to compute $\widetilde{\Phi}_{\overline{\mathbf{m}},\mathbf{q}}(m_{1},\mathbf{x})$ by Eq.(32). Stages 2 and 3 are performed in parallel and their channels are aligned so that for each $\mathbf{m}$ the values $B_{\mathbf{q},\mathbf{n}}(\mathbf{m})$ and $\widetilde{\Phi}_{\overline{\mathbf{m}},\mathbf{q}}(m_{1},\mathbf{x})$ can be found in the same layer. In stage 4, we compute the sum (33). This stage is performed in parallel to stages 2 and 3 and requires one more channel for computing the ReLU operations in the multiplication formula (24). We conclude that $2\nu+10$ channels are sufficient for the whole computation of $\widetilde{f}_{2,\mathbf{q}}$ and hence for the whole computation of $\widetilde{f}.$

3.3 Implementation of f~~𝑓\widetilde{f} in the case p∈(1ν,2ν)𝑝1𝜈2𝜈p\in(\frac{1}{\nu},\frac{2}{\nu}).

In this case the initial approximation $\widetilde{f}_{1}$ as well as stage 1 in the computations of $\widetilde{f}_{2,\mathbf{q}}$ are implemented by the parallel shallow subnetwork and only stages 2–4 of the computations of $\widetilde{f}_{2,\mathbf{q}}$ are implemented by the deep narrow subnetwork. We can make some blocks of the parallel subnetwork output the terms $f(\tfrac{\mathbf{n}}{N})\phi(N\mathbf{x}-\mathbf{n})$ of the expansion of $\widetilde{f}_{1}$ while other blocks output the numbers $b_{\mathbf{q}}(\mathbf{x}),\theta_{\mathbf{q}}(\mathbf{x})$ and the $\nu$-dimensional vector $\Psi_{\mathbf{q}}(\mathbf{x})$. The stages 2–4 are then implemented as in the previous case $p=\frac{2}{\nu}$, but now all the $\mathbf{q}\in S$ must be processed in parallel – that’s why the width of the deep subnetwork is taken to be $3^{\nu}(2\nu+10).$

Acknowledgments

The author thanks Alexander Kuleshov and the anonymous referees for helpful comments and suggestions. The research was supported by the Skoltech SBI Bazykin/Yarotsky project.

References