Title: NONPARAMETRIC NEURAL NETWORKS

Abstract: Automatically determining the optimal size of a neural network for a given task without prior information currently requires an expensive global search and training many networks from scratch. In this paper, we address the problem of automatically finding a good network size during a single training cycle. We introduce nonparametric neural networks, a non-probabilistic framework for conducting optimization over all possible network sizes and prove its soundness when network growth is limited via an p penalty. We train networks under this framework by continuously adding new units while eliminating redundant units via an 2 penalty. We employ a novel optimization algorithm, which we term "Adaptive Radial-Angular Gradient Descent" or AdaRad, and obtain promising results.
Training nonparametric networks is more difficult than training parametric networks, because the space over which we optimize the parameter (d, W) is no longer a space of form R d , but is an infinite, discrete union of such spaces. However, we would still like to utilize local, gradient-based search. We notice, like (Wei et al., 2016) , that there are pairs of parameter values with different dimensionality that are still in some sense "close" to one another. Specifically, we say that two parameter values
where not necessarily d 1 = d 2 . During iterative optimization, we can "jump" between those two parameter values while maintaining the output of f and thus preserving locality. We define a zero unit as any unit for which either the fan-in or fan-out or both are the zero vector. Given any parameter value, the most obvious way of generating another parameter value that is f -equivalent to it is to add a zero unit to any hidden layer l where σ l (0) = 0 holds. Further, if we have a parameter value

1. INTRODUCTION:

Automatically choosing a neural network model for a given task without prior information is a challenging problem. Formally, let Θ be the space of all models considered. The goal of model selection is then, usually, to find the value of the hyperparameter θ ∈ Θ that minimizes a certain criterion c(θ), such as the validation error achieved by the model represented by θ when trained to convergence. Because Θ is large, structured and heterogeneous, c is complex, and gradients of c are generally not available, the most popular methods for optimizing c perform zero-order, black-box optimization and do not use any information about c except its value for certain values of θ. These methods select one or more values of θ, compute c at those values and, based on the results, select new values of θ until convergence is achieved or a time limit is reached. The most popular such methods are grid search, random search (e.g. Bergstra & Bengio (2012) ) and Bayesian optimization using Gaussian processes (e.g. Snoek et al. (2012) ). Others utilize random forests (Hutter et al., 2009) , deep neural networks (Snoek et al., 2015) and recently Bayesian neural networks (Springenberg et al., 2016) and reinforcement learning (Zoph & Le, 2017) . These black-box methods have two drawbacks. (A) To obtain each value of c, they execute a full network training run. Each run can take days on many cores or multiple GPUs. (B) They do not exploit opportunities to improve the value of c further by altering θ during each training run. In this paper, we present a framework we term nonparametric neural networks for selecting network size. We dynamically and automatically shrink and expand the network as needed to select a good network size during a single training run. Further, by altering network size during training, the network ultimately chosen can achieve a higher accuracy than networks of the same size that are trained from scratch and, in some cases, achieve a higher accuracy than is possible by black-box methods.

There has been a recent surge of interest in eliminating unnecessary units from neural networks, either during training or after training is complete. This strategy is called pruning. Alvarez & Salzmann (2016) utilize an 2 penalty to eliminate units and Molchanov et al. (2017) compare a variety of strategies, whereas Figurnov et al. (2016) focuses on thinning convolutional layers in the spatial dimensions. While some of these methods even allow some previously pruned units to be added back in (e.g. Feng & Darrell (2015) ), all of these strategies require a high-performing network model as a starting point from which to prune, something that is generally only available in well-studied vision and NLP tasks. We do not require such a starting point in this paper.

In section 2, we introduce the nonparametric framework and state its theoretical soundness, which we prove in section 7.1. In section 3, we develop the machinery for training nonparametric networks, including a novel normalization layer in section 3.2, CapNorm, and a novel training algorithm in section 3.3, AdaRad. We provide experimental evaluation and analysis in section 4, further relevant literature in section 5 and conclude in section 6.

2. NONPARAMETRIC NEURAL NETWORKS:

For the purpose of this section, we define a parametric neural network as a function f (x) = σ L .(σ L-1 .(..σ 2 .(σ 1 .(xW 1 )W 2 )..)W L ) of a d 0 -dimensional row vector x, where W l ∈ R d l-1 * d l , 1 ≤ l ≤ L are dense weight matrices of fixed dimension and σ l : R → R, 1 ≤ l ≤ L are fixed non-linear transformations that are applied elementwise, as signified by the .() operator. The number of layers L is also fixed. Further, the weight matrices are trained by solving the minimization problem min W=(W ) l 1 |D| (x,y)∈D e(f (W, x), y) + Ω(W), where D is the dataset, e is an error function that consumes a vector of fixed size d L and the label y, and Ω is the regularizer.

We define a nonparametric neural network in the same way, except that the dimensionality of the weight matrices is undetermined. Hence, the optimization problem becomes There is no guarantee that optimization problem 1 has a global minimum. We may be able to reduce the value of the objective further and further by using larger and larger networks. This would be problematic, because as networks become better and better with regards to the objective, they would become more and more undesirable in practice. It turns out that in an important case, this degeneration does not occur. Define the fan-in regularizer Ω in and the fan-out regularizer Ω out as

Ω in (W, λ, p) = λ L l=1 d l j=1

||[W l (1, j), W l (2, j), .., W l (d l-1 , j)]|| p

(2)

EQUATION

In plain language, we either penalize the incoming weights (fan-in) of each unit with a p-norm, or the outgoing weights (fan-out) of each unit. We now state the core theorem that justifies our formulation of nonparametric networks. The proof is found in the appendix in section 7.1.

Theorem 1. Nonparametric neural networks achieve a global training error minimum at some finite dimensionality when Ω is a fan-in or a fan-out regularizer with λ > 0 and 1 ≤ p < ∞.

that already contains a zero unit in such a hidden layer, removing it yields an f -equivalent parameter value.

Thus, we will use the following strategy for training nonparametric networks. We use gradient-based methods to adjust W while periodically adding and removing zero units. We use only nonlinearities that satisfy σ(0) = 0. It should be noted that while adding and removing zero units leaves the output of f invariant, it does change the value of the fan-in and fan-out regularizers and thus the value of the objective. While it is possible to design regularizers that do not penalize such zero units, this is highly undesirable as it would stifle the regularizers ability to "reign in" the growth of the network during training.

To be able to reduce the network size during training, we must produce zero units and, it turns out, the fan-in and fan-out regularizers naturally produce such units as they induce sparsity, i.e. they cause individual weights to become exactly zero. This is well studied under the umbrella of sparse regression (see e.g. Tibshirani (1996) ). The cases p = 1 and p = 2 are especially attractive because it is computationally convenient to integrate them into a gradient-based optimization framework via a shrinkage / group shrinkage operator respectively (see e.g. Back & Teboulle (2006) ). Further, p = 1 and p = 2 differ in their effect on the parameter value. p = 1 sets individual weights to zero and thus leads to sparse fan-ins and fan-outs and thus ultimately to sparse weight matrices. A unit can only become a zero unit if each weight in its fan-in or each weight in its fan-out has been set to zero individually. p = 2, on the other hand, sets entire fan-ins (for the fan-in regularizer) or fan-outs (for the fan-out regularizer) to zero at once. Once the resulting zero units are removed, we obtain dense weight matrices. (For a basic comparison of 1-norm and 2-norm regularizers, see Yuan & Lin (2006) and for a comparison in the context of neural networks, see Collins & Kohli (2014) .) While there is recent interest in learning very sparse weight matrices (e.g. Guo et al. (2016) ), current hardware is geared towards dense weight matrices (Wen et al., 2016) . Hence, for the remainder of this paper, we will focus on the case p = 2. Further, we will focus on the fan-in rather than the fan-out regularizer.

When a new zero unit is added, we must choose its fan-in and fan-out. While one of the two weight vectors must be zero, the other can have an arbitrary value. We make the simple choice of initializing the other weight vector randomly. Since we are going to use the fan-in regularizer, we will initialize the fan-out to zero and the fan-in randomly. This will give each new unit the chance to learn and become useful before the regularizer can shrink its fan-in to zero. If it does become zero nonetheless, the unit is eliminated.

