# Capacity Control of ReLU Neural Networks by Basis-path Norm

Recently, path norm was proposed as a new capacity measure for neural networks with Rectified Linear Unit (ReLU) activation function, which takes the rescaling-invariant property of ReLU into account. It has been shown that the generalization error bound in terms of the path norm explains the empirical generalization behaviors of the ReLU neural networks better than that of other capacity measures. Moreover, optimization algorithms which take path norm as the regularization term to the loss function, like Path-SGD, have been shown to achieve better generalization performance. However, the path norm counts the values of all paths, and hence the capacity measure based on path norm could be improperly influenced by the dependency among different paths. It is also known that each path of a ReLU network can be represented by a small group of linearly independent basis paths with multiplication and division operation, which indicates that the generalization behavior of the network only depends on only a few basis paths. Motivated by this, we propose a new norm Basis-path Norm based on a group of linearly independent paths to measure the capacity of neural networks more accurately. We establish a generalization error bound based on this basis path norm, and show it explains the generalization behaviors of ReLU networks more accurately than previous capacity measures via extensive experiments. In addition, we develop optimization algorithms which minimize the empirical risk regularized by the basis-path norm. Our experiments on benchmark datasets demonstrate that the proposed regularization method achieves clearly better performance on the test set than the previous regularization approaches.

## Authors

• 7 publications
• 11 publications
• 15 publications
• 141 publications
• 39 publications
• 101 publications
• ### Positively Scale-Invariant Flatness of ReLU Neural Networks

It was empirically confirmed by Keskar et al.SharpMinima that flatter mi...
03/06/2019 ∙ by Mingyang Yi, et al. ∙ 0

• ### Towards Understanding the Role of Over-Parametrization in Generalization of Neural Networks

Despite existing work on ensuring generalization of neural networks in t...
05/30/2018 ∙ by Behnam Neyshabur, et al. ∙ 2

• ### Interpreting Basis Path Set in Neural Networks

Based on basis path set, G-SGD algorithm significantly outperforms conve...
10/18/2019 ∙ by Juanping Zhu, et al. ∙ 0

• ### Global Capacity Measures for Deep ReLU Networks via Path Sampling

Classical results on the statistical complexity of linear models have co...
10/22/2019 ∙ by Ryan Theisen, et al. ∙ 23

• ### Extreme Memorization via Scale of Initialization

We construct an experimental setup in which changing the scale of initia...
08/31/2020 ∙ by Harsh Mehta, et al. ∙ 7

• ### Fisher-Rao Metric, Geometry, and Complexity of Neural Networks

We study the relationship between geometry and capacity measures for dee...
11/05/2017 ∙ by Tengyuan Liang, et al. ∙ 0

• ### A Priori Estimates of the Population Risk for Residual Networks

Optimal a priori estimates are derived for the population risk of a regu...
03/06/2019 ∙ by Weinan E, et al. ∙ 6

##### This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

## Introduction

Deep neural networks have pushed the frontiers of a wide variety of AI tasks in recent years such as speech recognition [Xiong et al.2016, Chan et al.2016]

[Ioffe and Szegedy2015, Ren et al.2015] and neural language processing [Bahdanau, Cho, and Bengio2014, Gehring et al.2017], etc. More surprisingly, deep neural networks generalize well, even when the number of parameters is significantly larger than the amount of training data [Zhang et al.2017]. To explain the generalization ability of neural networks, researchers commonly used different norms of network parameters to measure the capacity [Bartlett, Foster, and Telgarsky2017, Neyshabur, Tomioka, and Srebro2014, Neyshabur, Tomioka, and Srebro2016].

