Add files using upload-large-folder tool

parse/train/B1ewdt9xe/B1ewdt9xe_content_list.json

@@ -0,0 +1,1615 @@
+[
+    {
+        "type": "text",
+        "text": "DEEP PREDICTIVE CODING NETWORKS FOR VIDEO PREDICTION AND UNSUPERVISED LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            818,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "William Lotter, Gabriel Kreiman & David Cox   \nHarvard University   \nCambridge, MA 02215, USA   \n{lotter,davidcox}@fas.harvard.edu   \ngabriel.kreiman@tch.harvard.edu ",
+        "bbox": [
+            184,
+            170,
+            511,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            276,
+            544,
+            291
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "While great strides have been made in using deep learning algorithms to solve supervised learning tasks, the problem of unsupervised learning — leveraging unlabeled examples to learn about the structure of a domain — remains a difficult unsolved challenge. Here, we explore prediction of future frames in a video sequence as an unsupervised learning rule for learning about the structure of the visual world. We describe a predictive neural network (“PredNet”) architecture that is inspired by the concept of “predictive coding” from the neuroscience literature. These networks learn to predict future frames in a video sequence, with each layer in the network making local predictions and only forwarding deviations from those predictions to subsequent network layers. We show that these networks are able to robustly learn to predict the movement of synthetic (rendered) objects, and that in doing so, the networks learn internal representations that are useful for decoding latent object parameters (e.g. pose) that support object recognition with fewer training views. We also show that these networks can scale to complex natural image streams (car-mounted camera videos), capturing key aspects of both egocentric movement and the movement of objects in the visual scene, and the representation learned in this setting is useful for estimating the steering angle. Altogether, these results suggest that prediction represents a powerful framework for unsupervised learning, allowing for implicit learning of object and scene structure. ",
+        "bbox": [
+            233,
+            308,
+            764,
+            585
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            612,
+            336,
+            628
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Many of the most successful current deep learning architectures for vision rely on supervised learning from large sets of labeled training images. While the performance of these networks is undoubtedly impressive, reliance on such large numbers of training examples limits the utility of deep learning in many domains where such datasets are not available. Furthermore, the need for large numbers of labeled examples stands at odds with human visual learning, where one or a few views of an object is often all that is needed to enable robust recognition of that object across a wide range of different views, lightings and contexts. The development of a representation that facilitates such abilities, especially in an unsupervised way, is a largely unsolved problem. ",
+        "bbox": [
+            174,
+            643,
+            825,
+            756
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In addition, while computer vision models are typically trained using static images, in the real world, visual objects are rarely experienced as disjoint snapshots. Instead, the visual world is alive with movement, driven both by self-motion of the viewer and the movement of objects within the scene. Many have suggested that temporal experience with objects as they move and undergo transformations can serve as an important signal for learning about the structure of objects (Foldi ¨ ak, 1991; ´ Softky, 1996; Wiskott & Sejnowski, 2002; George & Hawkins, 2005; Palm, 2012; O’Reilly et al., 2014; Agrawal et al., 2015; Goroshin et al., 2015a; Lotter et al., 2015; Mathieu et al., 2016; Srivastava et al., 2015; Wang & Gupta, 2015; Whitney et al., 2016). For instance, Wiskott and Sejnowski proposed “slow feature analysis” as a framework for exploiting temporal structure in video streams (Wiskott & Sejnowski, 2002). Their approach attempts to build feature representations that extract slowly-varying parameters, such as object identity, from parameters that produce fast changes in the image, such as movement of the object. While approaches that rely on temporal coherence have arguably not yet yielded representations as powerful as those learned by supervised methods, they nonetheless point to the potential of learning useful representations from video (Mohabi et al., 2009; Sun et al., 2014; Goroshin et al., 2015a; Maltoni & Lomonaco, 2015; Wang & Gupta, 2015). ",
+        "bbox": [
+            174,
+            762,
+            825,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            174
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Here, we explore another potential principle for exploiting video for unsupervised learning: prediction of future image frames (Softky, 1996; Palm, 2012; O’Reilly et al., 2014; Goroshin et al., 2015b; Srivastava et al., 2015; Mathieu et al., 2016; Patraucean et al., 2015; Finn et al., 2016; Vondrick et al., 2016). A key insight here is that in order to be able to predict how the visual world will change over time, an agent must have at least some implicit model of object structure and the possible transformations objects can undergo. To this end, we have designed a neural network architecture, which we informally call a “PredNet,” that attempts to continually predict the appearance of future video frames, using a deep, recurrent convolutional network with both bottom-up and topdown connections. Our work here builds on previous work in next-frame video prediction (Ranzato et al., 2014; Michalski et al., 2014; Srivastava et al., 2015; Mathieu et al., 2016; Lotter et al., 2015; Patraucean et al., 2015; Oh et al., 2015; Finn et al., 2016; Xue et al., 2016; Vondrick et al., 2016; Brabandere et al., 2016), but we take particular inspiration from the concept of “predictive coding” from the neuroscience literature (Rao & Ballard, 1999; Rao & Sejnowski, 2000; Lee & Mumford, 2003; Friston, 2005; Summerfield et al., 2006; Egner et al., 2010; Bastos et al., 2012; Spratling, 2012; Chalasani & Principe, 2013; Clark, 2013; O’Reilly et al., 2014; Kanai et al., 2015). Predictive coding posits that the brain is continually making predictions of incoming sensory stimuli (Rao & Ballard, 1999; Friston, 2005). Top-down (and perhaps lateral) connections convey these predictions, which are compared against actual observations to generate an error signal. The error signal is then propagated back up the hierarchy, eventually leading to an update of the predictions. ",
+        "bbox": [
+            173,
+            179,
+            825,
+            444
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We demonstrate the effectiveness of our model for both synthetic sequences, where we have access to the underlying generative model and can investigate what the model learns, as well as natural videos. Consistent with the idea that prediction requires knowledge of object structure, we find that these networks successfully learn internal representations that are well-suited to subsequent recognition and decoding of latent object parameters (e.g. identity, view, rotation speed, etc.). We also find that our architecture can scale effectively to natural image sequences, by training using car-mounted camera videos. The network is able to successfully learn to predict both the movement of the camera and the movement of objects in the camera’s view. Again supporting the notion of prediction as an unsupervised learning rule, the model’s learned representation in this setting supports decoding of the current steering angle. ",
+        "bbox": [
+            173,
+            450,
+            825,
+            590
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/96a1440b9f8c8bf098c1b691d0dce930f9e50a5bd99be7f869e6ae09b81b7762.jpg",
+        "image_caption": [
+            "Figure 1: Predictive Coding Network (PredNet). Left: Illustration of information flow within two layers. Each layer consists of representation neurons $( R _ { l } )$ , which output a layer-specific prediction at each time step $( \\hat { A } _ { l } )$ , which is compared against a target $( A _ { l } )$ (Bengio, 2014) to produce an error term $( E _ { l } )$ , which is then propagated laterally and vertically in the network. Right: Module operations for case of video sequences. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            248,
+            613,
+            738,
+            833
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 THE PREDNET MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            397,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The PredNet architecture is diagrammed in Figure 1. The network consists of a series of repeating stacked modules that attempt to make local predictions of the input to the module, which is then subtracted from the actual input and passed along to the next layer. Briefly, each module of the network consists of four basic parts: an input convolutional layer $( A _ { l } )$ , a recurrent representation layer $( R _ { l } )$ , a prediction layer $( \\hat { \\hat { A } } _ { l } )$ , and an error representation $( E _ { l } )$ . The representation layer, $R _ { l }$ , is a recurrent convolutional network that generates a prediction, $\\hat { A } _ { l }$ , of what the layer input, $A _ { l }$ , will be on the next frame. The network takes the difference between $A _ { l }$ and $\\hat { A } _ { l }$ and outputs an error representation, $E _ { l }$ , which is split into separate rectified positive and negative error populations. The error, $E _ { l }$ , is then passed forward through a convolutional layer to become the input to the next layer $( A _ { l + 1 } )$ . The recurrent prediction layer $R _ { l }$ receives a copy of the error signal $E _ { l }$ , along with top-down input from the representation layer of the next level of the network $( R _ { l + 1 } )$ . The organization of the network is such that on the first time step of operation, the “right” side of the network ( $A _ { l }$ ’s and $E _ { l }$ ’s) is equivalent to a standard deep convolutional network. Meanwhile, the “left” side of the network (the $R _ { l }$ ’s) is equivalent to a generative deconvolutional network with local recurrence at each stage. The architecture described here is inspired by that originally proposed by (Rao & Ballard, 1999), but is formulated in a modern deep learning framework and trained end-to-end using gradient descent, with a loss function implicitly embedded in the network as the firing rates of the error neurons. Our work also shares motivation with the Deep Predictive Coding Networks of Chalasani & Principe (2013); however, their framework is based upon sparse coding and a linear dynamical system with greedy layer-wise training, whereas ours is rooted in convolutional and recurrent neural networks trained with backprop. ",
+        "bbox": [
+            173,
+            132,
+            825,
+            430
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "While the architecture is general with respect to the kinds of data it models, here we focus on image sequence (video) data. Consider a sequence of images, $x _ { t }$ . The target for the lowest layer is set to the the actual sequence itself, i.e. $\\bar { A } _ { 0 } ^ { t } = x _ { t } \\forall t$ . The targets for higher layers, $A _ { l } ^ { t }$ for $l > 0$ , are computed by a convolution over the error units from the layer below, $E _ { l - 1 } ^ { t }$ , followed by rectified linear unit (ReLU) activation and max-pooling. For the representation neurons, we specifically use convolutional LSTM units (Hochreiter & Schmidhuber, 1997; Shi et al., 2015). In our setting, the $R _ { l } ^ { t }$ hidden state is updated according to $R _ { l } ^ { t - 1 }$ , $E _ { l } ^ { t - 1 }$ , as well as $R _ { l + 1 } ^ { t }$ , which is first spatially upsampled (nearest-neighbor), due to the pooling present in the feedforward path. The predictions, $\\hat { A } _ { l } ^ { t }$ are made through a convolution of the $R _ { l } ^ { t }$ stack followed by a ReLU non-linearity. For the lowest layer, $\\hat { A } _ { l } ^ { t }$ is also passed through a saturating non-linearity set at the maximum pixel value: $\\operatorname { S a t L U } ( x ; p _ { m a x } ) : = \\operatorname* { m i n } ( p _ { m a x } , x )$ . Finally, the error response, $E _ { l } ^ { t }$ , is calculated from the difference between $\\hat { A } _ { l } ^ { t }$ and $A _ { l } ^ { t }$ and is split into ReLU-activated positive and negative prediction errors, which are concatenated along the feature dimension. As discussed in (Rao & Ballard, 1999), although not explicit in their model, the separate error populations are analogous to the existence of on-center, off-surround and off-center, on-surround neurons early in the visual system. ",
+        "bbox": [
+            174,
+            436,
+            825,
+            652
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The full set of update rules are listed in Equations (1) to (4). The model is trained to minimize the weighted sum of the activity of the error units. Explicitly, the training loss is formalized in Equation 5 with weighting factors by time, $\\lambda _ { t }$ , and layer, $\\lambda _ { l }$ , and where $n _ { l }$ is the number of units in the lth layer. With error units consisting of subtraction followed by ReLU activation, the loss at each layer is equivalent to an L1 error. Although not explored here, other error unit implementations, potentially even probabilistic or adversarial (Goodfellow et al., 2014), could also be used. ",
+        "bbox": [
+            174,
+            660,
+            825,
+            743
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d4efd34db2f2780addbfd9d2817ec3f2ce20b4d0c18a15b42c819a20676e5669.jpg",
+        "text": "$$\n\\begin{array} { r l } & { A _ { l } ^ { t } = \\bigg \\{ x _ { t } } & { \\mathrm { i f } l = 0 } \\\\ & { \\mathbf { M } _ { \\mathrm { A X P o o L } } ( \\operatorname { R E L U } ( \\operatorname { C o N v } ( E _ { l - 1 } ^ { t } ) ) ) } & { l > 0 } \\\\ & { \\hat { A } _ { l } ^ { t } = \\operatorname { R E L U } ( \\operatorname { C o N v } ( R _ { l } ^ { t } ) ) } \\\\ & { E _ { l } ^ { t } = [ \\operatorname { R E L U } ( A _ { l } ^ { t } - \\hat { A } _ { l } ^ { t } ) ; \\operatorname { R E L U } ( \\hat { A } _ { l } ^ { t } - A _ { l } ^ { t } ) ] } \\\\ & { R _ { l } ^ { t } = \\operatorname { C o N v L S T M } ( E _ { l } ^ { t - 1 } , R _ { l } ^ { t - 1 } , \\operatorname { U P S A M P L E } ( R _ { l + 1 } ^ { t } ) ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            765,
+            689,
+            864
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/118394227ec7aaffb1e86b56b4dea6f1278381aa47137052f4ade323fa319af4.jpg",
+        "text": "$$\nL _ { t r a i n } = \\sum _ { t } \\lambda _ { t } \\sum _ { l } \\frac { \\lambda _ { l } } { n _ { l } } \\sum _ { n _ { l } } E _ { l } ^ { t }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            883,
+            514,
+            921
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Calculation of PredNet states ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            103,
+            454,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/c6086e2374093f12c8dbee3c103704a2878634b0eaf8ad59396dd945a9e15d31.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Require: Xt</td><td></td></tr><tr><td>1:A←xt 2:</td><td>E,R←0</td></tr><tr><td>3:</td><td>fort=1 to Tdo</td></tr><tr><td>4:</td><td>for l = L to O do</td></tr><tr><td>5:</td><td>if l=L then</td></tr><tr><td>6:</td><td>Rt =CONVLSTM(Et-1,Rt-1)</td></tr><tr><td>7:</td><td>else</td></tr><tr><td>8:</td><td>Rt = CONVLSTM(E𝑡-1,Rt-1,UPSAMPLE(Rt+1))</td></tr><tr><td>9:</td><td>for l= O to L do</td></tr><tr><td>10:</td><td>if l= O then</td></tr><tr><td>11:</td><td>At = SATLU(RELU(CONV(Rδ)))</td></tr><tr><td>12:</td><td>else</td></tr><tr><td>13:</td><td>At = RELU(CoNv(Rt))</td></tr><tr><td>14:</td><td>Et = [RELU(At - At); RELU(At - A)]</td></tr><tr><td>15:</td><td>ifl&lt;L then</td></tr><tr><td>16:</td><td>At+1 = MAXPOOL(CONV(E))</td></tr></table>",
+        "bbox": [
+            174,
+            123,
+            826,
+            375
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The order in which each unit in the model is updated must also be specified, and our implementation is described in Algorithm 1. Updating of states occurs through two passes: a top-down pass where the $R _ { l } ^ { t }$ states are computed, and then a forward pass to calculate the predictions, errors, and higher level targets. A last detail of note is that $R _ { l }$ and $E _ { l }$ are initialized to zero, which, due to the convolutional nature of the network, means that the initial prediction is spatially uniform. ",
+        "bbox": [
+            174,
+            404,
+            825,
+            473
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            497,
+            326,
+            513
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 RENDERED IMAGE SEQUENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            531,
+            431,
+            546
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To gain an understanding of the representations learned in the proposed framework, we first trained PredNet models using synthetic images, for which we have access to the underlying generative stimulus model and all latent parameters. We created sequences of rendered faces rotating with two degrees of freedom, along the “pan” (out-of-plane) and “roll” (in-plane) axes. The faces start at a random orientation and rotate at a random constant velocity for a total of 10 frames. A different face was sampled for each sequence. The images were processed to be grayscale, with values normalized between 0 and 1, and 64x64 pixels in size. We used 16K sequences for training and 800 for both validation and testing. ",
+        "bbox": [
+            174,
+            559,
+            825,
+            671
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Predictions generated by a PredNet model are shown in Figure 2. The model is able to accumulate information over time to make accurate predictions of future frames. Since the representation neurons are initialized to zero, the prediction at the first time step is uniform. On the second time step, with no motion information yet, the prediction is a blurry reconstruction of the first time step. After further iterations, the model adapts to the underlying dynamics to generate predictions that closely match the incoming frame. ",
+        "bbox": [
+            174,
+            678,
+            825,
+            761
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For choosing the hyperparameters of the model, we performed a random search and chose the model that had the lowest L1 error in frame prediction averaged over time steps 2-10 on a validation set. Given this selection criteria, the best performing models tended to have a loss solely concentrated at the lowest layer (i.e. $\\lambda _ { 0 } = 1$ , $\\lambda _ { l > 0 } = 0 $ ), which is the case for the model shown. Using an equal loss at each layer considerably degraded predictions, but enforcing a moderate loss on upper layers that was one magnitude smaller than the lowest layer (i.e. $\\lambda _ { 0 } = 1$ , $\\lambda _ { l > 0 } = 0 . 1$ ) led to only slightly worse predictions, as illustrated in Figure 9 in the Appendix. In all cases, the time loss weight, $\\lambda _ { t }$ , was set to zero for the first time step and then one for all time steps after. As for the remaining hyperparameters, the model shown has 5 layers with 3x3 filter sizes for all convolutions, max-pooling of stride 2, and number of channels per layer, for both $A _ { l }$ and $R _ { l }$ units, of (1, 32, 64, 128, 256). Model weights were optimized using the Adam algorithm (Kingma & Ba, 2014). ",
+        "bbox": [
+            174,
+            768,
+            825,
+            921
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/47e158f8ba016838740a961f995997b73a4e432fd723f2faa4ecb1fae041441c.jpg",
+        "image_caption": [
+            "time ",
+            "Figure 2: PredNet next-frame predictions for sequences of rendered faces rotating with two degrees of freedom. Faces shown were not seen during training. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            101,
+            825,
+            381
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Quantitative evaluation of generative models is a difficult, unsolved problem (Theis et al., 2016), but here we report prediction error in terms of meansquared error (MSE) and the Structural Similarity Index Measure (SSIM) (Wang et al., 2004). SSIM is designed to be more correlated with perceptual judgments, and ranges from $- 1$ and 1, with a larger score indicating greater similarity. We compare the PredNet to the trivial solution of copying the last frame, as well as a control model that shares the overall architecture and training scheme of the PredNet, but that sends forward the layer-wise activations $( A _ { l } )$ rather than the errors $( E _ { l } )$ . This model thus takes the form of a more traditional encoder-decoder pair, with a CNN encoder that has lateral skip connections to a convolutional LSTM decoder. The performance of all models on the rotating faces dataset is summarized in Table 1, where the scores were calculated as an average over all predictions after the first frame. We report results for the PredNet model trained with loss only on the lowest layer, denoted as PredNet $L _ { 0 }$ , as well as the model trained with an 0.1 weight on upper layers, denoted as PredNet $L _ { a l l }$ . Both PredNet models outperformed the baselines on both measures, with the $L _ { 0 }$ model slightly outperforming $L _ { a l l }$ , as expected for evaluating the pixel-level predictions. ",
+        "bbox": [
+            174,
+            431,
+            506,
+            556
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/52104c4d397a0ebe01aea3333b35ca079c4c81446bf375c1e186c1aa440a9d94.jpg",
+        "table_caption": [
+            "Table 1: Evaluation of next-frame predictions on Rotating Faces Dataset (test set). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>MSE</td><td>SSIM</td></tr><tr><td>PredNet Lo</td><td>0.0152</td><td>0.937</td></tr><tr><td>PredNet Lall</td><td>0.0157</td><td>0.921</td></tr><tr><td>CNN-LSTM Enc.-Dec.</td><td>0.0180</td><td>0.907</td></tr><tr><td>Copy Last Frame</td><td>0.125</td><td>0.631</td></tr></table>",
+        "bbox": [
+            521,
+            460,
+            821,
+            541
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            556,
+            825,
+            694
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Synthetic sequences were chosen as the initial training set in order to better understand what is learned in different layers of the model, specifically with respect to the underlying generative model (Kulkarni et al., 2015). The rotating faces were generated using the FaceGen software package (Singular Inversions, Inc.), which internally generates 3D face meshes by a principal component analysis in “face space”, derived from a corpus of 3D face scans. Thus, the latent parameters of the image sequences used here consist of the initial pan and roll angles, the pan and roll velocities, and the principal component (PC) values, which control the “identity” of the face. To understand the information contained in the trained models, we decoded the latent parameters from the representation neurons $( R _ { l } )$ in different layers, using a ridge regression. The $R _ { l }$ states were taken at the earliest possible informative time steps, which, in the our notation, are the second and third steps, respectively, for the static and dynamic parameters. The regression was trained using $4 K$ sequences with 500 for validation and $1 K$ for testing. For a baseline comparison of the information implicitly embedded in the network architecture, we compare to the decoding accuracies of an untrained network with random initial weights. Note that in this randomly initialized case, we still expect above-chance decoding performance, given past theoretical and empirical work with random networks (Pinto et al., 2009; Jarrett et al., 2009; Saxe et al., 2010). ",
+        "bbox": [
+            174,
+            702,
+            825,
+            922
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Latent variable decoding accuracies of the pan and roll velocities, pan initial angle, and first PC are shown in the left panel of Figure 3. There are several interesting patterns. First, the trained models learn a representation that generally permits a better linear decoding of the underlying latent factors than the randomly initialized model, with the most striking difference in terms of the the pan rotation speed $( \\alpha _ { p a n } )$ . Second, the most notable difference between the $L _ { a l l }$ and $L _ { 0 }$ versions occurs with the first principle component, where the model trained with loss on all layers has a higher decoding accuracy than the model trained with loss only on the lowest layer. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/0abef2797da5fa19f50184da371c6feb85f35b1d2b18d3d978fa3150145a690d.jpg",
+        "image_caption": [
+            "Figure 3: Information contained in PredNet representation for rotating faces sequences. Left: Decoding of latent variables using a ridge regression $( \\alpha _ { p a n }$ : pan (out-of-frame) angular velocity, $\\theta _ { p a n }$ : pan angle, PC-1: first principal component of face, $\\alpha _ { r o l l }$ : roll (in-frame) angular velocity). Right: Orientation-invariant classification of static faces. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            234,
+            812,
+            467
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The latent variable decoding analysis suggests that the model learns a representation that may generalize well to other tasks for which it was not explicitly trained. To investigate this further, we assessed the models in a classification task from single, static images. We created a dataset of 25 previously unseen FaceGen faces at 7 pan angles, equally spaced between $[ - \\frac { \\pi } { 2 } , \\frac { \\pi } { 2 } ]$ , and 8 roll angles, equally spaced between $[ 0 , 2 \\pi )$ . There were therefore orientations per identity, which were tested in a cross-validated fashion. A linear SVM to decode face identity was fit on a model’s representation of a random subset of orientations and then tested on the remaining angles. For each size of the SVM training set, ranging from 1-40 orientations per face, 50 different random splits were generated, with results averaged over the splits. ",
+        "bbox": [
+            174,
+            555,
+            825,
+            681
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For the static face classification task, we compare the PredNets to a standard autoencoder and a variant of the Ladder Network (Valpola, 2015; Rasmus et al., 2015). Both models were constructed to have the same number of layers and channel sizes as the PredNets, as well as a similar alternating convolution/max-pooling, then upsampling/convolution scheme. As both networks are autoencoders, they were trained with a reconstruction loss, with a dataset consisting of all of the individual frames from the sequences used to train the PredNets. For the Ladder Network, which is a denoising autoencoder with lateral skip connections, one must also choose a noise parameter, as well as the relative weights of each layer in the total cost. We tested noise levels ranging from 0 to 0.5 in increments of 0.1, with loss weights either evenly distributed across layers, solely concentrated at the pixel layer, or 1 at the bottom layer and 0.1 at upper layers (analogous to the PredNet $L _ { a l l }$ model). Shown is the model that performed best for classification, which consisted of 0.4 noise and only pixel weighting. Lastly, as in our architecture, the Ladder Network has lateral and top-down streams that are combined by a combinator function. Inspired by (Pezeshki et al., 2015), where a learnable MLP improved results, and to be consistent in comparing to the PredNet, we used a purely convolutional combinator. Given the distributed representation in both networks, we decoded from a concatenation of the feature representations at all layers, except the pixel layer. For the PredNets, the representation units were used and features were extracted after processing one input frame. ",
+        "bbox": [
+            173,
+            688,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Face classification accuracies using the representations learned by the $L _ { 0 }$ and $L _ { a l l }$ PredNets, a standard autoencoder, and a Ladder Network variant are shown in the right panel of Figure 3. Both PredNets compare favorably to the other models at all sizes of the training set, suggesting they learn a representation that is relatively tolerant to object transformations. Similar to the decoding accuracy of the first principle component, the PredNet $L _ { a l l }$ model actually outperformed the $L _ { 0 }$ variant. Altogether, these results suggest that predictive training with the PredNet can be a viable alternative to other models trained with a more traditional reconstructive or denoising loss, and that the relative layer loss weightings $( \\lambda _ { l } ^ { } \\mathbf { \\dot { s } } )$ may be important for the particular task at hand. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.2 NATURAL IMAGE SEQUENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            236,
+            421,
+            251
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We next sought to test the PredNet architecture on complex, real-world sequences. As a testbed, we chose car-mounted camera videos, since these videos span across a wide range of settings and are characterized by rich temporal dynamics, including both self-motion of the vehicle and the motion of other objects in the scene (Agrawal et al., 2015). Models were trained using the raw videos from the KITTI dataset (Geiger et al., 2013), which were captured by a roof-mounted camera on a car driving around an urban environment in Germany. Sequences of 10 frames were sampled from the “City”, “Residential”, and “Road” categories, with 57 recording sessions used for training and 4 used for validation. Frames were center-cropped and downsampled to 128x160 pixels. In total, the training set consisted of roughly 41K frames. ",
+        "bbox": [
+            174,
+            263,
+            825,
+            388
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A random hyperparameter search, with model selection based on the validation set, resulted in a 4 layer model with 3x3 convolutions and layer channel sizes of (3, 48, 96, 192). Models were again trained with Adam (Kingma & Ba, 2014) using a loss either solely computed on the lowest layer $( L _ { 0 } )$ or with a weight of 1 on the lowest layer and 0.1 on the upper layers $( L _ { a l l } )$ . Adam parameters were initially set to their default values $\\mathbf { \\Phi } _ { \\mathrm { { ( } } \\alpha } = 0 . 0 0 1 $ , $\\beta _ { 1 } = 0 . 9$ , $\\beta _ { 2 } = 0 . 9 9 9 )$ with the learning rate, $\\alpha$ , decreasing by a factor of 10 halfway through training. To assess that the network had indeed learned a robust representation, we tested on the CalTech Pedestrian dataset (Dollar et al., 2009), which´ consists of videos from a dashboard-mounted camera on a vehicle driving around Los Angeles. Testing sequences were made to match the frame rate of the KITTI dataset and again cropped to 128x160 pixels. Quantitative evaluation was performed on the entire CalTech test partition, split into sequences of 10 frames. ",
+        "bbox": [
+            173,
+            396,
+            825,
+            549
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Sample PredNet predictions (for the $L _ { 0 }$ model) on the CalTech Pedestrian dataset are shown in Figure 4, and example videos can be found at https://coxlab.github.io/prednet/. The model is able to make fairly accurate predictions in a wide range of scenarios. In the top sequence of Fig. 4, a car is passing in the opposite direction, and the model, while not perfect, is able to predict its trajectory, as well as fill in the ground it leaves behind. Similarly in Sequence 3, the model is able to predict the motion of a vehicle completing a left turn. Sequences 2 and 5 illustrate that the PredNet can judge its own movement, as it predicts the appearance of shadows and a stationary vehicle as they approach. The model makes reasonable predictions even in difficult scenarios, such as when the camera-mounted vehicle is turning. In Sequence 4, the model predicts the position of a tree, as the vehicle turns onto a road. The turning sequences also further illustrate the model’s ability to “fill-in”, as it is able to extrapolate sky and tree textures as unseen regions come into view. As an additional control, we show a sequence at the bottom of Fig. 4, where the input has been temporally scrambled. In this case, the model generates blurry frames, which mostly just resemble the previous frame. Finally, although the PredNet shown here was trained to predict one frame ahead, it is also possible to predict multiple frames into the future, by feeding back predictions as the inputs and recursively iterating. We explore this in Appendix 5.3. ",
+        "bbox": [
+            174,
+            556,
+            825,
+            776
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Quantitatively, the PredNet models again outperformed the CNN-LSTM EncoderDecoder. To ensure that the difference in performance was not simply because of the choice of hyperparameters, we trained models with four other sets of hyperparameters, which were sampled from the initial random search over the number of layers, fil",
+        "bbox": [
+            174,
+            785,
+            459,
+            896
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/c30f36c19aa8ec6af0e3d143966f300d0b5a586acb3e306a0d25c2faf3163afe.jpg",
+        "table_caption": [
+            "Table 2: Evaluation of Next-Frame Predictions on CalTech Pedestrian Dataset. "
+        ],
+        "table_footnote": [
+            "ter sizes, and number of filters per layer. For each of the four additional sets, the PredNet $L _ { 0 }$ had the best performance, with an average error reduction of $1 4 . 7 \\%$ and $1 4 . 9 \\%$ for MSE and SSIM, "
+        ],
+        "table_body": "<table><tr><td></td><td>MSE</td><td>SSIM</td></tr><tr><td>PredNet Lo</td><td>3.13 × 10-3</td><td>0.884</td></tr><tr><td>PredNet Lall</td><td>3.33 ×10-3</td><td>0.875</td></tr><tr><td>CNN-LSTMEnc.-Dec.</td><td>3.67 × 10-3</td><td>0.865</td></tr><tr><td>Copy Last Frame</td><td>7.95 × 10-3</td><td>0.762</td></tr></table>",
+        "bbox": [
+            472,
+            815,
+            821,
+            892
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/f2465bddecf762950203060719579f704eebd5b1c06d29b0051a317691866e37.jpg",
+        "image_caption": [
+            "time → ",
+            "Figure 4: PredNet predictions for car-cam videos. The first rows contain ground truth and the second rows contain predictions. The sequence below the red line was temporally scrambled. The model was trained on the KITTI dataset and sequences shown are from the CalTech Pedestrian dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            94,
+            821,
+            693
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "respectively, compared to the CNN-LSTM Encoder-Decoder. More details, as well as a thorough investigation of systematically simplified models on the continuum between the PredNet and the CNN-LSTM Encoder-Decoder can be found in Appendix 5.1. Briefly, the elementwise subtraction operation in the PredNet seems to be beneficial, and the nonlinearity of positive/negative splitting also adds modest improvements. Finally, while these experiments measure the benefits of each component of our model, we also directly compare against recent work in a similar car-cam setting, by reporting results on a 64x64 pixel, grayscale car-cam dataset released by Brabandere et al. (2016). Our PredNet model outperforms the model by Brabandere et al. (2016) by $2 9 \\%$ . Details can be found in Appendix 5.2. Also in Appendix 5.2, we present results for the Human3.6M (Ionescu et al., 2014) dataset, as reported by Finn et al. (2016). Without re-optimizing hyperparameters, our model underperforms the concurrently developed DNA model by Finn et al. (2016), but outperforms the model by Mathieu et al. (2016). ",
+        "bbox": [
+            173,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To test the implicit encoding of latent parameters in the car-cam setting, we used the internal representation in the PredNet to estimate the car’s steering angle (Bojarski et al., 2016; Biasini et al., 2016). We used a dataset released by Comma.ai (Biasini et al., 2016) consisting of 11 videos totaling about 7 hours of mostly highway driving. We first trained networks for next-frame prediction and then fit a linear fully-connected layer on the learned representation to estimate the steering angle, using a MSE loss. We again concatenate the $R _ { l }$ representation at all layers, but first spatially average pool lower layers to match the spatial size of the upper layer, in order to reduce dimensionality. Steering angle estimation results, using the representation on the $1 0 ^ { \\mathrm { t h } }$ time step, are shown in Figure 5. Given just 1K labeled training examples, a simple linear readout on the PredNet $L _ { 0 }$ representation explains $7 4 \\%$ of the variance in the steering angle and outperforms the CNN-LSTM Enc.-Dec. by $3 5 \\%$ . With 25K labeled training examples, the PredNet $L _ { 0 }$ has a MSE (in degrees2) of 2.14. As a point of reference, a CNN model designed to predict the steering angle (Biasini et al., 2016), albeit from a single frame instead of multiple frames, achieve a MSE of ${ \\sim } 4$ when trained end-to-end using 396K labeled training examples. Details of this analysis can be found in Appendix 8. Interestingly, in this task, the PredNet $L _ { a l l }$ model actually underperformed the $L _ { 0 }$ model and slightly underperformed the CNN-LSTM Enc.-Dec, again suggesting that the $\\lambda _ { l }$ parameter can affect the representation learned, and different values may be preferable in different end tasks. Nonetheless, the readout from the $L _ { a l l }$ model still explained a substantial proportion of the steering angle variance and strongly outperformed the random initial weights. Overall, this analysis again demonstrates that a representation learned through prediction, and particularly with the PredNet model with appropriate hyperparameters, can contain useful information about underlying latent parameters. ",
+        "bbox": [
+            173,
+            138,
+            825,
+            445
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/4eacc964ba30df01ba5dfac8e925e09b97a2e2cd91639d41fa77b3ced7bfe30a.jpg",
+        "image_caption": [
+            "Figure 5: Steering angle estimation accuracy on the Comma.ai dataset (Biasini et al., 2016). Left: Example steering angle curve with model estimations for a segment in the test set. Decoding was performed using a fully-connected readout on the PredNet representation trained with 25K labeled training examples. PredNet representation was trained for next-frame prediction on Comma.ai training set. Right: Mean-squared error of steering angle estimation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            468,
+            813,
+            681
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            768,
+            310,
+            784
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Above, we have demonstrated a predictive coding inspired architecture that is able to predict future frames in both synthetic and natural image sequences. Importantly, we have shown that learning to predict how an object or scene will move in a future frame confers advantages in decoding latent parameters (such as viewing angle) that give rise to an object’s appearance, and can improve recognition performance. More generally, we argue that prediction can serve as a powerful unsupervised learning signal, since accurately predicting future frames requires at least an implicit model of the objects that make up the scene and how they are allowed to move. Developing a deeper understanding of the nature of the representations learned by the networks, and extending the architecture, by, for instance, allowing sampling, are important future directions. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            104,
+            326,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We would like to thank Rasmus Berg Palm for fruitful discussions and early brainstorming. We would also like to thank the developers of Keras (Chollet, 2016). This work was supported by IARPA (contract D16PC00002), the National Science Foundation (NSF IIS 1409097), and the Center for Brains, Minds and Machines (CBMM, NSF STC award CCF-1231216). ",
+        "bbox": [
+            174,
+            127,
+            825,
+            184
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            204,
+            287,
+            219
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pulkit Agrawal, Joao Carreira, and Jitendra Malik. Learning to see by moving. ˜ CoRR, 2015. ",
+        "bbox": [
+            171,
+            227,
+            777,
+            242
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andre M. Bastos, W. Martin Usrey, Rick A. Adams, George R. Mangun, Pascal Fries, and Karl J. Friston. Canonical microcircuits for predictive coding. Neuron, 2012. ",
+        "bbox": [
+            173,
+            251,
+            821,
+            280
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Samy Bengio, Oriol Vinyals, Navdeep Jaitly, and Noam Shazeer. Scheduled sampling for sequence prediction with recurrent neural networks. CoRR, 2015. ",
+        "bbox": [
+            174,
+            287,
+            823,
+            316
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio. How auto-encoders could provide credit assignment in deep networks via target propagation. CoRR, 2014. ",
+        "bbox": [
+            174,
+            325,
+            821,
+            354
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Riccardo Biasini, George Hotz, Sam Khalandovsky, Eder Santana, and Niel van der Westhuizen. Comma.ai research, 2016. URL https://github.com/commaai/research. ",
+        "bbox": [
+            174,
+            363,
+            823,
+            392
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mariusz Bojarski, Davide Del Testa, Daniel Dworakowski, Bernhard Firner, Beat Flepp, Prasoon Goyal, Lawrence D. Jackel, Mathew Monfort, Urs Muller, Jiakai Zhang, Xin Zhang, Jake Zhao, and Karol Zieba. End to end learning for self-driving cars. CoRR, 2016. ",
+        "bbox": [
+            173,
+            400,
+            826,
+            443
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bert De Brabandere, Xu Jia, Tinne Tuytelaars, and Luc Van Gool. Dynamic filter networks. CoRR, 2016. ",
+        "bbox": [
+            173,
+            452,
+            823,
+            479
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rakesh Chalasani and Jose C. Principe. Deep predictive coding networks. CoRR, 2013. ",
+        "bbox": [
+            178,
+            488,
+            750,
+            503
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Franc¸ois Chollet. Comma.ai, 2016. URL http://keras.io/. ",
+        "bbox": [
+            173,
+            512,
+            609,
+            527
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andy Clark. Whatever next? predictive brains, situated agents, and the future of cognitive science. Behavioral and Brain Sciences, 2013. ",
+        "bbox": [
+            173,
+            535,
+            823,
+            564
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Piotr Dollar, Christian Wojek, Bernt Schiele, and Pietro Perona. Pedestrian detection: A benchmark.´ In CVPR, 2009. ",
+        "bbox": [
+            174,
+            571,
+            823,
+            602
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tobias Egner, Jim M. Monti, and Christopher Summerfield. Expectation and surprise determine neural population responses in the ventral visual stream. J Neurosci, 2010. ",
+        "bbox": [
+            173,
+            611,
+            823,
+            638
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chelsea Finn, Ian J. Goodfellow, and Sergey Levine. Unsupervised learning for physical interaction through video prediction. CoRR, 2016. ",
+        "bbox": [
+            174,
+            647,
+            820,
+            676
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Peter Foldi ¨ ak. Learning invariance from transformation sequences. ´ Neural Computation, 1991. ",
+        "bbox": [
+            174,
+            684,
+            797,
+            700
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karl Friston. A theory of cortical responses. Philos Trans R Soc Lond B Biol Sci, 2005. ",
+        "bbox": [
+            173,
+            708,
+            748,
+            723
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andreas Geiger, Philip Lenz, Christoph Stiller, and Raquel Urtasun. Vision meets robotics: The kitti dataset. International Journal of Robotics Research (IJRR), 2013. ",
+        "bbox": [
+            174,
+            731,
+            821,
+            761
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dileep George and Jeff Hawkins. A hierarchical bayesian model of invariant pattern recognition in the visual cortex. In Proceedings of the International Joint Conference on Neural Networks. IEEE, 2005. ",
+        "bbox": [
+            174,
+            768,
+            823,
+            811
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In NIPS. 2014. ",
+        "bbox": [
+            174,
+            820,
+            821,
+            849
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ross Goroshin, Joan Bruna, Jonathan Tompson, David Eigen, and Yann LeCun. Unsupervised learning of spatiotemporally coherent metrics. CoRR, 2015a. ",
+        "bbox": [
+            174,
+            858,
+            821,
+            887
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ross Goroshin, Michael Mathieu, and Yann LeCun. Learning to linearize under uncertainty. ¨ CoRR, 2015b. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. Neural Computation, 1997. ",
+        "bbox": [
+            171,
+            103,
+            808,
+            119
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Catalin Ionescu, Dragos Papava, Vlad Olaru, and Cristian Sminchisescu. Human3.6m: Large scale datasets and predictive methods for 3d human sensing in natural environments. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2014. ",
+        "bbox": [
+            176,
+            127,
+            821,
+            171
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kevin Jarrett, Koray Kavukcuoglu, MarcAurelio Ranzato, and Yann LeCun. What is the best multistage architecture for object recognition? In ICCV. 2009. ",
+        "bbox": [
+            171,
+            180,
+            823,
+            210
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ryota Kanai, Yutaka Komura, Stewart Shipp, and Karl Friston. Cerebral hierarchies : predictive processing , precision and the pulvinar. Philos Trans R Soc Lond B Biol Sci, 2015. ",
+        "bbox": [
+            174,
+            219,
+            820,
+            250
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, 2014. ",
+        "bbox": [
+            174,
+            258,
+            799,
+            273
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tejas D. Kulkarni, Will Whitney, Pushmeet Kohli, and Joshua B. Tenenbaum. Deep convolutional inverse graphics network. CoRR, 2015. ",
+        "bbox": [
+            173,
+            284,
+            820,
+            313
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tai Sing Lee and David Mumford. Hierarchical bayesian inference in the visual cortex. J Opt Soc Am A Opt Image Sci Vis, 2003. ",
+        "bbox": [
+            173,
+            321,
+            823,
+            352
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "William Lotter, Gabriel Kreiman, and David Cox. Unsupervised learning of visual structure using predictive generative networks. CoRR, 2015. ",
+        "bbox": [
+            174,
+            361,
+            823,
+            391
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Davide Maltoni and Vincenzo Lomonaco. Semi-supervised tuning from temporal coherence. CoRR, 2015. ",
+        "bbox": [
+            173,
+            400,
+            825,
+            429
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael Mathieu, Camille Couprie, and Yann LeCun. Deep multi-scale video prediction beyond ¨ mean square error. ICLR, 2016. ",
+        "bbox": [
+            171,
+            439,
+            823,
+            468
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Vincent Michalski, Roland Memisevic, and Kishore Konda. Modeling deep temporal dependencies with recurrent ”grammar cells”. In NIPS. 2014. ",
+        "bbox": [
+            173,
+            478,
+            823,
+            507
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hossein Mohabi, Ronan Collobert, and Jason Weston. Deep learning from temporal coherence in video. In ICML. 2009. ",
+        "bbox": [
+            173,
+            517,
+            823,
+            546
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Junhyuk Oh, Xiaoxiao Guo, Honglak Lee, Richard L. Lewis, and Satinder P. Singh. Actionconditional video prediction using deep networks in atari games. CoRR, 2015. ",
+        "bbox": [
+            173,
+            555,
+            821,
+            585
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Randall C. O’Reilly, Dean Wyatte, and John Rohrlich. Learning through time in the thalamocortical loops. CoRR, 2014. ",
+        "bbox": [
+            173,
+            594,
+            821,
+            625
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rasmus Berg Palm. Prediction as a candidate for learning deep hierarchical models of data. Master’s thesis, Technical University of Denmark, 2012. ",
+        "bbox": [
+            173,
+            633,
+            821,
+            662
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Viorica Patraucean, Ankur Handa, and Roberto Cipolla. Spatio-temporal video autoencoder with differentiable memory. CoRR, 2015. ",
+        "bbox": [
+            174,
+            672,
+            823,
+            702
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mohammad Pezeshki, Linxi Fan, Philemon Brakel, Aaron C. Courville, and Yoshua Bengio. Deconstructing the ladder network architecture. CoRR, 2015. ",
+        "bbox": [
+            173,
+            712,
+            823,
+            741
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Pinto, David Doukhan, James J. DiCarlo, and David D. Cox. A high-throughput screening approach to discovering good forms of biologically inspired visual representation. PLoS Comput Biol, 2009. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            792
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Marc’Aurelio Ranzato, Arthur Szlam, Joan Bruna, Michael Mathieu, Ronan Collobert, and Sumit ¨ Chopra. Video (language) modeling: a baseline for generative models of natural videos. CoRR, 2014. ",
+        "bbox": [
+            174,
+            803,
+            823,
+            845
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rajesh P. N. Rao and Dana H. Ballard. Predictive coding in the visual cortex: a functional interpretation of some extra-classical receptive-field effects. Nature Neuroscience, 1999. ",
+        "bbox": [
+            169,
+            856,
+            821,
+            885
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rajesh P. N. Rao and T. J. Sejnowski. Predictive sequence learning in recurrent neocortical circuits. NIPS, 2000. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Antti Rasmus, Harri Valpola, Mikko Honkala, Mathias Berglund, and Tapani Raiko. Semisupervised learning with ladder network. CoRR, 2015. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Eder Santana and George Hotz. Learning a driving simulator. CoRR, 2016. ",
+        "bbox": [
+            173,
+            140,
+            668,
+            156
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Andrew Saxe, Maneesh Bhand, Zhenghao Chen, Pang Wei Koh, Bipin Suresh, and Andrew Y. Ng. On random weights and unsupervised feature learning. In Workshop: Deep Learning and Unsupervised Feature Learning (NIPS). 2010. ",
+        "bbox": [
+            178,
+            165,
+            825,
+            208
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xingjian Shi, Zhourong Chen, Hao Wang, Dit-Yan Yeung, Wai-Kin Wong, and Wang-chun Woo. Convolutional LSTM network: A machine learning approach for precipitation nowcasting. CoRR, 2015. ",
+        "bbox": [
+            174,
+            215,
+            825,
+            258
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Singular Inversions, Inc. FaceGen. http://facegen.com. ",
+        "bbox": [
+            173,
+            268,
+            589,
+            284
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "William R. Softky. Unsupervised pixel-prediction. NIPS, 1996. ",
+        "bbox": [
+            173,
+            291,
+            589,
+            308
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "M. W. Spratling. Unsupervised learning of generative and discriminative weights encoding elementary image components in a predictive coding model of cortical function. Neural Computation, 2012. ",
+        "bbox": [
+            173,
+            315,
+            825,
+            358
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Elman Mansimov, and Ruslan Salakhutdinov. Unsupervised learning of video representations using lstms. CoRR, 2015. ",
+        "bbox": [
+            171,
+            367,
+            825,
+            396
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Christopher Summerfield, Tobias Egner, Matthew Greene, Etienne Koechlin, Jennifer Mangels, and Joy Hirsch. Predictive codes for forthcoming perception in the frontal cortex. Science, 314, 2006. ",
+        "bbox": [
+            173,
+            405,
+            823,
+            434
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Lin Sun, Kui Jia, Tsung-Han Chan, Yuqiang Fang, Gang Wang, and Shuicheng Yan. Dl-sfa: Deeplylearned slow feature analysis for action recognition. CVPR, 2014. ",
+        "bbox": [
+            171,
+            443,
+            823,
+            472
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Lucas Theis, Aaron van den Oord, and Matthias Bethge. A note on the evaluation of generative models. ICLR, 2016. ",
+        "bbox": [
+            173,
+            481,
+            823,
+            510
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Harri Valpola. From neural pca to deep unsupervised learning. CoRR, 2015. ",
+        "bbox": [
+            174,
+            518,
+            673,
+            534
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Carl Vondrick, Hamed Pirsiavash, and Antonio Torralba. Generating videos with scene dynamics. CoRR, 2016. ",
+        "bbox": [
+            173,
+            542,
+            821,
+            570
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xiaolong Wang and Abhinav Gupta. Unsupervised learning of visual representations using videos. CoRR, 2015. ",
+        "bbox": [
+            173,
+            580,
+            821,
+            609
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zhou Wang, Alan Bovik, Hamid Sheikh, and Eero Simoncelli. Image quality assessment: From error visibility to structural similarity. IEEE Transactions on Image Processing, 2004. ",
+        "bbox": [
+            171,
+            617,
+            823,
+            647
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "William F. Whitney, Michael Chang, Tejas D. Kulkarni, and Joshua B. Tenenbaum. Understanding visual concepts with continuation learning. CoRR, 2016. ",
+        "bbox": [
+            171,
+            655,
+            823,
+            684
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Laurenz Wiskott and Terrence J. Sejnowski. Learning invariance from transformation sequences. Neural Computation, 2002. ",
+        "bbox": [
+            171,
+            693,
+            821,
+            722
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tianfan Xue, Jiajun Wu, Katherine L. Bouman, and William T. Freeman. Visual dynamics: Probabilistic future frame synthesis via cross convolutional networks. CoRR, 2016. ",
+        "bbox": [
+            173,
+            731,
+            823,
+            760
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "5 APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            294,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "5.1 ADDITIONAL CONTROL MODELS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            133,
+            442,
+            148
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Table 3 contains results for additional variations of the PredNet and CNN-LSTM Encoder-Decoder evaluated on the CalTech Pedestrian Dataset after being trained on KITTI. We evaluate the models in terms of pixel prediction, thus using the PredNet model trained with loss only on the lowest layer (PredNet $L _ { 0 }$ ) as the base model. In addition to mean-squared error (MSE) and the Structural Similarity Index Measure (SSIM), we include calculations of the Peak Signal-To-Noise Ratio (PSNR). For each model, we evaluate it with the original set of hyperparameters (controlling the number of layers, filter sizes, and number of filters per layer), as well as with the four additional sets of hyperparameters that were randomly sampled from the initial random search (see main text for more details). Below is an explanation of the additional control models: ",
+        "bbox": [
+            174,
+            159,
+            825,
+            285
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "• PredNet (no E split): PredNet model except the error responses $( E _ { l } )$ are simply linear $( \\hat { A } _ { l } - A _ { l } )$ instead of being split into positive and negative rectifications. ",
+        "bbox": [
+            218,
+            296,
+            823,
+            327
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "• CNN-LSTM Enc.-Dec. $2 \\mathbf { x } \\ A _ { l }$ filts): CNN-LSTM Encoder-Decoder model ( $\\mathbf { \\delta } _ { \\cdot } A _ { l }$ ’s are passed instead of $E _ { l }$ ’s) except the number of filters in $A _ { l }$ is doubled. This controls for the total number of filters in the model compared to the PredNet, since the PredNet has filters to produce $\\hat { A } _ { l }$ at each layer, which is integrated into the model’s feedforward response. ",
+        "bbox": [
+            218,
+            332,
+            821,
+            390
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "• CNN-LSTM Enc.-Dec. (except pass $E _ { 0 }$ ): CNN-LSTM Encoder-Decoder model except the error is passed at the lowest layer. All remaining layers pass the activations $A _ { l }$ . With training loss taken at only the lowest layer, this variation allows us to determine if the “prediction” subtraction operation in upper layers, which is essentially unconstrained and learnable in the $L _ { 0 }$ case, aids in the model’s performance. ",
+        "bbox": [
+            222,
+            393,
+            821,
+            464
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "• CNN-LSTM Enc.-Dec. $+ / -$ split): CNN-LSTM Encoder-Decoder model except the activations $A _ { l }$ are split into positive and negative populations before being passed to other layers in the network. This isolates the effect of the additional nonlinearity introduced by this procedure. ",
+        "bbox": [
+            218,
+            468,
+            823,
+            523
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/107c35df6bbb37645497e7b53542e2f2d0502b22d0f65ffd8195ba3e604f3321.jpg",
+        "table_caption": [
+            "Table 3: Quantitative evaluation of additional controls for next-frame prediction in CalTech Pedestrian Dataset after training on KITTI. First number indicates score with original hyperparameters. Number in parenthesis indicates score averaged over total of five different hyperparameters. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>MSE (x 10-3)</td><td>PSNR</td><td>SSIM</td></tr><tr><td>PredNet</td><td>3.13 (3.33)</td><td>25.8 (25.5)</td><td>0.884 (0.878)</td></tr><tr><td>PredNet (no Et split)</td><td>3.20 (3.37)</td><td>25.6 (25.4)</td><td>0.883 (0.878)</td></tr><tr><td>CNN-LSTMEnc.-Dec.</td><td>3.67 (3.91)</td><td>25.0 (24.6)</td><td>0.865 (0.856)</td></tr><tr><td>CNN-LSTM Enc.-Dec. (2x At filts)</td><td>3.82 (3.97)</td><td>24.8 (24.6)</td><td>0.857 (0.853)</td></tr><tr><td>CNN-LSTM Enc.-Dec. (except pass Eo)</td><td>3.41 (3.61)</td><td>25.4 (25.1)</td><td>0.873 (0.866)</td></tr><tr><td>CNN-LSTMEnc.-Dec. (+/- split)</td><td>3.71 (3.84)</td><td>24.9 (24.7)</td><td>0.861 (0.857)</td></tr><tr><td>Copy Last Frame</td><td>7.95</td><td>20.0</td><td>0.762</td></tr></table>",
+        "bbox": [
+            192,
+            577,
+            805,
+            691
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Equalizing the number of filters in the CNN-LSTM Encoder-Decoder (2x $A _ { l }$ filts) cannot account for its performance difference with the PredNet, and actually leads to overfitting and a decrease in performance. Passing the error at the lowest layer $( E _ { 0 } )$ in the CNN-LSTM Enc.-Dec. improves performance, but still does not match the PredNet, where errors are passed at all layers. Finally, splitting the activations $A _ { l }$ into positive and negative populations in the CNN-LSTM Enc.-Dec. does not help, but the PredNet with linear error activation (“no $E _ { l }$ split”) performs slightly worse than the original split version. Together, these results suggest that the PredNet’s error passing operation can lead to improvements in next-frame prediction performance. ",
+        "bbox": [
+            174,
+            713,
+            825,
+            824
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "5.2 COMPARING AGAINST OTHER MODELS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            842,
+            488,
+            856
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "While our main comparison in the text was a control model that isolates the effects of the more unique components in the PredNet, here we directly compare against other published models. We report results on a $6 4 \\mathrm { x 6 4 }$ pixel, grayscale car-cam dataset and the Human3.6M dataset (Ionescu et al., 2014) to compare against the two concurrently developed models by Brabandere et al. (2016) ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "and Finn et al. (2016), respectively. For both comparisons, we use a model with the same hyperparameters (# of layers, # of filters, etc.) of the PredNet $L _ { 0 }$ model trained on KITTI, but train from scratch on the new datasets. The only modification we make is to train using an L2 loss instead of the effective L1 loss, since both models train with an L2 loss and report results using L2-based metrics (MSE for Brabandere et al. (2016) and PSNR for Finn et al. (2016)). That is, we keep the original PredNet model intact but directly optimize using MSE between actual and predicted frames. We measure next-frame prediction performance after inputting 3 frames and 10 frames, respectively, for the 64x64 car-cam and Human3.6M datasets, to be consistent with the published works. We also include the results using a feedforward multi-scale network, similar to the model of Mathieu et al. (2016), on Human3.6M, as reported by Finn et al. (2016). ",
+        "bbox": [
+            173,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/0859777712d72e7eda2afebb1ef6c2bbf1d95cc70d3349b59b00613c896c12d4.jpg",
+        "table_caption": [
+            "Table 4: Evaluation of Next-Frame Predictions on 64x64 Car-Cam Dataset. MSE (per-pixel) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">MSE (per-pixel)</td></tr><tr><td>DFN (Brabandere et al., 2016)</td><td>1.71 ×10-3</td></tr><tr><td>PredNet</td><td>1.16 ×10-3</td></tr><tr><td>Copy Last Frame</td><td>3.58 ×10-3</td></tr></table>",
+        "bbox": [
+            173,
+            281,
+            490,
+            347
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/af305d25fd31840f4f7d01204db7b851530b42d92119ec96e453c9bf72ee30e6.jpg",
+        "table_caption": [
+            "Table 5: Evaluation of Next-Frame Predictions on Human3.6M PSNR "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>DNA (Finn et al., 2016) PredNet FF multi-scale (Mathieu et al.,2016)</td><td>42.1 38.9 26.7 32.0</td></tr></table>",
+        "bbox": [
+            531,
+            281,
+            823,
+            349
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "On a dataset similar to KITTI, our model outperforms the model proposed by Brabandere et al. (2016). On Human3.6M, our model outperforms a model similar to (Mathieu et al., 2016), but underperforms Finn et al. (2016), although we note we did not perform any hyperparameter optimization. ",
+        "bbox": [
+            173,
+            363,
+            825,
+            419
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "5.3 MULTIPLE TIME STEP PREDICTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            438,
+            460,
+            452
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/d9c247d44b99433c9cfb95c59a9b7fce77018f62bc8529b66fb02544335c6500.jpg",
+        "image_caption": [
+            "Figure 6: Extrapolation sequences generated by feeding PredNet predictions back into model. Left of the orange line: Normal $t + 1$ predictions; Right: Generated by recursively using the predictions as input. First row: Ground truth sequences. Second row: Generated frames of the original model, trained to solely predict $t + 1$ . Third row: Model fine-tuned for extrapolation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            468,
+            790,
+            871
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "While the models presented here were originally trained to predict one frame ahead, they can be made to predict multiple frames by treating predictions as actual input and recursively iterating. Examples of this process are shown in Figure 6 for the PredNet $L _ { 0 }$ model. Although the next frame predictions are reasonably accurate, the model naturally breaks down when extrapolating further into the future. This is not surprising since the predictions will unavoidably have different statistics than the natural images for which the model was trained to handle (Bengio et al., 2015). If we additionally train the model to process its own predictions, the model is better able to extrapolate. The third row for every sequence shows the output of the original PredNet fine-tuned for extrapolation. Starting from the trained weights, the model was trained with a loss over 15 time steps, where the actual frame was inputted for the first 10 and then the model’s predictions were used as input to the network for the last 5. For the first 10 time steps, the training loss was calculated on the $E _ { l }$ activations as usual, and for the last 5, it was calculated directly as the mean absolute error with respect to the ground truth frames. Despite eventual blurriness (which might be expected to some extent due to uncertainty), the fine-tuned model captures some key structure in its extrapolations after the tenth time step. For instance, in the first sequence, the model estimates the general shape of an upcoming shadow, despite minimal information in the last seen frame. In the second sequence, the model is able to extrapolate the motion of a car moving to the right. The reader is again encouraged to visit https://coxlab.github.io/prednet/ to view the predictions in video form. Quantitatively, the MSE of the model’s predictions stay well below the trivial solution of copying the last seen frame, as illustrated in Fig 7. The MSE increases fairly linearly from time steps 2-10, even though the model was only trained for up to $t + 5$ prediction. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            395
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/386c934c0c7cd4d4bb7e1f0e1e6977d14b386376dbb66698689a1d26524a0395.jpg",
+        "image_caption": [
+            "Figure 7: MSE of PredNet predictions as a function of number of time steps ahead predicted. Model was fine-tuned for up to $t + 5$ prediction. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            246,
+            426,
+            718,
+            707
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "5.4 ADDITIONAL STEERING ANGLE ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            758,
+            511,
+            772
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In Figure 8, we show the steering angle estimation accuracy on the Comma.ai (Biasini et al., 2016) dataset using the representation learned by the PredNet $L _ { 0 }$ model, as a function of the number of frames inputted into the model. The PredNet’s representation at all layers was concatenated (after spatially pooling lower layers to a common spatial resolution) and a fully-connected readout was fit using MSE. For each level of the number of training examples, we average over 10 cross-validation splits. To serve as points of reference, we include results for two static models. The first model is an autoencoder trained on single frame reconstruction with appropriately matching hyperparameters. A fully-connected layer was fit on the autoencoder’s representation to estimate the steering angle in the same fashion as the PredNet. The second model is the default model in the posted Comma.ai code (Biasini et al., 2016), which is a five layer CNN. This model is trained end-to-end to estimate the steering angle given the current frame as input, with a MSE loss. In addition to 25K examples, we trained a version using all of the frames in the Comma dataset (\\~396K). For all models, the final weights were chosen at the minimum validation error during training. Given the relatively small number of videos in the dataset compared to the average duration of each video, we used $5 \\%$ of each video for validation and testing, chosen as a random continuous chunk, and discarded the 10 frames before and after the chosen segments from the training set. ",
+        "bbox": [
+            173,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/786ee29cf8d282ebc8e20ea4c6a1d601619f455dd6984bab67feeada0044938e.jpg",
+        "image_caption": [
+            "Figure 8: Steering angle estimation accuracy as a function of the number of input frames. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            274,
+            118,
+            720,
+            401
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            446,
+            825,
+            530
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "As illustrated in Figure 8, the PredNet’s performance gets better over time, as one might expect, as the model is able to accumulate more information. Interestingly, it performs reasonably well after just one time step, in a regime that is orthogonal to the training procedure of the PredNet where there are no dynamics. Altogether, these results again point to the usefulness of the model in learning underlying latent parameters. ",
+        "bbox": [
+            174,
+            537,
+            825,
+            607
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "5.5 PREDNET $L _ { a l l }$ NEXT-FRAME PREDICTIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            623,
+            514,
+            638
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Figures 9 and 10 compare next-frame predictions by the PredNet $L _ { a l l }$ model, trained with a prediction loss on all layers ( $\\lambda _ { 0 } = 1$ , $\\lambda _ { l > 0 } = 0 . 1 $ ), and the PredNet $L _ { 0 }$ model, trained with a loss only on the lowest layer. At first glance, the difference in predictions seem fairly minor, and indeed, in terms of MSE, the $L _ { a l l }$ model only underperformed the $L _ { 0 }$ version by $3 \\%$ and $6 \\%$ , respectively, for the rotating faces and CalTech Pedestrian datasets. Upon careful inspection, however, it is apparent that the $L _ { a l l }$ predictions lack some of the finer details of the $L _ { 0 }$ predictions and are more blurry in regions of high variance. For instance, with the rotating faces, the facial features are less defined and with CalTech, details of approaching shadows and cars are less precise. ",
+        "bbox": [
+            173,
+            650,
+            825,
+            762
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/235db1e2a31428ae54787e2a5c30dc4c978774edcf9dd06ef6ac6cecc851ece6.jpg",
+        "image_caption": [
+            "time ",
+            "Figure 9: Next-frame predictions of PredNet $L _ { a l l }$ model on the rotating faces dataset and comparison to $L _ { 0 }$ version. The ”Error ${ \\cal L } _ { a l l } { - \\cal L } _ { 0 } { } ^ { \\cdots }$ visualization shows where the pixel error was smaller for the $L _ { 0 }$ model than the $L _ { a l l }$ model. Green regions correspond to where $L _ { 0 }$ was better and red corresponds to where $L _ { a l l }$ was better. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            268,
+            825,
+            699
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/5436ead45eb2f3750a49987e6825e0fe9897d10aa4f0e52240e2823c9aafffd5.jpg",
+        "image_caption": [
+            "time ",
+            "Figure 10: Next-frame predictions of PredNet $L _ { a l l }$ model on the CalTech Pedestrian dataset and comparison to $L _ { 0 }$ version. The ”Error ${ \\cal L } _ { a l l } - { \\cal L } _ { 0 } { } ^ {  }$ visualization shows where the pixel error was smaller for the $L _ { 0 }$ model than the $L _ { a l l }$ model. Green regions correspond to where $L _ { 0 }$ was better and red corresponds to where $L _ { a l l }$ was better. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            204,
+            823,
+            757
+        ],
+        "page_idx": 17
+    }
+]

parse/train/S1J2ZyZ0Z/S1J2ZyZ0Z.md

@@ -0,0 +1,395 @@
+# INTERPRETABLE COUNTING FOR VISUAL QUESTION ANSWERING
+
+Alexander Trott, Caiming Xiong∗, & Richard Socher Salesforce Research   
+Palo Alto, CA   
+{atrott,cxiong,rsocher}@salesforce.com
+
+# ABSTRACT
+
+Questions that require counting a variety of objects in images remain a major challenge in visual question answering (VQA). The most common approaches to VQA involve either classifying answers based on fixed length representations of both the image and question or summing fractional counts estimated from each section of the image. In contrast, we treat counting as a sequential decision process and force our model to make discrete choices of what to count. Specifically, the model sequentially selects from detected objects and learns interactions between objects that influence subsequent selections. A distinction of our approach is its intuitive and interpretable output, as discrete counts are automatically grounded in the image. Furthermore, our method outperforms the state of the art architecture for VQA on multiple metrics that evaluate counting.
+
+# 1 INTRODUCTION
+
+Visual question answering (VQA) is an important benchmark to test for context-specific reasoning over complex images. While the field has seen substantial progress, counting-based questions have seen the least improvement (Chattopadhyay et al., 2017). Intuitively, counting should involve finding the number of distinct scene elements or objects that meet some criteria, see Fig. 1 for an example. In contrast, the predominant approach to VQA involves representing the visual input with the final feature map of a convolutional neural network (CNN), attending to regions based on an encoding of the question, and classifying the answer from the attention-weighted image features (Xu & Saenko, 2015; Yang et al., 2015; Xiong et al., 2016; Lu et al., 2016b; Fukui et al., 2016; Kim et al., 2017). Our intuition about counting seems at odds with the effects of attention, where a weighted average obscures any notion of distinct elements. As such, we are motivated to re-think the typical approach to counting in VQA and propose a method that embraces the discrete nature of the task.
+
+Our approach is partly inspired by recent work that represents images as a set of distinct objects, as identified by object detection (Anderson et al., 2017), and making use of the relationships between these objects (Teney et al., 2016). We experiment with counting systems that build off of the vision module used for these two works, which represents each image as a set of detected objects. For training and evaluation, we create a new dataset, HowMany-QA. It is taken from the countingspecific union of VQA 2.0 (Goyal et al., 2017) and Visual Genome QA (Krishna et al., 2016).
+
+We introduce the Interpretable Reinforcement Learning Counter (IRLC), which treats counting as a sequential decision process. We treat learning to count as learning to enumerate the relevant objects in the scene. As a result, IRLC not only returns a count but also the objects supporting its answer. This output is produced through an iterative method. Each step of this sequence has two stages: First, an object is selected to be added to the count. Second, the model adjusts the priority given to unselected objects based on their configuration with the selected objects (Fig. 1). We supervise only the final count and train the decision process using reinforcement learning (RL).
+
+Additional experiments highlight the importance of the iterative approach when using this manner of weak supervision. Furthermore, we train the current state of the art model for VQA on HowManyQA and find that IRLC achieves a higher accuracy and lower count error. Lastly, we compare the grounded counts of our model to the attentional focus of the state of the art baseline to demonstrate the interpretability gained through our approach.
+
+![](images/c5c9e95ac41429cf8416b9cdb435a7bbb84393ff4f9260f52bb1e7cea6f04f52.jpg)  
+Figure 1: IRLC takes as input a counting question and image. Detected objects are added to the returned count through a sequential decision process. The above example illustrates actual model behavior after training.
+
+# 2 RELATED WORK
+
+Visual representations for counting. As a standalone problem, counting from images has received some attention but typically within specific problem domains. Segui et al. (2015) explore training a CNN to count directly from synthetic data. Counts can also be estimated by learning to produce density maps for some category of interest (typically people), as in Lempitsky & Zisserman (2010); Onoro-Rubio & L ˜ opez-Sastre ´ (2016); Zhang et al. (2015). Density estimation simplifies the more challenging approach of counting by instance-by-instance detection (Ren & Zemel, 2017). Methods to detect objects and their bounding boxes have advanced considerably (Girshick et al., 2015; Girshick, 2015; Ren et al., 2015b; Dai et al., 2016; Lin et al., 2017) but tuning redundancy reduction steps in order to count is unreliable (Chattopadhyay et al., 2017). Here, we overcome this limitation by allowing flexible, question specific interactions during counting.
+
+Alternative approaches attempt to model subitizing, which describes the human ability to quickly and accurately gauge numerosity when at most a few objects are present. Zhang et al. (2017) demonstrates that CNNs may be trained towards a similar ability when estimating the number of salient objects in a scene. This approach was extended to counting 80 classes of objects simultaneously in Chattopadhyay et al. (2017). Their model is trained to estimate counts within each subdivision of the full image, where local counts are typically within the subitizing range.
+
+The above studies apply counting to a fixed set of object categories. In contrast, we are interested in counting during visual question answering, where the criteria for counting change from question to question and can be arbitrarily complex. This places our work in a different setting than those that count from the image alone. For example, Chattopadhyay et al. (2017) apply their trained models to a subset of VQA questions, but their analysis was limited to the specific subset of examples where the question and answer labels agreed with the object detection labels they use for training. Here, we overcome this limitation by learning to count directly from question/answer pairs.
+
+Visual question answering. The potential of deep learning to fuse visual and linguistic reasoning has been recognized for some time (Socher et al., 2014; Lu et al., 2016a). Visual question answering poses the challenge of retrieving question-specific information from an associated image, often requiring complex scene understanding and flexible reasoning. In recent years, a number of datasets have been introduced for studying this problem (Malinowski & Fritz, 2014; Ren et al., 2015a; Zhu et al., 2015; Agrawal et al., 2015; Goyal et al., 2017; Krishna et al., 2016). The majority of recent progress has been aimed at the so-named “VQA” datasets (Agrawal et al., 2015; Goyal et al., 2017), where counting questions represent roughly $11 \%$ of the data. Though our focus is on counting questions specifically, prior work on VQA is highly relevant.
+
+An early baseline for VQA represents the question and image at a coarse granularity, respectively using a “bag of words” embedding along with spatially-pooled CNN outputs to classify the answer (Zhou et al., 2015). In Ren et al. (2015a), a similar fixed-length image representation is fused with the question embeddings as input to a recurrent neural network (RNN), from which the answer is classified.
+
+Attention. More recent variants have chosen to represent the image at a finer granularity by omitting the spatial pooling of the CNN feature map and instead use attention to focus relevant image regions before producing an answer (Xu & Saenko, 2015; Yang et al., 2015; Xiong et al., 2016; Lu et al., 2016b; Fukui et al., 2016; Kim et al., 2017). These works use the spatially-tiled feature vectors output by a CNN to represent the image; others follow the intuition that a more meaningful representation may come from parsing the feature map according to the locations of objects in the scene (Shih et al., 2015; Ilievski et al., 2016). Notably, using object detection was a key design choice for the winning submission for the VQA 2017 challenge (Anderson et al., 2017; Teney et al., 2017). Work directed at VQA with synthetic images (which sidesteps the challenges created by computer vision) has further demonstrated the utility that relationships may provide as an additional form of image annotation (Teney et al., 2016).
+
+Interpretable VQA. The use of “scene graphs” in real-image VQA would have the desirable property that intermediate model variables would be grounded in concepts explicitly, a step towards making neural reasoning more transparent. A conceptual parallel to this is found in Neural Module Networks (Andreas et al., 2016a;b; Hu et al., 2017), which gain interpretability by grounding the reasoning process itself in defined concepts. The general concept of interpretable VQA has been the subject of recent interest. Park et al. (2016) extends the task itself to include generating explanations for produced answers. Chandrasekaran et al. (2017) take a different approach, asking how well humans can learn patterns in answers and failures of a trained VQA model. While humans indeed identify some patterns, they do not gain any apparent insight from knowing intermediate states of the model (such as its attentional focus). In light of this, we are motivated by the goal of developing more transparent AI.
+
+We address this at the level of counting in VQA. We show that, despite the challenge presented by this particular task, an intuitive approach gains in both performance and interpretability over state of the art.
+
+# 3 DATASETS
+
+Within the field of VQA, the majority of progress has been aimed at the VQA dataset (Agrawal et al., 2015) and, more recently, VQA 2.0 (Goyal et al., 2017), which expands the total number of questions in the dataset and attempts to reduce bias by balancing answers to repeated questions. VQA 2.0 consists of 1.1M questions pertaining to the 205K images from COCO (Lin et al., 2014). The examples are divided according to the official COCO splits.
+
+In addition to VQA 2.0, we incorporate the Visual Genome (VG) dataset (Krishna et al., 2016). Visual Genome consists of 108K images, roughly half of which are part of COCO. VG includes its own visual question answering dataset. We include examples from that dataset when they pertain to an image in the VQA 2.0 training set.
+
+# 3.1 HOWMANY-QA
+
+In order to evaluate counting specifically, we define a subset of the QA pairs, which we refer to as HowMany-QA. Our inclusion criteria were designed to filter QA pairs where the question asks for a count, as opposed to simply an answer in the form of a number (Fig 2). For the first condition, we require that the question contains one of the following phrases: “how many”, “number of”, “amount of”, or “count of”. We also reject a question if it contains the phrase “number of the”, since this phrase frequently refers to a printed number rather than a count (i.e. “what is the number of the bus?”). Lastly, we require that the ground-truth answer is a number between 0 to 20 (inclusive). The original VQA 2.0 train set includes roughly 444K QA pairs, of which 57,606 are labeled as having a “number” answer. Focusing on counting questions results in a still very large dataset with 47,542 pairs, showing the importance of this subtask.
+
+![](images/668b7443547a18002b177a3df0279a6acb148c7c828c7408873ca9b1f71c9dbd.jpg)  
+Figure 2: Examples of question-answer pairs that are excluded from HowMany-QA. This selection exemplifies the common types of “number” questions that do not require counting and therefore distract from our objective: (from left to right) time, general number-based answers, ballparking, and reading numbers from images. Importantly, the standard VQA evaluation metrics do not distinguish these from counting questions; instead, performance is reported for “number” questions as a whole.
+
+Due to our filter and focus on counting questions, we cannot make use of the official test data since its annotations are not available. Hence, we divide the validation data into separate development and test sets. More specifically, we apply the above criteria to the official validation data and select 5,000 of the resulting QA pairs to serve as the test data. The remaining 17,714 QA pairs are used as the development set.
+
+As mentioned above, the HowMany-QA training data is augmented with available QA pairs
+
+Table 1: Size breakdown of HowMany-QA. Neither development or test included VG data.   
+
+<table><tr><td>Split</td><td>QA Pairs</td><td>Images</td></tr><tr><td>Train</td><td>83,642</td><td>31,932</td></tr><tr><td>from VQA 2.0</td><td>47,542</td><td>31,932</td></tr><tr><td> from VG</td><td>36,100</td><td>0</td></tr><tr><td>Dev.</td><td>17,714</td><td>13,119</td></tr><tr><td>Test</td><td>5,000</td><td>2,483</td></tr></table>
+
+from Visual Genome, which are selected using the same criteria. A breakdown of the size and composition of HowMany-QA is provided in Table 1. All models compared in this work are trained and evaluated on HowMany-QA. To facilitate future comparison to our work, we have made the training, development, and test question IDs available for download.
+
+# 4 MODEL
+
+In this work, we focus specifically on counting in the setting of visual question answering (where the criteria for counting changes on a question-by-question basis). In addition, we are interested in model interpretability. We explore this notion by experimenting with models that are capable of producing question-guided counts which are visually grounded in object proposals.
+
+Rather than substantially modifying existing counting approaches – such as Chattopadhyay et al. (2017) – we compare three models whose architectures naturally fit within our experimental scope. These models each produce a count from the outputs of an object detection module and use identical strategies to encode the question and compare it to the detected objects. The models differ only in terms of how these components are used to produce a count (Fig. 3a).
+
+# 4.1 OBJECT DETECTION
+
+Our approach is inspired by the strategy of Anderson et al. (2017) and Teney et al. (2017). Their model, which represents current state of the art in VQA, infers objects as the input to the questionanswering system. This inference is performed using the Faster R-CNN architecture (Ren et al., 2015b). The Faster R-CNN proposes a set of regions corresponding to objects in the image. It encodes the image as a set of bounding boxes $\left\{ b _ { 1 } , . . . , b _ { N } \right\}$ , $b _ { i } \in \mathbb { R } ^ { 4 }$ and complementary set of object encodings $\left\{ v _ { 1 } , \dotsc , v _ { N } \right\}$ , $v _ { i } \in \mathbb { R } ^ { 2 0 4 8 }$ , corresponding to the locations and feature representations of each of the $N$ detected objects, respectively (blue box in Fig. 3a).
+
+![](images/2c5f371f62f7d35a6e0c81827a861b0cbd7733b1b7722346ef5e1d2947d80ced.jpg)  
+Figure 3: (a) Each model includes three basic modules: vision (blue), language (green), and counting (red). Text in the shaded regions describes which aspects of these modules are shared across models. (b) (left) The language model embeds the question and compares it to each object using a scoring function, which is jointly trained with caption grounding; (right) IRLC counting module.
+
+Rather than train our own vision module from scratch, we make use of the publicly available object proposals learned in Anderson et al. (2017). These provide rich, object-centric representations for each image in our dataset. These representations are fixed when learning to count and are shared across each of the QA models we experiment with.
+
+# 4.2 LANGUAGE
+
+Each architecture encodes the question and compares it to each detected object via a scoring function. We define $q$ as the final hidden state of an LSTM (Hochreiter & Schmidhuber, 1997) after processing the question and compute a score vector for each object (Fig. 3, green boxes):
+
+$$
+\begin{array} { r l } { h ^ { t } = \mathrm { L S T M } \left( x ^ { t } , h ^ { t - 1 } \right) \quad } & { { } q = h ^ { T } } \\ { s _ { i } = f ^ { S } \left( [ q , v _ { i } ] \right) \quad } & { { } } \end{array}
+$$
+
+Here, $x _ { t }$ denotes the word embedding of the question token at position $t$ and $s _ { i } \in \mathbb { R } ^ { n }$ denotes the score vector encoding the relevance of object $i$ to the question. Following Anderson et al. (2017), we implement the scoring function $f ^ { S } : \bar { \mathbb { R } ^ { m } }  \mathbb { R } ^ { n }$ as a layer of Gated Tanh Units (GTU) (van den Oord et al., 2016). $[ , ]$ denotes vector concatenation.
+
+We experiment with jointly training the scoring function to perform caption grounding, which we supervise using region captions from Visual Genome. Region captions provide linguistic descriptions of localized regions within the image, and the goal of caption grounding is to identify which object a given caption describes (details provided in Section B.1 of the Appendix). Caption grounding uses a strategy identical to that for question answering (Eqs. 1 and 2): an LSTM is used to encode each caption and the scoring function $f ^ { S }$ is used to encode its relevance to each detected object. The weights of the scoring function are tied for counting and caption grounding (Fig. 3b). We include results from experiments where caption grounding is ignored.
+
+# 4.3 COUNTING
+
+Interpretable RL Counter (IRLC). For our proposed model, we aim to learn how to count by learning what to count. We assume that each counting question implicitly refers to a subset of the objects within a scene that meet some variable criteria. In this sense, the goal of our model is to enumerate that subset of objects.
+
+![](images/38515b73a92b92a456cb7bba1b7325872b69b3aabf00f2fea83d573919a8d087.jpg)  
+Figure 4: Grounded counts produced by IRLC. Counts are formed from selections of detected objects. Each image displays the objects that IRLC chose to count.
+
+To implement this as a sequential decision process, we need to represent the probability of selecting a given action and how each action affects subsequent choices. To that end, we project the object scores $s \in \mathbb { R } ^ { N \times n }$ to a vector of logits $\boldsymbol { \kappa } \in \mathbb { R } ^ { N }$ , representing how likely each object is to be counted, where $N$ is the number of detected objects:
+
+$$
+\kappa = W s + b
+$$
+
+And we compute a matrix of interaction terms $\boldsymbol { \rho } \in \mathbb { R } ^ { N \times N }$ that are used to update the logits $\kappa$ . The value $\rho _ { i j }$ represents how selecting object $i$ will change $\kappa _ { j }$ . We calculate this interaction from a compressed representation of the question $( W q )$ , the dot product of the normalized object vectors $( \hat { v } _ { i } ^ { \mathrm { T } } \bar { \hat { v } } _ { j } )$ , the object coordinates $b _ { i }$ and $b _ { j }$ ), and basic overlap statistics $( \mathrm { I o U } _ { i j }$ , $\mathrm { O } _ { i j }$ , and ${ \mathrm { O } } _ { j i }$ ):
+
+$$
+\rho _ { i j } = f ^ { \rho } \left( \left[ W q , \hat { v } _ { i } ^ { \mathrm { T } } \hat { v } _ { j } , b _ { i } , b _ { j } , \mathrm { I o U } _ { i j } , \mathrm { O } _ { i j } , \mathrm { O } _ { j i } \right] \right)
+$$
+
+where $f ^ { \rho } : x \in \mathbb { R } ^ { m } \Rightarrow \mathbb { R }$ is a 2-layer MLP with ReLU activations.
+
+For each step $t$ of the counting sequence we greedily select the action with the highest value (interpreted as either selecting the next object to count or terminating), and update $\kappa$ accordingly:
+
+$$
+\begin{array} { r } { a ^ { t } = \operatorname { a r g m a x } _ { i } \left[ \kappa ^ { t } , \zeta \right] } \\ { \kappa ^ { t + 1 } = \kappa ^ { t } + \rho ( a ^ { t } , \cdot ) } \end{array}
+$$
+
+where $\zeta$ is a learnable scalar representing the logit value of the terminal action, and $\kappa ^ { 0 }$ is the result of Equation 3 (Fig. 3b, red box). The action $a ^ { t }$ is expressed as the index of the selected object. $\rho ( \boldsymbol a ^ { t } , \cdot )$ denotes the row of $\rho$ indexed by $a ^ { t }$ . Each object is only allowed to be counted once. We define the count $C$ as the timestep when the terminal action was selected $t : a ^ { t } = N + 1$ .
+
+This approach bears some similarity to Non-Maximal Suppression (NMS), a staple technique in object detection to suppress redundant proposals. However, our approach is far less rigid and allows the question to determine how similar and/or overlapping objects interact.
+
+Training IRLC. Because the process of generating a count requires making discrete decisions, training requires that we use techniques from Reinforcement Learning. Given our formulation, a natural choice is to apply REINFORCE (Williams, 1992). To do so, we calculate a distribution over action probabilities $p ^ { t }$ from $\kappa ^ { t }$ and generate a count by iteratively sampling actions from the distribution:
+
+$$
+\begin{array} { l c r } { { p ^ { t } = \mathrm { s o f t m a x } \left( \left[ \kappa ^ { t } , \zeta \right] \right) } } & { { ~ a ^ { t } \sim p ^ { t } } } \\ { { \kappa ^ { t + 1 } = \kappa ^ { t } + \rho ( a ^ { t } , \cdot ) } } & { { } } \end{array}
+$$
+
+We calculate the reward using Self-Critical Sequence training (Rennie et al., 2017; Anderson et al., 2017; Paulus et al., 2017), a variation of policy gradient. We define $E = | C - C ^ { \mathrm { G T } } |$ to be the count error and define the reward as $R = E ^ { \mathrm { g r e e d y } } - E$ , where $E ^ { \mathrm { g r e e d y } }$ is the baseline count error obtained by greedy action selection (which is also how the count is measured at test time). From this, we define our (unnormalized) counting loss as
+
+$$
+\tilde { L } _ { C } = - R \sum _ { t } \log p ^ { t } \left( a ^ { t } \right)
+$$
+
+Additionally, we include two auxiliary objectives to aid learning. For each sampled sequence, we measure the total negative policy entropy $H$ across the observed time steps. We also measure the average interaction strength at each time step and collect the total
+
+$$
+\tilde { P } _ { \mathrm { H } } = - \sum _ { t } H \left( p ^ { t } \right) \qquad \tilde { P } _ { \mathrm { I } } = \sum _ { i \in \{ a ^ { 0 } . . . a ^ { t } \} } \frac { 1 } { N } \sum _ { j } L _ { 1 } \left( \rho _ { i j } \right)
+$$
+
+where $L _ { 1 }$ is the Huber loss from Eq 12. Including the entropy objective is a common strategy when using policy gradient (Williams & Peng, 1991; Minh et al., 2016; Luo et al., 2017) and is used to improve exploration. The interaction penalty is motivated by the a priori expectation that interactions should be sparse. During training, we minimize a weighted sum of the three losses, normalized by the number of decision steps. As before, we provide training and implementation details in the Appendix (Sec. B.2).
+
+SoftCount. As a baseline approach, we train a model to count directly from the outputs $s$ of the scoring function. For each object, we project its score vector $s _ { i }$ to a scalar value and apply a sigmoid nonlinearity, denoted as $\sigma$ , to assign the object a count value between 0 and 1. The total count is the sum of these fractional, object-specific count values. We train this model by minimizing the Huber loss associated with the absolute difference $e$ between the predicted count $C$ and the ground truth count CGT:
+
+$$
+\begin{array} { l } { { C = \displaystyle \sum _ { i } \sigma \left( W s _ { i } \right) } } \\ { { \ } } \\ { { L _ { 1 } = \left\{ \begin{array} { l l } { { 0 . 5 e ^ { 2 } } } & { { \mathrm { i f } e \leq 1 } } \\ { { e - 0 . 5 } } & { { \mathrm { o t h e r w i s e } } } \end{array} \right. \ } } & { { e = \left| C - C ^ { \mathrm { G T } } \right| } } \end{array}
+$$
+
+For evaluation, we round the estimated count $C$ to the nearest integer and limit the output to the maximum ground truth count (in this case, 20).
+
+Attention Baseline (UpDown). As a second baseline, we re-implement the QA architecture introduced in Anderson et al. (2017), which the authors refer to as UpDown – see also Teney et al. (2017) for additional details. We focus on this architecture for three main reasons. First, it represents the current state of the art for VQA 2.0. Second, it was designed to use the visual representations we employ. And, third, it exemplifies the common two-stage approach of (1) deploying question-based attention over image regions (here, detected objects) to get a fixed-length visual representation
+
+$$
+\alpha = \mathrm { s o f t m a x } \left( W s \right) ; \quad \hat { v } = \sum \alpha _ { i } v _ { i }
+$$
+
+and then (2) classifying the answer based on this average and the question encoding
+
+$$
+\begin{array} { r } { v ^ { \prime } = f ^ { V } \left( \hat { v } \right) ; \quad q ^ { \prime } = f ^ { Q } \left( q \right) } \\ { p = \mathrm { s o f t m a x } \left( f ^ { C } \left( v ^ { \prime } \otimes q ^ { \prime } \right) \right) } \end{array}
+$$
+
+where $s \in \mathbb { R } ^ { N \times n }$ denotes the matrix of score vectors for each of the $N$ detected objects and $\boldsymbol { \alpha } \in \mathbb { R } ^ { N }$ denotes the attention weights. Here, each function $f$ is implemented as a GTU layer and $\otimes$ denotes element-wise multiplication. For training, we use a cross entropy loss, with the target given by the ground-truth count. At test time, we use the most probable count given by $p$ .
+
+# 5 RESULTS
+
+# 5.1 COUNTING PERFORMANCE
+
+We use two metrics for evaluation. For consistency with past work, we report the standard VQA test metric of accuracy. Since accuracy does not measure the degree of error we also report root-meansquared-error (RMSE), which captures the typical deviation between the estimated and ground-truth count and emphasizes extreme errors. Details are provided in the Appendix (Sec. D).
+
+To better understand the performance of the above models, we also report the performance of two non-visual baselines. The first baseline (Guess1) shows the performance when the estimated count is always 1 (the most common answer in the training set). The second baseline (LSTM) learns to predict the count directly from a linear projection of the question embedding $q$ (Eq. 1).
+
+![](images/b3993a0fdceb6a5a7390b9fb11e39582f5a0a5c636da4ce7445c783758825216.jpg)  
+Figure 5: Model performance on the HowMany-QA development set, grouped according to the frequency with which the counting subject appeared in the training data.
+
+IRLC achieves the highest overall accuracy and (with SoftCount) the lowest overall RMSE on the test set (Table 2). Interestingly, SoftCount clearly lags in accuracy but is competitive in RMSE, arguing that accuracy and RMSE are not redundant. We observe this to result from the fact that IRLC is less prone to small errors and very slightly more prone to large errors (which disproportionately impact RMSE). However, whereas UpDown improves in accuracy at the cost of RMSE, IRLC is substantially more accurate without sacrificing overall RMSE.
+
+Table 2: HowMany-QA test set performance. Values in parentheses apply to models trained without caption grounding.   
+
+<table><tr><td>Model</td><td> Accuracy</td><td>RMSE</td></tr><tr><td>Guess1</td><td>33.8</td><td>3.74</td></tr><tr><td>LSTM</td><td>36.8</td><td>3.47</td></tr><tr><td>SoftCount</td><td>50.2 (49.2)</td><td>2.37 (2.45)</td></tr><tr><td>UpDown</td><td>52.7 (51.5)</td><td>2.64 (2.69)</td></tr><tr><td>IRLC</td><td>57.7 (56.1)</td><td>2.37 (2.45)</td></tr></table>
+
+To gain more insight into the performance of these models, we calculate these metrics within the development set after separating the data according to how common the subject of the count is during training1. We break up the questions into 5 roughly equal-sized bins representing increasingly uncommon subjects. We include a 6th bin for subjects never seen during training. The accuracy and RMSE across the development set are reported for each of these bins in Figure 5.
+
+Organizing the data this way reveals two main trends. First, all models perform better when asked to count subjects that were common during training. Second, the performance improvements offered by IRLC over UpDown persist over all groupings of the development data.
+
+# 5.2 GROUNDING QUALITY
+
+We introduce a novel analysis to quantify how well counted objects match the subject of the question. To perform this analysis, we form generic questions that refer to the object categories in the COCO object detection dataset. We take the object proposals counted in response to a given question and compare them to the ground truth COCO labels to determine how relevant the counted object proposals are. Our metric takes on a value of 1 when the counted objects perfectly map onto the category to which the question refers. Values around 0 indicate that the counted objects were not relevant to the question. Section D of the Appendix details how the grounding quality metric is calculated.
+
+We perform this analysis for each of the 80 COCO categories using the images in the HowMany-QA development set. Figure 6 compares the grounding quality of SoftCount and IRLC, where each point represents the average grounding quality for a particular COCO category. As with the previous two metrics, grounding quality is highest for COCO categories that are more common during training. We observe that IRLC consistently grounds its counts in objects that are more relevant to the question than does SoftCount. A paired t-test shows that this trend is statistically significant $( p < 1 0 ^ { \frac { \cdot } { - 1 5 } }$ ).
+
+![](images/aac1bc41d15a6b233520ec746286c1de24c89f12695398f9e5b94ddc90fcbdb9.jpg)  
+Figure 6: (Left) Average grounding quality for each of the COCO object categories, as measured for SoftCount and IRLC. Each point represents a COCO category and is colored according to how common the category was during training (as in Figure 5). (Right) Histogram showing the difference in grounding quality between IRLC and SoftCount.
+
+![](images/b5b11846760f40370474dccf1f9bb6284b472b4081139758787c42427419aefd.jpg)  
+Figure 7: Examples of failure cases with common and rare subjects (“people” and “ties,” respectively). Each example shows the output of IRLC, where boxes correspond to counted objects, and the output of UpDown, where boxes are shaded according to their attention weights.
+
+# 5.3 QUALITATIVE ANALYSIS
+
+The design of IRLC is inspired by the ideal of interpretable VQA (Chandrasekaran et al., 2017). One hallmark of interpretability is the ability to predict failure modes. We argue that this is made more approachable by requiring IRLC to identify the objects in the scene that it chooses to count.
+
+Figure 7 illustrates two failure cases that exemplify observed trends in IRLC. In particular, IRLC has little trouble counting people (they are the most common subject) but encounters difficulty with referring phrases (in this case, “sitting on the bench”). When asked to count ties (a rare subject), IRLC includes a sleeve in the output, demonstrating the tendency to misidentify objects with few training examples. These failures are obvious by virtue of the grounded counts, which point out exactly which objects IRLC counted. In comparison, the attention focus of UpDown (representing the closest analogy to a grounded output) does not identify any pattern. From the attention weights, it is unclear which scene elements form the basis of the returned count.
+
+Indeed, the two models may share similar deficits. We observe that, in many cases, they produce similar counts. However, we stress that without IRLC and the chance to observe such similarities such deficits of the UpDown model would be difficult to identify.
+
+The Appendix includes further visualizations and comparisons of model output, including examples of how IRLC uses the iterative decision process to produce discrete, grounded counts (Sec. A).
+
+# 6 CONCLUSION
+
+We present an interpretable approach to counting in visual question answering, based on learning to enumerate objects in a scene. By using RL, we are able to train our model to make binary decisions about whether a detected object contributes to the final count. We experiment with two additional baselines and control for variations due to visual representations and for the mechanism of visuallinguistic comparison. Our approach achieves state of the art for each of the evaluation metrics. In addition, our model identifies the objects that contribute to each count. These groundings provide traction for identifying the aspects of the task that the model has failed to learn and thereby improve not only performance but also interpretability.
+
+# REFERENCES
+
+Aishwarya Agrawal, Jiasen Lu, Stanislaw Antol, Margaret Mitchell, C. Lawrence Zitnick, Devi Parikh, and Dhruv Batra. VQA: Visual Question Answering. International Journal of Computer Vision, 2015.
+
+Peter Anderson, Xiaodong He, Chris Buehler, Damien Teney, Mark Johnson, Stephen Gould, and Lei Zhang. Bottom-Up and Top-Down Attention for Image Captioning and VQA. arXiv, 2017.
+
+Jacob Andreas, Marcus Rohrbach, Trevor Darrell, and Dan Klein. Neural module networks. In CVPR, 2016a.
+
+Jacob Andreas, Marcus Rohrbach, Trevor Darrell, and Dan Klein. Learning to Compose Neural Networks for Question Answering. In NAACL, 2016b.
+
+Arjun Chandrasekaran, Deshraj Yadav, Prithvijit Chattopadhyay, Viraj Prabhu, and Devi Parikh. It Takes Two to Tango: Towards Theory of AI’s Mind. arXiv, 2017.
+
+Prithvijit Chattopadhyay, Ramakrishna Vedantam, Ramprasaath R. Selvaraju, Dhruv Batra, and Devi Parikh. Counting Everyday Objects in Everyday Scenes. In CVPR, 2017.
+
+Jifeng Dai, Yi Li, Kaiming He, and Jian Sun. R-FCN: Object Detection via Region-based Fully Convolutional Networks. In NIPS, 2016.
+
+Akira Fukui, Dong Huk Park, Daylen Yang, Anna Rohrbach, Trevor Darrell, and Marcus Rohrbach. Multimodal compact bilinear pooling for visual question answering and visual grounding. In EMNLP, 2016.
+
+Ross Girshick. Fast R-CNN. In ICCV, 2015.
+
+Ross Girshick, Jeff Donahue, Trevor Darrell, and Jitendra Malik. Rich feature hierarchies for accurate object detection and semantic segmentation. In CVPR, 2015.
+
+Yash Goyal, Tejas Khot, Douglas Summers-Stay, Dhruv Batra, and Devi Parikh. Making the V in VQA Matter: Elevating the Role of Image Understanding in Visual Question Answering. In CVPR, 2017.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long Short-Term Memory. ¨ Neural Computation, 9(8): 1735–1780, 1997.
+
+Ronghang Hu, Jacob Andreas, Marcus Rohrbach, Trevor Darrell, and Kate Saenko. Learning to Reason: End-to-End Module Networks for Visual Question Answering. In ICCV, 2017.
+
+Ilija Ilievski, Shuicheng Yan, and Jiashi Feng. A Focused Dynamic Attention Model for Visual Question Answering. arXiv, 2016.
+
+Jin-Hwa Kim, Kyoung-Woon On, Woosang Lim, Jeonghee Kim, Jung-Woo Ha, and Byoung-Tak Zhang. Hadamard Product for Low-rank Bilinear Pooling. In ICLR, 2017.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A Method for Stochastic Optimization. arXiv, 2014.
+
+Ranjay Krishna, Yuke Zhu, Oliver Groth, Justin Johnson, Kenji Hata, Joshua Kravitz, Stephanie Chen, Yannis Kalantidis, Li-Jia Li, David A. Shamma, Michael S. Bernstein, and Fei-Fei Li. Visual Genome: Connecting Language and Vision Using Crowdsourced Dense Image Annotations. International Journal of Computer Vision, 2016.
+
+Victor Lempitsky and Andrew Zisserman. Learning To Count Objects in Images. NIPS, 2010.
+
+Tsung-Yi Lin, Michael Maire, Serge Belongie, Lubomir Bourdev, Ross Girshick, James Hays, Pietro Perona, Deva Ramanan, C. Lawrence Zitnick, and Piotr Dollar. Microsoft COCO: Common ´ Objects in Context. In ECCV, 2014.
+
+Tsung-Yi Lin, Priya Goyal, Ross Girshick, Kaiming He, and Piotr Dollar. Focal Loss for Dense ´ Object Detection. ICCV, 2017.
+
+Jiasen Lu, Caiming Xiong, Devi Parikh, and Richard Socher. Knowing When to Look: Adaptive Attention via A Visual Sentinel for Image Captioning. In CVPR, 2016a.
+
+Jiasen Lu, Jianwei Yang, Dhruv Batra, and Devi Parikh. Hierarchical Question-Image Co-Attention for Visual Question Answering. In NIPS, 2016b.
+
+Yuping Luo, Chung-cheng Chiu, Navdeep Jaitly, and Ilya Sutskever. Learning Online Alignments with Continuous Rewards Policy Gradient. In ICASSP, 2017.
+
+Mateusz Malinowski and Mario Fritz. A Multi-World Approach to Question Answering about RealWorld Scenes based on Uncertain Input. In NIPS, 2014.
+
+Volodymyr Minh, Adria Puigdom \` enech Badia, Mehdi Mirza, Alex Graves, Tim Harley, Timothy\` Lillicrap, David Silver, and Koray Kavukcuoglu. Asynchronous Methods for Deep Reinforcement Learning. In ICML, 2016.
+
+Daniel Onoro-Rubio and Roberto J. L ˜ opez-Sastre. Towards perspective-free object counting with ´ deep learning. In ECCV, 2016.
+
+Dong Huk Park, Lisa Anne Hendricks, Zeynep Akata, Bernt Schiele, Trevor Darrell, and Marcus Rohrbach. Attentive Explanations: Justifying Decisions and Pointing to the Evidence. arXiv, 2016.
+
+Romain Paulus, Caiming Xiong, and Richard Socher. A Deep Reinforced Model for Abstractive Summarization. arXiv, 2017.
+
+Jeffrey Pennington, Richard Socher, and Christopher Manning. Glove: Global Vectors for Word Representation. EMNLP, 2014.
+
+Mengye Ren and Richard S. Zemel. End-to-End Instance Segmentation with Recurrent Attention. In CVPR, 2017.
+
+Mengye Ren, Ryan Kiros, and Richard Zemel. Exploring Models and Data for Image Question Answering. In NIPS, 2015a.
+
+Shaoqing Ren, Kaiming He, Ross Girshick, and Jian Sun. Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks. In NIPS, 2015b.
+
+Steven J. Rennie, Etienne Marcheret, Youssef Mroueh, Jarret Ross, and Vaibhava Goel. Self-critical Sequence Training for Image Captioning. In CVPR, 2017.
+
+Santi Segui, Oriol Pujol, and Jordi Vitria. Learning to count with deep object features. In CVPRW, 2015.
+
+Kevin J. Shih, Saurabh Singh, and Derek Hoiem. Where To Look: Focus Regions for Visual Question Answering. In CVPR, 2015.
+
+Richard Socher, Andrej Karpathy, Quoc V Le, Christopher D Manning, and Andrew $\textsf { Y } \mathrm { N g }$ Grounded Compositional Semantics for Finding and Describing Images with Sentences. In TACL, 2014.
+
+Damien Teney, Lingqiao Liu, and Anton van den Hengel. Graph-Structured Representations for Visual Question Answering. arXiv, 2016.   
+Damien Teney, Peter Anderson, Xiaodong He, and Anton van den Hengel. Tips and Tricks for Visual Question Answering: Learnings from the 2017 Challenge. In CVPR, 2017.   
+Aaron van den Oord, Nal Kalchbrenner, Oriol Vinyals, Lasse Espeholt, Alex Graves, and Koray Kavukcuoglu. Conditional Image Generation with PixelCNN Decoders. In NIPS, 2016.   
+R J Williams. Simple statistical gradient-following methods for connectionist reinforcement learning. Machine Learning, 8:229–256, 1992.   
+Ronald J. Williams and Jing Peng. Function Optimization using Connectionist Reinforcement Learning Algorithms. Connection Science, 3(3):241–268, 1991.   
+Caiming Xiong, Stephen Merity, and Richard Socher. Dynamic Memory Networks for Visual and Textual Question Answering. In ICML, 2016.   
+Huijuan Xu and Kate Saenko. Ask, Attend and Answer: Exploring Question-Guided Spatial Attention for Visual Question Answering. In ECCV, 2015.   
+Zichao Yang, Xiaodong He, Jianfeng Gao, Li Deng, and Alex Smola. Stacked Attention Networks for Image Question Answering. In CVPR, 2015.   
+Cong Zhang, Hongsheng Li, Xiaogang Wang, and Xiaokang Yang. Cross-scene crowd counting via deep convolutional neural networks. In CVPR, 2015.   
+Jianming Zhang, Shugao Ma, Mehrnoosh Sameki, Stan Sclaroff, Margrit Betke, Zhe Lin, Xiaohui Shen, Brian Price, and Radom´ır Mech. Salient Object Subitizing. ˇ International Journal of Computer Vision, 2017.   
+Bolei Zhou, Yuandong Tian, Sainbayar Sukhbaatar, Arthur Szlam, and Rob Fergus. Simple Baseline for Visual Question Answering. arXiv, 2015.   
+Yuke Zhu, Oliver Groth, Michael Bernstein, and Li Fei-Fei. Visual7W: Grounded Question Answering in Images. In CVPR, 2015.
+
+![](images/3317654381e9379c625179dd0473708e03b558c15dd4a60f3e3650bbfa100487.jpg)  
+A EXAMPLES   
+Figure 8: Example outputs produced by each model. For SoftCount, objects are shaded according to the fractional count of each $0 =$ transparent; $1 { = }$ opaque). For UpDown, we similarly shade the objects but use the attention focus to determine opacity. For IRLC, we plot only the boxes from objects that were selected as part of the count.
+
+![](images/d7f5c1fcafb3eeca6c5f2082b1a554c0eada328b7d767e2ceb40338d489c6c9a.jpg)  
+Figure 9: Sequential counting of IRLC. At each timestep, we illustrate the unchosen boxes in pink, and shade each box according to $\kappa ^ { t }$ (corresponding to the probability that the box would be selected at that time step; see main text). We also show the already-selected boxes in blue. For each of the questions, the counting sequence terminates at $t = 3$ , meaning that the returned count $C$ is 3. For each of these questions, that is the correct answer. The example on the far right is a ‘correct failure,’ a case where the correct answer is returned but the counted objects are not related to the question. These kinds of subtle failures are revealed with the grounded counts.
+
+# B TRAINING AND IMPLEMENTATION DETAILS
+
+# B.1 CAPTION GROUNDING
+
+We experiment with jointly training counting and caption grounding. The goal of caption grounding is, given a set of objects and a caption, to identify the object that the caption describes. Identical to the first stages of answering the counting question, we use an LSTM to encode the caption and compare it to each of the objects using the scoring function:
+
+$$
+\begin{array} { l } { { h ^ { t } = \mathrm { L S T M } \left( x ^ { t } , h ^ { t - 1 } \right) } } \\ { { s _ { i } = f ^ { S } \left( \left[ h ^ { T } , v _ { i } \right] \right) } } \end{array}
+$$
+
+where $h \in \mathbb { R } ^ { 1 0 2 4 }$ , $x _ { i } ^ { t } \in \mathbb { R } ^ { 3 0 0 }$ is the embedding for the token at timestep $t$ of the caption, $T$ is the caption length, and $f ^ { S } : \mathbb { R } ^ { m }  \mathbb { R } ^ { n }$ is the scoring function (Sec. 4.3). The embedding of object $i$ is denoted by $v _ { i }$ and the relevance of this object to the caption is encoded by the score vector $s _ { i }$ .
+
+We project each such score vector to a scalar logit $\alpha _ { i }$ and apply a softmax nonlinearity to estimate $\boldsymbol { p } \in \mathbf { \mathbb { R } } ^ { \tilde { N } }$ , where $N$ is the number of object proposals and $p _ { i }$ denotes the probability that the caption describes object proposal $i$ :
+
+$$
+\begin{array} { l } { \alpha _ { i } = W s _ { i } + b } \\ { p = \operatorname { s o f t m a x } \left( \alpha \right) . } \end{array}
+$$
+
+During training, we randomly select four of the images in the batch of examples to use for caption grounding (rather than the full 32 images that make up a batch). To create training data from the region captions in Visual Genome, we assign each caption to one of the detected object proposals. To do so, we compute the intersection over union between the ground truth region that the caption describes and the coordinates of each object proposal. We assign the object proposal with the largest IoU to the caption. If the maximum IoU for the given caption is less than 0.5, we ignore it during training. We compute the grounding probability $p$ for each caption to which we can successfully assign a detection and train using the cross entropy loss averaged over the captions. We weight the loss associated with caption grounding by 0.1 relative to the counting loss.
+
+# B.2 COUNTING MODELS
+
+Each of the considered counting models makes use of the same basic architecture for encoding the question and comparing it with each of the detected objects. For each model, we initialized the word embeddings from GloVe (Pennington et al., 2014) and encoded the question with an LSTM of hidden size 1024. The only differences in the model-specific implementations of the language module was the hidden size of the scoring function $f ^ { S }$ . We determined these specifics from the optimal settings observed during initial experiments. We use a hidden size of 512 for SoftCount and UpDown and a hidden size of 2048 for IRLC. We observed that the former two models were more prone to overfitting, whereas IRLC benefited from the increased capacity.
+
+When training on counting, we optimize using Adam (Kingma & Ba, 2014). For SoftCount and UpDown, we use a learning rate of $3 \mathrm { x } 1 0 ^ { - 4 }$ and decay the learning rate by 0.8 when the training accuracy plateaus. For IRLC, we use a learning rate of $5 \mathrm { x } 1 0 ^ { - 4 }$ and decay the learning rate by 0.99999 every iteration. For all models, we regularize using dropout and apply early stopping based on the development set accuracy (see below).
+
+When training IRLC, we apply the sampling procedure 5 times per question and average the losses. We weight the entropy penalty $P _ { H }$ and interaction penalty $P _ { I }$ (Eq. 10) both by 0.005 relative to the counting loss. These penalty weights yield the best development set accuracy within the hyperparameter search we performed (Fig. 10).
+
+# C ADDITIONAL ANALYSES AND EXPERIMENTS
+
+IRLC auxiliary loss. We performed a grid search to determine the optimal setting for the weights of the auxiliary losses for training IRLC. From our observations, the entropy penalty is important to balance the exploration of the model during training. In addition, the interaction penalty prevents degenerate counting strategies. The results of the grid search suggest that these auxiliary losses improve performance but become unhelpful if given too much weight (Fig. 10). In any case, IRLC outperforms the baseline models across the range of settings explored.
+
+![](images/e485c8ca56415cc03c33f92e851009fc3740f2e90c71827bc0edf11559b48d96.jpg)  
+Figure 10: Results of a hyperparameter sweep over the penalty weights. The accuracy over the development set is reported for each weight setting.
+
+![](images/956077bd0329998beea6c243d33d4871e53571c08b1c9e9aeb9ddaa0d579b1e7.jpg)  
+Figure 11: HowMany-QA test set performance for models trained with the full HowMany-QA training data (blue) and trained without the additional data from Visual Genome (green).
+
+Data augmentation with Visual Genome. Here, we compare performance on the HowManyQA test set for models trained with and without additional data from Visual Genome QA. In all cases, performance benefits from the additional training data (Fig. 11). On average, excluding Visual Genome from the training data decreases accuracy by $2 . 7 \%$ and increases RMSE by 0.12. Interestingly, the performance of IRLC is most robust to the loss of training data.
+
+Ordinality of UpDown output. Whereas the training objectives for SoftCount and IRLC intrinsically reflect the ordinal nature of counts, the same is not true for UpDown. For example, the loss experienced by SoftCount and IRLC reflect the degree of error between the estimated count and the ground truth target; however, UpDown is trained only to place high probability mass on the ground truth value (missing by 1 or by 10 are treated as equally incorrect). We examine the patterns in the output count probabilities from UpDown to ask whether the model learns an ordinal representation despite its non-ordinal training objective. Figure 12 illustrates these trends. When the estimated count is less than 5, the second-most probable count is very frequently adjacent to the most probable count. When the estimated count is larger than 5, the probability distribution is less smooth, such that the second-most probable count is often considerably different than the most probable count. This result suggests that UpDown learns ordinality for lower count values (where training data is abundant) but fails to generalize this concept to larger counts (where training data is more sparse).
+
+![](images/c83c9cf326a316921071e1b3e49aed3326729b5a922b2e42e5b15a753ffae7ac.jpg)  
+Figure 12: (Left) Average count probability (Eq. 15) from UpDown, grouped according to the estimated count. (Right) Cumulative distribution of the absolute difference between the top two predicted counts, shown for when the most likely count was less than 5 (blue) and when it was greater than or equal to 5 (green). The probability distributions are much less smooth when the estimated count is large.
+
+# D EVALUATION METRICS
+
+Accuracy. The VQA dataset includes annotations from ten human reviewers per question. The accuracy of a given answer $a$ depends on how many of the provided answers it agrees with. It is scored as correct if at least 3 humans answers agree:
+
+$$
+\operatorname { \mathrm { \tt ~ A c c } } \left( a \right) = \operatorname* { m i n } \left[ \frac { \# \mathrm { h u m a n s ~ t h a t ~ s a i d } a } { 3 } , 1 \right] .
+$$
+
+Each answer’s accuracy is averaged over each 10-choose-9 set of human answers. As described in the main text, we only consider examples where the consensus answer was in the range of 0-20. We use all ten labels to calculate accuracy, regardless of whether individual labels deviate from this range. Thee accuracy values we report are taken from the average accuracy over some set of examples.
+
+RMSE. This metric simply quantifies the typical deviation between the model count and the groundtruth. Across a set of $N$ , we calculate this metric as
+
+$$
+\mathrm { R M S E } = \sqrt { \frac { 1 } { N } \sum _ { i } ( \hat { C } _ { i } - C _ { i } ) ^ { 2 } } ,
+$$
+
+where $\hat { C } _ { i }$ and $C _ { i }$ are the predicted and ground truth counts, respectively, for question $i$ . RMSE is a measurement of error, so lower is better.
+
+Grounding Quality. We introduce a new evaluation method for quantifying how relevant the objects counted by a model are to the type of object it was asked to count. This evaluation metric takes advantage of the ground truth labels included in the COCO dataset. These labels annotate each object instance of 80 different categories for each of the images in the development set. We make use of GloVe embeddings to compute semantic similarity. We use GloVe $( x ) \ { \stackrel { \cdot } { \in } } \ \mathbb { R } ^ { 3 0 0 }$ to denote the ( $L 2$ normalized) GloVe embedding of category $x$ .
+
+For each image $m$ , the analysis is carried out in two stages.
+
+First, we assign one of the COCO categories (or background) to each of the object proposals used for counting. For each object proposal, we find the object in the COCO labels with the largest IoU. If the IoU is above 0.5, we assign the object proposal to the category of the COCO object, otherwise we assign the object proposal to the background. Below, we use $k _ { i } ^ { m }$ to denote the category assigned to object proposal $i$ for image $m$ .
+
+Second, for each of the COCO categories present in image $m$ , we use the category $q$ (i.e. $q = \ " \mathrm { c a r } \ ' )$ to build a question (i.e. “How many cars are there?”). For SoftCount and IRLC, the count returned in response to this question is the sum of each object proposal’s inferred count value:
+
+$$
+C ^ { ( m , q ) } = \sum _ { i } ^ { N ^ { m } } w _ { i } ^ { ( m , q ) } ,
+$$
+
+where $N ^ { m }$ is the number of object proposals in image $m$ and $w _ { i } ^ { ( m , q ) }$ is the count value given to proposal $i$ . We use the count values to compute a weighted sum of the semantic similarity between the assigned object proposal categories $k$ and the question category $q$ :
+
+$$
+s ^ { ( m , q ) } = \sum _ { i } ^ { N ^ { m } } w _ { i } ^ { ( m , q ) } \left( \mathsf { G l o V e } \left( k _ { i } ^ { m } \right) ^ { T } \mathsf { G l o V e } \left( q \right) \right) ,
+$$
+
+where semantic similarity is estimated from the dot product between the embeddings of the assigned category and the question category. If $k _ { i } ^ { m }$ corresponds to the background category, we replace its embedding with a vector of zeros.
+
+The final metric is computed for each COCO category by accumulating the results over all images that contain a label for that category and normalizing by the net count to get an average:
+
+$$
+s ^ { ( q ) } = \frac { \Sigma _ { m } s ^ { ( m , q ) } } { \Sigma _ { m } C ^ { ( m , q ) } } .
+$$
+
+The interpretation of this metric is straightforward: on average, how relevant are the counted objects to the subject of the question.

parse/train/S1J2ZyZ0Z/S1J2ZyZ0Z_content_list.json

@@ -0,0 +1,2008 @@
+[
+    {
+        "type": "text",
+        "text": "INTERPRETABLE COUNTING FOR VISUAL QUESTION ANSWERING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            821,
+            145
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Alexander Trott, Caiming Xiong∗, & Richard Socher Salesforce Research   \nPalo Alto, CA   \n{atrott,cxiong,rsocher}@salesforce.com ",
+        "bbox": [
+            183,
+            170,
+            550,
+            227
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            262,
+            544,
+            277
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Questions that require counting a variety of objects in images remain a major challenge in visual question answering (VQA). The most common approaches to VQA involve either classifying answers based on fixed length representations of both the image and question or summing fractional counts estimated from each section of the image. In contrast, we treat counting as a sequential decision process and force our model to make discrete choices of what to count. Specifically, the model sequentially selects from detected objects and learns interactions between objects that influence subsequent selections. A distinction of our approach is its intuitive and interpretable output, as discrete counts are automatically grounded in the image. Furthermore, our method outperforms the state of the art architecture for VQA on multiple metrics that evaluate counting. ",
+        "bbox": [
+            233,
+            294,
+            764,
+            446
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            473,
+            336,
+            489
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Visual question answering (VQA) is an important benchmark to test for context-specific reasoning over complex images. While the field has seen substantial progress, counting-based questions have seen the least improvement (Chattopadhyay et al., 2017). Intuitively, counting should involve finding the number of distinct scene elements or objects that meet some criteria, see Fig. 1 for an example. In contrast, the predominant approach to VQA involves representing the visual input with the final feature map of a convolutional neural network (CNN), attending to regions based on an encoding of the question, and classifying the answer from the attention-weighted image features (Xu & Saenko, 2015; Yang et al., 2015; Xiong et al., 2016; Lu et al., 2016b; Fukui et al., 2016; Kim et al., 2017). Our intuition about counting seems at odds with the effects of attention, where a weighted average obscures any notion of distinct elements. As such, we are motivated to re-think the typical approach to counting in VQA and propose a method that embraces the discrete nature of the task. ",
+        "bbox": [
+            174,
+            505,
+            825,
+            657
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Our approach is partly inspired by recent work that represents images as a set of distinct objects, as identified by object detection (Anderson et al., 2017), and making use of the relationships between these objects (Teney et al., 2016). We experiment with counting systems that build off of the vision module used for these two works, which represents each image as a set of detected objects. For training and evaluation, we create a new dataset, HowMany-QA. It is taken from the countingspecific union of VQA 2.0 (Goyal et al., 2017) and Visual Genome QA (Krishna et al., 2016). ",
+        "bbox": [
+            174,
+            665,
+            825,
+            747
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We introduce the Interpretable Reinforcement Learning Counter (IRLC), which treats counting as a sequential decision process. We treat learning to count as learning to enumerate the relevant objects in the scene. As a result, IRLC not only returns a count but also the objects supporting its answer. This output is produced through an iterative method. Each step of this sequence has two stages: First, an object is selected to be added to the count. Second, the model adjusts the priority given to unselected objects based on their configuration with the selected objects (Fig. 1). We supervise only the final count and train the decision process using reinforcement learning (RL). ",
+        "bbox": [
+            174,
+            755,
+            825,
+            853
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Additional experiments highlight the importance of the iterative approach when using this manner of weak supervision. Furthermore, we train the current state of the art model for VQA on HowManyQA and find that IRLC achieves a higher accuracy and lower count error. Lastly, we compare the grounded counts of our model to the attentional focus of the state of the art baseline to demonstrate the interpretability gained through our approach. ",
+        "bbox": [
+            176,
+            859,
+            825,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/c5c9e95ac41429cf8416b9cdb435a7bbb84393ff4f9260f52bb1e7cea6f04f52.jpg",
+        "image_caption": [
+            "Figure 1: IRLC takes as input a counting question and image. Detected objects are added to the returned count through a sequential decision process. The above example illustrates actual model behavior after training. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            102,
+            825,
+            299
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            393,
+            823,
+            421
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            449,
+            344,
+            465
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Visual representations for counting. As a standalone problem, counting from images has received some attention but typically within specific problem domains. Segui et al. (2015) explore training a CNN to count directly from synthetic data. Counts can also be estimated by learning to produce density maps for some category of interest (typically people), as in Lempitsky & Zisserman (2010); Onoro-Rubio & L ˜ opez-Sastre ´ (2016); Zhang et al. (2015). Density estimation simplifies the more challenging approach of counting by instance-by-instance detection (Ren & Zemel, 2017). Methods to detect objects and their bounding boxes have advanced considerably (Girshick et al., 2015; Girshick, 2015; Ren et al., 2015b; Dai et al., 2016; Lin et al., 2017) but tuning redundancy reduction steps in order to count is unreliable (Chattopadhyay et al., 2017). Here, we overcome this limitation by allowing flexible, question specific interactions during counting. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            625
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Alternative approaches attempt to model subitizing, which describes the human ability to quickly and accurately gauge numerosity when at most a few objects are present. Zhang et al. (2017) demonstrates that CNNs may be trained towards a similar ability when estimating the number of salient objects in a scene. This approach was extended to counting 80 classes of objects simultaneously in Chattopadhyay et al. (2017). Their model is trained to estimate counts within each subdivision of the full image, where local counts are typically within the subitizing range. ",
+        "bbox": [
+            174,
+            631,
+            823,
+            715
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The above studies apply counting to a fixed set of object categories. In contrast, we are interested in counting during visual question answering, where the criteria for counting change from question to question and can be arbitrarily complex. This places our work in a different setting than those that count from the image alone. For example, Chattopadhyay et al. (2017) apply their trained models to a subset of VQA questions, but their analysis was limited to the specific subset of examples where the question and answer labels agreed with the object detection labels they use for training. Here, we overcome this limitation by learning to count directly from question/answer pairs. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            819
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Visual question answering. The potential of deep learning to fuse visual and linguistic reasoning has been recognized for some time (Socher et al., 2014; Lu et al., 2016a). Visual question answering poses the challenge of retrieving question-specific information from an associated image, often requiring complex scene understanding and flexible reasoning. In recent years, a number of datasets have been introduced for studying this problem (Malinowski & Fritz, 2014; Ren et al., 2015a; Zhu et al., 2015; Agrawal et al., 2015; Goyal et al., 2017; Krishna et al., 2016). The majority of recent progress has been aimed at the so-named “VQA” datasets (Agrawal et al., 2015; Goyal et al., 2017), where counting questions represent roughly $11 \\%$ of the data. Though our focus is on counting questions specifically, prior work on VQA is highly relevant. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "An early baseline for VQA represents the question and image at a coarse granularity, respectively using a “bag of words” embedding along with spatially-pooled CNN outputs to classify the answer (Zhou et al., 2015). In Ren et al. (2015a), a similar fixed-length image representation is fused with the question embeddings as input to a recurrent neural network (RNN), from which the answer is classified. ",
+        "bbox": [
+            174,
+            138,
+            823,
+            208
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Attention. More recent variants have chosen to represent the image at a finer granularity by omitting the spatial pooling of the CNN feature map and instead use attention to focus relevant image regions before producing an answer (Xu & Saenko, 2015; Yang et al., 2015; Xiong et al., 2016; Lu et al., 2016b; Fukui et al., 2016; Kim et al., 2017). These works use the spatially-tiled feature vectors output by a CNN to represent the image; others follow the intuition that a more meaningful representation may come from parsing the feature map according to the locations of objects in the scene (Shih et al., 2015; Ilievski et al., 2016). Notably, using object detection was a key design choice for the winning submission for the VQA 2017 challenge (Anderson et al., 2017; Teney et al., 2017). Work directed at VQA with synthetic images (which sidesteps the challenges created by computer vision) has further demonstrated the utility that relationships may provide as an additional form of image annotation (Teney et al., 2016). ",
+        "bbox": [
+            174,
+            215,
+            825,
+            368
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Interpretable VQA. The use of “scene graphs” in real-image VQA would have the desirable property that intermediate model variables would be grounded in concepts explicitly, a step towards making neural reasoning more transparent. A conceptual parallel to this is found in Neural Module Networks (Andreas et al., 2016a;b; Hu et al., 2017), which gain interpretability by grounding the reasoning process itself in defined concepts. The general concept of interpretable VQA has been the subject of recent interest. Park et al. (2016) extends the task itself to include generating explanations for produced answers. Chandrasekaran et al. (2017) take a different approach, asking how well humans can learn patterns in answers and failures of a trained VQA model. While humans indeed identify some patterns, they do not gain any apparent insight from knowing intermediate states of the model (such as its attentional focus). In light of this, we are motivated by the goal of developing more transparent AI. ",
+        "bbox": [
+            174,
+            375,
+            825,
+            527
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We address this at the level of counting in VQA. We show that, despite the challenge presented by this particular task, an intuitive approach gains in both performance and interpretability over state of the art. ",
+        "bbox": [
+            176,
+            535,
+            825,
+            577
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            599,
+            292,
+            616
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Within the field of VQA, the majority of progress has been aimed at the VQA dataset (Agrawal et al., 2015) and, more recently, VQA 2.0 (Goyal et al., 2017), which expands the total number of questions in the dataset and attempts to reduce bias by balancing answers to repeated questions. VQA 2.0 consists of 1.1M questions pertaining to the 205K images from COCO (Lin et al., 2014). The examples are divided according to the official COCO splits. ",
+        "bbox": [
+            174,
+            632,
+            825,
+            703
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In addition to VQA 2.0, we incorporate the Visual Genome (VG) dataset (Krishna et al., 2016). Visual Genome consists of 108K images, roughly half of which are part of COCO. VG includes its own visual question answering dataset. We include examples from that dataset when they pertain to an image in the VQA 2.0 training set. ",
+        "bbox": [
+            176,
+            710,
+            823,
+            766
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 HOWMANY-QA ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            785,
+            325,
+            799
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In order to evaluate counting specifically, we define a subset of the QA pairs, which we refer to as HowMany-QA. Our inclusion criteria were designed to filter QA pairs where the question asks for a count, as opposed to simply an answer in the form of a number (Fig 2). For the first condition, we require that the question contains one of the following phrases: “how many”, “number of”, “amount of”, or “count of”. We also reject a question if it contains the phrase “number of the”, since this phrase frequently refers to a printed number rather than a count (i.e. “what is the number of the bus?”). Lastly, we require that the ground-truth answer is a number between 0 to 20 (inclusive). The original VQA 2.0 train set includes roughly 444K QA pairs, of which 57,606 are labeled as having a “number” answer. Focusing on counting questions results in a still very large dataset with 47,542 pairs, showing the importance of this subtask. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/668b7443547a18002b177a3df0279a6acb148c7c828c7408873ca9b1f71c9dbd.jpg",
+        "image_caption": [
+            "Figure 2: Examples of question-answer pairs that are excluded from HowMany-QA. This selection exemplifies the common types of “number” questions that do not require counting and therefore distract from our objective: (from left to right) time, general number-based answers, ballparking, and reading numbers from images. Importantly, the standard VQA evaluation metrics do not distinguish these from counting questions; instead, performance is reported for “number” questions as a whole. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            98,
+            818,
+            251
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            375,
+            825,
+            402
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Due to our filter and focus on counting questions, we cannot make use of the official test data since its annotations are not available. Hence, we divide the validation data into separate development and test sets. More specifically, we apply the above criteria to the official validation data and select 5,000 of the resulting QA pairs to serve as the test data. The remaining 17,714 QA pairs are used as the development set. ",
+        "bbox": [
+            174,
+            410,
+            483,
+            547
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As mentioned above, the HowMany-QA training data is augmented with available QA pairs ",
+        "bbox": [
+            174,
+            556,
+            485,
+            584
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/2003884b3d5294166d343ad5303ac37ca4e748b5c5bef55684a11a0fef0f8727.jpg",
+        "table_caption": [
+            "Table 1: Size breakdown of HowMany-QA. Neither development or test included VG data. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Split</td><td>QA Pairs</td><td>Images</td></tr><tr><td>Train</td><td>83,642</td><td>31,932</td></tr><tr><td>from VQA 2.0</td><td>47,542</td><td>31,932</td></tr><tr><td> from VG</td><td>36,100</td><td>0</td></tr><tr><td>Dev.</td><td>17,714</td><td>13,119</td></tr><tr><td>Test</td><td>5,000</td><td>2,483</td></tr></table>",
+        "bbox": [
+            519,
+            419,
+            797,
+            535
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "from Visual Genome, which are selected using the same criteria. A breakdown of the size and composition of HowMany-QA is provided in Table 1. All models compared in this work are trained and evaluated on HowMany-QA. To facilitate future comparison to our work, we have made the training, development, and test question IDs available for download. ",
+        "bbox": [
+            174,
+            584,
+            825,
+            638
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            660,
+            267,
+            676
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this work, we focus specifically on counting in the setting of visual question answering (where the criteria for counting changes on a question-by-question basis). In addition, we are interested in model interpretability. We explore this notion by experimenting with models that are capable of producing question-guided counts which are visually grounded in object proposals. ",
+        "bbox": [
+            174,
+            691,
+            825,
+            747
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Rather than substantially modifying existing counting approaches – such as Chattopadhyay et al. (2017) – we compare three models whose architectures naturally fit within our experimental scope. These models each produce a count from the outputs of an object detection module and use identical strategies to encode the question and compare it to the detected objects. The models differ only in terms of how these components are used to produce a count (Fig. 3a). ",
+        "bbox": [
+            174,
+            755,
+            825,
+            824
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 OBJECT DETECTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            842,
+            356,
+            856
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our approach is inspired by the strategy of Anderson et al. (2017) and Teney et al. (2017). Their model, which represents current state of the art in VQA, infers objects as the input to the questionanswering system. This inference is performed using the Faster R-CNN architecture (Ren et al., 2015b). The Faster R-CNN proposes a set of regions corresponding to objects in the image. It encodes the image as a set of bounding boxes $\\left\\{ b _ { 1 } , . . . , b _ { N } \\right\\}$ , $b _ { i } \\in \\mathbb { R } ^ { 4 }$ and complementary set of object encodings $\\left\\{ v _ { 1 } , \\dotsc , v _ { N } \\right\\}$ , $v _ { i } \\in \\mathbb { R } ^ { 2 0 4 8 }$ , corresponding to the locations and feature representations of each of the $N$ detected objects, respectively (blue box in Fig. 3a). ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/2c5f371f62f7d35a6e0c81827a861b0cbd7733b1b7722346ef5e1d2947d80ced.jpg",
+        "image_caption": [
+            "Figure 3: (a) Each model includes three basic modules: vision (blue), language (green), and counting (red). Text in the shaded regions describes which aspects of these modules are shared across models. (b) (left) The language model embeds the question and compares it to each object using a scoring function, which is jointly trained with caption grounding; (right) IRLC counting module. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            104,
+            825,
+            297
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            401,
+            825,
+            444
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Rather than train our own vision module from scratch, we make use of the publicly available object proposals learned in Anderson et al. (2017). These provide rich, object-centric representations for each image in our dataset. These representations are fixed when learning to count and are shared across each of the QA models we experiment with. ",
+        "bbox": [
+            174,
+            450,
+            825,
+            507
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 LANGUAGE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            526,
+            294,
+            540
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Each architecture encodes the question and compares it to each detected object via a scoring function. We define $q$ as the final hidden state of an LSTM (Hochreiter & Schmidhuber, 1997) after processing the question and compute a score vector for each object (Fig. 3, green boxes): ",
+        "bbox": [
+            176,
+            551,
+            823,
+            594
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e5097027f567ed250e13657efb8d2e84a9b4e3d6214460ce59412981aa2e602a.jpg",
+        "text": "$$\n\\begin{array} { r l } { h ^ { t } = \\mathrm { L S T M } \\left( x ^ { t } , h ^ { t - 1 } \\right) \\quad } & { { } q = h ^ { T } } \\\\ { s _ { i } = f ^ { S } \\left( [ q , v _ { i } ] \\right) \\quad } & { { } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            599,
+            611,
+            643
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here, $x _ { t }$ denotes the word embedding of the question token at position $t$ and $s _ { i } \\in \\mathbb { R } ^ { n }$ denotes the score vector encoding the relevance of object $i$ to the question. Following Anderson et al. (2017), we implement the scoring function $f ^ { S } : \\bar { \\mathbb { R } ^ { m } }  \\mathbb { R } ^ { n }$ as a layer of Gated Tanh Units (GTU) (van den Oord et al., 2016). $[ , ]$ denotes vector concatenation. ",
+        "bbox": [
+            174,
+            648,
+            825,
+            704
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We experiment with jointly training the scoring function to perform caption grounding, which we supervise using region captions from Visual Genome. Region captions provide linguistic descriptions of localized regions within the image, and the goal of caption grounding is to identify which object a given caption describes (details provided in Section B.1 of the Appendix). Caption grounding uses a strategy identical to that for question answering (Eqs. 1 and 2): an LSTM is used to encode each caption and the scoring function $f ^ { S }$ is used to encode its relevance to each detected object. The weights of the scoring function are tied for counting and caption grounding (Fig. 3b). We include results from experiments where caption grounding is ignored. ",
+        "bbox": [
+            174,
+            710,
+            825,
+            823
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.3 COUNTING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            840,
+            290,
+            856
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Interpretable RL Counter (IRLC). For our proposed model, we aim to learn how to count by learning what to count. We assume that each counting question implicitly refers to a subset of the objects within a scene that meet some variable criteria. In this sense, the goal of our model is to enumerate that subset of objects. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/38515b73a92b92a456cb7bba1b7325872b69b3aabf00f2fea83d573919a8d087.jpg",
+        "image_caption": [
+            "Figure 4: Grounded counts produced by IRLC. Counts are formed from selections of detected objects. Each image displays the objects that IRLC chose to count. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            94,
+            816,
+            236
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To implement this as a sequential decision process, we need to represent the probability of selecting a given action and how each action affects subsequent choices. To that end, we project the object scores $s \\in \\mathbb { R } ^ { N \\times n }$ to a vector of logits $\\boldsymbol { \\kappa } \\in \\mathbb { R } ^ { N }$ , representing how likely each object is to be counted, where $N$ is the number of detected objects: ",
+        "bbox": [
+            173,
+            314,
+            825,
+            371
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/60e134d3f6bf1275c2fc5ba02a0f2f2f9749f750c08d6681b6e2a9f60e9526f4.jpg",
+        "text": "$$\n\\kappa = W s + b\n$$",
+        "text_format": "latex",
+        "bbox": [
+            455,
+            377,
+            544,
+            391
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "And we compute a matrix of interaction terms $\\boldsymbol { \\rho } \\in \\mathbb { R } ^ { N \\times N }$ that are used to update the logits $\\kappa$ . The value $\\rho _ { i j }$ represents how selecting object $i$ will change $\\kappa _ { j }$ . We calculate this interaction from a compressed representation of the question $( W q )$ , the dot product of the normalized object vectors $( \\hat { v } _ { i } ^ { \\mathrm { T } } \\bar { \\hat { v } } _ { j } )$ , the object coordinates $b _ { i }$ and $b _ { j }$ ), and basic overlap statistics $( \\mathrm { I o U } _ { i j }$ , $\\mathrm { O } _ { i j }$ , and ${ \\mathrm { O } } _ { j i }$ ): ",
+        "bbox": [
+            173,
+            397,
+            825,
+            455
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d1d7010a70d8b70952590348c078d10966e48b2562c3307a5e854299f8fec46d.jpg",
+        "text": "$$\n\\rho _ { i j } = f ^ { \\rho } \\left( \\left[ W q , \\hat { v } _ { i } ^ { \\mathrm { T } } \\hat { v } _ { j } , b _ { i } , b _ { j } , \\mathrm { I o U } _ { i j } , \\mathrm { O } _ { i j } , \\mathrm { O } _ { j i } \\right] \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            460,
+            651,
+            481
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $f ^ { \\rho } : x \\in \\mathbb { R } ^ { m } \\Rightarrow \\mathbb { R }$ is a 2-layer MLP with ReLU activations. ",
+        "bbox": [
+            174,
+            484,
+            609,
+            500
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For each step $t$ of the counting sequence we greedily select the action with the highest value (interpreted as either selecting the next object to count or terminating), and update $\\kappa$ accordingly: ",
+        "bbox": [
+            173,
+            506,
+            820,
+            535
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0ded066fd962ee6bf7367cd5ac79f365dc3d55259a19204354d0be1ff3f38095.jpg",
+        "text": "$$\n\\begin{array} { r } { a ^ { t } = \\operatorname { a r g m a x } _ { i } \\left[ \\kappa ^ { t } , \\zeta \\right] } \\\\ { \\kappa ^ { t + 1 } = \\kappa ^ { t } + \\rho ( a ^ { t } , \\cdot ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            539,
+            555,
+            580
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\zeta$ is a learnable scalar representing the logit value of the terminal action, and $\\kappa ^ { 0 }$ is the result of Equation 3 (Fig. 3b, red box). The action $a ^ { t }$ is expressed as the index of the selected object. $\\rho ( \\boldsymbol a ^ { t } , \\cdot )$ denotes the row of $\\rho$ indexed by $a ^ { t }$ . Each object is only allowed to be counted once. We define the count $C$ as the timestep when the terminal action was selected $t : a ^ { t } = N + 1$ . ",
+        "bbox": [
+            174,
+            583,
+            825,
+            640
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This approach bears some similarity to Non-Maximal Suppression (NMS), a staple technique in object detection to suppress redundant proposals. However, our approach is far less rigid and allows the question to determine how similar and/or overlapping objects interact. ",
+        "bbox": [
+            174,
+            646,
+            825,
+            689
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Training IRLC. Because the process of generating a count requires making discrete decisions, training requires that we use techniques from Reinforcement Learning. Given our formulation, a natural choice is to apply REINFORCE (Williams, 1992). To do so, we calculate a distribution over action probabilities $p ^ { t }$ from $\\kappa ^ { t }$ and generate a count by iteratively sampling actions from the distribution: ",
+        "bbox": [
+            173,
+            695,
+            825,
+            765
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/364924c5b764cdf2d1becaa7f297534a49bf253ca083c5720a0a2d7c07da1fcd.jpg",
+        "text": "$$\n\\begin{array} { l c r } { { p ^ { t } = \\mathrm { s o f t m a x } \\left( \\left[ \\kappa ^ { t } , \\zeta \\right] \\right) } } & { { ~ a ^ { t } \\sim p ^ { t } } } \\\\ { { \\kappa ^ { t + 1 } = \\kappa ^ { t } + \\rho ( a ^ { t } , \\cdot ) } } & { { } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            768,
+            612,
+            810
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We calculate the reward using Self-Critical Sequence training (Rennie et al., 2017; Anderson et al., 2017; Paulus et al., 2017), a variation of policy gradient. We define $E = | C - C ^ { \\mathrm { G T } } |$ to be the count error and define the reward as $R = E ^ { \\mathrm { g r e e d y } } - E$ , where $E ^ { \\mathrm { g r e e d y } }$ is the baseline count error obtained by greedy action selection (which is also how the count is measured at test time). From this, we define our (unnormalized) counting loss as ",
+        "bbox": [
+            173,
+            813,
+            825,
+            883
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d51282e249ca26a1d66f1f7c26010362b24c6fbd68e66a1f93e24444d254867e.jpg",
+        "text": "$$\n\\tilde { L } _ { C } = - R \\sum _ { t } \\log p ^ { t } \\left( a ^ { t } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            411,
+            888,
+            584,
+            921
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Additionally, we include two auxiliary objectives to aid learning. For each sampled sequence, we measure the total negative policy entropy $H$ across the observed time steps. We also measure the average interaction strength at each time step and collect the total ",
+        "bbox": [
+            174,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/30e7d528ec206e7a3d43314345bc41181ff079593ba0a2ad2812bb6b8d4b60b4.jpg",
+        "text": "$$\n\\tilde { P } _ { \\mathrm { H } } = - \\sum _ { t } H \\left( p ^ { t } \\right) \\qquad \\tilde { P } _ { \\mathrm { I } } = \\sum _ { i \\in \\{ a ^ { 0 } . . . a ^ { t } \\} } \\frac { 1 } { N } \\sum _ { j } L _ { 1 } \\left( \\rho _ { i j } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            151,
+            687,
+            190
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $L _ { 1 }$ is the Huber loss from Eq 12. Including the entropy objective is a common strategy when using policy gradient (Williams & Peng, 1991; Minh et al., 2016; Luo et al., 2017) and is used to improve exploration. The interaction penalty is motivated by the a priori expectation that interactions should be sparse. During training, we minimize a weighted sum of the three losses, normalized by the number of decision steps. As before, we provide training and implementation details in the Appendix (Sec. B.2). ",
+        "bbox": [
+            174,
+            195,
+            825,
+            280
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "SoftCount. As a baseline approach, we train a model to count directly from the outputs $s$ of the scoring function. For each object, we project its score vector $s _ { i }$ to a scalar value and apply a sigmoid nonlinearity, denoted as $\\sigma$ , to assign the object a count value between 0 and 1. The total count is the sum of these fractional, object-specific count values. We train this model by minimizing the Huber loss associated with the absolute difference $e$ between the predicted count $C$ and the ground truth count CGT: ",
+        "bbox": [
+            173,
+            286,
+            825,
+            369
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/71eb5992ade3750386cc11d206b8aa2ef049327c80deb673b14210eabdd28068.jpg",
+        "text": "$$\n\\begin{array} { l } { { C = \\displaystyle \\sum _ { i } \\sigma \\left( W s _ { i } \\right) } } \\\\ { { \\ } } \\\\ { { L _ { 1 } = \\left\\{ \\begin{array} { l l } { { 0 . 5 e ^ { 2 } } } & { { \\mathrm { i f } e \\leq 1 } } \\\\ { { e - 0 . 5 } } & { { \\mathrm { o t h e r w i s e } } } \\end{array} \\right. \\ } } & { { e = \\left| C - C ^ { \\mathrm { G T } } \\right| } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            371,
+            663,
+            444
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For evaluation, we round the estimated count $C$ to the nearest integer and limit the output to the maximum ground truth count (in this case, 20). ",
+        "bbox": [
+            174,
+            448,
+            825,
+            477
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Attention Baseline (UpDown). As a second baseline, we re-implement the QA architecture introduced in Anderson et al. (2017), which the authors refer to as UpDown – see also Teney et al. (2017) for additional details. We focus on this architecture for three main reasons. First, it represents the current state of the art for VQA 2.0. Second, it was designed to use the visual representations we employ. And, third, it exemplifies the common two-stage approach of (1) deploying question-based attention over image regions (here, detected objects) to get a fixed-length visual representation ",
+        "bbox": [
+            173,
+            483,
+            825,
+            568
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/eb2658e41f2ec1f79b8c38e6a4db7e8ddd9068dcc487e7041c0afa76a86c70aa.jpg",
+        "text": "$$\n\\alpha = \\mathrm { s o f t m a x } \\left( W s \\right) ; \\quad \\hat { v } = \\sum \\alpha _ { i } v _ { i }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            573,
+            620,
+            597
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "and then (2) classifying the answer based on this average and the question encoding ",
+        "bbox": [
+            173,
+            602,
+            720,
+            617
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a31511d115909ba5536f14d3c56c3a51f191b30c0d116fb54de3705148319388.jpg",
+        "text": "$$\n\\begin{array} { r } { v ^ { \\prime } = f ^ { V } \\left( \\hat { v } \\right) ; \\quad q ^ { \\prime } = f ^ { Q } \\left( q \\right) } \\\\ { p = \\mathrm { s o f t m a x } \\left( f ^ { C } \\left( v ^ { \\prime } \\otimes q ^ { \\prime } \\right) \\right) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            403,
+            621,
+            594,
+            664
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $s \\in \\mathbb { R } ^ { N \\times n }$ denotes the matrix of score vectors for each of the $N$ detected objects and $\\boldsymbol { \\alpha } \\in \\mathbb { R } ^ { N }$ denotes the attention weights. Here, each function $f$ is implemented as a GTU layer and $\\otimes$ denotes element-wise multiplication. For training, we use a cross entropy loss, with the target given by the ground-truth count. At test time, we use the most probable count given by $p$ . ",
+        "bbox": [
+            174,
+            667,
+            825,
+            726
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            744,
+            282,
+            761
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 COUNTING PERFORMANCE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            776,
+            403,
+            791
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We use two metrics for evaluation. For consistency with past work, we report the standard VQA test metric of accuracy. Since accuracy does not measure the degree of error we also report root-meansquared-error (RMSE), which captures the typical deviation between the estimated and ground-truth count and emphasizes extreme errors. Details are provided in the Appendix (Sec. D). ",
+        "bbox": [
+            173,
+            801,
+            825,
+            858
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To better understand the performance of the above models, we also report the performance of two non-visual baselines. The first baseline (Guess1) shows the performance when the estimated count is always 1 (the most common answer in the training set). The second baseline (LSTM) learns to predict the count directly from a linear projection of the question embedding $q$ (Eq. 1). ",
+        "bbox": [
+            174,
+            864,
+            823,
+            921
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/b3993a0fdceb6a5a7390b9fb11e39582f5a0a5c636da4ce7445c783758825216.jpg",
+        "image_caption": [
+            "Figure 5: Model performance on the HowMany-QA development set, grouped according to the frequency with which the counting subject appeared in the training data. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            85,
+            820,
+            224
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "IRLC achieves the highest overall accuracy and (with SoftCount) the lowest overall RMSE on the test set (Table 2). Interestingly, SoftCount clearly lags in accuracy but is competitive in RMSE, arguing that accuracy and RMSE are not redundant. We observe this to result from the fact that IRLC is less prone to small errors and very slightly more prone to large errors (which disproportionately impact RMSE). However, whereas UpDown improves in accuracy at the cost of RMSE, IRLC is substantially more accurate without sacrificing overall RMSE. ",
+        "bbox": [
+            174,
+            313,
+            516,
+            478
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/1f52e29a5e2bbae78eb6313bbe383638f8800fafa6190c784b0c489d4daadaae.jpg",
+        "table_caption": [
+            "Table 2: HowMany-QA test set performance. Values in parentheses apply to models trained without caption grounding. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td> Accuracy</td><td>RMSE</td></tr><tr><td>Guess1</td><td>33.8</td><td>3.74</td></tr><tr><td>LSTM</td><td>36.8</td><td>3.47</td></tr><tr><td>SoftCount</td><td>50.2 (49.2)</td><td>2.37 (2.45)</td></tr><tr><td>UpDown</td><td>52.7 (51.5)</td><td>2.64 (2.69)</td></tr><tr><td>IRLC</td><td>57.7 (56.1)</td><td>2.37 (2.45)</td></tr></table>",
+        "bbox": [
+            537,
+            314,
+            812,
+            420
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To gain more insight into the performance of these models, we calculate these metrics within the development set after separating the data according to how common the subject of the count is during training1. We break up the questions into 5 roughly equal-sized bins representing increasingly uncommon subjects. We include a 6th bin for subjects never seen during training. The accuracy and RMSE across the development set are reported for each of these bins in Figure 5. ",
+        "bbox": [
+            174,
+            486,
+            825,
+            556
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Organizing the data this way reveals two main trends. First, all models perform better when asked to count subjects that were common during training. Second, the performance improvements offered by IRLC over UpDown persist over all groupings of the development data. ",
+        "bbox": [
+            174,
+            563,
+            823,
+            604
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 GROUNDING QUALITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            633,
+            370,
+            647
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We introduce a novel analysis to quantify how well counted objects match the subject of the question. To perform this analysis, we form generic questions that refer to the object categories in the COCO object detection dataset. We take the object proposals counted in response to a given question and compare them to the ground truth COCO labels to determine how relevant the counted object proposals are. Our metric takes on a value of 1 when the counted objects perfectly map onto the category to which the question refers. Values around 0 indicate that the counted objects were not relevant to the question. Section D of the Appendix details how the grounding quality metric is calculated. ",
+        "bbox": [
+            174,
+            665,
+            825,
+            775
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We perform this analysis for each of the 80 COCO categories using the images in the HowMany-QA development set. Figure 6 compares the grounding quality of SoftCount and IRLC, where each point represents the average grounding quality for a particular COCO category. As with the previous two metrics, grounding quality is highest for COCO categories that are more common during training. We observe that IRLC consistently grounds its counts in objects that are more relevant to the question than does SoftCount. A paired t-test shows that this trend is statistically significant $( p < 1 0 ^ { \\frac { \\cdot } { - 1 5 } }$ ). ",
+        "bbox": [
+            174,
+            782,
+            825,
+            866
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/aac1bc41d15a6b233520ec746286c1de24c89f12695398f9e5b94ddc90fcbdb9.jpg",
+        "image_caption": [
+            "Figure 6: (Left) Average grounding quality for each of the COCO object categories, as measured for SoftCount and IRLC. Each point represents a COCO category and is colored according to how common the category was during training (as in Figure 5). (Right) Histogram showing the difference in grounding quality between IRLC and SoftCount. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            84,
+            789,
+            291
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/b5b11846760f40370474dccf1f9bb6284b472b4081139758787c42427419aefd.jpg",
+        "image_caption": [
+            "Figure 7: Examples of failure cases with common and rare subjects (“people” and “ties,” respectively). Each example shows the output of IRLC, where boxes correspond to counted objects, and the output of UpDown, where boxes are shaded according to their attention weights. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            383,
+            816,
+            556
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.3 QUALITATIVE ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            647,
+            385,
+            661
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The design of IRLC is inspired by the ideal of interpretable VQA (Chandrasekaran et al., 2017). One hallmark of interpretability is the ability to predict failure modes. We argue that this is made more approachable by requiring IRLC to identify the objects in the scene that it chooses to count. ",
+        "bbox": [
+            176,
+            679,
+            823,
+            722
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Figure 7 illustrates two failure cases that exemplify observed trends in IRLC. In particular, IRLC has little trouble counting people (they are the most common subject) but encounters difficulty with referring phrases (in this case, “sitting on the bench”). When asked to count ties (a rare subject), IRLC includes a sleeve in the output, demonstrating the tendency to misidentify objects with few training examples. These failures are obvious by virtue of the grounded counts, which point out exactly which objects IRLC counted. In comparison, the attention focus of UpDown (representing the closest analogy to a grounded output) does not identify any pattern. From the attention weights, it is unclear which scene elements form the basis of the returned count. ",
+        "bbox": [
+            173,
+            728,
+            825,
+            839
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Indeed, the two models may share similar deficits. We observe that, in many cases, they produce similar counts. However, we stress that without IRLC and the chance to observe such similarities such deficits of the UpDown model would be difficult to identify. ",
+        "bbox": [
+            174,
+            847,
+            825,
+            888
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The Appendix includes further visualizations and comparisons of model output, including examples of how IRLC uses the iterative decision process to produce discrete, grounded counts (Sec. A). ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            318,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We present an interpretable approach to counting in visual question answering, based on learning to enumerate objects in a scene. By using RL, we are able to train our model to make binary decisions about whether a detected object contributes to the final count. We experiment with two additional baselines and control for variations due to visual representations and for the mechanism of visuallinguistic comparison. Our approach achieves state of the art for each of the evaluation metrics. In addition, our model identifies the objects that contribute to each count. These groundings provide traction for identifying the aspects of the task that the model has failed to learn and thereby improve not only performance but also interpretability. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            246
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            267,
+            285,
+            282
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aishwarya Agrawal, Jiasen Lu, Stanislaw Antol, Margaret Mitchell, C. Lawrence Zitnick, Devi Parikh, and Dhruv Batra. VQA: Visual Question Answering. International Journal of Computer Vision, 2015. ",
+        "bbox": [
+            174,
+            291,
+            823,
+            333
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Peter Anderson, Xiaodong He, Chris Buehler, Damien Teney, Mark Johnson, Stephen Gould, and Lei Zhang. Bottom-Up and Top-Down Attention for Image Captioning and VQA. arXiv, 2017. ",
+        "bbox": [
+            173,
+            343,
+            825,
+            373
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jacob Andreas, Marcus Rohrbach, Trevor Darrell, and Dan Klein. Neural module networks. In CVPR, 2016a. ",
+        "bbox": [
+            173,
+            382,
+            823,
+            412
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jacob Andreas, Marcus Rohrbach, Trevor Darrell, and Dan Klein. Learning to Compose Neural Networks for Question Answering. In NAACL, 2016b. ",
+        "bbox": [
+            173,
+            422,
+            823,
+            452
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Arjun Chandrasekaran, Deshraj Yadav, Prithvijit Chattopadhyay, Viraj Prabhu, and Devi Parikh. It Takes Two to Tango: Towards Theory of AI’s Mind. arXiv, 2017. ",
+        "bbox": [
+            173,
+            462,
+            825,
+            491
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Prithvijit Chattopadhyay, Ramakrishna Vedantam, Ramprasaath R. Selvaraju, Dhruv Batra, and Devi Parikh. Counting Everyday Objects in Everyday Scenes. In CVPR, 2017. ",
+        "bbox": [
+            171,
+            501,
+            823,
+            531
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jifeng Dai, Yi Li, Kaiming He, and Jian Sun. R-FCN: Object Detection via Region-based Fully Convolutional Networks. In NIPS, 2016. ",
+        "bbox": [
+            169,
+            540,
+            823,
+            570
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Akira Fukui, Dong Huk Park, Daylen Yang, Anna Rohrbach, Trevor Darrell, and Marcus Rohrbach. Multimodal compact bilinear pooling for visual question answering and visual grounding. In EMNLP, 2016. ",
+        "bbox": [
+            174,
+            580,
+            823,
+            622
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ross Girshick. Fast R-CNN. In ICCV, 2015. ",
+        "bbox": [
+            173,
+            633,
+            467,
+            648
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ross Girshick, Jeff Donahue, Trevor Darrell, and Jitendra Malik. Rich feature hierarchies for accurate object detection and semantic segmentation. In CVPR, 2015. ",
+        "bbox": [
+            171,
+            659,
+            820,
+            688
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yash Goyal, Tejas Khot, Douglas Summers-Stay, Dhruv Batra, and Devi Parikh. Making the V in VQA Matter: Elevating the Role of Image Understanding in Visual Question Answering. In CVPR, 2017. ",
+        "bbox": [
+            173,
+            698,
+            823,
+            741
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long Short-Term Memory. ¨ Neural Computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            169,
+            751,
+            823,
+            780
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ronghang Hu, Jacob Andreas, Marcus Rohrbach, Trevor Darrell, and Kate Saenko. Learning to Reason: End-to-End Module Networks for Visual Question Answering. In ICCV, 2017. ",
+        "bbox": [
+            173,
+            790,
+            823,
+            820
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ilija Ilievski, Shuicheng Yan, and Jiashi Feng. A Focused Dynamic Attention Model for Visual Question Answering. arXiv, 2016. ",
+        "bbox": [
+            173,
+            829,
+            823,
+            859
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jin-Hwa Kim, Kyoung-Woon On, Woosang Lim, Jeonghee Kim, Jung-Woo Ha, and Byoung-Tak Zhang. Hadamard Product for Low-rank Bilinear Pooling. In ICLR, 2017. ",
+        "bbox": [
+            174,
+            869,
+            820,
+            898
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma and Jimmy Ba. Adam: A Method for Stochastic Optimization. arXiv, 2014. ",
+        "bbox": [
+            173,
+            909,
+            803,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ranjay Krishna, Yuke Zhu, Oliver Groth, Justin Johnson, Kenji Hata, Joshua Kravitz, Stephanie Chen, Yannis Kalantidis, Li-Jia Li, David A. Shamma, Michael S. Bernstein, and Fei-Fei Li. Visual Genome: Connecting Language and Vision Using Crowdsourced Dense Image Annotations. International Journal of Computer Vision, 2016. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Victor Lempitsky and Andrew Zisserman. Learning To Count Objects in Images. NIPS, 2010. ",
+        "bbox": [
+            173,
+            169,
+            790,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Michael Maire, Serge Belongie, Lubomir Bourdev, Ross Girshick, James Hays, Pietro Perona, Deva Ramanan, C. Lawrence Zitnick, and Piotr Dollar. Microsoft COCO: Common ´ Objects in Context. In ECCV, 2014. ",
+        "bbox": [
+            176,
+            193,
+            823,
+            236
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Priya Goyal, Ross Girshick, Kaiming He, and Piotr Dollar. Focal Loss for Dense ´ Object Detection. ICCV, 2017. ",
+        "bbox": [
+            173,
+            244,
+            823,
+            273
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jiasen Lu, Caiming Xiong, Devi Parikh, and Richard Socher. Knowing When to Look: Adaptive Attention via A Visual Sentinel for Image Captioning. In CVPR, 2016a. ",
+        "bbox": [
+            173,
+            284,
+            821,
+            313
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jiasen Lu, Jianwei Yang, Dhruv Batra, and Devi Parikh. Hierarchical Question-Image Co-Attention for Visual Question Answering. In NIPS, 2016b. ",
+        "bbox": [
+            173,
+            320,
+            823,
+            349
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yuping Luo, Chung-cheng Chiu, Navdeep Jaitly, and Ilya Sutskever. Learning Online Alignments with Continuous Rewards Policy Gradient. In ICASSP, 2017. ",
+        "bbox": [
+            174,
+            359,
+            823,
+            388
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mateusz Malinowski and Mario Fritz. A Multi-World Approach to Question Answering about RealWorld Scenes based on Uncertain Input. In NIPS, 2014. ",
+        "bbox": [
+            173,
+            397,
+            823,
+            426
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Minh, Adria Puigdom \\` enech Badia, Mehdi Mirza, Alex Graves, Tim Harley, Timothy\\` Lillicrap, David Silver, and Koray Kavukcuoglu. Asynchronous Methods for Deep Reinforcement Learning. In ICML, 2016. ",
+        "bbox": [
+            178,
+            434,
+            823,
+            478
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daniel Onoro-Rubio and Roberto J. L ˜ opez-Sastre. Towards perspective-free object counting with ´ deep learning. In ECCV, 2016. ",
+        "bbox": [
+            173,
+            487,
+            823,
+            516
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dong Huk Park, Lisa Anne Hendricks, Zeynep Akata, Bernt Schiele, Trevor Darrell, and Marcus Rohrbach. Attentive Explanations: Justifying Decisions and Pointing to the Evidence. arXiv, 2016. ",
+        "bbox": [
+            174,
+            525,
+            821,
+            568
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Romain Paulus, Caiming Xiong, and Richard Socher. A Deep Reinforced Model for Abstractive Summarization. arXiv, 2017. ",
+        "bbox": [
+            173,
+            577,
+            823,
+            606
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jeffrey Pennington, Richard Socher, and Christopher Manning. Glove: Global Vectors for Word Representation. EMNLP, 2014. ",
+        "bbox": [
+            171,
+            614,
+            823,
+            643
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mengye Ren and Richard S. Zemel. End-to-End Instance Segmentation with Recurrent Attention. In CVPR, 2017. ",
+        "bbox": [
+            171,
+            652,
+            823,
+            683
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mengye Ren, Ryan Kiros, and Richard Zemel. Exploring Models and Data for Image Question Answering. In NIPS, 2015a. ",
+        "bbox": [
+            173,
+            690,
+            823,
+            719
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shaoqing Ren, Kaiming He, Ross Girshick, and Jian Sun. Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks. In NIPS, 2015b. ",
+        "bbox": [
+            173,
+            729,
+            823,
+            757
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Steven J. Rennie, Etienne Marcheret, Youssef Mroueh, Jarret Ross, and Vaibhava Goel. Self-critical Sequence Training for Image Captioning. In CVPR, 2017. ",
+        "bbox": [
+            171,
+            767,
+            823,
+            796
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Santi Segui, Oriol Pujol, and Jordi Vitria. Learning to count with deep object features. In CVPRW, 2015. ",
+        "bbox": [
+            171,
+            805,
+            823,
+            834
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kevin J. Shih, Saurabh Singh, and Derek Hoiem. Where To Look: Focus Regions for Visual Question Answering. In CVPR, 2015. ",
+        "bbox": [
+            173,
+            843,
+            823,
+            872
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Richard Socher, Andrej Karpathy, Quoc V Le, Christopher D Manning, and Andrew $\\textsf { Y } \\mathrm { N g }$ Grounded Compositional Semantics for Finding and Describing Images with Sentences. In TACL, 2014. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Damien Teney, Lingqiao Liu, and Anton van den Hengel. Graph-Structured Representations for Visual Question Answering. arXiv, 2016.   \nDamien Teney, Peter Anderson, Xiaodong He, and Anton van den Hengel. Tips and Tricks for Visual Question Answering: Learnings from the 2017 Challenge. In CVPR, 2017.   \nAaron van den Oord, Nal Kalchbrenner, Oriol Vinyals, Lasse Espeholt, Alex Graves, and Koray Kavukcuoglu. Conditional Image Generation with PixelCNN Decoders. In NIPS, 2016.   \nR J Williams. Simple statistical gradient-following methods for connectionist reinforcement learning. Machine Learning, 8:229–256, 1992.   \nRonald J. Williams and Jing Peng. Function Optimization using Connectionist Reinforcement Learning Algorithms. Connection Science, 3(3):241–268, 1991.   \nCaiming Xiong, Stephen Merity, and Richard Socher. Dynamic Memory Networks for Visual and Textual Question Answering. In ICML, 2016.   \nHuijuan Xu and Kate Saenko. Ask, Attend and Answer: Exploring Question-Guided Spatial Attention for Visual Question Answering. In ECCV, 2015.   \nZichao Yang, Xiaodong He, Jianfeng Gao, Li Deng, and Alex Smola. Stacked Attention Networks for Image Question Answering. In CVPR, 2015.   \nCong Zhang, Hongsheng Li, Xiaogang Wang, and Xiaokang Yang. Cross-scene crowd counting via deep convolutional neural networks. In CVPR, 2015.   \nJianming Zhang, Shugao Ma, Mehrnoosh Sameki, Stan Sclaroff, Margrit Betke, Zhe Lin, Xiaohui Shen, Brian Price, and Radom´ır Mech. Salient Object Subitizing. ˇ International Journal of Computer Vision, 2017.   \nBolei Zhou, Yuandong Tian, Sainbayar Sukhbaatar, Arthur Szlam, and Rob Fergus. Simple Baseline for Visual Question Answering. arXiv, 2015.   \nYuke Zhu, Oliver Groth, Michael Bernstein, and Li Fei-Fei. Visual7W: Grounded Question Answering in Images. In CVPR, 2015. ",
+        "bbox": [
+            169,
+            95,
+            828,
+            568
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/3317654381e9379c625179dd0473708e03b558c15dd4a60f3e3650bbfa100487.jpg",
+        "image_caption": [
+            "A EXAMPLES ",
+            "Figure 8: Example outputs produced by each model. For SoftCount, objects are shaded according to the fractional count of each $0 =$ transparent; $1 { = }$ opaque). For UpDown, we similarly shade the objects but use the attention focus to determine opacity. For IRLC, we plot only the boxes from objects that were selected as part of the count. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            145,
+            799,
+            825
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/d7f5c1fcafb3eeca6c5f2082b1a554c0eada328b7d767e2ceb40338d489c6c9a.jpg",
+        "image_caption": [
+            "Figure 9: Sequential counting of IRLC. At each timestep, we illustrate the unchosen boxes in pink, and shade each box according to $\\kappa ^ { t }$ (corresponding to the probability that the box would be selected at that time step; see main text). We also show the already-selected boxes in blue. For each of the questions, the counting sequence terminates at $t = 3$ , meaning that the returned count $C$ is 3. For each of these questions, that is the correct answer. The example on the far right is a ‘correct failure,’ a case where the correct answer is returned but the counted objects are not related to the question. These kinds of subtle failures are revealed with the grounded counts. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            212,
+            89,
+            789,
+            718
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B TRAINING AND IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            566,
+            118
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "B.1 CAPTION GROUNDING",
+        "text_level": 1,
+        "bbox": [
+            176,
+            132,
+            374,
+            147
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We experiment with jointly training counting and caption grounding. The goal of caption grounding is, given a set of objects and a caption, to identify the object that the caption describes. Identical to the first stages of answering the counting question, we use an LSTM to encode the caption and compare it to each of the objects using the scoring function: ",
+        "bbox": [
+            174,
+            159,
+            823,
+            215
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c1bb2a8b362d8a96b328b9557b91b58b59e76e1348eb64f96e6343117663feae.jpg",
+        "text": "$$\n\\begin{array} { l } { { h ^ { t } = \\mathrm { L S T M } \\left( x ^ { t } , h ^ { t - 1 } \\right) } } \\\\ { { s _ { i } = f ^ { S } \\left( \\left[ h ^ { T } , v _ { i } \\right] \\right) } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            419,
+            218,
+            578,
+            262
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "where $h \\in \\mathbb { R } ^ { 1 0 2 4 }$ , $x _ { i } ^ { t } \\in \\mathbb { R } ^ { 3 0 0 }$ is the embedding for the token at timestep $t$ of the caption, $T$ is the caption length, and $f ^ { S } : \\mathbb { R } ^ { m }  \\mathbb { R } ^ { n }$ is the scoring function (Sec. 4.3). The embedding of object $i$ is denoted by $v _ { i }$ and the relevance of this object to the caption is encoded by the score vector $s _ { i }$ . ",
+        "bbox": [
+            174,
+            265,
+            825,
+            309
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We project each such score vector to a scalar logit $\\alpha _ { i }$ and apply a softmax nonlinearity to estimate $\\boldsymbol { p } \\in \\mathbf { \\mathbb { R } } ^ { \\tilde { N } }$ , where $N$ is the number of object proposals and $p _ { i }$ denotes the probability that the caption describes object proposal $i$ : ",
+        "bbox": [
+            173,
+            315,
+            823,
+            358
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7c350014993111fcb987e0118e910efd42ad3469b5699c5e64fa9d182c25e9f6.jpg",
+        "text": "$$\n\\begin{array} { l } { \\alpha _ { i } = W s _ { i } + b } \\\\ { p = \\operatorname { s o f t m a x } \\left( \\alpha \\right) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            433,
+            363,
+            565,
+            400
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "During training, we randomly select four of the images in the batch of examples to use for caption grounding (rather than the full 32 images that make up a batch). To create training data from the region captions in Visual Genome, we assign each caption to one of the detected object proposals. To do so, we compute the intersection over union between the ground truth region that the caption describes and the coordinates of each object proposal. We assign the object proposal with the largest IoU to the caption. If the maximum IoU for the given caption is less than 0.5, we ignore it during training. We compute the grounding probability $p$ for each caption to which we can successfully assign a detection and train using the cross entropy loss averaged over the captions. We weight the loss associated with caption grounding by 0.1 relative to the counting loss. ",
+        "bbox": [
+            173,
+            410,
+            825,
+            537
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "B.2 COUNTING MODELS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            553,
+            356,
+            568
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Each of the considered counting models makes use of the same basic architecture for encoding the question and comparing it with each of the detected objects. For each model, we initialized the word embeddings from GloVe (Pennington et al., 2014) and encoded the question with an LSTM of hidden size 1024. The only differences in the model-specific implementations of the language module was the hidden size of the scoring function $f ^ { S }$ . We determined these specifics from the optimal settings observed during initial experiments. We use a hidden size of 512 for SoftCount and UpDown and a hidden size of 2048 for IRLC. We observed that the former two models were more prone to overfitting, whereas IRLC benefited from the increased capacity. ",
+        "bbox": [
+            173,
+            579,
+            825,
+            690
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "When training on counting, we optimize using Adam (Kingma & Ba, 2014). For SoftCount and UpDown, we use a learning rate of $3 \\mathrm { x } 1 0 ^ { - 4 }$ and decay the learning rate by 0.8 when the training accuracy plateaus. For IRLC, we use a learning rate of $5 \\mathrm { x } 1 0 ^ { - 4 }$ and decay the learning rate by 0.99999 every iteration. For all models, we regularize using dropout and apply early stopping based on the development set accuracy (see below). ",
+        "bbox": [
+            174,
+            698,
+            825,
+            767
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "When training IRLC, we apply the sampling procedure 5 times per question and average the losses. We weight the entropy penalty $P _ { H }$ and interaction penalty $P _ { I }$ (Eq. 10) both by 0.005 relative to the counting loss. These penalty weights yield the best development set accuracy within the hyperparameter search we performed (Fig. 10). ",
+        "bbox": [
+            173,
+            773,
+            825,
+            830
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "C ADDITIONAL ANALYSES AND EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            851,
+            575,
+            866
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "IRLC auxiliary loss. We performed a grid search to determine the optimal setting for the weights of the auxiliary losses for training IRLC. From our observations, the entropy penalty is important to balance the exploration of the model during training. In addition, the interaction penalty prevents degenerate counting strategies. The results of the grid search suggest that these auxiliary losses improve performance but become unhelpful if given too much weight (Fig. 10). In any case, IRLC outperforms the baseline models across the range of settings explored. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/e485c8ca56415cc03c33f92e851009fc3740f2e90c71827bc0edf11559b48d96.jpg",
+        "image_caption": [
+            "Figure 10: Results of a hyperparameter sweep over the penalty weights. The accuracy over the development set is reported for each weight setting. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            271,
+            98,
+            725,
+            375
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/956077bd0329998beea6c243d33d4871e53571c08b1c9e9aeb9ddaa0d579b1e7.jpg",
+        "image_caption": [
+            "Figure 11: HowMany-QA test set performance for models trained with the full HowMany-QA training data (blue) and trained without the additional data from Visual Genome (green). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            439,
+            790,
+            598
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            672,
+            825,
+            714
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Data augmentation with Visual Genome. Here, we compare performance on the HowManyQA test set for models trained with and without additional data from Visual Genome QA. In all cases, performance benefits from the additional training data (Fig. 11). On average, excluding Visual Genome from the training data decreases accuracy by $2 . 7 \\%$ and increases RMSE by 0.12. Interestingly, the performance of IRLC is most robust to the loss of training data. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            791
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Ordinality of UpDown output. Whereas the training objectives for SoftCount and IRLC intrinsically reflect the ordinal nature of counts, the same is not true for UpDown. For example, the loss experienced by SoftCount and IRLC reflect the degree of error between the estimated count and the ground truth target; however, UpDown is trained only to place high probability mass on the ground truth value (missing by 1 or by 10 are treated as equally incorrect). We examine the patterns in the output count probabilities from UpDown to ask whether the model learns an ordinal representation despite its non-ordinal training objective. Figure 12 illustrates these trends. When the estimated count is less than 5, the second-most probable count is very frequently adjacent to the most probable count. When the estimated count is larger than 5, the probability distribution is less smooth, such that the second-most probable count is often considerably different than the most probable count. This result suggests that UpDown learns ordinality for lower count values (where training data is abundant) but fails to generalize this concept to larger counts (where training data is more sparse). ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/c83c9cf326a316921071e1b3e49aed3326729b5a922b2e42e5b15a753ffae7ac.jpg",
+        "image_caption": [
+            "Figure 12: (Left) Average count probability (Eq. 15) from UpDown, grouped according to the estimated count. (Right) Cumulative distribution of the absolute difference between the top two predicted counts, shown for when the most likely count was less than 5 (blue) and when it was greater than or equal to 5 (green). The probability distributions are much less smooth when the estimated count is large. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            102,
+            820,
+            250
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            367,
+            825,
+            410
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "D EVALUATION METRICS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            430,
+            398,
+            445
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Accuracy. The VQA dataset includes annotations from ten human reviewers per question. The accuracy of a given answer $a$ depends on how many of the provided answers it agrees with. It is scored as correct if at least 3 humans answers agree: ",
+        "bbox": [
+            174,
+            460,
+            825,
+            503
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c4a7e8e6bce1b21acdcae5755b35ccee413147ad2332a965b06f75ff1f53f091.jpg",
+        "text": "$$\n\\operatorname { \\mathrm { \\tt ~ A c c } } \\left( a \\right) = \\operatorname* { m i n } \\left[ \\frac { \\# \\mathrm { h u m a n s ~ t h a t ~ s a i d } a } { 3 } , 1 \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            508,
+            642,
+            542
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Each answer’s accuracy is averaged over each 10-choose-9 set of human answers. As described in the main text, we only consider examples where the consensus answer was in the range of 0-20. We use all ten labels to calculate accuracy, regardless of whether individual labels deviate from this range. Thee accuracy values we report are taken from the average accuracy over some set of examples. ",
+        "bbox": [
+            174,
+            546,
+            825,
+            617
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "RMSE. This metric simply quantifies the typical deviation between the model count and the groundtruth. Across a set of $N$ , we calculate this metric as ",
+        "bbox": [
+            173,
+            623,
+            821,
+            652
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d950d2e56663f00502d01ee833d060c7f99e3846f1d9c0141226827364de772a.jpg",
+        "text": "$$\n\\mathrm { R M S E } = \\sqrt { \\frac { 1 } { N } \\sum _ { i } ( \\hat { C } _ { i } - C _ { i } ) ^ { 2 } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            656,
+            598,
+            699
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "where $\\hat { C } _ { i }$ and $C _ { i }$ are the predicted and ground truth counts, respectively, for question $i$ . RMSE is a measurement of error, so lower is better. ",
+        "bbox": [
+            176,
+            707,
+            823,
+            734
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Grounding Quality. We introduce a new evaluation method for quantifying how relevant the objects counted by a model are to the type of object it was asked to count. This evaluation metric takes advantage of the ground truth labels included in the COCO dataset. These labels annotate each object instance of 80 different categories for each of the images in the development set. We make use of GloVe embeddings to compute semantic similarity. We use GloVe $( x ) \\ { \\stackrel { \\cdot } { \\in } } \\ \\mathbb { R } ^ { 3 0 0 }$ to denote the ( $L 2$ normalized) GloVe embedding of category $x$ . ",
+        "bbox": [
+            173,
+            741,
+            825,
+            827
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "For each image $m$ , the analysis is carried out in two stages. ",
+        "bbox": [
+            173,
+            832,
+            562,
+            848
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "First, we assign one of the COCO categories (or background) to each of the object proposals used for counting. For each object proposal, we find the object in the COCO labels with the largest IoU. If the IoU is above 0.5, we assign the object proposal to the category of the COCO object, otherwise we assign the object proposal to the background. Below, we use $k _ { i } ^ { m }$ to denote the category assigned to object proposal $i$ for image $m$ . ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Second, for each of the COCO categories present in image $m$ , we use the category $q$ (i.e. $q = \\ \" \\mathrm { c a r } \\ ' )$ to build a question (i.e. “How many cars are there?”). For SoftCount and IRLC, the count returned in response to this question is the sum of each object proposal’s inferred count value: ",
+        "bbox": [
+            173,
+            103,
+            826,
+            146
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0e8cfc5258fdb7fc6aeab5659602039ea6150fa7ae8d0fb6d649e2221f544a93.jpg",
+        "text": "$$\nC ^ { ( m , q ) } = \\sum _ { i } ^ { N ^ { m } } w _ { i } ^ { ( m , q ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            424,
+            152,
+            571,
+            196
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "where $N ^ { m }$ is the number of object proposals in image $m$ and $w _ { i } ^ { ( m , q ) }$ is the count value given to proposal $i$ . We use the count values to compute a weighted sum of the semantic similarity between the assigned object proposal categories $k$ and the question category $q$ : ",
+        "bbox": [
+            174,
+            205,
+            825,
+            250
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e6c28644dcbf02fa6c8337073adc73d59ab6b8c1b8ea44cbe87b3591638750bf.jpg",
+        "text": "$$\ns ^ { ( m , q ) } = \\sum _ { i } ^ { N ^ { m } } w _ { i } ^ { ( m , q ) } \\left( \\mathsf { G l o V e } \\left( k _ { i } ^ { m } \\right) ^ { T } \\mathsf { G l o V e } \\left( q \\right) \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            328,
+            255,
+            666,
+            299
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "where semantic similarity is estimated from the dot product between the embeddings of the assigned category and the question category. If $k _ { i } ^ { m }$ corresponds to the background category, we replace its embedding with a vector of zeros. ",
+        "bbox": [
+            174,
+            305,
+            825,
+            348
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "The final metric is computed for each COCO category by accumulating the results over all images that contain a label for that category and normalizing by the net count to get an average: ",
+        "bbox": [
+            173,
+            354,
+            825,
+            383
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e537d6951a63f8fa223f1192cea6bc0ca9a1bdda072dd923150a57d78c53cc5f.jpg",
+        "text": "$$\ns ^ { ( q ) } = \\frac { \\Sigma _ { m } s ^ { ( m , q ) } } { \\Sigma _ { m } C ^ { ( m , q ) } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            434,
+            390,
+            563,
+            425
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "The interpretation of this metric is straightforward: on average, how relevant are the counted objects to the subject of the question. ",
+        "bbox": [
+            173,
+            430,
+            825,
+            459
+        ],
+        "page_idx": 17
+    }
+]

parse/train/S1x0CnEtvB/S1x0CnEtvB.md

@@ -0,0 +1,307 @@
+# AutoGrow: AUTOMATIC LAYER GROWING IN DEEPCONVOLUTIONAL NETWORKS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+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.
+
+# 1 INTRODUCTION
+
+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 $5 6 \times 5 6 .$ , $2 8 \times 2 8$ , $1 4 \times 1 4$ and $7 \times 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 (Wei et al., 2016; 2017; 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.
+
+![](images/72e33b5122b717c13c9dc77bce7ee8b88fa746ca183412e7a3b8ecb0c8f45468.jpg)  
+Figure 1: A simple example of AutoGrow.
+
+Table 1: Comparison with previous works about layer growth.   
+
+<table><tr><td colspan="2">Previous works</td><td>Ours</td></tr><tr><td>Goal</td><td>Ease training</td><td>Depth automation</td></tr><tr><td>Times</td><td>Once or a few</td><td>Unlimited</td></tr><tr><td>Locations</td><td>Human defined</td><td>Learned</td></tr><tr><td>Layer #</td><td>Human defined</td><td>Learned</td></tr></table>
+
+Our contributions are: (1) We propose AutoGrow to automate DNN layer growing and depth discovery. AutoGrow is very robust. With the same hyper-parameters, it adapts network depth to various datasets including MNIST, FashionMNIST, SVHN, CIFAR10, CIFAR100 and ImageNet. Moreover, AutoGrow can also discover shallower DNNs when the dataset is a subset. (2) AutoGrow demonstrates high efficiency and scales up to ImageNet, because the layer growing is as fast as training a single DNN. On ImageNet, it discovers a new ResNets with better trade-off between accuracy and computation complexity. (3) We challenge the idea of Network Morphism, as random initialization works equally or better when growing layers. (4) We find that it is beneficial to rapidly grow layers before a shallower net converge, contradicting previous intuition.
+
+# 2 AutoGrow – A DEPTH GROWING ALGORITHM
+
+# Algorithm 1 AutoGrow Algorithm.
+
+![](images/e7209b24a99a73964f399e911a453f4a602e8d31ef04219a317e7a5047c6e827.jpg)
+
+Figure 1 gives an overview of the proposed AutoGrow. In this paper, we use network, sub-networks, sub-modules and layers to describe the architecture hierarchy. A network is composed of a cascade of sub-networks. A sub-network is composed of sub-modules, which typical share the same output size. A sub-module (e.g. a residual block) is an elementary growing block composed of one or a few layers. In this section, we rigorously formulate a generic version of AutoGrow which will be materialized in subsections. A deep convolutional network $g ( \mathcal { X } _ { 0 } )$ is a cascade of sub-networks by composing functions as $g ( \mathcal { X } _ { 0 } ) = l \bar { ( } f _ { M - 1 } ( \pmb { f } _ { M - 2 } ( \cdot \cdot \cdot f _ { 1 } ( \pmb { f } _ { 0 } ( \mathcal { X } _ { 0 } ) ) \cdot \cdot \cdot \cdot ) ) ) .$ ), where $\mathcal { X } _ { 0 }$ is an input image, $M$ is the number of sub-networks, $l ( \cdot )$ is a loss function, and $\mathscr { X } _ { i + 1 } = f _ { i } \left( \mathscr { X } _ { i } \right)$ is a sub-network that operates on an input image or a feature tensor $\mathcal { X } _ { i } \in \mathbb { R } ^ { c _ { i } \times h _ { i } \times w _ { i } }$ . Here, $c _ { i }$ is the number of channels, and $h _ { i }$ and $w _ { i }$ are spatial dimensions. $f _ { i } \left( \mathcal { X } _ { i } \right)$ is a simplified notation of $\pmb { f } _ { i } \left( \mathcal { X } _ { i } ; \mathbb { W } _ { i } \right)$ , where $\mathbb { W } _ { i }$ is a set of sub-modules’ parameters within the $i$ -th sub-network. Thus $\mathbb { W } = \{ \mathbb { W } _ { i } : i = 0 \dots M - 1 \}$ denotes the whole set of parameters in the DNN. To facilitate growing, the following properties are supported within a sub-network: (1) the first sub-module usually reduces the size of input feature maps, e.g., using pooling or convolution with a stride; and (2) all sub-modules in a sub-network maintain the same output size. As such, our framework can support popular networks, including VggNet-like plain networks (Simonyan & Zisserman, 2014), GoogLeNet (Szegedy et al., 2015), ResNets (He et al., 2016) and DenseNets (Huang et al., 2017). In this paper, we select ResNets and VggNet-like nets as representatives of DNNs with and without shortcuts, respectively.
+
+With above notations, Algorithm 1 rigorously describes the AutoGrow algorithm. In brief, AutoGrow starts with the shallowest net where every sub-network has only one sub-module for spatial dimension reduction. AutoGrow loops over all growing sub-networks in order. For each sub-network, AutoGrow stacks a new sub-module. When the new sub-module does not improve the accuracy, the growth in corresponding sub-network will be permanently stopped. The details of our method will be materialized in the following subsections.
+
+# 2.1 SEED SHALLOW NETWORKS AND SUB-MODULES
+
+In this paper, in all datasets except ImageNet, we explore growing depth for four types of DNNs: (1) Basic3ResNet: the same ResNet used for CIFAR10 in He et al. (2016), which has 3 residual subnetworks with output spatial sizes of $3 2 \times 3 2$ , $1 6 \times 1 6$ and $8 \times 8$ , respectively; (2) Basic4ResNet: a variant of ResNet used for ImageNet in He et al. (2016) built by basic residual blocks (each of which contains two convolutions and one shortcut). There are 4 sub-networks with output spatial sizes of $3 2 \times 3 2$ , $1 6 \times 1 6$ , $8 \times 8$ and $4 \times 4$ , respectively; (3) Plain3Net: a VggNet-like plain net by removing shortcuts in Basic3ResNet; (4) Plain4Net: a VggNet-like plain net by removing shortcuts in Basic4ResNet.
+
+In AutoGrow, the architectures of seed shallow networks and sub-modules are pre-defined. In plain DNNs, a sub-module is a stack of convolution, Batch Normalization and ReLU; in residual DNNs, a sub-module is a residual block. In AutoGrow, a sub-network is a stack of all sub-modules with the same output spatial size. Unlike He et al. (2016) which manually designed the depth, AutoGrow starts from a seed architecture in which each sub-network has only one sub-module and automatically learns the number of sub-modules.
+
+On ImageNet, we apply the same backbones in He et al. (2016) as the seed architectures. A seed architecture has only one sub-module under each output spatial size. For a ResNet using basic residual blocks or bottleneck residual blocks (He et al., 2016), we respectively name it as Basic4ResNet or Bottleneck4ResNet. Plain4Net is also obtained by removing shortcuts in Basic4ResNet.
+
+# 2.2 SUB-MODULE INITIALIZERS
+
+Here we explain how to initialize a new sub-module $\mathcal { W }$ in initializer $( \mathcal { W } )$ mentioned in Algorithm 1. Network Morphism changes DNN architecture meanwhile preserving the loss function via special initialization of new layers, that is, $g ( \mathcal { X } _ { 0 } ; \mathbb { W } ) = g ( \mathcal { X } _ { 0 } ; \mathbb { W } \cup \mathcal { W } ) \ \forall \mathcal { X } _ { 0 }$ . A residual sub-module shows a nice property: when stacking a residual block and initializing the last Batch Normalization layer as zeros, the function of the shallower net is preserved but the DNN is morphed to a deeper net. Thus, Network Morphism can be easily implemented by this zero initialization (ZeroInit).
+
+In this work, all layers in $\mathcal { W }$ are initialized using default randomization, except for a special treatment of the last Batch Normalization layer in a residual sub-module. Besides ZeroInit, we propose a new AdamInit for Network Morphism. In AdamInit, we freeze all parameters except the last Batch Normalization layer in $\mathcal { W }$ , and then use Adam optimizer (Kingma & Ba, 2014) to optimize the last Bath Normalization for maximum 10 epochs till the training accuracy of the deeper net is as good as the shallower one. After AdamInit, all parameters are jointly optimized. We view AdamInit as a Network Morphism because the training loss is similar after AdamInit. We empirically find that AdamInit can usually find a solution in less than 3 epochs. We also study random initialization of the last Batch Normalization layer using uniform (UniInit) or Gaussian (GauInit) noises with a standard deviation 1.0. We will show that GauInit obtains the best result, challenging the idea of Network Morphism (Wei et al., 2016; 2017; Chen et al., 2015).
+
+# 2.3 GROWING AND STOPPING POLICIES
+
+In Algorithm 1, a growing policy refers to meetGrowingPolicy(), which returns true when the network should grow a sub-module. Two growing policies are studied here:
+
+1. Convergent Growth: meetGrowingPolicy() returns true when the improvement of validation accuracy is less than $\tau$ in the last $K$ epochs. That is, in Convergent Growth, AutoGrow only grows when current network has converged. This is a similar growing criterion adopted in previous works (Elsken et al., 2017; Cai et al., 2018a;b).   
+2. Periodic Growth: meetGrowingPolicy() always returns true, that is, the network always grows every $K$ epochs. Therefore, $K$ is also the growing period. In the best practice of AutoGrow, $K$ is small (e.g. $K = 3$ ) such that it grows before current network converges.
+
+Our experiments will show that Periodic Growth outperforms Convergent Growth. We hypothesize that a fully converged shallower net is an inadequate initialization to train a deeper net. We will perform experiments to test this hypothesis and visualize optimization trajectory to illustrate it.
+
+A stopping policy denotes meetStoppingPolicy() in Algorithm 1. When Convergent Growth is adopted, meetStoppingPolicy() returns true if a recent growth does not improve validation accuracy more than $\tau$ within $K$ epochs. We use a similar stopping policy for Periodic Growth; however, as it can grow rapidly with a small period $K$ (e.g. $K \ : = \ : 3 ,$ ) before it converges, we use a larger window size $J$ for stop. Specifically, when Periodic Growth is adopted, meetStoppingPolicy() returns true when the validation accuracy improves less than $\tau$ in the last $J$ epochs, where $J \gg K$ .
+
+Hyper-parameters $\tau$ , $J$ and $K$ control the operation of AutoGrow and can be easily setup and generalize well. $\tau$ denotes the significance of accuracy improvement for classification. We simply set $\tau = 0 . 0 5 \%$ in all experiments. $J$ represents how many epochs to wait for an accuracy improvement before stopping the growth of a sub-network. It is more meaningful to consider stopping when the new net is trained to some extent. As such, we set $J$ to the number of epochs $T$ under the largest learning rate when training a baseline. $K$ means how frequently AutoGrow checks the polices. In Convergent Growth, we simply set $K = T$ , which is long enough to ensure convergence. In Periodic Growth, $K$ is set to a small fraction of $T$ to enable fast growth before convergence; more importantly, $K = 3$ is very robust to all networks and datasets. Therefore, all those hyper-parameters are very robust and strongly correlated to design considerations.
+
+# 3 EXPERIMENTS
+
+In this paper, we use Basic3ResNet-2-3-2, for instance, to denote a model architecture which contains 2, 3 and 2 sub-modules in the first, second and third sub-networks, respectively. Sometimes we simplify it as $2 - 3 - 2$ for convenience. AutoGrow always starts from the shallowest depth of $1 - 1 - 1$ and uses the maximum validation accuracy as the metric to guide growing and stopping. All DNN baselines are trained by SGD with momentum 0.9 using staircase learning rate. The initial learning rate is 0.1 in ResNets and 0.01 in plain networks. On ImageNet, baselines are trained using batch size 256 for 90 epochs, within which learning rate is decayed by $0 . 1 \times$ at epoch 30 and 60. In all other smaller datasets, baselines are trained using batch size 128 for 200 epochs and learning rate is decayed by $0 . 1 \times$ at epoch 100 and 150.
+
+Our early experiments followed prior wisdom by growing layers with Network Morphism (Wei et al., 2016; 2017; Chen et al., 2015; Elsken et al., 2017; Cai et al., 2018a;b), i.e., AutoGrow with ZeroInit (or AdamInit) and Convergent Growth policy; however, it stopped early with very shallow DNNs, failing to find optimal depth. We hypothesize that a converged shallow net with Network Morphism gives a bad initialization to train a deeper neural network. Section 3.1 experimentally test that the hypothesis is valid. To tackle this issue, we intentionally avoid convergence during growing by three simple solutions, which are evaluated in Section 3.2. Finally, Section 3.3 and Section 3.4 include extensive experiments to show the effectiveness of our final AutoGrow.
+
+# 3.1 SUBOPTIMUM OF NETWORK MORPHISM AND CONVERGENT GROWTH
+
+In this section, we study Network Morphism itself and its integration into our AutoGrow under Convergent Growth. When studying Network Morphism, we take the following steps: 1) train a shallower ResNet to converge, 2) stack residual blocks on top of each sub-network to morph to a deeper net, 3) use ZeroInit or AdamInit to initialize new layers, and 4) train the deeper net in a standard way. We compare the accuracy difference $( ^ { 6 6 } \Delta ^ { , 3 } )$ between Network Morphism and training the deeper net from scratch. Table 2 summaries our results. Network Morphism has a lower accuracy (negative “ $\cdot \Delta ^ { \prime \prime }$ ) in all the cases, which validates our hypothesis that a converged shallow network with Network Morphism gives a bad initialization to train a deeper net. We visualize the optimization trajectories in Appendix A.0.1 to illustrate the hypothesis.
+
+To further validate our hypothesis, we integrate Network Morphism as the initializer in AutoGrow with Convergent Growth policy. We refer to this version of AutoGrow as $c$ -AutoGrow with “ $_ { \mathrm { ~ \tiny ~ c ~ } }$ -” denoting “Convergent.” More specific, we take ZeroInit or AdamInit as sub-module initializer and “Convergent Growth” policy in Algorithm 1. To recap, in this setting, AutoGrow trains a shallower net till it converges, then grows a sub-module which is initialized by Network Morphism, and repeats the same process till there is no further accuracy improvement. In every interval of $K$ training epochs (train $( g ( \mathcal { X } _ { 0 } ) , K )$ in Algorithm 1), “staircase” learning rate is used. The learning rate is reset to 0.1 at the first epoch, and decayed by $0 . 1 \times$ at epoch $\frac { K } { 2 }$ and $\frac { 3 K } { 4 }$ . The results are shown in Table 3 by “staircase” rows, which illustrate that $c$ -AutoGrow can grow a DNN multiple times and finally find a depth. However, there are two problems: 1) the final accuracy is lower than training the found net from scratch, as indicated by $^ { 6 6 } \Delta ^ { , 9 }$ , validating our hypothesis; 2) the depth learning stops too early with a relatively shallower net, while a deeper net beyond the found depth can achieve a higher accuracy as we will show in Table 6. These problems provide a circumstantial evidence of the hypothesis that a converged shallow net with Network Morphism gives a bad initialization. Thus, AutoGrow cannot receive signals to continue growing after a limited number of growths. In Appendix A.0.1, Figure 6(a) visualizes the trajectory of $c$ -AutoGrow corresponding to row $^ { 6 6 } 2 - 3 - 6 ^ { 3 3 }$ in Table 3.
+
+# 3.2 ABLATION STUDY FOR AutoGrow DESIGN
+
+Based on the findings in Section 3.1, we propose three simple but effective solutions to further enhance AutoGrow and refer it as $p$ -AutoGrow, with $\mathbf { \dot { \rho } } _ { p }$ -” denoting “Periodic”: (1) Use a large constant learning rate for growing, i.e., 0.1 for residual networks and 0.01 for plain networks. Stochastic gradient descent with a large learning rate intrinsically introduces noises, which help to avoid a full convergence into a bad initialization from a shallower net. Note that staircase learning rate is still used for fine-tuning after discovering the final DNN; (2) Use random initialization (UniInit or GauInit) as noises to escape from an inadequate initialization; (3) Grow rapidly before a shallower net converges by taking Periodic Growth with a small $K$ .
+
+$p$ -AutoGrow is our final AutoGrow. In the rest part of this section, we perform ablation study to prove that the three solutions are effective. We start from $c$ -AutoGrow, and incrementally add above solutions one by one and eventually obtain $p$ -AutoGrow. In Table 3, first, we replace the staircase learning rate with a constant learning rate, the accuracy of AutoGrow improves and therefore $^ { 6 6 } \Delta ^ { , 9 }$ improves; second, we further replace Network Morphism (ZeroInit or AdamInit) with a random initializer (UniInit or GauInit) and result in a bigger gain. Overall, combining a constant learning rate with GauInit performs the best. Thus, constant learning rate and GauInit are adopted in the remaining experiments, unless we explicitly specify them.
+
+Table 2: Network Morphism tested on CIFAR10.   
+
+<table><tr><td>net backbone</td><td>shallower</td><td>deeper</td><td>initializer</td><td>accu %</td><td>*</td></tr><tr><td>Basic3ResNet</td><td>3-3-3</td><td>5-5-5</td><td>ZeroInit AdamInit</td><td>92.71 92.82</td><td>-0.77</td></tr><tr><td rowspan="2">Basic3ResNet</td><td rowspan="2">5-5-5</td><td rowspan="2">9-9-9</td><td></td><td></td><td>-0.66</td></tr><tr><td>ZeroInit</td><td>93.64</td><td>-0.27 -0.38</td></tr><tr><td rowspan="2">Basic4ResNet</td><td rowspan="2">1-1-1-1</td><td rowspan="2">2-2-2-2</td><td>AdamInit</td><td>93.53 94.96</td><td></td></tr><tr><td>ZeroInit AdamInit</td><td>95.17</td><td>-0.37 -0.16</td></tr></table>
+
+∗ $\overline { { \Delta = } }$ (accuracy of Network Morphism) − (accuracy of training from scratch)
+
+Table 3: Ablation study of $c$ -AutoGrow.   
+
+<table><tr><td>dataset</td><td>learning rate</td><td>initializer</td><td>found net†</td><td>accu %</td><td>△*</td><td>dataset</td><td>learning rate</td><td>initializer</td><td>found net</td><td>accu %</td><td>△*</td></tr><tr><td rowspan="6">CIFAR10</td><td>staircase</td><td>ZeroInit</td><td>2-3-6</td><td>91.77</td><td>-1.06</td><td rowspan="6"></td><td>staircase</td><td>ZeroInit</td><td>4-3-4</td><td>70.04</td><td>-0.65</td></tr><tr><td>staircase</td><td>AdamInit</td><td>3-4-3</td><td>92.21 -0.59</td><td></td><td>staircase</td><td>AdamInit</td><td>3-3-3</td><td>69.85</td><td>-0.65</td></tr><tr><td>constant</td><td>ZeroInit</td><td>2-2-4</td><td>92.23</td><td>0.16</td><td>CIFAR100 constant</td><td>ZeroInit</td><td>3-2-4</td><td>70.22</td><td>0.35</td></tr><tr><td>constant</td><td>AdamInit</td><td>3-4-4</td><td>92.60</td><td>-0.41</td><td>constant</td><td>AdamInit</td><td>3-3-3</td><td>70.00</td><td>-0.50</td></tr><tr><td>constant</td><td>UniInit</td><td>3-4-4</td><td>92.93</td><td>-0.08</td><td>constant</td><td>UniInit</td><td>4-4-3</td><td>70.39</td><td>0.36</td></tr><tr><td>constant</td><td>GauInit</td><td>2-4-3</td><td>93.12</td><td>0.55</td><td>constant</td><td>GauInit</td><td>3-4-3</td><td>70.66</td><td>0.91</td></tr></table>
+
+† Basic3ResNet   
+∗ ∆ = (accuracy of c-AutoGrow) − (accuracy of training from scratch)
+
+Note that, in this paper, we are more interested in automating depth discovery to find a final DNN (“found net”) with a high accuracy (“accu”). Ideally, the “found net” has a minimum depth, a larger depth than which cannot further improve “accu”. We will show in Figure 3 that AutoGrow discovers a depth approximately satisfying this property. The “ $\Delta ^ { \prime \prime }$ is a metric to indicate how well shallower nets initialize deeper nets; a negative $^ { 6 6 } \Delta ^ { , 9 }$ indicates that weight initialization from a shallower net hurts training of a deeper net; while a positive “ $\cdot \Delta ^ { \prime \prime }$ indicates AutoGrow helps training a deeper net, which is a byproduct of this work.
+
+Finally, we apply the last solution – Periodic Growth, and obtain our final $p$ -AutoGrow. Our ablation study results for $p$ -AutoGrow are summarized in Table 5 and Table 4. Table 5 analyzes the impact of the growing period $K$ . In general, $K$ is a hyper-parameter to trade off speed and accuracy: a smaller $K$ takes a longer learning time but discovers a deeper net, vice versa. Our results validate the preference of a faster growth (i.e. a smaller $K$ ). On CIFAR10/CIFAR100, the accuracy reaches plateau/peak at $K = 3$ ; further reducing $K$ produces a deeper net while the accuracy gain is marginal/impossible. In the following, we simply select $K = 3$ for robustness test. More importantly, our quantitative results in Table 5 show that $p$ -AutoGrow finds much deeper nets, overcoming the very-early stop issue in $c$ -AutoGrow in Table 3. That is, Periodic Growth proposed in this work is much more effective than Convergent Growth utilized in previous work.
+
+For sanity check, we perform the ablation study of initializers for $p$ -AutoGrow. The results are in Table 8 in Appendix A.0.3, which further validates our wisdom on selecting GauInit. The motivation of Network Morphism in previous work was to start a deeper net from a loss function that has been well optimized by a shallower net, so as not to restart the deeper net training from scratch (Wei et al., 2016; 2017; Chen et al., 2015; Elsken et al., 2017; Cai et al., 2018a;b). In all our experiments, we find this is sure even with random initialization. Figure 2 plots the convergence curves and learning process for $^ {  } 4 2 - 4 2 - 4 2 ^ { \circ }$ in Table 5. Even with GauInit, the loss and accuracy rapidly recover and no restart is observed. The convergence pattern in the “Growing” stage is similar to the “Fine-tuning” stage under the same learning rate (the initial learning rate 0.1). Similar results on ImageNet will be shown in Figure 8. Our results challenge the necessity of Network Morphism when growing neural networks.
+
+At last, we perform the ablation study on the initial depth of the seed network. Table 4 demonstrates that a shallowest DNN works as well as a deeper seed. This implies that AutoGrow can appropriately stop regardless of the depth of the seed network. As the focus of this work is on depth automation, we prefer starting with the shallowest seed to avoid a manual search of a seed depth.
+
+![](images/7115fdf5652ea828e3ef817a308ac1719c82c992743edae687ce89c8bbfe3a43.jpg)  
+Figure 2: $p$ -AutoGrow on CIFAR10 $\ K \ : = \ : 3 ,$ . The seed net is Basic3ResNet $- 1 - 1 - 1$ .
+
+Table 4: $p$ -AutoGrow with different seed architecture.   
+
+<table><tr><td>dataset</td><td>seed net</td><td>found net†</td><td>accuracy %</td></tr><tr><td rowspan="2">CIFAR10</td><td>1-1-1</td><td>42-42-42</td><td>94.27</td></tr><tr><td>5-5-5</td><td>46-46-46</td><td>94.16</td></tr><tr><td rowspan="2">CIFAR10</td><td>1-1-1-1</td><td>22-22-22-22</td><td>95.49</td></tr><tr><td>5-5-5-5</td><td>23-22-22-22</td><td>95.62</td></tr></table>
+
+† Basic3ResNet or Basic4ResNet.
+
+# 3.3 ADAPTABILITY OF AutoGrow
+
+To verify the adaptability of AutoGrow, we use an identical configuration $\dot { p }$ -AutoGrow with $K = 3$ ) and test over 5 datasets and 4 seed architectures. Table 6 includes the results of all 20 combinations. Figure 3 compares AutoGrow with manual search which is obtained by training many DNNs with different depths from scratch. The results lead to the following conclusions and contributions:
+
+Table 5: $p$ -AutoGrow with different growing interval $K$ .   
+
+<table><tr><td rowspan="2">K</td><td colspan="2">CIFAR10</td><td colspan="3">CIFAR100</td></tr><tr><td>found net</td><td>accu %</td><td>K</td><td>found net</td><td>accu %</td></tr><tr><td>50</td><td>6-5-3</td><td>92.95</td><td>50</td><td>8-5-7</td><td>72.07</td></tr><tr><td>20</td><td>7-7-7</td><td>93.26</td><td>20</td><td>8-11-10</td><td>72.93</td></tr><tr><td>10</td><td>19-19-19</td><td>93.46</td><td>10</td><td>18-18-18</td><td>73.64</td></tr><tr><td>5</td><td>23-22-22</td><td>93.98</td><td>5</td><td>23-23-23</td><td>73.70</td></tr><tr><td>3</td><td>42-42-42</td><td>94.27</td><td>3</td><td>54-53-53</td><td>74.72</td></tr><tr><td>1</td><td>77-76-76</td><td>94.30</td><td>1</td><td>68-68-68</td><td>74.51</td></tr></table>
+
+† Basic3ResNet   
+† Basic3ResNet
+
+Table 6: The adaptability of AutoGrow to datasets   
+
+<table><tr><td>net</td><td>dataset</td><td>found net</td><td>accu %</td><td>△*</td></tr><tr><td rowspan="5">Basic3ResNet</td><td>CIFAR10</td><td>42-42-42</td><td>94.27</td><td>-0.03</td></tr><tr><td>CIFAR100</td><td>54-53-53</td><td>74.72</td><td>-0.95</td></tr><tr><td>SVHN</td><td>34-34-34</td><td>97.22</td><td>0.04</td></tr><tr><td>FashionMNIST</td><td>30-29-29</td><td>94.57</td><td>-0.06</td></tr><tr><td>MNIST</td><td>33-33-33</td><td>99.64</td><td>-0.03</td></tr><tr><td rowspan="5">Basic4ResNet</td><td>CIFAR10</td><td>22-22-22-22</td><td>95.49</td><td>-0.10</td></tr><tr><td>CIFAR100</td><td>17-51-16-16</td><td>79.47</td><td>1.22</td></tr><tr><td>SVHN</td><td>20-20-19-19</td><td>97.32</td><td>-0.08</td></tr><tr><td>FashionMNIST</td><td>27-27-27-26</td><td>94.62</td><td>-0.17</td></tr><tr><td>MNIST</td><td>11-10-10-10</td><td>99.66</td><td>0.01</td></tr></table>
+
+∗ $\overline { { \Delta = } }$ (accuracy of AutoGrow) $-$ (accuracy of training from scratch)
+
+<table><tr><td>net</td><td>dataset</td><td>found net</td><td>accu %</td><td>Δ*</td></tr><tr><td rowspan="5">Plain3Net</td><td>CIFAR10</td><td>23-22-22</td><td>90.82</td><td>6.49</td></tr><tr><td>CIFAR100</td><td>28-28-27</td><td>66.34</td><td>31.53</td></tr><tr><td>SVHN</td><td>36-35-35</td><td>96.79</td><td>77.20</td></tr><tr><td>FashionMNIST</td><td>17-17-17</td><td>94.49</td><td>0.56</td></tr><tr><td>MNIST</td><td>20-20-20</td><td>99.66</td><td>0.12</td></tr><tr><td rowspan="5">Plain4Net</td><td>CIFAR10</td><td>17-17-17-17</td><td>94.20</td><td>5.72</td></tr><tr><td>CIFAR100</td><td>16-15-15-15</td><td>73.91</td><td>29.34</td></tr><tr><td>SVHN</td><td>12-12-12-11</td><td>97.08</td><td>0.32</td></tr><tr><td>FashionMNIST</td><td>13-13-13-13</td><td>94.47</td><td>0.72</td></tr><tr><td>MNIST</td><td>13-12-12-12</td><td>99.57</td><td>0.03</td></tr></table>
+
+1. In Table 6, AutoGrow discovers layer depth across all scenarios without any tuning, achieving the main goal of this work. Manual design needs $m \cdot n \cdot k$ trials, where $m$ and $n$ are respectively the numbers of datasets and sub-module categories, and $k$ is the number of trials per dataset per sub-module category;
+
+2. For ResNets, a discovered depth $" \bullet '$ in Figure 3) falls at the location where accuracy saturates. This means AutoGrow discovers a near-optimal depth: a shallower depth will lose accuracy while a deeper one gains little. The final accuracy of AutoGrow is as good as training the discovered net from scratch as indicated by $\cdot \Delta ^ { , , }$ in Table 6, indicating that initialization from shallower nets does not hurt training of deeper nets. As a byproduct, in plain networks, there are large positive “ $\Delta \mathbf { i }$ ”s in Table 6. It implies that baselines fail to train very deep plain networks even using Batch Normalization, but AutoGrow enables the training of these networks; In Appendix A.0.3, Table 9 shows the accuracy improvement of plain networks by tuning $K$ , approaching the accuracy of ResNets with the same depth.
+
+3. For robustness and generalization study purpose, we stick to $K = 3$ in our experiments, however, we can tune $K$ to trade off accuracy and model size. As shown in Figure 3, AutoGrow discovers smaller DNNs when increasing $K$ from 3 $( ^ { 6 6 } \bullet \bullet )$ to 50 $( ^ { 6 6 } \bigcirc ^ { , 9 } )$ . Interestingly, the accuracy of plain networks even increases at $K = 5 0$ . This implies the possibility of discovering a better accuracy-depth trade-off by tuning $K$ , although we stick to $K = 3$ for generalizability study and it generalizes well.
+
+4. In Table 6, AutoGrow discovers different depths under different sub-modules. The final accuracy is limited by the sub-module design, not by our AutoGrow. Given a sub-module architecture, our AutoGrow can always find a near-optimal depth. With a better sub-module architecture, such as NASNet cell (Zoph et al., 2018), AutoGrow can improve accuracy.
+
+Finally, our supposition is that: when the size of dataset is smaller, the optimal depth should be smaller. Under this supposition, we test the effectiveness of AutoGrow by sampling a subset of dataset and verify if AutoGrow can discover a shallower depth. In Appendix A.0.3, Table 11 summarizes the results. As expected, our experiments show that AutoGrow adapts to shallower networks when the datasets are smaller.
+
+# 3.4 SCALING TO IMAGENET AND EFFICIENCY
+
+In ImageNet, $K = 3$ should generalize well, but we explore AutoGrow with $K = 2$ and $K = 5$ to obtain an accuracy-depth trade-off line for comparison with human experts. The larger $K = 5$ enables AutoGrow to obtain a smaller DNN to trade-off accuracy and model size (computation) and the smaller $K = 2$ achieves higher accuracy. The results are shown in Table 7, which proves that AutoGrow automatically finds a good depth without any tuning. As a byproduct, the accuracy is even higher than training the found net from scratch, indicating that the Periodic Growth in AutoGrow helps training deeper nets. The comparison of AutoGrow and manual depth design (He et al., 2016) is in Figure 4, which shows that AutoGrow achieves better trade-off between accuracy and computation (measured by floating point operations).
+
+Table 7: Scaling up to ImageNet   
+
+<table><tr><td>net</td><td>K</td><td>found net</td><td>Top-1</td><td>Top-5</td><td>△ Top-1</td></tr><tr><td rowspan="2">Basic4ResNet</td><td>2</td><td>12-12-11-11</td><td>76.28</td><td>92.79</td><td>0.43</td></tr><tr><td>5</td><td>9-3-6-4</td><td>74.75</td><td>91.97</td><td>0.72</td></tr><tr><td rowspan="2">Bottleneck4ResNet</td><td>2</td><td>6-6-6-17</td><td>77.99</td><td>93.91</td><td>0.83</td></tr><tr><td>5</td><td>6-7-3-9</td><td>77.33</td><td>93.65</td><td>0.83</td></tr><tr><td rowspan="2">Plain4Net</td><td>2</td><td>6-6-6-6</td><td>71.22</td><td>90.08</td><td>0.70</td></tr><tr><td>5</td><td>5-5-5-4</td><td>70.54</td><td>89.76</td><td>0.93</td></tr></table>
+
+† ∆ = (Top-1 of AutoGrow) − (Top-1 of training from scratch)
+
+In Appendix A.0.3, Table 10 summarizes the breakdown of wall-clock time in AutoGrow. The growing/searching time is as efficient as (often more efficient than) fine-tuning the single discovered DNN. The scalability of AutoGrow comes from its intrinsic features that (1) it grows quickly with a short period $K$ and stops immediately if no improvement is sensed; and (2) the network is small at the beginning of growing.
+
+![](images/f7a6254ad63b159c57ea06e4bc761b4e0c1049b8457efe33338457d61c2774a0.jpg)  
+Figure 3: AutoGrow vs manual search obtained by training many baselines from scratch. $x - a x i s$ is the number of parameters. Dataset is CIFAR10.
+
+![](images/84c1065d96345fcdaf849055087c1baabff04e3dc4738d9ef0934583464c554a.jpg)  
+Figure 4: AutoGrow vs. manual design (He et al., 2016) on ImageNet. Marker area is proportional to model size determined by depth. “basic”(“bottleneck”) refers to ResNets with basic (bottleneck) residual blocks.
+
+# 4 RELATED WORK
+
+Neural Architecture Search (NAS) (Zoph & Le, 2016) and neural evolution (Miikkulainen et al., 2019; Angeline et al., 1994; Stanley & Miikkulainen, 2002; Liu et al., 2017a; Real et al., 2017) can search network architectures from a gigantic search space. In NAS, the depth of DNNs in the search space is fixed, while AutoGrow learns the depth. Some NAS methods (Bender et al., 2018; Liu et al., 2018b; Cortes et al., 2017) can find DNNs with different depths, however, the maximum depth is pre-defined and shallower nets are obtained by padding zero operations or selecting shallower branches, while our AutoGrow learns the depth in an open domain to find a minimum depth, beyond which no accuracy improvement can be obtained. Moreover, NAS is very computation and memory intensive. To accelerate NAS, one-shot models (Saxena & Verbeek, 2016; Pham et al., 2018; Bender et al., 2018), DARTS (Liu et al., 2018b) and NAS with Transferable Cell (Zoph et al., 2018; Liu et al., 2018a) were proposed. The search time reduces dramatically but is still long from practical perspective. It is still very challenging to deploy these methods to larger datasets such as ImageNet. In contrast, our AutoGrow can scale up to ImageNet thanks to its short depth learning time, which is as efficient as training a single DNN.
+
+In addition to architecture search which requires to train lots of DNNs from scratch, there are also many studies on learning neural structures within a single training. Structure pruning and growing were proposed for different goals, such as efficient inference (Wen et al., 2016; Li et al., 2016; Lebedev & Lempitsky, 2016; He et al., 2017; Luo et al., 2017; Liu et al., 2017b; Dai et al., 2017; Huang et al., 2018; Gordon et al., 2018; Du et al., 2019), lifelong learning (Yoon et al., 2017) and model adaptation (Feng & Darrell, 2015; Philipp & Carbonell, 2017). However, those works fixed the network depth and limited structure learning within the existing layers. Optimization over a DNN with fixed depth is easier as the skeleton architecture is known. AutoGrow performs in a scenario where the DNN depth is unknown hence we need to seek for the optimal depth.
+
+# REFERENCES
+
+Peter J Angeline, Gregory M Saunders, and Jordan B Pollack. An evolutionary algorithm that constructs recurrent neural networks. IEEE transactions on Neural Networks, 5(1):54–65, 1994.
+
+Gabriel Bender, Pieter-Jan Kindermans, Barret Zoph, Vijay Vasudevan, and Quoc Le. Understanding and simplifying one-shot architecture search. In International Conference on Machine Learning, pp. 549–558, 2018.
+
+Han Cai, Tianyao Chen, Weinan Zhang, Yong Yu, and Jun Wang. Efficient architecture search by network transformation. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018a.
+
+Han Cai, Jiacheng Yang, Weinan Zhang, Song Han, and Yong Yu. Path-level network transformation for efficient architecture search. arXiv preprint arXiv:1806.02639, 2018b.
+
+Tianqi Chen, Ian Goodfellow, and Jonathon Shlens. Net2net: Accelerating learning via knowledge transfer. arXiv preprint arXiv:1511.05641, 2015.
+
+Corinna Cortes, Xavier Gonzalvo, Vitaly Kuznetsov, Mehryar Mohri, and Scott Yang. Adanet: Adaptive structural learning of artificial neural networks. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 874–883. JMLR. org, 2017.
+
+Xiaoliang Dai, Hongxu Yin, and Niraj K Jha. Nest: A neural network synthesis tool based on a grow-and-prune paradigm. arXiv preprint arXiv:1711.02017, 2017.
+
+Xiaocong Du, Zheng Li, and Yu Cao. Cgap: Continuous growth and pruning for efficient deep learning. arXiv preprint arXiv:1905.11533, 2019.
+
+Thomas Elsken, Jan-Hendrik Metzen, and Frank Hutter. Simple and efficient architecture search for cnns. In Workshop on Meta-Learning (MetaLearn 2017) at NIPS, 2017.
+
+Jiashi Feng and Trevor Darrell. Learning the structure of deep convolutional networks. In Proceedings of the IEEE international conference on computer vision, pp. 2749–2757, 2015.
+
+Ariel Gordon, Elad Eban, Ofir Nachum, Bo Chen, Hao Wu, Tien-Ju Yang, and Edward Choi. Morphnet: Fast & simple resource-constrained structure learning of deep networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1586–1595, 2018.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Yihui He, Xiangyu Zhang, and Jian Sun. Channel pruning for accelerating very deep neural networks. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1389–1397, 2017.
+
+Gao Huang, Zhuang Liu, Laurens Van Der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 4700–4708, 2017.
+
+Gao Huang, Shichen Liu, Laurens Van der Maaten, and Kilian Q Weinberger. Condensenet: An efficient densenet using learned group convolutions. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2752–2761, 2018.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012.
+
+Vadim Lebedev and Victor Lempitsky. Fast convnets using group-wise brain damage. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2554–2564, 2016.
+
+Hao Li, Asim Kadav, Igor Durdanovic, Hanan Samet, and Hans Peter Graf. Pruning filters for efficient convnets. arXiv preprint arXiv:1608.08710, 2016.
+
+Hao Li, Zheng Xu, Gavin Taylor, Christoph Studer, and Tom Goldstein. Visualizing the loss landscape of neural nets. In Advances in Neural Information Processing Systems, pp. 6391–6401, 2018.
+
+Chenxi Liu, Barret Zoph, Maxim Neumann, Jonathon Shlens, Wei Hua, Li-Jia Li, Li Fei-Fei, Alan Yuille, Jonathan Huang, and Kevin Murphy. Progressive neural architecture search. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 19–34, 2018a.
+
+Hanxiao Liu, Karen Simonyan, Oriol Vinyals, Chrisantha Fernando, and Koray Kavukcuoglu. Hierarchical representations for efficient architecture search. arXiv preprint arXiv:1711.00436, 2017a.
+
+Hanxiao Liu, Karen Simonyan, and Yiming Yang. Darts: Differentiable architecture search. arXiv preprint arXiv:1806.09055, 2018b.
+
+Zhuang Liu, Jianguo Li, Zhiqiang Shen, Gao Huang, Shoumeng Yan, and Changshui Zhang. Learning efficient convolutional networks through network slimming. In Proceedings of the IEEE International Conference on Computer Vision, pp. 2736–2744, 2017b.
+
+Jian-Hao Luo, Jianxin Wu, and Weiyao Lin. Thinet: A filter level pruning method for deep neural network compression. In Proceedings of the IEEE international conference on computer vision, pp. 5058–5066, 2017.
+
+Risto Miikkulainen, Jason Liang, Elliot Meyerson, Aditya Rawal, Daniel Fink, Olivier Francon, Bala Raju, Hormoz Shahrzad, Arshak Navruzyan, Nigel Duffy, et al. Evolving deep neural networks. In Artificial Intelligence in the Age of Neural Networks and Brain Computing, pp. 293–312. Elsevier, 2019.
+
+Hieu Pham, Melody Y Guan, Barret Zoph, Quoc V Le, and Jeff Dean. Efficient neural architecture search via parameter sharing. arXiv preprint arXiv:1802.03268, 2018.
+
+George Philipp and Jaime G Carbonell. Nonparametric neural networks. arXiv preprint arXiv:1712.05440, 2017.
+
+Esteban Real, Sherry Moore, Andrew Selle, Saurabh Saxena, Yutaka Leon Suematsu, Jie Tan, Quoc V Le, and Alexey Kurakin. Large-scale evolution of image classifiers. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 2902–2911. JMLR. org, 2017.
+
+Shreyas Saxena and Jakob Verbeek. Convolutional neural fabrics. In Advances in Neural Information Processing Systems, pp. 4053–4061, 2016.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.
+
+Leslie N Smith, Emily M Hand, and Timothy Doster. Gradual dropin of layers to train very deep neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4763–4771, 2016.
+
+Kenneth O Stanley and Risto Miikkulainen. Evolving neural networks through augmenting topologies. Evolutionary computation, 10(2):99–127, 2002.
+
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1–9, 2015.
+
+Guangcong Wang, Xiaohua Xie, Jianhuang Lai, and Jiaxuan Zhuo. Deep growing learning. In Proceedings of the IEEE International Conference on Computer Vision, pp. 2812–2820, 2017.
+
+Tao Wei, Changhu Wang, Yong Rui, and Chang Wen Chen. Network morphism. In International Conference on Machine Learning, pp. 564–572, 2016.
+
+Tao Wei, Changhu Wang, and Chang Wen Chen. Modularized morphing of neural networks. arXiv preprint arXiv:1701.03281, 2017.
+
+Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. In Advances in neural information processing systems, pp. 2074–2082, 2016.
+
+Jaehong Yoon, Eunho Yang, Jeongtae Lee, and Sung Ju Hwang. Lifelong learning with dynamically expandable networks. arXiv preprint arXiv:1708.01547, 2017.
+
+Barret Zoph and Quoc V Le. Neural architecture search with reinforcement learning. arXiv preprint arXiv:1611.01578, 2016.
+
+Barret Zoph, Vijay Vasudevan, Jonathon Shlens, and Quoc V Le. Learning transferable architectures for scalable image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 8697–8710, 2018.
+
+# A APPENDIX
+
+# A.0.1 OPTIMIZATION TRAJECTORIES OF NETWORK MORPHISM
+
+We hypothesize that a converged shallower net may not be an adequate initialization. Figure 5 visualizes and compares the optimization trajectories of Network Morphism and the training from scratch. In this figure, the shallower net is $\mathtt { B a s i c 3 R e s N e t - 3 - 3 - 3 }$ (ResNet-20) and the deeper one is $\mathtt { B a s i c 3 R e s N e t - 5 - 5 - 5 }$ (ResNet-32) in Table 2. The initializer is ZeroInit. The visualization method is extended from Li et al. (2018). Points on the trajectory are evenly sampled every a few epochs. To maximize the variance of trajectory, we use PCA to project from a high dimensional space to a 2D space and use the first two Principle Components (PC) to form the axes in Figure 5. The contours of training loss function and the trajectory are visualized around the final minimum of the deeper net. When projecting a shallower net to a deeper net space, zeros are padded for the parameters not existing in the deeper net. We must note that the loss increase along the trajectory does not truly represent the situation in high dimensional space, as the trajectory is just a projection. It is possible that the loss remains decreasing in the high dimension while it appears in an opposite way in the 2D space. The sharp detour at “Morphing” in Figure 5(a) may indicate that the shallower net plausibly converges to a point that the deeper net struggles to escape. In contrast, Figure 5(b) shows that the trajectory of the direct optimization in the deeper space smoothly converges to a better minimum.
+
+Figure 6(a) visualizes the trajectory of $c$ -AutoGrow corresponding to row $^ { 6 6 } 2 - 3 - 6 ^ { 3 3 }$ in Table 3. Along the trajectory, there are many trials to detour and escape an initialization from a shallower net. Figure 6(b) visualizes the trajectory corresponding to row $^ { 6 6 } 2 - 4 - 3 ^ { 5 }$ in Table 3, which is much smoother compared to Figure 6(a). Figure 6(c)(d) visualize the trajectories of $p$ -AutoGrow with $K = 5 0$ and 3. The 2D projection gives limited information to reveal the advantages of $p$ -AutoGrow comparing to $c$ -AutoGrow in Figure 6(b), although the trajectory of our final $p$ -AutoGrow in Figure 6(d) is plausibly more similar to the one of training from scratch in Figure 5(b).
+
+![](images/7ec45dcda0e4eec27bfa06e165883796dfd3195ad9dd58aa345219a511289cad.jpg)  
+Figure 5: An optimization trajectory comparison between (a) Network Morphism and (b) training from scratch.
+
+![](images/202e978119acb59297fd26c27e8b39d29c725967d74a077abfd3cc74d2f35679.jpg)  
+Figure 6: Optimization trajectory of AutoGrow, tested by Basic3ResNet on CIFAR10. (a) $c$ -AutoGrow with staircase learning rate and ZeroInit during growing; (b) $c$ -AutoGrow with constant learning rate and GauInit during growing; (c) $p$ -AutoGrow with $K = 5 0$ ; and (d) $p$ - AutoGrow with $K = 3$ . For better illustration, the dots on the trajectory are plotted every 4, 20, 5 and 3 epochs in (a-d), respectively.
+
+![](images/5bb68bf43dfb0e6d077a75dac2d1c40a1628ddbdaa60cb6364875f9789fd1ae1.jpg)  
+Figure 7: Loss surfaces around minima found by baselines and AutoGrow. Dataset is CIFAR10.
+
+# A.0.2 VISUALIZATION OF LOSS SURFACES AROUND MINIMA
+
+Figure 7 visualizes loss surfaces around minima by AutoGrow and baseline. Intuitively, AutoGrow finds wider or deeper minima with less chaotic landscapes.
+
+# A.0.3 MORE EXPERIMENTAL RESULTS
+
+Figure 8 plots the growing and converging curves for two DNNs in Table 10.
+
+Table 11 summarizes the adaptability of AutoGrow to the sizes of dataset. In each set of experiments, dataset is randomly down-sampled to $1 0 0 \%$ , $7 5 \%$ , $5 0 \%$ and $2 5 \%$ . For a fair comparison, $K$ is divided by the percentage of dataset such that the number of mini-batches between growths remains
+
+Table 8: $p$ -AutoGrow under initializers with $K = 3$   
+
+<table><tr><td colspan="2">CIFAR10</td><td rowspan="2">accu</td></tr><tr><td>initializer</td><td>found nett</td></tr><tr><td>ZeroInit</td><td>31-30-30</td><td>93.57</td></tr><tr><td>AdamInit</td><td>37-37-36</td><td>93.79</td></tr><tr><td>UniInit</td><td>28-28-28</td><td>93.82</td></tr><tr><td>GauInit</td><td>42-42-42</td><td>94.27</td></tr></table>
+
+† Basic3ResNet
+
+<table><tr><td colspan="3">CIFAR100</td></tr><tr><td>initializer</td><td>found nett</td><td>accu</td></tr><tr><td>ZeroInit</td><td>26-25-25</td><td>73.45</td></tr><tr><td>AdamInit</td><td>27-27-27</td><td>73.92</td></tr><tr><td>UniInit</td><td>41-41-41</td><td>74.31</td></tr><tr><td>GauInit</td><td>54-53-53</td><td>74.72</td></tr></table>
+
+† Basic3ResNet
+
+Table 9: AutoGrow improves accuracy of plain nets.   
+
+<table><tr><td colspan="2">dataset</td><td>net layer #</td><td>method</td><td> accu %</td></tr><tr><td rowspan="3">CIFAR10</td><td>Plain4Net-6-6-6-6</td><td>26</td><td>baseline</td><td>93.90</td></tr><tr><td>Plain4Net-6-6-6-6</td><td>26</td><td>AutoGrow K=30</td><td>95.17</td></tr><tr><td>Basic4ResNet-3-3-3-3</td><td>26</td><td>baseline</td><td>95.33</td></tr><tr><td rowspan="3">CIFAR10</td><td>Plain3Net-11-11-10</td><td>34</td><td>baseline</td><td>90.45</td></tr><tr><td>Plain3Net-11-11-10</td><td>34</td><td>AutoGrow K=50</td><td>93.13</td></tr><tr><td>Basic3ResNet-6-6-5</td><td>36</td><td>baseline</td><td>93.60</td></tr></table>
+
+Table 10: The efficiency of AutoGrow   
+
+<table><tr><td>net</td><td>GPUs</td><td>growing</td><td>fine-tuning</td></tr><tr><td>Basic4ResNet-12-12-11-11</td><td>4 GTX 1080 Ti</td><td>56.7 hours</td><td>157.9 hours</td></tr><tr><td>Basic4ResNet-9-3-6-4</td><td>4 GTX1080</td><td>47.9 hours</td><td>65.8 hours</td></tr><tr><td>Bottleneck4ResNet-6-6-6-17</td><td>4 TITAN V</td><td>45.3 hours</td><td>114.0 hours</td></tr><tr><td>Bottleneck4ResNet-6-7-3-9</td><td>4 TITAN V</td><td>61.6 hours</td><td>78.6 hours</td></tr><tr><td>Plain4Net-6-6-6-6</td><td>4 GTX 1080 Ti</td><td>11.7 hours</td><td>29.7 hours</td></tr><tr><td>Plain4Net-5-5-5-4</td><td>4 GTX 1080 Ti</td><td>25.6 hours</td><td>25.3 hours</td></tr></table>
+
+![](images/dcc4991c910983ddaab0d84913d1e1d63d3049b45ccade319b8e6be7bdb7f183.jpg)
+
+![](images/ff8de4cc3b0f11d571a7eff70a0eaf2908e5f3266d7d32a7c51b6d9bcc87ec95.jpg)
+
+Table 11: The adaptability of AutoGrow to dataset sizes   
+
+<table><tr><td colspan="2">Basic3ResNet on CIFAR10</td></tr><tr><td>dataset size</td><td>found net accu %</td></tr><tr><td>100%</td><td>42-42-42 94.27</td></tr><tr><td>75%</td><td>32-31-31 93.54</td></tr><tr><td>50%</td><td>17-17-17 91.34</td></tr><tr><td>25%</td><td>21-12-7 88.18</td></tr><tr><td>Basic4ResNet on CIFAR100</td><td></td></tr><tr><td>dataset size found net</td><td> accu %</td></tr><tr><td>100%</td><td>17-51-16-16 79.47</td></tr><tr><td>75% 17-17-16-16</td><td>77.26</td></tr><tr><td>50% 12-12-12-11</td><td>72.91</td></tr><tr><td>25%</td><td>6-6-6-6 62.53</td></tr></table>
+
+Figure 8: The convergence curves and growing process on ImageNet for (a) Basic4ResNet-9-3-6-4 and (b) Plain4Net-6-6-6-6 in Table 10.
+
+<table><tr><td colspan="2">Plain3Net on MNIST</td></tr><tr><td>dataset size</td><td>found net accu %</td></tr><tr><td>100%</td><td>20-20-20 99.66</td></tr><tr><td>75%</td><td>12-12-12 99.54</td></tr><tr><td>50%</td><td>12-11-11 99.46</td></tr><tr><td>25%</td><td>10-9-9 99.33</td></tr><tr><td colspan="2">Plain4Net on SVHN</td></tr><tr><td>dataset size</td><td>found net accu %</td></tr><tr><td>100%</td><td>12-12-12-11 97.08</td></tr><tr><td>75%</td><td>9-9-9-9 96.71</td></tr><tr><td>50% 8-8-8-8</td><td>96.37 95.68</td></tr><tr><td>25%</td><td>5-5-5-5</td></tr></table>
+
+the same. As expected, our experiments show that AutoGrow adapts to shallower networks when the sizes are smaller.

parse/train/S1x0CnEtvB/S1x0CnEtvB_content_list.json

@@ -0,0 +1,1591 @@
+[
+    {
+        "type": "text",
+        "text": "AutoGrow: AUTOMATIC LAYER GROWING IN DEEPCONVOLUTIONAL NETWORKS",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "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. ",
+        "bbox": [
+            232,
+            266,
+            764,
+            433
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            460,
+            336,
+            477
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "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 $5 6 \\times 5 6 .$ , $2 8 \\times 2 8$ , $1 4 \\times 1 4$ and $7 \\times 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. ",
+        "bbox": [
+            174,
+            492,
+            825,
+            686
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "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 (Wei et al., 2016; 2017; 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. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            819
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "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. ",
+        "bbox": [
+            173,
+            825,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "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. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/72e33b5122b717c13c9dc77bce7ee8b88fa746ca183412e7a3b8ecb0c8f45468.jpg",
+        "image_caption": [
+            "Figure 1: A simple example of AutoGrow. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            138,
+            501,
+            248
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/df2cdd86fe91d57f5ab9bb97641a6b0c39a8a6c5abdd1afe4ca580c9c69b697d.jpg",
+        "table_caption": [
+            "Table 1: Comparison with previous works about layer growth. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Previous works</td><td>Ours</td></tr><tr><td>Goal</td><td>Ease training</td><td>Depth automation</td></tr><tr><td>Times</td><td>Once or a few</td><td>Unlimited</td></tr><tr><td>Locations</td><td>Human defined</td><td>Learned</td></tr><tr><td>Layer #</td><td>Human defined</td><td>Learned</td></tr></table>",
+        "bbox": [
+            532,
+            150,
+            821,
+            223
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our contributions are: (1) We propose AutoGrow to automate DNN layer growing and depth discovery. AutoGrow is very robust. With the same hyper-parameters, it adapts network depth to various datasets including MNIST, FashionMNIST, SVHN, CIFAR10, CIFAR100 and ImageNet. Moreover, AutoGrow can also discover shallower DNNs when the dataset is a subset. (2) AutoGrow demonstrates high efficiency and scales up to ImageNet, because the layer growing is as fast as training a single DNN. On ImageNet, it discovers a new ResNets with better trade-off between accuracy and computation complexity. (3) We challenge the idea of Network Morphism, as random initialization works equally or better when growing layers. (4) We find that it is beneficial to rapidly grow layers before a shallower net converge, contradicting previous intuition. ",
+        "bbox": [
+            173,
+            280,
+            825,
+            405
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 AutoGrow – A DEPTH GROWING ALGORITHM ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            425,
+            583,
+            441
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 AutoGrow Algorithm. ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            455,
+            406,
+            469
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/e7209b24a99a73964f399e911a453f4a602e8d31ef04219a317e7a5047c6e827.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            158,
+            473,
+            759,
+            767
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Figure 1 gives an overview of the proposed AutoGrow. In this paper, we use network, sub-networks, sub-modules and layers to describe the architecture hierarchy. A network is composed of a cascade of sub-networks. A sub-network is composed of sub-modules, which typical share the same output size. A sub-module (e.g. a residual block) is an elementary growing block composed of one or a few layers. In this section, we rigorously formulate a generic version of AutoGrow which will be materialized in subsections. A deep convolutional network $g ( \\mathcal { X } _ { 0 } )$ is a cascade of sub-networks by composing functions as $g ( \\mathcal { X } _ { 0 } ) = l \\bar { ( } f _ { M - 1 } ( \\pmb { f } _ { M - 2 } ( \\cdot \\cdot \\cdot f _ { 1 } ( \\pmb { f } _ { 0 } ( \\mathcal { X } _ { 0 } ) ) \\cdot \\cdot \\cdot \\cdot ) ) ) .$ ), where $\\mathcal { X } _ { 0 }$ is an input image, $M$ is the number of sub-networks, $l ( \\cdot )$ is a loss function, and $\\mathscr { X } _ { i + 1 } = f _ { i } \\left( \\mathscr { X } _ { i } \\right)$ is a sub-network that operates on an input image or a feature tensor $\\mathcal { X } _ { i } \\in \\mathbb { R } ^ { c _ { i } \\times h _ { i } \\times w _ { i } }$ . Here, $c _ { i }$ is the number of channels, and $h _ { i }$ and $w _ { i }$ are spatial dimensions. $f _ { i } \\left( \\mathcal { X } _ { i } \\right)$ is a simplified notation of $\\pmb { f } _ { i } \\left( \\mathcal { X } _ { i } ; \\mathbb { W } _ { i } \\right)$ , where $\\mathbb { W } _ { i }$ is a set of sub-modules’ parameters within the $i$ -th sub-network. Thus $\\mathbb { W } = \\{ \\mathbb { W } _ { i } : i = 0 \\dots M - 1 \\}$ denotes the whole set of parameters in the DNN. To facilitate growing, the following properties are supported within a sub-network: (1) the first sub-module usually reduces the size of input feature maps, e.g., using pooling or convolution with a stride; and (2) all sub-modules in a sub-network maintain the same output size. As such, our framework can support popular networks, including VggNet-like plain networks (Simonyan & Zisserman, 2014), GoogLeNet (Szegedy et al., 2015), ResNets (He et al., 2016) and DenseNets (Huang et al., 2017). In this paper, we select ResNets and VggNet-like nets as representatives of DNNs with and without shortcuts, respectively. ",
+        "bbox": [
+            173,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "With above notations, Algorithm 1 rigorously describes the AutoGrow algorithm. In brief, AutoGrow starts with the shallowest net where every sub-network has only one sub-module for spatial dimension reduction. AutoGrow loops over all growing sub-networks in order. For each sub-network, AutoGrow stacks a new sub-module. When the new sub-module does not improve the accuracy, the growth in corresponding sub-network will be permanently stopped. The details of our method will be materialized in the following subsections. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            305
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 SEED SHALLOW NETWORKS AND SUB-MODULES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            325,
+            555,
+            340
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this paper, in all datasets except ImageNet, we explore growing depth for four types of DNNs: (1) Basic3ResNet: the same ResNet used for CIFAR10 in He et al. (2016), which has 3 residual subnetworks with output spatial sizes of $3 2 \\times 3 2$ , $1 6 \\times 1 6$ and $8 \\times 8$ , respectively; (2) Basic4ResNet: a variant of ResNet used for ImageNet in He et al. (2016) built by basic residual blocks (each of which contains two convolutions and one shortcut). There are 4 sub-networks with output spatial sizes of $3 2 \\times 3 2$ , $1 6 \\times 1 6$ , $8 \\times 8$ and $4 \\times 4$ , respectively; (3) Plain3Net: a VggNet-like plain net by removing shortcuts in Basic3ResNet; (4) Plain4Net: a VggNet-like plain net by removing shortcuts in Basic4ResNet. ",
+        "bbox": [
+            174,
+            353,
+            825,
+            464
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In AutoGrow, the architectures of seed shallow networks and sub-modules are pre-defined. In plain DNNs, a sub-module is a stack of convolution, Batch Normalization and ReLU; in residual DNNs, a sub-module is a residual block. In AutoGrow, a sub-network is a stack of all sub-modules with the same output spatial size. Unlike He et al. (2016) which manually designed the depth, AutoGrow starts from a seed architecture in which each sub-network has only one sub-module and automatically learns the number of sub-modules. ",
+        "bbox": [
+            174,
+            472,
+            825,
+            555
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "On ImageNet, we apply the same backbones in He et al. (2016) as the seed architectures. A seed architecture has only one sub-module under each output spatial size. For a ResNet using basic residual blocks or bottleneck residual blocks (He et al., 2016), we respectively name it as Basic4ResNet or Bottleneck4ResNet. Plain4Net is also obtained by removing shortcuts in Basic4ResNet. ",
+        "bbox": [
+            174,
+            563,
+            825,
+            632
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 SUB-MODULE INITIALIZERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            654,
+            410,
+            667
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here we explain how to initialize a new sub-module $\\mathcal { W }$ in initializer $( \\mathcal { W } )$ mentioned in Algorithm 1. Network Morphism changes DNN architecture meanwhile preserving the loss function via special initialization of new layers, that is, $g ( \\mathcal { X } _ { 0 } ; \\mathbb { W } ) = g ( \\mathcal { X } _ { 0 } ; \\mathbb { W } \\cup \\mathcal { W } ) \\ \\forall \\mathcal { X } _ { 0 }$ . A residual sub-module shows a nice property: when stacking a residual block and initializing the last Batch Normalization layer as zeros, the function of the shallower net is preserved but the DNN is morphed to a deeper net. Thus, Network Morphism can be easily implemented by this zero initialization (ZeroInit). ",
+        "bbox": [
+            174,
+            680,
+            825,
+            763
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this work, all layers in $\\mathcal { W }$ are initialized using default randomization, except for a special treatment of the last Batch Normalization layer in a residual sub-module. Besides ZeroInit, we propose a new AdamInit for Network Morphism. In AdamInit, we freeze all parameters except the last Batch Normalization layer in $\\mathcal { W }$ , and then use Adam optimizer (Kingma & Ba, 2014) to optimize the last Bath Normalization for maximum 10 epochs till the training accuracy of the deeper net is as good as the shallower one. After AdamInit, all parameters are jointly optimized. We view AdamInit as a Network Morphism because the training loss is similar after AdamInit. We empirically find that AdamInit can usually find a solution in less than 3 epochs. We also study random initialization of the last Batch Normalization layer using uniform (UniInit) or Gaussian (GauInit) noises with a standard deviation 1.0. We will show that GauInit obtains the best result, challenging the idea of Network Morphism (Wei et al., 2016; 2017; Chen et al., 2015). ",
+        "bbox": [
+            174,
+            770,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 GROWING AND STOPPING POLICIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            462,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In Algorithm 1, a growing policy refers to meetGrowingPolicy(), which returns true when the network should grow a sub-module. Two growing policies are studied here: ",
+        "bbox": [
+            176,
+            137,
+            823,
+            165
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1. Convergent Growth: meetGrowingPolicy() returns true when the improvement of validation accuracy is less than $\\tau$ in the last $K$ epochs. That is, in Convergent Growth, AutoGrow only grows when current network has converged. This is a similar growing criterion adopted in previous works (Elsken et al., 2017; Cai et al., 2018a;b).   \n2. Periodic Growth: meetGrowingPolicy() always returns true, that is, the network always grows every $K$ epochs. Therefore, $K$ is also the growing period. In the best practice of AutoGrow, $K$ is small (e.g. $K = 3$ ) such that it grows before current network converges. ",
+        "bbox": [
+            212,
+            185,
+            825,
+            287
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our experiments will show that Periodic Growth outperforms Convergent Growth. We hypothesize that a fully converged shallower net is an inadequate initialization to train a deeper net. We will perform experiments to test this hypothesis and visualize optimization trajectory to illustrate it. ",
+        "bbox": [
+            176,
+            306,
+            825,
+            349
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A stopping policy denotes meetStoppingPolicy() in Algorithm 1. When Convergent Growth is adopted, meetStoppingPolicy() returns true if a recent growth does not improve validation accuracy more than $\\tau$ within $K$ epochs. We use a similar stopping policy for Periodic Growth; however, as it can grow rapidly with a small period $K$ (e.g. $K \\ : = \\ : 3 ,$ ) before it converges, we use a larger window size $J$ for stop. Specifically, when Periodic Growth is adopted, meetStoppingPolicy() returns true when the validation accuracy improves less than $\\tau$ in the last $J$ epochs, where $J \\gg K$ . ",
+        "bbox": [
+            173,
+            356,
+            825,
+            453
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Hyper-parameters $\\tau$ , $J$ and $K$ control the operation of AutoGrow and can be easily setup and generalize well. $\\tau$ denotes the significance of accuracy improvement for classification. We simply set $\\tau = 0 . 0 5 \\%$ in all experiments. $J$ represents how many epochs to wait for an accuracy improvement before stopping the growth of a sub-network. It is more meaningful to consider stopping when the new net is trained to some extent. As such, we set $J$ to the number of epochs $T$ under the largest learning rate when training a baseline. $K$ means how frequently AutoGrow checks the polices. In Convergent Growth, we simply set $K = T$ , which is long enough to ensure convergence. In Periodic Growth, $K$ is set to a small fraction of $T$ to enable fast growth before convergence; more importantly, $K = 3$ is very robust to all networks and datasets. Therefore, all those hyper-parameters are very robust and strongly correlated to design considerations. ",
+        "bbox": [
+            173,
+            460,
+            825,
+            599
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            637,
+            326,
+            654
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we use Basic3ResNet-2-3-2, for instance, to denote a model architecture which contains 2, 3 and 2 sub-modules in the first, second and third sub-networks, respectively. Sometimes we simplify it as $2 - 3 - 2$ for convenience. AutoGrow always starts from the shallowest depth of $1 - 1 - 1$ and uses the maximum validation accuracy as the metric to guide growing and stopping. All DNN baselines are trained by SGD with momentum 0.9 using staircase learning rate. The initial learning rate is 0.1 in ResNets and 0.01 in plain networks. On ImageNet, baselines are trained using batch size 256 for 90 epochs, within which learning rate is decayed by $0 . 1 \\times$ at epoch 30 and 60. In all other smaller datasets, baselines are trained using batch size 128 for 200 epochs and learning rate is decayed by $0 . 1 \\times$ at epoch 100 and 150. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            805
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our early experiments followed prior wisdom by growing layers with Network Morphism (Wei et al., 2016; 2017; Chen et al., 2015; Elsken et al., 2017; Cai et al., 2018a;b), i.e., AutoGrow with ZeroInit (or AdamInit) and Convergent Growth policy; however, it stopped early with very shallow DNNs, failing to find optimal depth. We hypothesize that a converged shallow net with Network Morphism gives a bad initialization to train a deeper neural network. Section 3.1 experimentally test that the hypothesis is valid. To tackle this issue, we intentionally avoid convergence during growing by three simple solutions, which are evaluated in Section 3.2. Finally, Section 3.3 and Section 3.4 include extensive experiments to show the effectiveness of our final AutoGrow. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 SUBOPTIMUM OF NETWORK MORPHISM AND CONVERGENT GROWTH ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            697,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we study Network Morphism itself and its integration into our AutoGrow under Convergent Growth. When studying Network Morphism, we take the following steps: 1) train a shallower ResNet to converge, 2) stack residual blocks on top of each sub-network to morph to a deeper net, 3) use ZeroInit or AdamInit to initialize new layers, and 4) train the deeper net in a standard way. We compare the accuracy difference $( ^ { 6 6 } \\Delta ^ { , 3 } )$ between Network Morphism and training the deeper net from scratch. Table 2 summaries our results. Network Morphism has a lower accuracy (negative “ $\\cdot \\Delta ^ { \\prime \\prime }$ ) in all the cases, which validates our hypothesis that a converged shallow network with Network Morphism gives a bad initialization to train a deeper net. We visualize the optimization trajectories in Appendix A.0.1 to illustrate the hypothesis. ",
+        "bbox": [
+            174,
+            130,
+            825,
+            256
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To further validate our hypothesis, we integrate Network Morphism as the initializer in AutoGrow with Convergent Growth policy. We refer to this version of AutoGrow as $c$ -AutoGrow with “ $_ { \\mathrm { ~ \\tiny ~ c ~ } }$ -” denoting “Convergent.” More specific, we take ZeroInit or AdamInit as sub-module initializer and “Convergent Growth” policy in Algorithm 1. To recap, in this setting, AutoGrow trains a shallower net till it converges, then grows a sub-module which is initialized by Network Morphism, and repeats the same process till there is no further accuracy improvement. In every interval of $K$ training epochs (train $( g ( \\mathcal { X } _ { 0 } ) , K )$ in Algorithm 1), “staircase” learning rate is used. The learning rate is reset to 0.1 at the first epoch, and decayed by $0 . 1 \\times$ at epoch $\\frac { K } { 2 }$ and $\\frac { 3 K } { 4 }$ . The results are shown in Table 3 by “staircase” rows, which illustrate that $c$ -AutoGrow can grow a DNN multiple times and finally find a depth. However, there are two problems: 1) the final accuracy is lower than training the found net from scratch, as indicated by $^ { 6 6 } \\Delta ^ { , 9 }$ , validating our hypothesis; 2) the depth learning stops too early with a relatively shallower net, while a deeper net beyond the found depth can achieve a higher accuracy as we will show in Table 6. These problems provide a circumstantial evidence of the hypothesis that a converged shallow net with Network Morphism gives a bad initialization. Thus, AutoGrow cannot receive signals to continue growing after a limited number of growths. In Appendix A.0.1, Figure 6(a) visualizes the trajectory of $c$ -AutoGrow corresponding to row $^ { 6 6 } 2 - 3 - 6 ^ { 3 3 }$ in Table 3. ",
+        "bbox": [
+            174,
+            262,
+            825,
+            500
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 ABLATION STUDY FOR AutoGrow DESIGN ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            518,
+            504,
+            534
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Based on the findings in Section 3.1, we propose three simple but effective solutions to further enhance AutoGrow and refer it as $p$ -AutoGrow, with $\\mathbf { \\dot { \\rho } } _ { p }$ -” denoting “Periodic”: (1) Use a large constant learning rate for growing, i.e., 0.1 for residual networks and 0.01 for plain networks. Stochastic gradient descent with a large learning rate intrinsically introduces noises, which help to avoid a full convergence into a bad initialization from a shallower net. Note that staircase learning rate is still used for fine-tuning after discovering the final DNN; (2) Use random initialization (UniInit or GauInit) as noises to escape from an inadequate initialization; (3) Grow rapidly before a shallower net converges by taking Periodic Growth with a small $K$ . ",
+        "bbox": [
+            174,
+            545,
+            825,
+            656
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$p$ -AutoGrow is our final AutoGrow. In the rest part of this section, we perform ablation study to prove that the three solutions are effective. We start from $c$ -AutoGrow, and incrementally add above solutions one by one and eventually obtain $p$ -AutoGrow. In Table 3, first, we replace the staircase learning rate with a constant learning rate, the accuracy of AutoGrow improves and therefore $^ { 6 6 } \\Delta ^ { , 9 }$ improves; second, we further replace Network Morphism (ZeroInit or AdamInit) with a random initializer (UniInit or GauInit) and result in a bigger gain. Overall, combining a constant learning rate with GauInit performs the best. Thus, constant learning rate and GauInit are adopted in the remaining experiments, unless we explicitly specify them. ",
+        "bbox": [
+            174,
+            664,
+            825,
+            776
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/9f8ff78bb36c18c2a0c60f474ad907b320332a6691dcf56f9e7e5a363884d101.jpg",
+        "table_caption": [
+            "Table 2: Network Morphism tested on CIFAR10. "
+        ],
+        "table_footnote": [
+            "∗ $\\overline { { \\Delta = } }$ (accuracy of Network Morphism) − (accuracy of training from scratch) "
+        ],
+        "table_body": "<table><tr><td>net backbone</td><td>shallower</td><td>deeper</td><td>initializer</td><td>accu %</td><td>*</td></tr><tr><td>Basic3ResNet</td><td>3-3-3</td><td>5-5-5</td><td>ZeroInit AdamInit</td><td>92.71 92.82</td><td>-0.77</td></tr><tr><td rowspan=\"2\">Basic3ResNet</td><td rowspan=\"2\">5-5-5</td><td rowspan=\"2\">9-9-9</td><td></td><td></td><td>-0.66</td></tr><tr><td>ZeroInit</td><td>93.64</td><td>-0.27 -0.38</td></tr><tr><td rowspan=\"2\">Basic4ResNet</td><td rowspan=\"2\">1-1-1-1</td><td rowspan=\"2\">2-2-2-2</td><td>AdamInit</td><td>93.53 94.96</td><td></td></tr><tr><td>ZeroInit AdamInit</td><td>95.17</td><td>-0.37 -0.16</td></tr></table>",
+        "bbox": [
+            272,
+            814,
+            722,
+            917
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/21c95041da48ea2317c08bd28861ab4d467bfea18dbb37a4a113b38ff9a9e63d.jpg",
+        "table_caption": [
+            "Table 3: Ablation study of $c$ -AutoGrow. "
+        ],
+        "table_footnote": [
+            "† Basic3ResNet ",
+            "∗ ∆ = (accuracy of c-AutoGrow) − (accuracy of training from scratch) "
+        ],
+        "table_body": "<table><tr><td>dataset</td><td>learning rate</td><td>initializer</td><td>found net†</td><td>accu %</td><td>△*</td><td>dataset</td><td>learning rate</td><td>initializer</td><td>found net</td><td>accu %</td><td>△*</td></tr><tr><td rowspan=\"6\">CIFAR10</td><td>staircase</td><td>ZeroInit</td><td>2-3-6</td><td>91.77</td><td>-1.06</td><td rowspan=\"6\"></td><td>staircase</td><td>ZeroInit</td><td>4-3-4</td><td>70.04</td><td>-0.65</td></tr><tr><td>staircase</td><td>AdamInit</td><td>3-4-3</td><td>92.21 -0.59</td><td></td><td>staircase</td><td>AdamInit</td><td>3-3-3</td><td>69.85</td><td>-0.65</td></tr><tr><td>constant</td><td>ZeroInit</td><td>2-2-4</td><td>92.23</td><td>0.16</td><td>CIFAR100 constant</td><td>ZeroInit</td><td>3-2-4</td><td>70.22</td><td>0.35</td></tr><tr><td>constant</td><td>AdamInit</td><td>3-4-4</td><td>92.60</td><td>-0.41</td><td>constant</td><td>AdamInit</td><td>3-3-3</td><td>70.00</td><td>-0.50</td></tr><tr><td>constant</td><td>UniInit</td><td>3-4-4</td><td>92.93</td><td>-0.08</td><td>constant</td><td>UniInit</td><td>4-4-3</td><td>70.39</td><td>0.36</td></tr><tr><td>constant</td><td>GauInit</td><td>2-4-3</td><td>93.12</td><td>0.55</td><td>constant</td><td>GauInit</td><td>3-4-3</td><td>70.66</td><td>0.91</td></tr></table>",
+        "bbox": [
+            176,
+            103,
+            821,
+            190
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Note that, in this paper, we are more interested in automating depth discovery to find a final DNN (“found net”) with a high accuracy (“accu”). Ideally, the “found net” has a minimum depth, a larger depth than which cannot further improve “accu”. We will show in Figure 3 that AutoGrow discovers a depth approximately satisfying this property. The “ $\\Delta ^ { \\prime \\prime }$ is a metric to indicate how well shallower nets initialize deeper nets; a negative $^ { 6 6 } \\Delta ^ { , 9 }$ indicates that weight initialization from a shallower net hurts training of a deeper net; while a positive “ $\\cdot \\Delta ^ { \\prime \\prime }$ indicates AutoGrow helps training a deeper net, which is a byproduct of this work. ",
+        "bbox": [
+            174,
+            215,
+            825,
+            311
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Finally, we apply the last solution – Periodic Growth, and obtain our final $p$ -AutoGrow. Our ablation study results for $p$ -AutoGrow are summarized in Table 5 and Table 4. Table 5 analyzes the impact of the growing period $K$ . In general, $K$ is a hyper-parameter to trade off speed and accuracy: a smaller $K$ takes a longer learning time but discovers a deeper net, vice versa. Our results validate the preference of a faster growth (i.e. a smaller $K$ ). On CIFAR10/CIFAR100, the accuracy reaches plateau/peak at $K = 3$ ; further reducing $K$ produces a deeper net while the accuracy gain is marginal/impossible. In the following, we simply select $K = 3$ for robustness test. More importantly, our quantitative results in Table 5 show that $p$ -AutoGrow finds much deeper nets, overcoming the very-early stop issue in $c$ -AutoGrow in Table 3. That is, Periodic Growth proposed in this work is much more effective than Convergent Growth utilized in previous work. ",
+        "bbox": [
+            173,
+            318,
+            825,
+            458
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For sanity check, we perform the ablation study of initializers for $p$ -AutoGrow. The results are in Table 8 in Appendix A.0.3, which further validates our wisdom on selecting GauInit. The motivation of Network Morphism in previous work was to start a deeper net from a loss function that has been well optimized by a shallower net, so as not to restart the deeper net training from scratch (Wei et al., 2016; 2017; Chen et al., 2015; Elsken et al., 2017; Cai et al., 2018a;b). In all our experiments, we find this is sure even with random initialization. Figure 2 plots the convergence curves and learning process for $^ {  } 4 2 - 4 2 - 4 2 ^ { \\circ }$ in Table 5. Even with GauInit, the loss and accuracy rapidly recover and no restart is observed. The convergence pattern in the “Growing” stage is similar to the “Fine-tuning” stage under the same learning rate (the initial learning rate 0.1). Similar results on ImageNet will be shown in Figure 8. Our results challenge the necessity of Network Morphism when growing neural networks. ",
+        "bbox": [
+            174,
+            464,
+            825,
+            617
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "At last, we perform the ablation study on the initial depth of the seed network. Table 4 demonstrates that a shallowest DNN works as well as a deeper seed. This implies that AutoGrow can appropriately stop regardless of the depth of the seed network. As the focus of this work is on depth automation, we prefer starting with the shallowest seed to avoid a manual search of a seed depth. ",
+        "bbox": [
+            173,
+            625,
+            825,
+            680
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/7115fdf5652ea828e3ef817a308ac1719c82c992743edae687ce89c8bbfe3a43.jpg",
+        "image_caption": [
+            "Figure 2: $p$ -AutoGrow on CIFAR10 $\\ K \\ : = \\ : 3 ,$ . The seed net is Basic3ResNet $- 1 - 1 - 1$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            688,
+            493,
+            784
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/066e1cdae6d8307c170b192455cb4e615cfc225649076b7f7be175c9246b9748.jpg",
+        "table_caption": [
+            "Table 4: $p$ -AutoGrow with different seed architecture. "
+        ],
+        "table_footnote": [
+            "† Basic3ResNet or Basic4ResNet. "
+        ],
+        "table_body": "<table><tr><td>dataset</td><td>seed net</td><td>found net†</td><td>accuracy %</td></tr><tr><td rowspan=\"2\">CIFAR10</td><td>1-1-1</td><td>42-42-42</td><td>94.27</td></tr><tr><td>5-5-5</td><td>46-46-46</td><td>94.16</td></tr><tr><td rowspan=\"2\">CIFAR10</td><td>1-1-1-1</td><td>22-22-22-22</td><td>95.49</td></tr><tr><td>5-5-5-5</td><td>23-22-22-22</td><td>95.62</td></tr></table>",
+        "bbox": [
+            506,
+            691,
+            821,
+            765
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 ADAPTABILITY OF AutoGrow ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            842,
+            415,
+            854
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To verify the adaptability of AutoGrow, we use an identical configuration $\\dot { p }$ -AutoGrow with $K = 3$ ) and test over 5 datasets and 4 seed architectures. Table 6 includes the results of all 20 combinations. Figure 3 compares AutoGrow with manual search which is obtained by training many DNNs with different depths from scratch. The results lead to the following conclusions and contributions: ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/c8c99291a445335cd91c57491f641cc6b781620f59c713fdb244b079abe007fb.jpg",
+        "table_caption": [
+            "Table 5: $p$ -AutoGrow with different growing interval $K$ . "
+        ],
+        "table_footnote": [
+            "† Basic3ResNet ",
+            "† Basic3ResNet "
+        ],
+        "table_body": "<table><tr><td rowspan=\"2\">K</td><td colspan=\"2\">CIFAR10</td><td colspan=\"3\">CIFAR100</td></tr><tr><td>found net</td><td>accu %</td><td>K</td><td>found net</td><td>accu %</td></tr><tr><td>50</td><td>6-5-3</td><td>92.95</td><td>50</td><td>8-5-7</td><td>72.07</td></tr><tr><td>20</td><td>7-7-7</td><td>93.26</td><td>20</td><td>8-11-10</td><td>72.93</td></tr><tr><td>10</td><td>19-19-19</td><td>93.46</td><td>10</td><td>18-18-18</td><td>73.64</td></tr><tr><td>5</td><td>23-22-22</td><td>93.98</td><td>5</td><td>23-23-23</td><td>73.70</td></tr><tr><td>3</td><td>42-42-42</td><td>94.27</td><td>3</td><td>54-53-53</td><td>74.72</td></tr><tr><td>1</td><td>77-76-76</td><td>94.30</td><td>1</td><td>68-68-68</td><td>74.51</td></tr></table>",
+        "bbox": [
+            351,
+            116,
+            642,
+            200
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/3ec78c5beb7913b0a11a6fa3541b2f028a97a3403c48fa1674d0328f2aa28da3.jpg",
+        "table_caption": [
+            "Table 6: The adaptability of AutoGrow to datasets "
+        ],
+        "table_footnote": [
+            "∗ $\\overline { { \\Delta = } }$ (accuracy of AutoGrow) $-$ (accuracy of training from scratch) "
+        ],
+        "table_body": "<table><tr><td>net</td><td>dataset</td><td>found net</td><td>accu %</td><td>△*</td></tr><tr><td rowspan=\"5\">Basic3ResNet</td><td>CIFAR10</td><td>42-42-42</td><td>94.27</td><td>-0.03</td></tr><tr><td>CIFAR100</td><td>54-53-53</td><td>74.72</td><td>-0.95</td></tr><tr><td>SVHN</td><td>34-34-34</td><td>97.22</td><td>0.04</td></tr><tr><td>FashionMNIST</td><td>30-29-29</td><td>94.57</td><td>-0.06</td></tr><tr><td>MNIST</td><td>33-33-33</td><td>99.64</td><td>-0.03</td></tr><tr><td rowspan=\"5\">Basic4ResNet</td><td>CIFAR10</td><td>22-22-22-22</td><td>95.49</td><td>-0.10</td></tr><tr><td>CIFAR100</td><td>17-51-16-16</td><td>79.47</td><td>1.22</td></tr><tr><td>SVHN</td><td>20-20-19-19</td><td>97.32</td><td>-0.08</td></tr><tr><td>FashionMNIST</td><td>27-27-27-26</td><td>94.62</td><td>-0.17</td></tr><tr><td>MNIST</td><td>11-10-10-10</td><td>99.66</td><td>0.01</td></tr></table>",
+        "bbox": [
+            176,
+            232,
+            501,
+            342
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/f8b9303ea144a8498dba6c3f0b47990e23f386df9583b0d1de67b1a292bb086c.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>net</td><td>dataset</td><td>found net</td><td>accu %</td><td>Δ*</td></tr><tr><td rowspan=\"5\">Plain3Net</td><td>CIFAR10</td><td>23-22-22</td><td>90.82</td><td>6.49</td></tr><tr><td>CIFAR100</td><td>28-28-27</td><td>66.34</td><td>31.53</td></tr><tr><td>SVHN</td><td>36-35-35</td><td>96.79</td><td>77.20</td></tr><tr><td>FashionMNIST</td><td>17-17-17</td><td>94.49</td><td>0.56</td></tr><tr><td>MNIST</td><td>20-20-20</td><td>99.66</td><td>0.12</td></tr><tr><td rowspan=\"5\">Plain4Net</td><td>CIFAR10</td><td>17-17-17-17</td><td>94.20</td><td>5.72</td></tr><tr><td>CIFAR100</td><td>16-15-15-15</td><td>73.91</td><td>29.34</td></tr><tr><td>SVHN</td><td>12-12-12-11</td><td>97.08</td><td>0.32</td></tr><tr><td>FashionMNIST</td><td>13-13-13-13</td><td>94.47</td><td>0.72</td></tr><tr><td>MNIST</td><td>13-12-12-12</td><td>99.57</td><td>0.03</td></tr></table>",
+        "bbox": [
+            509,
+            232,
+            821,
+            344
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "1. In Table 6, AutoGrow discovers layer depth across all scenarios without any tuning, achieving the main goal of this work. Manual design needs $m \\cdot n \\cdot k$ trials, where $m$ and $n$ are respectively the numbers of datasets and sub-module categories, and $k$ is the number of trials per dataset per sub-module category; ",
+        "bbox": [
+            214,
+            378,
+            825,
+            435
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "2. For ResNets, a discovered depth $\" \\bullet '$ in Figure 3) falls at the location where accuracy saturates. This means AutoGrow discovers a near-optimal depth: a shallower depth will lose accuracy while a deeper one gains little. The final accuracy of AutoGrow is as good as training the discovered net from scratch as indicated by $\\cdot \\Delta ^ { , , }$ in Table 6, indicating that initialization from shallower nets does not hurt training of deeper nets. As a byproduct, in plain networks, there are large positive “ $\\Delta \\mathbf { i }$ ”s in Table 6. It implies that baselines fail to train very deep plain networks even using Batch Normalization, but AutoGrow enables the training of these networks; In Appendix A.0.3, Table 9 shows the accuracy improvement of plain networks by tuning $K$ , approaching the accuracy of ResNets with the same depth. ",
+        "bbox": [
+            212,
+            440,
+            823,
+            565
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3. For robustness and generalization study purpose, we stick to $K = 3$ in our experiments, however, we can tune $K$ to trade off accuracy and model size. As shown in Figure 3, AutoGrow discovers smaller DNNs when increasing $K$ from 3 $( ^ { 6 6 } \\bullet \\bullet )$ to 50 $( ^ { 6 6 } \\bigcirc ^ { , 9 } )$ . Interestingly, the accuracy of plain networks even increases at $K = 5 0$ . This implies the possibility of discovering a better accuracy-depth trade-off by tuning $K$ , although we stick to $K = 3$ for generalizability study and it generalizes well. ",
+        "bbox": [
+            214,
+            570,
+            825,
+            654
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4. In Table 6, AutoGrow discovers different depths under different sub-modules. The final accuracy is limited by the sub-module design, not by our AutoGrow. Given a sub-module architecture, our AutoGrow can always find a near-optimal depth. With a better sub-module architecture, such as NASNet cell (Zoph et al., 2018), AutoGrow can improve accuracy. ",
+        "bbox": [
+            214,
+            659,
+            823,
+            714
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Finally, our supposition is that: when the size of dataset is smaller, the optimal depth should be smaller. Under this supposition, we test the effectiveness of AutoGrow by sampling a subset of dataset and verify if AutoGrow can discover a shallower depth. In Appendix A.0.3, Table 11 summarizes the results. As expected, our experiments show that AutoGrow adapts to shallower networks when the datasets are smaller. ",
+        "bbox": [
+            174,
+            727,
+            825,
+            796
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.4 SCALING TO IMAGENET AND EFFICIENCY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            814,
+            504,
+            829
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In ImageNet, $K = 3$ should generalize well, but we explore AutoGrow with $K = 2$ and $K = 5$ to obtain an accuracy-depth trade-off line for comparison with human experts. The larger $K = 5$ enables AutoGrow to obtain a smaller DNN to trade-off accuracy and model size (computation) and the smaller $K = 2$ achieves higher accuracy. The results are shown in Table 7, which proves that AutoGrow automatically finds a good depth without any tuning. As a byproduct, the accuracy is even higher than training the found net from scratch, indicating that the Periodic Growth in AutoGrow helps training deeper nets. The comparison of AutoGrow and manual depth design (He et al., 2016) is in Figure 4, which shows that AutoGrow achieves better trade-off between accuracy and computation (measured by floating point operations). ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/865d2dd857902426f903825d1dea250f8a8f8b2c48cb259f57a05c143b549e1e.jpg",
+        "table_caption": [
+            "Table 7: Scaling up to ImageNet "
+        ],
+        "table_footnote": [
+            "† ∆ = (Top-1 of AutoGrow) − (Top-1 of training from scratch) "
+        ],
+        "table_body": "<table><tr><td>net</td><td>K</td><td>found net</td><td>Top-1</td><td>Top-5</td><td>△ Top-1</td></tr><tr><td rowspan=\"2\">Basic4ResNet</td><td>2</td><td>12-12-11-11</td><td>76.28</td><td>92.79</td><td>0.43</td></tr><tr><td>5</td><td>9-3-6-4</td><td>74.75</td><td>91.97</td><td>0.72</td></tr><tr><td rowspan=\"2\">Bottleneck4ResNet</td><td>2</td><td>6-6-6-17</td><td>77.99</td><td>93.91</td><td>0.83</td></tr><tr><td>5</td><td>6-7-3-9</td><td>77.33</td><td>93.65</td><td>0.83</td></tr><tr><td rowspan=\"2\">Plain4Net</td><td>2</td><td>6-6-6-6</td><td>71.22</td><td>90.08</td><td>0.70</td></tr><tr><td>5</td><td>5-5-5-4</td><td>70.54</td><td>89.76</td><td>0.93</td></tr></table>",
+        "bbox": [
+            303,
+            116,
+            689,
+            203
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            228,
+            821,
+            268
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Appendix A.0.3, Table 10 summarizes the breakdown of wall-clock time in AutoGrow. The growing/searching time is as efficient as (often more efficient than) fine-tuning the single discovered DNN. The scalability of AutoGrow comes from its intrinsic features that (1) it grows quickly with a short period $K$ and stops immediately if no improvement is sensed; and (2) the network is small at the beginning of growing. ",
+        "bbox": [
+            173,
+            276,
+            825,
+            345
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/f7a6254ad63b159c57ea06e4bc761b4e0c1049b8457efe33338457d61c2774a0.jpg",
+        "image_caption": [
+            "Figure 3: AutoGrow vs manual search obtained by training many baselines from scratch. $x - a x i s$ is the number of parameters. Dataset is CIFAR10. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            354,
+            498,
+            491
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/84c1065d96345fcdaf849055087c1baabff04e3dc4738d9ef0934583464c554a.jpg",
+        "image_caption": [
+            "Figure 4: AutoGrow vs. manual design (He et al., 2016) on ImageNet. Marker area is proportional to model size determined by depth. “basic”(“bottleneck”) refers to ResNets with basic (bottleneck) residual blocks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            522,
+            353,
+            802,
+            463
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            564,
+            343,
+            579
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Neural Architecture Search (NAS) (Zoph & Le, 2016) and neural evolution (Miikkulainen et al., 2019; Angeline et al., 1994; Stanley & Miikkulainen, 2002; Liu et al., 2017a; Real et al., 2017) can search network architectures from a gigantic search space. In NAS, the depth of DNNs in the search space is fixed, while AutoGrow learns the depth. Some NAS methods (Bender et al., 2018; Liu et al., 2018b; Cortes et al., 2017) can find DNNs with different depths, however, the maximum depth is pre-defined and shallower nets are obtained by padding zero operations or selecting shallower branches, while our AutoGrow learns the depth in an open domain to find a minimum depth, beyond which no accuracy improvement can be obtained. Moreover, NAS is very computation and memory intensive. To accelerate NAS, one-shot models (Saxena & Verbeek, 2016; Pham et al., 2018; Bender et al., 2018), DARTS (Liu et al., 2018b) and NAS with Transferable Cell (Zoph et al., 2018; Liu et al., 2018a) were proposed. The search time reduces dramatically but is still long from practical perspective. It is still very challenging to deploy these methods to larger datasets such as ImageNet. In contrast, our AutoGrow can scale up to ImageNet thanks to its short depth learning time, which is as efficient as training a single DNN. ",
+        "bbox": [
+            173,
+            597,
+            825,
+            791
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In addition to architecture search which requires to train lots of DNNs from scratch, there are also many studies on learning neural structures within a single training. Structure pruning and growing were proposed for different goals, such as efficient inference (Wen et al., 2016; Li et al., 2016; Lebedev & Lempitsky, 2016; He et al., 2017; Luo et al., 2017; Liu et al., 2017b; Dai et al., 2017; Huang et al., 2018; Gordon et al., 2018; Du et al., 2019), lifelong learning (Yoon et al., 2017) and model adaptation (Feng & Darrell, 2015; Philipp & Carbonell, 2017). However, those works fixed the network depth and limited structure learning within the existing layers. Optimization over a DNN with fixed depth is easier as the skeleton architecture is known. AutoGrow performs in a scenario where the DNN depth is unknown hence we need to seek for the optimal depth. ",
+        "bbox": [
+            173,
+            799,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Peter J Angeline, Gregory M Saunders, and Jordan B Pollack. An evolutionary algorithm that constructs recurrent neural networks. IEEE transactions on Neural Networks, 5(1):54–65, 1994. ",
+        "bbox": [
+            173,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gabriel Bender, Pieter-Jan Kindermans, Barret Zoph, Vijay Vasudevan, and Quoc Le. Understanding and simplifying one-shot architecture search. In International Conference on Machine Learning, pp. 549–558, 2018. ",
+        "bbox": [
+            173,
+            164,
+            823,
+            207
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Han Cai, Tianyao Chen, Weinan Zhang, Yong Yu, and Jun Wang. Efficient architecture search by network transformation. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018a. ",
+        "bbox": [
+            171,
+            217,
+            823,
+            246
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Han Cai, Jiacheng Yang, Weinan Zhang, Song Han, and Yong Yu. Path-level network transformation for efficient architecture search. arXiv preprint arXiv:1806.02639, 2018b. ",
+        "bbox": [
+            171,
+            256,
+            823,
+            285
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tianqi Chen, Ian Goodfellow, and Jonathon Shlens. Net2net: Accelerating learning via knowledge transfer. arXiv preprint arXiv:1511.05641, 2015. ",
+        "bbox": [
+            173,
+            294,
+            821,
+            324
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Corinna Cortes, Xavier Gonzalvo, Vitaly Kuznetsov, Mehryar Mohri, and Scott Yang. Adanet: Adaptive structural learning of artificial neural networks. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 874–883. JMLR. org, 2017. ",
+        "bbox": [
+            176,
+            333,
+            823,
+            376
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xiaoliang Dai, Hongxu Yin, and Niraj K Jha. Nest: A neural network synthesis tool based on a grow-and-prune paradigm. arXiv preprint arXiv:1711.02017, 2017. ",
+        "bbox": [
+            174,
+            386,
+            823,
+            415
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xiaocong Du, Zheng Li, and Yu Cao. Cgap: Continuous growth and pruning for efficient deep learning. arXiv preprint arXiv:1905.11533, 2019. ",
+        "bbox": [
+            176,
+            424,
+            823,
+            454
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Thomas Elsken, Jan-Hendrik Metzen, and Frank Hutter. Simple and efficient architecture search for cnns. In Workshop on Meta-Learning (MetaLearn 2017) at NIPS, 2017. ",
+        "bbox": [
+            173,
+            463,
+            823,
+            493
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jiashi Feng and Trevor Darrell. Learning the structure of deep convolutional networks. In Proceedings of the IEEE international conference on computer vision, pp. 2749–2757, 2015. ",
+        "bbox": [
+            169,
+            502,
+            823,
+            531
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ariel Gordon, Elad Eban, Ofir Nachum, Bo Chen, Hao Wu, Tien-Ju Yang, and Edward Choi. Morphnet: Fast & simple resource-constrained structure learning of deep networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1586–1595, 2018. ",
+        "bbox": [
+            176,
+            540,
+            823,
+            584
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016. ",
+        "bbox": [
+            174,
+            593,
+            823,
+            636
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yihui He, Xiangyu Zhang, and Jian Sun. Channel pruning for accelerating very deep neural networks. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1389–1397, 2017. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            689
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Zhuang Liu, Laurens Van Der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 4700–4708, 2017. ",
+        "bbox": [
+            176,
+            698,
+            823,
+            742
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Shichen Liu, Laurens Van der Maaten, and Kilian Q Weinberger. Condensenet: An efficient densenet using learned group convolutions. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2752–2761, 2018. ",
+        "bbox": [
+            176,
+            751,
+            823,
+            795
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            171,
+            804,
+            823,
+            833
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012. ",
+        "bbox": [
+            174,
+            842,
+            823,
+            885
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Vadim Lebedev and Victor Lempitsky. Fast convnets using group-wise brain damage. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2554–2564, 2016. ",
+        "bbox": [
+            176,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Hao Li, Asim Kadav, Igor Durdanovic, Hanan Samet, and Hans Peter Graf. Pruning filters for efficient convnets. arXiv preprint arXiv:1608.08710, 2016. ",
+        "bbox": [
+            169,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hao Li, Zheng Xu, Gavin Taylor, Christoph Studer, and Tom Goldstein. Visualizing the loss landscape of neural nets. In Advances in Neural Information Processing Systems, pp. 6391–6401, 2018. ",
+        "bbox": [
+            174,
+            141,
+            821,
+            184
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chenxi Liu, Barret Zoph, Maxim Neumann, Jonathon Shlens, Wei Hua, Li-Jia Li, Li Fei-Fei, Alan Yuille, Jonathan Huang, and Kevin Murphy. Progressive neural architecture search. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 19–34, 2018a. ",
+        "bbox": [
+            174,
+            194,
+            821,
+            238
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hanxiao Liu, Karen Simonyan, Oriol Vinyals, Chrisantha Fernando, and Koray Kavukcuoglu. Hierarchical representations for efficient architecture search. arXiv preprint arXiv:1711.00436, 2017a. ",
+        "bbox": [
+            171,
+            246,
+            823,
+            275
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hanxiao Liu, Karen Simonyan, and Yiming Yang. Darts: Differentiable architecture search. arXiv preprint arXiv:1806.09055, 2018b. ",
+        "bbox": [
+            173,
+            284,
+            825,
+            314
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhuang Liu, Jianguo Li, Zhiqiang Shen, Gao Huang, Shoumeng Yan, and Changshui Zhang. Learning efficient convolutional networks through network slimming. In Proceedings of the IEEE International Conference on Computer Vision, pp. 2736–2744, 2017b. ",
+        "bbox": [
+            173,
+            323,
+            823,
+            366
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jian-Hao Luo, Jianxin Wu, and Weiyao Lin. Thinet: A filter level pruning method for deep neural network compression. In Proceedings of the IEEE international conference on computer vision, pp. 5058–5066, 2017. ",
+        "bbox": [
+            173,
+            375,
+            821,
+            417
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Risto Miikkulainen, Jason Liang, Elliot Meyerson, Aditya Rawal, Daniel Fink, Olivier Francon, Bala Raju, Hormoz Shahrzad, Arshak Navruzyan, Nigel Duffy, et al. Evolving deep neural networks. In Artificial Intelligence in the Age of Neural Networks and Brain Computing, pp. 293–312. Elsevier, 2019. ",
+        "bbox": [
+            173,
+            428,
+            825,
+            484
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hieu Pham, Melody Y Guan, Barret Zoph, Quoc V Le, and Jeff Dean. Efficient neural architecture search via parameter sharing. arXiv preprint arXiv:1802.03268, 2018. ",
+        "bbox": [
+            173,
+            493,
+            823,
+            523
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "George Philipp and Jaime G Carbonell. Nonparametric neural networks. arXiv preprint arXiv:1712.05440, 2017. ",
+        "bbox": [
+            173,
+            531,
+            823,
+            561
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Esteban Real, Sherry Moore, Andrew Selle, Saurabh Saxena, Yutaka Leon Suematsu, Jie Tan, Quoc V Le, and Alexey Kurakin. Large-scale evolution of image classifiers. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 2902–2911. JMLR. org, 2017. ",
+        "bbox": [
+            173,
+            570,
+            825,
+            627
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shreyas Saxena and Jakob Verbeek. Convolutional neural fabrics. In Advances in Neural Information Processing Systems, pp. 4053–4061, 2016. ",
+        "bbox": [
+            173,
+            637,
+            821,
+            666
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014. ",
+        "bbox": [
+            173,
+            674,
+            823,
+            704
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Leslie N Smith, Emily M Hand, and Timothy Doster. Gradual dropin of layers to train very deep neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4763–4771, 2016. ",
+        "bbox": [
+            171,
+            713,
+            823,
+            756
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kenneth O Stanley and Risto Miikkulainen. Evolving neural networks through augmenting topologies. Evolutionary computation, 10(2):99–127, 2002. ",
+        "bbox": [
+            169,
+            766,
+            823,
+            795
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1–9, 2015. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            848
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Guangcong Wang, Xiaohua Xie, Jianhuang Lai, and Jiaxuan Zhuo. Deep growing learning. In Proceedings of the IEEE International Conference on Computer Vision, pp. 2812–2820, 2017. ",
+        "bbox": [
+            173,
+            856,
+            821,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tao Wei, Changhu Wang, Yong Rui, and Chang Wen Chen. Network morphism. In International Conference on Machine Learning, pp. 564–572, 2016. ",
+        "bbox": [
+            176,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tao Wei, Changhu Wang, and Chang Wen Chen. Modularized morphing of neural networks. arXiv preprint arXiv:1701.03281, 2017. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. In Advances in neural information processing systems, pp. 2074–2082, 2016. ",
+        "bbox": [
+            176,
+            142,
+            823,
+            185
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jaehong Yoon, Eunho Yang, Jeongtae Lee, and Sung Ju Hwang. Lifelong learning with dynamically expandable networks. arXiv preprint arXiv:1708.01547, 2017. ",
+        "bbox": [
+            171,
+            195,
+            823,
+            224
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph and Quoc V Le. Neural architecture search with reinforcement learning. arXiv preprint arXiv:1611.01578, 2016. ",
+        "bbox": [
+            174,
+            234,
+            823,
+            263
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph, Vijay Vasudevan, Jonathon Shlens, and Quoc V Le. Learning transferable architectures for scalable image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 8697–8710, 2018. ",
+        "bbox": [
+            173,
+            275,
+            826,
+            318
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            345,
+            297,
+            361
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.0.1 OPTIMIZATION TRAJECTORIES OF NETWORK MORPHISM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            377,
+            627,
+            392
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We hypothesize that a converged shallower net may not be an adequate initialization. Figure 5 visualizes and compares the optimization trajectories of Network Morphism and the training from scratch. In this figure, the shallower net is $\\mathtt { B a s i c 3 R e s N e t - 3 - 3 - 3 }$ (ResNet-20) and the deeper one is $\\mathtt { B a s i c 3 R e s N e t - 5 - 5 - 5 }$ (ResNet-32) in Table 2. The initializer is ZeroInit. The visualization method is extended from Li et al. (2018). Points on the trajectory are evenly sampled every a few epochs. To maximize the variance of trajectory, we use PCA to project from a high dimensional space to a 2D space and use the first two Principle Components (PC) to form the axes in Figure 5. The contours of training loss function and the trajectory are visualized around the final minimum of the deeper net. When projecting a shallower net to a deeper net space, zeros are padded for the parameters not existing in the deeper net. We must note that the loss increase along the trajectory does not truly represent the situation in high dimensional space, as the trajectory is just a projection. It is possible that the loss remains decreasing in the high dimension while it appears in an opposite way in the 2D space. The sharp detour at “Morphing” in Figure 5(a) may indicate that the shallower net plausibly converges to a point that the deeper net struggles to escape. In contrast, Figure 5(b) shows that the trajectory of the direct optimization in the deeper space smoothly converges to a better minimum. ",
+        "bbox": [
+            173,
+            404,
+            825,
+            625
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Figure 6(a) visualizes the trajectory of $c$ -AutoGrow corresponding to row $^ { 6 6 } 2 - 3 - 6 ^ { 3 3 }$ in Table 3. Along the trajectory, there are many trials to detour and escape an initialization from a shallower net. Figure 6(b) visualizes the trajectory corresponding to row $^ { 6 6 } 2 - 4 - 3 ^ { 5 }$ in Table 3, which is much smoother compared to Figure 6(a). Figure 6(c)(d) visualize the trajectories of $p$ -AutoGrow with $K = 5 0$ and 3. The 2D projection gives limited information to reveal the advantages of $p$ -AutoGrow comparing to $c$ -AutoGrow in Figure 6(b), although the trajectory of our final $p$ -AutoGrow in Figure 6(d) is plausibly more similar to the one of training from scratch in Figure 5(b). ",
+        "bbox": [
+            174,
+            631,
+            825,
+            702
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/7ec45dcda0e4eec27bfa06e165883796dfd3195ad9dd58aa345219a511289cad.jpg",
+        "image_caption": [
+            "Figure 5: An optimization trajectory comparison between (a) Network Morphism and (b) training from scratch. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            222,
+            723,
+            776,
+            882
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/202e978119acb59297fd26c27e8b39d29c725967d74a077abfd3cc74d2f35679.jpg",
+        "image_caption": [
+            "Figure 6: Optimization trajectory of AutoGrow, tested by Basic3ResNet on CIFAR10. (a) $c$ -AutoGrow with staircase learning rate and ZeroInit during growing; (b) $c$ -AutoGrow with constant learning rate and GauInit during growing; (c) $p$ -AutoGrow with $K = 5 0$ ; and (d) $p$ - AutoGrow with $K = 3$ . For better illustration, the dots on the trajectory are plotted every 4, 20, 5 and 3 epochs in (a-d), respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            99,
+            825,
+            204
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/5bb68bf43dfb0e6d077a75dac2d1c40a1628ddbdaa60cb6364875f9789fd1ae1.jpg",
+        "image_caption": [
+            "Figure 7: Loss surfaces around minima found by baselines and AutoGrow. Dataset is CIFAR10. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            220,
+            304,
+            774,
+            523
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            579,
+            823,
+            608
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.0.2 VISUALIZATION OF LOSS SURFACES AROUND MINIMA ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            627,
+            611,
+            642
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Figure 7 visualizes loss surfaces around minima by AutoGrow and baseline. Intuitively, AutoGrow finds wider or deeper minima with less chaotic landscapes. ",
+        "bbox": [
+            173,
+            652,
+            823,
+            681
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.0.3 MORE EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            699,
+            457,
+            714
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Figure 8 plots the growing and converging curves for two DNNs in Table 10. ",
+        "bbox": [
+            176,
+            726,
+            676,
+            741
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Table 11 summarizes the adaptability of AutoGrow to the sizes of dataset. In each set of experiments, dataset is randomly down-sampled to $1 0 0 \\%$ , $7 5 \\%$ , $5 0 \\%$ and $2 5 \\%$ . For a fair comparison, $K$ is divided by the percentage of dataset such that the number of mini-batches between growths remains ",
+        "bbox": [
+            174,
+            747,
+            826,
+            790
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/ef89ae780578bf7f49be11090635dd15ca5ee1f5ace5de8af06a8c5a1f534b08.jpg",
+        "table_caption": [
+            "Table 8: $p$ -AutoGrow under initializers with $K = 3$ "
+        ],
+        "table_footnote": [
+            "† Basic3ResNet "
+        ],
+        "table_body": "<table><tr><td colspan=\"2\">CIFAR10</td><td rowspan=\"2\">accu</td></tr><tr><td>initializer</td><td>found nett</td></tr><tr><td>ZeroInit</td><td>31-30-30</td><td>93.57</td></tr><tr><td>AdamInit</td><td>37-37-36</td><td>93.79</td></tr><tr><td>UniInit</td><td>28-28-28</td><td>93.82</td></tr><tr><td>GauInit</td><td>42-42-42</td><td>94.27</td></tr></table>",
+        "bbox": [
+            272,
+            832,
+            490,
+            915
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/3936b1f80f8c66fb407c2fe32b876fddc5047d7717f20a01eddb6938f4146193.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "† Basic3ResNet "
+        ],
+        "table_body": "<table><tr><td colspan=\"3\">CIFAR100</td></tr><tr><td>initializer</td><td>found nett</td><td>accu</td></tr><tr><td>ZeroInit</td><td>26-25-25</td><td>73.45</td></tr><tr><td>AdamInit</td><td>27-27-27</td><td>73.92</td></tr><tr><td>UniInit</td><td>41-41-41</td><td>74.31</td></tr><tr><td>GauInit</td><td>54-53-53</td><td>74.72</td></tr></table>",
+        "bbox": [
+            503,
+            832,
+            720,
+            915
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/b3f749c88bd86ef2236ff2da9fda5cbddbf63ba376d7223ae9c4e3a88779dd2c.jpg",
+        "table_caption": [
+            "Table 9: AutoGrow improves accuracy of plain nets. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">dataset</td><td>net layer #</td><td>method</td><td> accu %</td></tr><tr><td rowspan=\"3\">CIFAR10</td><td>Plain4Net-6-6-6-6</td><td>26</td><td>baseline</td><td>93.90</td></tr><tr><td>Plain4Net-6-6-6-6</td><td>26</td><td>AutoGrow K=30</td><td>95.17</td></tr><tr><td>Basic4ResNet-3-3-3-3</td><td>26</td><td>baseline</td><td>95.33</td></tr><tr><td rowspan=\"3\">CIFAR10</td><td>Plain3Net-11-11-10</td><td>34</td><td>baseline</td><td>90.45</td></tr><tr><td>Plain3Net-11-11-10</td><td>34</td><td>AutoGrow K=50</td><td>93.13</td></tr><tr><td>Basic3ResNet-6-6-5</td><td>36</td><td>baseline</td><td>93.60</td></tr></table>",
+        "bbox": [
+            258,
+            119,
+            740,
+            279
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/af60a3f4e4fb1d8fe0455c5078e8745655baadc7edbfbc8d6cca4cb816293bac.jpg",
+        "table_caption": [
+            "Table 10: The efficiency of AutoGrow "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>net</td><td>GPUs</td><td>growing</td><td>fine-tuning</td></tr><tr><td>Basic4ResNet-12-12-11-11</td><td>4 GTX 1080 Ti</td><td>56.7 hours</td><td>157.9 hours</td></tr><tr><td>Basic4ResNet-9-3-6-4</td><td>4 GTX1080</td><td>47.9 hours</td><td>65.8 hours</td></tr><tr><td>Bottleneck4ResNet-6-6-6-17</td><td>4 TITAN V</td><td>45.3 hours</td><td>114.0 hours</td></tr><tr><td>Bottleneck4ResNet-6-7-3-9</td><td>4 TITAN V</td><td>61.6 hours</td><td>78.6 hours</td></tr><tr><td>Plain4Net-6-6-6-6</td><td>4 GTX 1080 Ti</td><td>11.7 hours</td><td>29.7 hours</td></tr><tr><td>Plain4Net-5-5-5-4</td><td>4 GTX 1080 Ti</td><td>25.6 hours</td><td>25.3 hours</td></tr></table>",
+        "bbox": [
+            209,
+            320,
+            789,
+            445
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/dcc4991c910983ddaab0d84913d1e1d63d3049b45ccade319b8e6be7bdb7f183.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            460,
+            491,
+            655
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/ff8de4cc3b0f11d571a7eff70a0eaf2908e5f3266d7d32a7c51b6d9bcc87ec95.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            511,
+            460,
+            821,
+            656
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/b297ee54b07f87deff79e56795920fb55be9b0189e8af41894f07fa5b364f8aa.jpg",
+        "table_caption": [
+            "Table 11: The adaptability of AutoGrow to dataset sizes "
+        ],
+        "table_footnote": [
+            "Figure 8: The convergence curves and growing process on ImageNet for (a) Basic4ResNet-9-3-6-4 and (b) Plain4Net-6-6-6-6 in Table 10. "
+        ],
+        "table_body": "<table><tr><td colspan=\"2\">Basic3ResNet on CIFAR10</td></tr><tr><td>dataset size</td><td>found net accu %</td></tr><tr><td>100%</td><td>42-42-42 94.27</td></tr><tr><td>75%</td><td>32-31-31 93.54</td></tr><tr><td>50%</td><td>17-17-17 91.34</td></tr><tr><td>25%</td><td>21-12-7 88.18</td></tr><tr><td>Basic4ResNet on CIFAR100</td><td></td></tr><tr><td>dataset size found net</td><td> accu %</td></tr><tr><td>100%</td><td>17-51-16-16 79.47</td></tr><tr><td>75% 17-17-16-16</td><td>77.26</td></tr><tr><td>50% 12-12-12-11</td><td>72.91</td></tr><tr><td>25%</td><td>6-6-6-6 62.53</td></tr></table>",
+        "bbox": [
+            225,
+            738,
+            493,
+            916
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/61cb29134d63dd933a23b248620a850af1cff6c3561c4f688b2ece31ed621ce0.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Plain3Net on MNIST</td></tr><tr><td>dataset size</td><td>found net accu %</td></tr><tr><td>100%</td><td>20-20-20 99.66</td></tr><tr><td>75%</td><td>12-12-12 99.54</td></tr><tr><td>50%</td><td>12-11-11 99.46</td></tr><tr><td>25%</td><td>10-9-9 99.33</td></tr><tr><td colspan=\"2\">Plain4Net on SVHN</td></tr><tr><td>dataset size</td><td>found net accu %</td></tr><tr><td>100%</td><td>12-12-12-11 97.08</td></tr><tr><td>75%</td><td>9-9-9-9 96.71</td></tr><tr><td>50% 8-8-8-8</td><td>96.37 95.68</td></tr><tr><td>25%</td><td>5-5-5-5</td></tr></table>",
+        "bbox": [
+            506,
+            738,
+            772,
+            917
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "the same. As expected, our experiments show that AutoGrow adapts to shallower networks when the sizes are smaller. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 13
+    }
+]

parse/train/blfSjHeFM_e/blfSjHeFM_e.md

@@ -0,0 +1,660 @@
+# MALI: A MEMORY EFFICIENT AND REVERSE ACCURATE INTEGRATOR FOR NEURAL ODES
+
+Juntang Zhuang; Nicha C. Dvornek; Sekhar Tatikonda; James S. Duncan {j.zhuang; nicha.dvornek; sekhar.tatikonda; james.duncan} @yale.edu Yale University, New Haven, CT, USA
+
+# ABSTRACT
+
+Neural ordinary differential equations (Neural ODEs) are a new family of deeplearning models with continuous depth. However, the numerical estimation of the gradient in the continuous case is not well solved: existing implementations of the adjoint method suffer from inaccuracy in reverse-time trajectory, while the naive method and the adaptive checkpoint adjoint method (ACA) have a memory cost that grows with integration time. In this project, based on the asynchronous leapfrog (ALF) solver, we propose the Memory-efficient ALF Integrator (MALI), which has a constant memory cost w.r.t number of solver steps in integration similar to the adjoint method, and guarantees accuracy in reverse-time trajectory (hence accuracy in gradient estimation). We validate MALI in various tasks: on image recognition tasks, to our knowledge, MALI is the first to enable feasible training of a Neural ODE on ImageNet and outperform a well-tuned ResNet, while existing methods fail due to either heavy memory burden or inaccuracy; for time series modeling, MALI significantly outperforms the adjoint method; and for continuous generative models, MALI achieves new state-of-theart performance.We provide a pypi package: https://jzkay12.github. io/TorchDiffEqPack
+
+# 1 INTRODUCTION
+
+Recent research builds the connection between continuous models and neural networks. The theory of dynamical systems has been applied to analyze the properties of neural networks or guide the design of networks (Weinan, 2017; Ruthotto & Haber, 2019; Lu et al., 2018). In these works, a residual block (He et al., 2016) is typically viewed as a one-step Euler discretization of an ODE; instead of directly analyzing the discretized neural network, it might be easier to analyze the ODE.
+
+Another direction is the neural ordinary differential equation (Neural ODE) (Chen et al., 2018), which takes a continuous depth instead of discretized depth. The dynamics of a Neural ODE is typically approximated by numerical integration with adaptive ODE solvers. Neural ODEs have been applied in irregularly sampled time-series (Rubanova et al., 2019), free-form continuous generative models (Grathwohl et al., 2018; Finlay et al., 2020), mean-field games (Ruthotto et al., 2020), stochastic differential equations (Li et al., 2020) and physically informed modeling (SanchezGonzalez et al., 2019; Zhong et al., 2019).
+
+Though the Neural ODE has been widely applied in practice, how to train it is not extensively studied. The naive method directly backpropagates through an ODE solver, but tracking a continuous trajectory requires a huge memory. Chen et al. (2018) proposed to use the adjoint method to determine the gradient in continuous cases, which achieves constant memory cost $w . r . t$ integration time; however, as pointed out by Zhuang et al. (2020), the adjoint method suffers from numerical errors due to the inaccuracy in reverse-time trajectory. Zhuang et al. (2020) proposed the adaptive checkpoint adjoint (ACA) method to achieve accuracy in gradient estimation at a much smaller memory cost compared to the naive method, yet the memory consumption of ACA still grows linearly with integration time. Due to the non-constant memory cost, neither ACA nor naive method are suitable for large scale datasets (e.g. ImageNet) or high-dimensional Neural ODEs (e.g. FFJORD (Grathwohl et al., 2018)).
+
+In this project, we propose the Memory-efficient Asynchronous Leapfrog Integrator (MALI) to achieve advantages of both the adjoint method and ACA: constant memory cost w.r.t integration time and accuracy in reverse-time trajectory. MALI is based on the asynchronous leapfrog (ALF) integrator (Mutze, 2013). With the ALF integrator, each numerical step forward in time is reversible. Therefore, with MALI, we delete the trajectory and only keep the end-time states, hence achieve constant memory cost w.r.t integration time; using the reversibility, we can accurately reconstruct the trajectory from the end-time value, hence achieve accuracy in gradient. Our contributions are:
+
+1. We propose a new method (MALI) to solve Neural ODEs, which achieves constant memory cost w.r.t number of solver steps in integration and accuracy in gradient estimation. We provide theoretical analysis.   
+2. We validate our method with extensive experiments: (a) for image classification tasks, MALI enables a Neural ODE to achieve better accuracy than a well-tuned ResNet with the same number of parameters; to our knowledge, MALI is the first method to enable training of Neural ODEs on a large-scale dataset such as ImageNet, while existing methods fail due to either heavy memory burden or inaccuracy. (b) In time-series modeling, MALI achieves comparable or better results than other methods. (c) For generative modeling, a FFJORD model trained with MALI achieves new state-of-the-art results on MNIST and Cifar10.
+
+# 2 PRELIMINARIES
+
+# 2.1 NUMERICAL INTEGRATION METHODS
+
+An ordinary differential equation (ODE) typically takes the form
+
+$$
+\frac { \mathrm { d } z ( t ) } { \mathrm { d } t } = f _ { \theta } ( t , z ( t ) ) \quad s . t . \quad z ( t _ { 0 } ) = x , t \in [ t _ { 0 } , T ] , \quad L o s s = L ( z ( T ) , y )
+$$
+
+where $z ( t )$ is the hidden state evolving with time, $T$ is the end time, $t _ { 0 }$ is the start time (typically 0), $x$ is the initial state. The derivative of $z ( t )$ w.r.t $t$ is defined by a function $f$ , and $f$ is defined as a sequence of layers parameterized by $\theta$ . The loss function is $L ( z ( T ) , y )$ , where $y$ is the target variable. Eq. 1 is called the initial value problem (IVP) because only $z ( t _ { 0 } )$ is specified.
+
+Notations We summarize the notations following Zhuang et al. (2020).
+
+• $z _ { i } ( t _ { i } ) / \overline { { z } } ( \tau _ { i } )$ : hidden state in forward/reverse time trajectory at time $t _ { i } / \tau _ { i }$ .   
+• $\psi _ { h } ( t _ { i } , z _ { i } )$ : the numerical solution at time $t _ { i } + h$ , starting from $( t _ { i } , z _ { i } )$ with a stepsize $h$ .   
+• $N _ { f } , N _ { z } \colon N _ { f }$ is the number of layers in $f$ in Eq. 1, $N _ { z }$ is the dimension of $z$ .   
+• $N _ { t } / N _ { r }$ : number of discretized points (outer iterations in Algo. 1) in forward / reverse integration.   
+• $m$ : average number of inner iterations in Algo. 1 to find an acceptable stepsize.
+
+<table><tr><td>Algorithm1:Numerical Integration</td></tr><tr><td>Input initial state x,start timeto,end time T,error tolerance etol,initial</td></tr><tr><td>stepsize h. Initialize z(O) = x,t = to</td></tr><tr><td>Whilet&lt;T error_est=</td></tr><tr><td>While error_est&gt;etol h←h×DecayFactor</td></tr><tr><td>,error_est=yh(t,z) If error_est&lt;etol h←h×IncreaseFactor</td></tr></table>
+
+Numerical Integration The algorithm for general adaptive-stepsize numerical ODE solvers is summarized in Algo. 1 (Wanner & Hairer, 1996). The solver repeatedly advances in time by a step, which is the outer loop in Algo. 1 (blue curve in Fig. 1). For each step, the solver decreases the stepsize until the estimate of error is lower than the tolerance, which is the inner loop in Algo. 1 (green curve in Fig. 1). For fixed-stepsize solvers, the inner loop is replaced with a single evaluation of $\psi _ { h } ( t , z )$ using predefined stepsize $h$ . Different methods typically use different $\psi$ , for example different orders of the Runge-Kutta method (Runge, 1895).
+
+# 2.2 ANALYTICAL FORM OF GRADIENT IN CONTINUOUS CASE
+
+We first briefly introduce the analytical form of the gradient in the continuous case, then we compare different numerical implementations in the literature to estimate the gradient. The analytical form
+
+Table 1: Comparison between different methods for gradient estimation in continuous case. MALI achieves reverse accuracy, constant memory $w . r . t$ number of solver steps in integration, shallow computation graph and low computation cost.   
+
+<table><tr><td></td><td>Naive</td><td>Adjoint</td><td>ACA</td><td>MALI</td></tr><tr><td>Computation</td><td>NzNf×Nt×m×2</td><td>NzNf ×(Nt+Nr)×m</td><td>NzNf×Nt×(m+1)</td><td>NzNf×Nt×(m+2)</td></tr><tr><td>Memory</td><td>NzNf ×Nt × m</td><td>NzNf</td><td>Nz(Nf+Nt)</td><td>Nz(Nf +1)</td></tr><tr><td>Computation graph depth</td><td>Nf×Nt × m</td><td>Nf × Nr</td><td>Nf×Nt</td><td>Nf×Nt</td></tr><tr><td>Reverse accuracy</td><td></td><td>X</td><td></td><td></td></tr></table>
+
+![](images/22ff9c5a98236b61e291de2a5527538346dcc29c82d2c1ea58fe9325157384e8.jpg)  
+Figure 1: Illustration of numerical solver in forward-pass. For adaptive solvers, for each step forward-in-time, the stepsize is recursively adjusted until the estimated error is below predefined tolerance; the search process is represented by green curve, and the accepted step (ignore the search process) is represented by blue curve.
+
+![](images/b9c171536db45dffcafe51dcb7787e83aa5364bb5ae81e081dc303fe7404bbed.jpg)  
+Figure 2: In backward-pass, the adjoint method reconstructs trajectory as a separate IVP. Naive, ACA and MALI track the forward-time trajectory, hence are accurate. ACA and MALI only backpropagate through the accepted step, while naive method backpropagates through the search process hence has deeper computation graphs.
+
+of the gradient in the continuous case is
+
+$$
+\frac { \mathrm { d } L } { \mathrm { d } \theta } = - \int _ { T } ^ { 0 } \boldsymbol { a } ( t ) ^ { \top } \frac { \partial f ( \boldsymbol { z } ( t ) , t , \theta ) } { \partial \theta } d t
+$$
+
+$$
+\frac { \mathrm { d } a ( t ) } { d t } + \bigg ( \frac { \partial f ( z ( t ) , t , \theta ) } { \partial z ( t ) } \bigg ) ^ { \top } a ( t ) = 0 \ \forall t \in ( 0 , T ) , a ( T ) = \frac { \partial L } { \partial z ( T ) }
+$$
+
+where $a ( t )$ is the “adjoint state”. Detailed proof is given in (Pontryagin, 1962). In the next section we compare different numerical implementations of this analytical form.
+
+# 2.3 NUMERICAL IMPLEMENTATIONS IN THE LITERATURE FOR THE ANALYTICAL FORM
+
+We compare different numerical implementations of the analytical form in this section. The forwardpass and backward-pass of different methods are demonstrated in Fig. 1 and Fig. 2 respectively. Forward-pass is similar for different methods. The comparison of backward-pass among different methods are summarized in Table. 1. We explain methods in the literature below.
+
+Naive method The naive method saves all of the computation graph (including search for optimal stepsize, green curve in Fig. 2) in memory, and backpropagates through it. Hence the memory cost is $N _ { z } N _ { f } \times N _ { t } \times m$ and depth of computation graph are $N _ { f } \times N _ { t } \times m$ , and the computation is doubled considering both forward and backward passes. Besides the large memory and computation, the deep computation graph might cause vanishing or exploding gradient (Pascanu et al., 2013).
+
+Adjoint method Note that we use “adjoint state equation” to refer to the analytical form in Eq. 2 and 3, while we use “adjoint method” to refer to the numerical implementation by Chen et al. (2018). As in Fig. 1 and 2, the adjoint method forgets forward-time trajectory (blue curve) to achieve memory cost $N _ { z } N _ { f }$ which is constant to integration time; it takes the end-time state (derived from forward-time integration) as the initial state, and solves a separate IVP (red curve) in reverse-time.
+
+the reconstructed initial value by the adjoint method is Theorem 2.1. (Zhuang et al., 2020) For an ODE solver of order $\begin{array} { r } { \sum _ { k = 0 } ^ { N - 1 } \left[ h _ { k } ^ { p + 1 } D \Phi _ { t _ { k } } ^ { T } ( z _ { k } ) l ( t _ { k } , z _ { k } ) \right. + } \end{array}$ $p _ { ; }$ , the error of $( - h _ { k } ) ^ { p + 1 } D \Phi _ { T } ^ { t _ { k } } ( { \overline { { z _ { k } } } } ) \overline { { l ( t _ { k } , { \overline { { z _ { k } } } } ) } } ] + O ( h ^ { p + 1 } )$ , where $\Phi$ is the ideal solution, $D \Phi$ is the Jacobian of $\Phi , l ( t , z )$ and $\overline { { l ( t , z ) } }$ are the local error in forward-time and reverse-time integration respectively.
+
+Theorem 2.1 is stated as Theorem 3.2 in Zhuang et al. (2020); please see reference paper for detailed proof. To summarize, due to inevitable errors with numerical ODE solvers, the reverse-time trajectory (red curve, $\overline { { z } } ( \tau )$ ) cannot match the forward-time trajectory (blue curve, $z ( t ) .$ ) accurately. The error in $\overline { z }$ propagates to $\textstyle { \frac { \mathrm { d } L } { \mathrm { d } \theta } }$ by Eq. 2, hence affects the accuracy in gradient estimation.
+
+Adaptive checkpoint adjoint (ACA) To solve the inaccuracy of adjoint method, Zhuang et al. (2020) proposed ACA: ACA stores forward-time trajectory in memory for backward-pass, hence guarantees accuracy; ACA deletes the search process (green curve in Fig. 2), and only backpropagates through the accepted step (blue curve in Fig. 2), hence has a shallower computation graph $( N _ { f } \times N _ { t }$ for ACA vs $N _ { f } \times N _ { t } \times m$ for naive method). ACA only stores $\{ z ( t _ { i } ) \} _ { i = 1 } ^ { N _ { t } }$ , and deletes the computation graph for $\{ f ( z ( t _ { i } ) , t _ { i } ) \} _ { i = 1 } ^ { N _ { t } }$ , hence the memory cost is $N _ { z } ( N _ { f } + N _ { t } )$ . Though the memory cost is much smaller than the naive method, it grows linearly with $N _ { t }$ , and can not handle very high dimensional models. In the following sections, we propose a method to overcome all these disadvantages of existing methods.
+
+# 3 METHODS
+
+# 3.1 ASYNCHRONOUS LEAPFROG INTEGRATOR
+
+In this section we give a brief introduction to the asynchronous leapfrog (ALF) method (Mutze, 2013), and we provide theoretical analysis which is missing in Mutze (2013). For general firstorder ODEs in the form of Eq. 1, the tuple $( z , t )$ is sufficient for most ODE solvers to take a step numerically. For ALF, the required tuple is $( z , v , t )$ , where $v$ is the “approximated derivative”. Most numerical ODE solvers such as the Runge-Kutta method (Runge, 1895) track state $z$ evolving with time, while ALF tracks the “augmented state” $( z , v )$ . We explain the details of ALF as below.
+
+# Algorithm 2: Forward of $\psi$ in ALF
+
+<table><tr><td>Input (zin, Uin, Sin,h) where Sin is current time, Zin and Uin are correponding values at time Sin,h is stepsize.</td></tr><tr><td>Forward S1 = Sin +h/2</td></tr><tr><td>k1 = Zin + Uin × h/2</td></tr><tr><td></td></tr><tr><td>u1 = f(k1,S1)</td></tr><tr><td>Uout = Uin + 2(u1 - Uin)</td></tr><tr><td>Zout = k1 + Uout × h/2</td></tr><tr><td>Sout = S1 +h/2 Output (Zout,Vout, Sout,h)</td></tr></table>
+
+Algorithm 3: $\psi ^ { - 1 }$ (Inverse of $\psi$ ) in ALF   
+
+<table><tr><td colspan="2">Input (zout, Uout, Sout,h) where Sout is current time, Zout and vout are corresponding values at Sout,h is stepsize. Inverse S1 = Sout -h/2 k1 = Zout - Uout X h/2 u1 = f(k1,S1)</td></tr></table>
+
+Procedure of ALF Different ODE solvers have different $\psi$ in Algo. 1, hence we only summarize $\psi$ for ALF in Algo. 2. Note that for a complete algorithm of integration for ALF, we need to plug Algo. 2 into Algo. 1. The forward-pass is summarized in Algo. 2. Given stepsize $h$ , with input $( z _ { i n } , v _ { i n } , s _ { i n } )$ , a single step of ALF outputs $( z _ { o u t } , v _ { o u t } , s _ { o u t } )$ .
+
+![](images/da4dde8b53890c9e783c1ad01b8224fb995c8dfef6b9f8608c5ca38f19fdbd37.jpg)  
+$( z _ { j } , v _ { j } , t _ { j } )$ With ALF method, given and discretized time points $\{ t _ { i } \} _ { i = 1 } ^ { N _ { t } }$ rately due to the reversibility of ALF.
+
+As in Fig. 3, given $( z _ { 0 } , v _ { 0 } , t _ { 0 } )$ , the numerical forwardtime integration calls Algo. 2 iteratively:
+
+$$
+\begin{array} { r } { ( z _ { i } , v _ { i } , t _ { i } , h _ { i } ) = \psi ( z _ { i - 1 } , v _ { i - 1 } , t _ { i - 1 } , h _ { i } ) } \\ { s . t . \ h _ { i } = t _ { i } - t _ { i - 1 } , \ i = 1 , 2 , . . . N _ { t } } \end{array}
+$$
+
+Invertibility of ALF An interesting property of ALF is that $\psi$ defines a bijective mapping; therefore, we can reconstruct $( z _ { i n } , v _ { i n } , s _ { i n } , h )$ from $( z _ { o u t } , v _ { o u t } , s _ { o u t } , h )$ , as demonstrated in Algo. 7. As in Fig. 3, we can reconstruct the entire trajectory given the state $( z _ { j } , v _ { j } )$ at time $t _ { j }$ , and the discretized time points $\left\{ { t } _ { 0 } , . . . t _ { N _ { t } } \right\}$ . For example, given $\left( z _ { N _ { t } } , v _ { N _ { t } } \right)$ and $\{ t _ { i } \} _ { i = 0 } ^ { N _ { t } }$ , the trajectory for Eq. 4 is reconstructed:
+
+$$
+( z _ { i - 1 } , v _ { i - 1 } , t _ { i - 1 } , h _ { i } ) = \psi ^ { - 1 } ( z _ { i } , v _ { i } , t _ { i } , h _ { i } ) { \ s . t . \ h } _ { i } = t _ { i } - t _ { i - 1 } , { \ i = N _ { t } , N _ { t } - 1 , . . . , 1 }
+$$
+
+In the following sections, we will show the invertibility of ALF is the key to maintain accuracy at a constant memory cost to train Neural ODEs. Note that “inverse” refers to reconstructing the input from the output without computing the gradient, hence is different from “back-propagation”.
+
+Initial value For an initial value problem (IVP) such as Eq. 1, typically $z _ { 0 } = z ( t _ { 0 } )$ is given while $v _ { 0 }$ is undetermined. We can construct $v _ { 0 } = f ( z ( t _ { 0 } ) , t _ { 0 } )$ , so the initial augmented state is $( z _ { 0 } , v _ { 0 } )$ .
+
+Difference from midpoint integrator The midpoint integrator (Suli & Mayers, 2003) is similar ¨ to Algo. 2, except that it recomputes $v _ { i n } = f ( z _ { i n } , s _ { i n } )$ for every step, while ALF directly uses the input $v _ { i n }$ . Therefore, the midpoint method does not have an explicit form of inverse.
+
+Local truncation error Theorem 3.1 indicates that the local truncation error of ALF is of order $O ( h ^ { 3 } )$ ; this implies the global error is $O ( h ^ { 2 } )$ . Detailed proof is in Appendix A.3.
+
+Theorem 3.1. For a single step in ALF with stepsize $h$ , the local truncation error of $z$ is $O ( h ^ { 3 } )$ , and the local truncation error of v is $O ( h ^ { 2 } )$ .
+
+A-Stability The ALF solver has a limited stability region, but this can be solved with damping. The damped ALF replaces the update of $v _ { o u t }$ in Algo. 2 with $v _ { o u t } = v _ { i n } + 2 \eta ( u _ { 1 } - v _ { i n } )$ , where $\eta$ is the “damping coefficient” between 0 and 1. We have the following theorem on its numerical stability.
+
+Theorem 3.2. For the damped ALF integrator with stepsize $h$ , where $\sigma _ { i }$ is the $i$ -th eigenvalue of the Jacobian $\frac { \partial f } { \partial z }$ , then the solver is $A$ -stable $\left. \dot { \tau } f \right| 1 + \eta ( h \sigma _ { i } - 1 ) \pm \sqrt { \eta \big [ 2 h \sigma _ { i } + \eta ( h \sigma _ { i } - 1 ) ^ { 2 } \big ] } \Big | < 1$ , ∀i
+
+Proof is in Appendix A.4 and A.5. Theorem 3.2 implies the following: when $\eta = 1$ , the damped ALF reduces to ALF, and the stability region is empty; when $0 < \eta < 1$ , the stability region is nonempty. However, stability describes the behaviour when $T$ goes to infinity; in practice we always use a bounded $T$ and ALF performs well. Inverse of damped ALF is in Appendix A.5.
+
+# 3.2 MEMORY-EFFICIENT ALF INTEGRATOR (MALI) FOR GRADIENT ESTIMATION
+
+An ideal solver for Neural ODEs should achieve two goals: accuracy in gradient estimation and constant memory cost w.r.t integration time. Yet none of the existing methods can achieve both goals. We propose a method based on the ALF solver, which to our knowledge is the first method to achieve the two goals simultaneously.
+
+<table><tr><td>Algorithm 4: MALI to acheive accuracy at a constant memory cost w.r.t integration time</td></tr><tr><td>Input Initial state zo, start time to, end time T</td></tr><tr><td>Forward Apply the numerical integration in Algo.1, with the  function defined by Algo. 2.</td></tr><tr><td>Delete computation graph on the fly, only keep end-time state (zNt, UNt）</td></tr><tr><td></td></tr><tr><td>Keep accepted discretized time points {ti}N=0 (ignore processto search for optimal stepsize) Backward</td></tr><tr><td>8L by Eq.3,initialize dL =0</td></tr><tr><td>Initialize a(T) = (T) d</td></tr><tr><td>For i in {Nt,Nt -1,..,2,1}:</td></tr><tr><td>Reconstruct (zi-1, Ui-1) from (zi,Ui) by Algo.7 Local forward (zi,Ui,ti,hi)= γ(zi-1,Ui-1,ti-1,hi)</td></tr><tr><td>Local backward, get Of(zi-1,ti-1,0) and f（2i-1ti-1,0)</td></tr><tr><td>dzi-1 80 dL</td></tr><tr><td>Update a(t) and byEq.2 and Eq. 3 discretized at time points ti-1 and ti de</td></tr><tr><td>Delete local computation graph</td></tr><tr><td>Output the adjoint state a(to) (gradient w.r.t input zo) and parameter gradient</td></tr></table>
+
+Procedure of MALI Details of MALI are summarized in Algo. 4. For the forward-pass, we only keep the end-time state $\left( z _ { N _ { t } } , v _ { N _ { t } } \right)$ and the accepted discretized time points (blue curves in Fig. 1 and 2). We ignore the search process for optimal stepsize (green curve in Fig. 1 and 2), and delete other variables to save memory. During the backward pass, we can reconstruct the forward-time trajectory as in Eq. 5, then calculate the gradient by numerical discretization of Eq. 2 and Eq. 3.
+
+Constant memory cost w.r.t number of solver steps in integration We delete the computation graph and only keep the end-time state to save memory. The memory cost is $N _ { z } ( N _ { f } + 1 )$ , where
+
+![](images/72f602b837ed8e185f46ef9611847d89781d838c60ee6b4f4fd38f08381e9dc4.jpg)  
+Figure 4: Comparison of error in gradient in Eq. 6. (a) error in $\scriptstyle { \frac { \mathrm { d } L } { \mathrm { d } z _ { 0 } } }$ . (b) error in $\textstyle { \frac { \mathrm { d } L } { \mathrm { d } \alpha } }$ . (c) memory cost.
+
+![](images/a5790d97491493f8fedf10284fe335bda1b1750debbcc4560d4977556c8c12ca.jpg)  
+Figure 5: Results on Cifar10. From left to right: (1) box plot of test accuracy (first 4 columns are Neural ODEs, last is ResNet); (2) test accuracy $\pm s t d$ v.s. training epoch for Neural ODE; (3) test accuracy $\pm s t d$ v.s. training time of 90 epochs for Neural ODE.
+
+$N _ { z } N _ { f }$ is due to evaluating $f ( \boldsymbol { z } , t )$ and is irreducible for all methods. Compared with the adjoint method, MALI only requires extra $N _ { z }$ memory to record $v _ { N _ { t } }$ , and also has a constant memory cost $w . r . t$ time step $N _ { t }$ . The memory cost is $N _ { z } ( N _ { f } + 1 )$ .
+
+Accuracy Our method guarantees the accuracy of reverse-time trajectory (e.g. blue curve in Fig. 2 matches the blue curve in Fig. 1), because ALF is explicitly invertible for free-form $f$ (see Algo. 7). Therefore, the gradient estimation in MALI is more accurate compared to the adjoint method.
+
+Computation cost Recall that on average it takes $m$ steps to find an acceptable stepsize, whose error estimate is below tolerance. Therefore, the forward-pass with search process has computation burden $N _ { z } \times N _ { f } \times N _ { t } \times m$ . Note that we only reconstruct and backprop through the accepted step and ignore the search process, hence it takes another $N _ { z } \times N _ { f } \times N _ { t } \times 2$ computation. The overall computation burden is $N _ { z } N _ { f } \times N _ { t } \times ( m + 2 )$ as in Table 1.
+
+Shallow computation graph Similar to ACA, MALI only backpropagates through the accepted step (blue curve in Fig. 2) and ignores the search process (green curve in Fig. 2), hence the depth of computation graph is $N _ { f } \times N _ { t }$ . The computation graph of MALI is much shallower than the naive method, hence is more robust to vanishing and exploding gradients (Pascanu et al., 2013).
+
+Summary The adjoint method suffers from inaccuracy in reverse-time trajectory, the naive method suffers from exploding or vanishing gradient caused by deep computation graph, and ACA finds a balance but the memory grows linearly with integration time. MALI achieves accuracy in reversetime trajectory, constant memory $w . r . t$ integration time, and a shallow computation graph.
+
+# 4 EXPERIMENTS
+
+# 4.1 VALIDATION ON A TOY EXAMPLE
+
+We compare the performance of different methods on a toy example, defined as
+
+$$
+L ( z ( T ) ) = z ( T ) ^ { 2 } \ s . t . \ z ( 0 ) = z _ { 0 } , \ \mathrm { d } z ( t ) / \mathrm { d } t = \alpha z ( t )
+$$
+
+The analytical solution is
+
+$$
+z ( t ) = z _ { 0 } e ^ { \alpha t } , L = z _ { 0 } ^ { 2 } e ^ { 2 \alpha T } , \mathrm { d } L / \mathrm { d } z _ { 0 } = 2 z _ { 0 } e ^ { 2 \alpha T } , \mathrm { d } L / d \alpha = 2 T z _ { 0 } ^ { 2 } e ^ { 2 \alpha T }
+$$
+
+We plot the amplitude of error between numerical solution and analytical solution varying with $T$ (integrated under the same error tolerance, $\mathrm { r t o l } = 1 0 ^ { - 5 } , \mathrm { a t o l } = 1 0 ^ { - 6 } )$ in Fig 4. ACA and MALI have similar errors, both outperforming other methods. We also plot the memory consumption for different methods on a Neural ODE with the same input in Fig. 4. As the error tolerance decreases, the solver evaluates more steps, hence the naive method and ACA increase memory consumption, while MALI and the adjoint method have a constant memory cost. These results validate our analysis in Sec. 3.2 and Table 1, and shows MALI achieves accuracy at a constant memory cost.
+
+Table 2: Top-1 test accuracy of Neural ODE and ResNet on ImageNet. Neural ODE is trained with MALI, and ResNet is trained as the original model; Neural ODE is tested using different solvers without retraining.   
+
+<table><tr><td rowspan="2"></td><td colspan="6">Fixed-stepsize solvers of various stepsizes</td><td colspan="4">Adaptive-stepsize solver of various tolerances</td></tr><tr><td>Stepsize</td><td>1</td><td>0.5</td><td>0.25</td><td>0.15</td><td>0.1</td><td>Tolerance</td><td>1.00E+00</td><td>1.00E-01</td><td>1.00E-02</td></tr><tr><td rowspan="4">Neural ODE</td><td>MALI</td><td>42.33</td><td>66.4</td><td>69.59</td><td>70.17</td><td>69.94</td><td>MALI</td><td>62.56</td><td>69.89</td><td>69.87</td></tr><tr><td>Euler</td><td>21.94</td><td>61.25</td><td>67.38</td><td>68.69</td><td>70.02</td><td>Heun-Euler</td><td>68.48</td><td>69.87</td><td>69.88</td></tr><tr><td>RK2</td><td>42.33</td><td>69</td><td>69.72</td><td>70.14</td><td>69.92</td><td>RK23</td><td>50.77</td><td>69.89</td><td>69.93</td></tr><tr><td>RK4</td><td>12.6</td><td>69.99</td><td>69.91</td><td>70.21</td><td>69.96 70.09</td><td>Dopri5</td><td>52.3</td><td>68.58</td><td>69.71</td></tr><tr><td>ResNet</td><td colspan="14"></td></tr></table>
+
+Table 3: Top-1 accuracy under FGSM attack. $\epsilon$ is the perturbation amplitude. For Neural ODE models, row names represent the solvers to derive the gradient for attack, and column names represent solvers for inference on the perturbed image.   
+
+<table><tr><td rowspan="2" colspan="2"></td><td colspan="4">∈=1/255</td><td colspan="4">∈=2/255</td></tr><tr><td>MALI</td><td>Heun-Euler</td><td>RK23</td><td>Dopri5</td><td>MALI</td><td>Heun-Euler</td><td>RK23</td><td>Dopri5</td></tr><tr><td rowspan="4">Neural ODE</td><td>MALI</td><td>14.69</td><td>14.72</td><td>14.77</td><td>15.71</td><td>10.38</td><td>10.46</td><td>10.62</td><td>10.62</td></tr><tr><td>Heun-Euler</td><td>14.77</td><td>14.75</td><td>14.80</td><td>15.74</td><td>10.63</td><td>10.47</td><td>10.44</td><td>10.49</td></tr><tr><td>RK23</td><td>14.82</td><td>14.77</td><td>14.79</td><td>15.69</td><td>10.78</td><td>10.53</td><td>10.48</td><td>10.56</td></tr><tr><td>Dopri5</td><td>14.82</td><td>14.78</td><td>14.79</td><td>15.15</td><td>10.76</td><td>10.49</td><td>10.48</td><td>10.51</td></tr><tr><td colspan="2">ResNet</td><td colspan="4">13.02</td><td colspan="4">9.57</td></tr></table>
+
+# 4.2 IMAGE RECOGNITION WITH NEURAL ODE
+
+We validate MALI on image recognition tasks using Cifar10 and ImageNet datasets. Similar to Zhuang et al. (2020), we modify a ResNet18 into its corresponding Neural ODE: the forward function is $y = x + f _ { \theta } ( x )$ and $\begin{array} { r } { y = \overset { \cdot } { x } + \int _ { 0 } ^ { T } f _ { \theta } ( z ) \mathrm { d } t } \end{array}$ for the residual block and Neural ODE respectively, where the same $f _ { \theta }$ is shared. We compare MALI with the naive method, adjoint method and ACA.
+
+Results on Cifar10 Results of 5 independent runs on Cifar10 are summarized in Fig. 5. MALI achieves comparable accuracy to ACA, and both significantly outperform the naive and the adjoint method. Furthermore, the training speed of MALI is similar to ACA, and both are almost two times faster than the adjoint memthod, and three times faster than the naive method. This validates our analysis on accuracy and computation burden in Table 1.
+
+Accuracy on ImageNet Due to the heavy memory burden caused by large images, the naive method and ACA are unable to train a Neural ODE on ImageNet with 4 GPUs; only MALI and the adjoint method are feasible due to the constant memory. We also compare the Neural ODE to a standard ResNet. As shown in Fig. 6, the accuracy of the Neural ODE trained with MALI closely follows ResNet, and significantly outperforms the adjoint method (top-1 validation: $70 \%$ v.s. $63 \%$ ).
+
+![](images/5baeedcaa97100e0df410b2d664c7ea69138b65803c881e78de14fc713349129.jpg)  
+Figure 6: Top-1 accuracy on ImageNet validation dataset.
+
+Invariance to discretization scheme A continuous model should be invariant to discretization schemes (e.g. different types of ODE solvers) as long as the discretization is sufficiently accurate. We test the Neural ODE using different solvers without re-training; since ResNet is often viewed as a one-step Euler discretization of an ODE (Haber & Ruthotto, 2017), we perform similar experiments. As shown in Table 2, Neural ODE consistently achieves high accuracy $( \sim 7 0 \% )$ , while ResNet drops to random guessing $( \sim 0 . 1 \% )$ because ResNet as a one-step Euler discretization fails to be a meaningful dynamical system (Queiruga et al., 2020).
+
+Robustness to adversarial attack Hanshu et al. (2019) demonstrated that Neural ODE is more robust to adversarial attack than ResNet on small-scale datasets such as Cifar10. We validate this result on the large-scale ImageNet dataset. The top-1 accuracy of Neural ODE and ResNet under FGSM attack (Goodfellow et al., 2014) are summarized in Table 3. For Neural ODE, due to its invariance to discretization scheme, we derive the gradient for attack using a certain solver (row in
+
+Table 4: Test MSE $( \times 0 . 0 1 )$ on Mujoco dataset (lower is better). Results marked with superscript numbers correspond to literature in the footnote.   
+
+<table><tr><td rowspan="2">Percentage of training data</td><td rowspan="2">RNN1</td><td rowspan="2">RNN-GRU1</td><td colspan="4">Latent-ODE</td></tr><tr><td>Adjoint1</td><td>Naive2</td><td>ACA²</td><td>MALI</td></tr><tr><td>10%</td><td>2.451</td><td>1.972</td><td>0.471</td><td>0.362</td><td>0.312</td><td>0.35</td></tr><tr><td>20%</td><td>1.711</td><td>1.421</td><td>0.441</td><td>0.30²</td><td>0.272</td><td>0.27</td></tr><tr><td>50%</td><td>0.791</td><td>0.751</td><td>0.401</td><td>0.292</td><td>0.262</td><td>0.26</td></tr></table>
+
+Table 5: Test ACC on Speech Command Dataset   
+
+<table><tr><td>Method</td><td>Accuracy (%)</td></tr><tr><td>Adjoint3</td><td>92.8± 0.4</td></tr><tr><td>SemiNorm3</td><td>92.9 ±0.4</td></tr><tr><td>Naive ACA</td><td>93.2±0.2</td></tr><tr><td>MALI</td><td>93.2±0.2</td></tr><tr><td></td><td>93.7 ±0.3</td></tr></table>
+
+Table 3), and inference on the perturbed images using various solvers. For different combinations of solvers and perturbation amplitudes, Neural ODE consistently outperforms ResNet.
+
+Summary In image recognition tasks, we demonstrate Neural ODE is accurate, invariant to discretization scheme, and more robust to adversarial attack than ResNet. Note that detailed explanation on the robustness of Neural ODE is out of the scope for this paper, but to our knowledge, MALI is the first method to enable training of Neural ODE on large datasets due to constant memory cost.
+
+# 4.3 TIME-SERIES MODELING
+
+We apply MALI to latent-ODE (Rubanova et al., 2019) and Neural Controlled Differential Equation (Neural CDE) (Kidger et al., 2020a;b). Our experiment is based on the official implementation from the literature. We report the mean squared error (MSE) on the Mujoco test set in Table 4, which is generated from the “Hopper” model using DeepMind control suite (Tassa et al., 2018); for all experiments with different ratios of training data, MALI achieves similar MSE to ACA, and both outperform the adjoint and naive method. We report the test accuracy on the Speech Command dataset for Neural CDE in Table 5; MALI achieves a higher accuracy than competing methods.
+
+# 4.4 CONTINUOUS GENERATIVE MODELS
+
+We apply MALI on FFJORD (Grathwohl et al., 2018), a free-from continuous generative model, and compare with several variants in the literature (Finlay et al., 2020; Kidger et al., 2020a). Our experiment is based on the official implementaion of Finlay et al. (2020); for a fair comparison, we train with MALI, and test with the same solver as in the literature (Grathwohl et al., 2018; Finlay et al., 2020), the Dopri5 solver with $\mathrm { r t o l } = \mathrm { a t o l } = 1 0 ^ { - 5 }$ from the torchdiffeq package (Chen et al., 2018). Bits per dim (BPD, lower is better) on validation set for various datasets are reported in Table 6. For continuous models, MALI consistently generates the lowest BPD, and outperforms the Vanilla FFJORD (trained with adjoint), RNODE (regularized FFJORD) and the SemiNorm Adjoint (Kidger et al., 2020a). Furthermore, FFJORD trained with MALI achieves comparable BPD to stateof-the-art discrete-layer flow models in the literature. Please see Sec. B.3 for generated samples.
+
+# 5 RELATED WORKS
+
+Besides ALF, the symplectic integrator (Verlet, 1967; Yoshida, 1990) is also able to reconstruct trajectory accurately, yet it’s typically restricted to second order Hamiltonian systems (De Almeida, 1990), and are unsuitable for general ODEs. Besides aforementioned methods, there are other methods for gradient estimation such as interpolated adjoint (Daulbaev et al., 2020) and spectral method (Quaglino et al., 2019), yet the implementations are involved and not publicly available. Other works focus on the theoretical properties of Neural ODEs (Dupont et al., 2019; Tabuada & Gharesifard, 2020; Massaroli et al., 2020). Neural ODE is recently applied to stochastic differential equation (Li et al., 2020), jump differential equation (Jia & Benson, 2019) and auto-regressive models (Wehenkel & Louppe, 2019).
+
+# 6 CONCLUSION
+
+Based on the asynchronous leapfrog integrator, we propose MALI to estimate the gradient for Neural ODEs. To our knowledge, our method is the first to achieve accuracy, fast speed and a constant memory cost. We provide comprehensive theoretical analysis on its properties. We validate MALI
+
+Table 6: Bits per dim (BPD) of generative models, lower is better. Results marked with superscript numbers correspond to literature in the footnote.   
+
+<table><tr><td rowspan="2">Dataset</td><td colspan="4">Continuous Flow (FFJORD)</td><td colspan="5">Discrete Flow</td></tr><tr><td>Vanilla4</td><td>RNODE5</td><td>SemiNorm3</td><td>MALI</td><td>RealNVP6</td><td>i-ResNet</td><td>Glow8</td><td>Flow++9</td><td>Residual Flow10</td></tr><tr><td>MNIST</td><td>0.994</td><td>0.975</td><td>0.963</td><td>0.87</td><td>1.066</td><td>1.057</td><td>1.058</td><td>-</td><td>0.9710</td></tr><tr><td>CIFAR10</td><td>3.404</td><td>3.385</td><td>3.353</td><td>3.27</td><td>3.496</td><td>3.457</td><td>3.358</td><td>3.289</td><td>3.2810</td></tr><tr><td>ImageNet64</td><td>-</td><td>3.835</td><td>-</td><td>3.71</td><td>3.986</td><td>-</td><td>3.818</td><td>=</td><td>3.7610</td></tr></table>
+
+with extensive experiments, and achieved new state-of-the-art results in various tasks, including image recognition, continuous generative modeling, and time-series modeling.
+
+# 7 ACKNOWLEDGEMENT
+
+This research was funded by the National Institutes of Health (NINDS-R01NS035193)
+
+# REFERENCES
+
+Jens Behrmann, Will Grathwohl, Ricky TQ Chen, David Duvenaud, and Jorn-Henrik Jacobsen. ¨ Invertible residual networks. In International Conference on Machine Learning, pp. 573–582, 2019.
+
+Ricky TQ Chen, Yulia Rubanova, Jesse Bettencourt, and David K Duvenaud. Neural ordinary differential equations. In Advances in Neural Information Processing Systems, pp. 6571–6583, 2018.
+
+Ricky TQ Chen, Jens Behrmann, David K Duvenaud, and Jorn-Henrik Jacobsen. Residual flows ¨ for invertible generative modeling. In Advances in Neural Information Processing Systems, pp. 9916–9926, 2019.
+
+Talgat Daulbaev, Alexandr Katrutsa, Larisa Markeeva, Julia Gusak, Andrzej Cichocki, and Ivan Oseledets. Interpolated adjoint method for neural odes. arXiv preprint arXiv:2003.05271, 2020.
+
+Alfredo M Ozorio De Almeida. Hamiltonian systems: chaos and quantization. Cambridge University Press, 1990.
+
+Laurent Dinh, Jascha Sohl-Dickstein, and Samy Bengio. Density estimation using real nvp. arXiv preprint arXiv:1605.08803, 2016.
+
+Emilien Dupont, Arnaud Doucet, and Yee Whye Teh. Augmented neural odes. In Advances in Neural Information Processing Systems, pp. 3140–3150, 2019.
+
+Chris Finlay, Jorn-Henrik Jacobsen, Levon Nurbekyan, and Adam M Oberman. How to train your ¨ neural ode: the world of jacobian and kinetic regularization. In International Conference on Machine Learning, 2020.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014.
+
+Will Grathwohl, Ricky TQ Chen, Jesse Bettencourt, Ilya Sutskever, and David Duvenaud. Ffjord: Free-form continuous dynamics for scalable reversible generative models. arXiv preprint arXiv:1810.01367, 2018.
+
+Eldad Haber and Lars Ruthotto. Stable architectures for deep neural networks. Inverse Problems, 34(1):014004, 2017.
+
+YAN Hanshu, DU Jiawei, TAN Vincent, and FENG Jiashi. On robustness of neural ordinary differential equations. In International Conference on Learning Representations, 2019.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Jonathan Ho, Xi Chen, Aravind Srinivas, Yan Duan, and Pieter Abbeel. Flow $^ { + + }$ : Improving flowbased generative models with variational dequantization and architecture design. arXiv preprint arXiv:1902.00275, 2019.
+
+Junteng Jia and Austin R Benson. Neural jump stochastic differential equations. In Advances in Neural Information Processing Systems, pp. 9847–9858, 2019.
+
+Patrick Kidger, Ricky T. Q. Chen, and Terry Lyons. “Hey, that’s not an ODE”: Faster ODE Adjoints with 12 Lines of Code. arXiv:2009.09457, 2020a.
+
+Patrick Kidger, James Morrill, James Foster, and Terry Lyons. Neural controlled differential equations for irregular time series. arXiv preprint arXiv:2005.08926, 2020b.
+
+Durk P Kingma and Prafulla Dhariwal. Glow: Generative flow with invertible 1x1 convolutions. In Advances in Neural Information Processing Systems, pp. 10215–10224, 2018.
+
+Xuechen Li, Ting-Kam Leonard Wong, Ricky TQ Chen, and David Duvenaud. Scalable gradients for stochastic differential equations. arXiv preprint arXiv:2001.01328, 2020.
+
+Kuang Liu. Train cifar10 with pytorch. 2017. URL https://github.com/kuangliu/ pytorch-cifar.
+
+Yiping Lu, Aoxiao Zhong, Quanzheng Li, and Bin Dong. Beyond finite layer neural networks: Bridging deep architectures and numerical differential equations. In International Conference on Machine Learning, pp. 3276–3285. PMLR, 2018.
+
+Stefano Massaroli, Michael Poli, Jinkyoo Park, Atsushi Yamashita, and Hajime Asama. Dissecting neural odes. arXiv preprint arXiv:2002.08071, 2020.
+
+Ulrich Mutze. An asynchronous leapfrog method ii. arXiv preprint arXiv:1311.6602, 2013.
+
+Razvan Pascanu, Tomas Mikolov, and Yoshua Bengio. On the difficulty of training recurrent neural networks. In International conference on machine learning, pp. 1310–1318, 2013.
+
+Lev Semenovich Pontryagin. Mathematical theory of optimal processes. Routledge, 1962.
+
+Alessio Quaglino, Marco Gallieri, Jonathan Masci, and Jan Koutn´ık. Snode: Spectral discretization of neural odes for system identification. arXiv preprint arXiv:1906.07038, 2019.
+
+Alejandro F Queiruga, N Benjamin Erichson, Dane Taylor, and Michael W Mahoney. Continuousin-depth neural networks. arXiv preprint arXiv:2008.02389, 2020.
+
+Yulia Rubanova, Ricky TQ Chen, and David K Duvenaud. Latent ordinary differential equations for irregularly-sampled time series. In Advances in Neural Information Processing Systems, pp. 5320–5330, 2019.
+
+Carl Runge. Uber die numerische aufl ¨ osung von differentialgleichungen. ¨ Mathematische Annalen, 46(2):167–178, 1895.
+
+Lars Ruthotto and Eldad Haber. Deep neural networks motivated by partial differential equations. Journal of Mathematical Imaging and Vision, pp. 1–13, 2019.
+
+Lars Ruthotto, Stanley J Osher, Wuchen Li, Levon Nurbekyan, and Samy Wu Fung. A machine learning framework for solving high-dimensional mean field game and mean field control problems. Proceedings of the National Academy of Sciences, 117(17):9183–9193, 2020.
+
+Alvaro Sanchez-Gonzalez, Victor Bapst, Kyle Cranmer, and Peter Battaglia. Hamiltonian graph networks with ode integrators. arXiv preprint arXiv:1909.12790, 2019.
+
+John R Silvester. Determinants of block matrices. The Mathematical Gazette, 84(501):460–467, 2000.
+
+Endre Suli and David F Mayers. ¨ An introduction to numerical analysis. Cambridge university press, 2003.
+
+Paulo Tabuada and Bahman Gharesifard. Universal approximation power of deep neural networks via nonlinear control theory. arXiv preprint arXiv:2007.06007, 2020.
+
+Yuval Tassa, Yotam Doron, Alistair Muldal, Tom Erez, Yazhe Li, Diego de Las Casas, David Budden, Abbas Abdolmaleki, Josh Merel, Andrew Lefrancq, et al. Deepmind control suite. arXiv preprint arXiv:1801.00690, 2018.
+
+Loup Verlet. Computer” experiments” on classical fluids. i. Thermodynamical properties of Lennard-Jones molecules. Physical review, 159(1):98, 1967.
+
+Gerhard Wanner and Ernst Hairer. Solving ordinary differential equations II. Springer Berlin Heidelberg, 1996.
+
+Antoine Wehenkel and Gilles Louppe. Unconstrained monotonic neural networks. In Advances in Neural Information Processing Systems, pp. 1545–1555, 2019.
+
+E Weinan. A proposal on machine learning via dynamical systems. Communications in Mathematics and Statistics, 5(1):1–11, 2017.
+
+Haruo Yoshida. Construction of higher order symplectic integrators. Physics letters A, 150(5-7): 262–268, 1990.
+
+Yaofeng Desmond Zhong, Biswadip Dey, and Amit Chakraborty. Symplectic ode-net: Learning hamiltonian dynamics with control. arXiv preprint arXiv:1909.12077, 2019.
+
+Juntang Zhuang, Nicha Dvornek, Xiaoxiao Li, Sekhar Tatikonda, Xenophon Papademetris, and James Duncan. Adaptive checkpoint adjoint method for gradient estimation in neural ode. International Conference on Machine Learning, 2020.
+
+# CONTENTS (APPENDIX)
+
+# A Theoretical properties of ALF integrator 13
+
+A.1 Algorithm of ALF . 13   
+A.2 Preliminaries 13   
+A.3 Local truncation error of ALF 13   
+A.4 Stability analysis 15   
+A.5 Damped ALF 16
+
+# B Experimental Details
+
+# 1
+
+B.1 Image Recognition 18
+
+B.1.1 Experiment on Cifar10 18   
+B.1.2 Experiments on ImageNet 18   
+B.2 Time series modeling 19   
+B.3 Continuous generative models 20   
+B.3.1 Training details . 20   
+B.3.2 Addtional results 20   
+B.4 Error in gradient estimation for toy examples when $t < 1$ 20   
+B.5 Results of damped MALI 20
+
+# A THEORETICAL PROPERTIES OF ALF INTEGRATOR
+
+# A.1 ALGORITHM OF ALF
+
+For the ease of reading, we write the algorithm for $\psi$ in ALF below, which is the same as Algo. 2 in the main paper, but uses slightly different notations for the ease of analysis.
+
+# Algorithm 1: Forward of $\psi$ in ALF
+
+Input $( \widehat { z _ { i n } } , \widehat { v _ { i n } } , s _ { i n } , h ) = ( \widehat { z _ { 0 } } , \widehat { v _ { 0 } } , s _ { 0 } , h )$ where $s _ { 0 }$ is current time, $\widehat { z } _ { 0 }$ and $\widehat { v _ { 0 } }$ are correponding c cvalues at time $s _ { 0 }$ ; stepsize $h$ .
+
+Forward
+
+$$
+\begin{array} { r l } & { s _ { 1 } = s _ { 0 } + h / 2 } \\ & { \widehat { z } _ { 1 } = \widehat { z } _ { 0 } + \widehat { v } _ { 0 } \times h / 2 } \\ & { \widehat { v } _ { 1 } = f \big ( \widehat { z } _ { 1 } , s _ { 1 } \big ) } \\ & { \widehat { v } _ { 2 } = \widehat { v } _ { 1 } + \big ( \widehat { v } _ { 1 } - \widehat { v } _ { 0 } \big ) } \\ & { \widehat { z } _ { 2 } = \widehat { z } _ { 1 } + \widehat { v } _ { 2 } \times h / 2 } \\ & { s _ { 2 } = s _ { 1 } + h / 2 } \end{array}
+$$
+
+# Output
+
+$$
+( \widehat { z _ { o u t } } , \widehat { v _ { o u t } } , s _ { o u t } , h ) = ( \widehat { z _ { 2 } } , \widehat { v _ { 2 } } , s _ { 2 } , h )
+$$
+
+For simplicity, we can re-write the forward of ALF as
+
+$$
+\begin{array} { r } { [ \widehat { z _ { 2 } } ] = [ { \widehat { z _ { 0 } } } + h f ( \widehat { z _ { 0 } } + \frac { h } { 2 } \widehat { v _ { 0 } } , s _ { 0 } + \frac { h } { 2 } ) ] } \\ { \widehat { v _ { 2 } } ] = [ 2 f ( \widehat { z _ { 0 } } + \frac { h } { 2 } \widehat { v _ { 0 } } , s _ { 0 } + \frac { h } { 2 } ) - \widehat { v _ { 0 } } ] } \end{array}
+$$
+
+Similarly, the inverse of ALF can be written as
+
+$$
+\begin{array} { r } { \left[ \widehat { z _ { 0 } } \right] = \left[ { \widehat { z _ { 2 } } } - h f ( \widehat { z _ { 2 } } - \frac { h } { 2 } \widehat { v _ { 2 } } , s _ { 2 } - \frac { h } { 2 } ) \right] } \\ { 2 f ( \widehat { z _ { 2 } } - \frac { h } { 2 } \widehat { v _ { 2 } } , s _ { 2 } - \frac { h } { 2 } ) - \widehat { v _ { 2 } } } \end{array}
+$$
+
+# A.2 PRELIMINARIES
+
+For an ODE of the form
+
+$$
+\frac { \mathrm { d } \boldsymbol { z } ( t ) } { \mathrm { d } t } = \boldsymbol { f } ( \boldsymbol { z } ( t ) , t )
+$$
+
+We have:
+
+$$
+{ \frac { \mathrm { d } ^ { 2 } z ( t ) } { d t ^ { 2 } } } = { \frac { \mathrm { d } } { \mathrm { d } t } } f ( z ( t ) , t ) = { \frac { \partial f ( z ( t ) , t ) } { \partial t } } + { \frac { \partial f ( z ( t ) , t ) } { \partial z } } { \frac { \mathrm { d } z ( t ) } { \mathrm { d } t } }
+$$
+
+For the ease of notation, we re-write Eq. 10 as
+
+$$
+{ \frac { \mathrm { d } ^ { 2 } z ( t ) } { d t ^ { 2 } } } = f _ { t } + f _ { z } f
+$$
+
+where $f _ { t }$ and $f _ { z }$ represents the partial derivative of $f w . r . t \ t$ and $z$ respectively.
+
+# A.3 LOCAL TRUNCATION ERROR OF ALF
+
+Theorem A.1 (Theorem 3.1 in the main paper). For a single step in ALF with stepsize $h$ , the local truncation error of $z$ is $O ( h ^ { 3 } )$ , and the local truncation errof of $v$ is $O ( h ^ { 2 } )$ .
+
+Proof. Under the same notation as Algo. 1, denote the ground-truth state of $z$ and $v$ starting from $\left( \widehat { z _ { 0 } } , s _ { 0 } \right)$ as $\widetilde { z }$ and $\widetilde { v }$ respectively. Then the local truncation error is
+
+$$
+L _ { z } = \widetilde { z } ( s _ { 0 } + h ) - \widehat { z } _ { 2 } , L _ { v } = \widetilde { v } ( s _ { 0 } + h ) - \widehat { v _ { 2 } }
+$$
+
+We estimate $L _ { z }$ and $L _ { v }$ in terms of polynomial of $h$ .
+
+Under mild assumptions that $f$ is smooth up to 2nd order almost everywhere (this is typically satisfied with neural networks with bounded weights), hence Taylor expansion is meaningful for $f$ . By Eq. 11, the Taylor expansion of $\widetilde { z }$ around point $\left( \widehat { z _ { 0 } } , \widehat { v _ { 0 } } , s _ { 0 } \right)$ is
+
+$$
+\begin{array} { c } { { \displaystyle \widetilde { z } ( s _ { 0 } + h ) = \widehat { z } _ { 0 } + h \displaystyle \frac { \mathrm { d } z } { d t } + \displaystyle \frac { h ^ { 2 } } { 2 } \displaystyle \frac { \mathrm { d } ^ { 2 } z } { d t ^ { 2 } } + { \cal O } ( h ^ { 3 } ) } } \\ { { = \widehat { z } _ { 0 } + h f ( \widehat { z _ { 0 } } , s _ { 0 } ) + \displaystyle \frac { h ^ { 2 } } { 2 } \Big ( f _ { t } ( \widehat { z _ { 0 } } , s _ { 0 } ) + f _ { z } ( \widehat { z _ { 0 } } , s _ { 0 } ) f ( \widehat { z _ { 0 } } , s _ { 0 } ) \Big ) + { \cal O } ( h ^ { 3 } ) } } \end{array}
+$$
+
+Next, we analyze accuracy of the numerical approximation. For simplicity, we directly analyze Eq. 7 by performing Taylor Expansion on $f$ .
+
+$$
+f ( \widehat { z _ { 0 } } + \frac { h } { 2 } \widehat { v _ { 0 } } , s _ { 0 } + \frac { h } { 2 } ) = f ( \widehat { z _ { 0 } } , s _ { 0 } ) + \frac { h } { 2 } f _ { t } ( \widehat { z _ { 0 } } , s _ { 0 } ) + \frac { h \widehat { v _ { 0 } } } { 2 } f _ { z } ( \widehat { z _ { 0 } } , s _ { 0 } ) + O ( h ^ { 2 } )
+$$
+
+$$
+\widehat { z _ { 2 } } = \widehat { z _ { 0 } } + h f ( \widehat { z _ { 0 } } + \frac { h } { 2 } \widehat { v _ { 0 } } , s _ { 0 } + \frac { h } { 2 } )
+$$
+
+Plug Eq. 14, Eq. 15 and E.q. 16 into the definition of $L _ { z }$ , we get
+
+$$
+\begin{array} { r l } & { L _ { z } = \widetilde { z } ( s _ { 0 } + h ) - \widehat { z _ { 2 } } } \\ & { \quad = \Big [ \widehat { z _ { 0 } } + h f ( \widehat { z _ { 0 } } , s _ { 0 } ) + \displaystyle \frac { h ^ { 2 } } { 2 } \Big ( f _ { t } ( \widehat { z _ { 0 } } , s _ { 0 } ) + f _ { z } ( \widehat { z _ { 0 } } , s _ { 0 } ) f ( \widehat { z _ { 0 } } , s _ { 0 } ) \Big ) \Big ] } \\ & { \quad - \Big [ \widehat { z _ { 0 } } + h \Big ( f ( \widehat { z _ { 0 } } , s _ { 0 } ) + \displaystyle \frac { h } { 2 } f _ { t } ( \widehat { z _ { 0 } } , s _ { 0 } ) + \displaystyle \frac { h \widehat { v _ { 0 } } } { 2 } f _ { z } ( \widehat { z _ { 0 } } , s _ { 0 } ) \Big ) \Big ] + O ( h ^ { 3 } ) } \\ & { \quad = \displaystyle \frac { h ^ { 2 } } { 2 } f _ { z } ( \widehat { z _ { 0 } } , s _ { 0 } ) \Big ( f ( \widehat { z _ { 0 } } , s _ { 0 } ) - \widehat { v _ { 0 } } \Big ) + O ( h ^ { 3 } ) } \end{array}
+$$
+
+Therefore, if $\left| f ( \widehat { z _ { 0 } } , s _ { 0 } ) - \widehat { v _ { 0 } } \right|$ is of order $O ( 1 )$ , $L _ { z }$ is of order $O ( h ^ { 2 } )$ ; if $\left| f ( \widehat { z _ { 0 } } , s _ { 0 } ) - \widehat { v _ { 0 } } \right|$ is of order $O ( h )$ or smaller, then $L _ { z }$ is of order $O ( h ^ { 3 } )$ . Specifically, at the start time of integration, we have $\begin{array} { r } { \Big | f ( \widehat { z _ { 0 } } , s _ { 0 } ) - \widehat { v _ { 0 } } = 0 \Big | . } \end{array}$ , by induction, $L _ { z }$ at end time is $O ( h ^ { 3 } )$ .
+
+Next we analyze the local truncation error in $v$ , denoted as $L _ { v }$ . Denote the ground truth as $\widetilde { v } ( t _ { 0 } + h )$ , we have
+
+$$
+\begin{array} { r l } & { \widetilde { v } ( s _ { 0 } + h ) = f \bigl ( \widetilde { z } ( s _ { 0 } + h ) , s _ { 0 } + h \bigr ) } \\ & { \qquad = f ( \widehat { z _ { 0 } } , s _ { 0 } ) + h f _ { t } ( \widehat { z _ { 0 } } , s _ { 0 } ) + \bigl ( \widetilde { z } ( s _ { 0 } + h ) - \widehat { z _ { 0 } } \bigr ) f _ { z } ( \widehat { z _ { 0 } } , s _ { 0 } ) + O ( h ^ { 2 } ) } \end{array}
+$$
+
+Next we analyze the error in the numerical approximation. Plug Eq. 15 into Eq. 7,
+
+$$
+\begin{array} { l } { { \displaystyle \widehat { v _ { 2 } } = 2 f \big ( \widehat { z _ { 0 } } + \frac { h } { 2 } \widehat { v _ { 0 } } , s _ { 0 } + \frac { h } { 2 } \big ) - \widehat { v _ { 0 } } } } \\ { { \displaystyle \quad = f \big ( \widehat { z _ { 0 } } , s _ { 0 } \big ) + \big ( f \big ( \widehat { z _ { 0 } } , s _ { 0 } \big ) - \widehat { v _ { 0 } } \big ) + h f _ { t } \big ( \widehat { z _ { 0 } } , s _ { 0 } \big ) + h \widehat { v _ { 0 } } f _ { z } \big ( \widehat { z _ { 0 } } , s _ { 0 } \big ) + O \big ( h ^ { 2 } \big ) } } \end{array}
+$$
+
+From Eq. 14, Eq. 21 and Eq. 23, we have
+
+$$
+\begin{array} { r l } & { L _ { v } = \widetilde { v } ( s _ { 0 } + h ) - \widehat { v _ { 2 } } } \\ & { \qquad = \Big ( f ( \widehat { z _ { 0 } } , s _ { 0 } ) - \widehat { v _ { 0 } } \Big ) + \Big ( \widetilde { z } ( s _ { 0 } + h ) - \big ( \widehat { z _ { 0 } } + h \widehat { v _ { 0 } } \big ) \Big ) f _ { z } ( \widehat { z _ { 0 } } , s _ { 0 } ) + O ( h ^ { 2 } ) } \\ & { \qquad = \Big ( f ( \widehat { z _ { 0 } } , s _ { 0 } ) - \widehat { v _ { 0 } } \Big ) + h \Big ( f ( \widehat { z _ { 0 } } , s _ { 0 } ) - \widehat { v _ { 0 } } \Big ) f _ { z } ( \widehat { z _ { 0 } } , s _ { 0 } ) + O ( h ^ { 2 } ) } \end{array}
+$$
+
+The last equation is derived by plugging in Eq. 14. Note that Eq. 26 holds for every single step forward in time, and at the start time of integration, we have $\left| \hat { f } ( \widehat { z _ { 0 } } , s _ { 0 } ) - \widehat { v _ { 0 } } \right| = \mathbf { \bar { 0 } }$ due to our binitialization as in Sec. 3.1 of the main paper. Therefore, by induction, $L _ { v }$ bis of order $O ( h ^ { 2 } )$ for consecutive steps. □
+
+# A.4 STABILITY ANALYSIS
+
+Lemma A.shape, and matrix of the form , then we have det $\left[ \begin{array} { l l } { A } & { B } \\ { C } & { D } \end{array} \right]$ ${ \mathrm { : } } A , B , C , D$ square matrices of the same $C D = D C$ ${ \left[ \begin{array} { l l } { A } & { B } \\ { C } & { D } \end{array} \right] } = \operatorname* { d e t } ( A D - B C )$
+
+Proof. See (Silvester, 2000) for a detailed proof.
+
+Theorem A.2. For ALF integrator with stepsize $h$ , if $h \sigma _ { i }$ is $O$ or is imaginary with norm no larger than $^ { l }$ , where $\sigma _ { i }$ is the i-th eigenvalue of the Jacobian $\frac { \partial f } { \partial z }$ , then the solver is on the critical boundary of $A$ -stability; otherwise, the solver is not A-stable.
+
+Proof. A solver is A-stable is equivalent to the eigenvalue of the numerical forward has a norm below 1. We calculate the eigenvalue of $\psi$ below.
+
+For the function defined by Eq. 7, the Jacobian is
+
+$$
+J = \left[ \begin{array} { c c } { \frac { \partial \widehat { z } _ { 2 } } { \partial z _ { 0 } } } & { \frac { \partial \widehat { z } _ { 2 } } { \partial \widehat { v _ { 0 } } } } \\ { \frac { \partial \widehat { v _ { 2 } } } { \partial z _ { 0 } } } & { \frac { \partial \widehat { v _ { 2 } } } { \partial \widehat { v _ { 0 } } } } \end{array} \right] = \left[ \begin{array} { c c } { I + h \frac { \partial f } { \partial z } } & { \frac { h ^ { 2 } } { 2 } \frac { \partial f } { \partial z } } \\ { 2 \times \frac { \partial f } { \partial z } } & { h \frac { \partial f } { \partial z } - I } \end{array} \right]
+$$
+
+We determine the eigenvalue of $J$ by solving the equation
+
+$$
+\operatorname* { d e t } ( J - \lambda I ) = \left[ \begin{array} { c c } { h \frac { \partial f } { \partial z } + ( 1 - \lambda ) I } & { \frac { h ^ { 2 } } { 2 } \frac { \partial f } { \partial z } } \\ { 2 \times \frac { \partial f } { \partial z } } & { h \frac { \partial f } { \partial z } - ( 1 + \lambda ) I } \end{array} \right] = 0
+$$
+
+It’s trivial to check $J$ satisfies conditions for Lemma A.1.1.Therefore, we have
+
+$$
+\begin{array} { l } { \displaystyle \operatorname* { d e t } ( J - \lambda I ) = \operatorname* { d e t } \Bigl [ \Bigl ( h \frac { \partial f } { \partial z } + ( 1 - \lambda ) I \Bigr ) \Bigl ( h \frac { \partial f } { \partial z } - ( 1 + \lambda ) I \Bigr ) - \Bigl ( \frac { h ^ { 2 } } { 2 } \frac { \partial f } { \partial z } \Bigr ) \Bigl ( 2 \times \frac { \partial f } { \partial z } \Bigr ) \Bigr ] } \\ { = \operatorname* { d e t } \Bigl [ - 2 \lambda h \frac { \partial f } { \partial z } + ( \lambda ^ { 2 } - 1 ) I \Bigr ] } \end{array}
+$$
+
+Suppose the eigen-decompostion of $\frac { \partial f } { \partial z }$ can be written as
+
+$$
+\frac { \partial f } { \partial z } = \Lambda \left[ \begin{array} { c c c c c } { { \sigma _ { 1 } } } & { { } } & { { } } & { { } } & { { } } \\ { { } } & { { \sigma _ { 2 } } } & { { } } & { { } } & { { } } \\ { { } } & { { } } & { { \hdots } } & { { } } & { { } } \\ { { } } & { { } } & { { } } & { { } } & { { \sigma _ { N } } } \end{array} \right] \Lambda ^ { - 1 }
+$$
+
+Note that $I = \Lambda I \lambda ^ { - 1 }$ , hence we have
+
+$$
+\begin{array} { l } { { \displaystyle \operatorname * { d e t } ( J - \lambda I ) = \operatorname * { d e t } \ \Lambda \Bigg \{ - 2 \lambda h \left[ \begin{array} { l l l l } { { } } & { { } } & { { } } & { { } } \\ { { } } & { { \sigma _ { 2 } } } & { { } } & { { } } \\ { { } } & { { } } & { { \cdots } } & { { } } \\ { { } } & { { } } & { { } } & { { \sigma _ { N } } } \end{array} \right] + ( \lambda ^ { 2 } - 1 ) I \Bigg \} \Lambda ^ { - 1 } } } \\ { { \displaystyle \quad = \prod _ { i = 1 } ^ { N } ( \lambda ^ { 2 } - 2 h \sigma _ { i } \lambda - 1 ) } } \end{array}
+$$
+
+Hence the eigenvalues are
+
+$$
+\lambda _ { i \pm } = h \sigma _ { i } \pm \sqrt { h ^ { 2 } \sigma _ { i } ^ { 2 } + 1 }
+$$
+
+A-stability requires $| \lambda _ { i \pm } | < 1 , \forall i$ , and has no solution.
+
+The critical boundary is $| \lambda _ { i \pm } | = 1$ , the solution is: $h \sigma _ { i }$ is 0 or on the imaginary line with norm no larger than 1.
+
+# A.5 DAMPED ALF
+
+# Algorithm 2: Forward of $\psi$ in Damped ALF $( \eta \in ( 0 , 1 ]$ )
+
+Input $( \widehat { z _ { i n } } , \widehat { v _ { i n } } , s _ { i n } , h ) = ( \widehat { z _ { 0 } } , \widehat { v _ { 0 } } , s _ { 0 } , h )$ where $s _ { 0 }$ is current time, $\widehat { z } _ { 0 }$ and $\widehat { v _ { 0 } }$ are correponding c cvalues at time $s _ { 0 }$ ; stepsize $h$ .
+
+Forward
+
+$$
+\begin{array} { r l } & { s _ { 1 } = s _ { 0 } + h / 2 } \\ & { \widehat { z _ { 1 } } = \widehat { z _ { 0 } } + \widehat { v _ { 0 } } \times h / 2 } \\ & { \widehat { v _ { 1 } } = f ( \widehat { z _ { 1 } } , s _ { 1 } ) } \\ & { \widehat { v _ { 2 } } = \widehat { v _ { 0 } } + 2 \eta ( \widehat { v _ { 1 } } - \widehat { v _ { 0 } } ) } \\ & { \widehat { z _ { 2 } } = \widehat { z _ { 1 } } + \widehat { v _ { 2 } } \times h / 2 } \\ & { s _ { 2 } = s _ { 1 } + h / 2 } \end{array}
+$$
+
+# Output
+
+$$
+( \widehat { z _ { o u t } } , \widehat { v _ { o u t } } , s _ { o u t } , h ) = ( \widehat { z _ { 2 } } , \widehat { v _ { 2 } } , s _ { 2 } , h )
+$$
+
+# Algorithm 3: $\psi ^ { - 1 }$ (Inverse of $\psi$ ) in Damped ALF $( \eta \in ( 0 , 1 ]$ )
+
+Input $\widehat { ( z _ { o u t } , v _ { o u t } , s _ { o u t } , h ) }$ where $s _ { o u t }$ is current time, $\widehat { z _ { o u t } }$ and $\widehat { v _ { o u t } }$ are corresponding values at $s _ { o u t }$ , $h$ d dis stepsize.
+
+Inverse
+
+$$
+\begin{array} { r l r } {  { \big ( \widehat { z _ { 2 } } , \widehat { v _ { 2 } } , s _ { 2 } , h \big ) = \big ( \widehat { z _ { o u t } } , \widehat { v _ { o u t } } , s _ { o u t } , h \big ) } } \\ & { } & \\ & { s _ { 1 } = s _ { 2 } - h / 2 } \\ & { } & \\ & { } & { \widehat { z _ { 1 } } = z _ { 2 } - \widehat { v _ { 2 } } \times h / 2 } \\ & { } & \\ & { } & { \widehat { v _ { 1 } } = f \big ( \widehat { z _ { 1 } } , s _ { 1 } \big ) } \\ & { } & { \widehat { v _ { 0 } } = \big ( \widehat { v _ { 2 } } - 2 \eta \widehat { v _ { 1 } } \big ) \big / \big ( 1 - 2 \eta \big ) } \\ & { } & \\ & { } & { \widehat { z _ { 0 } } = \widehat { z _ { 1 } } - \widehat { v _ { 0 } } \times h / 2 } \\ & { } & \\ & { } & { s _ { 0 } = s _ { 1 } - h / 2 } \\ & { } & \\ & { } & { \big ( \widehat { z _ { i n } } , \widehat { v _ { i n } } , s _ { i n } , h \big ) = \big ( \widehat { z _ { 0 } } , \widehat { v _ { 0 } } , s _ { 0 } , h \big ) } \end{array}
+$$
+
+# Output
+
+The main difference between ALF and Damped ALF is marked in blue in Algo. 2. In ALF, the update of $\widehat { v _ { 2 } }$ is $\widehat { v _ { 2 } } = \widehat { ( v _ { 1 } - v _ { 0 } ) } + \widehat { v _ { 1 } } = 2 \widehat { ( v _ { 1 } - v _ { 0 } ) } + \widehat { v _ { 0 } }$ ; while in Damped ALF, the update is scaled by a factor $\eta$ b b b b bbetween 0 and 1, so the update is $\widehat { v _ { 2 } } = 2 \eta ( \widehat { v _ { 1 } } - \widehat { v _ { 0 } } ) + \widehat { v _ { 0 } }$ . When $\eta = 1$ , Damped ALF reduces to ALF.
+
+Similar to Sec. A.1, we can write the forward as For simplicity, we can re-write the forward of ALF as
+
+$$
+{ \left[ \begin{array} { l } { { \widehat { z _ { 2 } } } } \\ { 0 } \end{array} \right] } = { \left[ \begin{array} { l } { { \widehat { z _ { 0 } } } + \eta h f ( { \widehat { z _ { 0 } } } + { \frac { h } { 2 } } { \widehat { v _ { 0 } } } , s _ { 0 } + { \frac { h } { 2 } } ) + ( 1 - \eta ) h { \widehat { v _ { 0 } } } } \\ { 2 \eta f ( { \widehat { z _ { 0 } } } + { \frac { h } { 2 } } { \widehat { v _ { 0 } } } , s _ { 0 } + { \frac { h } { 2 } } ) + ( 1 - 2 \eta ) { \widehat { v _ { 0 } } } } \end{array} \right] }
+$$
+
+Similarly, the inverse of ALF can be written as
+
+$$
+\begin{array} { r } { \left[ \widehat { z _ { 0 } } \right] = \left[ { \begin{array} { c } { \widehat { z _ { 2 } } - h \frac { 1 - \eta } { 1 - 2 \eta } \widehat { v _ { 2 } } + h \frac { \eta } { 1 - 2 \eta } f \big ( \widehat { z _ { 2 } } - \frac { h } { 2 } \widehat { v _ { 2 } } , s _ { 2 } - \frac { h } { 2 } \big ) } \\ { \frac { 1 } { 1 - 2 \eta } \widehat { v _ { 2 } } - \frac { 2 \eta } { 1 - 2 \eta } f \big ( \widehat { z _ { 2 } } - \frac { h } { 2 } \widehat { v _ { 2 } } , s _ { 2 } - \frac { h } { 2 } \big ) } \end{array} } \right] } \end{array}
+$$
+
+Theorem A.3. For a single step in Damped $A L F$ with stepsize $h$ , the local truncation error of $z$ is $O ( h ^ { 2 } )$ , and the local truncation errof of $v$ is $O ( h )$ .
+
+Proof. The proof is similar to Thm. A.3. By similar calculations using the Taylor Expansion in Eq. 15 and Eq. 14, we have
+
+$$
+\begin{array} { r l } & { \widehat { z _ { 2 } } - \widetilde { z } ( s _ { 0 } + h ) = ( 1 - \eta ) h \widehat { v _ { 0 } } + h \eta \Big [ f ( \widehat { z _ { 0 } } , s _ { 0 } ) + \displaystyle \frac { h } { 2 } f _ { t } ( \widehat { z _ { 0 } } , s _ { 0 } ) + \displaystyle \frac { h \widehat { v _ { 0 } } } { 2 } f _ { z } ( \widehat { z _ { 0 } } , s _ { 0 } ) \Big ] } \\ & { \qquad - h \Big [ f ( \widehat { z _ { 0 } } , s _ { 0 } ) + \displaystyle \frac { h } { 2 } f _ { t } \widehat { z _ { 0 } } , s _ { 0 } + \displaystyle \frac { h } { 2 } f _ { z } ( \widehat { z _ { 0 } } , s _ { 0 } ) f ( \widehat { z _ { 0 } } , s _ { 0 } ) \Big ] + O ( h ^ { 2 } ) } \\ & { \qquad = ( 1 - \eta ) h \Big ( \widehat { v _ { 0 } } - f ( \widehat { z _ { 0 } } , s _ { 0 } ) \Big ) + \displaystyle \frac { \eta - 1 } { 2 } h ^ { 2 } f _ { t } ( \widehat { z _ { 0 } } , s _ { 0 } ) } \\ & { \qquad + \displaystyle \frac { h ^ { 2 } } { 2 } \Big ( \eta \widehat { v _ { 0 } } - f ( \widehat { z _ { 0 } } , s _ { 0 } ) \Big ) f _ { z } ( \widehat { z _ { 0 } } , s _ { 0 } ) + O ( h ^ { 2 } ) } \end{array}
+$$
+
+Using Eq. 21, Eq. 15 and Eq. 14, we have
+
+$$
+\begin{array} { r l } & { \widetilde { v _ { 2 } } - \widehat { v _ { 2 } } = ( 1 - 2 \eta ) \widehat { v _ { 0 } } + ( 2 \eta - 1 ) f ( \widehat { z _ { 0 } } , s _ { 0 } ) + ( 1 - \eta ) h f _ { t } ( \widehat { z _ { 0 } } , s _ { 0 } ) } \\ & { \qquad + \left( \widetilde { z } ( s _ { 0 } + h ) - \widehat { z _ { 0 } } - \eta h \widehat { v _ { 0 } } \right) f _ { z } ( \widehat { z _ { 0 } } , s _ { 0 } ) + O ( h ^ { 2 } ) } \\ & { \qquad = ( 2 \eta - 1 ) \big [ f ( \widehat { z _ { 0 } } , s _ { 0 } ) - \widehat { z _ { 0 } } \big ] + ( 1 - \eta ) h f _ { t } ( \widehat { z _ { 0 } } , s _ { 0 } ) } \\ & { \qquad + \eta \Big [ h f ( \widehat { z _ { 0 } } , s _ { 0 } ) - h \widehat { v _ { 0 } } \Big ] f _ { z } ( \widehat { z _ { 0 } } , s _ { 0 } ) + O ( h ^ { 2 } ) } \end{array}
+$$
+
+Note that when $\eta = 1$ , Eq. 51 reduces to Eq. 19, and Eq. 53 reduces to Eq. 26. By initialization, we have $| f ( \widehat { z _ { 0 } } , s _ { 0 } ) - \widehat { v _ { 0 } } | = 0$ at initial time, hence by induction, the local truncation error for $z$ is $O ( h ^ { 2 } )$ b b; the local truncation error for $v$ is $O ( h )$ when $\eta < 1$ , and is $O ( h ^ { 2 } )$ when $\eta = 1$ . □
+
+Theorem A.4 (Theorem 3.2 in the main paper). For Dampled $A L F$ integrator with stepsize $h$ , where $\sigma _ { i }$ is the $i$ -th eigenvalue of the Jacobian $\frac { \partial f } { \partial z }$ , then the solver is $A$ -stable $i f | 1 + \eta ( h \sigma -$ $1 ) \pm \sqrt { \eta \big [ 2 h \sigma _ { i } + \eta ( h \sigma _ { i } - 1 ) ^ { 2 } \big ] } \Big \vert < 1 , \forall i .$
+
+Proof. The Jacobian of the forward-pass of a single step damped ALF is
+
+$$
+J = \left[ \begin{array} { c c } { I + \eta h \frac { \partial f } { \partial z } } & { ( 1 - \eta ) h I + \eta \frac { h ^ { 2 } } { 2 } \frac { \partial f } { \partial z } } \\ { 2 \eta \frac { \partial f } { \partial z } } & { \eta h \frac { \partial f } { \partial z } + ( 1 - 2 \eta ) I } \end{array} \right]
+$$
+
+when $\eta = 1$ , $J$ reduces to Eq. 27. We can determine the eigenvalue of $J$ using similar techniques. Assume the eigenvalues for $\frac { \partial f } { \partial z }$ are $\{ \sigma _ { i } \}$ , then we have
+
+$$
+\begin{array} { l } { \displaystyle \operatorname* { d e t } ( J - \lambda I ) = \operatorname* { d e t } \left[ \begin{array} { l l } { ( 1 - \lambda ) I + \eta h \frac { \partial f } { \partial z } } & { ( 1 - \eta ) h I + \eta \frac { h ^ { 2 } } { 2 } \frac { \partial f } { \partial z } } \\ { \displaystyle \qquad } & { \eta h \frac { \partial f } { \partial z } + ( 1 - 2 \eta - \lambda ) I } \end{array} \right] } \\ { \displaystyle = \operatorname* { d e t } \left[ \Big ( ( 1 - \lambda ) I + \eta h \frac { \partial f } { \partial z } \Big ) \Big ( \eta h \frac { \partial f } { \partial z } + ( 1 - 2 \eta - \lambda ) I \Big ) \right. } \\ { \displaystyle - \left( ( 1 - \eta ) h I + \eta h \frac { \partial ^ { 2 } } { 2 } \frac { \partial f } { \partial z } \Big ) \Big ( 2 \eta \frac { \partial f } { \partial z } \Big ) \right] } \\ { \displaystyle = \prod _ { i = 1 } ^ { N } \left[ 1 + \eta ( h \sigma _ { i } - 1 ) \pm \sqrt { \eta \big [ 2 h \sigma _ { i } + \eta ( h \sigma _ { i } - 1 ) ^ { 2 } \big ] } \right] } \end{array}
+$$
+
+when $\eta < 1$ , it’s easy to check that $\left| 1 + \eta ( h \sigma _ { i } - 1 ) \pm \sqrt { \eta \big [ 2 h \sigma _ { i } + \eta ( h \sigma _ { i } - 1 ) ^ { 2 } \big ] } \right| < 1$ has non-empty solutions for $h \sigma$ .
+
+For a quick validation, we plot the region of A-stability on the imaginary plane for a single eigenvalue in Fig. 1. As $\eta$ increases, the area of stability decreases. When $\eta = 1$ , the system is no-where A-stable, and the boundary for A-stability is on the imaginary axis $[ - i , i ]$ where $i$ is the imaginary unit.
+
+![](images/101ac7d51d52296b4d11b9f4136ff79e830a99b276655dff89546fd5738863bb.jpg)  
+Figure 1: Region of A-stability for eigenvalue on the imaginary plane for damped ALF. From left to right, the region of stability for $\eta = 0 . 2 5$ , $\eta = 0 . 7 , \eta = 0 . 8$ respectively. As $\eta$ increases to 1, the area of stability region decreases.
+
+# B EXPERIMENTAL DETAILS
+
+# B.1 IMAGE RECOGNITION
+
+# B.1.1 EXPERIMENT ON CIFAR10
+
+We directly modify a ResNet18 into a Neural ODE, where the forward of a residual block $( y =$ $x + f ( x ) )$ and the forward of an ODE block $\begin{array} { r } { ( y = x + \int _ { 0 } ^ { T } f ( z , t ) d t } \end{array}$ where $T = 1$ ) share the same parameterization $f$ , hence they have the same number of parameters. Our experiment is based on the official implementation by Zhuang et al. (2020) and an open-source repository (Liu, 2017).
+
+All models are trained with SGD optimizer for 90 epochs, with an initial learning rate of 0.01, and decayed by a factor of 10 at 30th epoch and 60th epoch respectively. Training scheme is the same for all models (ResNet, Neural ODE trained with adjoint, naive, ACA and MALI). For ACA, we follow the settings in (Zhuang et al., 2020) and use the official implementation torch ACA 1, and use a Heun-Euler solver with $r t o \bar { l } = 1 0 ^ { - 1 }$ , $a t o l = 1 0 ^ { - 2 }$ during training. For MALI, we use an adaptive version and set $r t o l = 1 0 ^ { - 1 }$ , $a t o l = 1 0 ^ { - 2 }$ . For the naive and adjoint method, we use the default Dopri5 solver from the torchdiffeq2 package with $\mathrm { r t o l } = \mathrm { a t o l } = \mathrm { \bar { 1 0 } } ^ { - 5 }$ . We train all models for 5 independent runs, and report the mean and standard deviation across runs.
+
+# B.1.2 EXPERIMENTS ON IMAGENET
+
+Training scheme We conduct experiments on ImageNet with ResNet18 and Neural-ODE18. All models are trained on 4 GTX-1080Ti GPUs with a batchsize of 256. All models are trained for 80 epochs, with an initial learning rate of 0.1, and decayed by a factor of 10 at $3 0 \mathrm { t h }$ and 60th epoch. Note that due to the large size input $2 5 6 \times 2 5 6$ , the naive method and ACA requires a huge memory, and is infeasible to train. MALI and the adjoint method requires a constant memory hence is suitable for large-scale experiments. For both MALI and the adjoint menthod, we use a fixed stepsize of 0.25, and integrates from 0 to $T = 1$ . As shown in Table. 2 in the main paper, a stepsize of 0.25 is sufficiently small to train a meaningful continuous model that is robust to discretization scheme.
+
+Invariance to discretization scheme To test the influence of discretization scheme, we test our Neural ODE with different solvers without re-training. For fixed-stepsize solvers, we tested various step sizes including $\{ 0 . 1 , 0 . 1 5 , 0 . 2 5 , 0 . 5 , 1 . 0 \}$ ; for adaptive solvers, we set rto $\scriptstyle \mathbf { - 0 . 1 }$ , atol $= 0 . 0 1$ for MALI and Heun-Euler method, and set rto $1 \stackrel { { \textstyle \sum } } { = } 1 0 ^ { - 2 }$ , $\mathrm { a t o l } = 1 0 ^ { - 3 }$ for RK23 solver, and set rtol $=$ $1 0 ^ { - 4 }$ , $\mathrm { a t o l } = 1 0 ^ { - 5 }$ for Dopri5 solver. As shown in Table. 2, Neural ODE trained with MALI is robust to discretization scheme, and MALI significantly outperforms the adjoint method in terms of accuracy ( $70 \%$ v.s. $63 \%$ top-1 accuracy on the validation dataset). An interesting finding is that when trained with MALI which is a second-order solver, and tested with higher-order solver (e.g.
+
+![](images/a2eb3a813f5f7dc301a07eb82c50a2ff52e673b7a547da9299eb769bdf3b5a0e.jpg)  
+Figure 2: Results on ImageNet.
+
+RK4), our Neural ODE achieves $7 0 . 2 1 \%$ top-1 accuracy, which is higher than both the same solver during training (MALI, $6 9 . 5 9 \%$ accuracy) and the ResNet18 ( $7 0 . 0 9 \%$ accuracy).
+
+Furthermore, many papers claim ResNet to be an approximation for an ODE (Lu et al., 2018). However, Queiruga et al. (2020) argues that many numerical discretizations fail to be meaningful dynamical systems, while our experiments demonstrate that our model is continuous hence invariant to discretization schemes.
+
+Adversarial robustness Besides the high accuracy and robustness to discretization scheme, another advantage of Neural ODE is the robustness to adversarial attack. The adversary robustness of Neural ODE is extensively studied in (Hanshu et al., 2019), but not only validated on small-scale datasets such as Cifar10. To our knowledge, our method is the first to enable effectuve training of Neural ODE on large-scale datasets such as ImageNet and achieve a high accuracy, and we are the first to validate the robustness of Neural ODE on ImageNet. We use the advertorch 3 toolbox to perform adversarial attack. We test the performance of ResNet and Neural ODE under FGSM attack. To be more convincing, we conduct experiment on the pretrained ResNet18 provided by the official PyTorch website 4. Since Neural ODE is invariant to discretization scheme, it’s possible to derive the gradient for attack using one ODE solver, and inference on the perturbed image using another solver. As summarized in Table. 3, Neural ODE consistently achieves a higher accuracy than ResNet under the same attack.
+
+# B.2 TIME SERIES MODELING
+
+We conduct experiments on Latent-ODE models (Rubanova et al., 2019) and Neural CDE (controlled differential equation) (Kidger et al., 2020a). For all experiments, we use the official implementation, and only replace the solver with MALI. The latent-ODE model is trained on the Mujoco dataset processed with code provided by the official implementation, and we experiment with different ratios $( 1 0 \% , 2 0 \% , 5 0 \% )$ of training data as described in (Rubanova et al., 2019). All models are trained for 300 epochs with Adamax optimizer, with an initial learning rate of 0.01 and scaled by 0.999 for each epoch. For the Neural CDE model, for the naive method, ACA and MALI, we perform 5 independent runs and report the mean value and standard deviation; results for the adjoint and seminorm adjoint are from (Kidger et al., 2020a). For Neural CDE, we use MALI with ALF solver with a fixed stepsize of 0.25, and train the model for 100 epochs with an initial learning rate of 0.004.
+
+![](images/b6df4d8f55cc3c56539cccaad8c15e32a0388b4569c6981a30dc533bc97487b4.jpg)  
+Figure 3: Results on MNIST dataset.
+
+# B.3 CONTINUOUS GENERATIVE MODELS
+
+# B.3.1 TRAINING DETAILS
+
+Our experiment is based on the official implementation of (Finlay et al., 2020), with the only difference in ODE solver. For a fair comparison, we only use MALI for training, and use Dopri5 solver from torchdiffeq package (Chen et al., 2018) with ${ \dot { \mathrm { r t o l } } } = { \mathrm { a t o l } } = 1 0 ^ { - 5 }$ . For MALI, we use adaptive ALF solver with $r t o l \stackrel { - } { = } 1 0 ^ { - 2 } , a t o l = 1 0 ^ { - 3 }$ , and use an initial stepsize of 0.25. Integration time is from 0 to 1.
+
+On MNIST and CIFAR dataset, we set the regularization coefficients for kinetic energy and Frobenius norm of the derivative function as 0.05. We train the model for 50 epochs with an initial learning rate of 0.001.
+
+# B.3.2 ADDTIONAL RESULTS
+
+We show generated examples on MNIST dataset in Fig. 3, results for Cifar10 dataset in Fig. 4, and results for ImageNet64 in Fig. 5.
+
+# B.4 ERROR IN GRADIENT ESTIMATION FOR TOY EXAMPLES WHEN $t < 1$
+
+We plot the error in gradient estimation for the toy example defined by Eq.6 in the main paper in Fig. 6. Note that the integration time $T$ is set as smaller than 1, while the main paper is larger than 20. We observe the same results, MALI and ACA generate smaller error than the adjoint and the naive method.
+
+# B.5 RESULTS OF DAMPED MALI
+
+For all experiments in the main paper, we set $\eta = 1$ and did not use damping. For completeness, we experimented with damped MALI using different values of $\eta$ . As shown in Table. 7, MALI is robust to different $\eta$ values.
+
+![](images/48da9b9babd714737d38d09b19d94eb40fd95e8c5c77a259a8a7074aeb5682a4.jpg)  
+Figure 4: Results on Cifar10 dataset.
+
+![](images/c19eeda53c981b7203c76904f278cb0dc6c8a5cb88712851c7e859297256e97b.jpg)  
+Figure 5: Results on ImageNet64 dataset.
+
+Table 7: Results of damped MALI with different $\eta$ values. We report the test accuracy of Neural CDE on Speech Command dataset, and the test MSE of latent-ODE on Mujoco data.   
+
+<table><tr><td colspan="2">m</td><td>1.0</td><td>0.95</td><td>0.9</td><td>0.85</td></tr><tr><td colspan="2">Test Accuracy on Speech Commands (Higher is better)</td><td>93.7 ± 0.3</td><td>93.7 ± 0.1</td><td>93.5± 0.2</td><td>93.7 ± 0.3</td></tr><tr><td rowspan="2">Test MSEof latent ODE on Mujoco (Lower is better)</td><td>10% training data</td><td>0.35</td><td>0.36</td><td>0.33</td><td>0.33</td></tr><tr><td>20% training data</td><td>0.27</td><td>0.25</td><td>0.26</td><td>0.27</td></tr></table>
+
+(a) Error in the estimation of gradient $w . r . t$ initial condition.
+
+![](images/54d1f8b4535f2e6c9ab6d5e48efe2c1fbf9d27fbbba330f9ffb47beffb0447af.jpg)  
+(b) Error in the estimation of gradient $w . r . t$ parameter $\alpha$   
+Figure 6: Comparison of error in gradient estimation for the toy example by Eq.6 of the main paper, when $t < 1$ .