3.1. SELF-SIMILAR NONLINEARITIES:

For layers 1 through L -1, it is best to use nonlinearities that satisfy σ(cs) = cσ(s) for all c ∈ R ≥0 and s ∈ R. We call such nonlinearities self-similar. ReLU (Dahl et al., 2013) is an example of this. Self-similarity also implies σ(0) = 0.

Recall that the fan-in and fan-out regularizers shrink the values of weights during training. This in turn affects the scale of the values to which the nonlinearities are applied. (These values are called pre-activations.) The advantage of self-similar nonlinearities is that this change of scale does not affect the shape of the feature.

In contrast, the impact of a nonlinearity such as tanh on pre-activations varies greatly based on their scale. If the pre-activations have very large absolute values, tanh effectively has a binary output.

If they have very small absolute values, tanh mimics a linear function. In fact, all nonlinearities that are differentiable at 0 behave approximately like a linear function if the pre-activations have sufficiently small absolute values. This would render the unit ineffective. Since we expect some units to have small pre-activations due to shrinkage, this is undesirable.

By being invariant to the scale of pre-activations, self-similar nonlinearities further eliminate the need to tune how much regularization to assign to each layer. This is expressed in the following proposition which is proved in section 7.2.

Proposition 1. If all nonlinearities in a nonparametric network model except possibly σ L are selfsimilar, then the objective function 1 using a fan-in or fan-out regularizer with different regularization parameters λ 1 , .., λ L for each layer is equivalent to the same objective function using the single regularization parameter λ = ( L l=1 λ l )

1 L for each layer, up to rescaling of weights.

input: α r : radial step size; α φ : angular step size; λ: regularization hyperparameter; β: mixing rate; : numerical stabilizer; d 0 : initial dimensions; W 0 : initial weights; ν: unit addition rate; ν freq : unit addition frequency; T : number of iterations φ max = 0; c max = 0; d = d 0 ; W = W 0 ; for l = 1 to L do set φl (angular quadratic running average) and c l (angular quadratic running average capacity) to zero vectors of size d 0 l ; end for t = 1 to T do set D t to mini-batch used at iteration t; end end end return W; Algorithm 1: AdaRad with 2 fan-in regularizer and the unit addition / removal scheme used in this paper in its most instructive (bot not fastest) order of computation. Note that [] i notation is used to indicate a vector over index i.

G = 1 |D| ∇ W (x,y)∈D t e(f (W, x), y); for l = L to 1 do for j = d l to 1 do decompose [G l (i, j)] i into a component parallel to [W l (i, j)] i (call it r) and a component orthogonal to [W l (i, j)] i (call it φ) such that [G l (i, j)] i = r + φ; φl (j) = (1 -β) φl (j) + β||φ|| 2 2 ; c l (j) = (1 -β)c l (j) + β; φ max = max(φ max , φl (j)); c max = max(c max , c l (j)) ; φ adj = φmax cmax φl (j) c l (j) + φ; [W l (i, j)] i = [W l (i, j)] i -α r r ; rotate [W l (i, j)] i by angle α φ ||φ adj || 2 in direction - φadj ||φadj||2 ; shrink([W l (i, j)] i , α r λ |D t | |D| ); if l < L and [W l (i, j)] i is

3.2. CAPPED BATCH NORMALIZATION (CapNorm):

Recently, Ioffe & Szegedy (2015) proposed a strategy called batch normalization that quickly became the standard for keeping feed-forward networks well-conditioned during training. In our experiments, nonparametric networks trained without batch normalization could not compete with parametric networks trained with it. Batch normalization cannot be applied directly to nonparametric networks with a fan-in or fan-out regularizer, as it would allow us to shrink the absolute value of individual weights arbitrarily while compensating with the batch normalization layer, thus negating the regularizer. Hence, we make a small adjustment which results in a strategy we term capped batch normalization or CapNorm. We subtract the mean of the pre-activations of each hidden unit, but only scale their standard deviation if that standard deviation is greater than one. If it is less than one, we do not scale it. Also, after the normalization, we do not add or multiply the result with a free parameter. Hence, CapNorm replaces each pre-activation z with z-µ max(σ,1) , where µ is the mean and σ is the standard deviation of that unit's pre-activations across the current mini-batch.

Table 1 : Computational cost of efficient implementations of various algorithms, per mini-batch and weight. Operations that do not scale with the number of weights are not included. Operations associated with the computation of the gradient of the loss term (e.g. lines 7 and 8 in algorithm 1) as well as unit addition and removal (e.g. lines 18 to 24 in algorithm 1) are not included as they do not vary between algorithms.

Algorithm:

Network The staple method for training neural networks is stochastic gradient descent. Further, there are several popular variants: momentum and Nesterov momentum (Sutskever et al., 2013) , AdaGrad (Duchi et al., 2011) and AdaDelta (Zeiler, 2012), RMSprop (Tieleman & Hinton, 2012) and Adam (Kingma & Ba, 2015) . All of these methods center around two key principles: (1) averaging the gradient obtained over consecutive iterations to smooth out oscillations and ( 2) normalizing each component of the gradient so that each weight learns at roughly the same speed. Principle (2) turns out to be especially important for nonparametric neural networks. When a new unit is added, it does not initially contribute to the quality of the output of the network and so does not receive much gradient from the loss term. If the gradient is not normalized, that unit may take a very long time to learn anything useful. However, if we use a fan-in regularizer, we cannot normalize the components of the gradient outright as in e.g. RMSprop, as we would also have to scale the amount of shrinkage induced by the regularizer accordingly. This, in turn, would cause the fan-in of new units to become zero before they can learn anything useful.

We resolve this dilemma with a new training algorithm: Adaptive Radial-Angular Gradient Descent (AdaRad), shown in algorithm 1. Like in all the algorithms cited above, we begin each iteration by computing the gradient G of the loss term over the current mini-batch (line 8). Then, for each 1 ≤ l ≤ L and 1 ≤ j ≤ d l , we decompose the sub-vector [G l (1, j), G l (2, j), .., G l (d l-1 , j)] into a component parallel to its corresponding fan-in [W l (1, j), W l (2, j), .., W l (d l-1 , j)] and a component orthogonal to it (line 11). Out of the two, we normalize only the orthogonal component (line 14) while the parallel component is left unaltered. Finally, the normalized orthogonal component of each sub-vector is added to its corresponding fan-in in radial-angular coordinates instead of cartesian coordinates (line 16). This ensures that it does not affect the length of the fan-in. Like the parallel component, we leave the induced shrinkage unaltered. Note that 2 shrinkage acts only to shorten the length of each fan-in, but does not alter its direction. Hence, AdaRad with an 2 regularizer applies a normalized shift to each fan-in that alters its direction but not its length (angular shift), as well as an un-normalized shift that includes shrinkage that alters the length of the fan-in but not its direction (radial shift, lines 15 and 17).

AdaRad has two step sizes: One for the radial and one for the angular shift, α r and α φ respectively. This is desirable as they both control the behavior of the training algorithm in different ways. The radial step size controls how long it takes for the fan-in of a unit to be shrunk to zero, i.e. the time a unit has to learn something useful. On the other hand, the angular step size controls the general speed of learning and is tuned to achieve the quickest possible descent along the error surface.

Like RMSprop and unlike Adam, AdaRad does not make use of the principle of momentum. We have developed a variant called AdaRad-M that does. It is described in the appendix in section 7.3.

Using AdaRad over SGD incurs additional computational cost. However, that cost scales more gracefully than the cost of, for example, RMSprop. AdaRad normalizes at the granularity of fan-ins instead of the granularity of individual weights, so many of its operations scale only with the number of units and not with the number of weights in the network. In In color, we show how each element corresponds to our definition of a neural network in section 2. CapNorm does not fully fit our definition of nonlinearity as it requires information from multiple datapoints to compute its value. Hence, theorem 1 and proposition 1 do not technically apply. However, CapNorm is a benign operation that does not lead to problems in practice.

