user: text: Write a concise one-sentence TLDR summary of the scientific paper content below.

Title: AutoGrow: Automatic Layer Growing in Deep Convolutional Networks

Paper content:
Depth is a key component of Deep Neural Networks (DNNs), however, designing depth is heuristic and requires many human efforts.
We propose AutoGrow to automate depth discovery in DNNs: starting from a shallow seed architecture, AutoGrow grows new layers if the growth improves the accuracy; otherwise, stops growing and thus discovers the depth.
We propose robust growing and stopping policies to generalize to different network architectures and datasets.
Our experiments show that by applying the same policy to different network architectures, AutoGrow can always discover near-optimal depth on various datasets of MNIST, FashionMNIST, SVHN, CIFAR10, CIFAR100 and ImageNet.
For example, in terms of accuracy-computation trade-off, AutoGrow discovers a better depth combination in ResNets than human experts.
Our AutoGrow is efficient.
It discovers depth within similar time of training a single DNN.
Layer depth is one of the decisive factors of the success of Deep Neural Networks (DNNs).
For example, image classification accuracy keeps improving as the depth of network models grows (Krizhevsky et al., 2012; Simonyan & Zisserman, 2014; Szegedy et al., 2015; He et al., 2016; Huang et al., 2017) .
Although shallow networks cannot ensure high accuracy, DNNs composed of too many layers may suffer from over-fitting and convergence difficulty in training.
How to obtain the optimal depth for a DNN still remains mysterious.
For instance, ResNet-152 (He et al., 2016) uses 3, 8, 36 and 3 residual blocks under output sizes of 56 × 56, 28 × 28, 14 × 14 and 7 × 7, respectively, which don't show an obvious quantitative relation.
In practice, people usually reply on some heuristic trials and tests to obtain the depth of a network: they first design a DNN with a specific depth and then train and evaluate the network on a given dataset; finally, they change the depth and repeat the procedure until the accuracy meets the requirement.
Besides the high computational cost induced by the iteration process, such trial & test iterations must be repeated whenever dataset changes.
In this paper, we propose AutoGrow that can automate depth discovery given a layer architecture.
We will show that AutoGrow generalizes to different datasets and layer architectures.
There are some previous works which add or morph layers to increase the depth in DNNs.
VggNet (Simonyan & Zisserman, 2014) and DropIn (Smith et al., 2016) added new layers into shallower DNNs; Network Morphism Chen et al., 2015) morphed each layer to multiple layers to increase the depth meanwhile preserving the function of the shallower net.
Table 1 summarizes differences in this work.
Their goal was to overcome difficulty of training deeper DNNs or accelerate it.
Our goal is to automatically find an optimal depth.
Moreover, previous works applied layer growth by once or a few times at pre-defined locations to grow a pre-defined number of layers; in contrast, ours automatically learns the number of new layers and growth locations without limiting growing times.
We will summarize more related works in Section 4.
Figure 1 illustrates an example of AutoGrow.
It starts from the shallowest backbone network and gradually grows sub-modules (A sub-module can be one or more layers, e.g., a residual block); the growth stops once a stopping policy is satisfied.
We studied multiple initializers of new layers and multiple growing policies, and surprisingly find that: (1) a random initializer works equally or better than complicated Network Morphism; (2) it is more effective to grow before a shallow net converges.
We hypothesize that this is because a converged shallow net is an inadequate initialization for training deeper net, while random initialization can help to escape from a bad starting point.
Motivated by this, we intentionally avoid full convergence during the growing by using (1) random initialization of new layers, (2) a constant large learning rate, and (3) a short growing interval.
2 AutoGrow -A DEPTH GROWING ALGORITHM Algorithm 1 AutoGrow Algorithm.
Input :
, where each sub-network has only one sub-module (a dimension reduction sub-module); an epoch interval K to check growing and stopping policies; the number of fine-tuning epochs N after growing.
The current growing sub-network: growingSubNet = subNetList.head() = f0 (·; W0);

assistant: text: A framework to interleave training a shallower network and adding new layers which provides insights into the paradigm of 'growing networks'.