Among different types of deep neural networks, ReLU networks (i.e., neural networks with ReLU activations [Glorot, Bordes, and Bengio2011]) have demonstrated their outstanding performances in many fields such as image classification [He et al.2016, Huang et al.2017], information system [Cheng et al.2016, He et al.2017], and text understanding [Vaswani et al.2017] etc. It is well known that ReLU neural networks are positively scale invariant [Neyshabur, Salakhutdinov, and Srebro2015, Neyshabur et al.2016]. That is, for a hidden node with ReLU activation, if all of its incoming weights are multiplied by a positive constant and its outgoing weights are divided by the same constant, the neural network with the new weights will generate exactly the same output as the old one for any arbitrary input. [Neyshabur, Salakhutdinov, and Srebro2015] considered the product of weights along all paths from the input to output units as path norm which is invariant to the rescaling of weights, and proposed Path-SGD which takes path norm as the regularization term to the loss function.

In fact, each path in a ReLU network can be represented by a small group of generalized linearly independent paths (we call them basis-path in the sequels) with multiplication and division operation as shown in Figure 1. Thus, there is dependency among different paths. The smaller the percentage of basis paths, the higher the dependency. As the network is determined only by the basis paths, the generalization property of the network should depend only on the basis paths, as well as the relevant regularization methods. In addition, Path-SGD controls the capacity by solving argmin of the regularized loss function, the solution of the argmin problem is approximate because dependency among different values of all paths is not considered in the network. This motivates us to establish a capacity bound based on only the basis paths instead of all the paths. This is in contrast to the generalization bound based on the path norm which counts the values of all the paths and does not consider the dependency among different paths. To tackle these problems, we define a new norm based on the values of the basis paths called Basis-path Norm. In previous work, [Meng et al.2018] constructed the basis paths by skeleton method and proved that the values of all other paths can be calculated using the values of basis paths by multiplication and division operations. In this work, we take one step further and categorize the basis paths into positive and negative basis paths according to the sign of their coefficients in the calculations of non-basis paths.

In order to control generalization error, we need to keep the hypothesis space being small. As we know, loss function can be computed by paths, hence we keep the values of all paths being small. To keep small values of non-basis paths represented by positive and negative basis paths, we control the positive basis paths not being too large while the negative basis paths not being too small. In addition, to keep small values of basis paths, we control the negative basis paths not being too large as well. With this consideration, we define the new Basis-path norm. We prove a generalization error bound for ReLU networks in terms of the basis-path norm. We then study the relationship between this basis-path norm bound and the empirical generalization gap – the absolute difference between test error and training error. The experiments included ReLU networks with different depths, widths, and levels of randomness to the label. For comparison purpose, we also compute the generalization error bounds induced by other capacity measures for neural networks proposed in the literature. Our experiments show that the generalization bound based on basis-path norm is much more consistent with the empirical generalization gap than those based on other norms. In particular, when the network size is small, the ordinary path norm bound fit empirical generalization gap well. However, when the width and depth increases, the percentage of non-basis paths increases, and the dependency among paths increases and we observe that the path norm bound degenerates in reflecting the empirical generalization gap. In contrast, our basis-path norm bound fits the empirical generalization gap consistently as the network size changes. This validates the efficacy of BP norm as a capacity measure.

Finally, we propose a novel regularization method, called Basis-path regularization (BP regularization), in which we penalize the loss function by the BP norm. Empirically, we first conduct experiments on recommendation system of MovieLens-1M dataset to compare the multi-layer perceptron (MLP) model’s generalization with BP regularization and baseline norm-based regularization, then we verify the effectiveness of BP regularization on image classification task with ResNet and PlainNet on CIFAR-10 dataset. The results of all experiments show that, with our method, optimization algorithms (i.e., SGD, Adam, Quotient SGD) can attain better test accuracy than with other regularization methods.

### Related Work

Generalization of deep neural networks has attracted a great deal of attention in the community [Zhang et al.2017, Neyshabur et al.2017, Kawaguchi, Kaelbling, and Bengio2017]. Norm and margin-based measures have been widely studied, and commonly used in neural network optimization with capacity control [Bartlett and Mendelson2002, Evgeniou, Pontil, and Poggio2000, Neyshabur, Tomioka, and Srebro2016]. For example, in [Bartlett, Foster, and Telgarsky2017], the authors proposed a margin-based generalization bound for networks that scale with their margin-normalized spectral complexity. An analysis of generalization bounds based on PAC-Bayes was proposed in [Dziugaite and Roy2017].