AdaRad and RMSprop. Further, RMSprop has a larger memory footprint than AdaRad. Compared to SGD, it requires an additional cache of size equal to the number of weights, whereas AdaRad only requires 2 additional caches of size equal to the number of units.

4. EXPERIMENTS:

We evaluated our framework using the network architecture shown in Figure 1 with ReLU nonlinearities and CapNorm, and using AdaRad as the training algorithm. We used two hidden layers (L = 3) and started off with ten units in each hidden layer and each fan-in initialized randomly with expected length 1. We add one new unit with random fan-in of expected length 1 and zero fan-out to each layer every epoch. While this does not lead to fast convergence -we have to wait until tens or hundreds of units are added -we believe that growing nets from scratch is a good test case for investigating the robustness of our framework. After the validation error stopped improving, we ceased adding units, allowing all remaining redundant units to be eliminated. We set α r = 1 50λ , as this allows each new unit ≈ 50 epochs to train before being eliminated by shrinkage, assuming the length of the fan-in is not altered by the gradient of the loss term.

When training parametric networks, we replaced CapNorm with batch normalization, either with or without trainable free mean and variance parameters. We trained the network using one of the following algorithms: SGD, momentum, Nesterov momentum, RMSprop or Adam. Further experimental details can be found in the appendix in section 7.4.

4.1. PERFORMANCE:

In this section, we investigate our two core questions: (A) Do nonparametric networks converge to a good size? (B) Do nonparametric networks achieve higher accuracy than parametric networks?

We evaluated our framework using three standard benchmark datasets -the mnist dataset, the rectangles images dataset and the convex dataset (Bergstra & Bengio, 2012) . We started by training nonparametric networks. Through preliminary experiments, we determined a good starting angular step size for all datasets. We chose to start with α φ = 30 and repeatedly divided α φ by 3 when the validation error stopped improving. By varying the random seed, we trained 10 nets each for several values of the regularization parameter λ per dataset and then chose a typical representative from among those 10 trained nets. Results are shown in black in figure 2 . Values of λ are 3 * 10 -3 , 10 -3 and 3 * 10 -4 for MNIST, 3 * 10 -5 and 10 -6 for rectangles images and 10 -5 and 10 -8 for convex. We obtain different results for the three datasets. For mnist, nonparametric networks substantially outperform parametric networks of the same size. The best nonparametric network is close in performance to the best parametric network, while being substantially smaller (144 first layer units versus 694). For rectangles images, nonparametric networks underperform parametric networks of the same size when λ is large and outperform them when λ is small. Here, the best nonparametric network has the globally best performance, as measured by the median test error over 10 random reruns, using substantially fewer parameters than the best parametric network.

While results for the first two datasets are very promising, nonparametric networks performed badly on the convex dataset. Parametric networks of the same size perform substantially better and also have a smaller range of performance across random reruns. Even if the model found by training nonparametric networks were re-trained as a parametric network, the apparent tendency of nonparametric networks to converge to relatively small sizes hurts us here as we would still miss out on a significant amount of performance.

We also conducted experiments with AdaRad-M, but found that performance was very similar to that of AdaRad. Hence, we omit the results. Similarly, we found no significant difference in performance between parametric networks trained with RMSprop and those trained with Adam.

4.2. ANALYSIS OF THE NONPARAMETRIC TRAINING PROCESS:

In this section, we analyze in detail a single training run of a nonparametric network. We chose mnist as dataset, set λ = 3 * 10 -4 and lowered the angular step size to 10 as we did not use step size annealing. We trained for 1000 epochs while adding one unit to each hidden layer per epoch, then trained another 1000 epochs without adding new units. The final network had 193 units in the first hidden layer and 36 units in the second hidden layer. The results are shown in figure 3 .

In part (A), we show the validation classification error. As a comparison, we trained two parametric networks with 193 and 36 hidden units for 1000 epochs, once using SGD and the same step size and λ as the nonparametric network, and once using optimal settings (RMSprop, α = 300, λ = 0). It is not suprising that the parametric networks reach a good accuracy level faster, as the nonparametric network must wait for its units to be added. Also, the parametric network benefits from an increased step size -in this case α = 300. This was true throughout our experimental evaluation. In (B), we show the training cross-entropy error for the same training runs. Interestingly, parametric networks reach an error very close to zero. In fact, the unregularized network reaches a value of ≈ 10 -6 and the regularized network reaches a value of ≈ 10 -4 . Both made zero classification mistakes on the training set after training. In contrast, the nonparametric network did not have a near-zero training cross-entropy error. Towards the end of training, it still misclassified around 30 out of 50.000 training examples. However, this did not harm its performance on the validation or test set. In fact, the validation error of nonparametric networks tended to improve slowly for many epochs, whereas unregularized parametric networks (which were the best parametric networks when early stopping is used) tended to have a slightly increasing validation error in the long run.

In (C), we show the size of the two hidden layers during training. These curves are very typical of all training runs we examined. For the first ≈ 50 epochs, no units are eliminated. This is because we chose α r = 1 50λ , which guarantees that units that are added with a fan-in of length 1 take ≈ 50 epochs to be eliminated, assuming no impact from the gradient of the loss term. If the layer requires a relatively large number of units, it will keep growing linearly for a while and then either plateau or shrink slightly. Once we no longer add units after 1000 epochs, both layers shrink linearly by ≈ 50 units over ≈ 50 iterations, as the units that were added roughly between epochs 950 and 1000 are eliminated in succession. Overall, this process shows the value of controlling α φ and α r independently, as we can manage the "overhead" of extraneous units present during training while still ensuring an ideal speed of learning. In (D), we show the length of time individual units in the first hidden layer were present during training. On the x axis, we show the epoch during which a given unit was added. On the y axis, we show the number of epochs the unit was present. Green bars represent units that survived until the end, while black bars represent units that did not. As one might expect, units were more likely to survive the earlier they were added. Units that did not survive were eliminated in ≈ 50 epochs. The same graph for the second hidden layer is shown in figure 4 .

In (E) and (F), we show the lengths of fan-ins (blue) and fan-outs (red) of units in the hidden layers. For each layer, we depict the following units in dark colors: three randomly chosen units that were initially present as well as units that were added at epochs 0, 25, 50, 100, 200, 300, .., 1000. In addition, in light colors, we show three units that were added late but not eliminated. We see a consistent pattern for individual units. First, their length decreases linearly as the CapNorm layer filters the component of the gradient parallel to the fan-ins as long as the standard deviation of the pre-activations σ exceeds 1. During this period, the unit learns something useful and so the fan-out increases in length. When finally σ < 1, the parallel component of the gradient starts to slow down the decay and, if the unit has become useful enough, reverses it. If the decay is not reversed, the unit is eliminated. If it is reversed, both fan-in and fan-out will attain a length comparable to those of well-established units.

From a global perspective, we notice that fan-ins in the first layer have lengths much less than 1. This is because first layer units encode primarily AND functions of highly correlated input features, meaning weights of small magnitude are sufficient to attain σ = 1. In contrast, lengths of fan-ins in the second layer are more chaotic. We found this is because σ = 1 is generally NOT attained in the second layer. In fact, the network compensated for lower activation values in the second layer by assigning fan-ins of stable lengths between 3.5 and 4.5 to the 10 output units. The network can assign these lengths dynamically without altering the output of the network because ReLU is self-similar, as described in section 3.1.

4.3. SCALABILITY:

Finally, we wanted to verify whether nonparametric networks could be applied to a large dataset. We visited OpenML http://www.openml.org/, a website containing many datasets as well as the performance of various machine learning models applied to those datasets. We applied nonparametric networks to the largest classification dataset1 on OpenML meeting our standards2 . This was the poker dataset http://www.openml.org/d/354. It is a binary classification dataset with 1.025.010 datapoints and 14 features per datapoint. We had no prior information about this dataset. In general, we think that nonparametric networks are most useful in cases with no prior information and thus no possibility of choosing a good parametric model a priori.

We made the following changes to the experimental setup for poker: (i) we used 4 hidden layers instead of 2 (ii) we added a unit every tenth of an epoch instead of every epoch and (iii) we multiplied the radial step size by 10, i.e. α r = 1 5λ . The latter two changes were made as poker is approximately one order of magnitude larger than mnist, and we wanted to approximately preserve the rate of unit addition and elimination per mini-batch. Those changes were made a priori and were not based on examining their performance.

After some exploration, we set the starting angular step size for nonparametric networks to 10. We trained nonparametric networks for various values of λ, obtaining nets of different sizes. We then trained parametric networks of those same sizes with RMSprop, where the step size was chosen by validation, independently for each network size.

The results are shown in Table 2 . Both parametric and nonparametric networks perform very well, achieving less than 1% test error even for small networks. The nonparametric networks had a higher error for larger values of λ and a slightly lower error for smaller values of λ. In fact, the best nonparametric network made no mistake on the test set of 100.000 examples. For comparison, we show that linear models perform roughly as well as random guessing on poker. Also, the best result published on OpenML, achieved by a decision tree classifier, vastly underperforms our 4-hidden layer networks.

To achieve convergence, networks required many more mini-batches on poker than they did on the smaller datasets used in section 4.1. However, since units were added to the nonparametric networks at roughly the same rate per mini-batch, the time it took those networks to converge to a stable network size (as in Figure 3C ) was a much smaller fraction of the overall training time under poker compared to the smaller datasets. Thus, the downside of increased training time as shown in Figure 3A incurred when networks are built gradually was ameliorated.

5. FURTHER BACKGROUND:

Several strategies have been introduced to address the drawbacks of black-box model selection. Maclaurin et al. (2015) indeed calculate the gradient of the validation error after training with respect to certain hyperparameters, though their method only applies to specific networks trained with very specific algorithms. (Luketina et al., 2016) and (Larsen et al., 1998) train certain hyperparameters jointly with the network using second order information. Such methods are limited to continuous hyperparameters and are often applied specifically to regularization hyperparameters. The performance of a network of given size can be improved by injecting knowledge from other nets trained on the same task. Ba & Caruana (2014) use the predictions of a large network on a dataset to train a smaller network on those predictions, achieving an accuracy comparable to the large network. Hinton et al. (2015) compress the information stored in an ensemble of networks into a single network. Simonyan & Zisserman (2015) train very deep convolutional networks by initializing some layers with the trained layers of shallower networks. Romero et al. (2015) train deep, thin networks utilizing hints from wider, shallower networks.

Bayesian neural networks (e.g. McKay (1992) , De Freitas ( 2003)) use a probabilistic prior instead of a regularizer to control the complexity of the network. Gaussian processes can been used to mimick "infinitely wide" neural networks (e.g. Williams (1997), Hazan & Jaakkola (2015) ), thus eliminating the need to choose layer width and replacing it with the need to choose a kernel. Compared to these and other Bayesian approaches, we work within the popular feed-forward function optimization paradigm, which has advantages in terms of computational and algorithmic complexity.

Adding units to a network one at a time is an idea with a long history. Ash (1989) adds units to a single hidden layer, whereas Gallant (1986) builds up pyramid and tower structures and Fahlman & Lebiere (1990) effectively create a new layer for each new unit. While these papers provided inspiration to us, the methods they present for determining when to add a new unit requires training the network to convergence first, which is impractical in modern settings. We circumvent this problem by adding units agnostically and providing a mechanism for removing unnecessary units.

6. CONCLUSION:

We introduced nonparametric neural networks -a simple, general framework for automatically adapting and choosing the size of a neural network during a single training run. We improved the performance of the trained nets beyond what is achieved by regular parametric networks of the same size and obtained results competitive with those of an exhaustive random search, for two of three datasets. While we believe there is room for performance improvement in several areas -e.g. unit initialization, unit addition schedule, additional regularization and starting network size -we see this paper as validation of the basic concept. We also proved the theoretical soundness of the framework.

In future work, we plan to extend our framework to include convolutional layers and to automatically choosing the depth of networks, as done by e.g. Wen et al. (2016) . Part of our motivation to develop nonparametric networks was to control the layer size via a continuous parameter. We want to make use of this by tuning λ during training, either by simple annealing or in a comprehensive framework such as the one introduced in Luketina et al. (2016) . We want to use nonparametric networks to learn more complicated network topologies for e.g. semi-supervised or multi-task learning. Finally, we plan to investigate the possibility of sampling units with different nonlinearities and training an ever-growing network for lifelong learning. • error functions e : (R d L × Y ) → R that fulfils the following conditions:

-It is non-negative everywhere.

-It is differentiable with respect to its first argument everywhere.

-There exists a function b

EQUATION

attains a global minimum.

Most commonly used nonlinearities are admissible under this theorem as long as σ(0) = 0, i.e. the sigmoid non-linearity is not admissible, but the tanh non-linearity is. Note that nonlinearities, away from zero, are allowed to grow at an almost arbitrary pace. For example, polynomial or even exponential nonlinearities are possible. Note that the first condition on nonlinearities is technically implied by the other two as long as σ(0) = 0, though we will not prove this.

The conditions for the error function cover the two most popular choices: cross-entropy coupled with softmax (as in Figure 1 ) -and the square of the 2 distance.

We will prove this theorem through a sequence of lemmas. Throughout this process, all inputs to the main theorem are considered fixed and fulfilling their respective conditions. Lemma 1. Theorem 1 holds if d is fixed.

I.e. in the parametric case, 4 attains a global minimum.

Proof. • D = {(x (0) , y (0) ), (x (1) , y (1) ), .., (x (N ) , y (N ) )}

• We denote intermediate computations of the neural network f (W, x) as follows:

EQUATION

• We denote the gradients of e(f (W, x), y), when they are defined, as follows:

EQUATION

• Vector and matrix indeces are written in brackets. For example, the j'th component of z

(n) l is denoted by z (n) l (j).

• We denote by square brackets a vector and by its subscript the index the vector is over, e.g.

[v i ] i is a vector over index i.

Lemma 2. Under the conditions of theorem 1 and the additional condition that the σ l are differentiable everywhere, if Ω is the fan-in regularizer, then for all B, the set of values of d for which there exist proper B-local minima is bounded. Lemma 3. Under the conditions of theorem 1 and the additional condition that the σ l are differentiable everywhere, if Ω is the fan-out regularizer, then for all B, the set of values of d for which there exist proper B-local minima is bounded.

Lemmas 2 and 3 are the core segments of the overall proof. Here we show that that very large nets have no "good" local minima.

Proof of lemma 2. Throughout this proof, we consider B fixed.

Claim 1a: There exist constants B x,l , 0 ≤ l ≤ L, such that at all proper B-local minima, for all 1 ≤ n ≤ N , for all 0 ≤ l ≤ L, we have ||x

(n) l || 1 ≤ B x,l

. Claim 1b: There exist constants B z,l , 1 ≤ l ≤ L, such that at all proper B-local minima, for all 1 ≤ n ≤ N , for all 1 ≤ l ≤ L, we have ||z

(n) l || 1 ≤ B z,l .

Claim 1c: There exist constants B dσ,l , 1 ≤ l ≤ L, such that at all proper B-local minima, for all 1 ≤ n ≤ N , for all 1 ≤ l ≤ L, for all 1 ≤ j ≤ d l , we have |σ (z

(n) l (j))| ≤ B dσ,l .

First, we notice that it is sufficient to prove the bounds exist for a specific datapoint. The uniform bound across all datapoints is then simply the maximum of the individual bounds. Denote by (x, y) an arbitrary fixed datapoint throughout the proof of the above claims. Also, notice that the claims are trivially true if there are no proper B-local minima. Hence, throughout the proof of the claims, we assume there exists at least one such minimum.

We will prove the claims jointly by induction. The order of the induction follows the order of computation of the neural network. Our starting case will be x 0 , followed by z 1 , f 1 and x 1 etc.