Among these measures, the generalization bound based on path norm is tighter theoretically [Neyshabur, Tomioka, and Srebro2016]. Empirically, path norm has been showed to be more accurate to describe the tendency of generalization error [Neyshabur et al.2017]. Thus, we are interested in the capacity measure which is related to the path norm. In [Neyshabur, Tomioka, and Srebro2016], the authors first proposed group norm and path norm. The results show that the path norm is equivalent to a kind of group norm. In [Neyshabur, Salakhutdinov, and Srebro2015, Neyshabur et al.2016], the authors proposed to use path norm as a regularization term for ReLU multi-layers perceptron (MLP) network and recurrent network and designed Path-SGD algorithm. In [Neyshabur et al.2017], the authors empirically compared different kinds of capacity measures including path norm for deep neural network generalization. However, none of those norms considered the dependency among paths in the networks.

## Preliminaries

In this section, we introduce ReLU neural networks and generalization error.

First of all, we briefly introduce the structure of rectifier neural network models. Suppose is a -layer neural network with weight , where input space and output space . In the -th layer (), there are nodes. We denote the nodes and their values as . It is clear that, . The layer mapping is given as, , where is the adjacency matrix in the -layer, and the rectifier activation function is applied element-wisely. We can also calculate the -th output by paths, i.e.,

 Nkw(x)=∑(i0,⋯,iL=k)L∏l=1wl(il−1,il)⋅L−1∏l=1I(olil(w,x)>0)⋅xp0 (1)

where is the path starting from input feature node to output node via hidden nodes , and is the weight of the edge connecting nodes and . 111The paths across the bias node can also be described in the same way. For simplicity, we omit the bias term.

We denote and . The output can be represented using paths as

 Nkp,a(x)=∑(i0,⋯,iL)p(i0,⋯,iL)⋅a(i0,⋯,iL)⋅xi0.

For ease of reference, we omit the explicit index and use be the index of path. We use where

to denote the path vector. The path norm used in Path-SGD

[Neyshabur, Salakhutdinov, and Srebro2015] is defined as

Given the training set i.i.d sampled from the underlying distribution

, machine learning algorithms learn a model

from the hypothesis space by minimizing the empirical loss function . The uniform generalization error of empirical risk minimization in hypothesis space is defined as

 ϵgen(F)=supf∈F|1nn∑i=1l(f(xi),yi)−E(x,y)∼Pl(f(x),y)|.

Generalization error measures how well a model learned from the training data can fit an unknown test sample .

Empirically, we consider the empirical generalization error which is defined as the difference of empirical loss between the training set and test set at the trained model .

## Basis-path Norm

In this section, we define the Basis-path Norm (abbreviated as BP norm) on the networks. Using the BP norm, we define a capacity measure which is called BP-measure and we prove that the generalization error can be upper bounded using this measure.

### The Definition of Basis-path Norm

First, as shown in [Meng et al.2018], the authors constructed a group of basis paths by skeleton method. It means that the value of non-basis paths can be calculated using the values of basis paths. In the calculation of non-basis paths’ values, some basis paths always have positive exponents and hence appear in the numerator, others have negative exponents and hence appear in the denominator. We use to denote a non-basis path and to denote basis paths. We have the following proposition.

###### Proposition 1

For any non-basis path , , where .

Limited by the space, we put the detailed proof in the supplementary materials.

The proposition shows that basis paths always have negative exponent in the calculation, while always have positive exponent. We call the basis path with negative exponent Negative Basis Path and denote the negative basis path vector as . We call the basis path with positive exponent Positive Basis Path and denote it as .

In order to control generalization error, we need to keep the hypothesis space being small. Thus we want all the paths to have small values. For non-basis path represented by and , we control not being too small because is negative, and not being too large because is positive. We control not being too large as well to keep small values of basis paths. We define the following basis-path norm as follows.

###### Definition 1

The basis norm on the ReLU networks is

 ϕ(p)=sup{|log|p1||,⋯,|log|pm||,|pm+1|,⋯,|pr|}. (2)