The starting case is obvious as x 0 = x is fixed and does not depend on the parameter (d, W). Hence we can choose B x,0 = ||x|| 1 .

Now assume we have:

EQUATION

≤ sup

EQUATION

≤ sup

EQUATION

A line-by-line explanation of the above is as follows:

13 Replacing z l by its definition.

14 Relaxing the conditions on (d, W) by replacing proper B-local minimality by two conditions that proper B-local minimality implies. The first condition is the induction hypothesis. The second condition follows because E ≤ B and so specifically Ω in (W) ≤ B and so specifically Ω in (W l ) ≤ B 15 Breaking up the supremum into three stages. We drop components of d and W that are immaterial to the value of the objective of the supremum.

16 We further relax the innermost sup by no longer requiring that x l-1 be the intermediate output of some neural network but an arbitrary vector of fixed size and limited length. W <l then becomes immaterial.

17 Replacing the 1 norm by its definition.

18 We fix the length of each fan-in in the second sup and add an additional sup over these lengths.

19 Jensen's inequality 20 Simplifying the notation by replacing rows of W l by vector v.

21 Relaxing the conditions on v.

22 Using an elementary property of norms.

23. obvious 24 obvious:

And therefore, we may choose B z,l = Claim 2a: There exist constants B g,l , 0 ≤ l ≤ L, such that at all proper B-local minima, for all 1 ≤ n ≤ N , for all 0 ≤ l ≤ L, for all 1 ≤ i ≤ d l , we have |g

(n) l (i)| ≤ B g,l .

Claim 2b: There exist constants B h,l , 1 ≤ l ≤ L, such that at all proper B-local minima, for all 1 ≤ n ≤ N , for all 1 ≤ l ≤ L, for all 1 ≤ i ≤ d l , we have |h

(n) l (i)| ≤ B h,l .

Again, we can restrict our attention to a single datapoint and again, we will prove these claims by induction, but going backwards along the flow of the gradient. The starting case is g L . At all proper B-local minima, E ≤ B, so specifically e(x L , y) ≤ B and therefore we have 

||g L || ∞ = || de(x L ,y) dx L || ∞ ≤ b 3 (B)

(i)| = | de dz l (i) | = | de dx l (i) dx l (i) dz l (i) | = |g l (i)||σ (z l (i))| ≤ B g,l B dσ,l . Therefore we can choose B h,l = B g,l B dσ,l as required.

Finally, assume we have B h,l . Then we have

|g l-1 (i)| = | de dx l-1 (i) | = | d l j=1 de dz l (j) dz l (j) dx l (i) | = | d l j=1 h l (j)W l (i, j)| ≤ d l j=1 |h l (j)||W l (i, j)| ≤ B h,l d l j=1 |W l (i, j)| ≤ B h,l d l j=1 ||[W l (i, j)] i || p ≤ B h,l B

, so we can choose B g,l-1 = B h,l B as required. Claim 3: There is a constant B 2 , such that at all proper B-local minima, for all 1 ≤ l ≤ L, for all 1 ≤ j ≤ d l , we have

N n=1 |g (n) l (j)| ≥ B 2 .

At any proper parameter value, all fan-ins are non-zero. Therefore Ω is differentiable with respect to W, and therefore E is differentiable with respect to W. Hence, at any proper B-local minimum, we have ∇ W E = 0, so in particular for any l, j we have

dE d[W l (i,j)]i = 0, so 1 N N n=1 de d[W l (i,j)]i = -dΩ d[W l (i,j)]i and so specifically || 1 N N n=1 de d[W l (i,j)]i || p p-1 = || dΩ d[W l (i,j)]i || p p-1

, where p p-1 can take the value ∞. Further analyzing the right hand side, we have

|| dΩ d[W l (i,j)]i || p p-1 = || d(λ||[W l (i,j)]i||p) d[W l (i,j)]i || p p-1 = λ.

Therefore, at all proper B-local minima we have:

EQUATION

EQUATION

EQUATION

Hence, we can choose B 2 = max 1≤l≤L λN B dσ,l B x,l-1 as required. Note that in the above equations, we have omitted all (n) superscripts for brevity.

Claim 4: There exist constants D l , 1 ≤ l ≤ L such that at all proper B-local minima, for all

1 ≤ l ≤ L, we have d l ≤ D l .

Note that this claim is tantamount to proving the hypothesis of the Lemma.

We will prove this by induction going backwards. Since d L is fixed, we can simply pick D L = d L . Now assume we have a valid D l+1 . Then at all proper B-local minima we have

EQUATION

EQUATION

Therefore, by the box principle, there exists an n and j such that

d l i=1 |W l+1 (i, j )h (n ) l+1 (j )| ≥ d l B2 d l+1 N

. So further, we have

EQUATION

≤ |h

EQUATION

And therefore,

d l ≤ ( BB h,l+1 N d l+1 B2

) p and so we can choose D l = (

BB h,l+1 N D l+1 B2

) p , which completes the proof.

For brevity, we will only give a summary of the proof of lemma 3, as it is very similar to the proof of lemma 2.

Sketch of proof of lemma 3. As in the previous proof, we consider B fixed.

Claim 1a: There exist constants B x,l , 0 ≤ l ≤ L, such that at all proper B-local minima, for all 1 ≤ n ≤ N , for all 0 ≤ l ≤ L, for all 1 ≤ j ≤ d l , we have |x

(n) l (j)| ≤ B x,l .

Claim 1b: There exist constants B z,l , 1 ≤ l ≤ L, such that at all proper B-local minima, for all 1 ≤ n ≤ N , for all 1 ≤ l ≤ L, for all 1 ≤ j ≤ d l , we have |z

(n) l (j)| ≤ B z,l .

Claim 1c: There exist constants B dσ,l , 1 ≤ l ≤ L, such that at all proper B-local minima, for all 1 ≤ n ≤ N , for all 1 ≤ l ≤ L, for all 1 ≤ j ≤ d l , we have |σ (z

(n) l (j))| ≤ B dσ,l .

As in the previous proof, we proceed by induction along the order of feed-forward execution of the neural network. However, we use the arguments we used for Claims 2(a)-(b) in the previous proof. This is because the fan-out regularizer "appears" like a fan-in regularizer when the direction of signal flow is reversed.

Claim 2a: There exist constants B g,l , 0 ≤ l ≤ L, such that at all proper B-local minima, for all 1 ≤ n ≤ N , for all 0 ≤ l ≤ L, we have ||g

(n) l || 1 ≤ B g,l .

Claim 2b: There exist constants B h,l , 1 ≤ l ≤ L, such that at all proper B-local minima, for all 1 ≤ n ≤ N , for all 1 ≤ l ≤ L, we have ||h

(n) l || 1 ≤ B h,l .

As in the previous proof, we proceed by induction along the flow of the gradient. However, we use the arguments we used for Claims 1(a)-(c) in the previous proof.

Claim 3: There is a constant B 2 , such that at all proper B-local minima, for all 0 ≤ l ≤ L -1, for all 1 ≤ j ≤ d l , we have

N n=1 |x (n) l (j)| ≥ B 2 . Claim 4: There exist constants D l , 0 ≤ l ≤ L -1 such that at all proper B-local minima, for all 0 ≤ l ≤ L -1, we have d l ≤ D l .

The arguments mirror those of Claim 3 and 4 from the previous proof, but with the role of activation and gradient reversed. Also, here, Claim 4 is proved by induction along the order of feed-forward execution.

Lemma 4. Under the conditions of theorem 1, for all B, the set of values of d for which there exist proper B-local minima is bounded. This is the stronger version of the previous lemmas where we only use directional differentiability of the σ l instead of actual differentiability. The proof is a rather tedious extension of the previous two proofs and not very instructive, which is why we broke out the differential case as its own lemmas. Following this lemma, we immediately prove the main theorem.

Proof. We will describe how to amend the proof of lemma 2. The proof of lemma 3 can be amended similarly.