We next provide the property of .

###### Theorem 1

is a norm in the vector space where is a vector in Euclidean space and is a vector in a generalized linear space under the generalized addition and generalized scalar multiplication operations: and for and .

Proof: The definition of is equivalent to

 ϕ(p)=sup{ϕ∞(p+),ϕ∞(p−)}. (3)

where and . Obviously, is the norm in Euclidean space. Thus, it only needs to prove is a kind of norm. Next, we prove that is a norm in the generalized linear space.

In the generalized linear space, the zero vector is , where denotes a vector with all elements being equal to . Based on the generalized linear operators, we verify the properties including positive definite, absolutely homogeneous and the triangle inequality of as follows:

(1) (Positive definite) and when .

(2) (Absolutely homogeneous) For arbitrary , we have

 ϕ∞(c⋅p−)=supi{|log|p−i|c|,i=1,⋯,m}=|c|⋅ϕ∞(p−).

(3) (Triangle inequality)

 ϕ∞(p−⊕(p′)−)= supi{|log|pip′i||,i=1,⋯,m} ≤ supi{|log|pi||,i=1,⋯,m} +supi{|log|p′i||,i=1,⋯,m} = ϕ∞(p−)+ϕ∞((p′)−).

Considered that and are both norms, taking supreme of them is still a norm. Thus satisfies the definition of norm.

### Generalization Error Bound by Basis-path Norm

We want to use the basis-path norm to define a capacity measure to get the upper bound for the generalization error. Suppose the binary classifier is given as

, where represents the linear operator on the output of the deep network with input vector . We consider the following hypothesis space which is composed of linear operator , and -layered fully connected neural networks with width and input dimension :

 Gd,H,Lγ,v= {g=v∘f:L≥2,h0=d,h1=⋯=hL−1=H,ϕ(p)≤γ}.
###### Theorem 2

Given the training set with , , and the hypothesis space which contains MLPs with depth , width and , for arbitrary , for every

, with probability at least

, for every hypothesis , the generalization error can be upper bounded as

 ϵgen(Gd,H,Lγ,v)≤4√2ln(4/δ)n+ 2√2Φ(γ;d,H,L)(4H)L−1⋅∥v∥22⋅maxi∥xi∥22n,

where

 Φ(γ;d,H,L)Δ= (He2γ+(d−1)Hγ2)(1+(H−1)γ2e2γ)L−2. (4)

We call Basis-path measure. Therefore, the generalization error can be upper bounded by a function of Basis-path measure.

The proof depends on estimating the value of different types of paths and counting the number of different types of paths. We give the proof sketch of Theorem

2.

Proof of Theorem 2:

Step 1: If we denote , the generalization error of a binary classification problem is

 ϵgen(Gd,H,Lγ,v)≤2∥v∥22RA(Fγ)+4√2ln(4/δ)n,

where denotes the Rademacher complexity of a hypothesis space [Wolf2018]. Following the results of Theorem 1 and Theorem 5 in [Neyshabur, Tomioka, and Srebro2016] under and , we have

 RA(Fγ)≤√2Ω2(Fγ)(4H)L−1maxi∥xi∥22n,

where is the maximal path norm of .

Step 2 (estimating path value): We give an upper bound using Basis-path norm. Using , we have and . Then using Proposition 1, we have

 |~p| ≤∣∣m∏i=1pαiir∏j=m+1pαjj∣∣ (5) ≤e−γ∑mi=1αi⋅γ∑ri=m+1αj, (6)

where .

As shown in skeleton method in [Meng et al.2018] (which can also be referred in supplementary materials), basis paths are constructed according to skeleton weights. Here, we clarify the non-basis paths according to the number of non-skeleton weights it contains. We denote the non-basis path which contains non-skeleton weights as . The proofs of Proposition 1 indicates that for . Thus we have

 |~pb|≤eγ(b−1)⋅γb.