First, we define a signature S with dimensionality d as a binary sequence of vectors. Then, for all d, x ∈ R d0 , W of dimensionality d and S of dimensionality d, we define a linearized neural network that is linearized at point x with weights W and signature S f [S,W ,x ] as follows: First, obtain x l and z l for 1 ≤ l ≤ L by evaluating f (W , x ) as usual. Then, for each σ l used in f , define a vector of functions σ

[S,W ,x ] l

, where each element is a linear function with σ

[S,W ,x ] l (j)(z l (j)) = σ l (z l (j))

and with

dσ [S,W ,x ] l (j)(s) ds = σ ← l (z l (j)) if S l (j) = 0 and with dσ [S,W ,x ] l (j)(s) ds = σ → l (z l (j)) if S l (j) = 1. Finally, we obtain f [S,W ,x ] from f by, for each 1 ≤ l ≤ L, replacing σ l that is applied elementwise with σ [S,W ,x ] l

where each component is applied to the respective component of z l .

In plain language, we linearize a neural network at a point by evaluating it at that point and replacing each nonlinearity by a straight line as indicated by the value and directional derivative of that nonlinearity wherever it is evaluated, where the direction of the derivative used is governed by S.

Similarly, define a partially linearized neural network f [S ≥l ,W ,x ] in the same fashion, except only layers l and above are linearized. Finally, define a partially linearized neural network f [S ≥l,i ,W ,x ] in the same fashion, except only layers l and above as well as unit i in layer l -1 are linearized.

e is composed of functions that are differentiable or directionally differentiable with respect to W, so e itself is directionally differentiable with respect to W. Specifically, let us analyze the directional derivative of e with respect to some perturbation of W L-1 .

EQUATION