Step 3 (counting the number of different type of paths): Based on the construction of basis paths (refer to the skeleton method in supplementary), in each hidden layer, there are skeleton weights and non-skeleton weights. We can get that the number of in a -layer MLP with width is if and if .

Step 4: We have:

 Ω2(Fγ)=m∑i=1(pi)2+r∑j=m+1(pj)2+L−1∑b=2∑k~p2b,k. (7)

The number of negative basis paths is and , so we have , where .

 Ω2(Fγ)≤He2γ+L−2∑b=1((d−1)HCb−1L−2(H−1)b−1+HCbL−2(H−1)b)⋅(γbeγ(b−1))2+(d−1)H(H−1)L−2⋅(γL−1eγ(L−2))2≤(He2γ+(d−1)Hγ2L−2∑b=0CbL−2(H−1)b(γ2e2γ)b≤(He2γ+(d−1)Hγ2)(1+(H−1)γ2e2γ)L−2=Φ(γ;d,H,L), (8)

where Ineq.8 is established by the calculation of .

Based on the above theorem, we discuss how changes as width and depth . (1) For fixed , increases exponentially as and goes to large. (2) increases as increases. If diminishes to zero, we have . In this case, the feature directly flow into the output, which means that , for . (3) If , we have . It increases linearly as and increase and decreases linearly as increases.

### Empirical Verification

In the previous section, we derived a BP norm induced generalization error bound for ReLU networks. In this section, we study the relationship between this bound and the empirical generalization gap – the absolute difference between test error and training error with real-data experiments, in comparison with the generalization error bounds given by other capacity measures, including weight norm [Evgeniou, Pontil, and Poggio2000], path norm [Neyshabur, Tomioka, and Srebro2016] and spectral norm [Bartlett, Foster, and Telgarsky2017]. We follow the experiment settings in [Neyshabur et al.2017], and extend on our BP norm bound. As shown in the previous section, the BP norm with capacity is proportional to Eqn.2

We conduct experiments with multi-layer perceptrons (MLP) with ReLU of different depths, widths, and global minima on MNIST classification task which is optimized by stochastic gradient descent. More details of the training strategies can be found in the supplementary materials. All experiments are averaged over 5 trials if without explicit note.

First, we train several MLP models and force them to converge to different global minima by intentionally replacing a different number of training data with random labels, and then calculate the capacity measures on these models. The training set consists of 10000 randomly selected samples with true labels and another at most 5000 intentionally mislabeled data which are gradually added into the training set. The evaluation of error rate is conducted on a fixed 10000 validation set. Figure 2 (a) shows that every network is enough to fit the entire training set regardless of the amount of mislabeled data, while the test error of the learned networks increases with increasing size of the mislabeled data. As shown in Figure 2 (b), the measure of BP norm is consistent with the behaviors of generalization on the data and indeed is a good predictor of the generalization error, as well as weight norms, path norm, and spectral norm.

We further investigate the relationship between generalization error and the network size with different widths. We train a bunch of MLPs with 2 hidden layers and varying number of hidden units from 16 to 8192 for each layer. The experiment is conducted on the whole training set with 60000 images. As shown in Figure 2(c), the networks can fit the whole training set when the number of hidden units is greater than or equal to 32, while the minimal test error is achieved with 512 hidden units, then shows a slightly over fitting on training set beyond 1024 hidden units. Figure 2(d) shows that the measure of BP norm behaves similarly to the trend of generalization errors which decreases at the beginning and then slightly increases, and also achieves minimal value at 512 hidden units. Weight norm and spectral norm keep increasing along with the network size growing while the trend of generalization error behaves differently. Path norm shows the good explanation of the generalization when the number of hidden units is small, but keeps decreasing along with increasing the network size in this experiment. One possible reason is that the proportion of basis paths in all paths is decreasing, and the vast majority improperly affects the capacity measure when the dependency in the network becomes large. In contrast, BP norm better explains the generalization behaviors regardless of the network size.

Similar empirical observation is shown when we train the network with a different number of hidden layers. Each network has 32 hidden units in each layer and can fit the whole training set in this experiment. As shown in Figure2(e,f), the minimal test error is achieved with 3 hidden layers, and then shows an over fitting along with the increasing of the layers. The weight norm keeps increasing with the growing of network size as discussed above, and the in spectral norm will be quite large when layers is increasing. Path norm can partially explain the decreasing generalization error before 4 hidden layers and it indicates that the networks with 4, 5 and 6 hidden layers have small generalization error, which doesn’t match our observations. The amount of non-basis paths is exponentially growing when layers is increasing, therefore the path norm couldn’t measure the capacity accurately by counting all paths’ values. In contrast, the BP norm can nearly match the generalization error, these observations verify that BP norm bound is more tight to generalization error and can be a better predictor of generalization.

## Basis-path Regularization for ReLU Networks

In this section, we propose Basis-path regularization, in which we penalize the loss function by the BP norm. According to the definition of BP norm in Eqn.(2), to make it small, we need to restrict the values of negative basis paths to be moderate (neither too large nor too small) and minimize the value of positive basis paths. To this end, in our proposed method, we penalize the empirical loss by the distance between the values of negative basis paths and , as well as the sum of the values of all positive basis paths.

The constraint equals to and , which means that the largest element in a vector is smaller than iff all of the element is smaller than . We choose to optimize their square because of the smoothness. So using the Lagrangian dual methods, we add the constraint and in the loss function and then optimize the regularized empirical risk function:

 L(w,x)=f(w,x)+R(p)=f(w,x)+λ12∥p+∥2+λ24∥log(p−)2∥2. (9)

We use to denote the gradient of loss with respect to , i.e., . For the non-skeleton weight , since it is contained in only one positive basis path , we can calculate the gradient of the regularization term with respect to as

 h(wj)=λ12∂R(p)∂pj∂pj(w)∂wj=λ1⋅p2jwj. (10)

For the skeleton weight , it is contained in only one negative basis path (if the neural network has equal number of hidden nodes) and some of the positive basis paths . Thus its gradient can be calculated as follows

 h(wi)=λ24∂R(p)∂pi∂pi(w)∂wi+λ12∑pj:wi∂R(p)∂pj∂pj(w)∂wi=λ2logpiwi+λ1∑pj:wip2jwi, (11)

where denotes all positive basis paths containing .

Combining them together, we get the gradient of the regularized loss function with respected to the weights. For example, if we use stochastic gradient descent to be the optimizer, the update rule is as follows:

 wt+1=wt−ηt(g(wt)+h(wt)). (12)

Please note that the computation overhead of is high, moreover, we observed that the values of the negative basis paths are relatively stable in the optimization, thus we set to be zero for ease of the computation. Specifically, basis-path regularization can be easily combined with the optimization algorithm which is in quotient space.

The flow of SGD with basis-path regularization is shown in Algorithm 1, it’s trivial to extend basis-path regularization to other stochastic optimization algorithms. Comparing to weight decay, basis-path regularization has little additional computation overhead. All the additional computations regarding Ineq.(10) only introduce very lightweight element-wise matrix operations, which is small compared with the forward and backward process.

## Experimental Results

In this section, we evaluate Basis-path Regularization on deep ReLU neural networks with the aim of verifying that does our proposed BP regularization outperforms other baseline regularization methods and whether it can improve the generalization on the benchmark datasets. For sake of fairness, we reported the mean of 5 independent runs with random initialization.

### Recommendation System

We first apply our basis-path regularization method to recommendation task with MLP networks and conduct experimental studies based on a public dataset, MovieLens. The characteristics of the MovieLens dataset are summarized in Table 1. We use the version containing one million ratings, where each user has at least 20 ratings. We train an NCF framework with similar MLP network proposed in [He et al.2017] and followed their training strategies with Adam optimizer but without any pre-training. We test the predictive factors of [8,16,32,64], and set the number of hidden units to the embedding size in each hidden layer. We calculate both metrics for each test user and report the average score. For each method, we perform a wide range grid search of hyper-parameter from where and report the experimental results based on the best performance on the validation set. The performance of a ranked list is judged by Hit Ratio (HR) and Normalized Discounted Cumulative Gain (NDCG) [He et al.2015].

Figure 3 (a) and (b) show the performance of HR@10 and NDCG@10 w.r.t. the number of predictive factors. From this figure, it’s clear to see that basis-path regularization achieve better generalization performance than all baseline methods. Figure 3 (c) and (d) show the performance of Top-K recommended lists where the ranking position K ranges from 1 to 10. As can be seen, the basis-path regularization demonstrates consistent improvement over other methods across positions, which is consistent with our analysis of generalization error bound in the previous section.

### Image Classification

In this section, we apply our basis-path regularization to this task and conduct experimental studies based on CIFAR-10 [Krizhevsky and Hinton2009], with 10 classes of images. We employ a popular deep convolutional ReLU model, ResNet [He et al.2016] for image classification since it achieves huge successes in many image related tasks. In addition, we conduct our studies on a stacked deep CNN described in [He et al.2016] (refer to PlainNet), which suffers serious dependency among the paths. We train 34 layers ResNet and PlainNet networks on this dataset, and use SGD with widely used weight decay regularization (WD) as our baseline. In addition, we implement Q-SGD, which is proposed in [Meng et al.2018] and optimize the networks on basis paths. We investigate the combination of SGD/Q-SGD and basis-path regularization (BPR). Similar with the previous task, we perform a wide range grid search of from , where . More training details can be found in supplementary materials.

Table 2 shows the training and test results of each algorithms. From the figure and table, we can see that our basis-path regularization indeed improves test accuracy of PlainNet34 and Resnet34 by nearly 1.8% and 1.5% respectively. Moreover, the training behaviors of SGD with weight decay and basis-path regularization are quite similar, but the basis-path regularization can always find better generalization points during optimization, which is consistent with our theoretical analysis in the previous section. We further investigate the combination of Q-SGD and basis-path regularization. Q-SGD with basis-path regularization achieves the best test accuracy on both PlainNet and ResNet model, which indicates that taking BP norm as the regularization term to the loss function is helpful for optimization algorithms.

## Conclusion

In this paper, we define Basis-path norm on the group of basis paths, and prove that the generalization error of ReLU neural networks can be upper bounded by a function of BP norm. We then design Basis-path regularization method, which shows clearly performance gain on generalization ability. For future work, we plan to test basis-path regularization on larger networks and datasets. Furthermore, we are also interested in applying basis-path regularization on networks with different architecture.

## Supplementary: Capacity Control of ReLU Neural Networks by Basis-path Norm

This document contains supplementary theoretical materials and additional experimental details of the paper "Capacity Control of ReLU Neural Networks by Essential Path Norm".

## Skeleton Method to Construct Basis-Path

We briefly review the construction of basis-paths. For an -layer feedforward neural network with width , skeleton methods [Meng et al.2018] construct basis paths following two steps:

(1) Select skeleton weights: The skeleton weights are the diagonal elements in weight matrix , . For , select elements . For , select elements . All the selected weights are called skeleton weights. Others are called non-skeleton weights.

(2) Construct basis-paths: The paths contains no more than one non-skeleton weights are basis-paths.

In [Meng et al.2018], the authors also proved the following properties of basis-paths: each non-skeleton weight will only appear in one basis-path.

## Proof of Proposition 1

###### Proposition 2

For any non-basis path , , where .

Proof: We prove this proposition by induction. For ease of reference, we use to denote the operator , i.e., where .

(1) If , hidden node () has an ingoing skeleton weight and an outgoing skeleton weight . Then for a non-skeleton path where and , it can be calculated as

 p(i0,i1,i2) (13) = w1(i0,i1)⋅w2(i1,i2) (14) = w1(i0,i1)w2(i1,Mi1(K))⋅w1(Mi1(d),i1)w2(i1,i2)w1(Mi1(d),i1)⋅w2(i1,Mi1(K)) (15) = p(i0,i1,Mi1(K))⋅p(Mi1(d),i1,i2)p(Mi1(d),i1,Mi1(K)). (16)

According to skeleton method, , , are all basis-paths. We can see that the basis-path such as which contains no non-skeleton weights is in the denominator. The basis-path which contains one skeleton weight such as and is in the numerator. An example is shown in Figure 1 in the main paper.

(2) If the proposition is satisfied for a -layer FNN, i.e.,

 p(i0,⋯,iL−1)=L−1∏l=1wl(il−1,il)=∏l≤L−1pl(wil−1,il)∏jpj,

where is the basis-path which contains non-skeleton weight 333If is a non-skeleton weight. Otherwise, it will not appear in the numerator. and denotes a basis-path which only contains skeleton weights.

Then for a -layer FNN, a non-basis path can be calculated as

 p(i0,⋯,iL−1,iL) = L∏l=1wl(il−1,il) = wL(iL−1,iL)⋅∏l≤L−1pl(wl(il−1,il))⋅wL(wl(il−1,il))∏jpj⋅∏lwL(wl(il−1,il)) = pL(wL(iL−1,iL))∏L−1l=1wl(wL(iL−1,iL))⋅∏l≤L−1pl(wl(il−1,il))∏jpj⋅∏l≤L−1wL(wl(il−1,il)) = ∏l≤Lpl(wl(il−1,il))∏j~pj,

where is the skeleton weight at layer which connects the basis-path that contains , and denotes the skeleton weight at layer that connects the weight . Because are all skeleton weights, is the value of a basis-path in a layer FNN. The establishing of the above equality also uses the fact that is a basis-path for a L-layer FNN because it contains only one non-skeleton weight . Combining together, we can get that the denominator is a basis-path which contains only skeleton weight.

Therefore, we prove that basis-path which contains one non-skeleton weight will only appear in the numerator and basis-path which only contains skeleton weights will only appear in the denominator in the calculation of the non-basis paths.

All experiments were conducted with Pytorch commit 2b47480. The ResNet implementation can be found in (https://github.com/pytorch/vision/

). Unless noted the initialization method was used by sampling values from a uniform distribution with range

, where ,

is the dimension of previous layer, which is the default initialization method for linear layers and convolutional layers in PyTorch.

### Experiment settings

#### Empirical Verification

Multi-layer perceptrons with ReLU activation were trained by SGD in this experiments. The max iteration number is 500 epochs. The initial learning rate is set to 0.05 for each model. Exponential decay is a wildly used method when training neural network models

[Hinton et al.2012, Ruder2016], which is applied to the learning rate in this experiments with power 0.01. Mini-batch size with 128 was performed in this experiments.

#### Recommendation System

For the recommendation system experiments, to evaluate the performance of item recommendation, we employed the leave-one-out evaluation, which has been widely used in literatures [Bayer et al.2017, He et al.2017]. For each user, we held-out the latest interaction as the test set and utilized the remaining data for training. We followed the common strategy that randomly samples 100 items that are not interacted by the user, ranking the test item among the 100 items.

#### Image Classification

For the image classification experiment, we use the original RGB image of CIFAR-10 dataset with size 3 32 32. As before, we re-scale each pixel value to the interval [0, 1]. We then extract random crops (and their horizontal flips) of size 3 28 28 pixels and present these to the network in mini-batches of size 128. The training and test loss and the test error are only computed from the center patch (3 28 28).

We trained 34 layers ResNet and PlainNet models (refer to resnet34 and plain34 in the original paper respectively) on this dataset. We performed training for 64k iterations, with a mini-batch size of 128, and an initial learning rate of 1.0 which was divided by 10 at 32k and 48k iterations following the practice in the original paper.

### Experimental Results on the Influence of λ

As for different model and norm, the should be selected carefully. As described in image classification task section in the main paper, we performed a wide range of grid search for each norm from , where , and reported the best performance based on the validation set. In this section, we show how affect our basis-path regularization. The results are given in Figure 4. Each result is reported by 5 independent runs with random initialization. Please note that too large value of ( in this setting) will lead to diverge, meanwhile too small will make the regularization influence nearly disappear. A proper will lead to significant better accuracy.