= ((((

EQUATION

Here, a * superscript is a "wildcard" that can stand for a left or a right derivative. When combined with the .() elementwise operation, it can mean a different derivative (left or right) for each element.

We use the chain rule for directional derivatives (lines 47, 50 and 54), the linearity of the directional derivative (lines 52 and 55), the fact that the directional derivative of a differentiable function is the dot product of its gradient with the perturbation (line 48), and the fact that the directional derivative of a left-and right-differentiable scalar function is either the product of its left derivative with the perturbation or the product of its right derivative with the perturbation (lines 51 and 54).

We notice that the final expression in line 57 is the same expression we would obtain if the σ l were differentiable, except with a * instead of a superscript. Now the linearized neural networks come into play. We can choose a signature S that matches the wildcards in the above directional derivative and get

∇ δW L-1 e(f (W, x), y) = de(f [S,W,x] (W,x),y) dW L-1

.δW L-1 , because the forward evaluation of ,x] and f are identical at x and the backward evaluation picks out the correct left and right derivatives. In fact, it is sufficient to choose a partially linearized network with signature S ≥L-1 to achieve the above identity.

f [S,W

So far, we have investigated the directional derivative with respect to δW L-1 . However, the same arguments hold for all 1 ≤ l ≤ L. We can expand ∇ δW l e(f (W, x), y) in the same way, except we repeat the transformation from line 48 to line 53 L -l times. Hence, we have what we will call claim 0.

Claim 0: For all (d, W), for all x ∈ R d0 , for all 1 ≤ l ≤ L, for all δW l , we can choose a signature S or a partial signature S ≥l , such that ∇ δW l e(f (W, x), y) = de(f [S,W,x] (W,x),y)

dW l .δW l .

Now, we refer back to the proof of lemma 2. Claims 1(a)-(c) hold as before, except in Claim 1(c) we replace |σ (z

(n) l (j))| ≤ B dσ,l with |σ ← (z (n) l (j))| ≤ B dσ,l and |σ → (z (n) l (j))| ≤ B dσ,l .

Further, note that claims 1(a)-(c) also hold for neural networks that are linearized at the respective B-local minimum and datapoint at which they are evaluated.

Claims 2(a)-(b) are changed as follows::

Claim 2a: There exist constants B g,l , 0 ≤ l ≤ L, such that at all proper B-local minima, for all 1 ≤ n ≤ N , for all 0 ≤ l ≤ L, for all 1 ≤ i ≤ d l , for all signatures S or partial signatures S ≥l+1 of matching dimensionality we have |g

(n)[S,W,x (n) ] l (i)| ≤ B g,l .

Claim 2b: There exist constants B h,l , 1 ≤ l ≤ L, such that at all proper B-local minima, for all 1 ≤ n ≤ N , for all 1 ≤ l ≤ L, for all 1 ≤ i ≤ d l , for all signatures S or partial signatures S ≥l+1,i of matching dimensionality we have |h

(n)[S,W,x (n) ] l (i)| ≤ B h,l .

The proof is as before, where derivatives of the σ l are again replaced by a left or right derivative as indicated by the signature.

Claim 3 and its proof change somewhat.:

Claim 3: There exists a constant B 2 , such that at all proper B-local minima, for all 1 ≤ l ≤ L, for all 1 ≤ j ≤ d l , we have

N n=1 S ≥l+1 |g (n)[S ≥l+1 ,W,x (n) ] l (j)| ≥ B 2

, where S ≥l+1 is the sum over all partial signatures.

At line 65, we use the chain rule. Note that x and z do not need the [S i,j,n ≥l , W, x (n) ] superscript because the forward evaluation of f (W, x (n) ) and f [S i,j,n ≥l ,W,x (n) ] (W, x (n) ) are equivalent. So, we can set B 2 = max 1≤l≤L λN B dσ,l B x,l-1 , as required. Finally, claim 4 is the same as in Lemma 2. The only difference in the proof is that when we invoke the box principle, we choose a specific signature S ≥l+1 in addition to n and j such that ) p , which completes the proof. But (E) t converges to B from above. Therefore E T = B, therefore E(d T , W T ) = B and so E attains its greatest lower bound which means it attains a global minimum, as required.

d l i=1 |W l+1 (i, j )h (n )[S ≥l+1 ,W,x (n) ] l+1 (j )| ≥ d l B2 d l+1 N 2 D l+1 +..+D L .

7.2. PROOF OF PROPOSITION 1:

Proposition 1. If all nonlinearities in a nonparametric network model except possibly σ L are selfsimilar, then the objective function 1 using a fan-in or fan-out regularizer with different regularization parameters λ 1 , .., λ L for each layer is equivalent to the same objective function using the single regularization parameter λ = ( L l=1 λ l ) 1 L for each layer, up to rescaling of weights.

Proof. Choose arbitrary positive λ 1 , .., λ L and let λ = ( L l=1 λ l ) 1 L . We have:

EQUATION

The line-by-line explanation is as follows:

73 Insert the definition of f . 74 Insert a multiplicative factor of value 1.

75 Utilize the self-similarity of σ 1 .

76 Repeat the previous step L -2 times.

77 Utilize linearity.

Further, assuming we use a fan-in regularizer, we have:

EQUATION

)

The argument is equivalent for the fan-out regularizer.

We find that the value of the objective is preserved when we replace all regularization parameters with the same value λ = ( L l=1 λ l )

1 L and rescale W l by λ l λ . This completes the proof. 50.000 -10.000 train-valid split (rectangles images) 10.000 -2.000 train-valid split (convex) 7.000 -1.000 train-valid-test split (poker) 800.000 -125.010 -100.000

Table 3 : Hyperparameters and related choices.

4. We chose the 10 best performing settings from the grid search by VCE and produced 10 reruns for each setting using the same 10 random seeds as in step 2. Then we chose the best setting out of the 10 by median VCE. We depict the median as well as the range of TCE for that best setting in red in figure 2 . Note that the setting that had the lowest median TCE in all cases also had the lowest median VCE. 5. We conducted a random search for P networks with 500 random settings. We chose α uniformly from the interval [1, 100.000] in log scale. Training algorithm and type of batch normalization were chosen uniformly at random from the same sets as in step 3. The size of each hidden layer was chosen uniformly at random between the size of the corresponding layer in the largest NP representative, and 5 times that size. We used the same random seed as in step 1. 6. We chose the 10 best settings by VCE and reran them 10 times, using the same 10 random seeds as in step 2. By considering network size and median VCE, we chose 2 or 3 settings to display in blue in figure 2 , including the setting with the lowest median VCE. In each case, the setting with the lowest median VCE also had the lowest median TCE.

For NP networks, we trained until the VCE had not improved for 100 epochs. Then, we rewound the last 100 epochs and kept training without adding units. After no units had been eliminated and the VCE had not improved for 100 epochs, we set λ to zero, rewound the last 100 epochs and kept training. After the VCE had not improved for 100 epochs, we rewound again and divided the angular step size by 3. After the VCE had not improved for 5 epochs, we rewound and divided the angular step size by 3 again. We kept doing this until the angular step size was too small to change the VCE.

For P networks, we trained until the VCE had not improved for 100 epochs, then rewound and divided the step size by 3. We kept training until the VCE had not improved for 5 epochs, then rewound again and divided the step size by 3. We kept doing this until the step size was too small to change the VCE.

:

in terms of number of datapoints

our standards were: at least 10 published classification accuracy values; no published classification accuracy values exceeding 95%; no extreme label imbalance

Figures and Tables:

min d=(d) l ,d l ∈Z+,1≤l≤L-1 min W=(W ) l ,W l ∈R d l-1 * d l ,1≤l≤L 1 |D| (x,y)∈D e(f (W, x), y) + Ω(W) (1)Note that the dimensions d 0 and d L are fixed because the data and the error function e are fixed. The parameter value now takes the form of a pair (d, W).

a zero vector then remove column j from W l ; remove row j from W l+1 ; remove element j from φl and c l ; decrement d l ; end end if t = 0 mod ν freq then ν = ν; // if ν ∈ Z, we can set e.g. ν = Poisson(ν) add ν randomly initialized columns to W l ; add ν zero rows to W l+1 ; add ν zero elements to φl and c l ; d l = d l + ν ;

Figure1: Architecture of the nonparametric networks used in the experiments. Activations flow rightward, gradients flow leftward. In color, we show how each element corresponds to our definition of a neural network in section 2. CapNorm does not fully fit our definition of nonlinearity as it requires information from multiple datapoints to compute its value. Hence, theorem 1 and proposition 1 do not technically apply. However, CapNorm is a benign operation that does not lead to problems in practice.

Figure 2: Test classification error of trained networks. Nonparametric networks are shown in black, parametric networks in red and blue. Error bars indicate the range over 10 random reruns of the same setting.For parametric networks, the square represents the median test error over those 10 runs. For nonparametric networks, the square represents the test error and size of a single representative run that was close to the median in both size and error. In brackets below or above each plotted point, we show the number of units in the two hidden layers.

Figure 3: Detailed statistics of a nonparametric training run. See main text for details.

Several papers try to speed up the global model search by estimating the validation error of trained networks without fully training them. Saxe et al. (2011) use the validation error with randomly initialized convolutional layers as a proxy. Klein et al. (2017) predict the validation error after training based on the progress made during the first few epochs.Several papers have achieved increased performance by growing networks during training. Our main inspiration wasWei et al. (2016), who utilize a notion similar to our f -equivalence, though they enlarge their network in a somewhat ad-hoc way. The work ofChen et al. (2016) is similar, but focuses on convergence speed.Pandey & Dukkipati (2014) transform a trained small network into a larger network by multiplying weight matrices with large, random matrices.

restate the theorem formally. Theorem 1. For all • L, d 0 , d L ∈ Z + • finite datasets D of points (x, y) with x ∈ R d0 and y ∈ Y for some set Y • sets of nonlinearities {σ l : R → R, 1 ≤ l ≤ L} where each σ l fulfils the following conditions: There exists a function b 1,l : R ≥0 → R ≥0 such that for all S ∈ R ≥0 , -S ≤ s ≤ S, we have |σ l (s)| ≤ b 1,l (S) * |s|. -It is left-and right-differentiable everywhere. -There exists a function b 2,l : R ≥0 → R ≥0 such that for all S ∈ R ≥0 , -S ≤ s ≤ S, we have |σ ← l (s)| ≤ b 2,l (S) and |σ → l (s)| ≤ b 2,l (S), where the superscripts indicate directional derivatives.

other inductive steps. Assuming we have a valid B z,l , we have at all proper Blocal minima |σ l (z l (j))| ≤ b 2,l (B z,l ) because |z l (j)| ≤ ||z l || 1 ≤ B z,l and hence we can choose B dσ,l = b 2,l (B z,l ) as required. Finally, at all proper B-local minima, ||x l || 1 = ||σ l .(z l )|| 1 = d l j=1 |σ l (z l (j))| ≤ d l j=1 b 1,l (B z,l )|z l (j)| = b 1,l (B z,l )||z l || 1 ≤ b 1,l (B z,l )B z,l and so we can choose B x,l = b 1,l (B z,l )B z,l . This completes the proof of claims 1(a)-(c).

and so specifically |g L (i)| ≤ b 3 (B) and so we can choose B g,L = b 3 (B) as required. Now we assume we have a valid B g,l . At all proper B-local minima we have |h l

This is possible because of the induction hypothesis, which bounds the number of partial signatures S ≥l+1 by 2 D l+1 +..+D L . Hence we can set D l = ( BB h,l+1 N D l+1 2 D l+1 +..+D L B2

ADARAD-Minput: α r : radial step size; α φ : angular step size; λ: regularization hyperparameter; β arith : arithmetic mixing rate; β quad : quadratic mixing rate; : numerical stabilizer; d 0 : initial dimensions; W 0 : initial weights; ν: unit addition rate; ν freq : unit addition frequency; T : number of iterations φ max = 0; c max = 0; d = d 0 ; W = W 0 ; for l = 1 to L do set φl (angular arithmetic running average) to the zero matrix of size d 0 l-1 × d 0 l ; set φl (angular quadratic running average), c l (quadratic running average capacity) and a l (arithmetic running average capacity) to zero vectors of size d 0 l ; end for t = 1 to T do set D t to mini-batch used at iteration t;G = 1 |D| ∇ W (x,y)∈D t e(f (W, x), y); for l = L to 1 do alt = FALSE; for j = d l to 1 do decompose [G l (i, j)] i into a component parallel to [W l (i, j)] i (call it r) and a component orthogonal to [W l (i, j)] i (call it φ) such that [G l (i, j)] i = r + φ; φl (j) = (1 -β quad ) φl (j) + β quad ||φ|| 2 2 ; c l (j) = (1 -β quad )c l (j) + β quad ; φ max = max(φ max , φl (j)); c max = max(c max , c l (j)) ; [ φl (i, j)] i = (1 -β arith )[ φl (i, j)] i + β arith φ; a l (j) = (1 -β arith )a l (j) + β arith ; (i, j)] i = [W l (i, j)] i -α r r; rotate [W l (i, j)] i by angle α φ ||φ adj || 2 in direction -φadj ||φadj||2 ; rotate [ φl (i, j)] i by angle α φ ||φ adj || 2 in direction [W l (i,j)]i ||[W l (i,j)]i||2 ; shrink([W l (i, j)] i , α r λ |D t | |D| );if l < L and [W l (i, j)] i is a zero vector then remove column j from W l and φl ; remove row j from W l+1 and φl+1 ; remove element j from φl , c l and a l ; decrement d l ;alt = TRUE; end end if t = 0 mod ν freq then ν = ν; // if ν ∈ Z, we can set e.g. ν = Poisson(ν)add ν randomly initialized columns to W l ; add ν zero columns to φl ; add ν zero rows to W l+1 and φl+1 ; add ν zero elements to φl , c l and a l ;d l = d l + ν ; end if alt then for j = 1 to d l+1 do [ φl+1 (i, j)] i = [ φl+1 (i, j)] i -[ φl+1 (i,j)]i.[W l+1 (i,j)]i ||[W l+1 (i,j)]i|| 2AdaRad-M with 2 fan-in regularizer and the unit addition / removal scheme used in this paper in its most instructive (bot not fastest) order of computation. layers (not poker) 2 number of hidden layers (poker) 4 αr: radial step size for AdaRad (not poker) 1 50λ αr: radial step size for AdaRad (poker) 1 5λ ν: unit addition rate for AdaRad 1 νfreq: unit addition frequency for AdaRad (not poker) once per epoch νfreq: unit addition frequency for AdaRad (poker) ten times per epoch βarith: arithmetic mixing rate for AdaRad, momentum[W l (i, j)]i for a newly added unit j W 0 l (i, j) ∼ N (0, epoch, batches are sampled without replacement type of validation (not poker) one random train-valid split for each random seed type of validation (poker) one single random train-validtest split for all training runs train-valid split (MNIST)



Table content: <table><tr><td>, we compare the costs of SGD,</td></tr></table>

Test classification error of various models trained on the poker dataset.

Table content: <table><tr><td>Algorithm</td><td>λ</td><td>Starting net size</td><td>Final net size</td><td>Error</td></tr><tr><td>Logistic regression (ours)</td><td/><td/><td/><td>49.9%</td></tr><tr><td>Naive bayes (OpenML)</td><td/><td/><td/><td>48.3%</td></tr><tr><td>Decision tree (OpenML)</td><td/><td/><td/><td>26.8%</td></tr><tr><td/><td>10 -3</td><td>10-10-10-10</td><td>23-24-15-4</td><td>0.62%</td></tr><tr><td>Nonparametric net</td><td>10 -5 10 -6</td><td>10-10-10-10 10-10-10-10</td><td colspan="2">94-135-105-35 210-251-224-104 0.001% 0.022%</td></tr><tr><td/><td>10 -7</td><td>10-10-10-10</td><td>299-258-259-129</td><td>0%</td></tr><tr><td/><td/><td>23-24-15-4</td><td>unchanged</td><td>0.20%</td></tr><tr><td>Parametric net</td><td/><td>94-135-105-35 210-251-224-104</td><td>unchanged unchanged</td><td>0.003% 0.003%</td></tr><tr><td/><td/><td>299-258-259-129</td><td>unchanged</td><td>0.002%</td></tr></table>

B . Since R d \W B is compact and E is continuous, there exists a point W min that is a minimum of E inside R d \W B . Further, R d \W B contains at least one point, namely 0, for which E ≤ B, so a minimum within R d \W B is indeed a global minimum, the existence of which was required. We call a parameter value (d, W) a local minimum of E iff it is a local minimum in its second component, W. • We call a local minimum of E B-locally minimal for some B ∈ R iff the value of E at that minimum does not exceed B. • We call the proper dimensionality of W the dimensionality obtained when eliminating from W all units which have a zero fan-in or a zero fan-out or both. • We call a parameter value (d, W) proper if d is the proper dimensionality of W. We also call a local minimum with such a parameter value proper. • Denote (d 1 , .., d l ) by d ≤l and (W 1 , .., W l ) by W ≤l .

Table content: <table><tr><td>Now, some definitions:</td></tr><tr><td>•</td></tr></table>

Proof of theorem 1. Clearly, E is bounded below by zero. Therefore, it has a greatest lower bound, which we call B. Denote (t, t, .., t) by d t . If d is assumed to be fixed at d t , E has a global minimum by lemma 1. Let W t denote one such global minimum. Let E t denote the value of E at (d t , W t ).let d and d be two arbitrary values of d with d l ≥ d l for all 0 ≤ l ≤ L. (Denote such a relation by d ≥ d .) Then, any value that E can attain with d = d it can attain with d = d because we can change any d -dimensional value of W into a d -dimensional value by adding d l -d l units with zero fan-in and fan-out to each layer without changing E.In particular, this implies that (E) t is a decreasing sequence because d t+1 ≥ d t . Since it is also bounded below by B, it converges. Call its limit C. When we add the zero units that were removed from W t to obtain W proper t back into W , we obtain another weight parameter value we call W . Since E is invariant under the addition and removal of units with both zero fan-in and zero fan-out, we have both E(d proper E(d t , W t ). Therefore, we haveE(d t , W ) < E(d t , W t ), which contradicts that W t is a global minimum of E when d is fixed to d t . Therefore, (d proper) is a local minimum of E. In particular, it is a proper E t -local minimum of E and therefore a proper E 0 -local minimum of E.From lemma 4, we know that the set of proper E 0 -local minima is bounded. Hence, the set {d proper t , t ≥ 0} is bounded, i.e there exists some d max with d max ≥ d proper E(d t , W t ) = E t , and therefore E t ≥ E T for all t.

Table content: <table><tr><td>Now Let d proper t</td><td colspan="3">be the proper dimensionality of W t and W proper t</td><td>be the result of removing all units with</td></tr><tr><td colspan="4">zero fan-in or fan-out from W t . Indeed, as we have shown, all units removed had both zero fan-in and fan-out. Assume (d proper t , W proper t ) is not a local minimum of E. Then there exists a W of dimensionality d proper t with E(d proper t , W ) &lt; E(d proper t , W proper</td></tr><tr><td/><td>t</td><td colspan="2">, W proper t</td></tr><tr><td colspan="3">we denote max l d max l But E(d proper t , W proper by T , we have d T ≥ d proper t t ) =</td><td>t for all t and therefore E T ≤ E(d proper for all t. Hence, if t , W proper ). t</td></tr></table>

Peer review (iclr2017):
I agree with reviewer 2 on the interesting part of the paper. The idea of removing or adding units is definitely an interesting direction, that will make a model grow or shrink along the lines required by the problem and the data, not the user prior knowledge. The authors offer an interesting theoretical result that proves that under fan out or fan in regularization the optimum of the error function is achieved for finite number of parameters - so the net does not grow indefinitely, until it over-fits perfectly the data. That reminds me of more traditional approaches such as Lasso or Elastic Net, in which the regularization produces sparse weights. I would have like more intuition to be given for this theorem. It is a nice result, somewhat expected (at last for me it is intuitive) and I would have liked such intuition to be given some space in the paper. For example, less discussion of prior work (that is nice too, but not as important as discussing and studying the main result of the paper) could make more room for addressing the theoretical results. Please also see below (point 2) for some suggestions. I have a few other comments to make: 1. An interesting experiment would be to show that a model such as yours, where the nodes (neurons) are added or removed automatically can outperform a net with the same number of nodes (at the end, after complete learning), in which the size and number of nodes per layer are fixed from the start. This would prove the efficiency of the idea. This is where your method is interesting: do you save nodes that are not needed and replace them with nodes that are needed? Do you optimize performance vs. memory? I understand that experiments along this line are given in Figure 2, with mixed results. The Figure i must say, is not very clear, but it is possible to interpret under careful inspection. In some the non-parametric nets are doing better and others are doing worse than the parametric ones. Even in such case i could see the usefulness of the method as it helps discovering the structure. What i don*t fully understand is why they can do better sometimes than the end net which could be trained from scratch: why is the nonparametric version of learning better than the parametric version, when the final net is known in advance? Could you give more insight? 2. Can you better discuss the meaning and implications of Theorem 1. I feel this theorem is just put there with no proper discussion. Beyond the proofs, from the Appendix, what is the key insight of the Theorem? What does it say, in plain English? To me, the conclusion seems almost natural and obvious. Is there some powerful insight? As i have mentioned previously, i feel this theoretical result deserves more space, with even more experiments to back it up. For example, can regularizer parameter lambda be predicted given the data - is there a property in the data that can help guessing the right lambda? My feeling is that lambda is the key factor for determining the final net structure. Is this true? How much does the structure of the final net depend on the initialization? Do you get different nets if you start from different random weights? How different are they? What happens when fan in and fan out regularizers are combined? Do you still have the same theoretical result? I have a few additional questions: 1. Why do you say that adding zero units changes the regularizer value? For example, does L2 norm change if you add zero values? 2. Zero units are defined as having either the fan in or the fan out weights being zero. I think that what you meant is that both fan in and fan out weights are zero, otherwise you cannot remove the unit and keep the same output f. This should be clarified better I think. I changed my rating to 7, while hoping that the authors will address my comments above.